command

Documentation

Index

• Constants
• Variables
• func Elogin(usr, pwd, vc string) *manager.Client
• func Esetup(c *cli.Context, vals []string) *manager.Client
• func MapEnvOptions(c *cli.Context, opts map[string]interface{}) map[string]interface{}
• func ProviderFlagsToSlice(c *cli.Context) map[string]interface{}
• type NullWriter
  • func (NullWriter) Write([]byte) (int, error)

Constants

const (
	// NonEmptuTokenVal ...
	NonEmptuTokenVal = "non_empty_token"
	// NonAdminVal ...
	NonAdminVal = "non_admin"
)

Variables

var AWSVCloudFlags = append(ProviderVCloudFlags, ProviderAWSFlags...)

AWSVCloudFlags : All aws vcloud provider flags

var AddAdminUser = cli.Command{
	Name:        "add",
	Usage:       h.T("user.admin.add.usage"),
	ArgsUsage:   h.T("user.admin.add.args"),
	Description: h.T("user.admin.add.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "user.admin.add.args")

		client := esetup(c, NonAdminValidation)
		username := c.Args()[0]

		user := client.User().Get(username)
		user.Admin = true
		client.User().Update(user)

		color.Green("Admin privileges assigned to user " + username)
		return nil
	},
}

AddAdminUser :

var AddEntityToNotification = cli.Command{
	Name:        "add",
	Usage:       h.T("notification.service.add.usage"),
	ArgsUsage:   h.T("notification.service.add.args"),
	Description: h.T("notification.service.add.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "notification.service.add.args")

		notification := c.Args()[0]
		project := c.Args()[1]
		client := esetup(c, AuthUsersValidation)
		entity := project
		if len(c.Args()) > 2 {
			entity = entity + "/" + c.Args()[2]
			client.Notification().AddEnv(notification, project, c.Args()[2])
		} else {
			client.Notification().AddProject(notification, project)
		}

		color.Green(fmt.Sprintf(h.T("notification.service.add.success"), entity, notification))
		return nil
	},
}

AddEntityToNotification : Creates a new user

var AdminUser = cli.Command{
	Name:  "admin",
	Usage: h.T("user.admin.usage"),
	Subcommands: []cli.Command{
		AddAdminUser,
		RmAdminUser,
	},
}

AdminUser ...

var AllProviderFlags = append(AWSVCloudFlags, ProviderAzureFlags...)

AllProviderFlags : All provider flags

var ApplyEnv = cli.Command{
	Name:        "apply",
	Aliases:     []string{"a"},
	Usage:       h.T("envs.apply.usage"),
	ArgsUsage:   h.T("envs.apply.args"),
	Description: h.T("envs.apply.description"),
	Flags: append([]cli.Flag{
		tBoolFlag("envs.apply.flags.dry"),
		tBoolFlag("envs.apply.flags.verbose"),
		tStringFlagND("envs.apply.flags.credentials"),
	}, AllProviderFlags...),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "envs.apply.args")
		client := esetup(c, AuthUsersValidation)
		def := mapDefinition(c)

		if _, err := client.Cli().Environments.Get(def.Project, def.Name); err != nil {
			env := emodels.Environment{
				Name:        def.Name,
				Project:     def.Project,
				Credentials: ProviderFlagsToSlice(c),
				Options:     MapEnvOptions(c, nil),
			}
			client.Environment().Create(def.Project, &env)
		}
		payload, err := def.Save()
		if err != nil {
			h.PrintError("Could not finalize definition yaml")
		}
		if c.Bool("dry") == true {
			view.EnvDry(*client.Build().Dry(payload))
			return nil
		}
		if c.Bool("verbose") {
			client.Build().Verbose = true
		}

		build := client.Build().Create(payload)
		if build.Status == "submitted" {
			color.Green("Build has been succesfully submitted and is awaiting approval.")
			os.Exit(0)
		}

		h.Monitorize(client.Build().Stream(build.ID))
		view.PrintEnvInfo(
			client.Environment().Get(def.Project, def.Name),
			client.Build().Get(def.Project, def.Name, build.GetID()),
		)

		return nil
	},
}

ApplyEnv command Applies changes described on a YAML file to an env

var AttachPolicy = cli.Command{
	Name:        "attach",
	Usage:       h.T("policy.attach.usage"),
	ArgsUsage:   h.T("policy.attach.args"),
	Description: h.T("policy.attach.description"),
	Flags: []cli.Flag{
		tStringFlag("policy.attach.flags.name"),
		tStringFlag("policy.attach.flags.environment"),
	},
	Action: func(c *cli.Context) error {
		flags := parseTemplateFlags(c, map[string]flagDef{
			"policy-name": flagDef{typ: "string", req: true},
			"environment": flagDef{typ: "string", req: true},
		})
		client := esetup(c, AuthUsersValidation)
		env := flags["environment"].(string)
		parts := strings.Split(env, "/")
		if len(parts) != 2 {
			h.PrintError(h.T("policy.attach.errors.invalid_name"))
		}

		p := client.Policy().Get(flags["policy-name"].(string))
		_ = client.Environment().Get(parts[0], parts[1])
		for _, v := range p.Environments {
			if v == env {
				h.PrintError(h.T("policy.attach.errors.already_attached"))
			}
		}
		p.Environments = append(p.Environments, env)
		client.Policy().Update(p)

		color.Green(fmt.Sprintf(h.T("policy.attach.success"), p.Name, env))
		return nil
	},
}

AttachPolicy : Display an existing policy

var AuthUsersValidation = []string{NonEmptuTokenVal}

AuthUsersValidation ...

var CmdDocs = cli.Command{
	Name:        "docs",
	Usage:       h.T("docs.usage"),
	ArgsUsage:   h.T("docs.args"),
	Description: h.T("docs.description"),
	Action: func(c *cli.Context) error {
		err := open.Run(docURL)
		if err != nil {
			fmt.Println(h.T("azure.create.success"), docURL)
		}
		return nil
	},
}

CmdDocs : Open docs in the default browser

var CmdEnv = cli.Command{
	Name:    "environment",
	Aliases: []string{"env"},
	Usage:   "Environment related subcommands",
	Subcommands: []cli.Command{
		ListEnvs,
		CreateEnv,
		UpdateEnv,
		ApplyEnv,
		DestroyEnv,
		HistoryEnv,
		ResetEnv,
		RevertEnv,
		DefinitionEnv,
		InfoEnv,
		MonitorEnv,
		DiffEnv,
		ImportEnv,
		SyncEnv,
		ResolveEnv,
		ReviewEnv,
		ScheduleEnv,
		ValidateEnv,
	},
}

CmdEnv ...

var CmdLog = cli.Command{
	Name:        "log",
	Usage:       h.T("log.usage"),
	ArgsUsage:   h.T("log.args"),
	Description: h.T("log.description"),
	Flags: []cli.Flag{
		tBoolFlag("log.flags.raw"),
	},
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)

		if c.Bool("raw") {
			_ = helper.PrintRawLogs(client.Logger().Stream())
		} else {
			_ = helper.PrintLogs(client.Logger().Stream())
		}

		runtime.Goexit()

		return nil
	},
}

CmdLog : Preferences setup

var CmdNotification = cli.Command{
	Name:  "notification",
	Usage: "Notification related subcommands",
	Subcommands: []cli.Command{
		ListNotifications,
		CreateNotification,
		UpdateNotification,
		DeleteNotification,
		AddEntityToNotification,
		RmEntityToNotification,
	},
}

CmdNotification ...

var CmdPolicy = cli.Command{
	Name:    "policy",
	Aliases: []string{"p"},
	Usage:   "Policy related subcommands",
	Subcommands: []cli.Command{
		ListPolicies,
		CreatePolicy,
		UpdatePolicy,
		DeletePolicy,
		ShowPolicy,
		HistoryPolicy,
		AttachPolicy,
		DetachPolicy,
	},
}

CmdPolicy ...

var CmdPreferences = cli.Command{
	Name:  "preferences",
	Usage: "Ernest preferences",
	Subcommands: []cli.Command{
		LoggerCommands,
	},
}

CmdPreferences : Preferences setup

var CmdProject = cli.Command{
	Name:  "project",
	Usage: "Project related subcommands",
	Subcommands: []cli.Command{
		ListProjects,
		CreateProjects,
		UpdateProjects,
		DeleteProject,
		InfoProject,
	},
}

CmdProject ...

var CmdRoles = cli.Command{
	Name:  "role",
	Usage: "Roles to manage resources authorization",
	Subcommands: []cli.Command{
		CmdRolesSet,
		CmdRolesUnset,
	},
}

CmdRoles ...

var CmdRolesSet = cli.Command{
	Name:        "set",
	Usage:       h.T("roles.set.usage"),
	ArgsUsage:   h.T("roles.set.args"),
	Description: h.T("roles.set.description"),
	Flags: []cli.Flag{
		tStringFlag("roles.set.flags.user"),
		tStringFlag("roles.set.flags.project"),
		tStringFlag("roles.set.flags.role"),
		tStringFlag("roles.set.flags.environment"),
		tStringFlag("roles.set.flags.policy"),
	},
	Action: func(c *cli.Context) error {
		rolesManager(c, true)
		return nil
	},
}

CmdRolesSet :

var CmdRolesUnset = cli.Command{
	Name:        "unset",
	Usage:       h.T("roles.unset.usage"),
	ArgsUsage:   h.T("roles.unset.args"),
	Description: h.T("roles.unset.description"),
	Flags: []cli.Flag{
		tStringFlag("roles.set.flags.user"),
		tStringFlag("roles.set.flags.project"),
		tStringFlag("roles.set.flags.role"),
		tStringFlag("roles.set.flags.environment"),
		tStringFlag("roles.set.flags.policy"),
	},
	Action: func(c *cli.Context) error {
		rolesManager(c, false)
		return nil
	},
}

CmdRolesUnset :

var CmdUsage = cli.Command{
	Name:        "usage",
	Usage:       h.T("usage.usage"),
	ArgsUsage:   h.T("usage.args"),
	Description: h.T("usage.description"),
	Flags: []cli.Flag{
		tStringFlagND("usage.flags.from"),
		tStringFlagND("usage.flags.to"),
		tStringFlagND("usage.flags.output"),
	},
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)
		body := client.Report().Usage(c.String("from"), c.String("to"))

		if c.String("output") != "" {
			if err := ioutil.WriteFile(c.String("output"), body, 0644); err != nil {
				h.PrintError(err.Error())
			}
			color.Green(fmt.Sprintf(h.T("usage.success"), c.String("output")))
		} else {
			fmt.Println(string(body))
		}

		return nil
	},
}

CmdUsage : Exports an usage report to a file on the current folder

var CmdUser = cli.Command{
	Name:  "user",
	Usage: h.T("user.usage"),
	Subcommands: []cli.Command{
		CreateUser,
		DisableUser,
		DisableMFA,
		EnableMFA,
		InfoUser,
		ListUsers,
		PasswordUser,
		ResetMFA,
		AdminUser,
	},
}

CmdUser ...

var CreateAWSProject = cli.Command{
	Name:        "aws",
	Usage:       h.T("aws.create.usage"),
	Description: h.T("aws.create.description"),
	ArgsUsage:   h.T("aws.create.args"),
	Flags: []cli.Flag{
		tStringFlag("aws.create.flags.region"),
		tStringFlag("aws.create.flags.access_key_id"),
		tStringFlag("aws.create.flags.secret_access_key"),
		tStringFlag("aws.create.flags.template"),
		tBoolFlag("aws.create.flags.fake"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "aws.create.args")
		client := esetup(c, AuthUsersValidation)
		creds := parseTemplateFlags(c, map[string]flagDef{
			"secret_access_key": flagDef{typ: "string", mapto: "aws_secret_access_key", req: true},
			"access_key_id":     flagDef{typ: "string", mapto: "aws_access_key_id", req: true},
			"region":            flagDef{typ: "string", req: true},
			"fake":              flagDef{typ: "bool", def: false},
		})
		creds["username"] = c.Args()[0]

		rtype := "aws"
		if creds["fake"].(bool) {
			rtype = "aws-fake"
		}

		p := &emodels.Project{
			Name:        c.Args()[0],
			Type:        rtype,
			Credentials: creds,
		}
		client.Project().Create(p)
		color.Green(fmt.Sprintf(h.T("aws.create.success"), p.Name))

		return nil
	},
}

CreateAWSProject : Creates an AWS project

var CreateAzureProject = cli.Command{
	Name:        "azure",
	Usage:       h.T("azure.create.usage"),
	Description: h.T("azure.create.description"),
	ArgsUsage:   h.T("azure.create.args"),
	Flags: []cli.Flag{
		tStringFlag("azure.create.flags.subscription_id"),
		tStringFlag("azure.create.flags.client_id"),
		tStringFlag("azure.create.flags.client_secret"),
		tStringFlag("azure.create.flags.tenant_id"),
		tStringFlag("azure.create.flags.environment"),
		tBoolFlag("azure.create.flags.fake"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "azure.create.args")
		client := esetup(c, AuthUsersValidation)
		creds := parseTemplateFlags(c, map[string]flagDef{
			"subscription_id": flagDef{typ: "string", mapto: "azure_subscription_id", req: true},
			"client_id":       flagDef{typ: "string", mapto: "azure_client_id", req: true},
			"client_secret":   flagDef{typ: "string", mapto: "azure_client_secret", req: true},
			"tenant_id":       flagDef{typ: "string", mapto: "azure_tenant_id", req: true},
			"environment":     flagDef{typ: "string", mapto: "azure_environment", def: "default", req: true},
			"fake":            flagDef{typ: "bool", def: false},
		})
		rtype := "azure"
		if creds["fake"].(bool) {
			rtype = "azure-fake"
		}

		p := &emodels.Project{
			Name:        c.Args()[0],
			Type:        rtype,
			Credentials: creds,
		}
		client.Project().Create(p)
		color.Green(fmt.Sprintf(h.T("azure.create.success"), p.Name))

		return nil
	},
}

CreateAzureProject : Creates an AWS project

var CreateEnv = cli.Command{
	Name:        "create",
	Aliases:     []string{"a"},
	Usage:       h.T("envs.create.usage"),
	ArgsUsage:   h.T("envs.create.args"),
	Description: h.T("envs.create.description"),
	Flags: append([]cli.Flag{
		tStringFlagND("envs.create.flags.credentials"),
		tStringFlagND("envs.create.flags.submissions"),
	}, AllProviderFlags...),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.create.args")
		client := esetup(c, AuthUsersValidation)

		env := emodels.Environment{
			Name:        c.Args()[1],
			Project:     c.Args()[0],
			Credentials: ProviderFlagsToSlice(c),
			Options:     MapEnvOptions(c, nil),
		}
		client.Environment().Create(c.Args()[0], &env)
		color.Green("Environment successfully created")

		return nil
	},
}

CreateEnv : Creates an empty environment based on a name and a project name

var CreateNotification = cli.Command{
	Name:        "create",
	Usage:       h.T("notification.create.usage"),
	ArgsUsage:   h.T("notification.create.args"),
	Description: h.T("notification.create.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 3, "notification.create.args")
		client := esetup(c, AuthUsersValidation)

		name := c.Args()[0]
		notificationType := c.Args()[1]
		notificationConfig := c.Args()[2]
		notification := emodels.Notification{
			Name:   name,
			Type:   notificationType,
			Config: notificationConfig,
		}
		client.Notification().Create(&notification)
		color.Green(fmt.Sprintf(h.T("notification.create.success"), name))
		return nil
	},
}

CreateNotification : Creates a new user

var CreatePolicy = cli.Command{
	Name:        "create",
	Usage:       h.T("policy.create.usage"),
	ArgsUsage:   h.T("policy.create.args"),
	Description: h.T("policy.create.description"),
	Flags: []cli.Flag{
		tStringFlag("policy.create.flags.name"),
		tStringFlag("policy.create.flags.spec"),
	},
	Action: func(c *cli.Context) error {
		flags := parseTemplateFlags(c, map[string]flagDef{
			"policy-name": flagDef{typ: "string", req: true},
			"spec":        flagDef{typ: "string", req: true},
		})
		client := esetup(c, AuthUsersValidation)
		spec, err := ioutil.ReadFile(flags["spec"].(string))
		if err != nil {
			h.PrintError(h.T("policy.create.errors.spec"))
		}

		policy := emodels.Policy{
			Name: flags["policy-name"].(string),
		}
		client.Policy().Create(&policy)
		client.Policy().CreateDocument(policy.Name, string(spec))
		color.Green(fmt.Sprintf(h.T("policy.create.success"), policy.Name))
		return nil
	},
}

CreatePolicy : Creates a new user

var CreateProjects = cli.Command{
	Name:        "create",
	Usage:       "Create a new project.",
	Description: "Create a new project on the targeted instance of Ernest.",
	Subcommands: []cli.Command{
		CreateVcloudProject,
		CreateAWSProject,
		CreateAzureProject,
	},
}

CreateProjects ...

var CreateUser = cli.Command{
	Name:        "create",
	Usage:       h.T("user.create.usage"),
	ArgsUsage:   h.T("user.create.args"),
	Description: h.T("user.create.description"),
	Flags: []cli.Flag{
		tStringFlag("user.create.flags.email"),
		tBoolFlag("user.create.flags.mfa"),
		tBoolFlag("user.create.flags.admin"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "user.create.args")
		client := esetup(c, AuthUsersValidation)
		usr := c.Args()[0]
		mfa := c.Bool("mfa")

		user := &emodels.User{
			Username: usr,
			Email:    c.String("email"),
			Password: c.Args()[1],
			MFA:      &mfa,
			Disabled: h.Bool(false),
		}
		client.User().Create(user)
		color.Green("User %s successfully created\n\n", usr)

		if mfa {
			color.Green("MFA enabled")
			fmt.Printf("Account name: Ernest (%s)\nKey: %s\n", usr, user.MFASecret)
		}

		if c.Bool("admin") {
			client.User().Promote(user)
		}

		return nil
	},
}

CreateUser : Creates a new user

var CreateVcloudProject = cli.Command{
	Name:        "vcloud",
	Usage:       h.T("vcloud.create.usage"),
	ArgsUsage:   h.T("vcloud.create.args"),
	Description: h.T("vcloud.create.description"),
	Flags: []cli.Flag{
		tStringFlag("vcloud.create.flags.user"),
		tStringFlag("vcloud.create.flags.password"),
		tStringFlag("vcloud.create.flags.org"),
		tStringFlag("vcloud.create.flags.vdc"),
		tStringFlag("vcloud.create.flags.vcloud-url"),
		tStringFlag("vcloud.create.flags.template"),
		tBoolFlag("vcloud.create.flags.fake"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "vcloud.create.args")
		client := esetup(c, AuthUsersValidation)
		creds := parseTemplateFlags(c, map[string]flagDef{
			"vcloud-url": flagDef{typ: "string", mapto: "vcloud_url", req: true},
			"user":       flagDef{typ: "string", req: true},
			"org":        flagDef{typ: "string", req: true},
			"vdc":        flagDef{typ: "string", req: true},
			"password":   flagDef{typ: "string", req: true},
			"fake":       flagDef{typ: "bool", def: false},
		})
		creds["username"] = creds["user"].(string) + "@" + creds["org"].(string)

		rtype := "vcloud"
		if creds["fake"].(bool) {
			rtype = "vcloud-fake"
		}

		p := &emodels.Project{
			Name:        c.Args()[0],
			Type:        rtype,
			Credentials: creds,
		}
		client.Project().Create(p)
		color.Green(fmt.Sprintf(h.T("vcloud.create.success"), p.Name))

		return nil
	},
}

CreateVcloudProject : Creates a VCloud Project

var DefinitionEnv = cli.Command{
	Name:        "definition",
	Aliases:     []string{"s"},
	Usage:       h.T("envs.definition.usage"),
	ArgsUsage:   h.T("envs.definition.args"),
	Description: h.T("envs.definition.description"),
	Flags: []cli.Flag{
		tStringFlag("envs.definition.flags.build"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.definition.args")
		flags := parseTemplateFlags(c, map[string]flagDef{
			"build": flagDef{typ: "string"},
		})
		client := esetup(c, AuthUsersValidation)

		builds := client.Build().List(c.Args()[0], c.Args()[1])
		build := getBuildByPosition(flags["build"], builds)
		def := client.Build().Definition(c.Args()[0], c.Args()[1], build.ID)

		fmt.Println(def)

		return nil
	},
}

DefinitionEnv command Shows the current definition of an environment by its name

var DelLogger = cli.Command{
	Name:        "delete",
	Usage:       h.T("logger.del.usage"),
	ArgsUsage:   h.T("logger.del.args"),
	Description: h.T("logger.del.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "logger.del.args")
		client := esetup(c, NonAdminValidation)

		client.Logger().Delete(c.Args()[0])
		color.Green(h.T("logger.del.success"))

		return nil
	},
}

DelLogger : deletes a looger based on it type

var DeleteNotification = cli.Command{
	Name:        "delete",
	Usage:       h.T("notification.delete.usage"),
	ArgsUsage:   h.T("notification.delete.args"),
	Description: h.T("notification.delete.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "notification.delete.args")
		name := c.Args()[0]
		client := esetup(c, AuthUsersValidation)

		client.Notification().Delete(name)
		color.Green(fmt.Sprintf(h.T("notification.delete.success"), name))
		return nil
	},
}

DeleteNotification : Will delete the specified notification

var DeletePolicy = cli.Command{
	Name:        "delete",
	Usage:       h.T("policy.delete.usage"),
	ArgsUsage:   h.T("policy.delete.args"),
	Description: h.T("policy.delete.description"),
	Flags: []cli.Flag{
		tStringFlag("policy.delete.flags.name"),
	},
	Action: func(c *cli.Context) error {
		flags := parseTemplateFlags(c, map[string]flagDef{
			"policy-name": flagDef{typ: "string", req: true},
		})

		client := esetup(c, AuthUsersValidation)
		name := flags["policy-name"].(string)

		client.Policy().Delete(name)
		color.Green(fmt.Sprintf(h.T("policy.delete.success"), name))
		return nil
	},
}

DeletePolicy : Will delete the specified policy

var DeleteProject = cli.Command{
	Name:        "delete",
	Usage:       h.T("vcloud.delete.usage"),
	ArgsUsage:   h.T("vcloud.delete.args"),
	Description: h.T("vcloud.delete.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "vcloud.delete.args")
		client := esetup(c, AuthUsersValidation)

		name := c.Args()[0]
		client.Project().Delete(name)
		color.Green(fmt.Sprintf(h.T("vcloud.delete.success"), name))

		return nil
	},
}

DeleteProject : Project deletion command definition

var DestroyEnv = cli.Command{
	Name:        "delete",
	Aliases:     []string{"destroy", "d"},
	Usage:       h.T("envs.destroy.usage"),
	ArgsUsage:   h.T("envs.destroy.args"),
	Description: h.T("envs.destroy.description"),
	Flags: []cli.Flag{
		tBoolFlag("envs.destroy.flags.force"),
		tBoolFlag("envs.destroy.flags.yesflag"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.destroy.args")
		client := esetup(c, AuthUsersValidation)

		if c.Bool("force") {
			client.Environment().ForceDeletion(c.Args()[0], c.Args()[1])
		} else {
			if c.Bool("yes") == false {
				fmt.Print(h.T("envs.destroy.confirmation"))
				if askForConfirmation() == false {
					return nil
				}
			}
			build := client.Environment().Delete(c.Args()[0], c.Args()[1])
			h.Monitorize(client.Build().Stream(build.ID))
		}
		color.Green(h.T("envs.destroy.success"))
		return nil
	},
}

DestroyEnv command

var DetachPolicy = cli.Command{
	Name:        "detach",
	Usage:       h.T("policy.detach.usage"),
	ArgsUsage:   h.T("policy.detach.args"),
	Description: h.T("policy.detach.description"),
	Flags: []cli.Flag{
		tStringFlag("policy.detach.flags.name"),
		tStringFlag("policy.detach.flags.environment"),
	},
	Action: func(c *cli.Context) error {
		flags := parseTemplateFlags(c, map[string]flagDef{
			"policy-name": flagDef{typ: "string", req: true},
			"environment": flagDef{typ: "string", req: true},
		})
		client := esetup(c, AuthUsersValidation)
		env := flags["environment"].(string)
		parts := strings.Split(env, "/")
		if len(parts) != 2 {
			h.PrintError(h.T("policy.detach.errors.invalid_name"))
		}

		p := client.Policy().Get(flags["policy-name"].(string))
		_ = client.Environment().Get(parts[0], parts[1])
		var toBeAttached []string
		for _, v := range p.Environments {
			if v != env {
				toBeAttached = append(toBeAttached, v)
			}
		}
		if len(toBeAttached) == len(p.Environments) {
			h.T("policy.detach.error.not_attached")
		}
		p.Environments = toBeAttached
		client.Policy().Update(p)

		color.Green(fmt.Sprintf(h.T("policy.detach.success"), p.Name, env))
		return nil
	},
}

DetachPolicy : Display an existing policy

var DiffEnv = cli.Command{
	Name:        "diff",
	Aliases:     []string{"i"},
	Usage:       h.T("envs.diff.usage"),
	ArgsUsage:   h.T("envs.diff.args"),
	Description: h.T("envs.diff.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 4, "envs.diff.args")
		client := esetup(c, AuthUsersValidation)

		build1 := client.Build().BuildByPosition(c.Args()[0], c.Args()[1], c.Args()[2])
		build2 := client.Build().BuildByPosition(c.Args()[0], c.Args()[1], c.Args()[3])
		changelog := client.Build().Diff(c.Args()[0], c.Args()[1], build1.GetID(), build2.GetID())

		view.PrintDiff(changelog)

		return nil
	},
}

DiffEnv : Shows detailed information of an env by its name

var DisableMFA = cli.Command{
	Name:        "disable-mfa",
	Usage:       h.T("user.disable-mfa.usage"),
	Description: h.T("user.disable-mfa.description"),
	Flags: []cli.Flag{
		tStringFlagND("user.disable-mfa.flags.user"),
	},
	Action: func(c *cli.Context) error {
		client := esetup(c, NonAdminValidation)
		session := client.Session().Get()
		username := stringWithDefault(c, "user-name", session.Username)

		user := client.User().Get(username)
		if user.MFA == nil || !*user.MFA {
			fmt.Println("MFA already disabled")
			return nil
		}

		_ = client.User().ToggleMFA(user, false)
		color.Red("MFA disabled")

		return nil
	},
}

DisableMFA turns off Multi-Factor authentication

var DisableUser = cli.Command{
	Name:        "disable",
	Usage:       h.T("user.disable.usage"),
	ArgsUsage:   h.T("user.disable.args"),
	Description: h.T("user.disable.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "user.disable.args")
		client := esetup(c, NonAdminValidation)
		username := c.Args()[0]

		user := client.User().Get(username)
		user.Password = randString(16)
		user.Disabled = h.Bool(true)
		client.User().Update(user)

		color.Green("Account `" + username + "` has been disabled")
		return nil
	},
}

DisableUser : Will disable a user (change its password)

var EnableMFA = cli.Command{
	Name:        "enable-mfa",
	Usage:       h.T("user.enable-mfa.usage"),
	Description: h.T("user.enable-mfa.description"),
	Flags: []cli.Flag{
		tStringFlagND("user.enable-mfa.flags.user"),
	},
	Action: func(c *cli.Context) error {
		client := esetup(c, NonAdminValidation)
		session := client.Session().Get()
		username := stringWithDefault(c, "user-name", session.Username)

		user := client.User().Get(username)
		if user.MFA != nil && *user.MFA {
			fmt.Println("MFA already enabled")
			return nil
		}

		secret := client.User().ToggleMFA(user, true)
		color.Green("MFA enabled")
		fmt.Printf("Account name: Ernest (%s)\nKey: %s\n", user.Username, secret)

		return nil
	},
}

EnableMFA turns on Multi-Factor authentication

var EnvAddSchedule = cli.Command{
	Name:        "add",
	Aliases:     []string{"a"},
	Usage:       h.T("envs.schedule.add.usage"),
	ArgsUsage:   h.T("envs.schedule.add.args"),
	Description: h.T("envs.schedule.add.description"),
	Flags: []cli.Flag{
		tStringFlagND("envs.schedule.add.flags.action"),
		tStringFlagND("envs.schedule.add.flags.resolution"),
		tStringFlagND("envs.schedule.add.flags.instances"),
		tStringFlagND("envs.schedule.add.flags.schedule"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 3, "envs.schedule.list.args")
		client := esetup(c, AuthUsersValidation)

		env := client.Environment().Get(c.Args()[0], c.Args()[1])

		schedule := make(map[string]interface{}, 0)
		schedule["name"] = c.Args()[2]
		schedule["type"] = c.String("action")
		schedule["interval"] = c.String("schedule")

		switch c.String("action") {
		case "sync":
			resolution := c.String("resolution")
			if resolution == "" {
				resolution = "manual"
			}
			schedule["resolution"] = resolution
		case "power_on", "power_off":
			schedule["instances"] = strings.Split(c.String("instances"), ",")
		default:
			h.PrintError("unsupported action type: " + c.String("action"))
		}

		if env.Schedules == nil {
			env.Schedules = make(map[string]interface{}, 0)
		}

		env.Schedules[c.Args()[2]] = schedule
		client.Environment().Update(env)
		color.Green(h.T("envs.schedule.add.success"))

		return nil
	},
}

EnvAddSchedule : Appends a new schedule to a given environment

var EnvListSchedules = cli.Command{
	Name:        "list",
	Aliases:     []string{"a"},
	Usage:       h.T("envs.schedule.list.usage"),
	ArgsUsage:   h.T("envs.schedule.list.args"),
	Description: h.T("envs.schedule.list.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.schedule.list.args")
		client := esetup(c, AuthUsersValidation)

		env := client.Environment().Get(c.Args()[0], c.Args()[1])
		list := env.Schedules

		view.PrintScheduleList(list)
		return nil
	},
}

EnvListSchedules : Gets a list of env schedules

var EnvRmSchedule = cli.Command{
	Name:        "delete",
	Aliases:     []string{"a"},
	Usage:       h.T("envs.schedule.rm.usage"),
	ArgsUsage:   h.T("envs.schedule.rm.args"),
	Description: h.T("envs.schedule.rm.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.schedule.list.args")
		client := esetup(c, AuthUsersValidation)

		env := client.Environment().Get(c.Args()[0], c.Args()[1])
		delete(env.Schedules, c.Args()[2])

		client.Environment().Update(env)
		color.Green(h.T("envs.schedule.rm.success"))

		return nil
	},
}

EnvRmSchedule : Appends a new schedule to a given environment

var HistoryEnv = cli.Command{
	Name:        "history",
	Usage:       h.T("envs.history.usage"),
	ArgsUsage:   h.T("envs.history.args"),
	Description: h.T("envs.history.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.history.args")
		client := esetup(c, AuthUsersValidation)
		envs := client.Build().List(c.Args()[0], c.Args()[1])
		view.PrintEnvHistory(c.Args()[1], envs)
		return nil
	},
}

HistoryEnv command Shows the history of an env, a list of builds

var HistoryPolicy = cli.Command{
	Name:        "history",
	Usage:       h.T("policy.history.usage"),
	ArgsUsage:   h.T("policy.history.args"),
	Description: h.T("policy.history.description"),
	Flags: []cli.Flag{
		tStringFlag("policy.history.flags.name"),
	},
	Action: func(c *cli.Context) error {
		flags := parseTemplateFlags(c, map[string]flagDef{
			"policy-name": flagDef{typ: "string", req: true},
		})
		client := esetup(c, AuthUsersValidation)

		documents := client.Policy().ListDocuments(flags["policy-name"].(string))
		view.PrintPolicyHistory(documents)

		return nil
	},
}

HistoryPolicy : Display a policys revisions

var ImportEnv = cli.Command{
	Name:        "import",
	Aliases:     []string{"i"},
	Usage:       h.T("envs.import.usage"),
	ArgsUsage:   h.T("envs.import.args"),
	Description: h.T("envs.import.description"),
	Flags: []cli.Flag{
		tStringFlag("envs.import.flags.project"),
		tStringFlag("envs.import.flags.filters"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.import.args")
		client := esetup(c, AuthUsersValidation)

		var filters []string
		if c.String("filters") != "" {
			filters = strings.Split(c.String("filters"), ",")
		}

		env := emodels.Environment{
			Name:    c.Args()[1],
			Project: c.Args()[0],
		}
		client.Environment().Create(c.Args()[0], &env)
		a := client.Environment().Import(c.Args()[0], c.Args()[1], filters)
		h.Monitorize(client.Build().Stream(a.ResourceID))

		return nil
	},
}

ImportEnv : Shows detailed information of an env by its name

var Info = cli.Command{
	Name:        "info",
	Aliases:     []string{"i"},
	Usage:       h.T("info.usage"),
	ArgsUsage:   h.T("info.args"),
	Description: h.T("info.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, NoValidation)
		fmt.Println("Target:      " + client.Config().URL)
		fmt.Println("User:        " + client.Config().User)
		fmt.Println("CLI Version: " + c.App.Version)

		return nil
	},
}

Info command Shows the current ernest target instance information

var InfoEnv = cli.Command{
	Name:        "info",
	Aliases:     []string{"i"},
	Usage:       h.T("envs.info.usage"),
	ArgsUsage:   h.T("envs.info.args"),
	Description: h.T("envs.info.description"),
	Flags: []cli.Flag{
		tStringFlag("envs.info.flags.build"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.info.args")
		client := esetup(c, AuthUsersValidation)

		build := client.Build().BuildByPosition(c.Args()[0], c.Args()[1], c.String("build"))
		build = client.Build().Get(c.Args()[0], c.Args()[1], build.ID)
		env := client.Environment().Get(c.Args()[0], c.Args()[1])
		view.PrintEnvInfo(env, build)

		return nil
	},
}

InfoEnv : Shows detailed information of a env by its name

var InfoProject = cli.Command{
	Name:        "info",
	Usage:       h.T("project.info.usage"),
	ArgsUsage:   h.T("project.info.args"),
	Description: h.T("project.info.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "project.info.args")
		client := esetup(c, AuthUsersValidation)
		p := client.Project().Get(c.Args()[0])
		view.PrintProjectInfo(p)

		return nil
	},
}

InfoProject ...

var InfoUser = cli.Command{
	Name:        "info",
	Usage:       h.T("user.info.usage"),
	Description: h.T("user.info.description"),
	Flags: []cli.Flag{
		tStringFlag("user.info.flags.user"),
	},
	Action: func(c *cli.Context) error {
		client := esetup(c, NonAdminValidation)
		username := stringWithDefault(c, "user", client.Config().User)

		user := client.User().Get(username)
		view.PrintUserInfo(user)
		return nil
	},
}

InfoUser :

var ListEnvs = cli.Command{
	Name:        "list",
	Usage:       h.T("envs.list.usage"),
	ArgsUsage:   h.T("envs.list.args"),
	Description: h.T("envs.list.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)
		envs := client.Environment().ListAll()
		view.PrintEnvList(envs)

		return nil
	},
}

ListEnvs ...

var ListLoggers = cli.Command{
	Name:        "list",
	Usage:       h.T("logger.list.usage"),
	ArgsUsage:   h.T("logger.list.args"),
	Description: h.T("logger.list.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, NonAdminValidation)

		loggers := client.Logger().List()
		view.PrintLoggerList(loggers)

		return nil
	},
}

ListLoggers : Lists all loggers confured on ernest

var ListNotifications = cli.Command{
	Name:        "list",
	Usage:       h.T("notification.list.usage"),
	ArgsUsage:   h.T("notification.list.args"),
	Description: h.T("notification.list.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)
		notifications := client.Notification().List()

		view.PrintNotificationList(notifications)

		return nil
	},
}

ListNotifications ...

var ListPolicies = cli.Command{
	Name:        "list",
	Usage:       h.T("policy.list.usage"),
	ArgsUsage:   h.T("policy.list.args"),
	Description: h.T("policy.list.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)
		policies := client.Policy().List()

		view.PrintPolicyList(policies)

		return nil
	},
}

ListPolicies ...

var ListProjects = cli.Command{
	Name:        "list",
	Usage:       h.T("project.list.usage"),
	ArgsUsage:   h.T("project.list.args"),
	Description: h.T("project.list.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)
		projects := client.Project().List()
		view.PrintProjectList(projects)

		return nil
	},
}

ListProjects ...

var ListUsers = cli.Command{
	Name:        "list",
	Usage:       h.T("user.list.usage"),
	ArgsUsage:   h.T("user.list.args"),
	Description: h.T("user.list.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)
		users := client.User().List()
		view.PrintUserList(users)

		return nil
	},
}

ListUsers : Gets a list of accessible users

var LoggerCommands = cli.Command{
	Name:        "logger",
	Usage:       "Setup logger preferences.",
	Description: "Setup ernest logger preferenres.",
	Subcommands: []cli.Command{
		ListLoggers,
		SetLogger,
		DelLogger,
	},
}

LoggerCommands : Logger related commands

var Login = cli.Command{
	Name:        "login",
	Aliases:     []string{"l"},
	Usage:       h.T("login.usage"),
	ArgsUsage:   h.T("login.args"),
	Description: h.T("login.description"),
	Flags: []cli.Flag{
		tStringFlag("login.flags.user"),
		tStringFlag("login.flags.password"),
		tStringFlag("login.flags.verification"),
	},
	Action: func(c *cli.Context) error {
		var username string
		var password string
		var verificationCode string

		if c.String("user") == "" {
			if os.Getenv("ERNEST_USER") != "" {
				username = os.Getenv("ERNEST_USER")
			} else {
				fmt.Printf("Username: ")
				_, err := fmt.Scanln(&username)
				if err != nil {
					fmt.Fprintf(os.Stderr, "ERROR: %v\n", err)
				}
			}
		} else {
			username = c.String("user")
		}

		if c.String("password") == "" {
			if os.Getenv("ERNEST_PASSWORD") != "" {
				password = os.Getenv("ERNEST_PASSWORD")
			} else {
				fmt.Printf("Password: ")
				if runtime.GOOS == "windows" {
					_, err := fmt.Scanln(&password)
					if err != nil {
						fmt.Fprintf(os.Stderr, "ERROR: %v\n", err)
					}
				} else {
					pass, _ := gopass.GetPasswdMasked()
					password = string(pass)
				}
			}
		} else {
			password = c.String("password")
		}

		verificationCode = c.String("verification-code")
		client := elogin(username, password, verificationCode)
		token, err := client.Cli().Authenticate()

		if err != nil && err.Error() == "mfa required" {
			fmt.Printf("Verification code: ")
			vc, _ := gopass.GetPasswdMasked()
			verificationCode = string(vc)

			client = elogin(username, password, verificationCode)
			token, err = client.Cli().Authenticate()
		}

		if err != nil {
			h.PrintError(err.Error())
		}

		cfg := client.Config()
		cfg.Token = token

		if err := model.SaveConfig(client.Config()); err != nil {
			h.PrintError("Can't write config file")
		}

		color.Green("Welcome back " + username)

		return nil
	},
}

Login command Login with your Ernest credentials

var Logout = cli.Command{
	Name:        "logout",
	Usage:       h.T("logout.usage"),
	ArgsUsage:   h.T("logout.args"),
	Description: h.T("logout.description"),
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)

		cfg := client.Config()
		cfg.Token = ""
		cfg.User = ""
		if err := model.SaveConfig(cfg); err != nil {
			h.PrintError(h.T("logout.errors.write"))
		}
		color.Green(h.T("logout.success"))
		return nil
	},
}

Logout command Clear local authentication credentials

var MonitorEnv = cli.Command{
	Name:        "monitor",
	Aliases:     []string{"m"},
	Usage:       h.T("monitor.usage"),
	ArgsUsage:   h.T("monitor.args"),
	Description: h.T("monitor.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "monitor.args")
		client := esetup(c, AuthUsersValidation)

		build := client.Build().BuildByPosition(c.Args()[0], c.Args()[1], "")

		if build.Status == "done" {
			color.Yellow(h.T("monitor.success_1"))
			color.Yellow(fmt.Sprintf(h.T("monitor.success_2"), c.Args()[0], c.Args()[1]))
			return nil
		}
		return h.Monitorize(client.Build().Stream(build.ID))
	},
}

MonitorEnv command Monitorizes an environment and shows the actions being performed on it

var NoValidation = []string{}

NoValidation ...

var NonAdminValidation = []string{NonEmptuTokenVal, NonAdminVal}

NonAdminValidation ...

var PasswordUser = cli.Command{
	Name:        "change-password",
	Usage:       h.T("user.change_password.usage"),
	Description: h.T("user.change_password.description"),
	Flags: []cli.Flag{
		tStringFlag("user.change_password.flags.user"),
		tStringFlag("user.change_password.flags.password"),
		tStringFlag("user.change_password.flags.current-password"),
	},
	Action: func(c *cli.Context) error {
		client := esetup(c, AuthUsersValidation)
		session := client.Session().Get()

		username := c.String("user")
		password := c.String("password")
		currentPassword := c.String("current-password")

		if !session.IsAdmin() && username != "" {
			h.PrintError("You don’t have permissions to perform this action")
		}

		if session.IsAdmin() && username != "" {

			if password == "" {
				h.PrintError("Please provide a valid password for the user with `--password`")
			}
			user := client.User().Get(username)
			user.Password = password
			user.Disabled = h.Bool(false)
			client.User().Update(user)
			color.Green("`" + username + "` password has been changed")

		} else {

			users := client.User().List()
			if len(users) == 0 {
				h.PrintError("You don’t have permissions to perform this action")
			}

			oldpassword := currentPassword
			newpassword := password
			rnewpassword := password

			if oldpassword == "" || newpassword == "" {
				fmt.Printf("You're about to change your password, please respond the questions below: \n")
				fmt.Printf("Current password: ")
				opass, _ := gopass.GetPasswdMasked()
				oldpassword = string(opass)

				fmt.Printf("New password: ")
				npass, _ := gopass.GetPasswdMasked()
				newpassword = string(npass)

				fmt.Printf("Confirm new password: ")
				rnpass, _ := gopass.GetPasswdMasked()
				rnewpassword = string(rnpass)
			}

			if newpassword != rnewpassword {
				h.PrintError("Aborting... New password and confirmation doesn't match.")
			}

			username := client.Config().User
			user := client.User().Get(username)
			user.Password = newpassword
			user.OldPassword = oldpassword
			user.Disabled = h.Bool(false)
			client.User().Update(user)

			color.Green("Your password has been changed")
		}

		return nil
	},
}

PasswordUser : Allows users or admins to change its passwords

var ProviderAWSFlags = []cli.Flag{
	tStringFlag("aws.create.flags.region"),
	tStringFlag("aws.create.flags.access_key_id"),
	tStringFlag("aws.create.flags.secret_access_key"),
}

ProviderAWSFlags : ...

var ProviderAzureFlags = []cli.Flag{
	tStringFlag("azure.update.flags.subscription_id"),
	tStringFlag("azure.update.flags.client_id"),
	tStringFlag("azure.update.flags.client_secret"),
	tStringFlag("azure.update.flags.tenant_id"),
	tStringFlag("azure.update.flags.environment"),
}

ProviderAzureFlags : ...

var ProviderVCloudFlags = []cli.Flag{
	tStringFlag("vcloud.create.flags.user"),
	tStringFlag("vcloud.create.flags.password"),
	tStringFlag("vcloud.create.flags.org"),
	tStringFlag("vcloud.create.flags.vse-url"),
	tStringFlag("vcloud.create.flags.vcloud-url"),
	tStringFlag("vcloud.create.flags.public-network"),
	tStringFlag("vcloud.create.flags.vcloud-region"),
}

ProviderVCloudFlags : ..

var ResetEnv = cli.Command{
	Name:        "reset",
	Usage:       h.T("envs.reset.usage"),
	ArgsUsage:   h.T("envs.reset.args"),
	Description: h.T("envs.reset.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.reset.args")
		client := esetup(c, AuthUsersValidation)
		client.Environment().Reset(c.Args()[0], c.Args()[1])
		color.Red(fmt.Sprintf(h.T("envs.reset.success"), c.Args()[0], c.Args()[1]))
		return nil
	},
}

ResetEnv command

var ResetMFA = cli.Command{
	Name:        "reset-mfa",
	Usage:       h.T("user.reset-mfa.usage"),
	Description: h.T("user.reset-mfa.description"),
	Flags: []cli.Flag{
		tStringFlagND("user.reset-mfa.flags.user"),
	},
	Action: func(c *cli.Context) error {
		client := esetup(c, NonAdminValidation)
		session := client.Session().Get()
		username := stringWithDefault(c, "user-name", session.Username)
		user := client.User().Get(username)

		_ = client.User().ToggleMFA(user, false)
		secret := client.User().ToggleMFA(user, true)

		color.Green("MFA reset")
		fmt.Printf("Account name: Ernest (%s)\nKey: %s\n", user.Username, secret)

		return nil
	},
}

ResetMFA generates a new secret for Multi-Factor authentication

var ResolveEnv = cli.Command{
	Name:        "resolve",
	Aliases:     []string{"r"},
	Usage:       h.T("envs.resolve.usage"),
	ArgsUsage:   h.T("envs.resolve.args"),
	Description: h.T("envs.resolve.description"),
	Flags: append([]cli.Flag{
		tBoolFlag("envs.resolve.flags.accept"),
		tBoolFlag("envs.resolve.flags.reject"),
		tBoolFlag("envs.resolve.flags.ignore"),
	}),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.resolve.args")
		client := esetup(c, AuthUsersValidation)

		project := c.Args()[0]
		env := c.Args()[1]

		var resolution string
		if c.Bool("accept") {
			resolution = "accept-changes"
		}
		if c.Bool("reject") {
			resolution = "reject-changes"
		}
		if c.Bool("ignore") {
			resolution = "ignore-changes"
		}

		if resolution == "" {
			builds := client.Build().List(project, env)

			b1 := buildIDFromIndex(builds, strconv.Itoa(len(builds)-1))
			b2 := buildIDFromIndex(builds, strconv.Itoa(len(builds)))

			changelog := client.Build().Diff(project, env, b1.ID, b2.ID)
			view.PrintDiff(changelog)
			fmt.Printf("\n\n")
			view.PrintValidation(b2.Validation)

			return nil
		}

		action := client.Environment().Resolve(c.Args()[0], c.Args()[1], resolution)
		if action.ResourceID != "" {
			h.Monitorize(client.Build().Stream(action.ResourceID))
		}

		return nil
	},
}

ResolveEnv command Resolves an issue that requires user input

var RevertEnv = cli.Command{
	Name:        "revert",
	Usage:       h.T("envs.revert.usage"),
	ArgsUsage:   h.T("envs.revert.args"),
	Description: h.T("envs.revert.description"),
	Flags: []cli.Flag{
		tBoolFlag("envs.revert.flags.dry"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 3, "envs.revert.args")
		client := esetup(c, AuthUsersValidation)
		builds := client.Build().List(c.Args()[0], c.Args()[1])
		build := getBuildByPosition(c.Args()[2], builds)
		def := client.Build().Definition(c.Args()[0], c.Args()[1], build.ID)

		if c.Bool("dry") == true {
			view.EnvDry(*client.Build().Dry([]byte(def)))
		} else {
			build := client.Build().Create([]byte(def))
			if build.Status == "submitted" {
				color.Green(h.T("envs.revert.success"))
				os.Exit(0)
			}

			h.Monitorize(client.Build().Stream(build.ID))
		}

		return nil
	},
}

RevertEnv command

var ReviewEnv = cli.Command{
	Name:        "review",
	Aliases:     []string{"rev"},
	Usage:       h.T("envs.review.usage"),
	ArgsUsage:   h.T("envs.review.args"),
	Description: h.T("envs.review.description"),
	Flags: append([]cli.Flag{
		tBoolFlag("envs.review.flags.accept"),
		tBoolFlag("envs.review.flags.reject"),
	}),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.review.args")
		client := esetup(c, AuthUsersValidation)

		project := c.Args()[0]
		env := c.Args()[1]

		var resolution string
		if c.Bool("accept") {
			resolution = "submission-accepted"
		}
		if c.Bool("reject") {
			resolution = "submission-rejected"
		}

		if resolution == "" {
			builds := client.Build().List(project, env)
			b2 := buildIDFromIndex(builds, strconv.Itoa(len(builds)))

			changelog := client.Build().Changelog(project, env, b2.ID)
			view.PrintDiff(changelog)

			return nil
		}

		action := client.Environment().Review(project, env, resolution)
		if action.ResourceID != "" {
			h.Monitorize(client.Build().Stream(action.ResourceID))
			view.PrintEnvInfo(
				client.Environment().Get(project, env),
				client.Build().Get(project, env, action.ResourceID),
			)
		}

		return nil
	},
}

ReviewEnv command Approval for outstanding build submissions

var RmAdminUser = cli.Command{
	Name:        "rm",
	Usage:       h.T("user.admin.rm.usage"),
	Description: h.T("user.admin.rm.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "user.admin.rm.args")

		client := esetup(c, NonAdminValidation)
		username := c.Args()[0]

		user := client.User().Get(username)
		user.Admin = false
		client.User().Update(user)

		color.Green("Admin privileges revoked from user " + username)
		return nil
	},
}

RmAdminUser :

var RmEntityToNotification = cli.Command{
	Name:        "remove",
	Usage:       h.T("notification.service.rm.usage"),
	ArgsUsage:   h.T("notification.service.rm.args"),
	Description: h.T("notification.service.rm.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "notification.service.rm.args")

		notification := c.Args()[0]
		project := c.Args()[1]
		client := esetup(c, AuthUsersValidation)
		entity := project
		if len(c.Args()) > 2 {
			entity = entity + "/" + c.Args()[2]
			client.Notification().RmEnv(notification, project, c.Args()[2])
		} else {
			client.Notification().RmProject(notification, project)
		}

		color.Green(fmt.Sprintf(h.T("notification.service.rm.success"), entity, notification))
		return nil
	},
}

RmEntityToNotification : Creates a new user

var ScheduleEnv = cli.Command{
	Name:    "schedule",
	Aliases: []string{"sch"},
	Usage:   "Scheduling environment related subcommands",
	Subcommands: []cli.Command{
		EnvListSchedules,
		EnvAddSchedule,
		EnvRmSchedule,
	},
}

ScheduleEnv ...

var SetLogger = cli.Command{
	Name:        "add",
	Usage:       h.T("logger.set.usage"),
	ArgsUsage:   h.T("logger.set.args"),
	Description: h.T("logger.set.description"),
	Flags: []cli.Flag{
		tStringFlag("logger.set.flags.logfile"),
		tStringFlag("logger.set.flags.token"),
		tStringFlag("logger.set.flags.env"),
		tStringFlag("logger.set.flags.hostname"),
		tIntFlag("logger.set.flags.port"),
		tIntFlag("logger.set.flags.timeout"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "logger.set.args")
		client := esetup(c, NonAdminValidation)

		logger := emodels.Logger{
			Type:        c.Args()[0],
			Logfile:     c.String("logfile"),
			Hostname:    c.String("hostname"),
			Port:        c.Int("port"),
			Timeout:     c.Int("timeout"),
			Token:       c.String("token"),
			Environment: c.String("env"),
		}
		if logger.Type == "basic" {
			if logger.Logfile == "" {
				h.PrintError(h.T("logger.set.errors.logfile"))
			}
		} else if logger.Type == "logstash" {
			if logger.Hostname == "" {
				h.PrintError(h.T("logger.set.errors.hostname"))
			}
			if logger.Port == 0 {
				h.PrintError(h.T("logger.set.errors.port"))
			}
			if logger.Timeout == 0 {
				h.PrintError(h.T("logger.set.errors.timeout"))
			}
		} else if logger.Type == "rollbar" {
			if logger.Token == "" {
				h.PrintError(h.T("logger.set.errors.token"))
			}
			if logger.Environment == "" {
				logger.Environment = "development"
			}
		} else {
			color.Red(h.T("logger.set.errors.type"))
			return nil
		}

		client.Logger().Create(&logger)
		color.Green(h.T("logger.set.success"))

		return nil
	},
}

SetLogger : Creates / updates a looger based on it type

var ShowPolicy = cli.Command{
	Name:        "show",
	Usage:       h.T("policy.show.usage"),
	ArgsUsage:   h.T("policy.show.args"),
	Description: h.T("policy.show.description"),
	Flags: []cli.Flag{
		tStringFlag("policy.show.flags.name"),
		tStringFlag("policy.show.flags.revision"),
	},
	Action: func(c *cli.Context) error {
		flags := parseTemplateFlags(c, map[string]flagDef{
			"policy-name": flagDef{typ: "string", req: true},
			"revision":    flagDef{typ: "string", req: true},
		})
		client := esetup(c, AuthUsersValidation)

		n := client.Policy().GetDocument(flags["policy-name"].(string), flags["revision"].(string))
		fmt.Println(n.Definition)
		return nil
	},
}

ShowPolicy : Display an existing policy

var SyncEnv = cli.Command{
	Name:        "sync",
	Aliases:     []string{"s"},
	Usage:       h.T("envs.sync.usage"),
	ArgsUsage:   h.T("envs.sync.args"),
	Description: h.T("envs.sync.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.sync.args")
		client := esetup(c, AuthUsersValidation)

		project := c.Args()[0]
		env := c.Args()[1]

		action := client.Environment().Sync(project, env)
		if action.ResourceID == "" {
			return nil
		}

		stream := client.Build().Stream(action.ResourceID)
		for {
			var m map[string]interface{}

			msg, ok := <-stream
			if !ok {
				h.PrintError("could not monitor sync progress")
			}

			if msg == nil {
				continue
			}

			if json.Unmarshal(msg, &m) != nil {
				h.PrintError("could not parse response")
			}

			if m["_subject"].(string) == "build.import.done" {
				break
			}
		}

		time.Sleep(time.Second)

		build := client.Build().Get(project, env, action.ResourceID)

		switch build.Status {
		case "done":
			color.Green("No changes detected")
		case "awaiting_resolution":
			color.Red("Changes detected")
			fmt.Println("")

			builds := client.Build().List(project, env)

			b1 := buildIDFromIndex(builds, strconv.Itoa(len(builds)-1))
			b2 := buildIDFromIndex(builds, strconv.Itoa(len(builds)))

			changelog := client.Build().Diff(project, env, b1.ID, b2.ID)
			if len(*changelog) == 0 {
				color.Green("There are no changes detected")
				return nil
			}

			color.Red("If rejected, ernest will action the following changes:")

			view.PrintDiff(changelog)
		case "errored":
			color.Red("Sync failed!")
		}

		return nil
	},
}

SyncEnv command Syncs an environment with the cloud provider

var Target = cli.Command{
	Name:        "target",
	Aliases:     []string{"t"},
	Usage:       h.T("target.usage"),
	ArgsUsage:   h.T("target.args"),
	Description: h.T("target.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "target.args")
		cfg := esetup(c, NoValidation).Config()

		cfg.URL = c.Args()[0]
		persistTarget(cfg)

		color.Green("Target set")
		return nil
	},
}

Target command Configures the ernest target instance

var UpdateAWSProject = cli.Command{
	Name:        "aws",
	Usage:       h.T("aws.update.usage"),
	ArgsUsage:   h.T("aws.update.args"),
	Description: h.T("aws.update.description"),
	Flags: []cli.Flag{
		tStringFlag("aws.update.flags.access_key_id"),
		tStringFlag("aws.update.flags.secret_access_key"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "aws.create.args")
		client := esetup(c, AuthUsersValidation)

		creds := parseTemplateFlags(c, map[string]flagDef{
			"access_key_id":     flagDef{typ: "string", mapto: "aws_access_key_id"},
			"secret_access_key": flagDef{typ: "string", mapto: "aws_secret_access_key"},
		})

		n := client.Project().Get(c.Args()[0])
		n.Credentials = creds
		client.Project().Update(n)
		color.Green(fmt.Sprintf(h.T("aws.update.success"), n.Name))

		return nil
	},
}

UpdateAWSProject : Updates the specified VCloud project

var UpdateAzureProject = cli.Command{
	Name:        "azure",
	Usage:       h.T("azure.update.usage"),
	Description: h.T("azure.update.description"),
	ArgsUsage:   h.T("azure.update.args"),
	Flags: []cli.Flag{
		tStringFlag("azure.update.flags.subscription_id"),
		tStringFlag("azure.update.flags.client_id"),
		tStringFlag("azure.update.flags.client_secret"),
		tStringFlag("azure.update.flags.tenant_id"),
		tStringFlag("azure.update.flags.environment"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "azure.update.args")
		client := esetup(c, AuthUsersValidation)

		creds := parseTemplateFlags(c, map[string]flagDef{
			"subscription_id": flagDef{typ: "string", mapto: "azure_subscription_id"},
			"client_id":       flagDef{typ: "string", mapto: "azure_client_id"},
			"client_secret":   flagDef{typ: "string", mapto: "azure_client_secret"},
			"tenant_id":       flagDef{typ: "string", mapto: "azure_tenant_id"},
			"environment":     flagDef{typ: "string", mapto: "azure_environment"},
		})

		n := client.Project().Get(c.Args()[0])
		n.Credentials = creds
		client.Project().Update(n)
		color.Green(fmt.Sprintf(h.T("azure.update.success"), n.Name))

		return nil
	},
}

UpdateAzureProject : Updates the specified VCloud project

var UpdateEnv = cli.Command{
	Name:        "update",
	Aliases:     []string{"a"},
	Usage:       h.T("envs.update.usage"),
	ArgsUsage:   h.T("envs.update.args"),
	Description: h.T("envs.update.description"),
	Flags: append([]cli.Flag{
		tStringFlagND("envs.update.flags.submissions"),
	}, AllProviderFlags...),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.update.args")
		client := esetup(c, AuthUsersValidation)
		env := client.Environment().Get(c.Args()[0], c.Args()[1])
		env.Credentials = ProviderFlagsToSlice(c)
		env.Options = MapEnvOptions(c, env.Options)
		client.Environment().Update(env)
		color.Green("Environment successfully updated")

		return nil
	},
}

UpdateEnv : Creates an empty environment based on a name and a project name

var UpdateNotification = cli.Command{
	Name:        "update",
	Usage:       h.T("notification.update.usage"),
	ArgsUsage:   h.T("notification.update.args"),
	Description: h.T("notification.update.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "notification.update.args")
		client := esetup(c, AuthUsersValidation)
		name := c.Args()[0]
		notificationConfig := c.Args()[1]

		n := client.Notification().Get(name)
		n.Config = notificationConfig
		client.Notification().Update(n)
		color.Green(fmt.Sprintf(h.T("notification.update.success"), name))
		return nil
	},
}

UpdateNotification : Will update the notification specific fields

var UpdatePolicy = cli.Command{
	Name:        "update",
	Usage:       h.T("policy.update.usage"),
	ArgsUsage:   h.T("policy.update.args"),
	Description: h.T("policy.update.description"),
	Flags: []cli.Flag{
		tStringFlag("policy.update.flags.name"),
		tStringFlag("policy.update.flags.spec"),
	},
	Action: func(c *cli.Context) error {
		flags := parseTemplateFlags(c, map[string]flagDef{
			"policy-name": flagDef{typ: "string", req: true},
			"spec":        flagDef{typ: "string", req: true},
		})
		client := esetup(c, AuthUsersValidation)
		name := flags["policy-name"].(string)
		spec, err := ioutil.ReadFile(flags["spec"].(string))
		if err != nil {
			h.PrintError(h.T("policy.update.errors.spec"))
		}

		client.Policy().CreateDocument(name, string(spec))
		color.Green(fmt.Sprintf(h.T("policy.update.success"), name))
		return nil
	},
}

UpdatePolicy : Will update the policy specific fields

var UpdateProjects = cli.Command{
	Name:        "update",
	Usage:       "Updates an existing project.",
	Description: "Update an existing project on the targeted instance of Ernest.",
	Subcommands: []cli.Command{
		UpdateVCloudProject,
		UpdateAWSProject,
		UpdateAzureProject,
	},
}

UpdateProjects : Will update the project specific fields

var UpdateVCloudProject = cli.Command{
	Name:        "vcloud",
	Usage:       h.T("vcloud.update.usage"),
	ArgsUsage:   h.T("vcloud.update.args"),
	Description: h.T("vcloud.update.description"),
	Flags: []cli.Flag{
		stringFlag("user", "", "Your VCloud valid user name"),
		stringFlag("password", "", "Your VCloud valid password"),
		stringFlag("org", "", "Your vCloud Organization"),
	},
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 1, "vcloud.update.args")
		client := esetup(c, AuthUsersValidation)

		creds := parseTemplateFlags(c, map[string]flagDef{
			"user":     flagDef{typ: "string"},
			"org":      flagDef{typ: "string"},
			"password": flagDef{typ: "string"},
		})
		creds["user"] = creds["user"].(string) + "@" + creds["org"].(string)

		n := client.Project().Get(c.Args()[0])
		n.Credentials["user"] = creds["user"].(string)
		n.Credentials["passwrord"] = creds["password"].(string)
		client.Project().Update(n)
		color.Green(fmt.Sprintf(h.T("vcloud.update.success"), n.Name))

		return nil
	},
}

UpdateVCloudProject : Updates the specified VCloud project

var ValidateEnv = cli.Command{
	Name:        "validate",
	Usage:       h.T("envs.validate.usage"),
	ArgsUsage:   h.T("envs.validate.args"),
	Description: h.T("envs.validate.description"),
	Action: func(c *cli.Context) error {
		paramsLenValidation(c, 2, "envs.validate.args")
		client := esetup(c, AuthUsersValidation)

		project := c.Args()[0]
		env := c.Args()[1]

		validation := client.Environment().Validate(project, env)

		view.PrintValidation(validation)

		return nil
	},
}

ValidateEnv command Validates an issue that requires user input

Functions

func Elogin

func Elogin(usr, pwd, vc string) *manager.Client

Elogin : logs in

func Esetup

func Esetup(c *cli.Context, vals []string) *manager.Client

Esetup : sets up connection to ernest

func MapEnvOptions

func MapEnvOptions(c *cli.Context, opts map[string]interface{}) map[string]interface{}

MapEnvOptions : maps environment options from cli context

func ProviderFlagsToSlice

func ProviderFlagsToSlice(c *cli.Context) map[string]interface{}

ProviderFlagsToSlice :

Types

type NullWriter

type NullWriter int

NullWriter to disable logging

func (NullWriter) Write

func (NullWriter) Write([]byte) (int, error)

Write sends to nowhere the log messages