packages feed

amazonka 1.6.0 → 1.6.1

raw patch · 4 files changed

+45/−8 lines, 4 filesdep +unliftio-coredep ~amazonka-coredep ~http-clientPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: unliftio-core

Dependency ranges changed: amazonka-core, http-client

API changes (from Hackage documentation)

- Network.AWS.Auth: instance GHC.Exception.Exception Network.AWS.Auth.AuthError
- Network.AWS.Auth: instance Network.AWS.Auth.AsAuthError GHC.Exception.SomeException
+ Control.Monad.Trans.AWS: -- | The successful, expected response associated with a request.
+ Control.Monad.Trans.AWS: AccessKey :: ByteString -> AccessKey
+ Control.Monad.Trans.AWS: Auth :: AuthEnv -> Auth
+ Control.Monad.Trans.AWS: AuthEnv :: !AccessKey -> !Sensitive SecretKey -> Maybe (Sensitive SessionToken) -> Maybe ISO8601 -> AuthEnv
+ Control.Monad.Trans.AWS: ErrorCode :: Text -> ErrorCode
+ Control.Monad.Trans.AWS: ErrorMessage :: Text -> ErrorMessage
+ Control.Monad.Trans.AWS: Exponential :: !Double -> !Int -> !Int -> (ServiceError -> Maybe Text) -> Retry
+ Control.Monad.Trans.AWS: Ref :: ThreadId -> IORef AuthEnv -> Auth
+ Control.Monad.Trans.AWS: Request :: !Service -> !StdMethod -> !RawPath -> !QueryString -> ![Header] -> !RqBody -> Request a
+ Control.Monad.Trans.AWS: RequestId :: Text -> RequestId
+ Control.Monad.Trans.AWS: Seconds :: Int -> Seconds
+ Control.Monad.Trans.AWS: SecretKey :: ByteString -> SecretKey
+ Control.Monad.Trans.AWS: SerializeError :: SerializeError -> Error
+ Control.Monad.Trans.AWS: SerializeError' :: !Abbrev -> !Status -> Maybe LazyByteString -> String -> SerializeError
+ Control.Monad.Trans.AWS: Service :: !Abbrev -> !Signer -> !ByteString -> !ByteString -> !Region -> Endpoint -> !Maybe Seconds -> !Status -> Bool -> !Status -> [Header] -> LazyByteString -> Error -> !Retry -> Service
+ Control.Monad.Trans.AWS: ServiceError :: ServiceError -> Error
+ Control.Monad.Trans.AWS: ServiceError' :: !Abbrev -> !Status -> [Header] -> !ErrorCode -> Maybe ErrorMessage -> Maybe RequestId -> ServiceError
+ Control.Monad.Trans.AWS: SessionToken :: ByteString -> SessionToken
+ Control.Monad.Trans.AWS: Signed :: !Meta -> !ClientRequest -> Signed a
+ Control.Monad.Trans.AWS: Signer :: (forall a. () => Algorithm a) -> (forall a. () => Seconds -> Algorithm a) -> Signer
+ Control.Monad.Trans.AWS: TransportError :: HttpException -> Error
+ Control.Monad.Trans.AWS: [Meta] :: forall a. ToLog a => a -> Meta
+ Control.Monad.Trans.AWS: [_authAccess] :: AuthEnv -> !AccessKey
+ Control.Monad.Trans.AWS: [_authExpiry] :: AuthEnv -> Maybe ISO8601
+ Control.Monad.Trans.AWS: [_authSecret] :: AuthEnv -> !Sensitive SecretKey
+ Control.Monad.Trans.AWS: [_authToken] :: AuthEnv -> Maybe (Sensitive SessionToken)
+ Control.Monad.Trans.AWS: [_retryAttempts] :: Retry -> !Int
+ Control.Monad.Trans.AWS: [_retryBase] :: Retry -> !Double
+ Control.Monad.Trans.AWS: [_retryCheck] :: Retry -> ServiceError -> Maybe Text
+ Control.Monad.Trans.AWS: [_retryGrowth] :: Retry -> !Int
+ Control.Monad.Trans.AWS: [_rqBody] :: Request a -> !RqBody
+ Control.Monad.Trans.AWS: [_rqHeaders] :: Request a -> ![Header]
+ Control.Monad.Trans.AWS: [_rqMethod] :: Request a -> !StdMethod
+ Control.Monad.Trans.AWS: [_rqPath] :: Request a -> !RawPath
+ Control.Monad.Trans.AWS: [_rqQuery] :: Request a -> !QueryString
+ Control.Monad.Trans.AWS: [_rqService] :: Request a -> !Service
+ Control.Monad.Trans.AWS: [_serializeAbbrev] :: SerializeError -> !Abbrev
+ Control.Monad.Trans.AWS: [_serializeBody] :: SerializeError -> Maybe LazyByteString
+ Control.Monad.Trans.AWS: [_serializeMessage] :: SerializeError -> String
+ Control.Monad.Trans.AWS: [_serializeStatus] :: SerializeError -> !Status
+ Control.Monad.Trans.AWS: [_serviceAbbrev] :: ServiceError -> !Abbrev
+ Control.Monad.Trans.AWS: [_serviceCode] :: ServiceError -> !ErrorCode
+ Control.Monad.Trans.AWS: [_serviceHeaders] :: ServiceError -> [Header]
+ Control.Monad.Trans.AWS: [_serviceMessage] :: ServiceError -> Maybe ErrorMessage
+ Control.Monad.Trans.AWS: [_serviceRequestId] :: ServiceError -> Maybe RequestId
+ Control.Monad.Trans.AWS: [_serviceStatus] :: ServiceError -> !Status
+ Control.Monad.Trans.AWS: [_svcAbbrev] :: Service -> !Abbrev
+ Control.Monad.Trans.AWS: [_svcCheck] :: Service -> !Status -> Bool
+ Control.Monad.Trans.AWS: [_svcEndpoint] :: Service -> !Region -> Endpoint
+ Control.Monad.Trans.AWS: [_svcError] :: Service -> !Status -> [Header] -> LazyByteString -> Error
+ Control.Monad.Trans.AWS: [_svcPrefix] :: Service -> !ByteString
+ Control.Monad.Trans.AWS: [_svcRetry] :: Service -> !Retry
+ Control.Monad.Trans.AWS: [_svcSigner] :: Service -> !Signer
+ Control.Monad.Trans.AWS: [_svcTimeout] :: Service -> !Maybe Seconds
+ Control.Monad.Trans.AWS: [_svcVersion] :: Service -> !ByteString
+ Control.Monad.Trans.AWS: [sgMeta] :: Signed a -> !Meta
+ Control.Monad.Trans.AWS: [sgPresign] :: Signer -> forall a. () => Seconds -> Algorithm a
+ Control.Monad.Trans.AWS: [sgRequest] :: Signed a -> !ClientRequest
+ Control.Monad.Trans.AWS: [sgSign] :: Signer -> forall a. () => Algorithm a
+ Control.Monad.Trans.AWS: _Coerce :: (Coercible a b, Coercible b a) => Iso' a b
+ Control.Monad.Trans.AWS: _Default :: Monoid a => Iso' (Maybe a) a
+ Control.Monad.Trans.AWS: accessKeyId :: Lens' AuthEnv AccessKey
+ Control.Monad.Trans.AWS: class AWSRequest a => AWSPager a
+ Control.Monad.Trans.AWS: class AWSRequest a where {
+ Control.Monad.Trans.AWS: clientRequest :: Endpoint -> Maybe Seconds -> ClientRequest
+ Control.Monad.Trans.AWS: data Abbrev
+ Control.Monad.Trans.AWS: data Accept
+ Control.Monad.Trans.AWS: data Auth
+ Control.Monad.Trans.AWS: data AuthEnv
+ Control.Monad.Trans.AWS: data Error
+ Control.Monad.Trans.AWS: data HttpException
+ Control.Monad.Trans.AWS: data Meta
+ Control.Monad.Trans.AWS: data Request a
+ Control.Monad.Trans.AWS: data Retry
+ Control.Monad.Trans.AWS: data SerializeError
+ Control.Monad.Trans.AWS: data Service
+ Control.Monad.Trans.AWS: data ServiceError
+ Control.Monad.Trans.AWS: data Signed a
+ Control.Monad.Trans.AWS: data Signer
+ Control.Monad.Trans.AWS: data Wait a
+ Control.Monad.Trans.AWS: endpointHost :: Lens' Endpoint ByteString
+ Control.Monad.Trans.AWS: endpointPort :: Lens' Endpoint Int
+ Control.Monad.Trans.AWS: endpointScope :: Lens' Endpoint ByteString
+ Control.Monad.Trans.AWS: endpointSecure :: Lens' Endpoint Bool
+ Control.Monad.Trans.AWS: errorCode :: Text -> ErrorCode
+ Control.Monad.Trans.AWS: expiration :: Lens' AuthEnv (Maybe UTCTime)
+ Control.Monad.Trans.AWS: exponentBase :: Lens' Retry Double
+ Control.Monad.Trans.AWS: exponentGrowth :: Lens' Retry Int
+ Control.Monad.Trans.AWS: instance Control.Monad.IO.Unlift.MonadUnliftIO m => Control.Monad.IO.Unlift.MonadUnliftIO (Control.Monad.Trans.AWS.AWST' r m)
+ Control.Monad.Trans.AWS: microseconds :: Seconds -> Int
+ Control.Monad.Trans.AWS: newtype AccessKey
+ Control.Monad.Trans.AWS: newtype ErrorCode
+ Control.Monad.Trans.AWS: newtype ErrorMessage
+ Control.Monad.Trans.AWS: newtype RequestId
+ Control.Monad.Trans.AWS: newtype Seconds
+ Control.Monad.Trans.AWS: newtype SecretKey
+ Control.Monad.Trans.AWS: newtype SessionToken
+ Control.Monad.Trans.AWS: page :: AWSPager a => a -> Rs a -> Maybe a
+ Control.Monad.Trans.AWS: request :: AWSRequest a => a -> Request a
+ Control.Monad.Trans.AWS: response :: (AWSRequest a, MonadResource m, MonadThrow m) => Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
+ Control.Monad.Trans.AWS: retryAttempts :: Lens' Retry Int
+ Control.Monad.Trans.AWS: retryCheck :: Lens' Retry (ServiceError -> Maybe Text)
+ Control.Monad.Trans.AWS: rqBody :: () => Lens' (Request a) RqBody
+ Control.Monad.Trans.AWS: rqHeaders :: () => Lens' (Request a) [Header]
+ Control.Monad.Trans.AWS: rqMethod :: () => Lens' (Request a) StdMethod
+ Control.Monad.Trans.AWS: rqPath :: () => Lens' (Request a) RawPath
+ Control.Monad.Trans.AWS: rqPresign :: () => Seconds -> Algorithm a
+ Control.Monad.Trans.AWS: rqQuery :: () => Lens' (Request a) QueryString
+ Control.Monad.Trans.AWS: rqService :: () => Lens' (Request a) Service
+ Control.Monad.Trans.AWS: rqSign :: () => Algorithm a
+ Control.Monad.Trans.AWS: seconds :: Seconds -> Int
+ Control.Monad.Trans.AWS: secretAccessKey :: Lens' AuthEnv SecretKey
+ Control.Monad.Trans.AWS: serializeAbbrev :: Lens' SerializeError Abbrev
+ Control.Monad.Trans.AWS: serializeMessage :: Lens' SerializeError String
+ Control.Monad.Trans.AWS: serializeStatus :: Lens' SerializeError Status
+ Control.Monad.Trans.AWS: serviceAbbrev :: Lens' ServiceError Abbrev
+ Control.Monad.Trans.AWS: serviceCheck :: Lens' Service (Status -> Bool)
+ Control.Monad.Trans.AWS: serviceCode :: Lens' ServiceError ErrorCode
+ Control.Monad.Trans.AWS: serviceEndpoint :: Setter' Service Endpoint
+ Control.Monad.Trans.AWS: serviceHeaders :: Lens' ServiceError [Header]
+ Control.Monad.Trans.AWS: serviceMessage :: Lens' ServiceError (Maybe ErrorMessage)
+ Control.Monad.Trans.AWS: serviceRequestId :: Lens' ServiceError (Maybe RequestId)
+ Control.Monad.Trans.AWS: serviceRetry :: Lens' Service Retry
+ Control.Monad.Trans.AWS: serviceSigner :: Lens' Service Signer
+ Control.Monad.Trans.AWS: serviceStatus :: Lens' ServiceError Status
+ Control.Monad.Trans.AWS: serviceTimeout :: Lens' Service (Maybe Seconds)
+ Control.Monad.Trans.AWS: sessionToken :: Lens' AuthEnv (Maybe SessionToken)
+ Control.Monad.Trans.AWS: type Algorithm a = Request a -> AuthEnv -> Region -> UTCTime -> Signed a
+ Control.Monad.Trans.AWS: type ClientRequest = Request
+ Control.Monad.Trans.AWS: type ClientResponse = Response ResponseBody
+ Control.Monad.Trans.AWS: type Response a = (Status, Rs a)
+ Control.Monad.Trans.AWS: type ResponseBody = ConduitM () ByteString ResourceT IO ()
+ Control.Monad.Trans.AWS: type family Rs a :: Type;
+ Control.Monad.Trans.AWS: withAuth :: MonadIO m => Auth -> (AuthEnv -> m a) -> m a
+ Control.Monad.Trans.AWS: }
+ Network.AWS: -- | The successful, expected response associated with a request.
+ Network.AWS: AccessKey :: ByteString -> AccessKey
+ Network.AWS: Auth :: AuthEnv -> Auth
+ Network.AWS: AuthEnv :: !AccessKey -> !Sensitive SecretKey -> Maybe (Sensitive SessionToken) -> Maybe ISO8601 -> AuthEnv
+ Network.AWS: ErrorCode :: Text -> ErrorCode
+ Network.AWS: ErrorMessage :: Text -> ErrorMessage
+ Network.AWS: Exponential :: !Double -> !Int -> !Int -> (ServiceError -> Maybe Text) -> Retry
+ Network.AWS: Ref :: ThreadId -> IORef AuthEnv -> Auth
+ Network.AWS: Request :: !Service -> !StdMethod -> !RawPath -> !QueryString -> ![Header] -> !RqBody -> Request a
+ Network.AWS: RequestId :: Text -> RequestId
+ Network.AWS: Seconds :: Int -> Seconds
+ Network.AWS: SecretKey :: ByteString -> SecretKey
+ Network.AWS: SerializeError :: SerializeError -> Error
+ Network.AWS: SerializeError' :: !Abbrev -> !Status -> Maybe LazyByteString -> String -> SerializeError
+ Network.AWS: Service :: !Abbrev -> !Signer -> !ByteString -> !ByteString -> !Region -> Endpoint -> !Maybe Seconds -> !Status -> Bool -> !Status -> [Header] -> LazyByteString -> Error -> !Retry -> Service
+ Network.AWS: ServiceError :: ServiceError -> Error
+ Network.AWS: ServiceError' :: !Abbrev -> !Status -> [Header] -> !ErrorCode -> Maybe ErrorMessage -> Maybe RequestId -> ServiceError
+ Network.AWS: SessionToken :: ByteString -> SessionToken
+ Network.AWS: Signed :: !Meta -> !ClientRequest -> Signed a
+ Network.AWS: Signer :: (forall a. () => Algorithm a) -> (forall a. () => Seconds -> Algorithm a) -> Signer
+ Network.AWS: TransportError :: HttpException -> Error
+ Network.AWS: [Meta] :: forall a. ToLog a => a -> Meta
+ Network.AWS: [_authAccess] :: AuthEnv -> !AccessKey
+ Network.AWS: [_authExpiry] :: AuthEnv -> Maybe ISO8601
+ Network.AWS: [_authSecret] :: AuthEnv -> !Sensitive SecretKey
+ Network.AWS: [_authToken] :: AuthEnv -> Maybe (Sensitive SessionToken)
+ Network.AWS: [_retryAttempts] :: Retry -> !Int
+ Network.AWS: [_retryBase] :: Retry -> !Double
+ Network.AWS: [_retryCheck] :: Retry -> ServiceError -> Maybe Text
+ Network.AWS: [_retryGrowth] :: Retry -> !Int
+ Network.AWS: [_rqBody] :: Request a -> !RqBody
+ Network.AWS: [_rqHeaders] :: Request a -> ![Header]
+ Network.AWS: [_rqMethod] :: Request a -> !StdMethod
+ Network.AWS: [_rqPath] :: Request a -> !RawPath
+ Network.AWS: [_rqQuery] :: Request a -> !QueryString
+ Network.AWS: [_rqService] :: Request a -> !Service
+ Network.AWS: [_serializeAbbrev] :: SerializeError -> !Abbrev
+ Network.AWS: [_serializeBody] :: SerializeError -> Maybe LazyByteString
+ Network.AWS: [_serializeMessage] :: SerializeError -> String
+ Network.AWS: [_serializeStatus] :: SerializeError -> !Status
+ Network.AWS: [_serviceAbbrev] :: ServiceError -> !Abbrev
+ Network.AWS: [_serviceCode] :: ServiceError -> !ErrorCode
+ Network.AWS: [_serviceHeaders] :: ServiceError -> [Header]
+ Network.AWS: [_serviceMessage] :: ServiceError -> Maybe ErrorMessage
+ Network.AWS: [_serviceRequestId] :: ServiceError -> Maybe RequestId
+ Network.AWS: [_serviceStatus] :: ServiceError -> !Status
+ Network.AWS: [_svcAbbrev] :: Service -> !Abbrev
+ Network.AWS: [_svcCheck] :: Service -> !Status -> Bool
+ Network.AWS: [_svcEndpoint] :: Service -> !Region -> Endpoint
+ Network.AWS: [_svcError] :: Service -> !Status -> [Header] -> LazyByteString -> Error
+ Network.AWS: [_svcPrefix] :: Service -> !ByteString
+ Network.AWS: [_svcRetry] :: Service -> !Retry
+ Network.AWS: [_svcSigner] :: Service -> !Signer
+ Network.AWS: [_svcTimeout] :: Service -> !Maybe Seconds
+ Network.AWS: [_svcVersion] :: Service -> !ByteString
+ Network.AWS: [sgMeta] :: Signed a -> !Meta
+ Network.AWS: [sgPresign] :: Signer -> forall a. () => Seconds -> Algorithm a
+ Network.AWS: [sgRequest] :: Signed a -> !ClientRequest
+ Network.AWS: [sgSign] :: Signer -> forall a. () => Algorithm a
+ Network.AWS: _Coerce :: (Coercible a b, Coercible b a) => Iso' a b
+ Network.AWS: _Default :: Monoid a => Iso' (Maybe a) a
+ Network.AWS: accessKeyId :: Lens' AuthEnv AccessKey
+ Network.AWS: class AWSRequest a => AWSPager a
+ Network.AWS: class AWSRequest a where {
+ Network.AWS: clientRequest :: Endpoint -> Maybe Seconds -> ClientRequest
+ Network.AWS: data Abbrev
+ Network.AWS: data Auth
+ Network.AWS: data AuthEnv
+ Network.AWS: data Error
+ Network.AWS: data HttpException
+ Network.AWS: data Meta
+ Network.AWS: data Request a
+ Network.AWS: data Retry
+ Network.AWS: data SerializeError
+ Network.AWS: data Service
+ Network.AWS: data ServiceError
+ Network.AWS: data Signed a
+ Network.AWS: data Signer
+ Network.AWS: data Wait a
+ Network.AWS: endpointHost :: Lens' Endpoint ByteString
+ Network.AWS: endpointPort :: Lens' Endpoint Int
+ Network.AWS: endpointScope :: Lens' Endpoint ByteString
+ Network.AWS: endpointSecure :: Lens' Endpoint Bool
+ Network.AWS: errorCode :: Text -> ErrorCode
+ Network.AWS: expiration :: Lens' AuthEnv (Maybe UTCTime)
+ Network.AWS: exponentBase :: Lens' Retry Double
+ Network.AWS: exponentGrowth :: Lens' Retry Int
+ Network.AWS: microseconds :: Seconds -> Int
+ Network.AWS: newtype AccessKey
+ Network.AWS: newtype ErrorCode
+ Network.AWS: newtype ErrorMessage
+ Network.AWS: newtype RequestId
+ Network.AWS: newtype Seconds
+ Network.AWS: newtype SecretKey
+ Network.AWS: newtype SessionToken
+ Network.AWS: request :: AWSRequest a => a -> Request a
+ Network.AWS: response :: (AWSRequest a, MonadResource m, MonadThrow m) => Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
+ Network.AWS: retryAttempts :: Lens' Retry Int
+ Network.AWS: retryCheck :: Lens' Retry (ServiceError -> Maybe Text)
+ Network.AWS: rqBody :: () => Lens' (Request a) RqBody
+ Network.AWS: rqHeaders :: () => Lens' (Request a) [Header]
+ Network.AWS: rqMethod :: () => Lens' (Request a) StdMethod
+ Network.AWS: rqPath :: () => Lens' (Request a) RawPath
+ Network.AWS: rqPresign :: () => Seconds -> Algorithm a
+ Network.AWS: rqQuery :: () => Lens' (Request a) QueryString
+ Network.AWS: rqService :: () => Lens' (Request a) Service
+ Network.AWS: rqSign :: () => Algorithm a
+ Network.AWS: seconds :: Seconds -> Int
+ Network.AWS: secretAccessKey :: Lens' AuthEnv SecretKey
+ Network.AWS: serializeAbbrev :: Lens' SerializeError Abbrev
+ Network.AWS: serializeMessage :: Lens' SerializeError String
+ Network.AWS: serializeStatus :: Lens' SerializeError Status
+ Network.AWS: serviceAbbrev :: Lens' ServiceError Abbrev
+ Network.AWS: serviceCheck :: Lens' Service (Status -> Bool)
+ Network.AWS: serviceCode :: Lens' ServiceError ErrorCode
+ Network.AWS: serviceEndpoint :: Setter' Service Endpoint
+ Network.AWS: serviceHeaders :: Lens' ServiceError [Header]
+ Network.AWS: serviceMessage :: Lens' ServiceError (Maybe ErrorMessage)
+ Network.AWS: serviceRequestId :: Lens' ServiceError (Maybe RequestId)
+ Network.AWS: serviceRetry :: Lens' Service Retry
+ Network.AWS: serviceSigner :: Lens' Service Signer
+ Network.AWS: serviceStatus :: Lens' ServiceError Status
+ Network.AWS: serviceTimeout :: Lens' Service (Maybe Seconds)
+ Network.AWS: sessionToken :: Lens' AuthEnv (Maybe SessionToken)
+ Network.AWS: type Algorithm a = Request a -> AuthEnv -> Region -> UTCTime -> Signed a
+ Network.AWS: type ClientRequest = Request
+ Network.AWS: type ClientResponse = Response ResponseBody
+ Network.AWS: type Response a = (Status, Rs a)
+ Network.AWS: type ResponseBody = ConduitM () ByteString ResourceT IO ()
+ Network.AWS: type family Rs a :: Type;
+ Network.AWS: withAuth :: MonadIO m => Auth -> (AuthEnv -> m a) -> m a
+ Network.AWS: }
+ Network.AWS.Auth: instance GHC.Exception.Type.Exception Network.AWS.Auth.AuthError
+ Network.AWS.Auth: instance Network.AWS.Auth.AsAuthError GHC.Exception.Type.SomeException
- Control.Monad.Trans.AWS: FromEnv :: Text -> Text -> (Maybe Text) -> (Maybe Text) -> Credentials
+ Control.Monad.Trans.AWS: FromEnv :: Text -> Text -> Maybe Text -> Maybe Text -> Credentials
- Control.Monad.Trans.AWS: _MatchServiceError :: AsError a => Service -> ErrorCode -> Getting First ServiceError a ServiceError
+ Control.Monad.Trans.AWS: _MatchServiceError :: AsError a => Service -> ErrorCode -> Getting (First ServiceError) a ServiceError
- Control.Monad.Trans.AWS: catching :: MonadCatch m => Getting First a SomeException a -> m r -> (a -> m r) -> m r
+ Control.Monad.Trans.AWS: catching :: MonadCatch m => Getting (First a) SomeException a -> m r -> (a -> m r) -> m r
- Control.Monad.Trans.AWS: data ChunkedBody :: *
+ Control.Monad.Trans.AWS: data ChunkedBody
- Control.Monad.Trans.AWS: data Endpoint :: *
+ Control.Monad.Trans.AWS: data Endpoint
- Control.Monad.Trans.AWS: data HashedBody :: *
+ Control.Monad.Trans.AWS: data HashedBody
- Control.Monad.Trans.AWS: data LogLevel :: *
+ Control.Monad.Trans.AWS: data LogLevel
- Control.Monad.Trans.AWS: data Region :: *
+ Control.Monad.Trans.AWS: data Region
- Control.Monad.Trans.AWS: data RqBody :: *
+ Control.Monad.Trans.AWS: data RqBody
- Control.Monad.Trans.AWS: data RsBody :: *
+ Control.Monad.Trans.AWS: data RsBody
- Control.Monad.Trans.AWS: hasCode :: (Applicative f, Choice p) => ErrorCode -> Optic' * * p f ServiceError ServiceError
+ Control.Monad.Trans.AWS: hasCode :: (Applicative f, Choice p) => ErrorCode -> Optic' p f ServiceError ServiceError
- Control.Monad.Trans.AWS: hasService :: (Applicative f, Choice p) => Service -> Optic' * * p f ServiceError ServiceError
+ Control.Monad.Trans.AWS: hasService :: (Applicative f, Choice p) => Service -> Optic' p f ServiceError ServiceError
- Control.Monad.Trans.AWS: hasStatus :: (Applicative f, Choice p) => Int -> Optic' * * p f ServiceError ServiceError
+ Control.Monad.Trans.AWS: hasStatus :: (Applicative f, Choice p) => Int -> Optic' p f ServiceError ServiceError
- Control.Monad.Trans.AWS: newtype ChunkSize :: *
+ Control.Monad.Trans.AWS: newtype ChunkSize
- Control.Monad.Trans.AWS: trying :: MonadCatch m => Getting First a SomeException a -> m r -> m Either a r
+ Control.Monad.Trans.AWS: trying :: MonadCatch m => Getting (First a) SomeException a -> m r -> m (Either a r)
- Control.Monad.Trans.AWS: type AWSConstraint r m = (MonadThrow m, MonadResource m, MonadReader r m, HasEnv r)
+ Control.Monad.Trans.AWS: type AWSConstraint r m = (MonadThrow m, MonadCatch m, MonadResource m, MonadReader r m, HasEnv r)
- Network.AWS: FromEnv :: Text -> Text -> (Maybe Text) -> (Maybe Text) -> Credentials
+ Network.AWS: FromEnv :: Text -> Text -> Maybe Text -> Maybe Text -> Credentials
- Network.AWS: _MatchServiceError :: AsError a => Service -> ErrorCode -> Getting First ServiceError a ServiceError
+ Network.AWS: _MatchServiceError :: AsError a => Service -> ErrorCode -> Getting (First ServiceError) a ServiceError
- Network.AWS: catching :: MonadCatch m => Getting First a SomeException a -> m r -> (a -> m r) -> m r
+ Network.AWS: catching :: MonadCatch m => Getting (First a) SomeException a -> m r -> (a -> m r) -> m r
- Network.AWS: data ChunkedBody :: *
+ Network.AWS: data ChunkedBody
- Network.AWS: data Endpoint :: *
+ Network.AWS: data Endpoint
- Network.AWS: data HashedBody :: *
+ Network.AWS: data HashedBody
- Network.AWS: data LogLevel :: *
+ Network.AWS: data LogLevel
- Network.AWS: data Region :: *
+ Network.AWS: data Region
- Network.AWS: data RqBody :: *
+ Network.AWS: data RqBody
- Network.AWS: data RsBody :: *
+ Network.AWS: data RsBody
- Network.AWS: hasCode :: (Applicative f, Choice p) => ErrorCode -> Optic' * * p f ServiceError ServiceError
+ Network.AWS: hasCode :: (Applicative f, Choice p) => ErrorCode -> Optic' p f ServiceError ServiceError
- Network.AWS: hasService :: (Applicative f, Choice p) => Service -> Optic' * * p f ServiceError ServiceError
+ Network.AWS: hasService :: (Applicative f, Choice p) => Service -> Optic' p f ServiceError ServiceError
- Network.AWS: hasStatus :: (Applicative f, Choice p) => Int -> Optic' * * p f ServiceError ServiceError
+ Network.AWS: hasStatus :: (Applicative f, Choice p) => Int -> Optic' p f ServiceError ServiceError
- Network.AWS: newtype ChunkSize :: *
+ Network.AWS: newtype ChunkSize
- Network.AWS: trying :: MonadCatch m => Getting First a SomeException a -> m r -> m Either a r
+ Network.AWS: trying :: MonadCatch m => Getting (First a) SomeException a -> m r -> m (Either a r)
- Network.AWS.Auth: FromEnv :: Text -> Text -> (Maybe Text) -> (Maybe Text) -> Credentials
+ Network.AWS.Auth: FromEnv :: Text -> Text -> Maybe Text -> Maybe Text -> Credentials
- Network.AWS.Auth: data Auth :: *
+ Network.AWS.Auth: data Auth
- Network.AWS.Auth: newtype AccessKey :: *
+ Network.AWS.Auth: newtype AccessKey
- Network.AWS.Auth: newtype SecretKey :: *
+ Network.AWS.Auth: newtype SecretKey
- Network.AWS.Auth: newtype SessionToken :: *
+ Network.AWS.Auth: newtype SessionToken
- Network.AWS.EC2.Metadata: SecurityCredentials :: (Maybe Text) -> Info
+ Network.AWS.EC2.Metadata: SecurityCredentials :: Maybe Text -> Info
- Network.AWS.Env: Env :: !Region -> !Logger -> !(Int -> HttpException -> Bool) -> !(Dual (Endo Service)) -> !Manager -> !(IORef (Maybe Bool)) -> !Auth -> Env
+ Network.AWS.Env: Env :: !Region -> !Logger -> !Int -> HttpException -> Bool -> !Dual (Endo Service) -> !Manager -> !IORef (Maybe Bool) -> !Auth -> Env
- Network.AWS.Env: [_envEC2] :: Env -> !(IORef (Maybe Bool))
+ Network.AWS.Env: [_envEC2] :: Env -> !IORef (Maybe Bool)
- Network.AWS.Env: [_envOverride] :: Env -> !(Dual (Endo Service))
+ Network.AWS.Env: [_envOverride] :: Env -> !Dual (Endo Service)
- Network.AWS.Env: [_envRetryCheck] :: Env -> !(Int -> HttpException -> Bool)
+ Network.AWS.Env: [_envRetryCheck] :: Env -> !Int -> HttpException -> Bool

Files

CHANGELOG.md view
@@ -1,5 +1,20 @@ # Change Log +## [1.6.1](https://github.com/brendanhay/amazonka/tree/1.6.1)+Released: **03 Feb, 2019**, Compare: [1.6.0](https://github.com/brendanhay/amazonka/compare/1.6.0...1.6.1)++### Fixed++- Correctly catch exceptions in perform. [\#464](https://github.com/brendanhay/amazonka/pull/464)++### Changed++- Add a `MonadUnliftIO` instance for `AWST'`. [\#461](https://github.com/brendanhay/amazonka/pull/461)+- Add FromText instances for Int64, String and Seconds. [\#489](https://github.com/brendanhay/amazonka/pull/489)+- Add generalBracket for MonadMask instance on AWST'. [\#492](https://github.com/brendanhay/amazonka/pull/492)+- Remove fractional seconds from serialization of iso8601 timestamps [\#502](https://github.com/brendanhay/amazonka/pull/502)++ ## [1.6.0](https://github.com/brendanhay/amazonka/tree/1.6.0) Released: **16 May, 2018**, Compare: [1.5.0](https://github.com/brendanhay/amazonka/compare/1.5.0...1.6.0) 
amazonka.cabal view
@@ -1,5 +1,5 @@ name:                  amazonka-version:               1.6.0+version:               1.6.1 synopsis:              Comprehensive Amazon Web Services SDK. homepage:              https://github.com/brendanhay/amazonka bug-reports:           https://github.com/brendanhay/amazonka/issues@@ -60,7 +60,7 @@         , Network.AWS.Internal.Logger      build-depends:-          amazonka-core       == 1.6.0.*+          amazonka-core       == 1.6.1.*         , base                >= 4.7 && < 5         , bytestring          >= 0.9         , conduit             >= 1.1@@ -81,6 +81,7 @@         , transformers        >= 0.2         , transformers-base   >= 0.4         , transformers-compat >= 0.3+        , unliftio-core       >= 0.1         , void                >= 0.1  test-suite tests
src/Control/Monad/Trans/AWS.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE BangPatterns               #-} {-# LANGUAGE ConstraintKinds            #-}+{-# LANGUAGE CPP                        #-} {-# LANGUAGE FlexibleContexts           #-} {-# LANGUAGE FlexibleInstances          #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}@@ -160,6 +161,7 @@ import Control.Monad.Base import Control.Monad.Catch import Control.Monad.Error.Class    (MonadError (..))+import Control.Monad.IO.Unlift import Control.Monad.Morph import Control.Monad.Reader import Control.Monad.State.Class@@ -215,6 +217,15 @@     uninterruptibleMask a = AWST' $ uninterruptibleMask $ \u ->         unAWST $ a (AWST' . u . unAWST) +#if MIN_VERSION_exceptions(0,10,0)+    generalBracket acquire rel action = AWST' $+        generalBracket+            (unAWST acquire)+            (\a ex -> unAWST $ rel a ex)+            (\a -> unAWST $ action a)+#endif++ instance MonadBase b m => MonadBase b (AWST' r m) where     liftBase = liftBaseDefault @@ -230,6 +241,10 @@     liftBaseWith = defaultLiftBaseWith     restoreM     = defaultRestoreM +instance MonadUnliftIO m => MonadUnliftIO (AWST' r m) where+    askUnliftIO = AWST' $ (\(UnliftIO f) -> UnliftIO $ f . unAWST)+        <$> askUnliftIO+ instance MonadResource m => MonadResource (AWST' r m) where     liftResourceT = lift . liftResourceT @@ -263,6 +278,7 @@ -- which 'AWST' implicitly fulfils. type AWSConstraint r m =     ( MonadThrow     m+    , MonadCatch     m     , MonadResource  m     , MonadReader  r m     , HasEnv       r@@ -286,7 +302,7 @@ paginate = go   where     go !x = do-        !y <- send x+        !y <- lift $ send x         yield y         maybe (pure ()) go (page x y) 
src/Network/AWS/Internal/HTTP.hs view
@@ -23,11 +23,10 @@  import Control.Arrow                (first) import Control.Monad-import Control.Monad.Catch (MonadThrow)+import Control.Monad.Catch (MonadThrow, MonadCatch, Handler(Handler), catches) import Control.Monad.Reader import Control.Monad.Trans.Resource import Control.Retry-import Control.Exception (Handler(Handler), catches)  import Data.List   (intersperse) import Data.Monoid@@ -47,6 +46,7 @@ #endif  retrier :: ( MonadThrow m+           , MonadCatch m            , MonadResource m            , MonadReader r m            , HasEnv r@@ -83,6 +83,7 @@           ]  waiter :: ( MonadThrow m+          , MonadCatch m           , MonadResource m           , MonadReader r m           , HasEnv r@@ -122,11 +123,15 @@           ]  -- | The 'Service' is configured + unwrapped at this point.-perform :: (MonadThrow m, MonadResource m, AWSRequest a)+perform :: ( MonadThrow m+           , MonadCatch m+           , MonadResource m+           , AWSRequest a+           )         => Env         -> Request a         -> m (Either Error (Response a))-perform Env{..} x = liftIO $ catches (runResourceT go) handlers+perform Env{..} x = catches go handlers   where     go = do         t           <- liftIO getCurrentTime@@ -142,7 +147,7 @@ #else         rs'         <- liftResourceT (http rq _envManager)         let resSrc   = responseBody rs'-        (src', fin) <- unwrapResumable resSrc+        (src', fin) <- liftResourceT (unwrapResumable resSrc)         let src = addCleanup (const fin) src'         let rs  = src <$ rs' #endif