func Cmds(address string) ([]*cobra.Command, error) {
var image string
var outParentCommitID string
createJob := &cobra.Command{
Use: "create-job in-repo-name in-commit-id out-repo-name command [args]",
Short: "Create a new job. Returns the id of the created job.",
Long: `Create a new job. With repo-name/commit-id as input and
out-repo-name as output. A commit will be created for the output.
You can find out the name of the commit with inspect-job.`,
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
job, err := apiClient.CreateJob(
context.Background(),
&pps.CreateJobRequest{
Spec: &pps.CreateJobRequest_Transform{
Transform: &pps.Transform{
Image: image,
Cmd: args[3:],
},
},
Input: &pfs.Commit{
Repo: &pfs.Repo{
Name: args[0],
},
Id: args[1],
},
OutputParent: &pfs.Commit{
Repo: &pfs.Repo{
Name: args[2],
},
Id: outParentCommitID,
},
})
if err != nil {
errorAndExit("Error from CreateJob: %s", err.Error())
}
fmt.Println(job.Id)
},
}
createJob.Flags().StringVarP(&image, "image", "i", "ubuntu", "The image to run the job in.")
createJob.Flags().StringVarP(&outParentCommitID, "parent", "p", "", "The parent to use for the output commit.")
inspectJob := &cobra.Command{
Use: "inspect-job job-id",
Short: "Return info about a job.",
Long: "Return info about a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
jobInfo, err := apiClient.InspectJob(
context.Background(),
&pps.InspectJobRequest{
Job: &pps.Job{
Id: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if jobInfo == nil {
errorAndExit("Job %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
pretty.PrintJobInfo(writer, jobInfo)
return writer.Flush()
}),
}
var pipelineName string
listJob := &cobra.Command{
Use: "list-job -p pipeline-name",
Short: "Return info about all jobs.",
Long: "Return info about all jobs.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
var pipeline *pps.Pipeline
if pipelineName != "" {
pipeline = &pps.Pipeline{
Name: pipelineName,
}
}
jobInfos, err := apiClient.ListJob(
context.Background(),
&pps.ListJobRequest{
Pipeline: pipeline,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
for _, jobInfo := range jobInfos.JobInfo {
pretty.PrintJobInfo(writer, jobInfo)
}
return writer.Flush()
}),
}
listJob.Flags().StringVarP(&pipelineName, "pipeline", "p", "", "Limit to jobs made by pipeline.")
getJobLogs := &cobra.Command{
Use: "logs job-id",
Short: "Return logs from a job.",
Long: "Return logs from a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
logsClient, err := apiClient.GetJobLogs(
context.Background(),
&pps.GetJobLogsRequest{
Job: &pps.Job{
Id: args[0],
},
OutputStream: pps.OutputStream_OUTPUT_STREAM_ALL,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if err := protostream.WriteFromStreamingBytesClient(logsClient, os.Stdout); err != nil {
return err
}
return nil
}),
}
createPipeline := &cobra.Command{
Use: "create-pipeline pipeline-name input-repo output-repo command [args]",
Short: "Create a new pipeline.",
Long: "Create a new pipeline.",
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
if _, err := apiClient.CreatePipeline(
context.Background(),
&pps.CreatePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
Transform: &pps.Transform{
Image: image,
Cmd: args[3:],
},
Input: &pfs.Repo{
Name: args[1],
},
Output: &pfs.Repo{
Name: args[2],
},
},
); err != nil {
errorAndExit("Error from CreatePipeline: %s", err.Error())
}
},
}
createPipeline.Flags().StringVarP(&image, "image", "i", "ubuntu", "The image to run the pipeline's jobs in.")
inspectPipeline := &cobra.Command{
Use: "inspect-pipeline pipeline-name",
Short: "Return info about a pipeline.",
Long: "Return info about a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfo, err := apiClient.InspectPipeline(
context.Background(),
&pps.InspectPipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectPipeline: %s", err.Error())
}
if pipelineInfo == nil {
errorAndExit("Pipeline %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
pretty.PrintPipelineInfo(writer, pipelineInfo)
return writer.Flush()
}),
}
listPipeline := &cobra.Command{
Use: "list-pipeline",
Short: "Return info about all pipelines.",
Long: "Return info about all pipelines.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfos, err := apiClient.ListPipeline(
context.Background(),
&pps.ListPipelineRequest{},
)
if err != nil {
errorAndExit("Error from ListPipeline: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
for _, pipelineInfo := range pipelineInfos.PipelineInfo {
pretty.PrintPipelineInfo(writer, pipelineInfo)
}
return writer.Flush()
}),
}
deletePipeline := &cobra.Command{
Use: "delete-pipeline pipeline-name",
Short: "Delete a pipeline.",
Long: "Delete a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
if _, err := apiClient.DeletePipeline(
context.Background(),
&pps.DeletePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
); err != nil {
errorAndExit("Error from DeletePipeline: %s", err.Error())
}
return nil
}),
}
var result []*cobra.Command
result = append(result, createJob)
result = append(result, inspectJob)
result = append(result, listJob)
result = append(result, getJobLogs)
result = append(result, createPipeline)
result = append(result, inspectPipeline)
result = append(result, listPipeline)
result = append(result, deletePipeline)
return result, nil
}
func Cmds(address string) ([]*cobra.Command, error) {
marshaller := &jsonpb.Marshaler{Indent: " "}
job := &cobra.Command{
Use: "job",
Short: "Docs for jobs.",
Long: `Jobs are the basic unit of computation in Pachyderm.
Jobs run a containerized workload over a set of finished input commits.
Creating a job will also create a new repo and a commit in that repo which
contains the output of the job. Unless the job is created with another job as a
parent. If the job is created with a parent it will use the same repo as its
parent job and the commit it creates will use the parent job's commit as a
parent.
If the job fails the commit it creates will not be finished.
The increase the throughput of a job increase the Shard paremeter.
`,
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
return nil
}),
}
exampleCreateJobRequest, err := marshaller.MarshalToString(example.CreateJobRequest())
if err != nil {
return nil, err
}
var jobPath string
createJob := &cobra.Command{
Use: "create-job -f job.json",
Short: "Create a new job. Returns the id of the created job.",
Long: fmt.Sprintf("Create a new job from a spec, the spec looks like this\n%s", exampleCreateJobRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var jobReader io.Reader
if jobPath == "-" {
jobReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
jobFile, err := os.Open(jobPath)
if err != nil {
errorAndExit("Error opening %s: %s", jobPath, err.Error())
}
defer func() {
if err := jobFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", jobPath, err.Error())
}
}()
jobReader = jobFile
}
var request pps.CreateJobRequest
if err := jsonpb.Unmarshal(jobReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
job, err := apiClient.CreateJob(
context.Background(),
&request,
)
if err != nil {
errorAndExit("Error from CreateJob: %s", err.Error())
}
fmt.Println(job.Id)
},
}
createJob.Flags().StringVarP(&jobPath, "file", "f", "-", "The file containing the job, - reads from stdin.")
inspectJob := &cobra.Command{
Use: "inspect-job job-id",
Short: "Return info about a job.",
Long: "Return info about a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
jobInfo, err := apiClient.InspectJob(
context.Background(),
&pps.InspectJobRequest{
Job: &pps.Job{
Id: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if jobInfo == nil {
errorAndExit("Job %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
pretty.PrintJobInfo(writer, jobInfo)
return writer.Flush()
}),
}
var pipelineName string
listJob := &cobra.Command{
Use: "list-job -p pipeline-name",
Short: "Return info about all jobs.",
Long: "Return info about all jobs.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
var pipeline *pps.Pipeline
if pipelineName != "" {
pipeline = &pps.Pipeline{
Name: pipelineName,
}
}
jobInfos, err := apiClient.ListJob(
context.Background(),
&pps.ListJobRequest{
Pipeline: pipeline,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
for _, jobInfo := range jobInfos.JobInfo {
pretty.PrintJobInfo(writer, jobInfo)
}
return writer.Flush()
}),
}
listJob.Flags().StringVarP(&pipelineName, "pipeline", "p", "", "Limit to jobs made by pipeline.")
pipeline := &cobra.Command{
Use: "pipeline",
Short: "Docs for pipelines.",
Long: `Pipelines are a powerful abstraction for automating jobs.
Pipelines take a set of repos as inputs, rather than the set of commits that
jobs take. Pipelines then subscribe to commits on those repos and launches a job
to process each incoming commit.
Creating a pipeline will also create a repo of the same name.
All jobs created by a pipeline will create commits in the pipeline's repo.
`,
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
return nil
}),
}
var pipelinePath string
exampleCreatePipelineRequest, err := marshaller.MarshalToString(example.CreatePipelineRequest())
if err != nil {
return nil, err
}
createPipeline := &cobra.Command{
Use: "create-pipeline -f pipeline.json",
Short: "Create a new pipeline.",
Long: fmt.Sprintf("Create a new pipeline from a spec, the spec looks like this\n%s", exampleCreatePipelineRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var pipelineReader io.Reader
if pipelinePath == "-" {
pipelineReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
pipelineFile, err := os.Open(pipelinePath)
if err != nil {
errorAndExit("Error opening %s: %s", pipelinePath, err.Error())
}
defer func() {
if err := pipelineFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", pipelinePath, err.Error())
}
}()
pipelineReader = pipelineFile
}
var request pps.CreatePipelineRequest
if err := jsonpb.Unmarshal(pipelineReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
if _, err := apiClient.CreatePipeline(
context.Background(),
&request,
); err != nil {
errorAndExit("Error from CreatePipeline: %s", err.Error())
}
},
}
createPipeline.Flags().StringVarP(&pipelinePath, "file", "f", "-", "The file containing the pipeline, - reads from stdin.")
inspectPipeline := &cobra.Command{
Use: "inspect-pipeline pipeline-name",
Short: "Return info about a pipeline.",
Long: "Return info about a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfo, err := apiClient.InspectPipeline(
context.Background(),
&pps.InspectPipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectPipeline: %s", err.Error())
}
if pipelineInfo == nil {
errorAndExit("Pipeline %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
pretty.PrintPipelineInfo(writer, pipelineInfo)
return writer.Flush()
}),
}
listPipeline := &cobra.Command{
Use: "list-pipeline",
Short: "Return info about all pipelines.",
Long: "Return info about all pipelines.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfos, err := apiClient.ListPipeline(
context.Background(),
&pps.ListPipelineRequest{},
)
if err != nil {
errorAndExit("Error from ListPipeline: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
for _, pipelineInfo := range pipelineInfos.PipelineInfo {
pretty.PrintPipelineInfo(writer, pipelineInfo)
}
return writer.Flush()
}),
}
deletePipeline := &cobra.Command{
Use: "delete-pipeline pipeline-name",
Short: "Delete a pipeline.",
Long: "Delete a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
if _, err := apiClient.DeletePipeline(
context.Background(),
&pps.DeletePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
); err != nil {
errorAndExit("Error from DeletePipeline: %s", err.Error())
}
return nil
}),
}
var result []*cobra.Command
result = append(result, job)
result = append(result, createJob)
result = append(result, inspectJob)
result = append(result, listJob)
result = append(result, pipeline)
result = append(result, createPipeline)
result = append(result, inspectPipeline)
result = append(result, listPipeline)
result = append(result, deletePipeline)
return result, nil
}
func do(appEnvObj interface{}) error {
appEnv := appEnvObj.(*appEnv)
address := appEnv.PachydermPpsd1Port
if address == "" {
address = appEnv.Address
} else {
address = strings.Replace(address, "tcp://", "", -1)
}
clientConn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
return err
}
jobAPIClient := pps.NewJobAPIClient(clientConn)
pipelineAPIClient := pps.NewPipelineAPIClient(clientConn)
rootCmd := &cobra.Command{
Use: "pps",
Long: `Access the PPS API.
Note that this CLI is experimental and does not even check for common errors.
The environment variable PPS_ADDRESS controls what server the CLI connects to, the default is 0.0.0.0:651.`,
}
var image string
var outParentCommitID string
createJob := &cobra.Command{
Use: "create-job in-repo-name in-commit-id out-repo-name command [args]",
Short: "Create a new job. Returns the id of the created job.",
Long: `Create a new job. With repo-name/commit-id as input and
out-repo-name as output. A commit will be created for the output.
You can find out the name of the commit with inspect-job.`,
Run: func(cmd *cobra.Command, args []string) {
job, err := jobAPIClient.CreateJob(
context.Background(),
&pps.CreateJobRequest{
Spec: &pps.CreateJobRequest_Transform{
Transform: &pps.Transform{
Image: image,
Cmd: args[3:],
},
},
Input: &pfs.Commit{
Repo: &pfs.Repo{
Name: args[0],
},
Id: args[1],
},
OutputParent: &pfs.Commit{
Repo: &pfs.Repo{
Name: args[2],
},
Id: outParentCommitID,
},
})
if err != nil {
errorAndExit("Error from CreateJob: %s", err.Error())
}
fmt.Println(job.Id)
},
}
createJob.Flags().StringVarP(&image, "image", "i", "ubuntu", "The image to run the job in.")
createJob.Flags().StringVarP(&outParentCommitID, "parent", "p", "", "The parent to use for the output commit.")
inspectJob := &cobra.Command{
Use: "inspect-job job-id",
Short: "Return info about a job.",
Long: "Return info about a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
jobInfo, err := jobAPIClient.InspectJob(
context.Background(),
&pps.InspectJobRequest{
Job: &pps.Job{
Id: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if jobInfo == nil {
errorAndExit("Job %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
pretty.PrintJobInfo(writer, jobInfo)
return writer.Flush()
}),
}
var pipelineName string
listJob := &cobra.Command{
Use: "list-job -p pipeline-name",
Short: "Return info about all jobs.",
Long: "Return info about all jobs.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
var pipeline *pps.Pipeline
if pipelineName != "" {
pipeline = &pps.Pipeline{
Name: pipelineName,
}
}
jobInfos, err := jobAPIClient.ListJob(
context.Background(),
&pps.ListJobRequest{
Pipeline: pipeline,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
for _, jobInfo := range jobInfos.JobInfo {
pretty.PrintJobInfo(writer, jobInfo)
}
return writer.Flush()
}),
}
listJob.Flags().StringVarP(&pipelineName, "pipeline", "p", "", "Limit to jobs made by pipeline.")
getJobLogs := &cobra.Command{
Use: "logs job-id",
Short: "Return logs from a job.",
Long: "Return logs from a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
logsClient, err := jobAPIClient.GetJobLogs(
context.Background(),
&pps.GetJobLogsRequest{
Job: &pps.Job{
Id: args[0],
},
OutputStream: pps.OutputStream_OUTPUT_STREAM_ALL,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if err := protostream.WriteFromStreamingBytesClient(logsClient, os.Stdout); err != nil {
return err
}
return nil
}),
}
createPipeline := &cobra.Command{
Use: "create-pipeline pipeline-name input-repo output-repo command [args]",
Short: "Create a new pipeline.",
Long: "Create a new pipeline.",
Run: func(cmd *cobra.Command, args []string) {
if _, err := pipelineAPIClient.CreatePipeline(
context.Background(),
&pps.CreatePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
Transform: &pps.Transform{
Image: image,
Cmd: args[3:],
},
Input: &pfs.Repo{
Name: args[1],
},
Output: &pfs.Repo{
Name: args[2],
},
},
); err != nil {
errorAndExit("Error from CreatePipeline: %s", err.Error())
}
},
}
createPipeline.Flags().StringVarP(&image, "image", "i", "ubuntu", "The image to run the pipeline's jobs in.")
inspectPipeline := &cobra.Command{
Use: "inspect-pipeline pipeline-name",
Short: "Return info about a pipeline.",
Long: "Return info about a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
pipelineInfo, err := pipelineAPIClient.InspectPipeline(
context.Background(),
&pps.InspectPipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectPipeline: %s", err.Error())
}
if pipelineInfo == nil {
errorAndExit("Pipeline %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
pretty.PrintPipelineInfo(writer, pipelineInfo)
return writer.Flush()
}),
}
listPipeline := &cobra.Command{
Use: "list-pipeline",
Short: "Return info about all pipelines.",
Long: "Return info about all pipelines.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
pipelineInfos, err := pipelineAPIClient.ListPipeline(
context.Background(),
&pps.ListPipelineRequest{},
)
if err != nil {
errorAndExit("Error from ListPipeline: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
for _, pipelineInfo := range pipelineInfos.PipelineInfo {
pretty.PrintPipelineInfo(writer, pipelineInfo)
}
return writer.Flush()
}),
}
deletePipeline := &cobra.Command{
Use: "delete-pipeline pipeline-name",
Short: "Delete a pipeline.",
Long: "Delete a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
if _, err := pipelineAPIClient.DeletePipeline(
context.Background(),
&pps.DeletePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
); err != nil {
errorAndExit("Error from DeletePipeline: %s", err.Error())
}
return nil
}),
}
rootCmd.AddCommand(createJob)
rootCmd.AddCommand(inspectJob)
rootCmd.AddCommand(listJob)
rootCmd.AddCommand(getJobLogs)
rootCmd.AddCommand(createPipeline)
rootCmd.AddCommand(inspectPipeline)
rootCmd.AddCommand(listPipeline)
rootCmd.AddCommand(deletePipeline)
return rootCmd.Execute()
}
func Cmds(address string) ([]*cobra.Command, error) {
marshaller := &jsonpb.Marshaler{Indent: " "}
exampleCreateJobRequest, err := marshaller.MarshalToString(example.CreateJobRequest())
if err != nil {
return nil, err
}
var jobPath string
createJob := &cobra.Command{
Use: "create-job -f job.json",
Short: "Create a new job. Returns the id of the created job.",
Long: fmt.Sprintf("Create a new job from a spec, the spec looks like this\n%s", exampleCreateJobRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var jobReader io.Reader
if jobPath == "-" {
jobReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
jobFile, err := os.Open(jobPath)
if err != nil {
errorAndExit("Error opening %s: %s", jobPath, err.Error())
}
defer func() {
if err := jobFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", jobPath, err.Error())
}
}()
jobReader = jobFile
}
var request pps.CreateJobRequest
if err := jsonpb.Unmarshal(jobReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
job, err := apiClient.CreateJob(
context.Background(),
&request,
)
if err != nil {
errorAndExit("Error from CreateJob: %s", err.Error())
}
fmt.Println(job.Id)
},
}
createJob.Flags().StringVarP(&jobPath, "file", "f", "-", "The file containing the job, - reads from stdin.")
inspectJob := &cobra.Command{
Use: "inspect-job job-id",
Short: "Return info about a job.",
Long: "Return info about a job.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
jobInfo, err := apiClient.InspectJob(
context.Background(),
&pps.InspectJobRequest{
Job: &pps.Job{
Id: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
if jobInfo == nil {
errorAndExit("Job %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
pretty.PrintJobInfo(writer, jobInfo)
return writer.Flush()
}),
}
var pipelineName string
listJob := &cobra.Command{
Use: "list-job -p pipeline-name",
Short: "Return info about all jobs.",
Long: "Return info about all jobs.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
var pipeline *pps.Pipeline
if pipelineName != "" {
pipeline = &pps.Pipeline{
Name: pipelineName,
}
}
jobInfos, err := apiClient.ListJob(
context.Background(),
&pps.ListJobRequest{
Pipeline: pipeline,
},
)
if err != nil {
errorAndExit("Error from InspectJob: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintJobHeader(writer)
for _, jobInfo := range jobInfos.JobInfo {
pretty.PrintJobInfo(writer, jobInfo)
}
return writer.Flush()
}),
}
listJob.Flags().StringVarP(&pipelineName, "pipeline", "p", "", "Limit to jobs made by pipeline.")
var pipelinePath string
exampleCreatePipelineRequest, err := marshaller.MarshalToString(example.CreatePipelineRequest())
if err != nil {
return nil, err
}
createPipeline := &cobra.Command{
Use: "create-pipeline -f pipeline.json",
Short: "Create a new pipeline.",
Long: fmt.Sprintf("Create a new pipeline from a spec, the spec looks like this\n%s", exampleCreatePipelineRequest),
Run: func(cmd *cobra.Command, args []string) {
apiClient, err := getAPIClient(address)
if err != nil {
errorAndExit("Error connecting to pps: %s", err.Error())
}
var pipelineReader io.Reader
if pipelinePath == "-" {
pipelineReader = os.Stdin
fmt.Print("Reading from stdin.\n")
} else {
pipelineFile, err := os.Open(pipelinePath)
if err != nil {
errorAndExit("Error opening %s: %s", pipelinePath, err.Error())
}
defer func() {
if err := pipelineFile.Close(); err != nil {
errorAndExit("Error closing%s: %s", pipelinePath, err.Error())
}
}()
pipelineReader = pipelineFile
}
var request pps.CreatePipelineRequest
if err := jsonpb.Unmarshal(pipelineReader, &request); err != nil {
errorAndExit("Error reading from stdin: %s", err.Error())
}
if _, err := apiClient.CreatePipeline(
context.Background(),
&request,
); err != nil {
errorAndExit("Error from CreatePipeline: %s", err.Error())
}
},
}
createPipeline.Flags().StringVarP(&pipelinePath, "file", "f", "-", "The file containing the pipeline, - reads from stdin.")
inspectPipeline := &cobra.Command{
Use: "inspect-pipeline pipeline-name",
Short: "Return info about a pipeline.",
Long: "Return info about a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfo, err := apiClient.InspectPipeline(
context.Background(),
&pps.InspectPipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
)
if err != nil {
errorAndExit("Error from InspectPipeline: %s", err.Error())
}
if pipelineInfo == nil {
errorAndExit("Pipeline %s not found.", args[0])
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
pretty.PrintPipelineInfo(writer, pipelineInfo)
return writer.Flush()
}),
}
listPipeline := &cobra.Command{
Use: "list-pipeline",
Short: "Return info about all pipelines.",
Long: "Return info about all pipelines.",
Run: pkgcobra.RunFixedArgs(0, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
pipelineInfos, err := apiClient.ListPipeline(
context.Background(),
&pps.ListPipelineRequest{},
)
if err != nil {
errorAndExit("Error from ListPipeline: %s", err.Error())
}
writer := tabwriter.NewWriter(os.Stdout, 20, 1, 3, ' ', 0)
pretty.PrintPipelineHeader(writer)
for _, pipelineInfo := range pipelineInfos.PipelineInfo {
pretty.PrintPipelineInfo(writer, pipelineInfo)
}
return writer.Flush()
}),
}
deletePipeline := &cobra.Command{
Use: "delete-pipeline pipeline-name",
Short: "Delete a pipeline.",
Long: "Delete a pipeline.",
Run: pkgcobra.RunFixedArgs(1, func(args []string) error {
apiClient, err := getAPIClient(address)
if err != nil {
return err
}
if _, err := apiClient.DeletePipeline(
context.Background(),
&pps.DeletePipelineRequest{
Pipeline: &pps.Pipeline{
Name: args[0],
},
},
); err != nil {
errorAndExit("Error from DeletePipeline: %s", err.Error())
}
return nil
}),
}
var result []*cobra.Command
result = append(result, createJob)
result = append(result, inspectJob)
result = append(result, listJob)
result = append(result, createPipeline)
result = append(result, inspectPipeline)
result = append(result, listPipeline)
result = append(result, deletePipeline)
return result, nil
}