kmx.io/ex_ovh

diff --git a/.gitignore b/.gitignore
index 5fdd9aa..79a493c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,11 +3,14 @@
 /cover
 /deps
 /doc
-erl_crash.dump
+/.idea
+/.deprecated
+/.notes
+/.backup
+
 *.ez
+erl_crash.dump
 *.secret.exs
-.deprecated
-.notes
-.idea
+.env
 mix.lock
-
+todo.md
diff --git a/config/config.exs b/config/config.exs
index e7b3dfb..86c91eb 100644
--- a/config/config.exs
+++ b/config/config.exs
@@ -5,23 +5,10 @@ config :logger,
   level: :debug,
   format: "\n$date $time [$level] $metadata$message"
 
-
-if Mix.env == :dev do
-  config :logger,
-    backends: [:console],
-    compile_time_purge_level: :debug
-end
-
 if Mix.env == :prod do
   config :logger,
     backends: [:console],
     compile_time_purge_level: :warn
 end
 
-if Mix.env == :test do
-  config :logger,
-    backends: [:console],
-    compile_time_purge_level: :warn
-end
-
-import_config "#{Mix.env}.exs"
\ No newline at end of file
+import_config "#{Mix.env}.exs"
diff --git a/config/dev.exs b/config/dev.exs
index 0af5a88..4a1a288 100644
--- a/config/dev.exs
+++ b/config/dev.exs
@@ -1,4 +1,16 @@
 use Mix.Config
 
-import_config "#{Mix.env}.secret.exs"
+config :logger,
+  backends: [:console],
+  compile_time_purge_level: :debug
 
+config :ex_ovh,
+  ovh: %{
+    application_key: System.get_env("EX_OVH_APPLICATION_KEY"),
+    application_secret: System.get_env("EX_OVH_APPLICATION_SECRET"),
+    consumer_key: System.get_env("EX_OVH_CONSUMER_KEY"),
+    endpoint: System.get_env("EX_OVH_ENDPOINT"),
+    api_version: System.get_env("EX_OVH_API_VERSION") || "1.0",
+    connect_timeout: 30000, # 30 seconds
+    connect_timeout: (60000 * 30) # 30 minutes
+  }
diff --git a/config/test.exs b/config/test.exs
new file mode 100644
index 0000000..83948ca
--- /dev/null
+++ b/config/test.exs
@@ -0,0 +1,16 @@
+use Mix.Config
+
+config :logger,
+  backends: [:console],
+  compile_time_purge_level: :error
+
+config :ex_ovh,
+  ovh: %{
+    application_key: System.get_env("EX_OVH_APPLICATION_KEY"),
+    application_secret: System.get_env("EX_OVH_APPLICATION_SECRET"),
+    consumer_key: System.get_env("EX_OVH_CONSUMER_KEY"),
+    endpoint: System.get_env("EX_OVH_ENDPOINT"),
+    api_version: System.get_env("EX_OVH_API_VERSION") || "1.0",
+    connect_timeout: 30000, # 30 seconds
+    connect_timeout: (60000 * 30) # 30 minutes
+  }
\ No newline at end of file
diff --git a/lib/application.ex b/lib/application.ex
new file mode 100644
index 0000000..317ce3d
--- /dev/null
+++ b/lib/application.ex
@@ -0,0 +1,13 @@
+defmodule ExOvh.Application do
+  @moduledoc :false
+  use Application
+  @ex_ovh_config Application.get_all_env(:ex_ovh) |> Keyword.get(:ovh, :nil)
+
+  # Start the ex_ovh client only if a config :ex_ovh, ex_ovh: %{...} configuration file has been set.
+  unless @ex_ovh_config in [%{}, :nil] do
+    def start(_type, _args) do
+      ExOvh.Supervisor.start_link(ExOvh, @ex_ovh_config, :ex_ovh)
+    end
+  end
+
+end
diff --git a/lib/auth/openstack/swift/cache.ex b/lib/auth/openstack/swift/cache.ex
new file mode 100644
index 0000000..6c4771b
--- /dev/null
+++ b/lib/auth/openstack/swift/cache.ex
@@ -0,0 +1,316 @@
+defmodule ExOvh.Auth.Openstack.Swift.Cache do
+  @moduledoc :false
+
+  use GenServer
+  alias ExOvh.Auth.Supervisor, as: AuthSupervisor
+  alias ExOvh.Utils
+  @get_credentials_retries 10
+  @get_credentials_sleep_interval 450
+
+
+  # Public
+
+
+  def start_link({client, config, opts}, service) do
+    Og.context(__ENV__, :debug)
+    GenServer.start_link(__MODULE__, {client, service}, [name: gen_server_name(client, service)])
+  end
+
+
+  def get_credentials(client, service) do
+    unless supervisor_exists?(client, service), do: Supervisor.start_child(AuthSupervisor, [service])
+    get_credentials(client, service, 0)
+  end
+
+
+  def get_credentials_token(client, service), do: get_credentials(client, service).token
+
+
+  def get_swift_endpoint(client, service) do
+    credentials = get_credentials(client, service)
+    path = URI.parse(credentials.swift_endpoint) |> Map.get(:path)
+    {version, account} = String.split_at(path, 4)
+    endpoint = List.first(String.split(credentials.swift_endpoint, account))
+    endpoint
+  end
+
+
+  def get_account(service), do: get_account(ExOvh, service)
+  def get_account(client, service) do
+    credentials = get_credentials(client, service)
+    path = URI.parse(credentials.swift_endpoint) |> Map.get(:path)
+    {version, account} = String.split_at(path, 4)
+    account
+  end
+
+
+  # Genserver Callbacks
+
+
+  # trap exits so that terminate callback is invoked
+  # the :lock key is to allow for locking during the brief moment that the access token is being refreshed
+  def init({client, service}) do
+    Og.context(__ENV__, :debug)
+    :erlang.process_flag(:trap_exit, :true)
+    create_ets_table(client, service)
+
+    {:ok, credentials} = identity(client, service)
+
+    credentials = Map.put(credentials, :lock, :false)
+    :ets.insert(ets_tablename(client, service), {:credentials, credentials})
+    expires = to_seconds(credentials.token_expires_on)
+    Task.start_link(fn -> monitor_expiry(expires) end)
+    {:ok, {client, service, credentials}}
+  end
+
+  def handle_call(:add_lock, _from, {client, service, credentials}) do
+    Og.context(__ENV__, :debug)
+    new_credentials = Map.put(credentials, :lock, :true)
+    :ets.insert(ets_tablename(client, service), {:credentials, new_credentials})
+    {:reply, :ok, {client, service, new_credentials}}
+  end
+
+  def handle_call(:remove_lock, _from, {client, service, credentials}) do
+    Og.context(__ENV__, :debug)
+    new_credentials = Map.put(credentials, :lock, :false)
+    :ets.insert(ets_tablename(client, service), {:credentials, new_credentials})
+    {:reply, :ok, {client, service, new_credentials}}
+  end
+
+  def handle_call(:update_credentials, _from, {client, service, credentials}) do
+    Og.context(__ENV__, :debug)
+    {:ok, new_credentials} = identity(client, service)
+    |> Map.put(credentials, :lock, :false)
+    :ets.insert(ets_tablename(client, service), {:credentials, new_credentials})
+    {:reply, :ok, {client, service, new_credentials}}
+  end
+
+  def handle_call(:stop, _from, state) do
+    Og.context(__ENV__, :debug)
+    {:stop, :shutdown, :ok, state}
+  end
+
+  def terminate(:shutdown, {client, service, credentials}) do
+    Og.context(__ENV__, :debug)
+    :ets.delete(ets_tablename(client, service)) # explicilty remove
+    :ok
+  end
+
+
+  # Private
+
+
+  defp gen_server_name(client, service), do:  String.to_atom(Atom.to_string(client) <> service)
+  defp ets_tablename(client, service), do: String.to_atom(Atom.to_string(client) <> "-" <> service)
+
+
+
+  def identity(client, {service_name, :webstorage} = service) when is_atom(client) do
+    credentials =  ExOvh.Ovh.V1.Webstorage.Query.get_credentials(service_name) |> client.request!()
+    identity(service_name, credentials, client)
+  end
+  def identity(client, {service_name, pcs_service_name, :cloudstorage} = service) when is_atom(client) do
+    credentials = ExOvh.Ovh.V1.Cloudstorage.Query.get_credentials(service_name, pcs_service_name) |> client.request!()
+    identity(service_name, credentials, client)
+  end
+
+
+  def identity(service_name, credentials, client) do
+
+    config = Utils.config(client)
+    q1 = ExOvh.Ovh.V1.Webstorage.Query.get_service(service_name)
+    {:ok, resp} = ExOvh.request(service_name)
+
+    %{
+      "server" => domain,
+      "storageLimit" => storage_limit,
+      "server" => server
+    } = resp.body
+
+
+    {:ok, resp} = ExOvh.request(credentials)
+
+    %{
+      "endpoint" => endpoint,
+      "login" => login,
+      "password" => password,
+      "tenant" => tenant
+    } = resp.body
+
+
+    method = :post
+    uri = endpoint <> "/tokens"
+    body = %{"auth" =>
+                %{
+                "passwordCredentials" => %{"username" => login, "password" => password}
+                }
+        }
+        |> Poison.encode!()
+    headers = [{"Content-Type", "application/json; charset=utf-8"}]
+    options = Utils.set_opts([], config)
+    resp = HTTPoison.request(method, uri, body, headers, options)
+
+    unless resp.status_code >= 200 and resp.status_code <= 203, do: raise resp.body
+
+    %{
+      "access" =>
+                  %{
+                    "token" => %{
+                                 "expires" => expires_on,
+                                 "id" => token,
+                                 "issued_at" => created_on
+                                },
+                  }
+      } = Poison.decode!(resp.body)
+
+
+    method = :post
+    uri = endpoint <> "/tokens"
+    body = %{
+            "auth" =>
+                      %{
+                      "tenantName" => tenant,
+                      "token" => %{"id" => token}
+                      }
+            }
+    |> Poison.decode!()
+    headers = [{"Content-Type", "application/json; charset=utf-8"}]
+    options = Utils.set_opts([], config)
+    resp = HTTPoison.request(method, uri, body, headers, options)
+
+    unless resp.status_code >= 200 and resp.status_code <= 203, do: raise resp.body
+
+    %{
+      "serviceCatalog" => [
+                          %{
+                            "endpoints" => [%{"publicURL" => swift_endpoint}],
+                            "name" => "swift",
+                          },
+                          %{
+                            "endpoints" => [%{"publicURL" => identity_endpoint}],
+                            "name" => "keystone",
+                          }
+                         ],
+                          "token" => %{
+                                          "expires" => token_expires_on,
+                                          "id" => token,
+                                          "issued_at" => token_created_on,
+                                        },
+                          "user" => _user
+      } = Poison.decode!(resp.body) |> Map.get("access")
+
+      {:ok,
+          %{
+            token: token,
+            token_expires_on: expires_on,
+            token_created_on: token_created_on,
+            swift_endpoint: swift_endpoint,
+            identity_endpoint: identity_endpoint,
+            service: service_name,
+            public_url: public_url(domain, swift_endpoint),
+            storage_limit: storage_limit,
+            server: server
+          }
+      }
+
+  end
+
+
+  # private
+
+
+  defp public_url(domain, swift_endpoint) do
+    path = URI.parse(swift_endpoint) |> Map.get(:path)
+    {version, account} = String.split_at(path, 4)
+    domain <> version <> account
+  end
+
+  defp get_credentials(client, service, index) do
+    Og.context(__ENV__, :debug)
+
+    retry = fn(client, service, index) ->
+      if index > @get_credentials_retries do
+        raise "Cannot retrieve openstack credentials from ets table, #{__ENV__.module}, #{__ENV__.line}"
+      else
+        :timer.sleep(@get_credentials_sleep_interval)
+        get_credentials(client, service, index + 1)
+      end
+    end
+
+    if ets_tablename(client, service) in :ets.all() do
+      table = :ets.lookup(ets_tablename(client, service), :credentials)
+      case table do
+        [credentials: credentials] ->
+          if credentials.lock === :true do
+            retry.(client, service, index)
+          else
+            credentials
+          end
+        [] -> retry.(client,service,index)
+      end
+    else
+      retry.(client, service, index)
+    end
+  end
+
+
+  defp monitor_expiry(expires) do
+    Og.context(__ENV__, :debug)
+    interval = (expires - 30) * 1000
+    :timer.sleep(interval)
+    {:reply, :ok, _credentials} = GenServer.call(self(), :add_lock)
+    {:reply, :ok, _credentials} = GenServer.call(self(), :update_credentials)
+    {:reply, :ok, credentials} = GenServer.call(self(), :remove_lock)
+    expires = to_seconds(credentials["expires"])
+    monitor_expiry(expires)
+  end
+
+
+  defp create_ets_table(client, service) do
+    Og.context(__ENV__, :debug)
+    ets_options = [
+                   :set, # type
+                   :protected, # read - all, write this process only.
+                   :named_table,
+                   {:heir, :none}, # don't let any process inherit the table. when the ets table dies, it dies.
+                   {:write_concurrency, :false},
+                   {:read_concurrency, :true}
+                  ]
+    unless ets_tablename(client, service) in :ets.all() do
+      :ets.new(ets_tablename(client, service), ets_options)
+    end
+  end
+
+
+  defp to_seconds(iso_time) do
+    {:ok, expiry_ndt, offset} = Calendar.NaiveDateTime.Parse.iso8601(iso_time)
+    offset =
+    case offset do
+      :nil -> 0
+      offset -> offset
+    end
+    {:ok, expiry_dt_utc} = Calendar.NaiveDateTime.with_offset_to_datetime_utc(expiry_ndt, offset)
+    {:ok, now} = Calendar.DateTime.from_erl(:calendar.universal_time(), "UTC")
+    {:ok, seconds, _microseconds, _when} = Calendar.DateTime.diff(expiry_dt_utc, now)
+    if seconds > 0 do
+      seconds
+    else
+      0
+    end
+  end
+
+
+  defp supervisor_exists?(client, service) do
+    case Process.whereis(registered_supervisor_name(client, service)) do
+      :nil -> :false
+      _pid -> :true
+    end
+  end
+
+
+  defp registered_supervisor_name(client, service) do
+    String.to_atom(Atom.to_string(client) <> service)
+  end
+
+
+end
\ No newline at end of file
diff --git a/lib/auth/ovh/auth.ex b/lib/auth/ovh/auth.ex
new file mode 100644
index 0000000..05a585b
--- /dev/null
+++ b/lib/auth/ovh/auth.ex
@@ -0,0 +1,62 @@
+defimpl Openstex.Auth, for: ExOvh.Ovh.Query do
+  @moduledoc :false
+
+  alias ExOvh.Utils
+  alias ExOvh.Ovh.Query
+  alias ExOvh.Auth.Ovh.Cache
+  @default_headers [{"Content-Type", "application/json; charset=utf-8"}]
+
+
+  # Public
+
+
+  @spec prepare_request(Query.t, Keyword.t, atom) :: Openstex.HttpQuery.t
+  def prepare_request(query, opts, client)
+
+  def prepare_request(%Query{method: method, uri: uri, params: params}, opts, client) when method in [:get, :head, :delete] do
+    config = Utils.config(client)
+    if params !== :nil and params !== "" and is_map(params), do: uri = uri <> "?" <> URI.encode_query(params)
+    if params !== :nil and params !== "" and is_map(params) === :false, do: uri = uri <> URI.encode_www_form(params)
+    uri = Utils.uri(uri, config)
+    body = params || ""
+    headers = headers([Utils.app_secret(config), Utils.app_key(config), Utils.get_consumer_key(config), Atom.to_string(method), uri, ""], client)
+    options = Utils.set_opts(opts, config)
+    %Openstex.HttpQuery{method: method, uri: uri, body: body, headers: headers, options: options, service: :ovh}
+  end
+
+  def prepare_request(%Query{method: method, uri: uri, params: params}, opts, client) when method in [:post, :put] do
+    config = Utils.config(client)
+    if params !== "" and params !== :nil and is_map(params), do: params = Poison.encode!(params)
+    uri = Utils.uri(uri, config)
+    body = params || ""
+    header_opts = [Utils.app_secret(config), Utils.app_key(config), Utils.get_consumer_key(config), Atom.to_string(method), uri, params]
+    headers = headers([Utils.app_secret(config), Utils.app_key(config), Utils.get_consumer_key(config), Atom.to_string(method), uri, ""], client)
+    options = Utils.set_opts(opts, config)
+    %Openstex.HttpQuery{method: method, uri: uri, body: body, headers: headers, options: options, service: :ovh}
+  end
+
+
+  # Private
+
+
+  defp headers([app_secret, app_key, consumer_key, method, uri, body] = opts, client) do
+    time = :os.system_time(:seconds) + Cache.get_time_diff(client)
+    headers = [
+                {"X-Ovh-Application", app_key},
+                {"X-Ovh-Consumer", consumer_key},
+                {"X-Ovh-Timestamp", time},
+                {"X-Ovh-Signature", sign_request([app_secret, consumer_key, String.upcase(method), uri, body, time])}
+              ]
+              |> Enum.into(%{})
+    Map.merge(Enum.into(@default_headers, %{}), headers) |> Enum.into([])
+  end
+
+
+  defp sign_request([app_secret, consumer_key, method, uri, body, time] = opts) do
+    pre_hash = Enum.join(opts, "+")
+    post_hash = :crypto.hash(:sha, pre_hash) |> Base.encode16(case: :lower)
+    "$1$" <> post_hash
+  end
+
+
+end
diff --git a/lib/auth/ovh/cache.ex b/lib/auth/ovh/cache.ex
new file mode 100644
index 0000000..9671384
--- /dev/null
+++ b/lib/auth/ovh/cache.ex
@@ -0,0 +1,98 @@
+defmodule ExOvh.Auth.Ovh.Cache do
+  @moduledoc :false
+  use GenServer
+  import ExOvh.Utils, only: [gen_server_name: 1]
+  alias ExOvh.Utils
+
+
+  # Public
+
+
+  def start_link({client, config, opts}) do
+    Og.context(__ENV__, :debug)
+    client
+    |> Og.log_return(__ENV__, :warn)
+    GenServer.start_link(__MODULE__, {client, config, opts}, [name: gen_server_name(client)])
+  end
+
+
+  @doc "Retrieves the ovh api time diff from the state"
+  def get_time_diff(client) do
+    client |> Og.log_return(__ENV__, :warn)
+    gen_server_name(client) |> Og.log_return(__ENV__, :warn)
+
+    GenServer.call(gen_server_name(client), :get_diff)
+  end
+  @doc "Retrieves the ovh config map"
+  def get_config(client) do
+    client |> Og.log_return(__ENV__, :warn)
+    gen_server_name(client) |> Og.log_return(__ENV__, :warn)
+
+    GenServer.call(gen_server_name(client), :get_config)
+  end
+
+
+  # Genserver Callbacks
+
+
+  def init({client, config, opts}) do
+    Og.context(__ENV__, :debug)
+    diff = calculate_diff(config)
+    {:ok, {config, diff}}
+  end
+
+  def handle_call(:get_diff, _from, {config, diff}) do
+    Og.context(__ENV__, :debug)
+    {:reply, diff, {config, diff}}
+  end
+
+  def handle_call(:get_config, _from, {config, diff}) do
+    Og.context(__ENV__, :debug)
+    {:reply, config, {config, diff}}
+  end
+
+  def handle_cast({:set_diff, new_diff}, {config, diff}) do
+    Og.context(__ENV__, :debug)
+    {:noreply, {config, new_diff}}
+  end
+
+  def terminate(:shutdown, state) do
+    Og.context(__ENV__, :warn)
+    Og.log_return("gen_server #{__MODULE__} shutting down", :warn)
+    :ok
+  end
+
+
+  # Private
+
+
+  defp api_time_request(config) do
+    method = :get
+    uri = Utils.endpoint(config) <> Utils.api_version(config) <> "/auth/time"
+    body = ""
+    headers = [{"Content-Type", "application/json; charset=utf-8"}]
+    options = Utils.set_opts([], config)
+    resp = HTTPoison.request!(method, uri, body, headers, options)
+    api_time = Poison.decode!(resp.body)
+  end
+
+
+  defp calculate_diff(config) do
+    api_time = api_time_request(config)
+    os_t = :os.system_time(:seconds)
+    os_t - api_time
+  end
+
+
+  #Caches the ovh api time diff
+  defp set_time_diff(client) do
+    config = get_config(client)
+    set_time_diff(client, config)
+  end
+  defp set_time_diff(client, config) when is_map(config) do
+    diff = calculate_diff(config)
+    GenServer.cast(gen_server_name(client), {:set_diff, diff})
+  end
+
+
+end
\ No newline at end of file
diff --git a/lib/auth/supervisor.ex b/lib/auth/supervisor.ex
new file mode 100644
index 0000000..78f45c7
--- /dev/null
+++ b/lib/auth/supervisor.ex
@@ -0,0 +1,40 @@
+defmodule ExOvh.Auth.Supervisor do
+  @moduledoc :false
+
+  use Supervisor
+  import ExOvh.Utils, only: [supervisor_name: 1]
+  alias ExOvh.Auth.Ovh.Cache, as: OvhCache
+  alias ExOvh.Auth.Openstack.Swift.Cache, as: SwiftCache
+
+
+  #  Public
+
+
+  @doc ~S"""
+  Starts the OVH supervisor.
+  """
+  def start_link(client, config, opts) do
+    Og.context(__ENV__, :debug)
+    Supervisor.start_link(__MODULE__, {client, config, opts}, [name: supervisor_name(client)])
+  end
+
+
+  # Supervisor Callbacks
+
+
+  def init({client, config, opts}) do
+    Og.context(__ENV__, :debug)
+    Og.log({client, config, opts}, __ENV__, :debug)
+
+    tree = [
+            {OvhCache,
+              {OvhCache, :start_link, [{client, config, opts}]}, :transient, 10_000, :worker, [OvhCache]},
+#            {SwiftCache,
+#              {SwiftCache, :start_link, [{client, config, opts}]}, :permanent, 10_000, :worker, [SwiftCache]}
+           ]
+
+    supervise(tree, strategy: :one_for_one)
+  end
+
+
+end
diff --git a/lib/client.ex b/lib/client.ex
index 9a00e48..f556248 100644
--- a/lib/client.ex
+++ b/lib/client.ex
@@ -1,86 +1,39 @@
 defmodule ExOvh.Client do
   @moduledoc ~S"""
-  Defines a client.
-
-  When used, it expects the :otp_app as an option. The :otp_app should be an
-  application with the configuration settings for ovh and/or hubic.
-
-  ## Example app using the `ExOvh.Client` behaviour
-
-      defmodule TestOs.ExOvh do
-        use ExOvh.Client, otp_app: :test_os
-      end
-
-  ## Example configuration
-
-      config :test_os, TestOs.ExOvh,
-        ovh:  %{
-                application_key: "<app_key>",
-                application_secret: "<app_secret>",
-                consumer_key: "<con_key>"
-        },
-        hubic: %{
-                client_id: "<client_id>",
-                client_secret: "<client_secret>",
-                refresh_token: "<refresh_token>",
-                redirect_uri: "<redirect_uri>"
-                }
-
-  Either ovh or hubic can be set to :nil but not both. Both hubic and ovh being absent
-  will result in the supervision tree crashing since there are no application data with
-  which to authenticate requests.
-  For example, if hubic is set to :nil, then the hubic side of the supervision tree
-  will not be started. Then the only functions available will be:
-
-      TestOs.ExOvh.ovh_request/3
-      TestOs.ExOvh.ovh_prepare_request/3
   """
   alias ExOvh.Defaults
 
 
-  @type method_t :: atom()
-  @type path_t :: String.t
-  @type params_t :: map() | :nil
-  @type options_t :: map() | :nil
-  @type raw_query_t :: { method_t, path_t, params_t }
-  @type query_t :: { method_t, path_t, options_t }
-  @type response_t :: %{ body: map() | String.t, headers: map(), status_code: integer() }
-
-
   defmacro __using__(opts) do
     quote bind_quoted: [opts: opts] do
-      @otp_app opts[:otp_app] || :ex_ovh
-
+      @otp_app Keyword.get(opts, :otp_app, :ex_ovh)
 
-      if(@otp_app !== :ex_ovh)  do
-        def config(), do: Application.get_env(@otp_app, __MODULE__) |> Enum.into(%{})
-      else
-        def config(), do: Application.get_all_env(@otp_app) |> Enum.into(%{})
-      end
-
-
-      def start_link(opts \\ []) do
-        ExOvh.Supervisor.start_link(__MODULE__, config(), opts)
-      end
+      use Openstex.Client, client: __MODULE__, swift_cache: __MODULE__.Auth.Openstack.Swift.Cache
 
+      # Incorporation of the Swift Oject Storage Helpers modules.
+      defmodule Helpers.Swift do
+        %Macro.Env{context_modules: [_, client_module]} = __ENV__
+         use Openstex.Helpers.V1.Swift, client: client_module
+       end
 
-      def ovh_request({method, uri, params} = query, opts \\ %{}) do
-        ExOvh.Ovh.Request.request(__MODULE__, query, opts)
+      # Incorporation of the Custom Ovh Helpers modules.
+      defmodule Helpers.Ovh do
+       %Macro.Env{context_modules: [_, _, client_module]} = __ENV__
+        use ExOvh.Ovh.V1.Webstorage.Helpers, client: client_module
       end
 
 
-      def ovh_prepare_request({method, uri, params} = query, opts \\ %{}) do
-        ExOvh.Ovh.Auth.prepare_request(__MODULE__, query, opts)
-      end
-
-
-      def hubic_request({method, uri, params} = query, opts \\ %{}) do
-        ExOvh.Hubic.Request.request(__MODULE__, query, opts)
+      if (@otp_app != :ex_ovh)  do
+        def config(), do: Application.get_env(@otp_app, __MODULE__)
+        |> Keyword.fetch!(:ovh)
+      else
+        def config(), do: Application.get_all_env(@otp_app)
+        |> Keyword.fetch!(:ovh)
       end
 
 
-      def hubic_prepare_request({method, uri, params} = query, opts \\ %{}) do
-        ExOvh.Hubic.Auth.prepare_request(__MODULE__, query, opts)
+      def start_link(opts \\ []) do
+        ExOvh.Supervisor.start_link(__MODULE__, config(), opts)
       end
 
 
@@ -88,114 +41,16 @@ defmodule ExOvh.Client do
   end
 
 
-  @doc """
-  Starts the ovh and the hubic supervisors.
+  @doc ~s"""
+  Starts the ovh supervisors.
   """
   @callback start_link() :: :ok | {:error, {:already_started, pid}} | {:error, term}
 
 
-  @doc ~S"""
-  Gets the ovh and hubic config from the application environment.
-
-  Returns a map if the config is present in the config.exs file(s)
-  or
-  Returns :nil if the config is absent.
+  @doc ~s"""
+  Gets the ovh config from the application environment.
   """
   @callback config() :: :nil | map
 
 
-
-  @doc """
-  Prepares all elements necessary for making a request to the ovh api.
-
-  Returns a tuple `{method, uri, options}` which is the `query_t` tuple.
-  With the returned query_t, a request can easily be made with
-  [HTTPotion](http://hexdocs.pm/httpotion/HTTPotion.html).
-
-  ## Example
-
-  Building a request to the custom ovh api:
-      raw_query = {:get, "<account_name>", %{"format" => "json"}}
-      query = ExOvh.ovh_prepare_request(raw_query, %{})
-
-
-  Building a request to the openstack compliant ovh cdn webstorage service:
-      raw_query = {:get, "<account_name>", %{"format" => "json"}}
-      query = ExOvh.ovh_prepare_request(raw_query, %{ openstack: :true, webstorage: "<ovh_service_name>" })
-  """
-  @callback ovh_prepare_request(query :: raw_query_t)
-                             :: query_t
-
-
-
-  @doc ~S"""
-  Makes a request to the ovh api.
-
-  Returns a `response_t` map  with the structure:
-  `%{ body: <body>, headers: [<headers>], status_code: <code>}`
-
-  ## Example
-
-  Making a request to the custom ovh api:
-      raw_query = {:get, "<account_name>", %{"format" => "json"}}
-      ExOvh.ovh_request(raw_query, %{})
-
-  Making a request to the openstack compliant ovh cdn webstorage service:
-      raw_query = {:get, "<account_name>", %{"format" => "json"}}
-      ExOvh.ovh_request(raw_query, %{ openstack: :true, webstorage: "<ovh_service_name>" })
-  """
-  @callback ovh_request(query :: raw_query_t, opts :: map)
-                        :: {:ok, response_t} | {:error, response_t}
-
-
-
-
-  @doc ~S"""
-  Makes a request to the hubic api.
-
-  Returns a map `%{ body: <body>, headers: %{<headers>}, status_code: <code>}`
-
-  Making a request to the custom hubic api:
-      raw_query = {:get, "/scope/scope", :nil}
-      ExOvh.hubic_request(raw_query, %{})
-
-  Making a request to the openstack compliant hubic storage:
-      client = ExOvh
-      account = ExOvh.Hubic.OpenstackApi.Cache.get_account(client)
-      raw_query = {:get, account, %{"format" => "json"}}
-      ExOvh.hubic_request(raw_query, %{ openstack: :true })
-  """
-  @callback hubic_request(query :: raw_query_t, opts :: map)
-                         :: {:ok, response_t} | {:error, response_t}
-
-
-  @doc ~S"""
-  Prepares all elements necessary for making a request to the hubic api.
-
-  Returns a tuple `{method, uri, options}`
-
-  Building a request to the custom hubic api:
-      raw_query = {:get, "/scope/scope", :nil}
-      ExOvh.hubic_prepare_request(raw_query, %{})
-
-  Building a request to the openstack compliant hubic storage
-  with the default client `ExOvh`:
-
-      account = ExOvh.Hubic.OpenstackApi.Cache.get_account()
-      raw_query = {:get, account, %{"format" => "json"}}
-      ExOvh.hubic_prepare_request(raw_query, %{ openstack: :true })
-
-
-  Building a request to the openstack compliant hubic storage with your own
-  client:
-
-      client = MyApp.ExOvh # <-- enter your client here.
-      account = ExOvh.Hubic.OpenstackApi.Cache.get_account(client)
-      raw_query = {:get, account, %{"format" => "json"}}
-      ExOvh.hubic_prepare_request(raw_query, %{ openstack: :true })
-  """
-  @callback hubic_prepare_request(query :: raw_query_t)
-                               :: query_t
-
-
 end
diff --git a/lib/defaults.ex b/lib/defaults.ex
new file mode 100644
index 0000000..03958ae
--- /dev/null
+++ b/lib/defaults.ex
@@ -0,0 +1,54 @@
+defmodule ExOvh.Defaults do
+  @moduledoc :false
+
+  @doc "Returns ovh default configuration settings"
+  @spec ovh() :: map
+  def ovh() do
+    %{
+      endpoint: "ovh-eu",
+      api_version: "1.0"
+    }
+  end
+
+
+  @doc "Returns a map of ovh endpoints"
+  @spec endpoints() :: map
+  def endpoints() do
+    %{
+      "ovh-eu"        => "https://api.ovh.com/",
+      "ovh-ca"        => "https://ca.api.ovh.com/",
+      "kimsufi-eu"    => "https://eu.api.kimsufi.com/",
+      "kimsufi-ca"    => "https://ca.api.kimsufi.com/",
+      "soyoustart-eu" => "https://eu.api.soyoustart.com/",
+      "soyoustart-ca" => "https://ca.api.soyoustart.com/",
+      "runabove-ca"   => "https://api.runabove.com/"
+    }
+  end
+
+
+  @doc "Returns the default access rules (all methods and paths by default)"
+  @spec access_rules() :: [map]
+  def access_rules() do
+     [
+        %{
+            method: "GET",
+            path: "/*"
+        },
+        %{
+            method: "POST",
+            path: "/*"
+        },
+        %{
+            method: "PUT",
+            path: "/*"
+        },
+        %{
+            method: "DELETE",
+            path: "/*"
+        }
+    ]
+  end
+
+
+end
+
diff --git a/lib/ex_ovh.ex b/lib/ex_ovh.ex
index 50c641c..4919798 100644
--- a/lib/ex_ovh.ex
+++ b/lib/ex_ovh.ex
@@ -1,4 +1,10 @@
 defmodule ExOvh do
-  @moduledoc File.read!("#{__DIR__}/../README.md") |> String.replace("# ExOvh", "")
-  use ExOvh.Client, otp_app: :ex_ovh
-end
+  @moduledoc :false
+  @ex_ovh_config Application.get_all_env(:ex_ovh) |> Keyword.get(:ovh, :nil)
+
+  # Define a standard ExOvh client only if the user has entered a config :ex_ovh, ex_ovh: %{...} into the configuration file.
+  unless  @ex_ovh_config in [%{}, :nil] do
+    use ExOvh.Client, otp_app: :ex_ovh
+  end
+
+end
\ No newline at end of file
diff --git a/lib/hubic/auth.ex b/lib/hubic/auth.ex
deleted file mode 100644
index aa1e570..0000000
--- a/lib/hubic/auth.ex
+++ /dev/null
@@ -1,69 +0,0 @@
-defmodule ExOvh.Hubic.Auth do
-  @moduledoc :false
-  @doc ~S"""
-  Houses the `prepare_request` function which delegates the function call to the appropriate
-  module & function depending on the `opts` key-values.
-
-  Ovh uses it's own custom api and also separate Openstack compliant apis so
-  and these apis are quite different.
-  Therefore, the request needs to be routed to the correct `prepare_request` function so
-  that the correct auth credentials are put into the `options_t` in the returned
-  `ExOvh.Client.query_t` query tuple.
-
-  ## Examples of what some delegation depending on opts
-
-      ExOvh.hubic_prepare_request(query, %{} = opts)
-      calls
-      ExOvh.Hubic.HubicApi.Auth.hubic_prepare_request(ExOvh, query, opts)
-
-  -
-
-      ExOvh.hubic_prepare_request(query, %{ openstack: :true } = opts)
-      calls
-      ExOvh.Hubic.OpenstackApi.Auth.hubic_prepare_request(ExOvh, query, opts)
-
-
-  ## Subsequent Request modules
-
-  The subsequent request functions process the request by
-
-  1. Calling the appropriate `prepare_request` function which has been delegated to.
-  2. Getting the appropriate auth credentials and adding them to the headers as needed.
-  3. Returning `ExOvh.Client.query_t` which is a tuple of the format {method, uri, options} which
-     can then be easily used to make requests using HTTPpotion, `ovh_request` or `hubic_request`.
-  """
-  alias ExOvh.Hubic.OpenstackApi.Auth, as: OpenstackAuth
-  alias ExOvh.Hubic.HubicApi.Auth, as: HubicAuth
-
-
-  @doc ~S"""
-  Delegates the function call to the appropriate module & function depending on the `opts` key-values.
-
-  Subsequent request functions return `{:ok, response_t}` or `{:error, response_t}`
-
-  ## Options
-
-      { } = opts
-
-  The function call will be delegated to `ExOvh.Hubic.HubicApi.Auth`.
-
-      { openstack: :true, webstorage: "<service>" } = opts
-
-  The function call will be delegated to `ExOvh.Hubic.HubicApi.Webstorage.Auth`.
-
-  `openstack: :true` - boolean - indicates whether the request is an openstack one or not.
-
-  `webstorage: service` - String.t and is the name the cdn webstorage in your ovh stack which you which to use.
-  """
-  @spec prepare_request(client :: atom, query :: ExOvh.Client.raw_query_t, opts :: map())
-                     :: ExOvh.Client.query_t
-  def prepare_request(client, {method, uri, params} = query, %{openstack: :true} = opts) do
-    OpenstackAuth.prepare_request(client, query)
-  end
-
-  def prepare_request(client, {method, uri, params} = query, opts) do
-    HubicAuth.prepare_request(client, query)
-  end
-
-
-end
diff --git a/lib/hubic/defaults.ex b/lib/hubic/defaults.ex
deleted file mode 100644
index 54f9ca7..0000000
--- a/lib/hubic/defaults.ex
+++ /dev/null
@@ -1,19 +0,0 @@
-defmodule ExOvh.Hubic.Defaults do
-  @moduledoc :false
-
-  @doc "Returns hubic default configuration settings"
-  @spec hubic() :: map
-  def hubic() do
-    %{
-      auth_uri:    "https://api.hubic.com/oauth/auth",
-      token_uri:   "https://api.hubic.com/oauth/token",
-      api_uri:     "https://api.hubic.com",
-      api_version: "1.0"
-    }
-  end
-
-
-end
-
-
-
diff --git a/lib/hubic/hubic_api/auth.ex b/lib/hubic/hubic_api/auth.ex
deleted file mode 100644
index 2623160..0000000
--- a/lib/hubic/hubic_api/auth.ex
+++ /dev/null
@@ -1,92 +0,0 @@
-defmodule ExOvh.Hubic.HubicApi.Auth do
-  #@moduledoc "Gets the access and refresh token for access the hubic api"
-  @moduledoc :false
-  alias ExOvh.Hubic.Defaults
-  alias ExOvh.Hubic.HubicApi.Cache
-  @timeout 20_000
-
-
-  ###################
-  # Public
-  ###################
-  
-
-  @spec prepare_request(client :: atom, query :: ExOvh.Client.raw_query_t)
-                    :: ExOvh.Client.query_t
-  def prepare_request(client, query)
-
-  def prepare_request(client, {method, uri, params} = query) when method in [:get, :head, :delete] do
-    config = config(client)
-    uri = uri(config, uri)
-    if params !== :nil and params !== "" and is_map(params), do: uri = uri <> "?" <> URI.encode_query(params)
-    if params !== :nil and params !== "" and is_map(params) === :false, do: uri = uri <> URI.encode_www_form(params)
-    options = %{ headers: headers(client, method), timeout: @timeout }
-    {method, uri, options}
-  end
-
-  def prepare_request(client, {method, uri, params} = query) when method in [:post, :put] do
-    config = config(client)
-    uri = uri(config, uri)
-    if params !== "" and params !== :nil and is_map(params), do: params = Poison.encode!(params)
-    options = %{ body: params, headers: headers(client, method), timeout: @timeout }
-    {method, uri, options}
-  end
-
-
-  @doc """
-  - It is necessary to perform this request every time the access token expires.
-  - The refresh token needs to be available to perform this request.
-  - returned map structure is as follows:
-    %{
-      "access_token" => "access_token",
-      "expires_in" => 21600,
-      "token_type" => "Bearer"
-     }
-  """
-  @spec get_latest_access_token(refresh_token :: String.t, config :: map) :: map
-  def get_latest_access_token(refresh_token, config) do
-    Og.context(__ENV__, :debug)
-    auth_credentials = config.client_id <> ":" <> config.client_secret
-    auth_credentials_base64 = Base.encode64(auth_credentials)
-    req_body = "refresh_token=" <> refresh_token <>
-                "&grant_type=refresh_token"
-    headers = %{
-               "Content-Type": "application/x-www-form-urlencoded",
-               "Authorization": "Basic " <> auth_credentials_base64
-              }
-    options = %{ body: req_body, headers: headers, timeout: @timeout }
-    resp = HTTPotion.request(:post, hubic_token_uri(config), options)
-    resp =
-    %{
-      body: resp.body |> Poison.decode!(),
-      headers: resp.headers,
-      status_code: resp.status_code
-    }
-    if Map.has_key?(resp, "error") do
-      error = Map.get(resp, "error") <> " :: " <> Map.get(resp, "error_description")
-      raise error
-    end
-    body = resp |> Map.get(:body)
-  end
-
-
-  ###################
-  # Private
-  ###################
-
-  defp default_headers(client), do: %{ "Authorization": "Bearer " <> Cache.get_token(client) }
-  defp headers(client, method) when method in [:post, :put] do
-    Map.merge(default_headers(client), %{ "Content-Type": "application/json;charset=utf-8" })
-  end
-  defp headers(client, method) when method in [:get, :head, :delete], do: default_headers(client)
-
-  defp config(), do: Cache.get_config(ExOvh)
-  defp config(client), do: Cache.get_config(client)
-  defp api_version(config), do: config[:api_version]
-  defp uri(config, uri), do: hubic_api_uri(config) <> "/" <> api_version(config) <> uri
-  defp hubic_auth_uri(config), do: config[:auth_uri]
-  defp hubic_token_uri(config), do: config[:token_uri]
-  defp hubic_api_uri(config), do: config[:api_uri]
-
-
-end
\ No newline at end of file
diff --git a/lib/hubic/hubic_api/cache.ex b/lib/hubic/hubic_api/cache.ex
deleted file mode 100644
index e2d0ec1..0000000
--- a/lib/hubic/hubic_api/cache.ex
+++ /dev/null
@@ -1,195 +0,0 @@
-defmodule ExOvh.Hubic.HubicApi.Cache do
-  #@moduledoc ~S"""
-  #Caches the access_token and provides a simple get_token() api to other modules through one function get_token()
-  #Caches the hubic config map.
-
-  #Maintains the access token so that:
-  #- State is maintained in gen_server state but gen_server could be a bottleneck so it is also copied to a public ets table.
-  #- So state is also stored in an ets table and is quickly and globally retrievable.
-  #- State in :ets and :gen_server should be synchronised.
-  #- It is automatically refreshed in the background when it expires
-  #- If the gen_server crashes, it will attempt to re-establish the access token
-  #- The refresh token by attempting the following:
-  #  - 1. Firstly, try to recuperate the refresh_token from a dets entry.
-  #  - 2. Secondly, by checking for the refresh_token in the config secret file.
-  #- If both of the above methods fail, then ultimately the gen_server will crash and the user
-  #  will have to retrieve another refresh_token using the `mix hubic` task
-  #
-  #tokens is a map with the following structure:
-  #- `%{
-  #     :lock => :true,
-  #     "access_token" => "access_token",
-  #     "expires_in" => 21600,
-  #     "refresh_token" => "refresh_token",
-  #     "token_type" => "Bearer"
-  #  }`
-  #"""
-  @moduledoc :false
-  use GenServer
-  alias ExOvh.Hubic.HubicApi.Auth
-  @get_token_retries 20
-  @get_token_sleep_interval 300
-
-
-  #####################
-  # Public
-  #####################
-
-
-  @doc "Starts the genserver"
-  def start_link({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    GenServer.start_link(__MODULE__, {client, config, opts}, [name: gen_server_name(client)])
-  end
-
-
-  @doc "Gets the access_token from the :ets table"
-  @spec get_token() :: String.t
-  def get_token(), do: get_token(ExOvh, 0)
-
-  @doc "Gets the access_token from the :ets table"
-  @spec get_token(client :: atom) :: String.t
-  def get_token(client), do: get_token(client, 0)
-
-  @doc "Retrieves the hubic config map"
-  def get_config(client) do
-    GenServer.call(gen_server_name(client), :get_config)
-  end
-
-
-  #####################
-  # Genserver Callbacks
-  #####################
-
-  # trap exits so that terminate callback is invoked
-  # the :lock key is to allow for locking during the brief moment that the access token is being refreshed
-  def init({client, config, _opts}) do
-    Og.context(__ENV__, :debug)
-    :erlang.process_flag(:trap_exit, :true)
-    create_ets_table(client)
-    refresh_token = config.refresh_token
-    case refresh_token  do
-      :nil -> # RAISE AN EXCEPTION DUE TO UNAVAILABILITY OF THE REFRESH TOKEN
-        error = "Valid refresh token not available"
-        Og.log_return(error, :error)
-        raise error
-      refresh_token -> # TRY TO GET REFRESH TOKEN FROM THE CONFIG
-        tokens = get_latest_tokens(%{"refresh_token" => refresh_token}, config) |> Map.put(:lock, :false)
-        :ets.insert(ets_tablename(client), {:tokens, tokens})
-        Task.start_link(fn -> monitor_expiry(client, tokens["expires_in"]) end)
-        {:ok, {client, config, tokens}}
-    end
-  end
-
-  def handle_call(:add_lock, _from, {client, config, tokens}) do
-    Og.context(__ENV__, :debug)
-    new_tokens = Map.put(tokens, :lock, :true)
-    :ets.insert(ets_tablename(client), {:tokens, new_tokens})
-    {:reply, :ok, new_tokens}
-  end
-
-  def handle_call(:remove_lock, _from, {client, config, tokens}) do
-    Og.context(__ENV__, :debug)
-    new_tokens = Map.put(tokens, :lock, :false)
-    :ets.insert(ets_tablename(client), {:tokens, new_tokens})
-    {:reply, :ok, new_tokens}
-  end
-
-  def handle_call(:update_tokens, _from, {client, config, tokens}) do
-    Og.context(__ENV__, :debug)
-    new_tokens = get_latest_tokens(tokens, config)
-    |> Map.put(tokens, :lock, :false)
-    :ets.insert(ets_tablename(client), {:tokens, new_tokens})
-    {:reply, :ok, {client, new_tokens}}
-  end
-
-  def handle_call(:get_config, _from, {client, config, tokens}) do
-    Og.context(__ENV__, :debug)
-    {:reply, config, {client, config, tokens}}
-  end
-
-  def handle_call(:stop, _from, {client, config, tokens}) do
-    Og.context(__ENV__, :debug)
-    {:stop, :shutdown, :ok, {client, config, tokens}}
-  end
-
-  def terminate(:shutdown, {client, config, tokens}) do
-    Og.context(__ENV__, :debug)
-    :ets.delete(ets_tablename(client))
-    :ok
-  end
-
-
-  #####################
-  # Private
-  #####################
-
-  defp gen_server_name(client), do: String.to_atom(Atom.to_string(client) <> Atom.to_string(__MODULE__))
-  defp ets_tablename(client), do: String.to_atom("Ets" <> Atom.to_string(gen_server_name(client)))
-
-  # get the token from the :ets table
-  defp get_token(client, index) do
-    Og.context(__ENV__, :debug)
-    if ets_tablename(client) in :ets.all() do
-      [tokens: tokens] = :ets.lookup(ets_tablename(client), :tokens)
-      if tokens.lock === :true do
-        if index > @get_token_retries do
-          raise "Problem retrieving the access token from ets table"
-        else
-          :timer.sleep(@get_token_sleep_interval)
-          get_token(client, index + 1)
-        end
-      else
-        tokens["access_token"]
-      end
-    else
-      if index > @get_token_retries do
-        raise "Problem retrieving the access token from ets table"
-      else
-        :timer.sleep(@get_token_sleep_interval)
-        get_token(client, index + 1)
-      end
-    end
-  end
-
-
-  # Returns a map in following format with the latest tokens:
-  # %{"access_token" => "access_token", "expires_in" => 21600, "refresh_token" => "refresh_token", "token_type" => "Bearer"}
-  defp get_latest_tokens(tokens, config) do
-    Og.context(__ENV__, :debug)
-    Auth.get_latest_access_token(tokens["refresh_token"], config)
-    |> Map.put("refresh_token", tokens["refresh_token"])
-  end
-
-  # Recursive function
-  # Modifies the gen_server state every time the access_token expiry is within 30 seconds of expiry.
-  # expires_in parameter is in seconds
-  # This function is used as a worker `Task` everytime the genserver is initialised.
-  defp monitor_expiry(client, expires_in) do
-    Og.context(__ENV__, :debug)
-    interval = (expires_in - 30) * 1000
-    :timer.sleep(interval)
-    {:reply, :ok, _state} = GenServer.call(gen_server_name(client), :add_lock)
-    {:reply, :ok, _state} = GenServer.call(gen_server_name(client), :update_tokens)
-    {:reply, :ok, state} = GenServer.call(gen_server_name(client), :remove_lock)
-    monitor_expiry(client, state["expires_in"])
-  end
-
-  # creates the ets table
-  defp create_ets_table(client) do
-    Og.context(__ENV__, :debug)
-    ets_options = [
-                   :set, # type
-                   :protected, # read - all, write this process only.
-                   :named_table,
-                   {:heir, :none}, # don't let any process inherit the table. when the ets table dies, it dies.
-                   {:write_concurrency, :false},
-                   {:read_concurrency, :true}
-                  ]
-    unless ets_tablename(client) in :ets.all() do
-      :ets.new(ets_tablename(client), ets_options)
-    end
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/hubic/hubic_api/request.ex b/lib/hubic/hubic_api/request.ex
deleted file mode 100644
index e3d4853..0000000
--- a/lib/hubic/hubic_api/request.ex
+++ /dev/null
@@ -1,48 +0,0 @@
-defmodule ExOvh.Hubic.HubicApi.Request do
-  @moduledoc :false
-  alias ExOvh.Hubic.HubicApi.Auth
-  alias ExOvh.Hubic.HubicApi.Cache, as: TokenCache
-
-
-  @spec request(client :: atom, query :: ExOvh.Client.raw_query_t, opts :: map, retries :: integer)
-                :: {:ok, ExOvh.Client.response_t} | {:error, ExOvh.Client.response_t}
-
-  def request(client, {method, uri, params} = query, opts, retries \\ 0) do
-    {method, uri, options} = Auth.prepare_request(client, query)
-    Og.log_return({method, uri, options}, :debug)
-    resp = HTTPotion.request(method, uri, options)
-    |> Og.log_return(:debug)
-    if resp.status_code >= 100 and resp.status_code < 300 do
-      try do
-        {:ok, %{
-               body: resp.body |> Poison.decode!(),
-               headers: resp.headers,
-               status_code: resp.status_code
-              }
-        }
-      rescue
-        _ ->
-        {:ok, %{
-               body: resp.body,
-               headers: resp.headers,
-               status_code: resp.status_code
-              }
-        }
-      end
-    else
-      if Map.has_key?(resp.body, "error") do
-        if resp.body["error"] === "invalid_token" do
-          GenServer.call(TokenCache, :stop) # Restart the gen_server to recuperate state
-          unless retries >= 1, do: request(client, query, opts, 1) # Try request one more time
-        else
-          {:error, resp}
-        end
-      else
-        {:error, resp}
-      end
-    end
-
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/hubic/openstack_api/auth.ex b/lib/hubic/openstack_api/auth.ex
deleted file mode 100644
index 52f677d..0000000
--- a/lib/hubic/openstack_api/auth.ex
+++ /dev/null
@@ -1,42 +0,0 @@
-defmodule ExOvh.Hubic.OpenstackApi.Auth do
-  @moduledoc :false
-  alias ExOvh.Hubic.OpenstackApi.Cache
-
-  @methods [:get, :post, :put, :delete]
-  @timeout 10_000
-
-
-  ############################
-  # Public
-  ############################
-
-
-  @spec prepare_request(client :: atom, query :: ExOvh.Client.raw_query_t)
-                     :: ExOvh.Client.query_t
-  def prepare_request(client, query)
-
-  def prepare_request(client, {method, uri, params} = query) when method in [:get, :head, :delete] do
-    uri =  Cache.get_endpoint(client) <> uri
-    if params !== :nil and params !== "", do: uri = uri <> "?" <> URI.encode_query(params)
-    options = %{ headers: headers(client), timeout: @timeout }
-    {method, uri, options}
-  end
-
-  def prepare_request(client, {method, uri, params} = query) when method in [:post, :put] do
-    uri =  Cache.get_endpoint(client) <> uri
-    if params !== "" and params !== :nil and is_map(params), do: params = Poison.encode!(params)
-    options = %{ body: params, headers: headers(client), timeout: @timeout }
-    {method, uri, options}
-  end
-
-
-
-  ############################
-  # Private
-  ############################
-
-
-  defp headers(client), do: %{ "X-Auth-Token": Cache.get_credentials_token(client) }
-
-
-end
diff --git a/lib/hubic/openstack_api/cache.ex b/lib/hubic/openstack_api/cache.ex
deleted file mode 100644
index e56e030..0000000
--- a/lib/hubic/openstack_api/cache.ex
+++ /dev/null
@@ -1,186 +0,0 @@
-defmodule ExOvh.Hubic.OpenstackApi.Cache do
-  @moduledoc :false
-  use GenServer
-  alias ExOvh.Hubic.HubicApi.Cache
-  alias ExOvh.Hubic.Request
-  @get_credentials_retries 10
-  @get_credentials_sleep_interval 150
-  @init_delay 2_000
-
-
-  #####################
-  # Public
-  #####################
-
-
-  @doc "Starts the genserver"
-  def start_link({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    GenServer.start_link(__MODULE__, {client, config, opts}, [name: gen_server_name(client)])
-  end
-
-
-  def get_credentials(), do: get_credentials(ExOvh)
-  def get_credentials(client), do: get_credentials(client, 0)
-
-
-  def get_credentials_token(), do: get_credentials_token(ExOvh)
-  def get_credentials_token(client), do: get_credentials(client)["token"]
-
-
-  def get_endpoint(), do: get_endpoint(ExOvh)
-  def get_endpoint(client) do
-    credentials = get_credentials(client)
-    path = URI.parse(credentials["endpoint"])
-    |> Map.get(:path)
-    {version, account} = String.split_at(path, 4)
-    endpoint = List.first(String.split(credentials["endpoint"], account))
-    endpoint
-  end
-
-
-  def get_account(), do: get_account(ExOvh)
-  def get_account(client) do
-    credentials = get_credentials(client)
-    path = URI.parse(credentials["endpoint"])
-    |> Map.get(:path)
-    {version, account} = String.split_at(path, 4)
-    account
-  end
-
-
-  #####################
-  # Genserver Callbacks
-  #####################
-
-
-  # trap exits so that terminate callback is invoked
-  # the :lock key is to allow for locking during the brief moment that the access token is being refreshed
-  def init({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    :erlang.process_flag(:trap_exit, :true)
-    token = Cache.get_token(client)
-    :timer.sleep(@init_delay) # give some time for TokenCache Genserver to initialize
-    create_ets_table(client)
-    {:ok, resp} = Request.request(client, {:get, "/account/credentials", :nil}, %{})
-    |> Og.log_return(:debug)
-    credentials = Map.put(resp.body, :lock, :false)
-    :ets.insert(ets_tablename(client), {:credentials, credentials})
-    expires = to_seconds(credentials["expires"])
-    Task.start_link(fn -> monitor_expiry(client, expires) end)
-    {:ok, {client, config, credentials}}
-  end
-
-
-  def handle_call(:add_lock, _from, {client, config, credentials}) do
-    Og.context(__ENV__, :debug)
-    new_credentials = Map.put(credentials, :lock, :true)
-    :ets.insert(ets_tablename(client), {:credentials, new_credentials})
-    {:reply, :ok, {client, config, new_credentials}}
-  end
-  def handle_call(:remove_lock, _from, {client, config, credentials}) do
-    Og.context(__ENV__, :debug)
-    new_credentials = Map.put(credentials, :lock, :false)
-    :ets.insert(ets_tablename(client), {:credentials, new_credentials})
-    {:reply, :ok, {client, config, new_credentials}}
-  end
-  def handle_call(:update_credentials, _from, {client, config, credentials}) do
-    Og.context(__ENV__, :debug)
-    {:ok, resp} = Request.request(client, {:get, "/account/credentials", ""}, %{})
-    new_credentials = resp.body
-    |> Map.put(credentials, :lock, :false)
-    :ets.insert(ets_tablename(client), {:credentials, new_credentials})
-    {:reply, :ok, {client, config, new_credentials}}
-  end
-  def handle_call(:stop, _from, state) do
-    Og.context(__ENV__, :debug)
-    {:stop, :shutdown, :ok, state}
-  end
-  def terminate(:shutdown, {client, config, credentials}) do
-    Og.context(__ENV__, :debug)
-    :ets.delete(ets_tablename(client)) # explicilty remove
-    :ok
-  end
-
-
-
-  #####################
-  # Private
-  #####################
-
-  defp gen_server_name(client), do: String.to_atom(Atom.to_string(client) <> Atom.to_string(__MODULE__))
-  defp ets_tablename(client), do: String.to_atom("Ets" <> Atom.to_string(gen_server_name(client)))
-
-
-  defp get_credentials(client, index) do
-    Og.context(__ENV__, :debug)
-    if ets_tablename(client) in :ets.all() do
-      [credentials: credentials] = :ets.lookup(ets_tablename(client), :credentials)
-      if credentials.lock === :true do
-        if index > @get_credentials_retries do
-          raise "Problem retrieving the openstack credentials from ets table"
-        else
-          :timer.sleep(@get_credentials_sleep_interval)
-          get_credentials(client, index + 1)
-        end
-      else
-        credentials
-      end
-    else
-      if index > @get_credentials_retries do
-        raise "Problem retrieving the openstack credentials from ets table"
-      else
-        :timer.sleep(@get_credentials_sleep_interval)
-        get_credentials(client, index + 1)
-      end
-    end
-  end
-
-
-  defp monitor_expiry(client, expires) do
-    Og.context(__ENV__, :debug)
-    interval = (expires - 30) * 1000
-    :timer.sleep(interval)
-    {:reply, :ok, _credentials} = GenServer.call(gen_server_name(client), :add_lock)
-    {:reply, :ok, _credentials} = GenServer.call(gen_server_name(client), :update_credentials)
-    {:reply, :ok, credentials} = GenServer.call(gen_server_name(client), :remove_lock)
-    expires = to_seconds(credentials["expires"])
-    monitor_expiry(client, expires)
-  end
-
-
-  defp create_ets_table(client) do
-    Og.context(__ENV__, :debug)
-    ets_options = [
-                   :set, # type
-                   :protected, # read - all, write this process only.
-                   :named_table,
-                   {:heir, :none}, # don't let any process inherit the table. when the ets table dies, it dies.
-                   {:write_concurrency, :false},
-                   {:read_concurrency, :true}
-                  ]
-    unless ets_tablename(client) in :ets.all() do
-      :ets.new(ets_tablename(client), ets_options)
-    end
-  end
-
-
-  defp to_seconds(iso_time) do
-    {:ok, expiry_ndt, offset} = Calendar.NaiveDateTime.Parse.iso8601(iso_time)
-    offset =
-    case offset do
-      :nil -> 0
-      offset -> offset
-    end
-    {:ok, expiry_dt_utc} = Calendar.NaiveDateTime.with_offset_to_datetime_utc(expiry_ndt, offset)
-    {:ok, now} = Calendar.DateTime.from_erl(:calendar.universal_time(), "UTC")
-    {:ok, seconds, _microseconds, _when} = Calendar.DateTime.diff(expiry_dt_utc, now)
-    if seconds > 0 do
-      seconds
-    else
-      0
-    end
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/hubic/openstack_api/request.ex b/lib/hubic/openstack_api/request.ex
deleted file mode 100644
index a4e9793..0000000
--- a/lib/hubic/openstack_api/request.ex
+++ /dev/null
@@ -1,40 +0,0 @@
-defmodule ExOvh.Hubic.OpenstackApi.Request do
-  @moduledoc :false
-  alias ExOvh.Hubic.OpenstackApi.Cache
-  alias ExOvh.Hubic.OpenstackApi.Auth
-
-
-  @spec request(client :: atom, query :: ExOvh.Client.raw_query_t, opts :: map)
-                :: {:ok, ExOvh.Client.response_t} | {:error, ExOvh.Client.response_t}
-  def request(client, {method, uri, params} = query, opts) do
-    Og.context(__ENV__, :debug)
-    {method, uri, options} = Auth.prepare_request(client, query)
-    |> Og.log_return(:debug)
-    resp = HTTPotion.request(method, uri, options)
-    |> Og.log_return(:debug)
-
-    if resp.status_code >= 100 and resp.status_code < 300 do
-      try do
-        {:ok, %{
-               body: resp.body |> Poison.decode!(),
-               headers: resp.headers,
-               status_code: resp.status_code
-              }
-        }
-      rescue
-        _ ->
-        {:ok, %{
-               body: resp.body,
-               headers: resp.headers,
-               status_code: resp.status_code
-              }
-        }
-      end
-    else
-     {:error, resp}
-    end
-
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/hubic/request.ex b/lib/hubic/request.ex
deleted file mode 100644
index 260f9ea..0000000
--- a/lib/hubic/request.ex
+++ /dev/null
@@ -1,66 +0,0 @@
-defmodule ExOvh.Hubic.Request do
-  @moduledoc :false
-  @doc ~S"""
-  Houses the `request` function which delegates the function call to the appropriate
-  module & function depending on the `opts` key-values.
-
-  Hubic uses it's own custom api and also separate Openstack compliant apis so
-  and these apis are quite different.
-  Therefore, the request needs to be routed to the correct `request` function so
-  that the correct auth credentials are put into the `options_t` in the returned
-  `ExOvh.Client.query_t` query tuple.
-
-  ## Examples of what some delegation depending on opts
-
-      ExOvh.hubic_request(query, %{} = opts)
-      calls
-      ExOvh.Hubic.HubicApi.Request.request(ExOvh, query, opts)
-
-  -
-
-      ExOvh.hubic_request(query, %{ openstack: :true } = opts)
-      calls
-      ExOvh.Hubic.OpenstackApi.Request.request(ExOvh, query, opts)
-
-
-  ## Subsequent Request modules
-
-  The subsequent request functions process the request by
-
-  1. Calling the appropriate `prepare_request` function which has been delegated to.
-  2. Making the actual request with `HTTPotion`
-  3. Returning the response as `{:ok, response_t}` or `{:error, response_t}`
-  """
-  alias ExOvh.Hubic.HubicApi.Request, as: Hubic
-  alias ExOvh.Hubic.OpenstackApi.Request, as: Open
-
-
-  @doc ~S"""
-  Delegates the function call to the appropriate module & function depending on the `opts` key-values.
-
-  Subsequent request functions return `{:ok, response_t}` or `{:error, response_t}`
-
-  ## Options
-
-      { } = opts
-
-  The function call will be delegated to `ExOvh.Hubic.HubicApi.Request` and processed as a hubic api request.
-
-      { openstack: :true } = opts
-
-  The function call will be delegated to `ExOvh.Hubic.OpenstackApi.Request`.
-
-  `openstack: :true` - boolean - indicates whether the request is an openstack one or not.
-  """
-  @spec request(client :: atom, query :: ExOvh.Client.raw_query_t, opts :: map)
-                :: {:ok, ExOvh.Client.response_t} | {:error, ExOvh.Client.response_t}
-  def request(client, {method, uri, params} = query, %{ openstack: :true } = opts) do
-    Open.request(client, query, opts)
-  end
-
-  def request(client, {method, uri, params} = query, opts) do
-    Hubic.request(client, query, opts)
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/hubic/request_helpers.ex b/lib/hubic/request_helpers.ex
deleted file mode 100644
index 2ca74a8..0000000
--- a/lib/hubic/request_helpers.ex
+++ /dev/null
@@ -1,86 +0,0 @@
-defmodule ExOvh.Hubic.RequestHelpers do
-  @moduledoc ~S"""
-  Helper functions for making requests to the hubic custom api and hubic openstack api.
-  """
-  import ExOvh.Query.Openstack.Swift
-  alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-
-
-  @doc ~S"""
-  Gets a list of all openstack swift containers for the hubic app
-
-  Returns `{:ok, [<container_name>, <container_name> ...]`
-  or
-  Returns `{:error, resp}`
-
-  ## Example
-
-      alias ExOvh.Hubic.RequestHelpers
-      client = ExOvh # Enter your client here
-      RequestHelpers.containers(client)
-  """
-  @spec containers(client :: atom)
-                   :: {:ok, [String.t]} | {:error, ExOvh.Client.response_t}
-  def containers(client) do
-    account = OpenCache.get_account(client)
-    case ExOvh.hubic_request(account_info(account), %{ openstack: :true }) do
-      {:ok, resp} ->
-        Og.log_return(resp)
-        {:ok, resp.body |> Enum.map(fn(%{"name" => container}) -> container end)}
-      {:error, resp} ->
-        {:error, resp}
-    end
-  end
-
-
-  @doc ~S"""
-  Gets a list of all objects by name in an openstack swift container for the hubic app
-  Allows to filter the returned list by hash or by name depending on the filter used.
-
-  Returns `{:ok, [<object_name>, <object_name> ...]`
-  or
-  Returns `{:error, resp}`
-
-  ## Example
-
-      alias ExOvh.Hubic.RequestHelpers
-      client = ExOvh
-      container = "new_container"
-      RequestHelpers.get_objects(client, container, :name)
-
-
-  ## Example
-
-      alias ExOvh.Hubic.RequestHelpers
-      client = ExOvh
-      container = "new_container"
-      RequestHelpers.get_objects(client, container, :hash)
-  """
-  @spec get_objects(client :: atom, container :: String.t, filter :: atom)
-                   :: {:ok, [String.t]} | {:error, ExOvh.Client.response_t}
-  def get_objects(client, container, filter)
-
-  def get_objects(client, container, :name) do
-    account = OpenCache.get_account(client)
-    case ExOvh.hubic_request(get_objects(account, container), %{ openstack: :true }) do
-      {:ok, resp} ->
-        Og.log_return(resp)
-        {:ok, resp.body |> Enum.map(fn(%{"name" => object_name}) -> object_name end)}
-      {:error, resp} ->
-        {:error, resp}
-    end
-  end
-
-  def get_objects(client, container, :hash) do
-    account = OpenCache.get_account(client)
-    case ExOvh.hubic_request(get_objects(account, container), %{ openstack: :true }) do
-      {:ok, resp} ->
-        Og.log_return(resp)
-        {:ok, resp.body |> Enum.map(fn(%{"hash" => object_hash}) -> object_hash end)}
-      {:error, resp} ->
-        {:error, resp}
-    end
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/hubic/supervisor.ex b/lib/hubic/supervisor.ex
deleted file mode 100644
index 76b7602..0000000
--- a/lib/hubic/supervisor.ex
+++ /dev/null
@@ -1,31 +0,0 @@
-defmodule ExOvh.Hubic.Supervisor do
-  @moduledoc :false
-  use Supervisor
-  alias ExOvh.Hubic.HubicApi.Cache, as: TokenCache
-  alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenstackCache
-
-  #####################
-  # Public
-  #####################
-
-  def start_link(client, config, opts) do
-    Og.context(__ENV__, :debug)
-    Supervisor.start_link(__MODULE__, {client, config, opts}, [name: supervisor_name(client)])
-  end
-
-  #####################
-  # Supervisor Callbacks
-  #####################
-
-  def init({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    workers = [
-                {TokenCache, {TokenCache, :start_link, [{client, config, opts}]}, :permanent, 15000, :worker, [TokenCache]},
-                {OpenstackCache, {OpenstackCache, :start_link, [{client, config, opts}]}, :permanent, 20000, :worker, [OpenstackCache]}
-              ]
-    supervise(workers, strategy: :one_for_one, max_restarts: 20)
-  end
-
-  defp supervisor_name(client), do: String.to_atom(Atom.to_string(client) <> Atom.to_string(__MODULE__))
-
-end
diff --git a/lib/mix/tasks/hubic.ex b/lib/mix/tasks/hubic.ex
deleted file mode 100644
index 79a5793..0000000
--- a/lib/mix/tasks/hubic.ex
+++ /dev/null
@@ -1,255 +0,0 @@
-defmodule Mix.Tasks.Hubic do
-  @moduledoc ~S"""
-  A mix task that generates the hubic application refresh token on the user's behalf.
-
-  ## Steps
-
-  - The user needs to go to https://hubic.com/ and set up an account and retrieve a username and password.
-  - Then the user is prompted to do some activations.
-  - Upon completion of activations, the user needs to create an application in the hubic website.
-  - With the username, password, client_id, client_secret and redirect url from the recently created application,
-  a mixtask can be run which will apply the scope of the user and get the refresh_token on the user's behalf.
-
-  The mix task can be run as follows in a linux terminal:
-
-  ```shell
-  mix hubic
-  --login=<login>
-  --password=<password>
-  --clientid=<client_id>
-  --clientsecret=<client_secret>
-  --redirecturi=<uri>
-  ```
-
-  ## Shell Output
-
-  ```elixir
-  %{
-  client_id: "<client_id>",
-  client_secret: "<client_secret>",
-  refresh_token: "<refresh_token>",
-  redirect_uri: "<uri>"
-  }
-  ```
-
-  This map can then be manually added by the user to the `config/prod.secret.exs` file
-
-  ```
-  config :test_os, TestOs.ExOvh,
-    ovh: :nil
-    hubic:   %{
-              client_id: "<client_id>",
-              client_secret: "<client_secret>",
-              refresh_token: "<refresh_token>",
-              redirect_uri: "<uri>"
-             }
-  ```
-
-  - Then the hubic configuration is complete. Start up the app and the hubic wrapper is ready.
-  """
-  use Mix.Task
-  alias ExOvh.Hubic.Defaults
-  @hubic_auth_uri Defaults.hubic()[:auth_uri]
-  @hubic_token_uri Defaults.hubic()[:token_uri]
-  @timeout 20_000
-
-
-  ##########################
-  # Public
-  #########################
-
-
-  def run(args) do
-    Og.log_return(args, :debug)
-    opts_map = parse_args(args)
-    Og.log_return(opts_map, :debug)
-    IO.inspect(opts_map, pretty: :true)
-    Mix.Shell.IO.info("")
-    Mix.Shell.IO.info("The details in the map above will be used to get the hubic refresh token.")
-    Mix.Shell.IO.info("")
-    if Mix.Shell.IO.yes?("Do you want to proceed?") do
-      Application.start(:ibrowse, :permanent)
-      Application.start(:httpotion, :permanent)
-      options = get_auth_code(opts_map) |> get_refresh_token() |> remove_private()
-      message = "
-      %{
-        client_id: \"#{options.client_id}\",
-        client_secret: \"#{options.client_secret}\",
-        refresh_token: \"#{options.refresh_token}\",
-        redirect_uri: \"#{options.redirect_uri}\"
-       }
-      "
-      Mix.Shell.IO.info(message)
-    end
-  end
-
-
-  ##########################
-  # Private
-  #########################
-
-
-  defp parse_args(args) do
-    {opts, _, _} = OptionParser.parse(args)
-    Og.log_return(opts, :debug)
-    {opts, opts_map} = opts
-    |> has_required_args()
-    |> parsers_login()
-    |> parsers_password()
-    |> parsers_client_id()
-    |> parsers_client_secret()
-    |> parsers_redirect_uri()
-    opts_map
-  end
-
-  defp has_required_args(opts) do
-    login = Keyword.get(opts, :login, :nil)
-    if login === :nil do
-      raise "Task requires login argument"
-    end
-    password = Keyword.get(opts, :password, :nil)
-    if password === :nil do
-      raise "Task requires password argument"
-    end
-    client_id = Keyword.get(opts, :clientid, :nil)
-    if client_id === :nil do
-      raise "Task requires client_id argument"
-    end
-    client_secret = Keyword.get(opts, :clientsecret, :nil)
-    if client_secret === :nil do
-      raise "Task requires client_secret argument"
-    end
-    redirect_uri = Keyword.get(opts, :redirecturi, :nil)
-    if redirect_uri === :nil do
-      raise "Task requires redirect_uri argument"
-    end
-    {opts, %{}}
-  end
-
-
-  defp parsers_login({opts, acc}), do: {opts, Map.merge(acc, %{login: Keyword.fetch!(opts, :login)}) }
-  defp parsers_password({opts, acc}), do: {opts, Map.merge(acc, %{ password: Keyword.fetch!(opts, :password)}) }
-  defp parsers_client_id({opts, acc}), do: {opts, Map.merge(acc, %{ client_id: Keyword.fetch!(opts, :clientid)}) }
-  defp parsers_client_secret({opts, acc}), do: {opts, Map.merge(acc, %{ client_secret: Keyword.fetch!(opts, :clientsecret)}) }
-  defp parsers_redirect_uri({opts, acc}), do: {opts, Map.merge(acc, %{ redirect_uri: Keyword.fetch!(opts, :redirecturi)}) }
-
-
-  # - Summary: Gets the authorisation code when the refresh token is not provided in config.exs by the user
-  # - Makes a request to the @hubic_auth_uri with the client id and scopes for the code
-  # - Autocompletes the form information to acquire the code
-  # - Sends the application/x-www-form-urlencoded information to the @hubic_auth_uri on behalf of the user
-  # - Parses and returns the authorisation code inside the opts_map
-  defp get_auth_code(opts_map) do
-    Og.context(__ENV__, :debug)
-    query_string = "?client_id=" <> opts_map.client_id <>
-                   "&redirect_uri=" <> URI.encode_www_form(opts_map.redirect_uri) <>
-                   "&scope=" <> "usage.r,account.r,getAllLinks.r,credentials.r,sponsorCode.r,activate.w,sponsored.r,links.drw" <>
-                   "&response_type=" <> "code" <>
-                   "&state=" <> SecureRandom.urlsafe_base64(10)
-    options = %{ timeout: @timeout }
-    uri = @hubic_auth_uri <> query_string
-    resp = HTTPotion.request(:get, uri, options)
-    resp =
-    %{
-      body: resp.body,
-      headers: resp.headers,
-      status_code: resp.status_code
-     }
-    inputs = get_validated_inputs(resp.body)
-    {req_body, _, _} = Enum.reduce(inputs, {"", 1, Enum.count(inputs)}, fn({"input", input, _}, acc) ->
-      name = :proplists.get_value("name", input)
-      value = ""
-      {name, value} =
-      case name do
-        "login" ->
-          value = opts_map.login
-          {name, value}
-        "user_pwd" ->
-          value = opts_map.password
-          {name, value}
-        _ ->
-          value = :proplists.get_value("value", input)
-          {name, value}
-      end
-      param =  name <> "=" <> value
-      {acc, index, max} = acc
-      if index === max do
-        acc = acc <> param
-      else
-        acc = acc <> param <> "&"
-      end
-      {acc, index + 1, max}
-    end)
-
-    req_body = req_body <> "&links=d" # bug fix: *delete links needed - unknown why not in inputs already*
-    options = %{ body: req_body, headers: %{ "Content-Type": "application/x-www-form-urlencoded" } }
-    resp = HTTPotion.request(:post, @hubic_auth_uri, options)
-
-    if resp.status_code !== 302, do: raise Floki.find(resp.body, "h4.text-error") |> Floki.text
-
-    resp =
-    %{
-      body: resp.body,
-      headers: resp.headers  |> Enum.into(%{}),
-      status_code: resp.status_code
-    }
-
-    code = resp.headers
-    |> Map.get(:Location)
-    |> URI.parse
-    |> Map.get(:query)
-    |> URI.decode_query
-    |> Map.get("code")
-    Map.merge(opts_map, %{ auth_code: code })
-  end
-
-
-  defp get_validated_inputs(resp_body) do
-    Og.context(__ENV__, :debug)
-    inputs = Floki.find(resp_body, "form input[type=text], form input[type=password], form input[type=checkbox], form input[type=hidden]")
-    |> List.flatten()
-    if Enum.any?(inputs, fn(input) -> input === [] end), do: raise "Empty input found"
-    inputs
-  end
-
-  #- Adds the refresh_token to the opts_map
-  @spec get_refresh_token(opts_map :: map) :: map
-  defp get_refresh_token(opts_map) do
-    Og.context(__ENV__, :debug)
-    auth_credentials = opts_map.client_id <> ":" <> opts_map.client_secret
-    auth_credentials_base64 = Base.encode64(auth_credentials)
-    req_body = "code=" <> opts_map.auth_code <>
-               "&redirect_uri=" <> URI.encode_www_form(opts_map.redirect_uri) <>
-               "&grant_type=authorization_code"
-    headers = %{
-               "Content-Type": "application/x-www-form-urlencoded",
-               "Authorization": "Basic " <> auth_credentials_base64
-              }
-    options = %{ body: req_body, headers: headers, timeout: @timeout }
-    resp = HTTPotion.request(:post, @hubic_token_uri, options)
-    now_milli_seconds = :os.system_time(:milli_seconds)
-    body =
-    %{
-      body: resp.body |> Poison.decode!(),
-      headers: resp.headers,
-      status_code: resp.status_code
-    }
-    |> Map.get(:body)
-    if Map.has_key?(body, "error") do
-      error = Map.get(resp, "error") <> " :: " <> Map.get(resp, "error_description")
-      raise error
-    end
-    refresh_token = Map.get(body, "refresh_token")
-    Map.merge(opts_map, %{ refresh_token: refresh_token })
-  end
-
-
-  defp remove_private(opts_map) do
-    opts_map |> Map.delete(:login) |> Map.delete(:password) |> Map.delete(:auth_code)
-  end
-
-
-end
-
-
-
diff --git a/lib/mix/tasks/ovh.ex b/lib/mix/tasks/ovh.ex
index 5d212ba..c835415 100644
--- a/lib/mix/tasks/ovh.ex
+++ b/lib/mix/tasks/ovh.ex
@@ -1,6 +1,7 @@
 defmodule Mix.Tasks.Ovh do
+  @shortdoc "Create a new app and new credentials for accessing ovh api"
   @moduledoc ~S"""
-  A mix task that generates the hubic application refresh token on the user's behalf.
+  A mix task that generates the ex_ovh application secrets on the user's behalf.
 
   ## Steps
 
@@ -13,123 +14,69 @@ defmodule Mix.Tasks.Ovh do
   - Then the user can create an application at `https://eu.api.ovh.com/createApp/` or
     alternatively the user can use this mix task to generate the application:
 
-  ## Example
+  ## Examples
 
   Create an app with access to all apis:
 
+      mix ovh \
+      --login=<username> \
+      --password=<password> \
+      --appname='ex_ovh'
 
-  ```shell
-  mix ovh
-  --login=<username>
-  --password=<password>
-  ```
-
-  Uses defaults:
-  ```
-  app name - ex_ovh,
-  app description - ex_ovh,
-  redirect_uri - "",
-  api_version - "1.0",
-  endpoint - "ovh-eu"
-  ```
+  Output:
 
+      config :ex_ovh,
+        ovh: %{
+          application_key: System.get_env("EX_OVH_APPLICATION_KEY"),
+          application_secret: System.get_env("EX_OVH_APPLICATION_SECRET"),
+          consumer_key: System.get_env("EX_OVH_CONSUMER_KEY"),
+          endpoint: System.get_env("EX_OVH_ENDPOINT"),
+          api_version: System.get_env("EX_OVH_API_VERSION") || "1.0",
+          connect_timeout: 30000, # 30 seconds
+          connect_timeout: (60000 * 30) # 30 minutes
+        }
 
-  ## Example
 
   Create an app with access to all apis with specific app name and description:
 
-
-  ```shell
-  mix ovh
-  --login=<username>
-  --password=<password>
-  --appname='My app'
-  --appdesc='my app for api'
-  ```
-
-  Uses defaults:
-  ```
-  redirect_uri - "",
-  api_version - "1.0",
-  endpoint - "ovh-eu"
-  ```
-
-  ## Example
-
-  Create an app with access to all apis with specific everything:
-
-
-  ```shell
-  mix ovh
-  --login=<username>
-  --password=<password>
-  --appname='My app'
-  --appdesc='my app for api'
-  --endpoint=ovh-eu
-  --apiversion=1.0
-  --redirect_uri='http://localhost:4000/',
-  --accessrules='get-[/*]::put-[/me,/cdn]::post-[/me,/cdn]::delete-[]'
-  ```
-
-
-  A note on access rules:
-
-  The default for access rules will give your ovh application access to *all* of the api calls.
-  More than likely this is not a good idea. To limit the number of api endpoints available, generate access
-  rules using the commandline arguments as seen in the example above.
-
-
-  ## Shell Output
-
-  A map is printed to the shell as follows:
-
-  ```elixir
-  %{
-  application_key: "<app_key>",
-  application_secret: "<app_secret>",
-  consumer_key: "<consumer_secret>",
-  endpoint: "ovh-eu",
-  api_version: "1.0"
-  }
-  ```
-
-  - This map can then be manually added by the user to the `config/prod.secret.exs` file
-
-  ```
-  config :test_os, TestOs.ExOvh,
-  ovh: %{
-        application_key: "<app_key>",
-        application_secret: "<app_secret>",
-        consumer_key: "<consumer_secret>",
-        endpoint: "ovh-eu",
-        api_version: "1.0"
-       },
-  hubic: :nil
-  ```
-
-  - Then the ovh configuration is complete. Start up the app and the ovh wrapper is ready.
+      mix ovh \
+      --login=<username> \
+      --password=<password> \
+      --appdescription='my app for api' \
+      --endpoint='ovh-eu' \
+      --apiversion='1.0' \
+      --redirect_uri='http://localhost:4000/' \
+      --accessrules='get-[/*]::put-[/me,/cdn]::post-[/me,/cdn]::delete-[]' \
+      --appname='my_app'
+
+  Output:
+
+      config :my_app, MyApp.ExOvh,
+          ovh: %{
+            application_key: System.get_env("MY_APP_EX_OVH_APPLICATION_KEY"),
+            application_secret: System.get_env("MY_APP_EX_OVH_APPLICATION_SECRET"),
+            consumer_key: System.get_env("MY_APP_EX_OVH_CONSUMER_KEY"),
+            endpoint: System.get_env("MY_APP_EX_OVH_ENDPOINT"),
+            api_version: System.get_env("MY_APP_EX_OVH_API_VERSION") || "1.0",
+            connect_timeout: 30000, # 30 seconds
+            connect_timeout: (60000 * 30) # 30 minutes
+          }
+
+  ## Notes
+
+  - Access rules: The default for access rules will give your ovh application access to *all* of the api calls. More
+  than likely this is not a good idea. To limit the number of api endpoints available, generate access rules using
+  the commandline arguments as seen in the example above.
   """
   use Mix.Task
-  alias ExOvh.Ovh.Defaults
-  alias ExOvh.Ovh.Auth
-  import ExOvh.Query.Ovh.Webstorage, only: [get_all_webstorage: 0]
+  alias ExOvh.Utils
 
-  @shortdoc "Create a new app and new credentials for accessing ovh api"
-  @default_headers %{ "Content-Type": "application/json; charset=utf-8" }
-  @timeout 10_000
 
-  defp endpoint(config), do: Defaults.endpoints()[config[:endpoint]]
-  defp access_rules(config), do: config[:access_rules]
-  defp api_version(config), do: config[:api_version]
-  defp app_secret(config), do: config[:application_secret]
-  defp app_key(config), do: config[:application_key]
-  defp default_create_app_uri(config), do: endpoint(config) <> "createApp/"
-  defp consumer_key_uri(config), do: endpoint(config) <> api_version(config) <> "/auth/credential/"
+  @default_headers [{"Content-Type", "application/json; charset=utf-8"}]
+  @default_options [ timeout: 30000, recv_timeout: (60000 * 1) ]
 
 
-  ##########################
   # Public
-  #########################
 
 
   def run(args) do
@@ -139,20 +86,21 @@ defmodule Mix.Tasks.Ovh do
     Mix.Shell.IO.info("The details in the map above will be used to create the ovh application.")
     Mix.Shell.IO.info("")
     if Mix.Shell.IO.yes?("Do you want to proceed?") do
-      Application.start(:ibrowse, :permanent)
-      Application.start(:httpotion, :permanent)
+      HTTPoison.start
       opts_map = parse_args(args)
-      options = get_credentials(opts_map)
-      message = "
-      %{
-        application_key: \"#{options.application_key}\",
-        application_secret: \"#{options.application_secret}\",
-        consumer_key: \"#{options.consumer_key}\",
-        endpoint: \"#{options.endpoint}\",
-        api_version: \"#{options.api_version}\"
-       }
-       "
-       Mix.Shell.IO.info(message)
+
+      message = get_credentials(opts_map)
+      |> remove_private()
+      |> create_or_update_env_file()
+      |> print_config()
+
+      Mix.Shell.IO.info(message)
+      Mix.Shell.IO.info("")
+      Mix.Shell.IO.info("Update your environment variables and your set.")
+      Mix.Shell.IO.info("")
+      Mix.Shell.IO.info("For example: ")
+      Mix.Shell.IO.info("")
+      Mix.Shell.IO.info("source .env")
     end
   end
 
@@ -175,6 +123,7 @@ defmodule Mix.Tasks.Ovh do
     |> parsers_app_name()
     |> parsers_app_desc()
     |> parsers_access_rules()
+    |> parsers_client_name()
     opts_map
   end
 
@@ -189,11 +138,17 @@ defmodule Mix.Tasks.Ovh do
       raise "Task requires password argument"
     end
     {opts, %{}}
+    client_name = Keyword.get(opts, :appname, :ex_ovh)
+    if client_name === :nil do
+      raise "Task requires appname argument"
+    end
+    {opts, %{}}
   end
 
 
   defp parsers_login({opts, acc}), do: {opts, Map.merge(acc, %{login: Keyword.fetch!(opts, :login)}) }
   defp parsers_password({opts, acc}), do: {opts, Map.merge(acc, %{ password: Keyword.fetch!(opts, :password)}) }
+  defp parsers_client_name({opts, acc}), do: {opts, Map.merge(acc, %{ client_name: Keyword.fetch!(opts, :appname)}) }
   defp parsers_endpoint({opts, acc}) do
     endpoint = Keyword.get(opts, :endpoint, :nil)
     if endpoint === :nil do
@@ -223,7 +178,7 @@ defmodule Mix.Tasks.Ovh do
     {opts, Map.merge(acc, %{ application_name: application_name }) }
   end
   defp parsers_app_desc({opts, acc}) do
-    application_description = Keyword.get(opts, :appdesc, :nil)
+    application_description = Keyword.get(opts, :appdescription, :nil)
     if application_description === :nil do
       application_description = "ex_ovh"
     end
@@ -232,7 +187,7 @@ defmodule Mix.Tasks.Ovh do
   defp parsers_access_rules({opts, acc}) do
     access_rules = Keyword.get(opts, :accessrules, :nil)
     if access_rules === :nil do
-      access_rules = Defaults.access_rules()
+      access_rules = Utils.access_rules()
     else
       access_rules = access_rules
       |> String.split("::")
@@ -263,11 +218,14 @@ defmodule Mix.Tasks.Ovh do
 
   defp get_app_create_page(opts_map) do
     Og.context(__ENV__, :debug)
-    options = [ timeout: @timeout ]
-    default_create_app_uri(opts_map)
-    %HTTPotion.Response{body: resp_body, headers: headers, status_code: status_code} =
-      HTTPotion.request(:get, default_create_app_uri(opts_map), options)
-    resp_body
+
+    method = :get
+    uri = Utils.default_create_app_uri(opts_map)
+    body = ""
+    headers = []
+    options = @default_options
+    resp = HTTPoison.request!(method, uri, body, headers, options)
+    Map.get(resp, :body)
   end
 
 
@@ -313,17 +271,30 @@ defmodule Mix.Tasks.Ovh do
 
   defp send_app_request(req_body, opts_map) do
     Og.context(__ENV__, :debug)
-    uri = Defaults.endpoints()[opts_map.endpoint] <> "createApp/"
-    resp = HTTPotion.request(:post, uri, [body: req_body, headers: ["Content-Type": "application/x-www-form-urlencoded"]])
-    error_msg1 = "There is already an application with that name for that Account ID"
+
+    method = :post
+    uri = Utils.endpoints()[opts_map.endpoint] <> "createApp/"
+    body = req_body
+    headers = [{"Content-Type", "application/x-www-form-urlencoded"}]
+    options = @default_options
+    resp = HTTPoison.request!(method, uri, body, headers, options)
+
+    resp.body
+    |> Og.log_return(__ENV__, :warn)
+
+    error_msg1 =
+    # Error checking
     cond do
-     String.contains?(resp.body, error_msg1) ->
-      raise error_msg1
+     String.contains?(resp.body, msg = "There is already an application with that name for that Account ID") ->
+      raise(msg <> ", try removing the old application first using the ovh api console or just create a new one.")
+     String.contains?(resp.body, msg = "Invalid account/password") ->
+      raise(msg <> ", try adding '-ovh' to the end of the login")
      String.contains?(resp.body, "Application created") ->
       resp.body
      true ->
       raise "unknown error"
     end
+
   end
 
 
@@ -352,24 +323,32 @@ defmodule Mix.Tasks.Ovh do
 
   defp get_consumer_key(%{access_rules: access_rules, redirect_uri: redirect_uri} = opts_map) do
     Og.context(__ENV__, :debug)
-    body = %{ accessRules: access_rules, redirection: redirect_uri }
-    # {method, uri, options} = Auth.ovh_prepare_request(ExOvh, query, %{})
-    options = %{ body: Poison.encode!(body), headers: Map.merge(@default_headers, %{ "X-Ovh-Application": app_key(opts_map) } ), timeout: @timeout }
-    |> Og.log_return(:debug)
 
-    Og.log_return(consumer_key_uri(opts_map), :debug)
-    Og.log_return(options, :debug)
+    method = :post
+    uri = Utils.consumer_key_uri(opts_map)
+    body = %{ accessRules: access_rules, redirection: redirect_uri } |> Poison.encode!()
+    headers = Map.merge(Enum.into(@default_headers, %{}), Enum.into([{"X-Ovh-Application", Utils.app_key(opts_map)}], %{})) |> Enum.into([])
+    options = @default_options
+    resp = HTTPoison.request!(method, uri, body, headers, options)
 
-    body = HTTPotion.request(:post, consumer_key_uri(opts_map), options) |> Map.get(:body) |> Poison.decode!()
+    body = Poison.decode!(Map.get(resp, :body))
     {Map.get(body, "consumerKey"), Map.get(body, "validationUrl")}
   end
 
 
   defp bind_consumer_key_to_app({ck, validation_url}, opts_map) do
-      HTTPotion.request(:get, validation_url) |> Map.get(:body)
-      |> get_bind_ck_to_app_inputs()
-      |> build_ck_binding_request(opts_map)
-      |> send_ck_binding_request(validation_url, ck)
+
+    method = :get
+    uri = validation_url
+    body = ""
+    headers = []
+    options = @default_options
+    resp = HTTPoison.request!(method, uri, body, headers, options)
+
+    Map.get(resp, :body)
+    |> get_bind_ck_to_app_inputs()
+    |> build_ck_binding_request(opts_map)
+    |> send_ck_binding_request(validation_url, ck)
   end
 
 
@@ -425,7 +404,15 @@ defmodule Mix.Tasks.Ovh do
 
   defp send_ck_binding_request(req_body, validation_url, ck) do
     Og.context(__ENV__, :debug)
-    resp = HTTPotion.request(:post, validation_url, [body: req_body, headers: ["Content-Type": "application/x-www-form-urlencoded"]])
+
+
+    method = :post
+    uri = validation_url
+    body = req_body
+    headers = [{"Content-Type", "application/x-www-form-urlencoded"}]
+    options = @default_options
+    resp = HTTPoison.request!(method, uri, body, headers, options)
+
     error_msg1 = "Failed to bind the consumer token to the application. Please try to validate the consumer token manually at #{validation_url}"
     error_msg2 = "Invalid validity period entered for the consumer token. Please try to validate the consumer token manually at #{validation_url}"
     cond do
@@ -436,6 +423,7 @@ defmodule Mix.Tasks.Ovh do
      true ->
       raise error_msg1
     end
+
   end
 
 
@@ -453,4 +441,72 @@ defmodule Mix.Tasks.Ovh do
   end
 
 
+  defp remove_private(opts_map) do
+    opts_map |> Map.delete(:login) |> Map.delete(:password)
+  end
+
+
+  defp config_names(client_name) do
+    {config_header, mod_client_name} =
+    case client_name  do
+      "ex_ovh" ->
+        {
+          ":" <> client_name,
+          "EX_OVH_"
+        }
+      other ->
+        {
+          ":" <> client_name <> ", " <> Macro.camelize(client_name) <> "." <> "ExOvh",
+          String.upcase(other) <> "_EX_OVH_"
+        }
+    end
+    {config_header, mod_client_name}
+  end
+
+  defp create_or_update_env_file(options) do
+    env_path = ".env"
+    File.touch!(env_path)
+    existing = File.read!(env_path)
+    {_config_header, mod_client_name} = config_names(options.client_name)
+    format_date = ExOvh.Utils.formatted_date()
+    new = existing <>
+    ~s"""
+
+    # updated on #{format_date}
+    export #{mod_client_name <> "APPLICATION_KEY"}=\"#{options.application_key}\"
+    export #{mod_client_name <> "APPLICATION_SECRET"}="#{options.application_secret}\"
+    export #{mod_client_name <> "CONSUMER_KEY"}="#{options.consumer_key}\"
+    export #{mod_client_name <> "ENDPOINT"}=\"#{options.endpoint}\"
+    export #{mod_client_name <> "API_VERSION"}=\"#{options.api_version}\"
+
+    """
+    {:ok, file} = File.open(env_path, [:write, :utf8])
+    IO.binwrite(file, new)
+    File.close(file)
+    options
+  end
+
+
+  defp print_config(options) do
+    client_name = options.client_name
+    {config_header, mod_client_name} = config_names(client_name)
+
+    ~s"""
+
+    Add the following paragraph to your config.exs file(s):
+
+    config #{config_header},
+        ovh: %{
+          application_key: System.get_env(\"#{mod_client_name <> "APPLICATION_KEY"}\"),
+          application_secret: System.get_env(\"#{mod_client_name <> "APPLICATION_SECRET"}\"),
+          consumer_key: System.get_env(\"#{mod_client_name <> "CONSUMER_KEY"}\"),
+          endpoint: System.get_env(\"#{mod_client_name <> "ENDPOINT"}\"),
+          api_version: System.get_env(\"#{mod_client_name <> "API_VERSION"}\") || "1.0",
+          connect_timeout: 30000, # 30 seconds
+          connect_timeout: (60000 * 30) # 30 minutes
+        }
+    """
+  end
+
+
 end
\ No newline at end of file
diff --git a/lib/ovh/auth.ex b/lib/ovh/auth.ex
deleted file mode 100644
index 00b1163..0000000
--- a/lib/ovh/auth.ex
+++ /dev/null
@@ -1,69 +0,0 @@
-defmodule ExOvh.Ovh.Auth do
-  @moduledoc :false
-  @doc ~s"""
-  Houses the `prepare_request` function which delegates the function call to the appropriate
-  module & function depending on the `opts` key-values.
-
-  Ovh uses it's own custom api and also separate Openstack compliant apis so
-  and these apis are quite different.
-  Therefore, the request needs to be routed to the correct `prepare_request` function so
-  that the correct auth credentials are put into the `options_t` in the returned
-  `ExOvh.Client.query_t` query tuple.
-
-  ## Examples of what some delegation depending on opts
-
-      ExOvh.ovh_prepare_request(query, %{} = opts)
-      calls
-      ExOvh.Ovh.OvhApi.Auth.ovh_prepare_request(ExOvh, query, opts)
-
-  -
-
-      ExOvh.ovh_prepare_request(query, %{ openstack: :true, webstorage: "service_name" } = opts)
-      calls
-      ExOvh.Ovh.OpenstackApi.Webstorage.Auth.ovh_prepare_request(ExOvh, query, opts)
-
-
-  ## Subsequent Request modules
-
-  The subsequent request functions process the request by
-
-  1. Calling the appropriate `prepare_request` function which has been delegated to.
-  2. Getting the appropriate auth credentials and adding them to the headers as needed.
-  3. Returning `ExOvh.Client.query_t` which is a tuple of the format {method, uri, options} which
-     can then be easily used to make requests using HTTPpotion, `ovh_request` or `hubic_request`.
-  """
-  alias ExOvh.Ovh.OpenstackApi.Webstorage.Auth, as: Webstorage
-  alias ExOvh.Ovh.OvhApi.Auth, as: OvhAuth
-
-
-  @doc ~S"""
-  Delegates the function call to the appropriate module & function depending on the `opts` key-values.
-
-  Subsequent request functions return `{:ok, response_t}` or `{:error, response_t}`
-
-  ## Options
-
-      { } = opts
-
-  The function call will be delegated to `ExOvh.Ovh.OvhApi.Auth`.
-
-      { openstack: :true, webstorage: "<service>" } = opts
-
-  The function call will be delegated to `ExOvh.Ovh.OpenstackApi.Webstorage.Auth`.
-
-  `openstack: :true` - boolean - indicates whether the request is an openstack one or not.
-
-  `webstorage: service` - String.t and is the name the cdn webstorage in your ovh stack which you which to use.
-  """
-  @spec prepare_request(client :: atom, query :: ExOvh.Client.raw_query_t, opts :: map())
-                     :: ExOvh.Client.query_t
-  def prepare_request(client, {method, uri, params} = query, %{ openstack: :true, webstorage: service } = opts) do
-    Webstorage.prepare_request(client, query, service)
-  end
-
-  def prepare_request(client, {method, uri, params} = query, opts) do
-    OvhAuth.prepare_request(client, query)
-  end
-
-
-end
diff --git a/lib/ovh/defaults.ex b/lib/ovh/defaults.ex
deleted file mode 100644
index a575029..0000000
--- a/lib/ovh/defaults.ex
+++ /dev/null
@@ -1,54 +0,0 @@
-defmodule ExOvh.Ovh.Defaults do
-  @moduledoc :false
-
-  @doc "Returns ovh default configuration settings"
-  @spec ovh() :: map
-  def ovh() do
-    %{
-      endpoint: "ovh-eu",
-      api_version: "1.0"
-    }
-  end
-
-
-  @doc "Returns map of ovh endpoints"
-  @spec endpoints() :: map
-  def endpoints() do
-    %{
-      "ovh-eu"        => "https://api.ovh.com/",
-      "ovh-ca"        => "https://ca.api.ovh.com/",
-      "kimsufi-eu"    => "https://eu.api.kimsufi.com/",
-      "kimsufi-ca"    => "https://ca.api.kimsufi.com/",
-      "soyoustart-eu" => "https://eu.api.soyoustart.com/",
-      "soyoustart-ca" => "https://ca.api.soyoustart.com/",
-      "runabove-ca"   => "https://api.runabove.com/"
-    }
-  end
-
-
-  @doc "Returns the default access rules (all methods and paths)"
-  @spec access_rules() :: [map]
-  def access_rules() do
-     [
-        %{
-            method: "GET",
-            path: "/*"
-        },
-        %{
-            method: "POST",
-            path: "/*"
-        },
-        %{
-            method: "PUT",
-            path: "/*"
-        },
-        %{
-            method: "DELETE",
-            path: "/*"
-        }
-    ]
-  end
-
-
-end
-
diff --git a/lib/ovh/openstack_api/webstorage/auth.ex b/lib/ovh/openstack_api/webstorage/auth.ex
deleted file mode 100644
index fa2cfa5..0000000
--- a/lib/ovh/openstack_api/webstorage/auth.ex
+++ /dev/null
@@ -1,48 +0,0 @@
-defmodule ExOvh.Ovh.OpenstackApi.Webstorage.Auth do
-  @moduledoc :false
-  alias ExOvh.Ovh.OpenstackApi.Webstorage.Cache, as: WebStorageCache
-
-  @methods [:get, :post, :put, :delete]
-  @timeout 10_000
-
-
-  ############################
-  # Public
-  ############################
-
-
-  @spec prepare_request(client :: atom, query :: ExOvh.Client.raw_query_t, service :: String.t)
-                     :: ExOvh.Client.query_t
-  def prepare_request(client, query)
-
-  def prepare_request(client, {method, uri, params} = query, service) when method in [:get, :head, :delete] do
-    uri =  WebStorageCache.get_swift_endpoint(client, service) <> uri
-    if params !== :nil and params !== "", do: uri = uri <> "?" <> URI.encode_query(params)
-    options = %{ headers: headers(client, service), timeout: @timeout }
-    {method, uri, options}
-    |> Og.log_return(:debug)
-  end
-
-  def prepare_request(client, {method, uri, params} = query, service) when method in [:post, :put] do
-    uri =  WebStorageCache.get_swift_endpoint(client, service) <> uri
-    if params !== "" and params !== :nil and is_map(params), do: params = Poison.encode!(params)
-    options = %{ body: params, headers: headers(client, service), timeout: @timeout }
-    {method, uri, options}
-    |> Og.log_return(:debug)
-  end
-
-
-  ############################
-  # Private
-  ############################
-
-
-  defp headers(client, service) do
-    %{
-      "Content-Type": "application/json; charset=utf-8",
-      "X-Auth-Token": WebStorageCache.get_credentials_token(client, service)
-     }
-  end
-
-
-end
diff --git a/lib/ovh/openstack_api/webstorage/cache.ex b/lib/ovh/openstack_api/webstorage/cache.ex
deleted file mode 100644
index 049d93f..0000000
--- a/lib/ovh/openstack_api/webstorage/cache.ex
+++ /dev/null
@@ -1,303 +0,0 @@
-defmodule ExOvh.Ovh.OpenstackApi.Webstorage.Cache do
-  @moduledoc :false
-  use GenServer
-  alias ExOvh.Ovh.OpenstackApi.Webstorage.Supervisor, as: WebStorageSupervisor
-  import ExOvh.Query.Ovh.Webstorage, only: [get_webstorage_credentials: 1, get_webstorage_service: 1]
-  @get_credentials_retries 10
-  @get_credentials_sleep_interval 450
-
-
-  #####################
-  # Public
-  #####################
-
-
-  @doc "Starts the genserver"
-  def start_link({client, config, opts}, service) do
-    Og.context(__ENV__, :debug)
-    GenServer.start_link(__MODULE__, {client, service}, [name: gen_server_name(client, service)])
-  end
-
-
-  def get_credentials(service), do: get_credentials(ExOvh, service)
-  def get_credentials(client, service) do
-    unless supervisor_exists?(client, service), do: Supervisor.start_child(WebStorageSupervisor, [service])
-    get_credentials(client, service, 0)
-  end
-
-
-  def get_credentials_token(service), do: get_credentials_token(ExOvh, service)
-  def get_credentials_token(client, service), do: get_credentials(client, service).token
-
-
-  def get_swift_endpoint(service), do: get_swift_endpoint(ExOvh, service)
-  def get_swift_endpoint(client, service) do
-    credentials = get_credentials(client, service)
-    path = URI.parse(credentials.swift_endpoint) |> Map.get(:path)
-    {version, account} = String.split_at(path, 4)
-    endpoint = List.first(String.split(credentials.swift_endpoint, account))
-    endpoint
-  end
-
-
-  def get_account(service), do: get_account(ExOvh, service)
-  def get_account(client, service) do
-    credentials = get_credentials(client, service)
-    path = URI.parse(credentials.swift_endpoint) |> Map.get(:path)
-    {version, account} = String.split_at(path, 4)
-    account
-  end
-
-
-  #####################
-  # Genserver Callbacks
-  #####################
-
-
-  # trap exits so that terminate callback is invoked
-  # the :lock key is to allow for locking during the brief moment that the access token is being refreshed
-  def init({client, service}) do
-    Og.context(__ENV__, :debug)
-    :erlang.process_flag(:trap_exit, :true)
-    create_ets_table(client, service)
-    {:ok, credentials} = identity(service)
-    credentials = Map.put(credentials, :lock, :false)
-    :ets.insert(ets_tablename(client, service), {:credentials, credentials})
-    expires = to_seconds(credentials.token_expires_on)
-    Task.start_link(fn -> monitor_expiry(expires) end)
-    {:ok, {client, service, credentials}}
-  end
-
-  def handle_call(:add_lock, _from, {client, service, credentials}) do
-    Og.context(__ENV__, :debug)
-    new_credentials = Map.put(credentials, :lock, :true)
-    :ets.insert(ets_tablename(client, service), {:credentials, new_credentials})
-    {:reply, :ok, {client, service, new_credentials}}
-  end
-
-  def handle_call(:remove_lock, _from, {client, service, credentials}) do
-    Og.context(__ENV__, :debug)
-    new_credentials = Map.put(credentials, :lock, :false)
-    :ets.insert(ets_tablename(client, service), {:credentials, new_credentials})
-    {:reply, :ok, {client, service, new_credentials}}
-  end
-
-  def handle_call(:update_credentials, _from, {client, service, credentials}) do
-    Og.context(__ENV__, :debug)
-    {:ok, new_credentials} = identity(service)
-    |> Map.put(credentials, :lock, :false)
-    :ets.insert(ets_tablename(client, service), {:credentials, new_credentials})
-    {:reply, :ok, {client, service, new_credentials}}
-  end
-
-  def handle_call(:stop, _from, state) do
-    Og.context(__ENV__, :debug)
-    {:stop, :shutdown, :ok, state}
-  end
-
-  def terminate(:shutdown, {client, service, credentials}) do
-    Og.context(__ENV__, :debug)
-    :ets.delete(ets_tablename(client, service)) # explicilty remove
-    :ok
-  end
-
-
-
-  #####################
-  # Private
-  #####################
-
-  defp gen_server_name(client, service), do:  String.to_atom(Atom.to_string(client) <> service)
-  defp ets_tablename(client, service), do: String.to_atom(Atom.to_string(client) <> "-" <> service)
-
-
-  #@spec identity(service :: String.t, username :: String.t, password :: String.t)
-  #               :: {:ok, map()} | {:error, map()} ??
-  # This function probably should be broken down into smaller parts
-  def identity(service) do
-
-    {:ok, resp} = ExOvh.ovh_request(get_webstorage_service(service), %{})
-
-    %{
-      "server" => domain,
-      "storageLimit" => storage_limit
-    } = resp.body
-
-
-    {:ok, resp} = ExOvh.ovh_request(get_webstorage_credentials(service), %{})
-
-    %{
-      "endpoint" => endpoint,
-      "login" => login,
-      "password" => password,
-      "tenant" => tenant
-    } = resp.body
-
-    params = %{"auth" =>
-                        %{
-                        "passwordCredentials" => %{"username" => login, "password" => password}
-                        }
-              }
-    options = %{
-                body: params |> Poison.encode!,
-                headers: %{ "Content-Type": "application/json; charset=utf-8" },
-                timeout: 10_000
-               }
-    resp = HTTPotion.request(:post, endpoint <> "/tokens", options)
-
-    unless resp.status_code >= 200 and resp.status_code <= 203, do: raise resp.body
-
-    %{
-      "access" =>
-                  %{
-                    "token" => %{
-                                 "expires" => expires_on,
-                                 "id" => token,
-                                 "issued_at" => created_on
-                                },
-                  }
-      } = Poison.decode!(resp.body)
-
-    params = %{"auth" =>
-                        %{
-                        "tenantName" => tenant,
-                        "token" => %{"id" => token}}
-                        }
-    options = %{
-                body: params |> Poison.encode!,
-                headers: %{ "Content-Type": "application/json; charset=utf-8" },
-                timeout: 10_000
-               }
-    resp = HTTPotion.request(:post, endpoint <> "/tokens", options)
-
-    unless resp.status_code >= 200 and resp.status_code <= 203, do: raise resp.body
-
-    %{
-      "serviceCatalog" => [
-                          %{
-                            "endpoints" => [%{"publicURL" => swift_endpoint}],
-                            "name" => "swift",
-                          },
-                          %{
-                            "endpoints" => [%{"publicURL" => identity_endpoint}],
-                            "name" => "keystone",
-                          }
-                         ],
-                          "token" => %{
-                                          "expires" => token_expires_on,
-                                          "id" => token,
-                                          "issued_at" => token_created_on,
-                                        },
-                          "user" => _user
-      } = Poison.decode!(resp.body) |> Map.get("access")
-
-      {:ok,
-          %{
-            token: token,
-            token_expires_on: expires_on,
-            token_created_on: token_created_on,
-            swift_endpoint: swift_endpoint,
-            identity_endpoint: identity_endpoint,
-            service: service,
-            public_url: public_url(domain, swift_endpoint),
-            storage_limit: storage_limit
-          }
-      }
-
-  end
-
-  defp public_url(domain, swift_endpoint) do
-    path = URI.parse(swift_endpoint) |> Map.get(:path)
-    {version, account} = String.split_at(path, 4)
-    domain <> version <> account
-  end
-
-  defp get_credentials(client, service, index) do
-    Og.context(__ENV__, :debug)
-
-    retry = fn(client, service, index) ->
-      if index > @get_credentials_retries do
-        raise "Cannot retrieve openstack credentials from ets table, #{__ENV__.module}, #{__ENV__.line}"
-      else
-        :timer.sleep(@get_credentials_sleep_interval)
-        get_credentials(client, service, index + 1)
-      end
-    end
-
-    if ets_tablename(client, service) in :ets.all() do
-      table = :ets.lookup(ets_tablename(client, service), :credentials)
-      case table do
-        [credentials: credentials] ->
-          if credentials.lock === :true do
-            retry.(client, service, index)
-          else
-            credentials
-          end
-        [] -> retry.(client,service,index)
-      end
-    else
-      retry.(client, service, index)
-    end
-  end
-
-
-  defp monitor_expiry(expires) do
-    Og.context(__ENV__, :debug)
-    interval = (expires - 30) * 1000
-    :timer.sleep(interval)
-    {:reply, :ok, _credentials} = GenServer.call(self(), :add_lock)
-    {:reply, :ok, _credentials} = GenServer.call(self(), :update_credentials)
-    {:reply, :ok, credentials} = GenServer.call(self(), :remove_lock)
-    expires = to_seconds(credentials["expires"])
-    monitor_expiry(expires)
-  end
-
-
-  defp create_ets_table(client, service) do
-    Og.context(__ENV__, :debug)
-    ets_options = [
-                   :set, # type
-                   :protected, # read - all, write this process only.
-                   :named_table,
-                   {:heir, :none}, # don't let any process inherit the table. when the ets table dies, it dies.
-                   {:write_concurrency, :false},
-                   {:read_concurrency, :true}
-                  ]
-    unless ets_tablename(client, service) in :ets.all() do
-      :ets.new(ets_tablename(client, service), ets_options)
-    end
-  end
-
-
-  defp to_seconds(iso_time) do
-    {:ok, expiry_ndt, offset} = Calendar.NaiveDateTime.Parse.iso8601(iso_time)
-    offset =
-    case offset do
-      :nil -> 0
-      offset -> offset
-    end
-    {:ok, expiry_dt_utc} = Calendar.NaiveDateTime.with_offset_to_datetime_utc(expiry_ndt, offset)
-    {:ok, now} = Calendar.DateTime.from_erl(:calendar.universal_time(), "UTC")
-    {:ok, seconds, _microseconds, _when} = Calendar.DateTime.diff(expiry_dt_utc, now)
-    if seconds > 0 do
-      seconds
-    else
-      0
-    end
-  end
-
-
-  defp supervisor_exists?(client, service) do
-    case Process.whereis(registered_supervisor_name(client, service)) do
-      :nil -> :false
-      _pid -> :true
-    end
-  end
-
-
-  defp registered_supervisor_name(client, service) do
-    String.to_atom(Atom.to_string(client) <> service)
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/ovh/openstack_api/webstorage/request.ex b/lib/ovh/openstack_api/webstorage/request.ex
deleted file mode 100644
index 1b47734..0000000
--- a/lib/ovh/openstack_api/webstorage/request.ex
+++ /dev/null
@@ -1,40 +0,0 @@
-defmodule ExOvh.Ovh.OpenstackApi.Webstorage.Request do
-  @moduledoc :false
-  alias ExOvh.Ovh.OpenstackApi.Webstorage.Auth
-
-
-  @spec request(client :: atom, query :: ExOvh.Client.query_t, service :: String.t)
-               :: {:ok, ExOvh.Client.response_t} | {:error, ExOvh.Client.response_t}
-  def request(client, {method, uri, params} = query, %{ webstorage: service } = opts) do
-    Og.context(__ENV__, :debug)
-
-    {method, uri, options} = Auth.prepare_request(client, query, service)
-    resp = HTTPotion.request(method, uri, options)
-    |> Og.log_return(:debug)
-
-    if resp.status_code >= 100 and resp.status_code < 300 do
-      try do
-        {:ok, %{
-               body: resp.body |> Poison.decode!(),
-               headers: resp.headers,
-               status_code: resp.status_code
-              }
-        }
-      rescue
-        _ ->
-        {:ok, %{
-               body: resp.body,
-               headers: resp.headers,
-               status_code: resp.status_code
-              }
-        }
-      end
-    else
-      {:error, resp}
-    end
-
-  end
-
-
-end
-
diff --git a/lib/ovh/openstack_api/webstorage/supervisor.ex b/lib/ovh/openstack_api/webstorage/supervisor.ex
deleted file mode 100644
index 3a08675..0000000
--- a/lib/ovh/openstack_api/webstorage/supervisor.ex
+++ /dev/null
@@ -1,32 +0,0 @@
-defmodule ExOvh.Ovh.OpenstackApi.Webstorage.Supervisor do
-  @moduledoc :false
-  use Supervisor
-  alias ExOvh.Ovh.OpenstackApi.Webstorage.Cache
-
-  #####################
-  #  Public
-  #####################
-
-  @doc ~S"""
-  Starts the OVH Openstack dynamic supervisor.
-  """
-  def start_link({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    Supervisor.start_link(__MODULE__, {client, config, opts}, [name: __MODULE__])
-  end
-
-
-  #####################
-  #  Callbacks
-  #####################
-
-  def init({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    tree = [
-            {Cache, {Cache, :start_link, [{client, config, opts}]}, :transient, 10_000, :worker, []}
-           ]
-    supervise(tree, strategy: :simple_one_for_one)
-  end
-
-
-end
diff --git a/lib/ovh/ovh_api/auth.ex b/lib/ovh/ovh_api/auth.ex
deleted file mode 100644
index 7ffea99..0000000
--- a/lib/ovh/ovh_api/auth.ex
+++ /dev/null
@@ -1,81 +0,0 @@
-defmodule ExOvh.Ovh.OvhApi.Auth do
-  @moduledoc :false
-  alias ExOvh.Ovh.Defaults
-  alias ExOvh.Ovh.OvhApi.Cache
-
-  @default_headers %{ "Content-Type": "application/json; charset=utf-8" }
-  @methods [:get, :post, :put, :delete]
-  @timeout 10_000
-
-
-  ############################
-  # Public
-  ############################
-
-
-  @spec prepare_request(query :: ExOvh.Client.raw_query_t)
-                     :: ExOvh.Client.query_t
-  def prepare_request({method, uri, params} = query), do: prepare_request(ExOvh, query)
-
-  @spec prepare_request(client :: atom, query :: ExOvh.Client.raw_query_t)
-                     :: ExOvh.Client.query_t
-  def prepare_request(client, query)
-
-  def prepare_request(client, {method, uri, params} = query) when method in [:get, :head, :delete] do
-    uri = uri(config, uri)
-    config = config(client)
-    if params !== :nil and params !== "" and is_map(params), do: uri = uri <> "?" <> URI.encode_query(params)
-    if params !== :nil and params !== "" and is_map(params) === :false, do: uri = uri <> URI.encode_www_form(params)
-    consumer_key = get_consumer_key(config)
-    opts = [app_secret(config), app_key(config), consumer_key, Atom.to_string(method), uri, ""]
-    options = %{ headers: headers(opts, client), timeout: @timeout }
-    {method, uri, options}
-  end
-
-  def prepare_request(client, {method, uri, params} = query) when method in [:post, :put] do
-    uri = uri(config, uri)
-    config = config(client)
-    consumer_key = get_consumer_key(config)
-    if params !== "" and params !== :nil and is_map(params), do: params = Poison.encode!(params)
-    opts = [app_secret(config), app_key(config), consumer_key, Atom.to_string(method), uri, params]
-    #opts = [app_secret(config), consumer_key, Atom.to_string(method), uri, params]
-    options = %{ body: params, headers: headers(opts, client), timeout: @timeout }
-    {method, uri, options}
-  end
-
-
-  ############################
-  # Private
-  ############################
-
-
-  defp headers([app_secret, app_key, consumer_key, method, uri, body] = opts, client) do
-    time = :os.system_time(:seconds) + Cache.get_time_diff(client)
-    Map.merge(@default_headers,
-    %{
-    "X-Ovh-Application": app_key,
-    "X-Ovh-Consumer":    consumer_key,
-    "X-Ovh-Timestamp":   time,
-    "X-Ovh-Signature":   sign_request([app_secret, consumer_key, String.upcase(method), uri, body, time])
-    })
-  end
-
-
-  defp sign_request([app_secret, consumer_key, method, uri, body, time] = opts) do
-    pre_hash = Enum.join(opts, "+")
-    post_hash = :crypto.hash(:sha, pre_hash) |> Base.encode16(case: :lower)
-    "$1$" <> post_hash
-  end
-
-
-  defp config(), do: Cache.get_config(ExOvh)
-  defp config(client), do: Cache.get_config(client)
-  defp endpoint(config), do: Defaults.endpoints()[config[:endpoint]]
-  defp api_version(config), do: config[:api_version]
-  defp uri(config, uri), do: endpoint(config) <> api_version(config) <> uri
-  defp app_secret(config), do: config[:application_secret]
-  defp app_key(config), do: config[:application_key]
-  defp get_consumer_key(config), do: config[:consumer_key]
-
-
-end
diff --git a/lib/ovh/ovh_api/cache.ex b/lib/ovh/ovh_api/cache.ex
deleted file mode 100644
index 4d59de5..0000000
--- a/lib/ovh/ovh_api/cache.ex
+++ /dev/null
@@ -1,94 +0,0 @@
-defmodule ExOvh.Ovh.OvhApi.Cache do
-  @moduledoc :false
-  use GenServer
-  alias ExOvh.Ovh.Defaults
-
-  ############################
-  # Public
-  ###########################
-
-  @doc "Starts a genserver to keep state on the config and time diff"
-  def start_link({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    GenServer.start_link(__MODULE__, {client, config, opts}, [name: gen_server_name(client)])
-  end
-
-
-  @doc "Retrieves the ovh api time diff from the cache"
-  def get_time_diff(client) do
-    GenServer.call(gen_server_name(client), :get_diff)
-  end
-  @doc "Retrieves the ovh config map"
-  def get_config(client) do
-    GenServer.call(gen_server_name(client), :get_config)
-  end
-
-
-  ############################
-  # Genserver Callbacks
-  ###########################
-
-  def init({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    diff = calculate_diff(config)
-    {:ok, {config, diff}}
-  end
-
-  def handle_call(:get_diff, _from, {config, diff}) do
-    Og.context(__ENV__, :debug)
-    {:reply, diff, {config, diff}}
-  end
-
-  def handle_call(:get_config, _from, {config, diff}) do
-    Og.context(__ENV__, :debug)
-    {:reply, config, {config, diff}}
-  end
-
-  def handle_cast({:set_diff, new_diff}, {config, diff}) do
-    Og.context(__ENV__, :debug)
-    {:noreply, {config, new_diff}}
-  end
-
-  def terminate(:shutdown, state) do
-    Og.context(__ENV__, :warn)
-    Og.log_return("gen_server #{__MODULE__} shutting down", :warn)
-    :ok
-  end
-
-
-  ############################
-  # Private
-  ###########################
-
-
-  defp gen_server_name(client), do: String.to_atom(Atom.to_string(client) <> Atom.to_string(__MODULE__))
-  defp endpoint(config), do: Defaults.endpoints()[config[:endpoint]]
-  defp api_version(config), do: config[:api_version]
-
-
-  defp api_time_request(config) do
-    time_uri = endpoint(config) <> api_version(config) <> "/auth/time"
-    options = %{ headers: %{ "Content-Type": "application/json; charset=utf-8" }, timeout: 10_000 }
-    api_time = HTTPotion.request(:get, time_uri, options) |> Map.get(:body) |> Poison.decode!()
-  end
-
-
-  defp calculate_diff(config) do
-    api_time = api_time_request(config)
-    os_t = :os.system_time(:seconds)
-    os_t - api_time
-  end
-
-
-  #Caches the ovh api time diff
-  defp set_time_diff(client) do
-    config = get_config(client)
-    set_time_diff(client, config)
-  end
-  defp set_time_diff(client, config) when is_map(config) do
-    diff = calculate_diff(config)
-    GenServer.cast(gen_server_name(client), {:set_diff, diff})
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/ovh/ovh_api/request.ex b/lib/ovh/ovh_api/request.ex
deleted file mode 100644
index c39a513..0000000
--- a/lib/ovh/ovh_api/request.ex
+++ /dev/null
@@ -1,43 +0,0 @@
-defmodule ExOvh.Ovh.OvhApi.Request do
-  @moduledoc :false
-  alias ExOvh.Ovh.OvhApi.Auth
-  alias ExOvh.Ovh.OvhApi.Cache
-  alias ExOvh.Ovh.Defaults
-
-  ############################
-  # Public
-  ############################
-
-
-  @spec request(client :: atom, query :: ExOvh.Client.query_t, opts :: map)
-               :: {:ok, ExOvh.Client.response_t} | {:error, ExOvh.Client.response_t}
-  def request(client, {method, uri, params} = query, opts) do
-    Og.context(__ENV__, :debug)
-    config = config(client)
-
-    {method, uri, options} = Auth.prepare_request(client, query)
-    |> Og.log_return(:debug)
-
-    resp = HTTPotion.request(method, uri, options)
-    if resp.status_code >= 100 and resp.status_code < 300 do
-      {:ok, %{
-             body: resp.body |> Poison.decode!(),
-             headers: resp.headers,
-             status_code: resp.status_code
-            }
-      }
-    else
-     {:error, resp}
-    end
-  end
-
-
-  ############################
-  # Private
-  ############################
-
-  defp config(client), do: Cache.get_config(client)
-
-
-end
-
diff --git a/lib/ovh/request.ex b/lib/ovh/request.ex
deleted file mode 100644
index befb30a..0000000
--- a/lib/ovh/request.ex
+++ /dev/null
@@ -1,68 +0,0 @@
-defmodule ExOvh.Ovh.Request do
-  @moduledoc :false
-  @doc ~S"""
-  Houses the `request` function which delegates the function call to the appropriate
-  module & function depending on the `opts` key-values.
-
-  Ovh uses it's own custom api and also separate Openstack compliant apis so
-  and these apis are quite different.
-  Therefore, the request needs to be routed to the correct `request` function so
-  that the correct auth credentials are put into the `options_t` in the returned
-  `ExOvh.Client.query_t` query tuple.
-
-  ## Examples of what some delegation depending on opts
-
-      ExOvh.ovh_request(query, %{} = opts)
-      calls
-      ExOvh.Ovh.OvhApi.Request.request(ExOvh, query, opts)
-
-  -
-
-      ExOvh.ovh_request(query, %{ openstack: :true, webstorage: "service_name" } = opts)
-      calls
-      ExOvh.Ovh.OpenstackApi.Webstorage.Request.request(ExOvh, query, opts)
-
-
-  ## Subsequent Request modules
-
-  The subsequent request functions process the request by
-
-  1. Calling the appropriate `prepare_request` function which has been delegated to.
-  2. Making the actual request with `HTTPotion`
-  3. Returning the response as `{:ok, response_t}` or `{:error, response_t}`
-  """
-  alias ExOvh.Ovh.OvhApi.Request, as: Ovh
-  alias ExOvh.Ovh.OpenstackApi.Webstorage.Request, as: Webstorage
-
-
-  @doc ~S"""
-  Delegates the function call to the appropriate module & function depending on the `opts` key-values.
-
-  Subsequent request functions return `{:ok, response_t}` or `{:error, response_t}`
-
-  ## Options
-
-      { } = opts
-
-  The function call will be delegated to `ExOvh.Ovh.OvhApi.Request` and processed as a hubic api request.
-
-      { openstack: :true, webstorage: service } = opts
-
-  The function call will be delegated to `ExOvh.Ovh.OpenstackApi.Webstorage.Request`.
-
-  `openstack: :true` - boolean - indicates whether the request is an openstack one or not.
-
-  `webstorage: service` - String.t and is the name the cdn webstorage in your ovh stack which you which to use.
-  """
-  @spec request(client :: atom, query :: ExOvh.Client.raw_query_t, opts :: map)
-                :: {:ok, ExOvh.Client.response_t} | {:error, ExOvh.Client.response_t}
-  def request(client, {method, uri, params} = query, %{ openstack: :true, webstorage: service } = opts) do
-    Webstorage.request(client, query, opts)
-  end
-
-  def request(client, {method, uri, params} = query, opts) do
-    Ovh.request(client, query, opts)
-  end
-
-
-end
\ No newline at end of file
diff --git a/lib/ovh/supervisor.ex b/lib/ovh/supervisor.ex
deleted file mode 100644
index 06a2a4a..0000000
--- a/lib/ovh/supervisor.ex
+++ /dev/null
@@ -1,41 +0,0 @@
-defmodule ExOvh.Ovh.Supervisor do
-  @moduledoc :false
-  use Supervisor
-  alias ExOvh.Ovh.OvhApi.Cache
-  alias ExOvh.Ovh.OpenstackApi.Webstorage.Supervisor, as: Webstorage
-
-  #####################
-  #  Public
-  #####################
-
-  @doc ~S"""
-  Starts the OVH supervisor.
-  """
-  def start_link(client, config, opts) do
-    Og.context(__ENV__, :debug)
-    Supervisor.start_link(__MODULE__, {client, config, opts}, [name: supervisor_name(client)])
-  end
-
-
-  #####################
-  #  Callbacks
-  #####################
-
-  def init({client, config, opts}) do
-    Og.context(__ENV__, :debug)
-    tree = [
-            {Cache, {Cache, :start_link, [{client, config, opts}]}, :permanent, 10_000, :worker, [Cache]},
-            {Webstorage, {Webstorage, :start_link, [{client, config, opts}]}, :permanent, 10_000, :supervisor, [Webstorage]}
-           ]
-    supervise(tree, strategy: :one_for_one, max_restarts: 20)
-  end
-
-
-  #####################
-  #  Private
-  #####################
-
-  defp supervisor_name(client), do: String.to_atom(Atom.to_string(client) <> Atom.to_string(__MODULE__))
-
-
-end
diff --git a/lib/ovh/v1/webstorage/helpers.ex b/lib/ovh/v1/webstorage/helpers.ex
new file mode 100644
index 0000000..679eef8
--- /dev/null
+++ b/lib/ovh/v1/webstorage/helpers.ex
@@ -0,0 +1,16 @@
+defmodule ExOvh.Ovh.V1.Webstorage.Helpers do
+  @moduledoc :false
+  # alias ExOvh.Ovh.V1.Webstorage.Query
+  # alias Openstex.Response
+
+  defmacro __using__(opts) do
+    quote bind_quoted: [opts: opts] do
+      @client Keyword.fetch!(opts, :client)
+
+      # No helpers yet
+
+    end
+  end
+
+
+end
diff --git a/lib/ovh/v1/webstorage/query.ex b/lib/ovh/v1/webstorage/query.ex
new file mode 100644
index 0000000..d80cd75
--- /dev/null
+++ b/lib/ovh/v1/webstorage/query.ex
@@ -0,0 +1,127 @@
+defmodule ExOvh.Ovh.V1.Webstorage.Query do
+  @moduledoc ~s"""
+  Helper functions for building `queries directed at the `/cdn/webstorage` part of the custom ovh api.
+
+  ## Example
+
+      alias ExOvh.Ovh.V1.Webstorage.Query
+      query = Query.get_all_webstorage()
+      ExOvh.request(query)
+  """
+  alias ExOvh.Ovh.Query
+
+
+
+  @doc ~s"""
+  GET /v1/​cdn/webstorage​, Get a list of all webstorage cdn services available for the client account
+
+  ### Example usage
+
+      alias ExOvh.Ovh.V1.Webstorage.Query
+      query = Query.get_services()
+      ExOvh.request(query)
+  """
+  @spec get_services() :: Query.t
+  def get_services() do
+    %Query{
+          method: :get,
+          uri: "/cdn/webstorage",
+          params: :nil
+          }
+  end
+
+
+
+  @doc ~s"""
+  GET /v1/​cdn/webstorage​/{serviceName}, Get the domain, server and storage limits for a specific webstorage cdn service
+
+  ### Example usage
+
+      alias ExOvh.Ovh.V1.Webstorage.Query
+      service_name = "cdnwebstorage-????"
+      query = Query.get_service(service_name)
+      {:ok, resp} = ExOvh.request(query)
+      %{
+        "domain" => domain,
+        "storageLimit => storage_limit,
+        "server" => server
+       } = resp.body
+  """
+  @spec get_service(String.t) :: Query.t
+  def get_service(service_name) do
+   %Query{
+          method: :get,
+          uri: "/cdn/webstorage/",
+          params: service_name
+          }
+  end
+
+
+
+  @doc ~s"""
+  GET /v1/​cdn/webstorage​/{serviceName}/serviceInfos, Get a administrative details for a specific webstorage cdn service
+
+  ### Example usage
+
+      alias ExOvh.Ovh.V1.Webstorage.Query
+      service_name = "cdnwebstorage-????"
+      Query.get_service_info(service_name)
+      {:ok, resp} = ExOvh.request(query)
+  """
+  @spec get_service_info(String.t) :: Query.t
+  def get_service_info(service_name) do
+    %Query{
+      method: :get,
+      uri: "/cdn/webstorage/#{service_name}/serviceInfos",
+      params: :nil
+      }
+  end
+
+
+
+  @doc ~s"""
+  GET /v1/​cdn/webstorage​/{serviceName}/statistics, Get statistics for a specific webstorage cdn service
+
+    `period can be "month", "week" or "day"`
+    `type can be "backend", "quota" or "cdn"`
+
+  ### Example usage
+
+      alias ExOvh.Ovh.V1.Webstorage.Query
+      service_name = "cdnwebstorage-????"
+      query = Query.get_service_stats(service_name, [period: "month", type: "backend"])
+      {:ok, resp} = ExOvh.request(query)
+  """
+  @spec get_service_stats(String.t, Keyword.t) :: Query.t
+  def get_service_stats(service_name, opts \\ []) do
+    period = Keyword.get(opts, "period", "month")
+    type = Keyword.get(opts, "type", "cdn")
+    %Query{
+          method: :get,
+          uri: "/cdn/webstorage/#{service_name}/statistics",
+          params: %{"period" => period, "type" => type}
+          }
+  end
+
+
+
+  @doc ~s"""
+  GET /v1/​cdn/webstorage​/{serviceName}/credentials, Get credentials for using the swift compliant api
+
+  ### Example usage
+
+      alias ExOvh.Ovh.V1.Webstorage.Query
+      service_name = "cdnwebstorage-????"
+      query = Query.get_webstorage_credentials(service_name)
+      {:ok, resp} = ExOvh.request(query)
+  """
+  @spec get_credentials(String.t) :: ExOvh.Query.Ovh.t
+  def get_credentials(service_name) do
+    %Query{
+          method: :get,
+          uri: "/cdn/webstorage/#{service_name}/credentials",
+          params: :nil
+          }
+  end
+
+end
diff --git a/lib/query.ex b/lib/query.ex
new file mode 100644
index 0000000..7d69cdc
--- /dev/null
+++ b/lib/query.ex
@@ -0,0 +1,5 @@
+defmodule ExOvh.Ovh.Query do
+  @moduledoc false
+  defstruct [:method, :uri, :params,  service: :ovh]
+  @type t :: %__MODULE__{method: atom, uri: String.t, params: any, service: :ovh}
+end
\ No newline at end of file
diff --git a/lib/query/hubic/query.ex b/lib/query/hubic/query.ex
deleted file mode 100644
index 4ecb55f..0000000
--- a/lib/query/hubic/query.ex
+++ /dev/null
@@ -1,183 +0,0 @@
-defmodule ExOvh.Query.Hubic do
-  @moduledoc ~S"""
-  Helper functions for building queries for the hubic api.
-
-  The raw query can be passed into a client request.
-
-    ## Example
-
-      import ExOvh.Query.Hubic, only: [scope: 0]
-      scope = ExOvh.hubic_request(scope())
-  """
-
-
-  #########################
-  # General Hubic Requests
-  #########################
-
-
-  @doc ~S"""
-  GET /scope/scope, Get the possible scopes for hubiC API
-
-    ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      ExOvh.hubic_request(scope())
-  """
-  @spec scope() :: ExOvh.Client.raw_query_t
-  def scope(), do: {:get, "/scope/scope", :nil}
-
-
-  @doc ~S"""
-  GET /account, Get the account object properties
-
-    ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      ExOvh.hubic_request(account())
-  """
-  @spec account() :: ExOvh.Client.raw_query_t
-  def account(), do: {:get, "/account", :nil}
-
-
-  @doc ~S"""
-  GET /account/credentials, Returns openstack credentials for connecting to the file API
-
-      ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      ExOvh.hubic_request(openstack_credentials())
-  """
-  @spec openstack_credentials() :: ExOvh.Client.raw_query_t
-  def openstack_credentials(), do: {:get, "/account/credentials", :nil}
-
-
-  @doc ~S"""
-  GET /account/usage, Returns used space & quota of your account
-
-      ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      ExOvh.hubic_request(account_usage())
-  """
-  @spec account_usage() :: ExOvh.Client.raw_query_t
-  def account_usage(), do: {:get, "/account/usage", :nil}
-
-
-
-  ########################
-  # Link related Requests
-  ########################
-
-
-
-  @doc """
-  GET /account/links, Get all links as a list of links (showing the object internal uri - not the indirectUri)
-
-    ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      ExOvh.hubic_request(get_links())
-      ```
-  """
-  @spec get_links() :: ExOvh.Client.raw_query_t
-  def get_links(), do: {:get, "/account/links", :nil}
-
-
-  @doc """
-  GET /account/getAllLinks, Get all published objects' public urls with detailed info
-
-    ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      ExOvh.hubic_request(get_links_detailed())
-      ```
-  """
-  @spec get_links_detailed() :: ExOvh.Client.raw_query_t
-  def get_links_detailed(), do: {:get, "/account/getAllLinks", :nil}
-
-
-  @doc """
-  GET /account/links/{uri}, Get detailed information for an object at a given uri
-
-
-  ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      container = "new_container"
-      folder = "/"
-      object = "server_file.txt"
-      uri = folder <> object
-      ExOvh.hubic_request(get_link(uri))
-  """
-  @spec get_link(uri :: String.t) :: ExOvh.Client.raw_query_t
-  def get_link(uri), do: {:get, "/account/links/", uri}
-
-
-  @doc ~S"""
-  POST /account/links, Create a public url to a file
-
-  Note: links have a max ttl of 30 days on hubic currently.
-  ttl can be 1,5,10,15,20,25 or 30
-  See hubic ovh [docs](https://hubic.com/en/faq) under 'What is sharing?'.
-
-  ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      container = "new_container"
-      object = "server_file.txt"
-      {:ok, resp} = ExOvh.hubic_request(publish_object(container, object))
-      %{ "indirectUrl" => link_indirect_uri, "expirationDate" => exp,
-         "creationDate" => created_on, "uri" => uri } = resp.body
-      object_attrs = %{
-                      link: link_indirect_uri,
-                      expiry: exp,
-                      created: created_on,
-                      object: object,
-                      folder: String.replace(uri, object, ""),
-                      object_uri: uri
-                     }
-      ```
-  """
-  @spec publish_object(container :: String.t, object :: String.t, opts :: map)
-                             :: ExOvh.Client.raw_query_t
-  def publish_object(container, object, folder \\ "/", ttl \\ "5", file \\ "file") do
-    params = %{
-               "comment" => "none",
-               "container" => container,
-               "mode" => "ro",
-               "ttl" => ttl,
-               "type" => file,
-               "uri" => folder <> object
-              }
-    {:post, "/account/links", params}
-  end
-
-
-
-  @doc ~S"""
-  DELETE /account/links/{uri}, Deletes a public url to a file
-
-
-  ### Example:
-      ```elixir
-      import ExOvh.Query.Hubic
-      container = "new_container"
-      object = "server_file.txt"
-      folder = "/"
-      uri = folder <> object
-      ExOvh.hubic_request(delete_link(uri))
-  """
-  @spec delete_link(uri :: String.t) :: ExOvh.Client.raw_query_t
-  def delete_link(uri), do: {:delete, "/account/links/", uri}
-
-
-
-  ########################################
-  # Folder related requests
-  ########################################
-
-
-
-
-end
\ No newline at end of file
diff --git a/lib/query/openstack/swift/query.ex b/lib/query/openstack/swift/query.ex
deleted file mode 100644
index db0892d..0000000
--- a/lib/query/openstack/swift/query.ex
+++ /dev/null
@@ -1,199 +0,0 @@
-defmodule ExOvh.Query.Openstack.Swift do
-  @moduledoc ~S"""
-  Helper functions for to building queries for the openstack compatible swift apis.
-
-  The raw query can be passed into a client request.
-
-    ## Example
-
-      import ExOvh.Query.Openstack.Swift, only: [scope: 0]
-      account = ExOvh.Hubic.OpenstackApi.Cache.get_account()
-      client = ExOvh
-      scope = ExOvh.hubic_request(account_info(client), %{ openstack: : true })
-  """
-  alias ExOvh.Hubic.OpenstackApi.Cache, as: HubicOpenstackCache
-
-
-  #############################
-  # CONTAINER RELATED REQUESTS
-  #############################
-
-
-  @doc ~S"""
-  GET /v1/​{account}​, Get account details and containers for given account
-
-  ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      account = OpenCache.get_account(client)
-      ExOvh.hubic_request(account_info(account), %{ openstack: :true })
-      ```
-  """
-  @spec account_info(account :: String.t) :: [map]
-  def account_info(account), do: {:get, account, %{ "format" => "json" }}
-
-
-  @doc ~S"""
-  PUT /v1/​{account}/{container}​, Create a new container
-
-  ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      account = OpenCache.get_account(client)
-      ExOvh.hubic_request(create_container(account, "new_container"), %{ openstack: :true })
-      ```
-  """
-  @spec create_container(account :: String.t, container :: String.t)
-                         :: ExOvh.Client.raw_query_t
-  def create_container(account, container), do: {:put, account <> "/" <> container, %{ "format" => "json" }}
-
-
-  @doc ~S"""
-  DELETE /v1/​{account}/{container}​, Delete a container
-
-  ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      account = OpenCache.get_account(client)
-      ExOvh.hubic_request(delete_container(account, "new_container"), %{ openstack: :true })
-      ```
-  """
-  @spec delete_container(account :: String.t, container :: String.t)
-                         :: ExOvh.Client.raw_query_t
-  def delete_container(account, container), do: {:delete, account <> "/" <> container, %{ "format" => "json" }}
-
-
-  @doc ~S"""
-  DELETE /v1/​{account}/{container}​, Delete a container
-
-  ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      account = OpenCache.get_account(client)
-      ExOvh.hubic_request(container_info(account, "new_container"), %{ openstack: :true })
-      ```
-  """
-  @spec container_info(account :: String.t, container :: String.t)
-                         :: ExOvh.Client.raw_query_t
-  def container_info(account, container), do: {:head, account <> "/" <> container, %{ "format" => "json" }}
-
-
-  ##########################
-  # OBJECT RELATED REQUESTS
-  ##########################
-
-
-  @doc ~S"""
-  GET /v1/​{account}​/{container}, List objects in a container
-
-  ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      account = OpenCache.get_account(client)
-      ExOvh.hubic_request(get_objects(account, "default"), %{ openstack: :true })
-      ```
-  """
-  @spec get_objects(account :: String.t, container :: String.t)
-                    :: ExOvh.Client.raw_query_t
-  def get_objects(account, container), do: {:get, account <> "/" <> container, %{ "format" => "json" }}
-
-
-
-  @doc ~S"""
-  GET /v1/​{account}​/{container}/{object}, Get/Download a specific object (file)
-
-  ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      file = "server_file.txt"
-      container = "new_container"
-      account = OpenCache.get_account(client)
-      ExOvh.hubic_request(get_object(account, container, file), %{ openstack: :true })
-      ```
-  """
-  @spec get_object(account :: String.t, container :: String.t, object :: String.t)
-                   :: ExOvh.Client.raw_query_t
-  def get_object(account, container, object), do: {:get, account <> "/" <> container <> "/" <> object, :nil}
-
-
-  @doc """
-  PUT /v1/​{account}​/{container}/{object}, Create or replace an object (file)
-
-    ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      account = OpenCache.get_account(client)
-      object_name = "client_file.txt"
-      client_object = Kernel.to_string(:code.priv_dir(:ex_ovh)) <> "/" <> object_name
-      container = "new_container"
-      server_object = String.replace(object_name, "client", "server")
-      ExOvh.hubic_request(create_object(account, container, client_object, server_object), %{ openstack: :true })
-      ```
-  """
-  @spec create_object(account :: String.t, container :: String.t, client_object :: String.t, server_object :: String.t)
-                      :: ExOvh.Client.raw_query_t
-  def create_object(account, container, client_object, server_object) do
-    case File.read(client_object) do
-      {:ok, binary_object} ->
-        path = account <> "/" <> container <> "/" <> server_object
-        {:put, path, binary_object}
-      {:error, posix_error} ->
-        Og.context(__ENV__, :error)
-        Og.log_return(posix_error, :error)
-        raise posix_error
-    end
-  end
-
-
-  @doc """
-  DELETE /v1/​{account}​/{container}/{object}, Delete an Object (Delete a file)
-
-    ### Example usage
-
-      ```elixir
-      import ExOvh.Query.Openstack.Swift
-      alias ExOvh.Hubic.OpenstackApi.Cache, as: OpenCache
-      client = ExOvh
-      account = OpenCache.get_account(client)
-      container = "new_container"
-      server_object = "server_file.txt"
-      ExOvh.hubic_request(delete_object(account, container, server_object), %{ openstack: :true })
-  """
-  @spec delete_object(account :: String.t, container :: String.t, server_object :: String.t)
-                      :: ExOvh.Client.raw_query_t
-  def delete_object(account, container, server_object) do
-    {:delete, account <> "/" <> container <> "/" <> server_object, :nil}
-  end
-
-
-
-end
-
-
-
-
-
-
-
-
diff --git a/lib/query/ovh/webstorage/query.ex b/lib/query/ovh/webstorage/query.ex
deleted file mode 100644
index 9b5a793..0000000
--- a/lib/query/ovh/webstorage/query.ex
+++ /dev/null
@@ -1,109 +0,0 @@
-defmodule ExOvh.Query.Ovh.Webstorage do
-  @moduledoc ~S"""
-  Helper functions for to building queries to the `/cdn/webstorage` part of the custom ovh api.
-
-  The raw query can be passed into a client request.
-
-    ## Example
-
-      import ExOvh.Query.Ovh.Webstorage
-      query = get_all_webstorage()
-      ExOvh.ovh_request(query, %{})
-  """
-  alias ExOvh.Ovh.OvhApi.Cache, as: OvhApiCache
-
-
-
-  @doc ~S"""
-  GET /v1/​cdn/webstorage​, Get a list of all webstorage cdn services available for the client account
-
-  ### Example usage
-
-      import ExOvh.Query.Ovh.Webstorage
-      ExOvh.ovh_request(get_all_webstorage(), %{})
-  """
-  @spec get_all_webstorage() :: ExOvh.Client.raw_query_t
-  def get_all_webstorage(), do: {:get, "/cdn/webstorage", :nil}
-
-
-
-  @doc ~S"""
-  GET /v1/​cdn/webstorage​/{serviceName}, Get the domain, server and storage limits for a specific webstorage cdn service
-
-  ### Example usage
-
-      import ExOvh.Query.Ovh.Webstorage
-      service_name = "cdnwebstorage-????"
-      {:ok, resp} = ExOvh.ovh_request(get_webstorage_service(service_name), %{})
-      %{
-        "domain" => domain,
-        "storageLimit => storage_limit,
-        "server" => server
-       } = resp.body
-  """
-  @spec get_webstorage_service(service_name :: String.t)
-                               :: ExOvh.Client.raw_query_t
-  def get_webstorage_service(service_name), do: {:get, "/cdn/webstorage/", service_name}
-
-
-
-  @doc ~S"""
-  GET /v1/​cdn/webstorage​/{serviceName}/serviceInfos, Get a administrative details for a specific webstorage cdn service
-
-  ### Example usage
-
-      import ExOvh.Query.Ovh.Webstorage
-      service_name = "cdnwebstorage-????"
-      {:ok, resp} = ExOvh.ovh_request(get_webstorage_service_info(service_name), %{})
-  """
-  @spec get_webstorage_service_info(service_name :: String.t)
-                               :: ExOvh.Client.raw_query_t
-  def get_webstorage_service_info(service_name), do: {:get, "/cdn/webstorage/#{service_name}/serviceInfos", :nil}
-
-
-
-  @doc ~S"""
-  GET /v1/​cdn/webstorage​/{serviceName}/statistics, Get statistics for a specific webstorage cdn service
-
-    `period can be "month", "week" or "day"`
-    `type can be "backend", "quota" or "cdn"`
-
-  ### Example usage
-
-      import ExOvh.Query.Ovh.Webstorage
-      # service_name = "cdnwebstorage-????"
-      {:ok, resp} = ExOvh.ovh_request(get_webstorage_service_stats(service_name, "month", "backend"), %{})
-  """
-  @spec get_webstorage_service_stats(service_name :: String.t, period :: String.t, type :: String.t)
-                               :: ExOvh.Client.raw_query_t
-  def get_webstorage_service_stats(service_name, period \\ "month", type \\ "cdn") do
-    {:get, "/cdn/webstorage/#{service_name}/statistics", %{"period" => period, "type" => type} }
-  end
-
-
-
-  @doc ~S"""
-  GET /v1/​cdn/webstorage​/{serviceName}/credentials, Get credentials for using the swift compliant api
-
-  ### Example usage
-
-      import ExOvh.Query.Ovh.Webstorage
-      # service = "cdnwebstorage-????"
-      {:ok, resp} = ExOvh.ovh_request(get_webstorage_credentials(service), %{})
-  """
-  @spec get_webstorage_credentials(service_name :: String.t)
-                               :: ExOvh.Client.raw_query_t
-  def get_webstorage_credentials(service_name), do: {:get, "/cdn/webstorage/#{service_name}/credentials", :nil}
-
-
-
-
-end
-
-
-
-
-
-
-
-
diff --git a/lib/request/ovh/request.ex b/lib/request/ovh/request.ex
new file mode 100644
index 0000000..f7aa6a2
--- /dev/null
+++ b/lib/request/ovh/request.ex
@@ -0,0 +1,52 @@
+defimpl Openstex.Request, for: ExOvh.Ovh.Query do
+  @moduledoc :false
+
+  alias Openstex.{Auth, Response}
+  alias ExOvh.Ovh.Query
+
+
+  # Public
+
+
+  @spec request(Query.t, Keyword.t, atom) :: {:ok, Response.t} | {:error, Response.t}
+  def request(query, opts, client) do
+    Og.context(__ENV__, :debug)
+
+    q = Auth.prepare_request(query, opts, client) |> Map.from_struct()
+
+    options = set_opts(q.options, opts)
+    case HTTPoison.request(q.method, q.uri, q.body, q.headers, options) do
+      {:ok, resp} ->
+        body = parse_body(resp)
+        resp = %Response{ body: body, headers: resp.headers |> Enum.into(%{}), status_code: resp.status_code }
+        if resp.status_code >= 100 and resp.status_code < 300 do
+          {:ok, resp}
+        else
+          {:error, resp}
+        end
+      {:error, resp} ->
+        {:error, %HTTPoison.Error{reason: resp.reason}}
+    end
+
+  end
+
+
+  # private
+
+
+  def parse_body(resp) do
+    try do
+       resp.body |> Poison.decode!()
+    rescue
+      _ ->
+        resp.body
+    end
+  end
+
+
+  defp set_opts(query_opts, opts), do: Keyword.merge(query_opts, opts)
+
+
+end
+
+
diff --git a/lib/supervisor.ex b/lib/supervisor.ex
index c933947..8dbada8 100644
--- a/lib/supervisor.ex
+++ b/lib/supervisor.ex
@@ -1,96 +1,51 @@
 defmodule ExOvh.Supervisor do
   @moduledoc :false
-  @doc ~S"""
-  Supervisor for the Hubic and Ovh api configuration.
-  """
+
   use Supervisor
-  alias ExOvh.Ovh.Cache
-  alias ExOvh.Ovh.Defaults, as: OvhDefaults
-  alias ExOvh.Hubic.Defaults, as: HubicDefaults
-  alias ExOvh.Ovh.Supervisor, as: OvhSupervisor
-  alias ExOvh.Hubic.Supervisor, as: HubicSupervisor
-  require Logger
+  alias ExOvh.Defaults
+  alias ExOvh.Auth.Supervisor, as: AuthSupervisor
 
 
-  #####################
   #  Public
-  #####################
-
-  @doc ~S"""
-  Starts the OVH and Hubic supervisors.
 
-  If the hubic_config is set to :nil, it will simply ignore hubic and start ovh only.
-  If the ovh_config is set to :nil, it will simply ignore ovh and start hubic only.
 
-  If the both ovh_config and hubic_config are set to :nil, then an error will be raised
-  which will crash the supervisor.
-  """
   def start_link(client, config, opts) do
     Og.context(__ENV__, :debug)
     Supervisor.start_link(__MODULE__, {client, config, opts}, [name: client])
   end
 
-  #####################
+
   #  Callbacks
-  #####################
+
 
   def init({client, config, opts}) do
     Og.context(__ENV__, :debug)
     sup_tree =
     case ovh_config(config, client) do
       {:error, :config_not_found} ->
-        Logger.warn(IO. inspect("No ovh config found. OVH supervisor will not be started for client #{client}"))
+        Og.log("No ovh config found. Ovh supervisor will not be started for client #{client}", :error)
         []
       valid_config ->
-        [{OvhSupervisor,
-         {OvhSupervisor, :start_link, [client, valid_config, opts]}, :permanent, 10_000, :supervisor, [OvhSupervisor]}]
-    end
-    sup_tree =
-    case hubic_config(config, client) do
-      {:error, :config_not_found} ->
-        Og.log_return("No hubic config found. Hubic supervisor will not be started for client #{client}", :warn)
-        sup_tree
-      valid_config -> sup_tree ++
-        [{HubicSupervisor,
-         {HubicSupervisor, :start_link, [client, valid_config, opts]}, :permanent, 10_000, :supervisor, [HubicSupervisor]}]
+        [{AuthSupervisor,
+         {AuthSupervisor, :start_link, [client, valid_config, opts]}, :permanent, 10_000, :supervisor, [AuthSupervisor]}]
     end
     if sup_tree === [] do
-        raise "No configuration found for hubic or ovh."
+        raise "No configuration found for ovh."
     end
     supervise(sup_tree, strategy: :one_for_one, max_restarts: 20)
   end
 
 
-
   @doc """
   Gets the ovh config settings.
-
-  Returns the config_map if the ovh_config is not :nil.
-  or
-  Returns {:error, :config_not_found} if the ovh_config is set to :nil.
   """
   @spec ovh_config(config :: map, client :: atom) :: map | {:error, atom}
   def ovh_config(config, client) do
-    case config[:ovh] do
+    case config do
       :nil -> {:error, :config_not_found}
-      _ -> Map.merge(OvhDefaults.ovh(), client.config()[:ovh])
+      _ -> Map.merge(Defaults.ovh(), client.config())
     end
   end
 
 
-  @doc """
-  Gets the hubic config settings.
-
-  Returns the config_map if the hubic_config is not :nil.
-  or
-  Returns {:error, :config_not_found} if the hubic_config is set to :nil.
-  """
-  @spec hubic_config(config :: map, client :: atom) :: map | :nil
-  def hubic_config(config, client) do
-    case config[:hubic] do
-      :nil -> {:error, :config_not_found}
-      _ -> Map.merge(HubicDefaults.hubic(), client.config()[:hubic])
-    end
-  end
-
 end
diff --git a/lib/utils/utils.ex b/lib/utils/utils.ex
new file mode 100644
index 0000000..bed4f44
--- /dev/null
+++ b/lib/utils/utils.ex
@@ -0,0 +1,114 @@
+defmodule ExOvh.Utils do
+  @moduledoc false
+
+  alias ExOvh.Auth.Ovh.Cache
+  alias ExOvh.Defaults
+
+
+  @doc """
+  For naming a supervisor to incorporate the name of the client.
+
+  The client name is required so that when a client makes a request, the correct supervisor
+  is called if there are multiple clients in use.
+  """
+  defmacro supervisor_name(client) do
+    caller = __CALLER__.module
+    quote do
+      (
+        (
+         Atom.to_string(unquote(client))
+         <>
+         "."
+         )
+         <>
+         Atom.to_string(unquote(caller))
+       )
+       |> String.replace("Elixir.", "")
+       |> String.to_atom()
+     end
+  end
+
+
+  @doc """
+  For naming a genserver to incorporate the name of the client.
+
+  The client name is required so that when a client makes a request, the correct genserver
+  is called if there are multiple clients in use.
+  """
+  defmacro gen_server_name(client) do
+    caller = __CALLER__.module
+    quote do
+      (
+        (
+         Atom.to_string(unquote(client))
+         <>
+         "."
+         )
+         <>
+         Atom.to_string(unquote(caller))
+      )
+      |> String.replace("Elixir.", "")
+      |> String.to_atom()
+    end
+  end
+
+
+  @doc """
+  For naming an ets table to incorporate the name of the client.
+
+  The client name is required so that when a client makes a request, the correct ets table
+  is looked up if there are multiple clients in use.
+  """
+  defmacro ets_tablename(client) do
+    # caller = __CALLER__.module
+    quote do
+      "Ets."
+      <>
+      (
+        gen_server_name(unquote(client))
+        |> Atom.to_string()
+      )
+      |> String.to_atom()
+    end
+  end
+
+  @doc """
+  Changes the timeout option for a http_query.
+  """
+  @spec change_http_query_timeout(Openstex.HttpQuery.t, integer) :: Openstex.HttpQuery.t
+  def change_http_query_timeout(%Openstex.HttpQuery{options: options} = http_query, new_timeout) do
+    new_options = Map.merge(options, Map.put(options, :timeout, new_timeout))
+    Map.put(http_query, :options, new_options)
+  end
+
+
+  @doc """
+  Returns a string with the formatted date
+  """
+  @spec formatted_date() :: String.t
+  def formatted_date() do
+    {year, month, date} = :erlang.date()
+    Integer.to_string(date) <> "." <>
+    Integer.to_string(month) <> "." <>
+    Integer.to_string(year)
+  end
+
+
+  def config(client), do: Cache.get_config(client)
+  def endpoints(), do: Defaults.endpoints()
+  def endpoint(config), do: Defaults.endpoints()[config[:endpoint]]
+  def api_version(config), do: config[:api_version]
+  def uri(uri, config), do: endpoint(config) <> api_version(config) <> uri
+  def app_secret(config), do: config[:application_secret]
+  def app_key(config), do: config[:application_key]
+  def get_consumer_key(config), do: config[:consumer_key]
+  def connect_timeout(config), do: config[:connect_timeout]
+  def receive_timeout(config), do: config[:receive_timeout]
+  def set_opts(opts, config), do: Keyword.merge([ timeout: connect_timeout(config), recv_timeout: receive_timeout(config) ], opts)
+  def access_rules(), do: Defaults.access_rules()
+  def access_rules(config), do: config[:access_rules]
+  def default_create_app_uri(config), do: endpoint(config) <> "createApp/"
+  def consumer_key_uri(config), do: endpoint(config) <> api_version(config) <> "/auth/credential/"
+
+
+end
diff --git a/mix.exs b/mix.exs
index 58d9a63..ca70f13 100644
--- a/mix.exs
+++ b/mix.exs
@@ -19,18 +19,19 @@ defmodule ExOvh.Mixfile do
   def application() do
     [
       mod: [],
-      applications: [:calendar, :crypto, :httpotion, :logger]
+      applications: [:calendar, :crypto, :logger, :openstex]
     ]
   end
 
   defp deps() do
     [
-      {:httpotion, "<= 2.2.0"},
-      {:poison, "~> 1.0"},
       {:secure_random, "~> 0.2"},
       {:floki, "~> 0.7.1"},
       {:calendar, "~> 0.13.2"},
-      {:og, "~> 0.0", only: :dev},
+      {:og, "~> 0.1"},
+      # {:openstex, github: "stephenmoloney/openstex", branch: "master"}, # incorporates :poison and httpoison
+      {:openstex, path: "../openstex"},
+
       {:earmark, "~> 0.2.1", only: :dev},
       {:ex_doc,  "~> 0.11", only: :dev}
     ]
@@ -38,7 +39,7 @@ defmodule ExOvh.Mixfile do
 
   defp description() do
     ~s"""
-    An elixir client library for easier use of the Hubic api and Ovh api.
+    An elixir client library for easier use of the Ovh api.
     """
   end