Wrapped more of Namespaces and Deployments

Author: Fletcher Haynes

config/config.exs

@@ -2,7 +2,10 @@
 # and its dependencies with the aid of the Mix.Config module.
 use Mix.Config
 
-config :exkube, insecure_ca: :secure
+config :exkube, insecure_ca: :insecure,
+  kube_user: "admin",
+  kube_password: System.get_env("EXKUBE_PASSWORD"),
+  api_url: System.get_env("EXKUBE_API")
 # This configuration is loaded before any dependency and is restricted
 # to this project. If another project depends on this project, this
 # file won't be loaded nor affect the parent project. For this reason,

lib/deployments.ex

@@ -0,0 +1,77 @@
+defmodule Exkube.Deployments do
+  @moduledoc """
+  This module contains functions for working with Deployments
+  """
+
+  require Logger
+  alias Exkube.Base
+
+  @doc """
+  This gets all of the Deployments
+  """
+  def all do
+    {:ok, %HTTPoison.Response{status_code: status_code, body: body}} = Base.get("apis/apps/v1beta1/deployments")
+    processed = Base.process_response_status_code(body, status_code)
+
+    # We need to process the result a bit to extract only the Namespace names
+    case processed do
+      {:ok, data} ->
+        deployments = Enum.reduce(data["items"], [],
+          fn(n), acc ->
+            [%{name: n["metadata"]["name"], namespace: n["metadata"]["namespace"]} | acc]
+          end
+        )
+        Logger.debug(inspect(deployments))
+        {:ok, deployments}
+      _ ->
+        {:error, status_code}
+    end
+  end
+
+  @doc """
+  Lists all the Deployments in a specific Namespace
+  """
+  def all(namespace) do
+    {:ok, %HTTPoison.Response{status_code: status_code, body: body}} = Base.get("apis/apps/v1beta1/namespaces/" <> namespace <> "/deployments")
+    processed = Base.process_response_status_code(body, status_code)
+
+    # We need to process the result a bit to extract only the Namespace names
+    case processed do
+      {:ok, data} ->
+        deployments = Enum.reduce(data["items"], [],
+          fn(n), acc ->
+            [%{name: n["metadata"]["name"], namespace: n["metadata"]["namespace"]} | acc]
+          end
+        )
+        Logger.debug(inspect(deployments))
+        {:ok, deployments}
+      _ ->
+        {:error, status_code}
+    end
+  end
+
+  @doc """
+  Gets the details of one Deployment. Defaults to the default Namespace if one is
+  not specified.
+  """
+  def one(namespace \\ "default") do
+    {:ok, %HTTPoison.Response{status_code: status_code, body: body}} =
+      Base.get("apis/apps/v1beta1/namespaces/" <> namespace <> "/deployments/" <> namespace)
+      
+    processed = Base.process_response_status_code(body, status_code)
+
+    # We need to process the result a bit to extract only the Namespace names
+    case processed do
+      {:ok, data} ->
+        deployments = Enum.reduce(data["items"], [],
+          fn(n), acc ->
+            [%{name: n["metadata"]["name"], namespace: n["metadata"]["namespace"]} | acc]
+          end
+        )
+        Logger.debug(inspect(deployments))
+        {:ok, deployments}
+      _ ->
+        {:error, status_code}
+    end
+  end
+end

lib/exkube.ex

@@ -7,14 +7,19 @@ defmodule Exkube.Base do
   use HTTPoison.Base
   require Logger
 
+  @kube_user Application.get_env(:exkube, :kube_user)
+  @kube_password Application.get_env(:exkube, :kube_password)
+  @insecure_ca Application.get_env(:exkube, :insecure_ca)
+  @endpoint Application.get_env(:exkube, :api_url)
+
   @doc """
   Checks the health endpoint of Kubernetes cluster
 
   Returns `{:ok, "ok"}` if healthy or `{:error, %{status_code, body}}` if not
   """
   def status(api_url) do
     url = api_url <> "/healthz"
-    result = HTTPoison.request!(:get, url, "", [], hackney: [Application.get_env(:exkube, :insecure_ca)])
+    result = HTTPoison.request!(:get, url, "", [], hackney: [@insecure_ca])
     %HTTPoison.Response{status_code: status_code, body: body} = result
 
     case status_code do
@@ -24,4 +29,47 @@ defmodule Exkube.Base do
         {:error, %{status_code: status_code, body: body}}
     end
   end
+
+  @doc """
+  Processes the status code out of a response and returns a tuple
+  """
+  def process_response_status_code(body, status_code) do
+    case status_code do
+      403 ->
+        {:error, :forbidden}
+      404 ->
+        {:error, :not_found}
+      200 ->
+        data = JSON.decode!(body)
+        {:ok, data}
+      201 ->
+        data = JSON.decode!(body)
+        {:ok, data}
+      _ ->
+        data = JSON.decode!(body)
+        {:error, status_code: status_code, body: data}
+      end
+  end
+
+  @doc """
+  Builds up a URL
+  """
+  def process_url(url) do
+    @endpoint <> url
+  end
+
+  @doc """
+  Adds in the necessary auth headers if they exist
+  """
+  def process_request_options(options) do
+    options ++ [hackney: [@insecure_ca, basic_auth: {@kube_user, @kube_password}]]
+  end
+
+  @doc """
+  Adds in the necessary headers
+  """
+  def process_request_headers(headers) do
+    headers ++ [{"Content-Type", "application/json"}]
+  end
+  
 end

lib/namespaces.ex

@@ -0,0 +1,67 @@
+defmodule Exkube.Namespaces do
+  @moduledoc """
+  This module contains functions for working with Namespaces
+  """
+
+  use HTTPoison.Base
+
+  require Logger
+  alias Exkube.Base
+
+  @doc """
+  This gets all of the Namespaces
+  """
+  def all do
+    {:ok, %HTTPoison.Response{status_code: status_code, body: body}} = Base.get("api/v1/namespaces")
+    processed = Base.process_response_status_code(body, status_code)
+
+    # We need to process the result a bit to extract only the Namespace names
+    case processed do
+      {:ok, data} ->
+        namespaces = Enum.reduce(data["items"], [],
+          fn(n), acc ->
+            [n["metadata"]["name"] | acc]
+          end
+        )
+        {:ok, namespaces}
+      _ ->
+        {:error, status_code}
+    end
+  end
+
+  @doc """
+  This retrieves the details for one Namespace if it exists
+  """
+  def one(%{namespace: namespace}) do
+    {:ok, %HTTPoison.Response{status_code: status_code, body: body}} = Base.get("api/v1/namespaces/" <> namespace)
+    Base.process_response_status_code(body, status_code)
+  end
+
+  @doc """
+  This creates a new Namespace if it doesn't exist
+  """
+  def create(%{namespace: namespace}) do
+    body = Poison.encode!(%{
+      kind: "Namespace",
+      apiVersion: "v1",
+      metadata: %{
+        name: namespace,
+        labels: %{
+          name: namespace
+        }
+      }
+    })
+
+    {:ok, %HTTPoison.Response{status_code: status_code, body: body}} = Base.post("api/v1/namespaces", body)
+    Base.process_response_status_code(body, status_code)
+  end
+
+  @doc """
+  This creates a new Namespace if it doesn't exist
+  """
+  def delete(%{namespace: namespace}) do
+    {:ok, %HTTPoison.Response{status_code: status_code, body: body}} = Base.delete("api/v1/namespaces/" <> namespace)
+    Base.process_response_status_code(body, status_code)
+  end
+
+end

lib/persistent_volume_claims.ex

@@ -0,0 +1,19 @@
+defmodule Exkube.PersistentVolumeClaims do
+  @moduledoc """
+  This contains functions for working with Persistent Volumes Claims
+  """
+  
+  @doc """
+  This gets all of the Persistent Volume Claims from all Namespaces
+  """
+  def all do
+
+  end
+
+  @doc """
+  This gets all of the Persistent Volume Claims from a Namespace
+  """
+  def all(%{"namespace" => namespace}) do
+
+  end
+end

lib/persistent_volumes.ex

@@ -0,0 +1,19 @@
+defmodule Exkube.PersistentVolumes do
+  @moduledoc """
+  This contains functions for working with Persistent Volumes
+  """
+
+  @doc """
+  This gets all of the Persistent Volumes from all Namespaces
+  """
+  def all do
+
+  end
+
+  @doc """
+  This gets all of the Persistent Volumes from a Namespace
+  """
+  def all(%{"namespace" => namespace}) do
+
+  end
+end

lib/pods.ex

@@ -0,0 +1,19 @@
+defmodule Exkube.Pods do
+  @moduledoc """
+  This module contains functions for working with Kubernetes Pods
+  """
+
+  @doc """
+  Gets all of the Pods from all Namespaces
+  """
+  def all do
+
+  end
+
+  @doc """
+  Gets all of the Pods from a specific Namespace
+  """
+  def all(%{"namespace" => namespace}) do
+
+  end
+end

test/deployments_test.exs

@@ -0,0 +1,27 @@
+defmodule Exkube.DeploymentsTest do
+  @moduledoc """
+  Tests for the Namespaces module
+  """
+  use ExUnit.Case, async: true
+  alias Exkube.Deployments
+  require Logger
+
+  test "can list deployments", %{} do
+    result = Deployments.all
+    assert elem(result, 0) == :ok
+  end
+  #
+  # test "can get one namespace", %{} do
+  #   result = Namespaces.one(%{namespace: "uops"})
+  #   assert elem(result, 0) == :ok
+  # end
+  #
+  # test "can create and delete new namespace", %{} do
+  #   name = "test-" <> Integer.to_string(:rand.uniform(1000))
+  #   result = Namespaces.create(%{namespace: name})
+  #   assert elem(result, 0) == :ok
+  #   result = Namespaces.delete(%{namespace: name})
+  #   assert elem(result, 0) == :ok
+  # end
+
+end

test/namespaces_test.exs

@@ -0,0 +1,27 @@
+defmodule Exkube.NamespacesTest do
+  @moduledoc """
+  Tests for the Namespaces module
+  """
+  use ExUnit.Case, async: true
+  alias Exkube.Namespaces
+  require Logger
+
+  test "can list namespaces", %{} do
+    result = Namespaces.all
+    assert elem(result, 0) == :ok
+  end
+
+  test "can get one namespace", %{} do
+    result = Namespaces.one(%{namespace: "uops"})
+    assert elem(result, 0) == :ok
+  end
+
+  test "can create and delete new namespace", %{} do
+    name = "test-" <> Integer.to_string(:rand.uniform(1000))
+    result = Namespaces.create(%{namespace: name})
+    assert elem(result, 0) == :ok
+    result = Namespaces.delete(%{namespace: name})
+    assert elem(result, 0) == :ok
+  end
+
+end