Plug.Conn

Assigns a value to a key in the connection

Examples

iex> conn.assigns[:hello]
nil
iex> conn = assign(conn, :hello, :world)
iex> conn.assigns[:hello]
:world

Sends a chunk as part of a chunked response.

It expects a connection with state :chunked as set by send_chunked/2. It returns {:ok, conn} in case of success, otherwise {:error, reason}.

Configures the session.

Options

• :renew - generates a new session id for the cookie
• :drop - drops the session, a session cookie will not be included in the response

Deletes a response cookie.

Deleting a cookie requires the same options as to when the cookie was put. Check put_resp_cookie/4 for more information.

Deletes a response header if present.

Raises a Plug.Conn.AlreadySentError if the connection has already been :sent.

Deletes the session for the given key.

The key can be a string or an atom, where atoms are automatically convert to strings.

Fetches cookies from the request headers.

Fetches parameters from the query string.

This function does not fetch parameters from the body. To fetch parameters from the body, use the Plug.Parsers plug.

Fetches the session from the session store. Will also fetch cookies.

Receives the connection and returns the full requested path as a string.

The full path of a request is made by joining its script_path with its path_info.

Examples

iex> conn = %{conn | script_name: ["foo"], path_info: ["bar", "baz"]}
iex> full_path(conn)
"/foo/bar/baz"

Returns the values of the request header specified by key.

Returns the values of the response header specified by key.

Examples

iex> conn = %{conn | resp_headers: [{"content-type", "text/plain"}]}
iex> conn |> get_resp_header("content-type")
["text/plain"]

Returns session value for the given key.

The key can be a string or an atom, where atoms are automatically convert to strings.

Halts the Plug pipeline by preventing further plugs downstream from being invoked. See the docs for Plug.Builder for more informations on halting a plug pipeline.

Assigns a new private key and value in the connection.

This storage is meant to be used by libraries and frameworks to avoid writing to the user storage (the :assigns field). It is recommended for libraries/frameworks to prefix the keys with the library name.

For example, if some plug needs to store a :hello key, it should do so as :plug_hello:

iex> conn.private[:plug_hello]
nil
iex> conn = put_private(conn, :plug_hello, :world)
iex> conn.private[:plug_hello]
:world

Sets the value of the "content-type" response header taking into account the charset.

Puts a response cookie.

Options

• :domain - the domain the cookie applies to
• :max_age - the cookie max-age
• :path - the path the cookie applies to
• :http_only - when false, the cookie is accessible beyond http
• :secure - if the cookie must be sent only over https. Defaults to true when the connection is https

Adds a new response header (key) if not present, otherwise replaces the previous value of that header with value.

Raises a Plug.Conn.AlreadySentError if the connection has already been :sent.

Puts the specified value in the session for the given key.

The key can be a string or an atom, where atoms are automatically convert to strings.

Stores the given status code in the connection.

The status code can be nil, an integer or an atom. The list of allowed atoms is available in Plug.Conn.Status.

Reads the request body.

This function reads a chunk of the request body. If there is more data to be read, then {:more, partial_body, conn} is returned. Otherwise {:ok, body, conn} is returned. In case of error reading the socket, {:error, reason} is returned as per :gen_tcp.recv/2.

Because the request body can be of any size, reading the body will only work once, as Plug will not cache the result of these operations. If you need to access the body multiple times, it is your responsibility to store it. Finally keep in mind some plugs like Plug.Parsers may read the body, so the body may be unavailable after accessing such plugs.

This function is able to handle both chunked and identity transfer-encoding by default.

Options

• :length - sets the max body length to read, defaults to 8,000,000 bytes;
• :read_length - set the amount of bytes to read at one time, defaults to 1,000,000 bytes;
• :read_timeout - set the timeout for each chunk received, defaults to 15000ms;

Examples

{:ok, body, conn} = Plug.Conn.read_body(conn, length: 1_000_000)

Registers a callback to be invoked before the response is sent.

Callbacks are invoked in the reverse order they are defined (callbacks defined first are invoked last).

Sets the response to the given status and body.

It sets the connection state to :set (if not already :set) and raises Plug.Conn.AlreadySentError if it was already :sent.

Sends the response headers as a chunked response.

It expects a connection that has not been :sent yet and sets its state to :chunked afterwards. Otherwise raises Plug.Conn.AlreadySentError.

Sends a file as the response body with the given status and optionally starting at the given offset until the given length.

If available, the file is sent directly over the socket using the operating system sendfile operation.

It expects a connection that has not been :sent yet and sets its state to :sent afterwards. Otherwise raises Plug.Conn.AlreadySentError.

Sends a response to the client.

It expects the connection state to be :set, otherwise raises an ArgumentError for :unset connections or a Plug.Conn.AlreadySentError for already :sent connections.

At the end sets the connection state to :sent.

Sends a response with given status and body.

See send_resp/1 for more information.