http.async.client — com.fluree/http.async.client 1.3.1-25-0xae4f

Asynchronous HTTP Client - Clojure

await clj

(await response)

Waits for response processing to be finished. Returns same response.

body clj

(body resp)

Gets body. If body have not yet been delivered and request hasn't failed waits for body.

cancel clj

(cancel resp)

Cancels response.

cancelled? clj

(cancelled? resp)

Checks if response has been cancelled.

close clj

(close client)

Closes client.

close-websocket clj

(close-websocket ws)

content-type clj

(content-type resp)

Gets content type from response.

cookies clj

(cookies resp)

Gets cookies from response.

create-client clj

(create-client &
               {:keys [compression-enabled connection-timeout follow-redirects
                       idle-in-pool-timeout keep-alive max-conns-per-host
                       max-conns-total max-redirects proxy auth read-timeout
                       request-timeout user-agent thread-factory ssl-context]})

Creates new Async Http Client. Arguments:

• :compression-enabled :: enable HTTP compression
• :connection-timeout :: connections timeout in ms
• :follow-redirects :: enable following HTTP redirects
• :idle-in-pool-timeout :: idle connection in pool timeout in ms
• :keep-alive :: enable HTTP keep alive, enabled by default
• :max-conns-per-host :: max number of polled connections per host
• :max-conns-total :: max number of total connections held open by client
• :max-redirects :: max nuber of redirects to follow
• :proxy :: map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user
• :auth :: map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :preemptive - assume authentication is required
• :read-timeout :: read timeout in ms
• :request-timeout :: request timeout in ms
• :user-agent :: User-Agent branding string
• :thread-factory :: Provide your own ThreadFactory for callbacks to be executed with
• :ssl-context :: provide your own SSL Context

DELETE clj

(DELETE client url & {:as options})

Sends asynchronously HTTP DELETE request to url. Returns a map:

• :id - unique ID of request
• :status - promise that once status is received is delivered, contains lazy map of:
  • :code - response code
  • :msg - response message
  • :protocol - protocol with version
  • :major - major version of protocol
  • :minor - minor version of protocol
• :headers - promise that once headers are received is delivered, contains lazy map of:
  • :server - header names are keyworded, values stay not changed
• :body - body of response, depends on request type, might be ByteArrayOutputStream or lazy sequence, use conveniece methods to extract it, like string
• :done - promise that is delivered once receiving response has finished
• :error - promise that is delivered if requesting resource failed, once delivered will contain Throwable. Arguments:
• client - client created via create-client
• url - URL to request
• options - keyworded arguments: :query - map of query parameters, if value is vector than multiple values will be send as n=v1&n=v2 :headers - map of headers :body - body :cookies - cookies to send :proxy - map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user :auth - map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :timeout - request timeout in ms

done? clj

(done? resp)

Checks if request is finished already (response receiving finished).

error clj

(error resp)

Returns Throwable if request processing failed.

failed? clj

(failed? resp)

Checks if request failed.

GET clj

(GET client url & {:as options})

Sends asynchronously HTTP GET request to url. Returns a map:

• :id - unique ID of request
• :status - promise that once status is received is delivered, contains lazy map of:
  • :code - response code
  • :msg - response message
  • :protocol - protocol with version
  • :major - major version of protocol
  • :minor - minor version of protocol
• :headers - promise that once headers are received is delivered, contains lazy map of:
  • :server - header names are keyworded, values stay not changed
• :body - body of response, depends on request type, might be ByteArrayOutputStream or lazy sequence, use conveniece methods to extract it, like string
• :done - promise that is delivered once receiving response has finished
• :error - promise that is delivered if requesting resource failed, once delivered will contain Throwable. Arguments:
• client - client created via create-client
• url - URL to request
• options - keyworded arguments: :query - map of query parameters, if value is vector than multiple values will be send as n=v1&n=v2 :headers - map of headers :body - body :cookies - cookies to send :proxy - map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user :auth - map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :timeout - request timeout in ms

HEAD clj

(HEAD client url & {:as options})

Sends asynchronously HTTP HEAD request to url. Returns a map:

• :id - unique ID of request
• :status - promise that once status is received is delivered, contains lazy map of:
  • :code - response code
  • :msg - response message
  • :protocol - protocol with version
  • :major - major version of protocol
  • :minor - minor version of protocol
• :headers - promise that once headers are received is delivered, contains lazy map of:
  • :server - header names are keyworded, values stay not changed
• :body - body of response, depends on request type, might be ByteArrayOutputStream or lazy sequence, use conveniece methods to extract it, like string
• :done - promise that is delivered once receiving response has finished
• :error - promise that is delivered if requesting resource failed, once delivered will contain Throwable. Arguments:
• client - client created via create-client
• url - URL to request
• options - keyworded arguments: :query - map of query parameters, if value is vector than multiple values will be send as n=v1&n=v2 :headers - map of headers :body - body :cookies - cookies to send :proxy - map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user :auth - map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :timeout - request timeout in ms

headers clj

(headers resp)

Gets headers. If headers have not yet been delivered and request hasn't failed waits for headers.

IClosable clj protocol

-close clj

(-close this)

-open? clj

(-open? this)

location clj

(location resp)

Retrieves location of redirect.

open? clj

(open? client)

Checks if client is open.

OPTIONS clj

(OPTIONS client url & {:as options})

Sends asynchronously HTTP OPTIONS request to url. Returns a map:

• :id - unique ID of request
• :status - promise that once status is received is delivered, contains lazy map of:
  • :code - response code
  • :msg - response message
  • :protocol - protocol with version
  • :major - major version of protocol
  • :minor - minor version of protocol
• :headers - promise that once headers are received is delivered, contains lazy map of:
  • :server - header names are keyworded, values stay not changed
• :body - body of response, depends on request type, might be ByteArrayOutputStream or lazy sequence, use conveniece methods to extract it, like string
• :done - promise that is delivered once receiving response has finished
• :error - promise that is delivered if requesting resource failed, once delivered will contain Throwable. Arguments:
• client - client created via create-client
• url - URL to request
• options - keyworded arguments: :query - map of query parameters, if value is vector than multiple values will be send as n=v1&n=v2 :headers - map of headers :body - body :cookies - cookies to send :proxy - map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user :auth - map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :timeout - request timeout in ms

PATCH clj

(PATCH client url & {:as options})

Sends asynchronously HTTP PATCH request to url. Returns a map:

• :id - unique ID of request
• :status - promise that once status is received is delivered, contains lazy map of:
  • :code - response code
  • :msg - response message
  • :protocol - protocol with version
  • :major - major version of protocol
  • :minor - minor version of protocol
• :headers - promise that once headers are received is delivered, contains lazy map of:
  • :server - header names are keyworded, values stay not changed
• :body - body of response, depends on request type, might be ByteArrayOutputStream or lazy sequence, use conveniece methods to extract it, like string
• :done - promise that is delivered once receiving response has finished
• :error - promise that is delivered if requesting resource failed, once delivered will contain Throwable. Arguments:
• client - client created via create-client
• url - URL to request
• options - keyworded arguments: :query - map of query parameters, if value is vector than multiple values will be send as n=v1&n=v2 :headers - map of headers :body - body :cookies - cookies to send :proxy - map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user :auth - map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :timeout - request timeout in ms

POST clj

(POST client url & {:as options})

Sends asynchronously HTTP POST request to url. Returns a map:

• :id - unique ID of request
• :status - promise that once status is received is delivered, contains lazy map of:
  • :code - response code
  • :msg - response message
  • :protocol - protocol with version
  • :major - major version of protocol
  • :minor - minor version of protocol
• :headers - promise that once headers are received is delivered, contains lazy map of:
  • :server - header names are keyworded, values stay not changed
• :body - body of response, depends on request type, might be ByteArrayOutputStream or lazy sequence, use conveniece methods to extract it, like string
• :done - promise that is delivered once receiving response has finished
• :error - promise that is delivered if requesting resource failed, once delivered will contain Throwable. Arguments:
• client - client created via create-client
• url - URL to request
• options - keyworded arguments: :query - map of query parameters, if value is vector than multiple values will be send as n=v1&n=v2 :headers - map of headers :body - body :cookies - cookies to send :proxy - map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user :auth - map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :timeout - request timeout in ms

PUT clj

(PUT client url & {:as options})

Sends asynchronously HTTP PUT request to url. Returns a map:

• :id - unique ID of request
• :status - promise that once status is received is delivered, contains lazy map of:
  • :code - response code
  • :msg - response message
  • :protocol - protocol with version
  • :major - major version of protocol
  • :minor - minor version of protocol
• :headers - promise that once headers are received is delivered, contains lazy map of:
  • :server - header names are keyworded, values stay not changed
• :body - body of response, depends on request type, might be ByteArrayOutputStream or lazy sequence, use conveniece methods to extract it, like string
• :done - promise that is delivered once receiving response has finished
• :error - promise that is delivered if requesting resource failed, once delivered will contain Throwable. Arguments:
• client - client created via create-client
• url - URL to request
• options - keyworded arguments: :query - map of query parameters, if value is vector than multiple values will be send as n=v1&n=v2 :headers - map of headers :body - body :cookies - cookies to send :proxy - map with proxy configuration to be used :host - proxy host :port - proxy port :protocol - (optional) protocol to communicate with proxy, :http (default, if you provide no value) and :https are allowed :user - (optional) user name to use for proxy authentication, has to be provided with :password :password - (optional) password to use for proxy authentication, has to be provided with :user :auth - map with authentication to be used :type - either :basic or :digest :user - user name to be used :password - password to be used :realm - realm name to authenticate in :timeout - request timeout in ms

redirect? clj

(redirect? resp)

Checks if response is redirect.

request-stream clj

(request-stream client method url body-part-callback & {:as options})

Consumes stream from given url. method - HTTP method to be used (:get, :post, ...) url - URL to set request to body-part-callback - callback that takes status (ref {}) of request and received body part as vector of bytes options - are optional and can contain :headers, :param, and :query (see prepare-request).

send clj

(send ws & {text :text byte :byte})

Send message via WebSocket.

status clj

(status resp)

Gets status if status was delivered.

stream-seq clj

(stream-seq client method url & {:as options})

Creates potentially infinite lazy sequence of Http Stream.

string clj

(string resp)

(string headers body)

Converts response to string. Or converts body taking encoding from response.

uri clj

(uri resp)

Get the request URI from the response

url clj

(url resp)

Gets URL from response

websocket clj

(websocket client url & options)

Opens WebSocket connection.