Servant.Client.Internal.HttpClient

Documentation

data ClientEnv

The environment in which a request is run. The $sel:baseUrl:ClientEnv and $sel:makeClientRequest:ClientEnv function are used to create a http-client request. Cookies are then added to that request if a CookieJar is set on the environment. Finally the request is executed with the $sel:manager:ClientEnv. The $sel:makeClientRequest:ClientEnv function can be used to modify the request to execute and set values which are not specified on a servant RequestF like responseTimeout or redirectCount

Constructors

ClientEnv

Fields

• manager :: Manager
• baseUrl :: BaseUrl
• cookieJar :: Maybe (TVar CookieJar)
• makeClientRequest :: BaseUrl -> Request -> IO Request

  this function can be used to customize the creation of http-client requests from servant requests. Default value: defaultMakeClientRequest Note that: 1. $sel:makeClientRequest:ClientEnv exists to allow overriding operational semantics e.g. responseTimeout per request, If you need global modifications, you should use managerModifyRequest 2. the $sel:cookieJar:ClientEnv, if defined, is being applied after $sel:makeClientRequest:ClientEnv is called.

• middleware :: ClientMiddleware

Instances

MonadReader ClientEnv ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

ask :: ClientM ClientEnv

local :: (ClientEnv -> ClientEnv) -> ClientM a -> ClientM a

reader :: (ClientEnv -> a) -> ClientM a

MonadReader ClientEnv ClientM

Defined in Servant.Client.Internal.HttpClient.Streaming

Methods

ask :: ClientM ClientEnv

local :: (ClientEnv -> ClientEnv) -> ClientM a -> ClientM a

reader :: (ClientEnv -> a) -> ClientM a

type ClientApplication = Request -> ClientM Response

type ClientMiddleware = ClientApplication -> ClientApplication

mkClientEnv :: Manager -> BaseUrl -> ClientEnv

ClientEnv smart constructor.

client :: HasClient ClientM api => Proxy api -> Client ClientM api

Generates a set of client functions for an API.

Example:

type API = Capture "no" Int :> Get '[JSON] Int
       :<|> Get '[JSON] [Bool]

api :: Proxy API
api = Proxy

getInt :: Int -> ClientM Int
getBools :: ClientM [Bool]
getInt :<|> getBools = client api

hoistClient :: HasClient ClientM api => Proxy api -> (forall a. m a -> n a) -> Client m api -> Client n api

Change the monad the client functions live in, by supplying a conversion function (a natural transformation to be precise).

For example, assuming you have some manager :: Manager and baseurl :: BaseUrl around:

type API = Get '[JSON] Int :<|> Capture "n" Int :> Post '[JSON] Int
api :: Proxy API
api = Proxy
getInt :: IO Int
postInt :: Int -> IO Int
getInt :<|> postInt = hoistClient api (flip runClientM cenv) (client api)
  where cenv = mkClientEnv manager baseurl

newtype ClientM a

ClientM is the monad in which client functions run. Contains the Manager and BaseUrl used for requests in the reader environment.

Constructors

ClientM

Fields

• unClientM :: ReaderT ClientEnv (ExceptT ClientError IO) a

Instances

MonadIO ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

liftIO :: IO a -> ClientM a

Applicative ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

pure :: a -> ClientM a

(<*>) :: ClientM (a -> b) -> ClientM a -> ClientM b

liftA2 :: (a -> b -> c) -> ClientM a -> ClientM b -> ClientM c

(*>) :: ClientM a -> ClientM b -> ClientM b

(<*) :: ClientM a -> ClientM b -> ClientM a

Functor ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

fmap :: (a -> b) -> ClientM a -> ClientM b

(<$) :: a -> ClientM b -> ClientM a

Monad ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

(>>=) :: ClientM a -> (a -> ClientM b) -> ClientM b

(>>) :: ClientM a -> ClientM b -> ClientM b

return :: a -> ClientM a

MonadCatch ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

catch :: (HasCallStack, Exception e) => ClientM a -> (e -> ClientM a) -> ClientM a

MonadMask ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

mask :: HasCallStack => ((forall a. ClientM a -> ClientM a) -> ClientM b) -> ClientM b

uninterruptibleMask :: HasCallStack => ((forall a. ClientM a -> ClientM a) -> ClientM b) -> ClientM b

generalBracket :: HasCallStack => ClientM a -> (a -> ExitCase b -> ClientM c) -> (a -> ClientM b) -> ClientM (b, c)

MonadThrow ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

throwM :: (HasCallStack, Exception e) => e -> ClientM a

Alt ClientM

Try clients in order, last error is preserved.

Defined in Servant.Client.Internal.HttpClient

Methods

(<!>) :: ClientM a -> ClientM a -> ClientM a

some :: Applicative ClientM => ClientM a -> ClientM [a]

many :: Applicative ClientM => ClientM a -> ClientM [a]

RunClient ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

runRequestAcceptStatus :: Maybe [Status] -> Request -> ClientM Response

throwClientError :: ClientError -> ClientM a

MonadBaseControl IO ClientM

Defined in Servant.Client.Internal.HttpClient

Associated Types

type StM ClientM a

Methods

liftBaseWith :: (RunInBase ClientM IO -> IO a) -> ClientM a

restoreM :: StM ClientM a -> ClientM a

MonadError ClientError ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

throwError :: ClientError -> ClientM a

catchError :: ClientM a -> (ClientError -> ClientM a) -> ClientM a

MonadReader ClientEnv ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

ask :: ClientM ClientEnv

local :: (ClientEnv -> ClientEnv) -> ClientM a -> ClientM a

reader :: (ClientEnv -> a) -> ClientM a

MonadBase IO ClientM

Defined in Servant.Client.Internal.HttpClient

Methods

liftBase :: IO α -> ClientM α

Generic (ClientM a)

Defined in Servant.Client.Internal.HttpClient

Associated Types

type Rep (ClientM a) :: Type -> Type

Methods

from :: ClientM a -> Rep (ClientM a) x

to :: Rep (ClientM a) x -> ClientM a

type StM ClientM a

Defined in Servant.Client.Internal.HttpClient

type StM ClientM a = Either ClientError a

type Rep (ClientM a)

Defined in Servant.Client.Internal.HttpClient

type Rep (ClientM a) = Rep (ReaderT ClientEnv (ExceptT ClientError IO) a)

runClientM :: ClientM a -> ClientEnv -> IO (Either ClientError a)

performRequest :: Maybe [Status] -> Request -> ClientM Response

mkFailureResponse :: BaseUrl -> Request -> ResponseF ByteString -> ClientError

clientResponseToResponse :: (a -> b) -> Response a -> ResponseF b

defaultMakeClientRequest :: BaseUrl -> Request -> IO Request

Create a http-client Request from a servant RequestF The host, path and port fields are extracted from the BaseUrl otherwise the body, headers and query string are derived from the servant RequestF

catchConnectionError :: IO a -> IO (Either ClientError a)