Skip to content

Commit

Permalink
Merge pull request #59 from bunnyshell/template-variables
Browse files Browse the repository at this point in the history 
Template variables
  • Loading branch information
@BunnyCrlu
BunnyCrlu authored Apr 4, 2024
2 parents 2fca1d7 + 371e400 commit 6d437e3
Show file tree
Hide file tree
Showing 9 changed files with 766 additions and 826 deletions.
145 changes: 5 additions & 140 deletions cmd/environment/action/create.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,67 +2,32 @@ package action

import (
"errors"
"io"
"os"

"bunnyshell.com/cli/pkg/api"
"bunnyshell.com/cli/pkg/api/environment"
"bunnyshell.com/cli/pkg/config"
"bunnyshell.com/cli/pkg/lib"
"bunnyshell.com/cli/pkg/util"
"bunnyshell.com/sdk"
"github.com/spf13/cobra"
)

var (
errCreateSourceNotProvided = errors.New("template id, content or git repository must be provided")
errK8SIntegrationNotProvided = errors.New("kubernetes integration must be provided when deploying")
)

type CreateSource struct {
TemplateID string

Git string

YamlPath string

GitRepo string
GitBranch string
GitPath string
}

func (createSource *CreateSource) UpdateCommandFlags(command *cobra.Command) {
flags := command.Flags()

flags.StringVar(&createSource.Git, "from-git", createSource.Git, "Use a template git repository during creation")
flags.StringVar(&createSource.TemplateID, "from-template", createSource.TemplateID, "Use a TemplateID during creation")
flags.StringVar(&createSource.YamlPath, "from-path", createSource.YamlPath, "Use a local bunnyshell.yaml during creation")
flags.StringVar(&createSource.GitRepo, "from-git-repo", createSource.GitRepo, "Git repository for the environment")
flags.StringVar(&createSource.GitBranch, "from-git-branch", createSource.GitBranch, "Git branch for the environment")
flags.StringVar(&createSource.GitPath, "from-git-path", createSource.GitPath, "Git path for the environment")

command.MarkFlagsMutuallyExclusive("from-git", "from-template", "from-path", "from-git-repo")
command.MarkFlagsRequiredTogether("from-git-branch", "from-git-repo")
command.MarkFlagsRequiredTogether("from-git-path", "from-git-repo")

_ = command.MarkFlagFilename("from-path", "yaml", "yml")
}

func init() {
options := config.GetOptions()
settings := config.GetSettings()

createOptions := environment.NewCreateOptions()
createSource := CreateSource{}

command := &cobra.Command{
Use: "create",

ValidArgsFunction: cobra.NoFileCompletions,

PreRunE: func(cmd *cobra.Command, args []string) error {
if createSource.Git == "" && createSource.TemplateID == "" && createSource.YamlPath == "" && createSource.GitRepo == "" {
return errCreateSourceNotProvided
if err := createOptions.Validate(); err != nil {
return err
}

if createOptions.WithDeploy && createOptions.GetKubernetesIntegration() == "" {
Expand All @@ -77,19 +42,13 @@ func init() {
RunE: func(cmd *cobra.Command, args []string) error {
createOptions.Project = settings.Profile.Context.Project

if err := parseCreateOptions(createSource, createOptions); err != nil {
if err := createOptions.AttachGenesis(); err != nil {
return lib.FormatCommandError(cmd, err)
}

model, err := environment.Create(createOptions)
if err != nil {
var apiError api.Error

if errors.As(err, &apiError) {
return handleCreateErrors(cmd, apiError, createOptions)
}

return lib.FormatCommandError(cmd, err)
return createOptions.HandleError(cmd, err)
}

if !createOptions.WithDeploy {
Expand All @@ -112,101 +71,7 @@ func init() {
util.FlagRequired,
))

createOptions.UpdateFlagSet(flags)

createSource.UpdateCommandFlags(command)
createOptions.UpdateCommandFlags(command)

mainCmd.AddCommand(command)
}

func handleCreateErrors(cmd *cobra.Command, apiError api.Error, createOptions *environment.CreateOptions) error {
genesisName := getCreateGenesisName(createOptions)

if len(apiError.Violations) == 0 {
return apiError
}

for _, violation := range apiError.Violations {
cmd.Printf("Problem with %s: %s\n", genesisName, violation.GetMessage())
}

return lib.ErrGeneric
}

func getCreateGenesisName(createOptions *environment.CreateOptions) string {
if createOptions.Genesis.FromGitSpec != nil {
return "--from-git"
}

if createOptions.Genesis.FromTemplate != nil {
return "--from-template"
}

if createOptions.Genesis.FromString != nil {
return "--from-path"
}

return "arguments"
}

func parseCreateOptions(createSource CreateSource, createOptions *environment.CreateOptions) error {
createOptions.Genesis = &sdk.EnvironmentCreateActionGenesis{}

if createSource.Git != "" {
fromGitSpec := sdk.NewFromGitSpec()
fromGitSpec.Spec = &createSource.Git

createOptions.Genesis.FromGitSpec = fromGitSpec

return nil
}

if createSource.TemplateID != "" {
fromTemplate := sdk.NewFromTemplate()
fromTemplate.Template = &createSource.TemplateID

createOptions.Genesis.FromTemplate = fromTemplate

return nil
}

if createSource.YamlPath != "" {
fromString := sdk.NewFromString()

bytes, err := readFile(createSource.YamlPath)
if err != nil {
return err
}

content := string(bytes)
fromString.Yaml = &content

createOptions.Genesis.FromString = fromString

return nil
}

if createSource.GitRepo != "" {
fromGit := sdk.NewFromGit()
fromGit.Url = &createSource.GitRepo
fromGit.Branch = &createSource.GitBranch
fromGit.YamlPath = &createSource.GitPath

createOptions.Genesis.FromGit = fromGit

return nil
}

return errCreateSourceNotProvided
}

func readFile(fileName string) ([]byte, error) {
file, err := os.Open(fileName)
if err != nil {
return nil, err
}

defer file.Close()

return io.ReadAll(file)
}
138 changes: 7 additions & 131 deletions cmd/environment/action/update.configuration.go
View file
Original file line number Diff line number Diff line change
@@ -1,73 +1,37 @@
package action

import (
"errors"

"bunnyshell.com/cli/pkg/api"
"bunnyshell.com/cli/pkg/api/environment"
"bunnyshell.com/cli/pkg/config"
"bunnyshell.com/cli/pkg/lib"
"bunnyshell.com/sdk"
"github.com/spf13/cobra"
)

type EditSource struct {
TemplateID string

Git string

YamlPath string

GitRepo string
GitBranch string
GitPath string
}

func (es *EditSource) UpdateCommandFlags(command *cobra.Command) {
flags := command.Flags()

flags.StringVar(&es.Git, "from-git", es.Git, "Use a template git repository during update")
flags.StringVar(&es.TemplateID, "from-template", es.TemplateID, "Use a template ID during update")
flags.StringVar(&es.YamlPath, "from-path", es.YamlPath, "Use a local environment yaml during update")
flags.StringVar(&es.GitRepo, "from-git-repo", es.GitRepo, "Git repository for the environment template")
flags.StringVar(&es.GitBranch, "from-git-branch", es.GitBranch, "Git branch for the environment template")
flags.StringVar(&es.GitPath, "from-git-path", es.GitPath, "Git path for the environment template")

command.MarkFlagsMutuallyExclusive("from-git", "from-template", "from-path", "from-git-repo")
command.MarkFlagsRequiredTogether("from-git-branch", "from-git-repo")
command.MarkFlagsRequiredTogether("from-git-path", "from-git-repo")

_ = command.MarkFlagFilename("from-path", "yaml", "yml")
}

func init() {
options := config.GetOptions()
settings := config.GetSettings()

editConfigurationOptions := environment.NewEditConfigurationOptions("")
editSource := EditSource{}

command := &cobra.Command{
Use: "update-configuration",

ValidArgsFunction: cobra.NoFileCompletions,

PreRunE: func(cmd *cobra.Command, args []string) error {
return editConfigurationOptions.Validate()
},

RunE: func(cmd *cobra.Command, args []string) error {
editConfigurationOptions.ID = settings.Profile.Context.Environment

if err := parseEditConfigurationOptions(editSource, editConfigurationOptions); err != nil {
if err := editConfigurationOptions.AttachGenesis(); err != nil {
return lib.FormatCommandError(cmd, err)
}

model, err := environment.EditConfiguration(editConfigurationOptions)
if err != nil {
var apiError api.Error

if errors.As(err, &apiError) {
return handleEditErrors(cmd, apiError, editConfigurationOptions)
}

return lib.FormatCommandError(cmd, err)
return editConfigurationOptions.HandleError(cmd, err)
}

if !editConfigurationOptions.WithDeploy {
Expand All @@ -87,95 +51,7 @@ func init() {
flags.AddFlag(idFlag)
_ = command.MarkFlagRequired(idFlag.Name)

editConfigurationOptions.UpdateFlagSet(flags)
editSource.UpdateCommandFlags(command)
editConfigurationOptions.UpdateCommandFlags(command)

mainCmd.AddCommand(command)
}

func handleEditErrors(cmd *cobra.Command, apiError api.Error, editOptions *environment.EditConfigurationOptions) error {
genesisName := getEditGenesisName(editOptions)

if len(apiError.Violations) == 0 {
return apiError
}

for _, violation := range apiError.Violations {
cmd.Printf("Problem with %s: %s\n", genesisName, violation.GetMessage())
}

return lib.ErrGeneric
}

func getEditGenesisName(editOptions *environment.EditConfigurationOptions) string {
configuration := editOptions.Configuration

if configuration.FromGitSpec != nil {
return "--from-git"
}

if configuration.FromTemplate != nil {
return "--from-template"
}

if configuration.FromString != nil {
return "--from-path"
}

return "arguments"
}

//nolint:dupl
func parseEditConfigurationOptions(
editSource EditSource,
editConfigurationOptions *environment.EditConfigurationOptions,
) error {
editConfigurationOptions.Configuration = &sdk.EnvironmentEditConfigurationConfiguration{}

if editSource.Git != "" {
fromGitSpec := sdk.NewFromGitSpec()
fromGitSpec.Spec = &editSource.Git

editConfigurationOptions.Configuration.FromGitSpec = fromGitSpec

return nil
}

if editSource.TemplateID != "" {
fromTemplate := sdk.NewFromTemplate()
fromTemplate.Template = &editSource.TemplateID

editConfigurationOptions.Configuration.FromTemplate = fromTemplate

return nil
}

if editSource.YamlPath != "" {
fromString := sdk.NewFromString()

bytes, err := readFile(editSource.YamlPath)
if err != nil {
return err
}

content := string(bytes)
fromString.Yaml = &content

editConfigurationOptions.Configuration.FromString = fromString

return nil
}

if editSource.GitRepo != "" {
fromGit := sdk.NewFromGit()
fromGit.Url = &editSource.GitRepo
fromGit.Branch = &editSource.GitBranch
fromGit.YamlPath = &editSource.GitPath

editConfigurationOptions.Configuration.FromGit = fromGit

return nil
}

return errCreateSourceNotProvided
}
Loading

0 comments on commit 6d437e3

Please sign in to comment.