cmd

package
v0.29.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 22, 2024 License: Apache-2.0 Imports: 29 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	GithubIntegrationOAuthToken = "github_token"
	GithubIntegrationApp        = "github_app"
)

Variables

View Source 
var (
	ReleaseVersion = "dev"
	ReleaseCommit  = "none"
	ReleaseDate    = "unknown"
)
View Source 
var CreateAgentTypeCmd = &cobra.Command{
	Use:     "agent_type [NAME]",
	Short:   "Create a self-hosted agent type.",
	Long:    ``,
	Aliases: []string{"agenttype", "agentType"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		nameAssignmentOrigin, err := cmd.Flags().GetString("name-assignment-origin")
		utils.Check(err)

		if !utils.Contains(models.SelfHostedAgentTypeAssignmentOrigins, nameAssignmentOrigin) {
			fmt.Printf("invalid name assignment origin '%s'\n", nameAssignmentOrigin)
			os.Exit(1)
		}

		releaseNameAfter, err := cmd.Flags().GetInt64("release-name-after")
		utils.Check(err)

		c := client.NewAgentTypeApiV1AlphaApi()
		at := models.NewAgentTypeV1Alpha(name)
		at.Spec.AgentNameSettings = models.AgentTypeV1AlphaAgentNameSettings{
			AssignmentOrigin: nameAssignmentOrigin,
			ReleaseAfter:     releaseNameAfter,
		}

		accountID, err := cmd.Flags().GetString("aws-account-id")
		utils.Check(err)

		roles, err := cmd.Flags().GetString("aws-roles")
		utils.Check(err)

		at.Spec.AgentNameSettings.Aws = models.AgentTypeV1AlphaAws{
			AccountID:        accountID,
			RoleNamePatterns: roles,
		}

		agentType, err := c.CreateAgentType(&at)
		utils.Check(err)

		y, err := agentType.ToYaml()
		utils.Check(err)
		fmt.Printf("%s", y)
	},
}
View Source 
var CreateDashboardCmd = &cobra.Command{
	Use:     "dashboard [NAME]",
	Short:   "Create a dashboard.",
	Long:    ``,
	Aliases: []string{"dashboard", "dash"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		c := client.NewDashboardV1AlphaApi()

		dash := models.NewDashboardV1Alpha(name)
		_, err := c.CreateDashboard(&dash)

		utils.Check(err)

		fmt.Printf("Dashboard '%s' created.\n", dash.Metadata.Name)
	},
}
View Source 
var CreateWorkflowCmd = &cobra.Command{
	Use:     "workflow [NAME]",
	Short:   "Create a workflow from snapshot.",
	Long:    ``,
	Aliases: []string{"workflows", "wf"},
	Args:    cobra.ExactArgs(0),

	Run: func(cmd *cobra.Command, args []string) {
		projectName, err := cmd.Flags().GetString("project-name")
		utils.Check(err)

		archiveName, err := cmd.Flags().GetString("archive")
		utils.Check(err)

		follow, err := cmd.Flags().GetBool("follow")
		utils.Check(err)

		if projectName == "" {
			projectName, err = utils.InferProjectName()
			utils.Check(err)
		}

		label, err := cmd.Flags().GetString("label")
		utils.Check(err)

		createSnapshot(projectName, label, archiveName, follow)
	},
}
View Source 
var DeleteAgentTypeCmd = &cobra.Command{
	Use:     "agent_type [NAME]",
	Short:   "Delete a self-hosted agent type.",
	Long:    ``,
	Aliases: []string{"agenttype", "agentType"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]
		c := client.NewAgentTypeApiV1AlphaApi()
		err := c.DeleteAgentType(name)
		utils.Check(err)

		fmt.Printf("Self-hosted agent type '%s' deleted.\n", name)
	},
}
View Source 
var DeleteDashboardCmd = &cobra.Command{
	Use:     "dashboard [NAME]",
	Short:   "Delete a dashboard.",
	Long:    ``,
	Aliases: []string{"dashboards", "dash"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		c := client.NewDashboardV1AlphaApi()

		err := c.DeleteDashboard(name)

		utils.Check(err)

		fmt.Printf("Dashboard '%s' deleted.\n", name)
	},
}
View Source 
var DeleteNotificationCmd = &cobra.Command{
	Use:     "notification [NAME]",
	Short:   "Delete a notification.",
	Long:    ``,
	Aliases: []string{"notifications", "notif", "notifs"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		c := client.NewNotificationsV1AlphaApi()

		err := c.DeleteNotification(name)

		utils.Check(err)

		fmt.Printf("Notification '%s' deleted.\n", name)
	},
}
View Source 
var DeleteProjectCmd = &cobra.Command{
	Use:     "project [NAME]",
	Short:   "Delete a project.",
	Long:    ``,
	Aliases: []string{"projects", "prj"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		c := client.NewProjectV1AlphaApi()

		err := c.DeleteProject(name)

		utils.Check(err)

		fmt.Printf("Project '%s' deleted.\n", name)
	},
}
View Source 
var DeleteSecretCmd = &cobra.Command{
	Use:     "secret [NAME]",
	Short:   "Delete a secret.",
	Long:    `Delete a organization or project secret. To delete a project secret, use the --project-name or --project-id flag.`,
	Aliases: []string{"secrets"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		projectID := GetProjectID(cmd)

		if projectID == "" {
			name := args[0]

			c := client.NewSecretV1BetaApi()

			err := c.DeleteSecret(name)

			utils.Check(err)

			fmt.Printf("Secret '%s' deleted.\n", name)
		} else {
			name := args[0]
			c := client.NewProjectSecretV1Api(projectID)

			err := c.DeleteSecret(name)

			utils.Check(err)

			fmt.Printf("Secret '%s' deleted.\n", name)
		}
	},
}
View Source 
var EditDashboardCmd = &cobra.Command{
	Use:     "dashboard [name]",
	Short:   "Edit a dashboard.",
	Long:    ``,
	Aliases: []string{"dashboards", "dash"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		c := client.NewDashboardV1AlphaApi()

		dashboard, err := c.GetDashboard(name)

		utils.Check(err)

		content, err := dashboard.ToYaml()

		utils.Check(err)

		new_content, err := utils.EditYamlInEditor(dashboard.ObjectName(), string(content))

		utils.Check(err)

		updated_dashboard, err := models.NewDashboardV1AlphaFromYaml([]byte(new_content))

		utils.Check(err)

		dashboard, err = c.UpdateDashboard(updated_dashboard)

		utils.Check(err)

		fmt.Printf("Dashboard '%s' updated.\n", dashboard.Metadata.Name)
	},
}
View Source 
var EditDeploymentTargetCmd = &cobra.Command{
	Use:     "deployment_target [id or name]",
	Short:   "Edit a deployment target.",
	Long:    ``,
	Aliases: models.DeploymentTargetCmdAliases,
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		c := client.NewDeploymentTargetsV1AlphaApi()
		targetName, err := cmd.Flags().GetString("name")
		utils.Check(err)
		targetId, err := cmd.Flags().GetString("id")
		utils.Check(err)
		if len(args) == 1 {
			if uuid.IsValid(args[0]) {
				targetId = args[0]
			} else {
				targetName = args[0]
			}
		}
		shouldActivate, err := cmd.Flags().GetBool("activate")
		utils.Check(err)
		shouldDeactivate, err := cmd.Flags().GetBool("deactivate")
		utils.Check(err)

		var target *models.DeploymentTargetV1Alpha
		if targetId != "" {
			if !shouldActivate && !shouldDeactivate {
				target, err = c.DescribeWithSecrets(targetId)
			}
		} else if targetName != "" {
			target, err = c.DescribeByName(targetName, getPrj(cmd))
			if err == nil && target != nil {
				target, err = c.DescribeWithSecrets(target.Id)
			}
		} else {
			err = errors.New("target id or target name must be provided")
		}
		utils.Check(err)
		if target != nil {
			targetId = target.Id
		}
		if shouldActivate {
			succeeded, err := c.Activate(targetId)
			utils.Check(err)
			if !succeeded {
				utils.Check(errors.New("the deployment target wasn't activated successfully"))
			} else {
				fmt.Printf("The deployment target '%s' is active.\n", targetId)
				return
			}
		} else if shouldDeactivate {
			succeeded, err := c.Deactivate(targetId)
			utils.Check(err)
			if !succeeded {
				utils.Check(errors.New("the deployment target wasn't deactivated successfully"))
			} else {
				fmt.Printf("The deployment target '%s' is inactive.\n", targetId)
				return
			}
		}
		if target == nil {
			utils.Check(errors.New("valid target could not be retrieved"))
		}

		request := models.DeploymentTargetUpdateRequestV1Alpha{
			DeploymentTargetV1Alpha: *target,
		}
		content, err := request.ToYaml()
		utils.Check(err)

		new_content, err := utils.EditYamlInEditor(request.ObjectName(), string(content))
		utils.Check(err)

		changedTarget, err := models.NewDeploymentTargetV1AlphaFromYaml([]byte(new_content))
		utils.Check(err)
		utils.Check(changedTarget.LoadFiles())

		updateRequest := &models.DeploymentTargetUpdateRequestV1Alpha{
			DeploymentTargetV1Alpha: *changedTarget,
		}

		updatedTarget, err := c.Update(updateRequest)
		utils.Check(err)

		fmt.Printf("Deployment target '%s' updated.\n", updatedTarget.Name)
	},
}
View Source 
var EditNotificationCmd = &cobra.Command{
	Use:     "notification [name]",
	Short:   "Edit a notification.",
	Long:    ``,
	Aliases: []string{"notifications", "notifs", "notif"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		c := client.NewNotificationsV1AlphaApi()

		notif, err := c.GetNotification(name)

		utils.Check(err)

		content, err := notif.ToYaml()

		utils.Check(err)

		newContent, err := utils.EditYamlInEditor(notif.ObjectName(), string(content))

		utils.Check(err)

		updatedNotif, err := models.NewNotificationV1AlphaFromYaml([]byte(newContent))

		utils.Check(err)

		notif, err = c.UpdateNotification(updatedNotif)

		utils.Check(err)

		fmt.Printf("Notification '%s' updated.\n", notif.Metadata.Name)
	},
}
View Source 
var EditProjectCmd = &cobra.Command{
	Use:     "project [name]",
	Short:   "Edit a project.",
	Long:    ``,
	Aliases: []string{"project", "prj"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		name := args[0]

		c := client.NewProjectV1AlphaApi()

		project, err := c.GetProject(name)

		utils.Check(err)

		content, err := project.ToYaml()

		utils.Check(err)

		new_content, err := utils.EditYamlInEditor(project.ObjectName(), string(content))

		utils.Check(err)

		updated_project, err := models.NewProjectV1AlphaFromYaml([]byte(new_content))

		utils.Check(err)

		project, err = c.UpdateProject(updated_project)

		utils.Check(err)

		fmt.Printf("Project '%s' updated.\n", project.Metadata.Name)
	},
}
View Source 
var EditSecretCmd = &cobra.Command{
	Use:     "secret [name]",
	Short:   "Edit a secret.",
	Long:    ``,
	Aliases: []string{"secrets"},
	Args:    cobra.ExactArgs(1),

	Run: func(cmd *cobra.Command, args []string) {
		projectID := GetProjectID(cmd)

		if projectID == "" {
			name := args[0]

			c := client.NewSecretV1BetaApi()

			secret, err := c.GetSecret(name)

			utils.Check(err)

			content, err := secret.ToYaml()

			utils.Check(err)

			new_content, err := utils.EditYamlInEditor(secret.ObjectName(), string(content))

			utils.Check(err)

			updated_secret, err := models.NewSecretV1BetaFromYaml([]byte(new_content))

			utils.Check(err)

			secret, err = c.UpdateSecret(updated_secret)

			utils.Check(err)

			fmt.Printf("Secret '%s' updated.\n", secret.Metadata.Name)
		} else {
			name := args[0]

			c := client.NewProjectSecretV1Api(projectID)

			secret, err := c.GetSecret(name)

			utils.Check(err)

			content, err := secret.ToYaml()

			utils.Check(err)

			new_content, err := utils.EditYamlInEditor(secret.ObjectName(), string(content))

			utils.Check(err)

			updated_secret, err := models.NewProjectSecretV1FromYaml([]byte(new_content))

			utils.Check(err)

			secret, err = c.UpdateSecret(updated_secret)

			utils.Check(err)

			fmt.Printf("Secret '%s' updated.\n", secret.Metadata.Name)
		}
	},
}
View Source 
var GetAgentTypeCmd = &cobra.Command{
	Use:     "agent_types [name]",
	Short:   "Get self-hosted agent types.",
	Long:    ``,
	Aliases: []string{"agent_type", "agenttype", "agenttypes", "agentTypes", "agentType"},
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		c := client.NewAgentTypeApiV1AlphaApi()

		if len(args) == 0 {
			agentTypeList, err := c.ListAgentTypes()

			utils.Check(err)

			const padding = 3
			w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)

			fmt.Fprintln(w, "NAME\tAGE")

			for _, a := range agentTypeList.AgentTypes {
				updateTime, err := a.Metadata.UpdateTime.Int64()
				utils.Check(err)
				fmt.Fprintf(w, "%s\t%s\n", a.Metadata.Name, utils.RelativeAgeForHumans(updateTime))
			}

			if err := w.Flush(); err != nil {
				fmt.Printf("Error flushing agent types: %v\n", err)
			}
		} else {
			name := args[0]

			secret, err := c.GetAgentType(name)

			utils.Check(err)

			y, err := secret.ToYaml()

			utils.Check(err)

			fmt.Printf("%s", y)
		}
	},
}
View Source 
var GetAgentsCmd = &cobra.Command{
	Use:     "agents",
	Short:   "Get self-hosted agents.",
	Long:    ``,
	Aliases: []string{"agent"},
	Args:    cobra.RangeArgs(0, 1),
	Run: func(cmd *cobra.Command, args []string) {
		c := client.NewAgentApiV1AlphaApi()

		if len(args) == 0 {
			agentType, err := cmd.Flags().GetString("agent-type")
			utils.Check(err)

			agents, err := getAllAgents(c, agentType)
			utils.Check(err)

			if len(agents) == 0 {
				fmt.Fprintln(os.Stdout, "No agents found")
				return
			}

			const padding = 3
			w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)

			fmt.Fprintln(w, "NAME\tTYPE\tSTATE\tAGE")
			for _, a := range agents {
				connectedAt, err := a.Metadata.ConnectedAt.Int64()
				utils.Check(err)
				fmt.Fprintf(w, "%s\t%s\t%s\t%s\n",
					a.Metadata.Name,
					a.Metadata.Type,
					a.Status.State,
					utils.RelativeAgeForHumans(connectedAt),
				)
			}

			if err := w.Flush(); err != nil {
				fmt.Printf("Error flushing agents: %v\n", err)
			}
		} else {
			name := args[0]

			agent, err := c.GetAgent(name)

			utils.Check(err)

			y, err := agent.ToYaml()

			utils.Check(err)

			fmt.Printf("%s", y)
		}
	},
}
View Source 
var GetDTCmd = &cobra.Command{
	Use:     "deployment_targets [id or name]",
	Short:   "Get deployment targets.",
	Long:    ``,
	Aliases: models.DeploymentTargetCmdAliases,
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		getHistory, err := cmd.Flags().GetBool("history")
		utils.Check(err)
		targetName, err := cmd.Flags().GetString("name")
		utils.Check(err)
		targetId, err := cmd.Flags().GetString("id")
		utils.Check(err)
		if len(args) == 1 {
			if uuid.IsValid(args[0]) {
				targetId = args[0]
			} else {
				targetName = args[0]
			}
		}
		if getHistory {
			if targetId != "" {
				deployment_targets.History(targetId, cmd)
			} else if targetName != "" {
				deployment_targets.HistoryByName(targetName, getPrj(cmd), cmd)
			}
		} else {
			if targetId != "" {
				deployment_targets.Describe(targetId)
			} else if targetName != "" {
				deployment_targets.DescribeByName(targetName, getPrj(cmd))
			} else {
				deployment_targets.List(getPrj(cmd))
			}
		}
	},
}
View Source 
var GetDashboardCmd = &cobra.Command{
	Use:     "dashboards [name]",
	Short:   "Get dashboards.",
	Long:    ``,
	Aliases: []string{"dashboard", "dash"},
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		c := client.NewDashboardV1AlphaApi()

		if len(args) == 0 {
			dashList, err := c.ListDashboards()

			utils.Check(err)

			const padding = 3
			w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)

			fmt.Fprintln(w, "NAME\tAGE")

			for _, d := range dashList.Dashboards {
				updateTime, err := d.Metadata.UpdateTime.Int64()

				utils.Check(err)

				fmt.Fprintf(w, "%s\t%s\n", d.Metadata.Name, utils.RelativeAgeForHumans(updateTime))
			}

			if err := w.Flush(); err != nil {
				fmt.Printf("Error flushing dashboards: %v\n", err)
			}
		} else {
			name := args[0]

			dash, err := c.GetDashboard(name)

			utils.Check(err)

			y, err := dash.ToYaml()

			utils.Check(err)

			fmt.Printf("%s", y)
		}
	},
}
View Source 
var GetJobAllStates bool
View Source 
var GetJobCmd = &cobra.Command{
	Use:     "jobs [id]",
	Short:   "Get jobs.",
	Long:    ``,
	Aliases: []string{"job"},
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		c := client.NewJobsV1AlphaApi()

		if len(args) == 0 {
			states := []string{
				"PENDING",
				"QUEUED",
				"RUNNING",
			}

			if GetJobAllStates {
				states = append(states, "FINISHED")
			}

			jobList, err := c.ListJobs(states)

			utils.Check(err)

			const padding = 3
			w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)

			fmt.Fprintln(w, "ID\tNAME\tAGE\tSTATE\tRESULT")

			for _, j := range jobList.Jobs {
				createTime, err := j.Metadata.CreateTime.Int64()

				utils.Check(err)

				fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\n",
					j.Metadata.Id,
					j.Metadata.Name,
					utils.RelativeAgeForHumans(createTime),
					j.Status.State,
					j.Status.Result)
			}

			if err := w.Flush(); err != nil {
				fmt.Printf("Error flushing jobs: %v\n", err)
			}
		} else {
			id := args[0]

			job, err := c.GetJob(id)

			utils.Check(err)

			y, err := job.ToYaml()

			utils.Check(err)

			fmt.Printf("%s", y)
		}
	},
}
View Source 
var GetPplCmd = &cobra.Command{
	Use:     "pipelines [id]",
	Short:   "Get pipelines.",
	Long:    ``,
	Aliases: []string{"pipeline", "ppl"},
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		if len(args) == 0 {
			projectID := getPrj(cmd)

			pipelines.List(projectID)
		} else {
			id := args[0]
			pipelines.Describe(id, GetPplFollow)
		}
	},
}
View Source 
var GetPplFollow bool
View Source 
var GetProjectCmd = &cobra.Command{
	Use:     "projects [name]",
	Short:   "Get projects.",
	Long:    ``,
	Aliases: []string{"project", "prj"},
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		c := client.NewProjectV1AlphaApi()

		if len(args) == 0 {
			projectList, err := c.ListProjects()

			utils.Check(err)

			const padding = 3
			w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)

			fmt.Fprintln(w, "NAME\tREPOSITORY")

			for _, p := range projectList.Projects {
				fmt.Fprintf(w, "%s\t%s\n", p.Metadata.Name, p.Spec.Repository.Url)
			}

			if err := w.Flush(); err != nil {
				fmt.Printf("Error flushing projects: %v\n", err)
			}
		} else {
			name := args[0]

			project, err := c.GetProject(name)

			utils.Check(err)

			y, err := project.ToYaml()

			utils.Check(err)

			fmt.Printf("%s", y)
		}
	},
}
View Source 
var GetSecretCmd = &cobra.Command{
	Use:     "secrets [name]",
	Short:   "Get secrets.",
	Long:    ``,
	Aliases: []string{"secret"},
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		projectID := GetProjectID(cmd)

		if projectID == "" {
			c := client.NewSecretV1BetaApi()

			if len(args) == 0 {
				secretList, err := c.ListSecrets()

				utils.Check(err)

				const padding = 3
				w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)

				fmt.Fprintln(w, "NAME\tAGE")

				for _, s := range secretList.Secrets {
					updateTime, err := s.Metadata.UpdateTime.Int64()

					utils.Check(err)

					fmt.Fprintf(w, "%s\t%s\n", s.Metadata.Name, utils.RelativeAgeForHumans(updateTime))
				}

				if err := w.Flush(); err != nil {
					fmt.Printf("Error flushing secrets: %v\n", err)
				}
			} else {
				name := args[0]

				secret, err := c.GetSecret(name)

				utils.Check(err)

				y, err := secret.ToYaml()

				utils.Check(err)

				fmt.Printf("%s", y)
			}
		} else {
			c := client.NewProjectSecretV1Api(projectID)

			if len(args) == 0 {
				secretList, err := c.ListSecrets()
				utils.Check(err)

				const padding = 3
				w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)

				fmt.Fprintln(w, "NAME\tAGE")

				for _, s := range secretList.Secrets {
					updateTime, err := s.Metadata.UpdateTime.Int64()

					utils.Check(err)

					fmt.Fprintf(w, "%s\t%s\n", s.Metadata.Name, utils.RelativeAgeForHumans(updateTime))
				}

				if err := w.Flush(); err != nil {
					fmt.Printf("Error flushing secrets: %v\n", err)
				}
			} else {
				name := args[0]

				secret, err := c.GetSecret(name)

				utils.Check(err)

				y, err := secret.ToYaml()

				utils.Check(err)

				fmt.Printf("%s", y)
			}
		}
	},
}
View Source 
var GetWfCmd = &cobra.Command{
	Use:     "workflows [id]",
	Short:   "Get workflows.",
	Long:    ``,
	Aliases: []string{"workflow", "wf"},
	Args:    cobra.RangeArgs(0, 1),

	Run: func(cmd *cobra.Command, args []string) {
		projectID := getPrj(cmd)

		if len(args) == 0 {
			workflows.List(projectID)
		} else {
			wfID := args[0]
			workflows.Describe(projectID, wfID)
		}
	},
}
View Source 
var RootCmd = &cobra.Command{
	Use:   "sem",
	Short: "Semaphore 2.0 command line interface",
	PersistentPreRun: func(cmd *cobra.Command, args []string) {
		if !Verbose {
			log.SetOutput(ioutil.Discard)
		}
	},
}

RootCmd represents the base command when called without any subcommands

View Source 
var StopJobCmd = &cobra.Command{
	Use:     "job [id]",
	Short:   "Stop running job.",
	Long:    ``,
	Aliases: []string{"jobs"},
	Args:    cobra.RangeArgs(1, 1),

	Run: func(cmd *cobra.Command, args []string) {
		id := args[0]

		jobClient := client.NewJobsV1AlphaApi()
		err := jobClient.StopJob(id)

		utils.Check(err)

		fmt.Printf("Job '%s' stopped.\n", id)
	},
}
View Source 
var StopPplCmd = &cobra.Command{
	Use:     "pipeline [id]",
	Short:   "Stop running pipeline.",
	Long:    ``,
	Aliases: []string{"pipelines", "ppl"},
	Args:    cobra.RangeArgs(1, 1),

	Run: func(cmd *cobra.Command, args []string) {
		id := args[0]
		pipelines.Stop(id)
	},
}
View Source 
var StopWfCmd = &cobra.Command{
	Use:     "workflow [id]",
	Short:   "Stop all running pipelines in the workflow.",
	Long:    ``,
	Aliases: []string{"workflows", "wf"},
	Args:    cobra.RangeArgs(1, 1),

	Run: func(cmd *cobra.Command, args []string) {
		id := args[0]
		workflows.Stop(id)
	},
}
View Source 
var Verbose bool

Functions

func ConstructProjectName 

func ConstructProjectName(repoUrl string) (string, error)

func Execute 

func Execute()

Execute adds all child commands to the root command and sets flags appropriately. This is called by main.main(). It only needs to happen once to the RootCmd.

func GetProjectID added in v0.28.0 

func GetProjectID(cmd *cobra.Command) string

func InitCmd added in v0.5.0 

func InitCmd() cobra.Command

func NewCreateDeploymentTargetCmd added in v0.28.2 

func NewCreateDeploymentTargetCmd() *cobra.Command

func NewCreateNotificationCmd added in v0.8.3 

func NewCreateNotificationCmd() *cobra.Command

func NewCreateSecretCmd added in v0.10.0 

func NewCreateSecretCmd() *cobra.Command

func NewDebugJobCmd added in v0.8.11 

func NewDebugJobCmd() *cobra.Command

func NewDebugProjectCmd added in v0.8.2 

func NewDebugProjectCmd() *cobra.Command

func NewGetNotificationCmd added in v0.8.3 

func NewGetNotificationCmd() *cobra.Command

func RunApply added in v0.5.0 

func RunApply(cmd *cobra.Command, args []string)

func RunCreateNotification added in v0.8.3 

func RunCreateNotification(cmd *cobra.Command, args []string)

func RunDebugJobCmd added in v0.8.11 

func RunDebugJobCmd(cmd *cobra.Command, args []string)

func RunDebugProjectCmd added in v0.8.2 

func RunDebugProjectCmd(cmd *cobra.Command, args []string)

func RunGetNotification added in v0.8.3 

func RunGetNotification(cmd *cobra.Command, args []string)

func RunInit 

func RunInit(cmd *cobra.Command, args []string)

func RunListNotifications added in v0.8.3 

func RunListNotifications(cmd *cobra.Command, args []string)

Types

type CreateJobCmd added in v0.7.2 

type CreateJobCmd struct {
	Cmd *cobra.Command
}

func NewCreateJobCmd added in v0.7.2 

func NewCreateJobCmd() *CreateJobCmd

func (*CreateJobCmd) FindProjectId added in v0.7.2 

func (c *CreateJobCmd) FindProjectId() string

func (*CreateJobCmd) ParseCommandFlag added in v0.7.2 

func (c *CreateJobCmd) ParseCommandFlag() []string

func (*CreateJobCmd) ParseFileFlags added in v0.7.2 

func (c *CreateJobCmd) ParseFileFlags() []models.JobV1AlphaSpecFile

func (*CreateJobCmd) Run added in v0.7.2 

func (c *CreateJobCmd) Run(args []string)

type Event added in v0.7.0 

type Event struct {
	Timestamp int32  `json:"timestamp"`
	Type      string `json:"event"`
	Output    string `json:"output"`
	Directive string `json:"directive"`
	ExitCode  int32  `json:"exit_code"`
	JobResult string `json:"job_result"`
}

type Events added in v0.7.0 

type Events struct {
	Events []Event `json:"events"`
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.