defmodule Auth0.Common.Management.Http do
@moduledoc """
Documentation for Auth0 Management HTTP.
This module manages http request for Auth0 Management API.
"""
alias Auth0.Config
alias Auth0.Common.Management.TokenManager
@type endpoint :: String.t()
@type body :: map | list
@type multipart :: {:multipart, list}
@type config :: Config.t()
@type response :: {:ok, integer, String.t()} | {:error, integer, term} | {:error, term}
@type method :: :get | :post | :put | :patch | :delete | :options | :head
@type headers :: map
@type raw_response ::
{:ok,
HTTPoison.Response.t()
| HTTPoison.AsyncResponse.t()
| HTTPoison.MaybeRedirect.t()}
| {:error, HTTPoison.Error.t()}
@request_headers %{"Content-Type" => "application/json"}
@post_headers %{"Content-Type" => "application/json"}
@patch_headers %{"Content-Type" => "application/json"}
@put_headers %{"Content-Type" => "application/json"}
@get_headers %{}
@delete_headers %{}
@multipart_post_headers %{"Content-Type" => "multipart/form-data"}
@max_request_retry_count 10
@max_request_retry_jitter 100
@max_request_retry_delay 1000
@min_request_retry_delay 100
@doc """
Request Auth0 management rest api simply.
"""
@spec raw_request(method, endpoint, body, headers, config) :: raw_response
def raw_request(method, endpoint, body \\ %{}, headers \\ nil, %Config{} = config \\ %Config{}) do
headers =
if headers |> is_nil do
case method do
:get -> @get_headers
:post -> @post_headers
:put -> @put_headers
:patch -> @patch_headers
:delete -> @delete_headers
end
else
headers
end
|> set_correlation_id(config)
|> set_authorization(config)
url = endpoint |> get_url(config)
HTTPoison.request(method, url, body |> Jason.encode!(), headers)
end
@doc """
POST Auth0 management rest api.
"""
@spec post(endpoint, body, config) :: response
def post(endpoint, body, %Config{} = config) do
headers =
@post_headers
|> set_correlation_id(config)
|> set_authorization(config)
request_with_retry(
fn url -> HTTPoison.post(url, body |> Jason.encode!(), headers) end,
endpoint,
config
)
end
@doc """
PATCH Auth0 management rest api.
"""
@spec patch(endpoint, body, config) :: response
def patch(endpoint, body, %Config{} = config) do
headers =
@patch_headers
|> set_correlation_id(config)
|> set_authorization(config)
request_with_retry(
fn url -> HTTPoison.patch(url, body |> Jason.encode!(), headers) end,
endpoint,
config
)
end
@doc """
PUT Auth0 management rest api.
"""
@spec put(endpoint, body, config) :: response
def put(endpoint, body, %Config{} = config) do
headers =
@put_headers
|> set_correlation_id(config)
|> set_authorization(config)
request_with_retry(
fn url -> HTTPoison.put(url, body |> Jason.encode!(), headers) end,
endpoint,
config
)
end
@doc """
GET Auth0 management rest api.
"""
@spec get(endpoint, config) :: response
def get(endpoint, %Config{} = config) do
headers =
@get_headers
|> set_correlation_id(config)
|> set_authorization(config)
request_with_retry(fn url -> HTTPoison.get(url, headers) end, endpoint, config)
end
@doc """
DELETE Auth0 management rest api.
"""
@spec delete(endpoint, config) :: response
def delete(endpoint, %Config{} = config) do
headers =
@delete_headers
|> set_correlation_id(config)
|> set_authorization(config)
request_with_retry(fn url -> HTTPoison.delete(url, headers) end, endpoint, config)
end
@doc """
DELETE Auth0 management rest api. (with body)
"""
@spec delete(endpoint, body, config) :: response
def delete(endpoint, body, %Config{} = config) do
headers =
@request_headers
|> set_correlation_id(config)
|> set_authorization(config)
request_with_retry(
fn url -> HTTPoison.request(:delete, url, body |> Jason.encode!(), headers) end,
endpoint,
config
)
end
@doc """
MULTIPART POST Auth0 management rest api.
"""
@spec multipart_post(endpoint, multipart, config) :: response
def multipart_post(endpoint, multipart, %Config{} = config) do
headers =
@multipart_post_headers
|> set_correlation_id(config)
|> set_authorization(config)
request_with_retry(
fn url -> HTTPoison.post(url, multipart, headers) |> IO.inspect() end,
endpoint,
config
)
end
defp request_with_retry(request_func, endpoint, %Config{} = config, retry_count \\ 0) do
url = endpoint |> get_url(config)
max_request_retry_count = config |> get_max_request_retry_count
case request_func.(url) do
{:ok, %HTTPoison.Response{status_code: 429}} when max_request_retry_count > retry_count ->
retry_count = retry_count + 1
exponential_delay(retry_count)
request_with_retry(request_func, endpoint, config, retry_count)
{:ok, %HTTPoison.Response{status_code: status_code, body: body}}
when status_code in [200, 201, 202, 204] ->
{:ok, status_code, body}
{:ok, %HTTPoison.Response{status_code: 302, headers: headers}} ->
location =
Enum.filter(headers, fn {key, _} -> key |> String.match?(~r/\Alocation\z/i) end)
|> Enum.map(fn {_, value} -> value end)
|> List.first()
{:ok, 302, location}
{:ok, %HTTPoison.Response{status_code: status_code, body: body}} ->
{:error, status_code, body}
{:error, %HTTPoison.Error{reason: reason}} ->
{:error, reason}
end
end
defp get_url(endpoint, %Config{} = config) do
"https://#{Config.get_domain(config)}#{endpoint}"
end
defp set_correlation_id(headers, %Config{correlation_id: nil}), do: headers
defp set_correlation_id(headers, %Config{correlation_id: correlation_id}),
do: headers |> Map.put("x-correlation-id", correlation_id)
defp set_authorization(headers, %Config{} = config) do
case config |> Config.get_api_token() do
nil ->
case config |> TokenManager.get_token() do
nil ->
headers
access_token ->
headers |> Map.put("Authorization", "Bearer #{access_token}")
end
api_token ->
headers |> Map.put("Authorization", "Bearer #{api_token}")
end
end
defp get_max_request_retry_count(%Config{} = config),
do: min(Config.get_max_request_retry_count(config), @max_request_retry_count)
defp exponential_delay(retry_count) do
request_retry_jitter = Enum.random(0..@max_request_retry_jitter)
max(
@min_request_retry_delay,
min(@max_request_retry_delay, 100 * Integer.pow(2, retry_count - 1) + request_retry_jitter)
)
|> Process.sleep()
end
end
