github.com/anuvu/nomad@v0.8.7-atom1/command/job_deployments.go (about)

     1  package command
     2  
     3  import (
     4  	"fmt"
     5  	"strings"
     6  
     7  	"github.com/hashicorp/nomad/api/contexts"
     8  	"github.com/posener/complete"
     9  )
    10  
    11  type JobDeploymentsCommand struct {
    12  	Meta
    13  }
    14  
    15  func (c *JobDeploymentsCommand) Help() string {
    16  	helpText := `
    17  Usage: nomad job deployments [options] <job>
    18  
    19    Deployments is used to display the deployments for a particular job.
    20  
    21  General Options:
    22  
    23    ` + generalOptionsUsage() + `
    24  
    25  Deployments Options:
    26  
    27    -json
    28      Output the deployments in a JSON format.
    29  
    30    -t
    31      Format and display deployments using a Go template.
    32  
    33    -latest
    34      Display the latest deployment only.
    35  
    36    -verbose
    37      Display full information.
    38  `
    39  	return strings.TrimSpace(helpText)
    40  }
    41  
    42  func (c *JobDeploymentsCommand) Synopsis() string {
    43  	return "List deployments for a job"
    44  }
    45  
    46  func (c *JobDeploymentsCommand) AutocompleteFlags() complete.Flags {
    47  	return mergeAutocompleteFlags(c.Meta.AutocompleteFlags(FlagSetClient),
    48  		complete.Flags{
    49  			"-json":    complete.PredictNothing,
    50  			"-t":       complete.PredictAnything,
    51  			"-latest":  complete.PredictNothing,
    52  			"-verbose": complete.PredictNothing,
    53  		})
    54  }
    55  
    56  func (c *JobDeploymentsCommand) AutocompleteArgs() complete.Predictor {
    57  	return complete.PredictFunc(func(a complete.Args) []string {
    58  		client, err := c.Meta.Client()
    59  		if err != nil {
    60  			return nil
    61  		}
    62  
    63  		resp, _, err := client.Search().PrefixSearch(a.Last, contexts.Jobs, nil)
    64  		if err != nil {
    65  			return []string{}
    66  		}
    67  		return resp.Matches[contexts.Jobs]
    68  	})
    69  }
    70  
    71  func (c *JobDeploymentsCommand) Name() string { return "job deployments" }
    72  
    73  func (c *JobDeploymentsCommand) Run(args []string) int {
    74  	var json, latest, verbose bool
    75  	var tmpl string
    76  
    77  	flags := c.Meta.FlagSet(c.Name(), FlagSetClient)
    78  	flags.Usage = func() { c.Ui.Output(c.Help()) }
    79  	flags.BoolVar(&latest, "latest", false, "")
    80  	flags.BoolVar(&verbose, "verbose", false, "")
    81  	flags.BoolVar(&json, "json", false, "")
    82  	flags.StringVar(&tmpl, "t", "", "")
    83  
    84  	if err := flags.Parse(args); err != nil {
    85  		return 1
    86  	}
    87  
    88  	// Check that we got exactly one node
    89  	args = flags.Args()
    90  	if l := len(args); l != 1 {
    91  		c.Ui.Error("This command takes one argument: <job>")
    92  		c.Ui.Error(commandErrorText(c))
    93  		return 1
    94  	}
    95  
    96  	// Get the HTTP client
    97  	client, err := c.Meta.Client()
    98  	if err != nil {
    99  		c.Ui.Error(fmt.Sprintf("Error initializing client: %s", err))
   100  		return 1
   101  	}
   102  
   103  	jobID := args[0]
   104  
   105  	// Check if the job exists
   106  	jobs, _, err := client.Jobs().PrefixList(jobID)
   107  	if err != nil {
   108  		c.Ui.Error(fmt.Sprintf("Error listing jobs: %s", err))
   109  		return 1
   110  	}
   111  	if len(jobs) == 0 {
   112  		c.Ui.Error(fmt.Sprintf("No job(s) with prefix or id %q found", jobID))
   113  		return 1
   114  	}
   115  	if len(jobs) > 1 && strings.TrimSpace(jobID) != jobs[0].ID {
   116  		c.Ui.Error(fmt.Sprintf("Prefix matched multiple jobs\n\n%s", createStatusListOutput(jobs)))
   117  		return 1
   118  	}
   119  	jobID = jobs[0].ID
   120  
   121  	// Truncate the id unless full length is requested
   122  	length := shortId
   123  	if verbose {
   124  		length = fullId
   125  	}
   126  
   127  	if latest {
   128  		deploy, _, err := client.Jobs().LatestDeployment(jobID, nil)
   129  		if err != nil {
   130  			c.Ui.Error(fmt.Sprintf("Error retrieving deployments: %s", err))
   131  			return 1
   132  		}
   133  
   134  		if json || len(tmpl) > 0 {
   135  			out, err := Format(json, tmpl, deploy)
   136  			if err != nil {
   137  				c.Ui.Error(err.Error())
   138  				return 1
   139  			}
   140  
   141  			c.Ui.Output(out)
   142  			return 0
   143  		}
   144  
   145  		c.Ui.Output(c.Colorize().Color(formatDeployment(deploy, length)))
   146  		return 0
   147  	}
   148  
   149  	deploys, _, err := client.Jobs().Deployments(jobID, nil)
   150  	if err != nil {
   151  		c.Ui.Error(fmt.Sprintf("Error retrieving deployments: %s", err))
   152  		return 1
   153  	}
   154  
   155  	if json || len(tmpl) > 0 {
   156  		out, err := Format(json, tmpl, deploys)
   157  		if err != nil {
   158  			c.Ui.Error(err.Error())
   159  			return 1
   160  		}
   161  
   162  		c.Ui.Output(out)
   163  		return 0
   164  	}
   165  
   166  	c.Ui.Output(formatDeployments(deploys, length))
   167  	return 0
   168  }