feat: init deploy on cobra cli

cmd/deploy/deploy.go

@@ -0,0 +1,16 @@
+package deploy
+
+import (
+	"github.com/dream11/odin/cmd"
+	"github.com/spf13/cobra"
+)
+
+var deployCmd = &cobra.Command{
+	Use:   "deploy",
+	Short: "Deploy resources",
+	Long:  `Deploy resources`,
+}
+
+func init() {
+	cmd.RootCmd.AddCommand(deployCmd)
+}

cmd/deploy/service.go

@@ -0,0 +1,77 @@
+package deploy
+
+import (
+	"encoding/json"
+	"os"
+
+	"github.com/dream11/odin/internal/service"
+	serviceDto "github.com/dream11/odin/proto/gen/go/dream11/od/dto/v1"
+	serviceProto "github.com/dream11/odin/proto/gen/go/dream11/od/service/v1"
+	log "github.com/sirupsen/logrus"
+	"github.com/spf13/cobra"
+)
+
+var env string
+var definitionFile string
+var provisioningFile string
+
+var serviceClient = service.Service{}
+
+var serviceCmd = &cobra.Command{
+	Use:   "service",
+	Short: "Deploy service",
+	Args: func(cmd *cobra.Command, args []string) error {
+		return cobra.NoArgs(cmd, args)
+	},
+	Long: "Deploy service using files or service name",
+	Run: func(cmd *cobra.Command, args []string) {
+		execute(cmd)
+	},
+}
+
+func init() {
+	serviceCmd.Flags().StringVar(&env, "env", "", "environment for deploying the service")
+	serviceCmd.Flags().StringVar(&definitionFile, "file", "", "path to the service definition file")
+	serviceCmd.Flags().StringVar(&provisioningFile, "provisioning", "", "path to the provisioning file")
+	err := serviceCmd.MarkFlagRequired("env")
+	if err != nil {
+		log.Fatal("Error marking 'env' flag as required:", err)
+	}
+
+	deployCmd.AddCommand(serviceCmd)
+}
+
+func execute(cmd *cobra.Command) {
+	ctx := cmd.Context()
+
+	definitionData, err := os.ReadFile(definitionFile)
+	if err != nil {
+		log.Fatal("Error while reading definition file ", err)
+	}
+	var definitionProto serviceDto.ServiceDefinition
+	if err := json.Unmarshal(definitionData, &definitionProto); err != nil {
+		log.Fatalf("Error unmarshalling definition file: %v", err)
+	}
+
+	provisioningData, err := os.ReadFile(provisioningFile)
+	if err != nil {
+		log.Fatal("Error while reading provisioning file ", err)
+	}
+	var compProvConfigs []*serviceDto.ComponentProvisioningConfig
+	if err := json.Unmarshal(provisioningData, &compProvConfigs); err != nil {
+		log.Fatalf("Error unmarshalling provisioning file: %v", err)
+	}
+	provisioningProto := &serviceDto.ProvisioningConfig{
+		ComponentProvisioningConfig: compProvConfigs,
+	}
+
+	err = serviceClient.DeployService(&ctx, &serviceProto.DeployServiceRequest{
+		EnvName:            env,
+		ServiceDefinition:  &definitionProto,
+		ProvisioningConfig: provisioningProto,
+	})
+
+	if err != nil {
+		log.Fatal("Failed to deploy service ", err)
+	}
+}

go.mod

@@ -40,5 +40,5 @@ require (
 	golang.org/x/net v0.14.0 // indirect
 	google.golang.org/genproto/googleapis/rpc v0.0.0-20230815205213-6bfd019c3878 // indirect
 	google.golang.org/grpc v1.57.0
-	google.golang.org/protobuf v1.31.0
+	google.golang.org/protobuf v1.33.0
 )

go.sum

@@ -1918,8 +1918,9 @@ google.golang.org/protobuf v1.28.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqw
 google.golang.org/protobuf v1.28.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.29.1/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
-google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
 google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
+google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

internal/service/environment.go

@@ -68,7 +68,7 @@ func (e *Environment) CreateEnvironment(ctx *context.Context, request *environme
 	return err
 }
 
-// DeleteEnvironment : Delete environment
+// DeleteEnvironment deletes environment
 func (e *Environment) DeleteEnvironment(ctx *context.Context, request *environment.DeleteEnvironmentRequest) error {
 	conn, requestCtx, err := grpcClient(ctx)
 	if err != nil {

internal/service/service.go

@@ -8,37 +8,82 @@ import (
 
 	"github.com/briandowns/spinner"
 	"github.com/dream11/odin/pkg/constant"
-	service "github.com/dream11/odin/proto/gen/go/dream11/od/service/v1"
+	serviceProto "github.com/dream11/odin/proto/gen/go/dream11/od/service/v1"
 	log "github.com/sirupsen/logrus"
 )
 
 // Service performs operation on service like deploy. undeploy
 type Service struct{}
 
-// UndeployService : Delete environment
-func (e *Service) UndeployService(ctx *context.Context, request *service.UndeployServiceRequest) error {
+// DeployService deploys service
+func (e *Service) DeployService(ctx *context.Context, request *serviceProto.DeployServiceRequest) error {
+	conn, requestCtx, err := grpcClient(ctx)
+	if err != nil {
+		return err
+	}
+	client := serviceProto.NewServiceServiceClient(conn)
+	stream, err := client.DeployService(*requestCtx, request)
+	if err != nil {
+		return err
+	}
+
+	log.Info("Deploying Service...")
+	spinnerInstance := spinner.New(spinner.CharSets[constant.SpinnerType], constant.SpinnerDelay)
+	err = spinnerInstance.Color(constant.SpinnerColor, constant.SpinnerStyle)
+	if err != nil {
+		return err
+	}
+
+	var message string
+	for {
+		response, err := stream.Recv()
+		spinnerInstance.Stop()
+		if err != nil {
+			if errors.Is(err, context.Canceled) || err == io.EOF {
+				break
+			}
+			return err
+		}
+
+		if response != nil {
+			message = response.Message
+			message += fmt.Sprintf("\n Service %s %s", response.ServiceStatus.ServiceAction, response.ServiceStatus.ServiceStatus)
+			for _, compMessage := range response.ComponentsStatus {
+				message += fmt.Sprintf("\n Component %s %s %s", compMessage.ComponentName, compMessage.ComponentAction, compMessage.ComponentStatus)
+			}
+			spinnerInstance.Prefix = fmt.Sprintf(" %s  ", message)
+			spinnerInstance.Start()
+		}
+	}
+
+	log.Info(message)
+	return err
+}
+
+// UndeployService undeploys service
+func (e *Service) UndeployService(ctx *context.Context, request *serviceProto.UndeployServiceRequest) error {
 	conn, requestCtx, err := grpcClient(ctx)
 	if err != nil {
 		return err
 	}
 
-	client := service.NewServiceServiceClient(conn)
+	client := serviceProto.NewServiceServiceClient(conn)
 	stream, err := client.UndeployService(*requestCtx, request)
 
 	if err != nil {
 		return err
 	}
 
 	log.Info("Undeploying Service...")
-	spinner := spinner.New(spinner.CharSets[constant.SpinnerType], constant.SpinnerDelay)
-	err = spinner.Color(constant.SpinnerColor, constant.SpinnerStyle)
+	spinnerInstance := spinner.New(spinner.CharSets[constant.SpinnerType], constant.SpinnerDelay)
+	err = spinnerInstance.Color(constant.SpinnerColor, constant.SpinnerStyle)
 	if err != nil {
 		return err
 	}
 	var message string
 	for {
 		response, err := stream.Recv()
-		spinner.Stop()
+		spinnerInstance.Stop()
 		if err != nil {
 			if errors.Is(err, context.Canceled) || err == io.EOF {
 				break
@@ -47,8 +92,8 @@ func (e *Service) UndeployService(ctx *context.Context, request *service.Undeplo
 		}
 		if response != nil {
 			message = response.Message
-			spinner.Prefix = fmt.Sprintf(" %s  ", response.Message)
-			spinner.Start()
+			spinnerInstance.Prefix = fmt.Sprintf(" %s  ", response.Message)
+			spinnerInstance.Start()
 		}
 	}
 	log.Info(message)

main.go

@@ -8,6 +8,7 @@ import (
 	_ "github.com/dream11/odin/cmd/configure"
 	_ "github.com/dream11/odin/cmd/create"
 	_ "github.com/dream11/odin/cmd/delete"
+	_ "github.com/dream11/odin/cmd/deploy"
 	_ "github.com/dream11/odin/cmd/list"
 	_ "github.com/dream11/odin/cmd/operate"
 	_ "github.com/dream11/odin/cmd/undeploy"

pkg/util/file.go

@@ -38,28 +38,29 @@ func FindAndReadAllAllowedFormat(path string, allowedFormats []string) ([]byte,
 
 // ParseFile parse json or yaml file given path to json and return as interface
 func ParseFile(filePath string) (interface{}, error) {
-	if len(filePath) != 0 {
-		var parsedDefinition interface{}
+	var parsedContent interface{}
 
-		fileDefinition, err := Read(filePath)
+	if len(filePath) == 0 {
+		return parsedContent, errors.New("filepath cannot be empty")
+	}
+
+	fileContent, err := Read(filePath)
+	if err != nil {
+		return parsedContent, errors.New("Error reading file: " + err.Error())
+	}
+
+	if strings.Contains(filePath, ".yaml") || strings.Contains(filePath, ".yml") {
+		err = yamlPorvider.Unmarshal(fileContent, &parsedContent)
 		if err != nil {
-			return parsedDefinition, errors.New("file does not exist")
+			return parsedContent, errors.New("Unable to parse YAML file: " + err.Error())
 		}
-
-		if strings.Contains(filePath, ".yaml") || strings.Contains(filePath, ".yml") {
-			err = yamlPorvider.Unmarshal(fileDefinition, &parsedDefinition)
-			if err != nil {
-				return parsedDefinition, errors.New("Unable to parse YAML. " + err.Error())
-			}
-		} else if strings.Contains(filePath, ".json") {
-			err = json.Unmarshal(fileDefinition, &parsedDefinition)
-			if err != nil {
-				return parsedDefinition, errors.New("Unable to parse JSON. " + err.Error())
-			}
-		} else {
-			return parsedDefinition, errors.New("unrecognized file format")
+	} else if strings.Contains(filePath, ".json") {
+		err = json.Unmarshal(fileContent, &parsedContent)
+		if err != nil {
+			return parsedContent, errors.New("Unable to parse JSON file: " + err.Error())
 		}
-		return parsedDefinition, nil
+	} else {
+		return parsedContent, errors.New("unrecognized file format")
 	}
-	return errors.New("filepath cannot be empty"), nil
+	return parsedContent, nil
 }