CB-1857 Add redbeams db commands

dataplane/cmd/redbeams.go

@@ -121,6 +121,72 @@ func init() {
 					},
 				},
 			},
+			{
+				Name:  "db",
+				Usage: "manage redbeams databases",
+				Subcommands: []cli.Command{
+					{
+						Name:   "list",
+						Usage:  "list all databases",
+						Before: cf.CheckConfigAndCommandFlagsWithoutWorkspace,
+						Flags:  fl.NewFlagBuilder().AddFlags(fl.FlEnvironmentCrn).AddAuthenticationFlags().AddOutputFlag().Build(),
+						Action: redbeams.ListDatabases,
+						BashComplete: func(c *cli.Context) {
+							for _, f := range fl.NewFlagBuilder().AddFlags(fl.FlEnvironmentCrn).AddAuthenticationFlags().AddOutputFlag().Build() {
+								fl.PrintFlagCompletion(f)
+							}
+						},
+					},
+					{
+						Name:   "describe",
+						Usage:  "describe a database",
+						Before: cf.CheckConfigAndCommandFlagsWithoutWorkspace,
+						Flags:  fl.NewFlagBuilder().AddFlags(fl.FlEnvironmentCrn, fl.FlName).AddAuthenticationFlags().AddOutputFlag().Build(),
+						Action: redbeams.GetDatabase,
+						BashComplete: func(c *cli.Context) {
+							for _, f := range fl.NewFlagBuilder().AddFlags(fl.FlEnvironmentCrn, fl.FlName).AddAuthenticationFlags().AddOutputFlag().Build() {
+								fl.PrintFlagCompletion(f)
+							}
+						},
+					},
+					{
+						Name:   "create",
+						Usage:  "create a database",
+						Before: cf.CheckConfigAndCommandFlagsWithoutWorkspace,
+						Flags:  fl.NewFlagBuilder().AddFlags(fl.FlDatabaseCreationFile).AddAuthenticationFlags().AddOutputFlag().Build(),
+						Action: redbeams.CreateDatabase,
+						BashComplete: func(c *cli.Context) {
+							for _, f := range fl.NewFlagBuilder().AddFlags(fl.FlDatabaseCreationFile).AddAuthenticationFlags().AddOutputFlag().Build() {
+								fl.PrintFlagCompletion(f)
+							}
+						},
+					},
+					{
+						Name:   "register",
+						Usage:  "register a database",
+						Before: cf.CheckConfigAndCommandFlagsWithoutWorkspace,
+						Flags:  fl.NewFlagBuilder().AddFlags(fl.FlDatabaseRegistrationFile).AddAuthenticationFlags().AddOutputFlag().Build(),
+						Action: redbeams.RegisterDatabase,
+						BashComplete: func(c *cli.Context) {
+							for _, f := range fl.NewFlagBuilder().AddFlags(fl.FlDatabaseRegistrationFile).AddAuthenticationFlags().AddOutputFlag().Build() {
+								fl.PrintFlagCompletion(f)
+							}
+						},
+					},
+					{
+						Name:   "delete",
+						Usage:  "delete a database",
+						Before: cf.CheckConfigAndCommandFlagsWithoutWorkspace,
+						Flags:  fl.NewFlagBuilder().AddFlags(fl.FlEnvironmentCrn, fl.FlName).AddAuthenticationFlags().Build(),
+						Action: redbeams.DeleteDatabase,
+						BashComplete: func(c *cli.Context) {
+							for _, f := range fl.NewFlagBuilder().AddFlags(fl.FlEnvironmentCrn, fl.FlName).AddAuthenticationFlags().Build() {
+								fl.PrintFlagCompletion(f)
+							}
+						},
+					},
+				},
+			},
 		},
 	})
 }

dataplane/flags/flags.go

@@ -1315,6 +1315,20 @@ var (
 			Usage: "location of the JSON file for database server registration",
 		},
 	}
+	FlDatabaseCreationFile = StringFlag{
+		RequiredFlag: REQUIRED,
+		StringFlag: cli.StringFlag{
+			Name:  "database-creation-file",
+			Usage: "location of the JSON file for database creation",
+		},
+	}
+	FlDatabaseRegistrationFile = StringFlag{
+		RequiredFlag: REQUIRED,
+		StringFlag: cli.StringFlag{
+			Name:  "database-registration-file",
+			Usage: "location of the JSON file for database registration",
+		},
+	}
 )
 
 type RequiredFlag struct {

dataplane/redbeams/redbeams.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/hortonworks/cb-cli/dataplane/api-redbeams/client/database_servers"
+	"github.com/hortonworks/cb-cli/dataplane/api-redbeams/client/databases"
 	"github.com/hortonworks/cb-cli/dataplane/api-redbeams/model"
 	fl "github.com/hortonworks/cb-cli/dataplane/flags"
 	"github.com/hortonworks/cb-cli/dataplane/oauth"
@@ -253,3 +254,141 @@ func DeleteDatabaseServer(c *cli.Context) {
 	}
 	log.Infof("[DeleteDBServer] Deleted database server with CRN: %s Details: %s", crn, result)
 }
+
+var dbListHeader = []string{"Name", "Description", "Crn", "EnvironmentCrn", "DatabaseVendor", "ConnectionURL"}
+
+type dbDetails struct {
+	Name           string `json:"Name" yaml:"Name"`
+	Description    string `json:"Description" yaml:"Description"`
+	CRN            string `json:"CRN" yaml:"CRN"`
+	EnvironmentCrn string `json:"EnvironmentCrn" yaml:"EnvironmentCrn"`
+	DatabaseEngine string `json:"DatabaseEngine" yaml:"DatabaseEngine"`
+	ConnectionURL  string `json:"ConnectionURL" yaml:"ConnectionURL"`
+	CreationDate   int64  `json:"CreationDate" yaml:"CreationDate"`
+}
+
+func (db *dbDetails) DataAsStringArray() []string {
+	return []string{db.Name, db.Description, db.CRN, db.EnvironmentCrn, db.DatabaseEngine, db.ConnectionURL, string(db.CreationDate)}
+}
+
+func NewDetailsFromDbResponse(r *model.DatabaseV4Response) *dbDetails {
+	details := &dbDetails{
+		Name:           *r.Name,
+		CRN:            r.Crn,
+		EnvironmentCrn: r.EnvironmentCrn,
+		ConnectionURL:  *r.ConnectionURL,
+		CreationDate:   r.CreationDate,
+	}
+
+	if r.Description != nil {
+		details.Description = *r.Description
+	}
+	if r.DatabaseEngine != nil {
+		details.DatabaseEngine = *r.DatabaseEngine
+	}
+
+	return details
+}
+
+func ListDatabases(c *cli.Context) {
+	defer commonutils.TimeTrack(time.Now(), "List databases in environment")
+	envCrn := c.String(fl.FlEnvironmentCrn.Name)
+	redbeamsDbClient := ClientRedbeams(*oauth.NewRedbeamsClientFromContext(c)).Redbeams.Databases
+
+	log.Infof("[ListDBs] Listing databases in environment: %s", envCrn)
+	resp, err := redbeamsDbClient.ListDatabases(databases.NewListDatabasesParams().WithEnvironmentCrn(envCrn), nil)
+	if err != nil {
+		commonutils.LogErrorAndExit(err)
+	}
+
+	output := commonutils.Output{Format: c.String(fl.FlOutputOptional.Name)}
+
+	var tableRows []commonutils.Row
+
+	for _, response := range resp.Payload.Responses {
+		row := NewDetailsFromDbResponse(response)
+		tableRows = append(tableRows, row)
+	}
+	output.WriteList(dbListHeader, tableRows)
+}
+
+func GetDatabase(c *cli.Context) {
+	defer commonutils.TimeTrack(time.Now(), "Get a database")
+	envCrn := c.String(fl.FlEnvironmentCrn.Name)
+	name := c.String(fl.FlName.Name)
+	redbeamsDbClient := ClientRedbeams(*oauth.NewRedbeamsClientFromContext(c)).Redbeams.Databases
+
+	log.Infof("[GetDB] Getting database with name: %s", name)
+	resp, err := redbeamsDbClient.GetDatabase(databases.NewGetDatabaseParams().WithEnvironmentCrn(envCrn).WithName(name), nil)
+	if err != nil {
+		commonutils.LogErrorAndExit(err)
+	}
+	db := resp.Payload
+
+	output := commonutils.Output{Format: c.String(fl.FlOutputOptional.Name)}
+	row := NewDetailsFromDbResponse(db)
+	output.Write(serverListHeader, row)
+}
+
+func CreateDatabase(c *cli.Context) {
+	defer commonutils.TimeTrack(time.Now(), "Create a database")
+	fileLocation := c.String(fl.FlDatabaseCreationFile.Name)
+
+	log.Infof("[CreateDB] Creating database from file: %s", fileLocation)
+	content := commonutils.ReadFile(fileLocation)
+	var req model.CreateDatabaseV4Request
+	err := json.Unmarshal(content, &req)
+	if err != nil {
+		msg := fmt.Sprintf(`Invalid JSON: %s`, err.Error())
+		commonutils.LogErrorMessageAndExit(msg)
+	}
+
+	log.Infof("[CreateDB] JSON read, creating database with name: %s", *req.DatabaseName)
+	redbeamsDbServerClient := ClientRedbeams(*oauth.NewRedbeamsClientFromContext(c)).Redbeams.DatabaseServers
+	result, err := redbeamsDbServerClient.CreateDatabaseOnServer(database_servers.NewCreateDatabaseOnServerParams().WithBody(&req))
+	if err != nil {
+		commonutils.LogErrorAndExit(err)
+	}
+
+	log.Infof("[DeleteDBServer] Created database with name: %s Details: %s", *req.DatabaseName, result)
+}
+
+func RegisterDatabase(c *cli.Context) {
+	defer commonutils.TimeTrack(time.Now(), "Register database")
+	fileLocation := c.String(fl.FlDatabaseRegistrationFile.Name)
+
+	log.Infof("[RegisterDB] Registering database server from file: %s", fileLocation)
+	content := commonutils.ReadFile(fileLocation)
+	var req model.DatabaseV4Request
+	err := json.Unmarshal(content, &req)
+	if err != nil {
+		msg := fmt.Sprintf(`Invalid JSON: %s`, err.Error())
+		commonutils.LogErrorMessageAndExit(msg)
+	}
+
+	log.Infof("[RegisterDB] JSON read, registering database with name: %s", *req.Name)
+	redbeamsDbClient := ClientRedbeams(*oauth.NewRedbeamsClientFromContext(c)).Redbeams.Databases
+	resp, err := redbeamsDbClient.RegisterDatabase(databases.NewRegisterDatabaseParams().WithBody(&req), nil)
+	if err != nil {
+		commonutils.LogErrorAndExit(err)
+	}
+	db := resp.Payload
+
+	output := commonutils.Output{Format: c.String(fl.FlOutputOptional.Name)}
+	row := NewDetailsFromDbResponse(db)
+	output.Write(statusListHeader, row)
+}
+
+func DeleteDatabase(c *cli.Context) {
+	defer commonutils.TimeTrack(time.Now(), "Delete a registered database")
+	envCrn := c.String(fl.FlEnvironmentCrn.Name)
+	name := c.String(fl.FlName.Name)
+	redbeamsDbClient := ClientRedbeams(*oauth.NewRedbeamsClientFromContext(c)).Redbeams.Databases
+
+	log.Infof("[DeleteDB] Deleting database with name: %s", name)
+	result, err := redbeamsDbClient.DeleteDatabase(databases.NewDeleteDatabaseParams().WithEnvironmentCrn(envCrn).WithName(name), nil)
+	if err != nil {
+		commonutils.LogErrorAndExit(err)
+	}
+	log.Infof("[DeleteDB] Deleted database with name: %s Details: %s", name, result)
+}