Stop standalone applications

Author: pmarino90

lib/makina.ex

@@ -1,16 +1,3 @@
 defmodule Makina do
-  @moduledoc """
-
-  """
-
-  @doc """
-  Deploys a list of standalone application on a list of servers.
-
-  Standalone applications do not have dependencies among each other and therefore
-  they are deployed as they are listed.
-  Errors in the process will be collected and reported but those will not affect the deployment of other applications also on the same server.
-
-  Deployments happen sequentially server by server, application by application.
-  """
-  defdelegate deploy_standalone_applications(servers, applications), to: Makina.Applications
+  @moduledoc false
 end

lib/makina/applications.ex

@@ -10,26 +10,104 @@ defmodule Makina.Applications do
   alias Makina.Docker
   alias Makina.IO
 
-  def deploy_standalone_applications(servers, applications)
+  @doc """
+  Deploys a list of application on a server or a list of servers
+
+  If a list of servers is provided the function iterates the list and
+  connects to the server before deploying the application.
+  Connection is established before triggering applications deployment
+  and disconnection happens when all applications have been deployed.
+  """
+  def deploy_applications(servers, applications)
       when is_list(servers) and is_list(applications) do
     for server <- servers do
       server = Servers.connect_to_server(server)
-      deployment_result = deploy_applications_on_server(server, applications)
+      deployment_result = deploy_applications(server, applications)
 
       Servers.disconnect_from_server(server)
 
       deployment_result
     end
   end
 
-  def deploy_applications_on_server(%Server{} = server, applications)
+  def deploy_applications(%Server{} = server, applications)
       when is_list(applications) do
     for app <- applications do
-      do_deploy_application(server, app)
+      deploy_application(server, app)
     end
   end
 
-  defp do_deploy_application(%Server{} = server, %Application{} = app) do
+  @doc """
+  Stops all provided applications in all servers
+
+  If `servers` is a list then the function iterates on them and attempt to connect
+  to the server.
+  Servers and applications are processed sequentially.
+  """
+  def stop_applications(servers, applications) when is_list(servers) and is_list(applications) do
+    for server <- servers do
+      server = Servers.connect_to_server(server)
+      deployment_result = stop_applications(server, applications)
+
+      Servers.disconnect_from_server(server)
+
+      deployment_result
+    end
+  end
+
+  def stop_applications(%Server{} = server, applications) when is_list(applications) do
+    for app <- applications do
+      stop_application(server, app)
+    end
+  end
+
+  @doc """
+  Deploys an application on a specific server
+
+  Note: The server has to have a connection at this point.
+  """
+  def deploy_application(%Server{} = server, %Application{} = app) do
+    if Server.connected?(server) do
+      do_deploy(server, app)
+    else
+      connect_and_deploy(server, app)
+    end
+  end
+
+  @doc """
+  Stops an application on a given server
+  """
+  def stop_application(%Server{} = server, %Application{} = app) do
+    if Server.connected?(server) do
+      do_stop(server, app)
+    else
+      connect_and_stop(server, app)
+    end
+  end
+
+  defp do_stop(%Server{} = server, %Application{} = app) do
+    IO.puts(" Stopping \"#{app.name}\"")
+
+    Docker.stop(server, app) |> SSH.execute()
+  end
+
+  defp connect_and_stop(%Server{} = server, %Application{} = app) do
+    server = Servers.connect_to_server(server)
+    result = do_stop(server, app)
+    Servers.disconnect_from_server(server)
+
+    result
+  end
+
+  defp connect_and_deploy(%Server{} = server, %Application{} = app) do
+    server = Servers.connect_to_server(server)
+    result = do_deploy(server, app)
+    Servers.disconnect_from_server(server)
+
+    result
+  end
+
+  def do_deploy(%Server{} = server, %Application{} = app) do
     IO.puts(" Deploying \"#{app.name}\"")
 
     with {:ok, _} <- maybe_login_to_registry(server, app),

lib/makina/cli/commands/standalone.ex

@@ -4,8 +4,9 @@ defmodule Makina.Cli.Commands.Standalone do
   import Makina.Cli.Utils
 
   alias Makina.IO
+  alias Makina.Applications
 
-  @sub_commands ~w[deploy]a
+  @sub_commands ~w[deploy stop]a
 
   def name(), do: "standalone"
 
@@ -46,7 +47,7 @@ defmodule Makina.Cli.Commands.Standalone do
     servers = ctx.servers
 
     deployment_result =
-      Makina.deploy_standalone_applications(servers, ctx.standalone_applications)
+      Applications.deploy_applications(servers, ctx.standalone_applications)
 
     case deployment_errors?(deployment_result) do
       true ->
@@ -61,6 +62,29 @@ defmodule Makina.Cli.Commands.Standalone do
     :ok
   end
 
+  defp sub_command(:stop, options) do
+    ctx =
+      makinafile(options)
+      |> fetch_context()
+
+    servers = ctx.servers
+
+    deployment_result =
+      Applications.stop_applications(servers, ctx.standalone_applications)
+
+    case deployment_errors?(deployment_result) do
+      true ->
+        IO.puts_error("There were errors while stopping some applications.")
+
+        :ok
+
+      false ->
+        IO.puts_success("All applications have been stopped!")
+    end
+
+    :ok
+  end
+
   defp extract_subcommand([sub_command | _rest]) do
     sub_command = sub_command |> String.to_atom()
 

lib/makina/docker.ex

@@ -75,6 +75,10 @@ defmodule Makina.Docker do
     docker(server, "network", ["inspect", name])
   end
 
+  def stop(%Server{} = server, %Application{} = app) do
+    docker(server, "stop", [app_name(app)])
+  end
+
   defp app_name(%Application{__scope__: []} = app) do
     app.name
   end

lib/makina/models/server.ex

@@ -29,4 +29,10 @@ defmodule Makina.Models.Server do
 
     %__MODULE__{server | __private__: private}
   end
+
+  def connected?(%__MODULE__{__private__: %{conn_ref: nil}}), do: false
+
+  def connected?(%__MODULE__{__private__: %{conn_ref: conn_ref}}) do
+    Process.alive?(conn_ref)
+  end
 end

lib/makina/servers.ex

@@ -122,7 +122,7 @@ defmodule Makina.Servers do
       reverse_proxy(ctx.proxy_config)
     ]
 
-    Applications.deploy_applications_on_server(server, system_applications)
+    Applications.deploy_applications(server, system_applications)
 
     server
   end

test/makina/models/docker_test.exs

@@ -1,6 +1,7 @@
 defmodule Makina.Models.DockerTest do
   use ExUnit.Case
 
+  alias Makina.Command
   alias Makina.Models.Server
   alias Makina.Models.Application
 
@@ -139,6 +140,36 @@ defmodule Makina.Models.DockerTest do
     end
   end
 
+  describe "stop/2" do
+    test "returns the command to stop a given container" do
+      app = basic_app_without_scope()
+
+      server =
+        Server.new(host: "example.com")
+        |> Server.put_private(:conn_ref, self())
+
+      cmd = Docker.stop(server, app)
+
+      assert is_struct(cmd, Command)
+
+      assert cmd.cmd == "docker stop foo"
+    end
+
+    test "returns the command to stop a given container with scopes" do
+      app = basic_app_with_scope()
+
+      server =
+        Server.new(host: "example.com")
+        |> Server.put_private(:conn_ref, self())
+
+      cmd = Docker.stop(server, app)
+
+      assert is_struct(cmd, Command)
+
+      assert cmd.cmd == "docker stop makina_app_foo"
+    end
+  end
+
   describe "login/2" do
     test "returns a command to login into a private registry" do
       server =
@@ -185,4 +216,13 @@ defmodule Makina.Models.DockerTest do
       assert cmd.cmd == "docker network inspect foo"
     end
   end
+
+  defp basic_app_without_scope() do
+    Application.new(name: "foo")
+  end
+
+  defp basic_app_with_scope() do
+    Application.new(name: "foo")
+    |> Application.set_private(:__scope__, ["foo", :app, :makina])
+  end
 end