github.com/hernad/nomad@v1.6.112/command/node_pool_jobs.go (about)

     1  // Copyright (c) HashiCorp, Inc.
     2  // SPDX-License-Identifier: MPL-2.0
     3  
     4  package command
     5  
     6  import (
     7  	"fmt"
     8  	"os"
     9  	"strings"
    10  
    11  	"github.com/posener/complete"
    12  
    13  	"github.com/hernad/nomad/api"
    14  )
    15  
    16  type NodePoolJobsCommand struct {
    17  	Meta
    18  }
    19  
    20  func (c *NodePoolJobsCommand) Name() string {
    21  	return "node pool jobs"
    22  }
    23  
    24  func (c *NodePoolJobsCommand) Synopsis() string {
    25  	return "Fetch a list of jobs in a node pool"
    26  }
    27  
    28  func (c *NodePoolJobsCommand) Help() string {
    29  	helpText := `
    30  Usage: nomad node pool jobs <node-pool>
    31  
    32    Node pool jobs is used to list jobs in a given node pool.
    33  
    34    If ACLs are enabled, this command requires a token with the 'read' capability
    35    in a 'node_pool' policy that matches the node pool being targeted. The results
    36    will be filtered by the namespaces where the token has 'read-job' capability.
    37  
    38  General Options:
    39  
    40    ` + generalOptionsUsage(usageOptsDefault) + `
    41  
    42  Node Pool Jobs Options:
    43  
    44    -filter
    45      Specifies an expression used to filter jobs from the results.
    46      The filter is applied to the job and not the node pool.
    47  
    48    -json
    49      Output the list in JSON format.
    50  
    51    -page-token
    52      Where to start pagination.
    53  
    54    -per-page
    55      How many results to show per page. If not specified, or set to 0, all
    56      results are returned.
    57  
    58    -t
    59      Format and display jobs list using a Go template.
    60  `
    61  
    62  	return strings.TrimSpace(helpText)
    63  }
    64  
    65  func (c *NodePoolJobsCommand) AutocompleteFlags() complete.Flags {
    66  	return mergeAutocompleteFlags(c.Meta.AutocompleteFlags(FlagSetClient),
    67  		complete.Flags{
    68  			"-filter":     complete.PredictAnything,
    69  			"-json":       complete.PredictNothing,
    70  			"-page-token": complete.PredictAnything,
    71  			"-per-page":   complete.PredictAnything,
    72  			"-t":          complete.PredictAnything,
    73  		})
    74  }
    75  
    76  func (c *NodePoolJobsCommand) AutocompleteArgs() complete.Predictor {
    77  	return nodePoolPredictor(c.Client, nil)
    78  }
    79  
    80  func (c *NodePoolJobsCommand) Run(args []string) int {
    81  	var json bool
    82  	var perPage int
    83  	var pageToken, filter, tmpl string
    84  
    85  	flags := c.Meta.FlagSet(c.Name(), FlagSetClient)
    86  	flags.Usage = func() { c.Ui.Output(c.Help()) }
    87  	flags.BoolVar(&json, "json", false, "")
    88  	flags.StringVar(&filter, "filter", "", "")
    89  	flags.StringVar(&pageToken, "page-token", "", "")
    90  	flags.IntVar(&perPage, "per-page", 0, "")
    91  	flags.StringVar(&tmpl, "t", "", "")
    92  
    93  	if err := flags.Parse(args); err != nil {
    94  		return 1
    95  	}
    96  
    97  	// Check that we only have one argument.
    98  	args = flags.Args()
    99  	if len(args) != 1 {
   100  		c.Ui.Error("This command takes one argument: <node-pool>")
   101  		c.Ui.Error(commandErrorText(c))
   102  		return 1
   103  	}
   104  
   105  	// Lookup node pool by prefix.
   106  	client, err := c.Meta.Client()
   107  	if err != nil {
   108  		c.Ui.Error(fmt.Sprintf("Error initializing client: %s", err))
   109  		return 1
   110  	}
   111  
   112  	pool, possible, err := nodePoolByPrefix(client, args[0])
   113  	if err != nil {
   114  		c.Ui.Error(fmt.Sprintf("Error retrieving node pool: %s", err))
   115  		return 1
   116  	}
   117  	if len(possible) != 0 {
   118  		c.Ui.Error(fmt.Sprintf(
   119  			"Prefix matched multiple node pools\n\n%s", formatNodePoolList(possible)))
   120  		return 1
   121  	}
   122  
   123  	opts := &api.QueryOptions{
   124  		Filter:    filter,
   125  		PerPage:   int32(perPage),
   126  		NextToken: pageToken,
   127  	}
   128  
   129  	jobs, qm, err := client.NodePools().ListJobs(pool.Name, opts)
   130  	if err != nil {
   131  		c.Ui.Error(fmt.Sprintf("Error querying jobs: %s", err))
   132  		return 1
   133  	}
   134  
   135  	if len(jobs) == 0 {
   136  		c.Ui.Output("No jobs")
   137  		return 0
   138  	}
   139  
   140  	// Format output if requested.
   141  	if json || tmpl != "" {
   142  		out, err := Format(json, tmpl, jobs)
   143  		if err != nil {
   144  			c.Ui.Error(err.Error())
   145  			return 1
   146  		}
   147  
   148  		c.Ui.Output(out)
   149  		return 0
   150  	}
   151  
   152  	c.Ui.Output(createStatusListOutput(jobs, c.allNamespaces()))
   153  
   154  	if qm.NextToken != "" {
   155  		c.Ui.Output(fmt.Sprintf(`
   156   Results have been paginated. To get the next page run:
   157  
   158   %s -page-token %s`, argsWithoutPageToken(os.Args), qm.NextToken))
   159  	}
   160  
   161  	return 0
   162  }