errors.go raw

   1  package smithy
   2  
   3  import "fmt"
   4  
   5  // APIError provides the generic API and protocol agnostic error type all SDK
   6  // generated exception types will implement.
   7  type APIError interface {
   8  	error
   9  
  10  	// ErrorCode returns the error code for the API exception.
  11  	ErrorCode() string
  12  	// ErrorMessage returns the error message for the API exception.
  13  	ErrorMessage() string
  14  	// ErrorFault returns the fault for the API exception.
  15  	ErrorFault() ErrorFault
  16  }
  17  
  18  // GenericAPIError provides a generic concrete API error type that SDKs can use
  19  // to deserialize error responses into. Should be used for unmodeled or untyped
  20  // errors.
  21  type GenericAPIError struct {
  22  	Code    string
  23  	Message string
  24  	Fault   ErrorFault
  25  }
  26  
  27  // ErrorCode returns the error code for the API exception.
  28  func (e *GenericAPIError) ErrorCode() string { return e.Code }
  29  
  30  // ErrorMessage returns the error message for the API exception.
  31  func (e *GenericAPIError) ErrorMessage() string { return e.Message }
  32  
  33  // ErrorFault returns the fault for the API exception.
  34  func (e *GenericAPIError) ErrorFault() ErrorFault { return e.Fault }
  35  
  36  func (e *GenericAPIError) Error() string {
  37  	return fmt.Sprintf("api error %s: %s", e.Code, e.Message)
  38  }
  39  
  40  var _ APIError = (*GenericAPIError)(nil)
  41  
  42  // OperationError decorates an underlying error which occurred while invoking
  43  // an operation with names of the operation and API.
  44  type OperationError struct {
  45  	ServiceID     string
  46  	OperationName string
  47  	Err           error
  48  }
  49  
  50  // Service returns the name of the API service the error occurred with.
  51  func (e *OperationError) Service() string { return e.ServiceID }
  52  
  53  // Operation returns the name of the API operation the error occurred with.
  54  func (e *OperationError) Operation() string { return e.OperationName }
  55  
  56  // Unwrap returns the nested error if any, or nil.
  57  func (e *OperationError) Unwrap() error { return e.Err }
  58  
  59  func (e *OperationError) Error() string {
  60  	return fmt.Sprintf("operation error %s: %s, %v", e.ServiceID, e.OperationName, e.Err)
  61  }
  62  
  63  // DeserializationError provides a wrapper for an error that occurs during
  64  // deserialization.
  65  type DeserializationError struct {
  66  	Err      error //  original error
  67  	Snapshot []byte
  68  }
  69  
  70  // Error returns a formatted error for DeserializationError
  71  func (e *DeserializationError) Error() string {
  72  	const msg = "deserialization failed"
  73  	if e.Err == nil {
  74  		return msg
  75  	}
  76  	return fmt.Sprintf("%s, %v", msg, e.Err)
  77  }
  78  
  79  // Unwrap returns the underlying Error in DeserializationError
  80  func (e *DeserializationError) Unwrap() error { return e.Err }
  81  
  82  // ErrorFault provides the type for a Smithy API error fault.
  83  type ErrorFault int
  84  
  85  // ErrorFault enumeration values
  86  const (
  87  	FaultUnknown ErrorFault = iota
  88  	FaultServer
  89  	FaultClient
  90  )
  91  
  92  func (f ErrorFault) String() string {
  93  	switch f {
  94  	case FaultServer:
  95  		return "server"
  96  	case FaultClient:
  97  		return "client"
  98  	default:
  99  		return "unknown"
 100  	}
 101  }
 102  
 103  // SerializationError represents an error that occurred while attempting to serialize a request
 104  type SerializationError struct {
 105  	Err error // original error
 106  }
 107  
 108  // Error returns a formatted error for SerializationError
 109  func (e *SerializationError) Error() string {
 110  	const msg = "serialization failed"
 111  	if e.Err == nil {
 112  		return msg
 113  	}
 114  	return fmt.Sprintf("%s: %v", msg, e.Err)
 115  }
 116  
 117  // Unwrap returns the underlying Error in SerializationError
 118  func (e *SerializationError) Unwrap() error { return e.Err }
 119  
 120  // CanceledError is the error that will be returned by an API request that was
 121  // canceled. API operations given a Context may return this error when
 122  // canceled.
 123  type CanceledError struct {
 124  	Err error
 125  }
 126  
 127  // CanceledError returns true to satisfy interfaces checking for canceled errors.
 128  func (*CanceledError) CanceledError() bool { return true }
 129  
 130  // Unwrap returns the underlying error, if there was one.
 131  func (e *CanceledError) Unwrap() error {
 132  	return e.Err
 133  }
 134  
 135  func (e *CanceledError) Error() string {
 136  	return fmt.Sprintf("canceled, %v", e.Err)
 137  }
 138