errors.go

Documentation: github.com/aws/smithy-go

     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
View as plain text