github.com/quite/nomad@v0.8.6/nomad/structs/errors.go (about)

     1  package structs
     2  
     3  import (
     4  	"errors"
     5  	"fmt"
     6  	"strings"
     7  )
     8  
     9  const (
    10  	errNoLeader            = "No cluster leader"
    11  	errNoRegionPath        = "No path to region"
    12  	errTokenNotFound       = "ACL token not found"
    13  	errPermissionDenied    = "Permission denied"
    14  	errNoNodeConn          = "No path to node"
    15  	errUnknownMethod       = "Unknown rpc method"
    16  	errUnknownNomadVersion = "Unable to determine Nomad version"
    17  	errNodeLacksRpc        = "Node does not support RPC; requires 0.8 or later"
    18  
    19  	// Prefix based errors that are used to check if the error is of a given
    20  	// type. These errors should be created with the associated constructor.
    21  	ErrUnknownAllocationPrefix = "Unknown allocation"
    22  	ErrUnknownNodePrefix       = "Unknown node"
    23  	ErrUnknownJobPrefix        = "Unknown job"
    24  	ErrUnknownEvaluationPrefix = "Unknown evaluation"
    25  	ErrUnknownDeploymentPrefix = "Unknown deployment"
    26  )
    27  
    28  var (
    29  	ErrNoLeader            = errors.New(errNoLeader)
    30  	ErrNoRegionPath        = errors.New(errNoRegionPath)
    31  	ErrTokenNotFound       = errors.New(errTokenNotFound)
    32  	ErrPermissionDenied    = errors.New(errPermissionDenied)
    33  	ErrNoNodeConn          = errors.New(errNoNodeConn)
    34  	ErrUnknownMethod       = errors.New(errUnknownMethod)
    35  	ErrUnknownNomadVersion = errors.New(errUnknownNomadVersion)
    36  	ErrNodeLacksRpc        = errors.New(errNodeLacksRpc)
    37  )
    38  
    39  // IsErrNoLeader returns whether the error is due to there being no leader.
    40  func IsErrNoLeader(err error) bool {
    41  	return err != nil && strings.Contains(err.Error(), errNoLeader)
    42  }
    43  
    44  // IsErrNoRegionPath returns whether the error is due to there being no path to
    45  // the given region.
    46  func IsErrNoRegionPath(err error) bool {
    47  	return err != nil && strings.Contains(err.Error(), errNoRegionPath)
    48  }
    49  
    50  // IsErrTokenNotFound returns whether the error is due to the passed token not
    51  // being resolvable.
    52  func IsErrTokenNotFound(err error) bool {
    53  	return err != nil && strings.Contains(err.Error(), errTokenNotFound)
    54  }
    55  
    56  // IsErrPermissionDenied returns whether the error is due to the operation not
    57  // being allowed due to lack of permissions.
    58  func IsErrPermissionDenied(err error) bool {
    59  	return err != nil && strings.Contains(err.Error(), errPermissionDenied)
    60  }
    61  
    62  // IsErrNoNodeConn returns whether the error is due to there being no path to
    63  // the given node.
    64  func IsErrNoNodeConn(err error) bool {
    65  	return err != nil && strings.Contains(err.Error(), errNoNodeConn)
    66  }
    67  
    68  // IsErrUnknownMethod returns whether the error is due to the operation not
    69  // being allowed due to lack of permissions.
    70  func IsErrUnknownMethod(err error) bool {
    71  	return err != nil && strings.Contains(err.Error(), errUnknownMethod)
    72  }
    73  
    74  // NewErrUnknownAllocation returns a new error caused by the allocation being
    75  // unknown.
    76  func NewErrUnknownAllocation(allocID string) error {
    77  	return fmt.Errorf("%s %q", ErrUnknownAllocationPrefix, allocID)
    78  }
    79  
    80  // NewErrUnknownNode returns a new error caused by the node being unknown.
    81  func NewErrUnknownNode(nodeID string) error {
    82  	return fmt.Errorf("%s %q", ErrUnknownNodePrefix, nodeID)
    83  }
    84  
    85  // NewErrUnknownJob returns a new error caused by the job being unknown.
    86  func NewErrUnknownJob(jobID string) error {
    87  	return fmt.Errorf("%s %q", ErrUnknownJobPrefix, jobID)
    88  }
    89  
    90  // NewErrUnknownEvaluation returns a new error caused by the evaluation being
    91  // unknown.
    92  func NewErrUnknownEvaluation(evaluationID string) error {
    93  	return fmt.Errorf("%s %q", ErrUnknownEvaluationPrefix, evaluationID)
    94  }
    95  
    96  // NewErrUnknownDeployment returns a new error caused by the deployment being
    97  // unknown.
    98  func NewErrUnknownDeployment(deploymentID string) error {
    99  	return fmt.Errorf("%s %q", ErrUnknownDeploymentPrefix, deploymentID)
   100  }
   101  
   102  // IsErrUnknownAllocation returns whether the error is due to an unknown
   103  // allocation.
   104  func IsErrUnknownAllocation(err error) bool {
   105  	return err != nil && strings.Contains(err.Error(), ErrUnknownAllocationPrefix)
   106  }
   107  
   108  // IsErrUnknownNode returns whether the error is due to an unknown
   109  // node.
   110  func IsErrUnknownNode(err error) bool {
   111  	return err != nil && strings.Contains(err.Error(), ErrUnknownNodePrefix)
   112  }
   113  
   114  // IsErrUnknownJob returns whether the error is due to an unknown
   115  // job.
   116  func IsErrUnknownJob(err error) bool {
   117  	return err != nil && strings.Contains(err.Error(), ErrUnknownJobPrefix)
   118  }
   119  
   120  // IsErrUnknownEvaluation returns whether the error is due to an unknown
   121  // evaluation.
   122  func IsErrUnknownEvaluation(err error) bool {
   123  	return err != nil && strings.Contains(err.Error(), ErrUnknownEvaluationPrefix)
   124  }
   125  
   126  // IsErrUnknownDeployment returns whether the error is due to an unknown
   127  // deployment.
   128  func IsErrUnknownDeployment(err error) bool {
   129  	return err != nil && strings.Contains(err.Error(), ErrUnknownDeploymentPrefix)
   130  }
   131  
   132  // IsErrUnknownNomadVersion returns whether the error is due to Nomad being
   133  // unable to determine the version of a node.
   134  func IsErrUnknownNomadVersion(err error) bool {
   135  	return err != nil && strings.Contains(err.Error(), errUnknownNomadVersion)
   136  }
   137  
   138  // IsErrNodeLacksRpc returns whether error is due to a Nomad server being
   139  // unable to connect to a client node because the client is too old (pre-v0.8).
   140  func IsErrNodeLacksRpc(err error) bool {
   141  	return err != nil && strings.Contains(err.Error(), errNodeLacksRpc)
   142  }