add change detection to stack run creation process

lib/console.ex

@@ -218,5 +218,7 @@ defmodule Console do
     end
   end
 
+  def lines(str), do: String.split(str, ~r/\R/)
+
   def storage, do: Console.Storage.Git
 end

lib/console/deployments/git/agent.ex

@@ -32,6 +32,8 @@ defmodule Console.Deployments.Git.Agent do
 
   def sha(pid, ref), do: GenServer.call(pid, {:sha, ref}, 30_000)
 
+  def changes(pid, sha1, sha2), do: GenServer.call(pid, {:changes, sha1, sha2}, 30_000)
+
   def kick(pid), do: send(pid, :pull)
 
   def start(%GitRepository{} = repo) do
@@ -83,6 +85,10 @@ defmodule Console.Deployments.Git.Agent do
     {:reply, Cache.commit(cache, ref), state}
   end
 
+  def handle_call({:changes, sha1, sha2}, _, %State{cache: cache} = state) do
+    {:reply, Cache.changes(cache, sha1, sha2), state}
+  end
+
   def handle_call({:fetch, %Service.Git{} = ref}, _, %State{cache: cache} = state) do
     case Cache.fetch(cache, ref) do
       {:ok, %Cache.Line{file: f}, cache} -> {:reply, File.open(f), %{state | cache: cache}}

lib/console/deployments/git/cache.ex

@@ -65,6 +65,8 @@ defmodule Console.Deployments.Git.Cache do
     end
   end
 
+  def changes(%__MODULE__{git: g}, sha1, sha2), do: file_changes(g, sha1, sha2)
+
   defp new_line(cache, repo, sha, path, filter) do
     with {:ok, _} <- git(repo, "checkout", [sha]),
          {:ok, msg} <- msg(repo),

lib/console/deployments/git/cmd.ex

@@ -27,6 +27,13 @@ defmodule Console.Deployments.Git.Cmd do
       do: {:ok, String.trim(sha)}
   end
 
+  def file_changes(repo, sha1, sha2) do
+    case git(repo, "--no-pager", ["diff", "--name-only", "#{sha1}", "#{sha2}"]) do
+      {:ok, res} -> {:ok, String.trim(res) |> Console.lines()}
+      _ -> {:ok, :pass}
+    end
+  end
+
   def branches(%GitRepository{} = repo) do
     with {:ok, res} <- git(repo, "branch", ["-r"]) do
       split_and_trim(res)

lib/console/deployments/git/discovery.ex

@@ -26,6 +26,11 @@ defmodule Console.Deployments.Git.Discovery do
       do: Agent.sha(pid, ref)
   end
 
+  def changes(%GitRepository{} = repo, sha1, sha2) do
+    with {:ok, pid} <- find(repo),
+      do: Agent.changes(pid, sha1, sha2)
+  end
+
   @spec docs(Service.t) :: {:ok, File.t} | error
   def docs(%Service{} = svc) do
     %{repository: repo} = Console.Repo.preload(svc, [:repository])

lib/console/deployments/stacks.ex

@@ -191,11 +191,13 @@ defmodule Console.Deployments.Stacks do
   def poll(%Stack{delete_run_id: id}) when is_binary(id),
     do: {:error, "stack is deleting"}
 
-  def poll(%Stack{sha: sha} = stack) do
+  def poll(%Stack{sha: sha, git: git} = stack) do
     %{repository: repo} = stack = Repo.preload(stack, @poll_preloads)
-    case Discovery.sha(repo, stack.git.ref) do
+    case Discovery.sha(repo, git.ref) do
       {:ok, ^sha} -> {:error, "no new commit in repo"}
-      {:ok, new_sha} -> create_run(stack, new_sha)
+      {:ok, new_sha} ->
+        with {:ok, new_sha} <- new_changes(repo, git, sha, new_sha),
+          do: create_run(stack, new_sha)
       err -> err
     end
   end
@@ -205,21 +207,33 @@ defmodule Console.Deployments.Stacks do
     case Discovery.sha(repo, ref) do
       {:ok, ^sha} -> {:error, "no new commit in repo for branch #{ref}"}
       {:ok, new_sha} ->
-        start_transaction()
-        |> add_operation(:run, fn _ ->
-          create_run(stack, new_sha, %{pull_request_id: pr.id, dry_run: true})
-        end)
-        |> add_operation(:pr, fn _ ->
-          Ecto.Changeset.change(pr, %{ref: new_sha})
-          |> Repo.update()
-        end)
-        |> execute(extract: :run)
+        with {:ok, new_sha} <- new_changes(repo, stack.git, sha, new_sha) do
+          start_transaction()
+          |> add_operation(:run, fn _ ->
+            create_run(stack, new_sha, %{pull_request_id: pr.id, dry_run: true})
+          end)
+          |> add_operation(:pr, fn _ ->
+            Ecto.Changeset.change(pr, %{ref: new_sha})
+            |> Repo.update()
+          end)
+          |> execute(extract: :run)
+        end
       err -> err
     end
   end
 
   def poll(_), do: {:error, "invalid parent"}
 
+  defp new_changes(repo, %{folder: folder}, sha1, sha2) do
+    with {:ok, [_ | _] = changes} <- Discovery.changes(repo, sha1, sha2),
+         true <- Enum.any?(changes, &String.starts_with?(&1, folder)) do
+      {:ok, sha2}
+    else
+      {:ok, :pass} -> {:ok, sha2}
+      _ -> {:error, "no changes within #{folder}"}
+    end
+  end
+
   @doc """
   Creates a new run for the stack with the given sha and optional additional attrs
   """
@@ -241,14 +255,17 @@ defmodule Console.Deployments.Stacks do
       |> Repo.insert()
     end)
     |> add_operation(:stack, fn %{run: run} ->
-      Ecto.Changeset.change(stack, %{sha: sha})
+      Ecto.Changeset.change(stack, sha_attrs(run, sha))
       |> Stack.delete_changeset(delete_run(stack, run))
       |> Repo.update()
     end)
     |> execute(extract: :run)
     |> notify(:create)
   end
 
+  defp sha_attrs(%StackRun{dry_run: true}, _sha), do: %{}
+  defp sha_attrs(%StackRun{}, sha), do: %{sha: sha}
+
   defp delete_run(%Stack{deleted_at: d}, %{id: id}) when not is_nil(d),
     do: %{delete_run_id: id}
   defp delete_run(_, _), do: %{}

test/console/deployments/cron_test.exs

@@ -203,8 +203,12 @@ defmodule Console.Deployments.CronTest do
 
   describe "#poll_stacks/0" do
     test "it can generate new stack runs" do
-      stack = insert(:stack, environment: [%{name: "ENV", value: "1"}], files: [%{path: "test.txt", content: "test"}])
+      stack = insert(:stack,
+        environment: [%{name: "ENV", value: "1"}], files: [%{path: "test.txt", content: "test"}],
+        git: %{ref: "main", folder: "terraform"}
+      )
       expect(Console.Deployments.Git.Discovery, :sha, fn _, _ -> {:ok, "new-sha"} end)
+      expect(Console.Deployments.Git.Discovery, :changes, fn _, _, _ -> {:ok, ["terraform/main.tf"]} end)
 
       Cron.poll_stacks()
 

test/console/deployments/pubsub/recurse_test.exs

@@ -361,8 +361,9 @@ defmodule Console.Deployments.PubSub.RecurseTest do
 
   describe "StackCreated" do
     test "it will poll the stack" do
-      stack = insert(:stack)
+      stack = insert(:stack, git: %{folder: "terraform", ref: "main"})
       expect(Discovery, :sha, fn _, _ -> {:ok, "new-sha"} end)
+      expect(Discovery, :changes, fn _, _, _ -> {:ok, ["terraform/main.tf"]} end)
 
       event = %PubSub.StackCreated{item: stack}
       {:ok, run} = Recurse.handle_event(event)
@@ -377,8 +378,9 @@ defmodule Console.Deployments.PubSub.RecurseTest do
 
   describe "StackUpdated" do
     test "it will poll the stack" do
-      stack = insert(:stack)
+      stack = insert(:stack, git: %{folder: "terraform", ref: "main"})
       expect(Discovery, :sha, fn _, _ -> {:ok, "new-sha"} end)
+      expect(Discovery, :changes, fn _, _, _ -> {:ok, ["terraform/main.tf"]} end)
 
       event = %PubSub.StackUpdated{item: stack}
       {:ok, run} = Recurse.handle_event(event)

test/console/deployments/stacks_test.exs

@@ -143,8 +143,13 @@ defmodule Console.Deployments.StacksTest do
 
   describe "#poll/1" do
     test "it can create a new run when the sha changes" do
-      stack = insert(:stack, environment: [%{name: "ENV", value: "1"}], files: [%{path: "test.txt", content: "test"}])
+      stack = insert(:stack,
+        environment: [%{name: "ENV", value: "1"}],
+        files: [%{path: "test.txt", content: "test"}],
+        git: %{ref: "main", folder: "terraform"}
+      )
       expect(Discovery, :sha, fn _, _ -> {:ok, "new-sha"} end)
+      expect(Discovery, :changes, fn _, _, _ -> {:ok, ["terraform/main.tf"]} end)
 
       {:ok, run} = Stacks.poll(stack)
 
@@ -175,9 +180,14 @@ defmodule Console.Deployments.StacksTest do
     end
 
     test "it can create a new run from a pr the sha changes" do
-      stack = insert(:stack, environment: [%{name: "ENV", value: "1"}], files: [%{path: "test.txt", content: "test"}])
+      stack = insert(:stack,
+        environment: [%{name: "ENV", value: "1"}],
+        files: [%{path: "test.txt", content: "test"}],
+        git: %{ref: "main", folder: "terraform"}
+      )
       pr = insert(:pull_request, stack: stack)
       expect(Discovery, :sha, fn _, _ -> {:ok, "new-sha"} end)
+      expect(Discovery, :changes, fn _, _, _ -> {:ok, ["terraform/main.tf"]} end)
 
       {:ok, run} = Stacks.poll(pr)