Implement stack install apis in-console (#170)

Author: michaeljguarino

lib/console/commands/plural.ex

@@ -13,6 +13,7 @@ defmodule Console.Commands.Plural do
 
   def deploy(_repo \\ :ignore), do: plural("deploy", ["--silence"])
 
+  def install([_ | _] = repos), do: plural("deploy", ["--silence", "--ignore-console" | Enum.flat_map(repos, & ["--from", &1])])
   def install(repo), do: plural("deploy", ["--silence", "--ignore-console", "--from", repo])
 
   def diff(_repo \\ :ignore), do: plural("diff", [])

lib/console/deployer.ex

@@ -175,6 +175,17 @@ defmodule Console.Deployer do
     ], storage)
   end
 
+  defp perform(storage, %Build{type: :install, context: %{"configuration" => conf, "bundles" => bs}, message: message} = build) do
+    with_build(build, [
+      {storage, :init, []},
+      {Context, :merge, [conf, Enum.map(bs, fn b -> %Context.Bundle{repository: b["repository"], name: b["name"]} end)]},
+      {Plural, :build, []},
+      {Plural, :install, [Enum.map(bs, & &1["repository"])]},
+      {storage, :revise, [message]},
+      {storage, :push, []}
+    ], storage)
+  end
+
   defp perform(storage, %Build{type: :approval, repository: repo, message: message} = build) do
     with_build(build, [
       {storage, :init, []},

lib/console/graphql/plural.ex

@@ -84,6 +84,15 @@ defmodule Console.GraphQl.Plural do
     field :operation, :string
   end
 
+  object :stack do
+    field :id,       non_null(:id)
+    field :name,     non_null(:string)
+    field :bundles,  list_of(:recipe)
+    field :sections, list_of(:recipe_section)
+
+    timestamps()
+  end
+
   object :repository_context do
     field :repository, non_null(:string)
     field :context,    :map
@@ -140,6 +149,13 @@ defmodule Console.GraphQl.Plural do
       resolve &Plural.get_recipe/2
     end
 
+    field :stack, :stack do
+      middleware Authenticated
+      arg :name, non_null(:string)
+
+      resolve &Plural.get_stack/2
+    end
+
     field :smtp, :smtp do
       middleware Authenticated
       middleware AdminRequired
@@ -155,13 +171,27 @@ defmodule Console.GraphQl.Plural do
     field :install_recipe, :build do
       middleware Authenticated
       middleware RequiresGit
+      middleware Rbac, perm: :deploy, arg: :id
+
       arg :id,      non_null(:id)
       arg :context, non_null(:map)
       arg :oidc,    :boolean
 
       safe_resolve &Plural.install_recipe/2
     end
 
+    field :install_stack, :build do
+      middleware Authenticated
+      middleware RequiresGit
+      middleware Rbac, perm: :deploy, arg: :id
+
+      arg :name,    non_null(:string)
+      arg :context, non_null(:map)
+      arg :oidc,    :boolean
+
+      safe_resolve &Plural.install_stack/2
+    end
+
     field :update_smtp, :smtp do
       middleware Authenticated
       middleware AdminRequired

lib/console/graphql/resolvers/plural.ex

@@ -1,7 +1,7 @@
 defmodule Console.GraphQl.Resolvers.Plural do
   use Nebulex.Caching
   alias Console.Plural.{Repositories, ExternalToken}
-  alias Console.Plural.{Connection, PageInfo}
+  alias Console.Plural.{Connection, PageInfo, Stack}
   alias Console.Services.Plural
   alias Kube.Client
 
@@ -28,13 +28,22 @@ defmodule Console.GraphQl.Resolvers.Plural do
 
   def get_recipe(%{id: id}, _) do
     with {:ok, recipe} <- Repositories.get_recipe(id) do
-      sections = Enum.map(recipe.recipeSections, fn section ->
-        Map.put(section, :recipe_items, section.recipeItems)
-      end)
-      {:ok, Map.put(recipe, :recipe_sections, sections)}
+      {:ok, format_recipe(recipe)}
     end
   end
 
+  defp format_section(section), do: Map.put(section, :recipe_items, section.recipeItems)
+
+  defp format_recipe(recipe) do
+    sections = Enum.map(recipe.recipeSections, &format_section/1)
+    Map.put(recipe, :recipe_sections, sections)
+  end
+
+  def get_stack(%{name: name}, _) do
+    with {:ok, %Stack{bundles: recipes, sections: sections} = stack} <- Repositories.get_stack(name),
+      do: {:ok, %{stack | bundles: Enum.map(recipes, &format_recipe/1), sections: Enum.map(sections, &format_section/1)}}
+  end
+
   def list_applications(_, _) do
     with {:ok, %{items: items}} <- Client.list_applications(),
       do: {:ok, items}
@@ -53,6 +62,10 @@ defmodule Console.GraphQl.Resolvers.Plural do
     Plural.install_recipe(id, context, !!args[:oidc], user)
   end
 
+  def install_stack(%{name: name, context: context} = args, %{context: %{current_user: user}}) do
+    Plural.install_stack(name, context, !!args[:oidc], user)
+  end
+
   def update_smtp(%{smtp: smtp}, _), do: Plural.update_smtp(smtp)
 
   def resolve_configuration(%{metadata: %{name: name}}, first, second),

lib/console/plural/context.ex

@@ -43,13 +43,16 @@ defmodule Console.Plural.Context do
     end
   end
 
-  def merge(ctx, bundle) do
+  def merge(ctx, new_bundles) do
     with {:ok, %{configuration: config, bundles: bundles} = context} <- get() do
       updated = DeepMerge.deep_merge(config, ctx)
-      write(%{context | configuration: updated, bundles: Enum.uniq([bundle | bundles])})
+      write(%{context | configuration: updated, bundles: merge_bundles(new_bundles, bundles)})
     end
   end
 
+  defp merge_bundles([_ | _] = new, bundles), do: Enum.uniq(new ++ bundles)
+  defp merge_bundles(b, bundles), do: merge_bundles([b], bundles)
+
   def write(%__MODULE__{bundles: bundles, configuration: conf, smtp: smtp} = context) do
     sanitized = %{
       apiVersion: "plural.sh/v1alpha1",

lib/console/plural/models.ex

@@ -125,6 +125,19 @@ defmodule Console.Plural.Recipe do
   end
 end
 
+defmodule Console.Plural.Stack do
+  alias Console.Plural.{Recipe, RecipeSection}
+
+  defstruct [:id, :name, :bundles, :sections]
+
+  def spec() do
+    %__MODULE__{
+      bundles: [Recipe.spec()],
+      sections: [RecipeSection.spec()]
+    }
+  end
+end
+
 defmodule Console.Plural.Edge do
   defstruct [:node]
 end

lib/console/plural/queries.ex

@@ -93,6 +93,17 @@ defmodule Console.Plural.Queries do
     #{@oidc_provider_fragment}
   """
 
+  @stack_fragment """
+    fragment StackFragment on Stack {
+      id
+      name
+      bundles { ...RecipeFragment }
+      sections { ...RecipeSectionFragment }
+    }
+    #{@recipe_fragment}
+    #{@recipe_section_fragment}
+  """
+
   @installation_query """
     query Installations($first: Int!, $cursor: String) {
       installations(first: $first, after: $cursor) {
@@ -185,6 +196,24 @@ defmodule Console.Plural.Queries do
     }
   """
 
+  @install_stack """
+    mutation Install($name: String!, $provider: Provider!) {
+      installStack(name: $name, provider: $provider) {
+        ...RecipeFragment
+      }
+    }
+    #{@recipe_fragment}
+  """
+
+  @get_stack """
+    query Stack($name: String!, $provider: Provider!) {
+      stack(name: $name, provider: $provider) {
+        ...StackFragment
+      }
+    }
+    #{@stack_fragment}
+  """
+
   @oidc_upsert """
     mutation OIDC($id: ID!, $attributes: OidcAttributes!) {
       upsertOidcProvider(installationId: $id, attributes: $attributes) {
@@ -247,4 +276,8 @@ defmodule Console.Plural.Queries do
   def update_incident_mutation(), do: @update_incident
 
   def create_incident_mutation(), do: @create_incident
+
+  def get_stack_query(), do: @get_stack
+
+  def install_stack_mutation(), do: @install_stack
 end

lib/console/plural/repositories.ex

@@ -9,15 +9,16 @@ defmodule Console.Plural.Repositories do
     Dashboard,
     Recipe,
     Workspace,
-    OIDCProvider
+    OIDCProvider,
+    Stack
   }
 
   defmodule Query do
-    defstruct [:installations, :searchRepositories, :recipes, :recipe, :installation]
+    defstruct [:installations, :searchRepositories, :recipes, :recipe, :installation, :stack]
   end
 
   defmodule Mutation do
-    defstruct [:installRecipe, :upsertOidcProvider]
+    defstruct [:installRecipe, :upsertOidcProvider, :installStack]
   end
 
   def search_repositories(query, first) do
@@ -59,6 +60,20 @@ defmodule Console.Plural.Repositories do
     |> when_ok(fn %{recipe: result} -> result end)
   end
 
+  def get_stack(name) do
+    prov = Workspace.provider()
+    get_stack_query()
+    |> Client.run(%{name: name, provider: provider(prov)}, %Query{stack: Stack.spec()})
+    |> when_ok(fn %{stack: s} -> s end)
+  end
+
+  def install_stack(name) do
+    prov = Workspace.provider()
+    install_stack_mutation()
+    |> Client.run(%{name: name, provider: provider(prov)}, %Mutation{installStack: [Recipe.spec()]})
+    |> when_ok(fn %{installStack: recipes} -> recipes end)
+  end
+
   def install_recipe(id) do
     install_recipe_mutation()
     |> Client.run(

lib/console/services/base.ex

@@ -16,13 +16,19 @@ defmodule Console.Services.Base do
 
   def start_transaction(), do: Ecto.Multi.new()
 
+  def short_circuit(), do: []
+
+  def short(circuit, name, fun) when is_list(circuit) and is_function(fun),
+    do: [{name, fun} | circuit]
+
   def add_operation(multi, name, fun) when is_function(fun) do
     Ecto.Multi.run(multi, name, fn _, params ->
       fun.(params)
     end)
   end
 
-  def execute(%Ecto.Multi{} = multi, opts \\ []) do
+  def execute(operation, opts \\ [])
+  def execute(%Ecto.Multi{} = multi, opts) do
     with {:ok, result} <- Console.Repo.transaction(multi) do
       case Map.new(opts) do
         %{extract: operation} -> {:ok, result[operation]}
@@ -33,6 +39,19 @@ defmodule Console.Services.Base do
       {:error, reason} -> {:error, reason}
     end
   end
+  def execute(circuit, _) when is_list(circuit) do
+    Enum.reverse(circuit)
+    |> execute_short_circuit(%{})
+  end
+
+  defp execute_short_circuit([], result), do: {:ok, result}
+  defp execute_short_circuit([{name, fun} | rest], result) do
+    case fun.() do
+      {:ok, res} -> execute_short_circuit(rest, Map.put(result, name, res))
+      :ok -> execute_short_circuit(rest, result)
+      {:error, _} = error -> error
+    end
+  end
 
   def broadcast(resource, delta) do
     topic = Topic.infer(resource, delta)

lib/console/services/plural.ex

@@ -1,4 +1,5 @@
 defmodule Console.Services.Plural do
+  use Console.Services.Base
   alias Console.Deployer
   alias Console.Schema.{User, Manifest}
   alias Console.Services.{Builds}
@@ -64,6 +65,32 @@ defmodule Console.Services.Plural do
     end
   end
 
+  def install_stack(name, context, oidc, %User{} = user) do
+    with {:ok, [recipe | _] = recipes} <- Repositories.install_stack(name),
+         {:ok, _} <- oidc_for_stack(recipes, context, oidc) do
+      repos = Enum.map(recipes, & &1.repository.name)
+      Builds.create(%{
+        type: :install,
+        repository: recipe.repository.name,
+        message: "Installed stack #{name} with repositories #{Enum.join(repos, ", ")}",
+        context: %{
+          configuration: context,
+          bundles: Enum.map(recipes, & %{name: &1.name, repository: &1.repository.name}),
+        },
+      }, user)
+    end
+  end
+
+  def oidc_for_stack([_ | _] = recipes, context, oidc) do
+    Enum.reduce(recipes, short_circuit(), fn recipe, circuit ->
+      short(circuit, recipe.id, fn ->
+        with :ok <- configure_oidc(recipe, context, oidc),
+          do: oidc_dependencies(recipe.recipeDependencies, context, oidc)
+      end)
+    end)
+    |> execute()
+  end
+
   def configure_oidc(
     %Recipe{
       repository: %{name: name},