github.com/djenriquez/nomad-1@v0.8.1/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) Run(args []string) int {
    72  	var json, latest, verbose bool
    73  	var tmpl string
    74  
    75  	flags := c.Meta.FlagSet("job deployments", FlagSetClient)
    76  	flags.Usage = func() { c.Ui.Output(c.Help()) }
    77  	flags.BoolVar(&latest, "latest", false, "")
    78  	flags.BoolVar(&verbose, "verbose", false, "")
    79  	flags.BoolVar(&json, "json", false, "")
    80  	flags.StringVar(&tmpl, "t", "", "")
    81  
    82  	if err := flags.Parse(args); err != nil {
    83  		return 1
    84  	}
    85  
    86  	// Check that we got exactly one node
    87  	args = flags.Args()
    88  	if l := len(args); l != 1 {
    89  		c.Ui.Error(c.Help())
    90  		return 1
    91  	}
    92  
    93  	// Get the HTTP client
    94  	client, err := c.Meta.Client()
    95  	if err != nil {
    96  		c.Ui.Error(fmt.Sprintf("Error initializing client: %s", err))
    97  		return 1
    98  	}
    99  
   100  	jobID := args[0]
   101  
   102  	// Check if the job exists
   103  	jobs, _, err := client.Jobs().PrefixList(jobID)
   104  	if err != nil {
   105  		c.Ui.Error(fmt.Sprintf("Error listing jobs: %s", err))
   106  		return 1
   107  	}
   108  	if len(jobs) == 0 {
   109  		c.Ui.Error(fmt.Sprintf("No job(s) with prefix or id %q found", jobID))
   110  		return 1
   111  	}
   112  	if len(jobs) > 1 && strings.TrimSpace(jobID) != jobs[0].ID {
   113  		c.Ui.Error(fmt.Sprintf("Prefix matched multiple jobs\n\n%s", createStatusListOutput(jobs)))
   114  		return 1
   115  	}
   116  	jobID = jobs[0].ID
   117  
   118  	// Truncate the id unless full length is requested
   119  	length := shortId
   120  	if verbose {
   121  		length = fullId
   122  	}
   123  
   124  	if latest {
   125  		deploy, _, err := client.Jobs().LatestDeployment(jobID, nil)
   126  		if err != nil {
   127  			c.Ui.Error(fmt.Sprintf("Error retrieving deployments: %s", err))
   128  			return 1
   129  		}
   130  
   131  		if json || len(tmpl) > 0 {
   132  			out, err := Format(json, tmpl, deploy)
   133  			if err != nil {
   134  				c.Ui.Error(err.Error())
   135  				return 1
   136  			}
   137  
   138  			c.Ui.Output(out)
   139  			return 0
   140  		}
   141  
   142  		c.Ui.Output(c.Colorize().Color(formatDeployment(deploy, length)))
   143  		return 0
   144  	}
   145  
   146  	deploys, _, err := client.Jobs().Deployments(jobID, nil)
   147  	if err != nil {
   148  		c.Ui.Error(fmt.Sprintf("Error retrieving deployments: %s", err))
   149  		return 1
   150  	}
   151  
   152  	if json || len(tmpl) > 0 {
   153  		out, err := Format(json, tmpl, deploys)
   154  		if err != nil {
   155  			c.Ui.Error(err.Error())
   156  			return 1
   157  		}
   158  
   159  		c.Ui.Output(out)
   160  		return 0
   161  	}
   162  
   163  	c.Ui.Output(formatDeployments(deploys, length))
   164  	return 0
   165  }