From cc973cc11c58eded739f59c1cd7a6ae0b6130eed Mon Sep 17 00:00:00 2001 From: HaimKortovich Date: Thu, 16 Apr 2026 14:20:58 -0500 Subject: [PATCH] init commit --- .envrc | 1 + .gitea/workflows/build-and-publish.yaml | 68 +++++ config/config.exs | 46 ++++ config/dev.exs | 42 +++ config/prod.exs | 6 + config/runtime.exs | 94 +++++++ config/test.exs | 24 ++ flake.lock | 61 +++++ flake.nix | 55 ++++ lib/workload_service/aggregates/quote_task.ex | 9 + .../aggregates/solicitation_task.ex | 9 + lib/workload_service/aggregates/task.ex | 145 ++++++++++ lib/workload_service/aggregates/task_id.ex | 48 ++++ lib/workload_service/application.ex | 29 ++ lib/workload_service/commanded_app.ex | 32 +++ lib/workload_service/commands/quote_task.ex | 53 ++++ .../commands/solicitation_task.ex | 53 ++++ .../consumers/quote_requested_consumer.ex | 93 +++++++ .../solicitation_requested_consumer.ex | 138 ++++++++++ lib/workload_service/event_store.ex | 3 + lib/workload_service/events/task.ex | 47 ++++ lib/workload_service/message_bus.ex | 86 ++++++ lib/workload_service/projections/task.ex | 61 +++++ .../projectors/task_projector.ex | 61 +++++ lib/workload_service/release.ex | 37 +++ lib/workload_service/repo.ex | 7 + lib/workload_service/workload/queries.ex | 38 +++ lib/workload_service_web.ex | 46 ++++ lib/workload_service_web/api_spec.ex | 20 ++ lib/workload_service_web/controllers.ex | 3 + .../controllers/fallback_controller.ex | 28 ++ .../controllers/health_controller.ex | 15 ++ .../controllers/task_controller.ex | 249 ++++++++++++++++++ lib/workload_service_web/endpoint.ex | 33 +++ lib/workload_service_web/error_json.ex | 5 + lib/workload_service_web/router.ex | 32 +++ lib/workload_service_web/schemas/task.ex | 146 ++++++++++ lib/workload_service_web/telemetry.ex | 51 ++++ mix.exs | 59 +++++ mix.lock | 50 ++++ ops/chart/Chart.yaml | 14 + ops/chart/templates/common.tpl | 4 + ops/chart/values.yaml | 247 +++++++++++++++++ .../20240101000001_create_tasks.exs | 25 ++ ...60413000001_create_projection_versions.exs | 12 + priv/repo/seeds.exs | 11 + rel/overlays/bin/migrate | 5 + rel/overlays/bin/migrate.bat | 1 + rel/overlays/bin/server | 5 + rel/overlays/bin/server.bat | 2 + rel/vm.args.eex | 38 +++ 51 files changed, 2447 insertions(+) create mode 100644 .envrc create mode 100644 .gitea/workflows/build-and-publish.yaml create mode 100644 config/config.exs create mode 100644 config/dev.exs create mode 100644 config/prod.exs create mode 100644 config/runtime.exs create mode 100644 config/test.exs create mode 100644 flake.lock create mode 100644 flake.nix create mode 100644 lib/workload_service/aggregates/quote_task.ex create mode 100644 lib/workload_service/aggregates/solicitation_task.ex create mode 100644 lib/workload_service/aggregates/task.ex create mode 100644 lib/workload_service/aggregates/task_id.ex create mode 100644 lib/workload_service/application.ex create mode 100644 lib/workload_service/commanded_app.ex create mode 100644 lib/workload_service/commands/quote_task.ex create mode 100644 lib/workload_service/commands/solicitation_task.ex create mode 100644 lib/workload_service/consumers/quote_requested_consumer.ex create mode 100644 lib/workload_service/consumers/solicitation_requested_consumer.ex create mode 100644 lib/workload_service/event_store.ex create mode 100644 lib/workload_service/events/task.ex create mode 100644 lib/workload_service/message_bus.ex create mode 100644 lib/workload_service/projections/task.ex create mode 100644 lib/workload_service/projectors/task_projector.ex create mode 100644 lib/workload_service/release.ex create mode 100644 lib/workload_service/repo.ex create mode 100644 lib/workload_service/workload/queries.ex create mode 100644 lib/workload_service_web.ex create mode 100644 lib/workload_service_web/api_spec.ex create mode 100644 lib/workload_service_web/controllers.ex create mode 100644 lib/workload_service_web/controllers/fallback_controller.ex create mode 100644 lib/workload_service_web/controllers/health_controller.ex create mode 100644 lib/workload_service_web/controllers/task_controller.ex create mode 100644 lib/workload_service_web/endpoint.ex create mode 100644 lib/workload_service_web/error_json.ex create mode 100644 lib/workload_service_web/router.ex create mode 100644 lib/workload_service_web/schemas/task.ex create mode 100644 lib/workload_service_web/telemetry.ex create mode 100644 mix.exs create mode 100644 mix.lock create mode 100644 ops/chart/Chart.yaml create mode 100644 ops/chart/templates/common.tpl create mode 100644 ops/chart/values.yaml create mode 100644 priv/repo/migrations/20240101000001_create_tasks.exs create mode 100644 priv/repo/migrations/20260413000001_create_projection_versions.exs create mode 100644 priv/repo/seeds.exs create mode 100644 rel/overlays/bin/migrate create mode 100644 rel/overlays/bin/migrate.bat create mode 100644 rel/overlays/bin/server create mode 100644 rel/overlays/bin/server.bat create mode 100644 rel/vm.args.eex diff --git a/.envrc b/.envrc new file mode 100644 index 0000000..3550a30 --- /dev/null +++ b/.envrc @@ -0,0 +1 @@ +use flake diff --git a/.gitea/workflows/build-and-publish.yaml b/.gitea/workflows/build-and-publish.yaml new file mode 100644 index 0000000..dc1cb1f --- /dev/null +++ b/.gitea/workflows/build-and-publish.yaml @@ -0,0 +1,68 @@ +name: Build and Publish +on: + push: + branches: + - main +env: + CHART_NAME: ${{ github.event.repository.name }} + IMAGE_NAME: ${{ github.event.repository.name }} +jobs: + build-release: + runs-on: nix + permissions: + id-token: write + contents: read + steps: + - name: Checkout repository + uses: actions/checkout@v4 + + - name: Build Docker Image via Nix Flake + run: | + nix build .#dockerImage --print-build-logs + docker load < result + + - name: Log in to Gitea Container Registry + uses: docker/login-action@v3 + with: + registry: ${{ github.server_url }} + username: ${{ secrets.CI_USER }} + password: ${{ secrets.CI_PASSWORD }} + + - name: Tag and Push Docker Image + run: | + VERSION=${{ github.run_number }} + + # Strip https from server URL + REGISTRY=${GITHUB_SERVER_URL#https://} + + TARGET_IMAGE=$REGISTRY/${{ github.repository_owner }}/${{ env.IMAGE_NAME }} + + # Auto-detect the built image name (better version) + SOURCE_IMAGE=$(docker load < result | awk '{print $3}') + + docker tag $SOURCE_IMAGE $TARGET_IMAGE:$VERSION + docker tag $SOURCE_IMAGE $TARGET_IMAGE:latest + docker push $TARGET_IMAGE:$VERSION + docker push $TARGET_IMAGE:latest + + - name: Setup Helm + uses: azure/setup-helm@v4 + with: + version: v3.14.0 + + - name: Package Helm Chart + run: | + VERSION=${{ github.run_number }} + helm repo add bjw-s https://bjw-s-labs.github.io/helm-charts + helm dependency build ops/chart + helm package ops/chart --version $VERSION --app-version $VERSION + + - name: Push Helm Chart to Gitea Registry + run: | + VERSION=${{ github.run_number }} + CHART_FILE=${{ env.CHART_NAME }}-${VERSION}.tgz + + curl -f --user "${{ secrets.CI_USER }}:${{ secrets.CI_PASSWORD }}" \ + -X POST \ + --upload-file ./$CHART_FILE \ + "${{ github.server_url }}/api/packages/${{ github.repository_owner }}/helm/api/charts" \ No newline at end of file diff --git a/config/config.exs b/config/config.exs new file mode 100644 index 0000000..58b4ff1 --- /dev/null +++ b/config/config.exs @@ -0,0 +1,46 @@ +import Config + +config :workload_service, + ecto_repos: [WorkloadService.Repo], + event_stores: [WorkloadService.EventStore] + +config :workload_service, WorkloadServiceWeb.Endpoint, + url: [host: "localhost"], + adapter: Bandit.PhoenixAdapter, + render_errors: [ + formats: [json: WorkloadServiceWeb.ErrorJSON], + layout: false + ], + pubsub_server: WorkloadService.PubSub, + live_view: [signing_salt: "workload_secret"] + +config :logger, :console, + format: "$time $metadata[$level] $message\n", + metadata: [:request_id] + +config :phoenix, :json_library, Jason + +config :workload_service, WorkloadService.CommandedApp, + event_store: [ + adapter: Commanded.EventStore.Adapters.EventStore, + event_store: WorkloadService.EventStore + ], + pub_sub: :local, + registry: :local + +config :commanded, + event_store_adapter: Commanded.EventStore.Adapters.EventStore + +config :commanded_ecto_projections, + repo: WorkloadService.Repo + +config :flop, repo: WorkloadService.Repo + +config :workload_service, WorkloadService.Repo, + database: "workload_service_dev", + username: "postgres", + password: "postgres", + host: "localhost", + pool_size: 10 + +import_config "#{config_env()}.exs" diff --git a/config/dev.exs b/config/dev.exs new file mode 100644 index 0000000..fc62b4e --- /dev/null +++ b/config/dev.exs @@ -0,0 +1,42 @@ +import Config + +config :workload_service, :amqp_url, "amqp://guest:guest@localhost:5672" + +config :workload_service, WorkloadService.EventStore, + serializer: Commanded.Serialization.JsonSerializer, + username: "postgres", + password: "postgres", + database: "workload_service_eventstore_dev", + hostname: "localhost", + pool_size: 10 + +config :workload_service, WorkloadService.Repo, + username: "postgres", + password: "postgres", + hostname: "localhost", + database: "workload_service_dev", + stacktrace: true, + show_sensitive_data_on_connection_error: true, + pool_size: 10 + +config :workload_service, WorkloadServiceWeb.Endpoint, + http: [ip: {127, 0, 0, 1}], + check_origin: false, + code_reloader: true, + debug_errors: true, + secret_key_base: "rSPVNB6DCC2RMMlmk9QkCVGAzasUD6AWh5ussctvNuUxgZL9DRnFXTo6jcIz6JpB", + watchers: [] + +config :workload_service, dev_routes: true + +config :logger, :default_formatter, format: "[$level] $message\n" + +config :phoenix, :stacktrace_depth, 20 + +config :phoenix, :plug_init_mode, :runtime + +config :open_api_spex, :cache_adapter, OpenApiSpex.Plug.NoneCache + +config :workload_service, + provider_service_url: "http://localhost:4002", + solicitation_service_url: "http://localhost:8081" diff --git a/config/prod.exs b/config/prod.exs new file mode 100644 index 0000000..9610f3e --- /dev/null +++ b/config/prod.exs @@ -0,0 +1,6 @@ +import Config + +config :logger, level: :debug + +# Runtime production configuration, including reading +# of environment variables, is done on config/runtime.exs. diff --git a/config/runtime.exs b/config/runtime.exs new file mode 100644 index 0000000..faa5979 --- /dev/null +++ b/config/runtime.exs @@ -0,0 +1,94 @@ +import Config + +# config/runtime.exs is executed for all environments, including +# during releases. It is executed after compilation and before the +# system starts, so it is typically used to load production configuration +# and secrets from environment variables or elsewhere. Do not define +# any compile-time configuration in here, as it won't be applied. +# The block below contains prod specific runtime configuration. + +logger_level = + case System.get_env("LOG_LEVEL", "info") do + "debug" -> :debug + "info" -> :info + "warn" -> :warning + "error" -> :error + val when val in ["warning", "error"] -> :error + _ -> :info + end + +config :logger, level: logger_level + +config :logger, :console, format: {Logger.Formatter, :format} + +rabbitmq_host = System.get_env("RABBITMQ_HOST", "localhost") +rabbitmq_vhost = System.get_env("RABBITMQ_VHOST", "/") +rabbitmq_username = System.get_env("RABBITMQ_USERNAME") +rabbitmq_password = System.get_env("RABBITMQ_PASSWORD") + +amqp_url = + if rabbitmq_username && rabbitmq_password do + "amqp://#{rabbitmq_username}:#{rabbitmq_password}@#{rabbitmq_host}/#{rabbitmq_vhost}" + end + +if amqp_url do + config :workload_service, :amqp_url, amqp_url +end + +# ## Using releases +# +# If you use `mix release`, you need to explicitly enable the server +# by passing the PHX_SERVER=true when you start it: +# +# PHX_SERVER=true bin/workload_service start +# +# Alternatively, you can use `mix phx.gen.release` to generate a `bin/server` +# script that automatically sets the env var above. +if System.get_env("PHX_SERVER") do + config :workload_service, WorkloadServiceWeb.Endpoint, server: true +end + +if cookie = System.get_env("RELEASE_COOKIE") do + config :elixir, :cookie, cookie +end + +if config_env() == :prod do + database_url = + System.get_env("DATABASE_URL") || + raise """ + environment variable DATABASE_URL is missing. + For example: ecto://USER:PASS@HOST/DATABASE + """ + + maybe_ipv6 = if System.get_env("ECTO_IPV6") in ~w(true 1), do: [:inet6], else: [] + + config :workload_service, WorkloadService.Repo, + url: database_url, + pool_size: String.to_integer(System.get_env("DATABASE_POOL_SIZE") || "1"), + socket_options: maybe_ipv6 + + config :workload_service, WorkloadService.EventStore, + serializer: Commanded.Serialization.JsonSerializer, + url: database_url, + schema: "eventstore", + pool_size: String.to_integer(System.get_env("EVENTSTORE_POOL_SIZE") || "1") + + secret_key_base = + System.get_env("SECRET_KEY_BASE") || + raise """ + environment variable SECRET_KEY_BASE is missing. + You can generate one by calling: mix phx.gen.secret + """ + + host = System.get_env("PHX_HOST") || "example.com" + + config :workload_service, :dns_cluster_query, System.get_env("DNS_CLUSTER_QUERY") + + config :workload_service, WorkloadServiceWeb.Endpoint, + url: [host: host, port: String.to_integer(System.get_env("PORT", "4000")), scheme: "http"], + http: [ + ip: {0, 0, 0, 0, 0, 0, 0, 0}, + port: String.to_integer(System.get_env("PORT", "4000")) + ], + secret_key_base: secret_key_base +end \ No newline at end of file diff --git a/config/test.exs b/config/test.exs new file mode 100644 index 0000000..4d976e1 --- /dev/null +++ b/config/test.exs @@ -0,0 +1,24 @@ +import Config + +config :workload_service, WorkloadService.Repo, + username: "postgres", + password: "postgres", + hostname: "localhost", + database: "workload_service_test#{System.get_env("MIX_TEST_PARTITION")}", + pool: Ecto.Adapters.SQL.Sandbox, + pool_size: System.schedulers_online() * 2 + +config :workload_service, WorkloadServiceWeb.Endpoint, + http: [ip: {127, 0, 0, 1}, port: 4002], + secret_key_base: "workload_test_secret_key_base_at_least_64_bytes_long_for_testing", + server: false + +config :logger, level: :warning + +config :phoenix, :plug_init_mode, :runtime + +config :workload_service, WorkloadService.Application, + event_store: [ + adapter: Commanded.EventStore.Adapters.InMemory, + serializer: Commanded.Serialization.JsonSerializer + ] diff --git a/flake.lock b/flake.lock new file mode 100644 index 0000000..57640e9 --- /dev/null +++ b/flake.lock @@ -0,0 +1,61 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1775710090, + "narHash": "sha256-ar3rofg+awPB8QXDaFJhJ2jJhu+KqN/PRCXeyuXR76E=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "4c1018dae018162ec878d42fec712642d214fdfa", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixos-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/flake.nix b/flake.nix new file mode 100644 index 0000000..bd7b199 --- /dev/null +++ b/flake.nix @@ -0,0 +1,55 @@ +{ + description = "Workload Service - Elixir/Commanded CQRS/ES service"; + + inputs = { + nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; + flake-utils.url = "github:numtide/flake-utils"; + }; + + outputs = { + self, + nixpkgs, + flake-utils, + }: + flake-utils.lib.eachDefaultSystem ( + system: + let + pkgs = nixpkgs.legacyPackages.${system}; + beamPackages = pkgs.beamPackages; + pname = "workload_service"; + version = "1.0.0"; + mixFodDeps = beamPackages.fetchMixDeps { + inherit pname version; + src = ./.; + sha256 = "sha256-YkX+Bti+GyU6RQOjVTwsPIWKuqJox0lz+qK2V8Zg1XI="; + }; + package = beamPackages.mixRelease { + inherit pname version mixFodDeps; + src = ./.; + meta = { + mainProgram = "workload_service"; + }; + removeCookie = false; + }; + dockerImage = pkgs.dockerTools.buildLayeredImage { + name = "workload_service"; + contents = [ package pkgs.bashInteractive pkgs.busybox pkgs.shadow ]; + config = { + Cmd = [ "${package}/bin/workload_service" "start" ]; + }; + }; + in + { + packages.default = package; + packages.dockerImage = dockerImage; + devShells.default = pkgs.mkShell { + buildInputs = with pkgs; [ + elixir + elixir-ls + kubernetes-helm + git + ]; + }; + } + ); +} \ No newline at end of file diff --git a/lib/workload_service/aggregates/quote_task.ex b/lib/workload_service/aggregates/quote_task.ex new file mode 100644 index 0000000..44bf8a7 --- /dev/null +++ b/lib/workload_service/aggregates/quote_task.ex @@ -0,0 +1,9 @@ +defmodule WorkloadService.Aggregates.QuoteTask do + use WorkloadService.Aggregates.Task, + task_type: "quote", + commands: WorkloadService.Commands.QuoteTask + + def validate_submission(_) do + :ok + end +end diff --git a/lib/workload_service/aggregates/solicitation_task.ex b/lib/workload_service/aggregates/solicitation_task.ex new file mode 100644 index 0000000..1d7da9f --- /dev/null +++ b/lib/workload_service/aggregates/solicitation_task.ex @@ -0,0 +1,9 @@ +defmodule WorkloadService.Aggregates.SolicitationTask do + use WorkloadService.Aggregates.Task, + task_type: "solicitation", + commands: WorkloadService.Commands.SolicitationTask + + def validate_submission(_) do + :ok + end +end diff --git a/lib/workload_service/aggregates/task.ex b/lib/workload_service/aggregates/task.ex new file mode 100644 index 0000000..b5491ac --- /dev/null +++ b/lib/workload_service/aggregates/task.ex @@ -0,0 +1,145 @@ +defmodule WorkloadService.Aggregates.Task do + @moduledoc """ + Behaviour and __using__ macro for task aggregates. + Each task type can override validation and add specific behavior. + + Usage: + defmodule WorkloadService.Aggregates.QuoteTask do + use WorkloadService.Aggregates.Task, + task_type: "quote" + end + """ + + @callback validate_submission(map()) :: :ok | {:error, term()} + + defmacro __using__(opts) do + task_type = Keyword.fetch!(opts, :task_type) + commands_module = Keyword.get(opts, :commands, WorkloadService.Commands.Task) + + quote do + @behaviour Commanded.Aggregates.Aggregate + @task_type unquote(task_type) + + alias unquote(commands_module).CreateTask + alias unquote(commands_module).SubmitResponse + alias unquote(commands_module).ApproveSubmission + alias unquote(commands_module).CompleteTask + + alias Commanded.Aggregates.Aggregate + + defstruct [ + :id, + :application_id, + :provider_id, + :provider_name, + :task_info, + :submission, + :attachments, + :status, + :version + ] + + @impl Aggregate + def execute(%__MODULE__{status: nil}, %CreateTask{} = cmd) do + %WorkloadService.Events.TaskCreated{ + id: cmd.id, + application_id: cmd.application_id, + provider_id: cmd.provider_id, + provider_name: cmd.provider_name, + task_info: cmd.task_info || %{}, + attachments: cmd.attachments || [] + } + end + + @impl Aggregate + def execute(%__MODULE__{}, %CreateTask{}) do + {:error, :task_already_exists} + end + + @impl Aggregate + def execute(%__MODULE__{status: status}, %SubmitResponse{} = cmd) + when status in [nil, "created", "draft", "approved"] do + with :ok <- validate_submission(cmd.submission) do + new_status = if status == "approved", do: "draft", else: "draft" + + %WorkloadService.Events.SubmissionUpdated{ + id: cmd.id, + submission: cmd.submission, + attachments: cmd.attachments + } + end + end + + @impl Aggregate + def execute(%__MODULE__{status: "draft"}, %ApproveSubmission{}) do + %WorkloadService.Events.SubmissionApproved{ + id: nil + } + end + + @impl Aggregate + def execute(%__MODULE__{status: status}, %ApproveSubmission{}) do + {:error, {:invalid_state, "cannot approve in state: #{status}"}} + end + + @impl Aggregate + def execute(%__MODULE__{status: "approved"}, %CompleteTask{} = cmd) do + %WorkloadService.Events.TaskCompleted{ + id: cmd.id, + completed_by: cmd.completed_by + } + end + + @impl Aggregate + def execute(%__MODULE__{status: status}, %CompleteTask{}) do + {:error, {:invalid_state, "cannot complete in state: #{status}"}} + end + + @impl Aggregate + def apply(%__MODULE__{} = agg, %WorkloadService.Events.TaskCreated{} = e) do + %{ + agg + | id: e.id, + application_id: e.application_id, + provider_id: e.provider_id, + provider_name: e.provider_name, + task_info: e.task_info, + attachments: e.attachments, + status: "created", + version: agg.version + 1 + } + end + + @impl Aggregate + def apply(%__MODULE__{} = agg, %WorkloadService.Events.SubmissionUpdated{} = e) do + %{ + agg + | submission: e.submission, + attachments: e.attachments || [], + status: "draft", + version: agg.version + 1 + } + end + + @impl Aggregate + def apply(%__MODULE__{} = agg, %WorkloadService.Events.SubmissionApproved{}) do + %{ + agg + | status: "approved", + version: agg.version + 1 + } + end + + @impl Aggregate + def apply(%__MODULE__{} = agg, %WorkloadService.Events.TaskCompleted{}) do + %{ + agg + | status: "completed", + version: agg.version + 1 + } + end + + defoverridable execute: 2, apply: 2 + end + end +end diff --git a/lib/workload_service/aggregates/task_id.ex b/lib/workload_service/aggregates/task_id.ex new file mode 100644 index 0000000..d7eb328 --- /dev/null +++ b/lib/workload_service/aggregates/task_id.ex @@ -0,0 +1,48 @@ +defmodule WorkloadService.Aggregates.TaskId do + @moduledoc """ + Task identifier with org_id, type and task_id. + ID format: "org_id:type:task_id" (e.g., "test:quote:uuid") + """ + + @derive Jason.Encoder + defstruct [:org_id, :type, :task_id] + + def new(org_id, type, task_id) when type in ["quote", "solicitation"] do + %__MODULE__{ + org_id: org_id, + type: type, + task_id: task_id + } + end + + def parse(string) when is_binary(string) do + case String.split(string, ":", parts: 3) do + [org_id, type, task_id] when type in ["quote", "solicitation"] -> + {:ok, new(org_id, type, task_id)} + + _ -> + {:error, :invalid_task_id} + end + end + + def parse!(string) do + case parse(string) do + {:ok, id} -> id + {:error, reason} -> raise ArgumentError, "invalid task id #{inspect(string)}: #{reason}" + end + end + + defimpl String.Chars do + def to_string(%WorkloadService.Aggregates.TaskId{ + org_id: org_id, + type: type, + task_id: task_id + }) do + "#{org_id}:#{type}:#{task_id}" + end + end + + defimpl Commanded.Serialization.JsonDecoder do + def decode(id), do: id + end +end diff --git a/lib/workload_service/application.ex b/lib/workload_service/application.ex new file mode 100644 index 0000000..043c6e9 --- /dev/null +++ b/lib/workload_service/application.ex @@ -0,0 +1,29 @@ +defmodule WorkloadService.Application do + @moduledoc false + + use Application + + @impl true + def start(_type, _args) do + children = [ + WorkloadService.CommandedApp, + WorkloadService.Consumers.QuoteRequestedConsumer, + WorkloadService.Consumers.SolicitationRequestedConsumer, + WorkloadService.Projectors.TaskProjector, + WorkloadService.Repo, + WorkloadServiceWeb.Telemetry, + {DNSCluster, query: Application.get_env(:workload_service, :dns_cluster_query) || :ignore}, + {Phoenix.PubSub, name: WorkloadService.PubSub}, + WorkloadServiceWeb.Endpoint + ] + + opts = [strategy: :one_for_one, name: WorkloadService.Supervisor] + Supervisor.start_link(children, opts) + end + + @impl true + def config_change(changed, _new, removed) do + WorkloadServiceWeb.Endpoint.config_change(changed, removed) + :ok + end +end diff --git a/lib/workload_service/commanded_app.ex b/lib/workload_service/commanded_app.ex new file mode 100644 index 0000000..198d684 --- /dev/null +++ b/lib/workload_service/commanded_app.ex @@ -0,0 +1,32 @@ +defmodule WorkloadService.Router do + use Commanded.Commands.Router + + dispatch( + [ + WorkloadService.Commands.QuoteTask.CreateTask, + WorkloadService.Commands.QuoteTask.SubmitResponse, + WorkloadService.Commands.QuoteTask.ApproveSubmission, + WorkloadService.Commands.QuoteTask.CompleteTask + ], + to: WorkloadService.Aggregates.QuoteTask, + identity: :id + ) + + dispatch( + [ + WorkloadService.Commands.SolicitationTask.CreateTask, + WorkloadService.Commands.SolicitationTask.SubmitResponse, + WorkloadService.Commands.SolicitationTask.ApproveSubmission, + WorkloadService.Commands.SolicitationTask.CompleteTask + ], + to: WorkloadService.Aggregates.SolicitationTask, + identity: :id + ) +end + +defmodule WorkloadService.CommandedApp do + use Commanded.Application, + otp_app: :workload_service + + router(WorkloadService.Router) +end diff --git a/lib/workload_service/commands/quote_task.ex b/lib/workload_service/commands/quote_task.ex new file mode 100644 index 0000000..5f0c3cd --- /dev/null +++ b/lib/workload_service/commands/quote_task.ex @@ -0,0 +1,53 @@ +defmodule WorkloadService.Commands.QuoteTask do + @moduledoc """ + Quote task commands. + """ + + defmodule CreateTask do + @moduledoc """ + Command to create a new quote task. + """ + @derive Jason.Encoder + defstruct [:id, :application_id, :provider_id, :provider_name, :task_info, :attachments] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end + + defmodule SubmitResponse do + @moduledoc """ + Command to submit response for a quote task. + """ + @derive Jason.Encoder + defstruct [:id, :submission, :attachments] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end + + defmodule ApproveSubmission do + @moduledoc """ + Command to approve submission for a quote task. + """ + @derive Jason.Encoder + defstruct [:id] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end + + defmodule CompleteTask do + @moduledoc """ + Command to complete a quote task. + """ + @derive Jason.Encoder + defstruct [:id, :completed_by] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end +end \ No newline at end of file diff --git a/lib/workload_service/commands/solicitation_task.ex b/lib/workload_service/commands/solicitation_task.ex new file mode 100644 index 0000000..bec9233 --- /dev/null +++ b/lib/workload_service/commands/solicitation_task.ex @@ -0,0 +1,53 @@ +defmodule WorkloadService.Commands.SolicitationTask do + @moduledoc """ + Solicitation task commands. + """ + + defmodule CreateTask do + @moduledoc """ + Command to create a new solicitation task. + """ + @derive Jason.Encoder + defstruct [:id, :application_id, :provider_id, :provider_name, :task_info, :attachments] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end + + defmodule SubmitResponse do + @moduledoc """ + Command to submit response for a solicitation task. + """ + @derive Jason.Encoder + defstruct [:id, :submission, :attachments] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end + + defmodule ApproveSubmission do + @moduledoc """ + Command to approve submission for a solicitation task. + """ + @derive Jason.Encoder + defstruct [:id] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end + + defmodule CompleteTask do + @moduledoc """ + Command to complete a solicitation task. + """ + @derive Jason.Encoder + defstruct [:id, :completed_by] + + def new(attrs) do + struct(__MODULE__, attrs) + end + end +end \ No newline at end of file diff --git a/lib/workload_service/consumers/quote_requested_consumer.ex b/lib/workload_service/consumers/quote_requested_consumer.ex new file mode 100644 index 0000000..79f91fe --- /dev/null +++ b/lib/workload_service/consumers/quote_requested_consumer.ex @@ -0,0 +1,93 @@ +defmodule WorkloadService.Consumers.QuoteRequestedConsumer do + use GenServer + require Logger + + alias WorkloadService.CommandedApp + alias WorkloadService.Commands.QuoteTask + + @exchange "workload_service.events.quote_requested" + @queue "workload_service.quote_requested" + @routing_key "quote.requested" + + def start_link(opts \\ []) do + GenServer.start_link(__MODULE__, opts, name: __MODULE__) + end + + def init(_opts) do + {:ok, conn} = AMQP.Connection.open(amqp_url()) + {:ok, channel} = AMQP.Channel.open(conn) + + AMQP.Queue.declare(channel, @queue, durable: true) + AMQP.Queue.bind(channel, @queue, @exchange, routing_key: @routing_key) + {:ok, _tag} = AMQP.Basic.consume(channel, @queue) + + Logger.info("QuoteRequestedConsumer started, listening on #{@queue}") + + {:ok, %{channel: channel}} + end + + def handle_info({:basic_consume_ok, _}, state), do: {:noreply, state} + def handle_info({:basic_cancel, _}, state), do: {:stop, :normal, state} + def handle_info({:basic_cancel_ok, _}, state), do: {:noreply, state} + + def handle_info({:basic_deliver, payload, meta}, state) do + case process(payload) do + :ok -> + AMQP.Basic.ack(state.channel, meta.delivery_tag) + + {:error, reason} -> + Logger.error("QuoteRequestedConsumer: failed to process: #{inspect(reason)}") + AMQP.Basic.reject(state.channel, meta.delivery_tag, requeue: false) + end + + {:noreply, state} + end + + defp process(payload) do + with {:ok, event} <- Jason.decode(payload), + :ok <- handle_event(event) do + :ok + end + end + + defp handle_event(%{ + "application_id" => application_id, + "org_id" => org_id, + "provider_id" => provider_id, + "policy_type" => policy_type + } = event) do + task_id = WorkloadService.Aggregates.TaskId.new(org_id, "quote", Ecto.UUID.generate()) + + command = %QuoteTask.CreateTask{ + id: task_id, + application_id: application_id, + provider_id: provider_id, + provider_name: Map.get(event, "provider_name", ""), + task_info: %{ + "policy_type" => policy_type, + "provider_email" => Map.get(event, "provider_email"), + "applicant_info" => Map.get(event, "applicant_info", %{}), + "car_details" => Map.get(event, "car_details", %{}), + "building_details" => Map.get(event, "building_details", %{}), + "life_details" => Map.get(event, "life_details", %{}) + } + } + + case CommandedApp.dispatch(command) do + :ok -> + Logger.info("QuoteRequestedConsumer: created task #{task_id}") + :ok + + {:error, reason} -> + {:error, reason} + end + end + + defp handle_event(event) do + {:error, {:invalid_event, event}} + end + + defp amqp_url do + Application.get_env(:workload_service, :amqp_url, "amqp://guest:guest@localhost:5672") + end +end \ No newline at end of file diff --git a/lib/workload_service/consumers/solicitation_requested_consumer.ex b/lib/workload_service/consumers/solicitation_requested_consumer.ex new file mode 100644 index 0000000..f645d08 --- /dev/null +++ b/lib/workload_service/consumers/solicitation_requested_consumer.ex @@ -0,0 +1,138 @@ +defmodule WorkloadService.Consumers.SolicitationRequestedConsumer do + use GenServer + require Logger + + alias WorkloadService.CommandedApp + alias WorkloadService.Commands.SolicitationTask + + @exchange "workload_service.events.solicitation_requested" + @queue "workload_service.solicitation_requested" + @routing_key "solicitation.requested" + + @provider_service_url "http://localhost:4002" + @solicitation_service_url "http://localhost:8081" + + def start_link(opts \\ []) do + GenServer.start_link(__MODULE__, opts, name: __MODULE__) + end + + def init(_opts) do + {:ok, conn} = AMQP.Connection.open(amqp_url()) + {:ok, channel} = AMQP.Channel.open(conn) + + AMQP.Queue.declare(channel, @queue, durable: true) + AMQP.Queue.bind(channel, @queue, @exchange, routing_key: @routing_key) + {:ok, _tag} = AMQP.Basic.consume(channel, @queue) + + Logger.info("SolicitationRequestedConsumer started, listening on #{@queue}") + + {:ok, %{channel: channel}} + end + + def handle_info({:basic_consume_ok, _}, state), do: {:noreply, state} + def handle_info({:basic_cancel, _}, state), do: {:stop, :normal, state} + def handle_info({:basic_cancel_ok, _}, state), do: {:noreply, state} + + def handle_info({:basic_deliver, payload, meta}, state) do + case process(payload) do + :ok -> + AMQP.Basic.ack(state.channel, meta.delivery_tag) + + {:error, reason} -> + Logger.error("SolicitationRequestedConsumer: failed to process: #{inspect(reason)}") + AMQP.Basic.reject(state.channel, meta.delivery_tag, requeue: false) + end + + {:noreply, state} + end + + defp process(payload) do + with {:ok, event} <- Jason.decode(payload), + {:ok, provider} <- get_provider(event["provider_id"]), + {:ok, template} <- get_active_template(provider, event["policy_type"]), + {:ok, result} <- generate_solicitation(event, template), + :ok <- create_task(event, result) do + :ok + end + end + + defp get_provider(provider_id) do + url = "#{@provider_service_url}/api/v1/providers/#{provider_id}" + + case Req.get(url) do + {:ok, %{status: 200, body: %{"data" => provider}}} -> {:ok, provider} + {:ok, %{status: 404}} -> {:error, :provider_not_found} + {:error, reason} -> {:error, reason} + end + end + + defp get_active_template(provider, policy_type) do + templates = get_in(provider, ["templates", policy_type]) || [] + default_id = get_in(provider, ["default_templates", policy_type]) + + template = + if default_id do + Enum.find(templates, &(&1["template_id"] == default_id)) + else + Enum.find(templates, &(&1["active"] == true)) + end + + case template do + nil -> {:error, :no_active_template} + t -> {:ok, t} + end + end + + defp generate_solicitation(event, template) do + url = "#{@solicitation_service_url}/api/solicitations/generate" + + body = %{ + org_id: event["org_id"], + id: event["id"], + template_document_url: template["document_url"], + fields: event["fields"] || %{} + } + + case Req.post(url, json: body) do + {:ok, %{status: 200, body: result}} -> + {:ok, result} + + {:ok, %{status: status, body: body}} -> + {:error, "solicitation_service returned #{status}: #{inspect(body)}"} + + {:error, reason} -> + {:error, reason} + end + end + + defp create_task(event, result) do + org_id = event["org_id"] + task_id = WorkloadService.Aggregates.TaskId.new(org_id, "solicitation", Ecto.UUID.generate()) + + command = %SolicitationTask.CreateTask{ + id: task_id, + application_id: event["id"], + provider_id: event["provider_id"], + provider_name: event["provider_name"] || "", + task_info: %{ + "quote_id" => event["quote_id"], + "plan_id" => event["plan_id"], + "document_url" => result["document_url"] + }, + attachments: [result["document_url"]] |> Enum.filter(& &1) + } + + case CommandedApp.dispatch(command) do + :ok -> + Logger.info("SolicitationRequestedConsumer: created task #{task_id}") + :ok + + {:error, reason} -> + {:error, reason} + end + end + + defp amqp_url do + Application.get_env(:workload_service, :amqp_url, "amqp://guest:guest@localhost:5672") + end +end \ No newline at end of file diff --git a/lib/workload_service/event_store.ex b/lib/workload_service/event_store.ex new file mode 100644 index 0000000..62c8a5d --- /dev/null +++ b/lib/workload_service/event_store.ex @@ -0,0 +1,3 @@ +defmodule WorkloadService.EventStore do + use EventStore, otp_app: :workload_service +end diff --git a/lib/workload_service/events/task.ex b/lib/workload_service/events/task.ex new file mode 100644 index 0000000..c01a709 --- /dev/null +++ b/lib/workload_service/events/task.ex @@ -0,0 +1,47 @@ +defmodule WorkloadService.Events do + @moduledoc """ + All domain events for the workload service. + """ + + defmodule TaskCreated do + @moduledoc """ + Emitted when a new task is created (quote or solicitation). + ID format: "org_id:type:task_id" (e.g., "test:quote:uuid") - TaskId struct + """ + @derive Jason.Encoder + defstruct [:id, :application_id, :provider_id, :provider_name, :task_info, :attachments] + end + + defmodule SubmissionUpdated do + @moduledoc """ + Emitted when submission is updated (user provides response data). + """ + @derive Jason.Encoder + defstruct [:id, :submission, :attachments] + end + + defmodule SubmissionApproved do + @moduledoc """ + Emitted when submission is approved and ready to send. + """ + @derive Jason.Encoder + defstruct [:id] + end + + defmodule TaskCompleted do + @moduledoc """ + Emitted when task is completed and sent to policy-service. + Triggers RabbitMQ publish. + """ + @derive Jason.Encoder + defstruct [:id, :completed_by] + end + + defmodule QuoteAccepted do + @moduledoc """ + Emitted when a quote is accepted - triggers solicitation generation. + """ + @derive Jason.Encoder + defstruct [:id, :provider_id, :quote_id, :plan_id] + end +end \ No newline at end of file diff --git a/lib/workload_service/message_bus.ex b/lib/workload_service/message_bus.ex new file mode 100644 index 0000000..82772c0 --- /dev/null +++ b/lib/workload_service/message_bus.ex @@ -0,0 +1,86 @@ +defmodule WorkloadService.MessageBus do + @moduledoc false + + use GenServer + require Logger + + alias AMQP.{Connection, Channel, Exchange} + + @reconnect_interval 5_000 + + def start_link(opts \\ []) do + GenServer.start_link(__MODULE__, opts, name: __MODULE__) + end + + def publish(routing_key, payload) when is_binary(payload) do + GenServer.cast(__MODULE__, {:publish, routing_key, payload}) + end + + def publish(routing_key, payload) do + GenServer.cast(__MODULE__, {:publish, routing_key, Jason.encode!(payload)}) + end + + @impl true + def init(_opts) do + send(self(), :connect) + {:ok, %{channel: nil, connection: nil}} + end + + @impl true + def handle_info(:connect, _state) do + case connect() do + {:ok, connection, channel} -> + {:noreply, %{connection: connection, channel: channel}} + + {:error, reason} -> + Logger.error("Failed to connect to RabbitMQ: #{inspect(reason)}") + schedule_reconnect() + {:noreply, %{channel: nil, connection: nil}} + end + end + + @impl true + def handle_info({:DOWN, _, :process, _pid, reason}, _state) do + Logger.error("RabbitMQ connection lost: #{inspect(reason)}") + schedule_reconnect() + {:noreply, %{channel: nil, connection: nil}} + end + + @impl true + def handle_cast({:publish, _routing_key, _payload}, %{channel: nil} = state) do + Logger.warning("RabbitMQ not connected, message dropped") + {:noreply, state} + end + + @impl true + def handle_cast({:publish, routing_key, payload}, %{channel: channel} = state) do + Exchange.direct(channel, exchange_name(), durable: true) + + AMQP.Basic.publish(channel, exchange_name(), routing_key, payload, + content_type: "application/json", + persistent: true + ) + + {:noreply, state} + end + + defp connect do + config = Application.get_env(:workload_service, WorkloadService.MessageBus, []) + + with {:ok, connection} <- Connection.open(config), + {:ok, channel} <- Channel.open(connection) do + Exchange.declare(channel, exchange_name(), :direct, durable: true) + Process.monitor(connection.pid) + {:ok, connection, channel} + end + end + + defp exchange_name do + Application.get_env(:workload_service, WorkloadService.MessageBus, []) + |> Keyword.get(:exchange, "workload_service.events") + end + + defp schedule_reconnect do + Process.send_after(self(), :connect, @reconnect_interval) + end +end diff --git a/lib/workload_service/projections/task.ex b/lib/workload_service/projections/task.ex new file mode 100644 index 0000000..4fda04d --- /dev/null +++ b/lib/workload_service/projections/task.ex @@ -0,0 +1,61 @@ +defmodule WorkloadService.Projections.Task do + @moduledoc """ + Ecto schema for the task read model. + ID format: "org_id:type:task_id" (e.g., "test:quote:uuid") + """ + + use Ecto.Schema + import Ecto.Changeset + + @derive {Flop.Schema, + filterable: [:status, :org_id, :application_id, :provider_id], + sortable: [:inserted_at, :updated_at, :status]} + + @primary_key {:id, :string, []} + schema "tasks" do + field(:org_id, :string) + field(:application_id, :string) + field(:provider_id, :string) + field(:provider_name, :string) + field(:task_info, :map) + field(:submission, :map) + field(:attachments, {:array, :string}) + field(:status, :string) + field(:version, :integer, default: 1) + + timestamps(type: :utc_datetime) + end + + @statuses ["created", "draft", "approved", "completed"] + + def status_changeset(task, attrs) do + task + |> cast(attrs, [:status, :task_info, :submission, :attachments, :updated_at]) + |> validate_inclusion(:status, @statuses) + end + + def create_changeset(task, attrs) do + task + |> cast(attrs, [ + :id, + :org_id, + :application_id, + :provider_id, + :provider_name, + :task_info, + :submission, + :attachments, + :status, + :version + ]) + |> validate_required([ + :id, + :org_id, + :application_id, + :provider_id, + :provider_name, + :status + ]) + |> validate_inclusion(:status, @statuses) + end +end \ No newline at end of file diff --git a/lib/workload_service/projectors/task_projector.ex b/lib/workload_service/projectors/task_projector.ex new file mode 100644 index 0000000..1f288bc --- /dev/null +++ b/lib/workload_service/projectors/task_projector.ex @@ -0,0 +1,61 @@ +defmodule WorkloadService.Projectors.TaskProjector do + use Commanded.Projections.Ecto, + application: WorkloadService.CommandedApp, + repo: WorkloadService.Repo, + name: "TaskProjector" + + alias WorkloadService.Aggregates.TaskId + alias WorkloadService.Events + alias WorkloadService.Projections.Task + import Ecto.Query + + project(%Events.TaskCreated{} = e, _meta, fn multi -> + task_id = TaskId.parse!(to_string(e.id)) + %{org_id: org_id} = task_id + + Ecto.Multi.insert(multi, :task, %Task{ + id: to_string(e.id), + org_id: org_id, + application_id: e.application_id, + provider_id: e.provider_id, + provider_name: e.provider_name, + task_info: e.task_info, + attachments: e.attachments || [], + status: "created" + }) + end) + + project(%Events.SubmissionUpdated{} = e, _meta, fn multi -> + multi + |> Ecto.Multi.run(:fetch, fn repo, _ -> + {:ok, repo.get(Task, to_string(e.id))} + end) + |> Ecto.Multi.update(:task, fn %{fetch: task} -> + Ecto.Changeset.change(task, %{ + status: "draft", + submission: e.submission, + attachments: e.attachments || [] + }) + end) + end) + + project(%Events.SubmissionApproved{} = e, _meta, fn multi -> + multi + |> Ecto.Multi.run(:fetch, fn repo, _ -> + {:ok, repo.get(Task, to_string(e.id))} + end) + |> Ecto.Multi.update(:task, fn %{fetch: task} -> + Ecto.Changeset.change(task, %{status: "approved"}) + end) + end) + + project(%Events.TaskCompleted{} = e, _meta, fn multi -> + multi + |> Ecto.Multi.run(:fetch, fn repo, _ -> + {:ok, repo.get(Task, to_string(e.id))} + end) + |> Ecto.Multi.update(:task, fn %{fetch: task} -> + Ecto.Changeset.change(task, %{status: "completed"}) + end) + end) +end \ No newline at end of file diff --git a/lib/workload_service/release.ex b/lib/workload_service/release.ex new file mode 100644 index 0000000..0ed375f --- /dev/null +++ b/lib/workload_service/release.ex @@ -0,0 +1,37 @@ +defmodule WorkloadService.Release do + @moduledoc """ + Used for executing DB release tasks when run in production without Mix + installed. + """ + @app :workload_service + + def migrate do + load_app() + init_event_store() + + for repo <- repos() do + {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true)) + end + end + + def rollback(repo, version) do + load_app() + {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version)) + end + + defp repos do + Application.fetch_env!(@app, :ecto_repos) + end + + defp load_app do + Application.ensure_all_started(:ssl) + Application.ensure_all_started(:postgrex) + Application.ensure_loaded(@app) + end + + def init_event_store do + config = WorkloadService.EventStore.config() + + :ok = EventStore.Tasks.Init.exec(config, []) + end +end \ No newline at end of file diff --git a/lib/workload_service/repo.ex b/lib/workload_service/repo.ex new file mode 100644 index 0000000..d8008d5 --- /dev/null +++ b/lib/workload_service/repo.ex @@ -0,0 +1,7 @@ +defmodule WorkloadService.Repo do + @moduledoc false + + use Ecto.Repo, + otp_app: :workload_service, + adapter: Ecto.Adapters.Postgres +end diff --git a/lib/workload_service/workload/queries.ex b/lib/workload_service/workload/queries.ex new file mode 100644 index 0000000..b40da92 --- /dev/null +++ b/lib/workload_service/workload/queries.ex @@ -0,0 +1,38 @@ +defmodule WorkloadService.Workload.Queries do + @moduledoc """ + Database query functions for tasks. + """ + + import Ecto.Query + alias WorkloadService.Projections.Task + alias WorkloadService.Repo + + def list_tasks(params \\ %{}) do + base_query() + |> Flop.validate_and_run(params, for: Task) + end + + def list_tasks_by_org(org_id, params \\ %{}) do + base_query() + |> where(org_id: ^org_id) + |> Flop.validate_and_run(params, for: Task) + end + + def get_task_by_id(id) do + case Repo.get(Task, id) do + nil -> {:error, :not_found} + task -> {:ok, task} + end + end + + def get_task_by_org_and_application(org_id, application_id) do + case Repo.get_by(Task, org_id: org_id, application_id: application_id) do + nil -> {:error, :not_found} + task -> {:ok, task} + end + end + + defp base_query do + from(t in Task, as: :task) + end +end diff --git a/lib/workload_service_web.ex b/lib/workload_service_web.ex new file mode 100644 index 0000000..1b6fe60 --- /dev/null +++ b/lib/workload_service_web.ex @@ -0,0 +1,46 @@ +defmodule WorkloadServiceWeb do + @moduledoc """ + The entrypoint for defining your web interface, such as controllers, components, channels, and so on. + + This can be used in your application as: + + use WorkloadServiceWeb, :controller + use WorkloadServiceWeb, :html + + The definitions below will be executed for every controller, + component, etc, so keep them short and clean, focused + on imports, uses and aliases. + + Do NOT define functions inside the quoted expressions + below. Instead, define additional modules and import + those modules here. + """ + + def static_paths, do: ~w(assets fonts images favicon.ico robots.txt) + + def router do + quote do + use Phoenix.Router, helpers: false + + import Plug.Conn + import Phoenix.Controller + end + end + + def controller do + quote do + use Phoenix.Controller, formats: [:json] + + import Plug.Conn + + alias WorkloadServiceWeb.Router.Helpers, as: Routes + end + end + + @doc """ + When used, dispatch to the appropriate controller/live_view/etc. + """ + defmacro __using__(which) when is_atom(which) do + apply(__MODULE__, which, []) + end +end diff --git a/lib/workload_service_web/api_spec.ex b/lib/workload_service_web/api_spec.ex new file mode 100644 index 0000000..f07d121 --- /dev/null +++ b/lib/workload_service_web/api_spec.ex @@ -0,0 +1,20 @@ +defmodule WorkloadServiceWeb.ApiSpec do + alias OpenApiSpex.{Info, OpenApi, Server} + alias WorkloadServiceWeb.Endpoint + @behaviour OpenApi + + @impl OpenApi + def spec do + %OpenApi{ + servers: [ + Server.from_endpoint(Endpoint) + ], + info: %Info{ + title: "Workload Service", + version: "1.0" + }, + paths: OpenApiSpex.Paths.from_router(WorkloadServiceWeb.Router) + } + |> OpenApiSpex.resolve_schema_modules() + end +end diff --git a/lib/workload_service_web/controllers.ex b/lib/workload_service_web/controllers.ex new file mode 100644 index 0000000..5e7cfae --- /dev/null +++ b/lib/workload_service_web/controllers.ex @@ -0,0 +1,3 @@ +defmodule WorkloadServiceWeb.Controllers do + @moduledoc false +end diff --git a/lib/workload_service_web/controllers/fallback_controller.ex b/lib/workload_service_web/controllers/fallback_controller.ex new file mode 100644 index 0000000..a1dc8e9 --- /dev/null +++ b/lib/workload_service_web/controllers/fallback_controller.ex @@ -0,0 +1,28 @@ +defmodule WorkloadServiceWeb.FallbackController do + use WorkloadServiceWeb, :controller + + def call(conn, {:error, :not_found}) do + conn + |> put_status(:not_found) + |> put_view(json: WorkloadServiceWeb.ErrorJSON) + |> render(:"404") + end + + def call(conn, {:error, reason}) when is_atom(reason) do + conn + |> put_status(:unprocessable_entity) + |> json(%{error: Atom.to_string(reason)}) + end + + def call(conn, {:error, %{errors: errors}}) do + conn + |> put_status(:unprocessable_entity) + |> json(%{errors: errors}) + end + + def call(conn, {:error, reason}) do + conn + |> put_status(:unprocessable_entity) + |> json(%{error: inspect(reason)}) + end +end diff --git a/lib/workload_service_web/controllers/health_controller.ex b/lib/workload_service_web/controllers/health_controller.ex new file mode 100644 index 0000000..dd7dd41 --- /dev/null +++ b/lib/workload_service_web/controllers/health_controller.ex @@ -0,0 +1,15 @@ +defmodule WorkloadServiceWeb.HealthController do + use WorkloadServiceWeb, :controller + + def health(conn, _params) do + conn + |> put_status(:ok) + |> json(%{status: "ok"}) + end + + def ready(conn, _params) do + conn + |> put_status(:ok) + |> json(%{status: "ready"}) + end +end \ No newline at end of file diff --git a/lib/workload_service_web/controllers/task_controller.ex b/lib/workload_service_web/controllers/task_controller.ex new file mode 100644 index 0000000..0126dbc --- /dev/null +++ b/lib/workload_service_web/controllers/task_controller.ex @@ -0,0 +1,249 @@ +defmodule WorkloadServiceWeb.TaskController do + use WorkloadServiceWeb, :controller + use OpenApiSpex.ControllerSpecs + + alias WorkloadService.CommandedApp + alias WorkloadService.Workload.Queries + alias WorkloadServiceWeb.Schemas.Task, as: S + + tags(["Tasks"]) + + operation(:list, + summary: "List tasks", + parameters: [ + page: [in: :query, type: :integer, required: false, example: 1], + page_size: [in: :query, type: :integer, required: false, example: 20], + status: [in: :query, type: :string, required: false], + policy_type: [in: :query, type: :string, required: false], + org_id: [in: :query, type: :string, required: false], + application_id: [in: :query, type: :string, required: false], + provider_id: [in: :query, type: :string, required: false] + ], + responses: [ + ok: {"Task list", "application/json", S.TaskListResponse}, + bad_request: {"Invalid params", "application/json", S.ErrorResponse} + ] + ) + + def list(conn, params) do + case Queries.list_tasks(params) do + {:ok, {tasks, meta}} -> + conn + |> put_status(:ok) + |> json(%{ + data: Enum.map(tasks, &task_summary/1), + meta: meta_json(meta) + }) + + {:error, _} -> + conn |> put_status(:bad_request) |> json(%{error: "invalid parameters"}) + end + end + + operation(:show, + summary: "Get task by ID", + parameters: [ + id: [in: :path, type: :string, required: true] + ], + responses: [ + ok: {"Task detail", "application/json", S.TaskDetailResponse}, + not_found: {"Not found", "application/json", S.ErrorResponse} + ] + ) + + def show(conn, %{"id" => id}) do + case Queries.get_task_by_id(id) do + {:error, :not_found} -> + conn |> put_status(:not_found) |> json(%{error: "task not found"}) + + {:ok, task} -> + conn |> put_status(:ok) |> json(%{data: task_detail(task)}) + end + end + + operation(:respond_to_quote, + summary: "Record quote response", + parameters: [ + id: [in: :path, type: :string, required: true] + ], + request_body: {"Quote response", "application/json", S.QuoteResponseRequest, required: true}, + responses: [ + ok: {"Quote response recorded", "application/json", S.TaskDetailResponse}, + not_found: {"Not found", "application/json", S.ErrorResponse}, + unprocessable_entity: {"Error", "application/json", S.ErrorResponse} + ] + ) + + def respond_to_quote(conn, %{"id" => id} = params) do + case Queries.get_task_by_id(id) do + {:error, :not_found} -> + conn |> put_status(:not_found) |> json(%{error: "task not found"}) + + {:ok, %{status: "created"} = _task} -> + command = %WorkloadService.Commands.QuoteTask.SubmitResponse{ + id: id, + submission: %{ + "quote_id" => params["quote_id"], + "plans" => params["plans"], + "valid_until" => params["valid_until"], + "responded_by" => params["responded_by"], + "document_data" => params["document_data"] + }, + attachments: [params["document_url"]] |> Enum.filter(& &1) + } + + case CommandedApp.dispatch(command) do + :ok -> + {:ok, task} = Queries.get_task_by_id(id) + conn |> put_status(:ok) |> json(%{data: task_detail(task)}) + + {:error, reason} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)}) + end + + {:ok, %{status: "draft"} = _task} -> + command = %WorkloadService.Commands.QuoteTask.ApproveSubmission{ + id: id + } + + case CommandedApp.dispatch(command) do + :ok -> + {:ok, task} = Queries.get_task_by_id(id) + conn |> put_status(:ok) |> json(%{data: task_detail(task)}) + + {:error, reason} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)}) + end + + {:ok, %{status: "approved"} = _task} -> + command = %WorkloadService.Commands.QuoteTask.CompleteTask{ + id: id, + completed_by: params["completed_by"] || "system" + } + + case CommandedApp.dispatch(command) do + :ok -> + {:ok, task} = Queries.get_task_by_id(id) + conn |> put_status(:ok) |> json(%{data: task_detail(task)}) + + {:error, reason} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)}) + end + + {:ok, _task} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: "invalid state"}) + end + end + + operation(:confirm_delivery, + summary: "Confirm solicitation delivery", + parameters: [ + id: [in: :path, type: :string, required: true] + ], + request_body: + {"Delivery confirmation", "application/json", S.ConfirmDeliveryRequest, required: false}, + responses: [ + ok: {"Delivery confirmed", "application/json", S.TaskDetailResponse}, + not_found: {"Not found", "application/json", S.ErrorResponse}, + unprocessable_entity: {"Error", "application/json", S.ErrorResponse} + ] + ) + + def confirm_delivery(conn, %{"id" => id} = params) do + case Queries.get_task_by_id(id) do + {:error, :not_found} -> + conn |> put_status(:not_found) |> json(%{error: "task not found"}) + + {:ok, %{status: "created"} = _task} -> + command = %WorkloadService.Commands.SolicitationTask.SubmitResponse{ + id: id, + submission: %{ + "delivery_confirmed_by" => params["delivery_confirmed_by"] || "system" + }, + attachments: [] + } + + case CommandedApp.dispatch(command) do + :ok -> + {:ok, task} = Queries.get_task_by_id(id) + conn |> put_status(:ok) |> json(%{data: task_detail(task)}) + + {:error, reason} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)}) + end + + {:ok, %{status: "draft"} = _task} -> + command = %WorkloadService.Commands.SolicitationTask.ApproveSubmission{ + id: id + } + + case CommandedApp.dispatch(command) do + :ok -> + {:ok, task} = Queries.get_task_by_id(id) + conn |> put_status(:ok) |> json(%{data: task_detail(task)}) + + {:error, reason} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)}) + end + + {:ok, %{status: "approved"} = _task} -> + command = %WorkloadService.Commands.SolicitationTask.CompleteTask{ + id: id, + completed_by: params["completed_by"] || "system" + } + + case CommandedApp.dispatch(command) do + :ok -> + {:ok, task} = Queries.get_task_by_id(id) + conn |> put_status(:ok) |> json(%{data: task_detail(task)}) + + {:error, reason} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: inspect(reason)}) + end + + {:ok, _task} -> + conn |> put_status(:unprocessable_entity) |> json(%{error: "invalid state"}) + end + end + + defp task_summary(t) do + %{ + id: t.id, + org_id: t.org_id, + application_id: t.application_id, + provider_id: t.provider_id, + provider_name: t.provider_name, + task_info: t.task_info, + status: t.status, + created_at: t.inserted_at + } + end + + defp task_detail(t) do + %{ + id: t.id, + org_id: t.org_id, + application_id: t.application_id, + provider_id: t.provider_id, + provider_name: t.provider_name, + task_info: t.task_info, + submission: t.submission, + attachments: t.attachments, + status: t.status, + version: t.version, + created_at: t.inserted_at, + updated_at: t.updated_at + } + end + + defp meta_json(meta) do + %{ + total_count: meta.total_count, + total_pages: meta.total_pages, + current_page: meta.current_page, + page_size: meta.page_size, + has_next: meta.has_next_page?, + has_prev: meta.has_previous_page? + } + end +end \ No newline at end of file diff --git a/lib/workload_service_web/endpoint.ex b/lib/workload_service_web/endpoint.ex new file mode 100644 index 0000000..0e35c37 --- /dev/null +++ b/lib/workload_service_web/endpoint.ex @@ -0,0 +1,33 @@ +defmodule WorkloadServiceWeb.Endpoint do + use Phoenix.Endpoint, otp_app: :workload_service + + @session_options [ + store: :cookie, + key: "_workload_service_key", + signing_salt: "workload_salt", + same_site: "Lax" + ] + + plug Plug.Static, + at: "/", + from: :workload_service, + gzip: false, + only: WorkloadServiceWeb.static_paths() + + if code_reloading? do + plug Phoenix.CodeReloader + end + + plug Plug.RequestId + plug Plug.Telemetry, event_prefix: [:phoenix, :endpoint] + + plug Plug.Parsers, + parsers: [:urlencoded, :multipart, :json], + pass: ["*/*"], + json_decoder: Phoenix.json_library() + + plug Plug.MethodOverride + plug Plug.Head + plug Plug.Session, @session_options + plug WorkloadServiceWeb.Router +end diff --git a/lib/workload_service_web/error_json.ex b/lib/workload_service_web/error_json.ex new file mode 100644 index 0000000..bb257ba --- /dev/null +++ b/lib/workload_service_web/error_json.ex @@ -0,0 +1,5 @@ +defmodule WorkloadServiceWeb.ErrorJSON do + def render(template, _assigns) do + %{errors: %{detail: Phoenix.Controller.status_message_from_template(template)}} + end +end diff --git a/lib/workload_service_web/router.ex b/lib/workload_service_web/router.ex new file mode 100644 index 0000000..f6fc3b9 --- /dev/null +++ b/lib/workload_service_web/router.ex @@ -0,0 +1,32 @@ +defmodule WorkloadServiceWeb.Router do + use WorkloadServiceWeb, :router + + alias WorkloadServiceWeb.TaskController + alias WorkloadServiceWeb.HealthController + + pipeline :api do + plug OpenApiSpex.Plug.PutApiSpec, module: WorkloadServiceWeb.ApiSpec + end + + scope "/api" do + pipe_through [:api] + + get "/health", HealthController, :health + get "/health/ready", HealthController, :ready + + get "/openapi", OpenApiSpex.Plug.RenderSpec, [] + + scope "/v1" do + get "/tasks", TaskController, :list + get "/tasks/:id", TaskController, :show + post "/tasks/:id/respond-quote", TaskController, :respond_to_quote + post "/tasks/:id/confirm-delivery", TaskController, :confirm_delivery + end + end + + if Mix.env() == :dev do + scope "/swaggerui" do + get "/", OpenApiSpex.Plug.SwaggerUI, path: "/api/openapi" + end + end +end diff --git a/lib/workload_service_web/schemas/task.ex b/lib/workload_service_web/schemas/task.ex new file mode 100644 index 0000000..f98db2d --- /dev/null +++ b/lib/workload_service_web/schemas/task.ex @@ -0,0 +1,146 @@ +defmodule WorkloadServiceWeb.Schemas.Task do + alias OpenApiSpex.Schema + + defmodule PaginationMeta do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "PaginationMeta", + type: :object, + properties: %{ + total_count: %Schema{type: :integer}, + total_pages: %Schema{type: :integer}, + current_page: %Schema{type: :integer}, + page_size: %Schema{type: :integer}, + has_next: %Schema{type: :boolean}, + has_prev: %Schema{type: :boolean} + } + }) + end + + defmodule Plan do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "Plan", + type: :object, + properties: %{ + plan_id: %Schema{type: :string}, + plan_name: %Schema{type: :string}, + premium: %Schema{type: :number}, + coverage_details: %Schema{type: :string}, + deductible: %Schema{type: :number, nullable: true}, + coverage_limit: %Schema{type: :number, nullable: true} + } + }) + end + + defmodule TaskSummary do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "TaskSummary", + type: :object, + properties: %{ + id: %Schema{type: :string}, + org_id: %Schema{type: :string}, + application_id: %Schema{type: :string}, + provider_id: %Schema{type: :string}, + provider_name: %Schema{type: :string}, + task_info: %Schema{type: :object}, + status: %Schema{type: :string, enum: ["created", "draft", "approved", "completed"]}, + created_at: %Schema{type: :string, format: :"date-time"} + } + }) + end + + defmodule TaskDetail do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "TaskDetail", + type: :object, + properties: %{ + id: %Schema{type: :string}, + org_id: %Schema{type: :string}, + application_id: %Schema{type: :string}, + provider_id: %Schema{type: :string}, + provider_name: %Schema{type: :string}, + task_info: %Schema{type: :object}, + submission: %Schema{type: :object, nullable: true}, + attachments: %Schema{type: :array, items: %Schema{type: :string}}, + status: %Schema{type: :string, enum: ["created", "draft", "approved", "completed"]}, + version: %Schema{type: :integer}, + created_at: %Schema{type: :string, format: :"date-time"}, + updated_at: %Schema{type: :string, format: :"date-time"} + } + }) + end + + defmodule QuoteResponseRequest do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "QuoteResponseRequest", + type: :object, + required: [:quote_id, :document_url], + properties: %{ + quote_id: %Schema{type: :string}, + plans: %Schema{type: :array, items: Plan}, + valid_until: %Schema{type: :string, format: :date}, + responded_by: %Schema{type: :string}, + document_url: %Schema{type: :string}, + document_data: %Schema{type: :object, additionalProperties: true} + } + }) + end + + defmodule ConfirmDeliveryRequest do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "ConfirmDeliveryRequest", + type: :object, + properties: %{ + delivery_confirmed_by: %Schema{type: :string} + } + }) + end + + defmodule TaskListResponse do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "TaskListResponse", + type: :object, + properties: %{ + data: %Schema{type: :array, items: TaskSummary}, + meta: PaginationMeta + } + }) + end + + defmodule TaskDetailResponse do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "TaskDetailResponse", + type: :object, + properties: %{ + data: TaskDetail + } + }) + end + + defmodule ErrorResponse do + require OpenApiSpex + + OpenApiSpex.schema(%{ + title: "ErrorResponse", + type: :object, + properties: %{ + error: %Schema{type: :string} + } + }) + end +end \ No newline at end of file diff --git a/lib/workload_service_web/telemetry.ex b/lib/workload_service_web/telemetry.ex new file mode 100644 index 0000000..5f781c1 --- /dev/null +++ b/lib/workload_service_web/telemetry.ex @@ -0,0 +1,51 @@ +defmodule WorkloadServiceWeb.Telemetry do + use Supervisor + import Telemetry.Metrics + + def start_link(arg) do + Supervisor.start_link(__MODULE__, arg, name: __MODULE__) + end + + @impl true + def init(_arg) do + children = [ + {:telemetry_poller, measurements: periodic_measurements(), period: 10_000} + ] + + Supervisor.init(children, strategy: :one_for_one) + end + + def metrics do + [ + summary("phoenix.endpoint.start.system_time", + unit: {:native, :millisecond} + ), + summary("phoenix.endpoint.stop.duration", + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.start.system_time", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.exception.duration", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("phoenix.router_dispatch.stop.duration", + tags: [:route], + unit: {:native, :millisecond} + ), + summary("workload_service.repo.query.total_time", + unit: {:native, :millisecond} + ), + summary("vm.memory.total", unit: {:byte, :kilobyte}), + summary("vm.total_run_queue_lengths.total"), + summary("vm.total_run_queue_lengths.cpu"), + summary("vm.total_run_queue_lengths.io") + ] + end + + defp periodic_measurements do + [] + end +end diff --git a/mix.exs b/mix.exs new file mode 100644 index 0000000..ab040c3 --- /dev/null +++ b/mix.exs @@ -0,0 +1,59 @@ +defmodule WorkloadService.MixProject do + use Mix.Project + + def project do + [ + app: :workload_service, + version: "1.0.0", + elixir: "~> 1.16", + elixirc_paths: elixirc_paths(Mix.env()), + start_permanent: Mix.env() == :prod, + aliases: aliases(), + deps: deps() + ] + end + + def application do + [ + mod: {WorkloadService.Application, []}, + extra_applications: [:logger, :runtime_tools] + ] + end + + defp elixirc_paths(:test), do: ["lib", "test/support"] + defp elixirc_paths(_), do: ["lib"] + + defp deps do + [ + {:phoenix, "~> 1.7"}, + {:phoenix_ecto, "~> 4.4"}, + {:ecto_sql, "~> 3.11"}, + {:postgrex, ">= 0.0.0"}, + {:phoenix_html, "~> 4.0"}, + {:phoenix_live_reload, "~> 1.2", only: :dev}, + {:telemetry_metrics, "~> 1.0"}, + {:telemetry_poller, "~> 1.0"}, + {:jason, "~> 1.4"}, + {:dns_cluster, "~> 0.1.1"}, + {:bandit, "~> 1.5"}, + {:commanded, "~> 1.4"}, + {:commanded_eventstore_adapter, "~> 1.4"}, + {:commanded_ecto_projections, "~> 1.4"}, + {:eventstore, "~> 1.4"}, + {:open_api_spex, "~> 3.20"}, + {:flop, "~> 0.20"}, + {:amqp, "~> 4.1"}, + {:uuid, "~> 1.1"}, + {:req, "~> 0.5"} + ] + end + + defp aliases do + [ + setup: ["deps.get", "ecto.setup"], + "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"], + "ecto.reset": ["ecto.drop", "ecto.setup"], + test: ["ecto.create --quiet", "ecto.migrate --quiet", "test"] + ] + end +end diff --git a/mix.lock b/mix.lock new file mode 100644 index 0000000..00a73ec --- /dev/null +++ b/mix.lock @@ -0,0 +1,50 @@ +%{ + "amqp": {:hex, :amqp, "4.1.0", "ab993d7a7adb41bc52fc084224441bad34ba04a6ff97fcd4a17f8281ed010ed1", [:mix], [{:amqp_client, "~> 4.0", [hex: :amqp_client, repo: "hexpm", optional: false]}], "hexpm", "360559cb5a4c4a920806a8c281d0418db3a625ce730008c8460749dd9b1cf838"}, + "amqp_client": {:hex, :amqp_client, "4.2.1", "cff0cc13186e57457dc5745f1b3a4127c6857717cb8f5920dc457c84d0ad00a2", [:make, :rebar3], [{:credentials_obfuscation, "3.5.0", [hex: :credentials_obfuscation, repo: "hexpm", optional: false]}, {:rabbit_common, "4.2.1", [hex: :rabbit_common, repo: "hexpm", optional: false]}], "hexpm", "8ae00b055a58500e0557f73d9c0ffe257487131e603f7f84fe72cbfaaf03838a"}, + "backoff": {:hex, :backoff, "1.1.6", "83b72ed2108ba1ee8f7d1c22e0b4a00cfe3593a67dbc792799e8cce9f42f796b", [:rebar3], [], "hexpm", "cf0cfff8995fb20562f822e5cc47d8ccf664c5ecdc26a684cbe85c225f9d7c39"}, + "bandit": {:hex, :bandit, "1.10.4", "02b9734c67c5916a008e7eb7e2ba68aaea6f8177094a5f8d95f1fb99069aac17", [:mix], [{:hpax, "~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}, {:plug, "~> 1.18", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:thousand_island, "~> 1.0", [hex: :thousand_island, repo: "hexpm", optional: false]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "a5faf501042ac1f31d736d9d4a813b3db4ef812e634583b6a457b0928798a51d"}, + "commanded": {:hex, :commanded, "1.4.9", "289bc371943cf082f1161b1560563f5451ca176c967670cccd63fc3988fcd225", [:mix], [{:backoff, "~> 1.1", [hex: :backoff, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_registry, "~> 0.2", [hex: :telemetry_registry, repo: "hexpm", optional: false]}], "hexpm", "a4f49c23041a23687aa10e99f3db7ee3b8ae470bb615b73b9f887b86437263e7"}, + "commanded_ecto_projections": {:hex, :commanded_ecto_projections, "1.4.0", "a1b220577577d5e0aee4c92b2d9bc6de221f9c1ac2ab36932cba15881761332f", [:mix], [{:commanded, "~> 1.4", [hex: :commanded, repo: "hexpm", optional: false]}, {:ecto, "~> 3.11", [hex: :ecto, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.11", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "8919a6173cd8f30fe2f948c2967f9289c7f5fe4eeca7abc67966bfca31f4aa9f"}, + "commanded_eventstore_adapter": {:hex, :commanded_eventstore_adapter, "1.4.2", "4f2d9d9bd8ef7807a5a4c278b4344adddbbbb4d9c86c693872bc85b944be1fe8", [:mix], [{:commanded, "~> 1.4", [hex: :commanded, repo: "hexpm", optional: false]}, {:eventstore, "~> 1.4", [hex: :eventstore, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "26eaa68515e3e73834d769b73bddfea76c3fdcaff085d735c22b82a66ba19b10"}, + "credentials_obfuscation": {:hex, :credentials_obfuscation, "3.5.0", "61e282adfb4439486b3994faaec69543c7ee6cc7e70c6340e8853fd9deaf8219", [:rebar3], [], "hexpm", "843adbe3246861ce0f1a0fa3222f384834eb31defd8d6b9cba7afd2977c957bc"}, + "db_connection": {:hex, :db_connection, "2.9.0", "a6a97c5c958a2d7091a58a9be40caf41ab496b0701d21e1d1abff3fa27a7f371", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "17d502eacaf61829db98facf6f20808ed33da6ccf495354a41e64fe42f9c509c"}, + "decimal": {:hex, :decimal, "2.3.0", "3ad6255aa77b4a3c4f818171b12d237500e63525c2fd056699967a3e7ea20f62", [:mix], [], "hexpm", "a4d66355cb29cb47c3cf30e71329e58361cfcb37c34235ef3bf1d7bf3773aeac"}, + "dns_cluster": {:hex, :dns_cluster, "0.1.3", "0bc20a2c88ed6cc494f2964075c359f8c2d00e1bf25518a6a6c7fd277c9b0c66", [:mix], [], "hexpm", "46cb7c4a1b3e52c7ad4cbe33ca5079fbde4840dedeafca2baf77996c2da1bc33"}, + "ecto": {:hex, :ecto, "3.13.5", "9d4a69700183f33bf97208294768e561f5c7f1ecf417e0fa1006e4a91713a834", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "df9efebf70cf94142739ba357499661ef5dbb559ef902b68ea1f3c1fabce36de"}, + "ecto_sql": {:hex, :ecto_sql, "3.13.5", "2f8282b2ad97bf0f0d3217ea0a6fff320ead9e2f8770f810141189d182dc304e", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.13.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.7", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.19 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "aa36751f4e6a2b56ae79efb0e088042e010ff4935fc8684e74c23b1f49e25fdc"}, + "eventstore": {:hex, :eventstore, "1.4.8", "26778c991cfb078f3906a4267060efc7bb5e5943f69ddb8ae6fb60f07042a66e", [:mix], [{:fsm, "~> 0.3", [hex: :fsm, repo: "hexpm", optional: false]}, {:gen_stage, "~> 1.2", [hex: :gen_stage, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: true]}, {:poolboy, "~> 1.5", [hex: :poolboy, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.17", [hex: :postgrex, repo: "hexpm", optional: false]}], "hexpm", "30c914602fdea8db5992a90ecb1f84068531e764cf0c066be71ff0eec4e3bcb9"}, + "file_system": {:hex, :file_system, "1.1.1", "31864f4685b0148f25bd3fbef2b1228457c0c89024ad67f7a81a3ffbc0bbad3a", [:mix], [], "hexpm", "7a15ff97dfe526aeefb090a7a9d3d03aa907e100e262a0f8f7746b78f8f87a5d"}, + "finch": {:hex, :finch, "0.21.0", "b1c3b2d48af02d0c66d2a9ebfb5622be5c5ecd62937cf79a88a7f98d48a8290c", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.6.2 or ~> 1.7", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "87dc6e169794cb2570f75841a19da99cfde834249568f2a5b121b809588a4377"}, + "flop": {:hex, :flop, "0.26.3", "9bc700b34f96a57e56aaa89b850926356311372556eacd5a1abe0fdd0ea40bf2", [:mix], [{:ecto, "~> 3.11", [hex: :ecto, repo: "hexpm", optional: false]}, {:nimble_options, "~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}], "hexpm", "cd77588229778ac55560c90dfbe15ab6486773f067d6e52db9fa703b8c9a9d2d"}, + "fsm": {:hex, :fsm, "0.3.1", "087aa9b02779a84320dc7a2d8464452b5308e29877921b2bde81cdba32a12390", [:mix], [], "hexpm", "fbf0d53f89e9082b326b0b5828b94b4c549ff9d1452bbfd00b4d1ac082208e96"}, + "gen_stage": {:hex, :gen_stage, "1.3.2", "7c77e5d1e97de2c6c2f78f306f463bca64bf2f4c3cdd606affc0100b89743b7b", [:mix], [], "hexpm", "0ffae547fa777b3ed889a6b9e1e64566217413d018cabd825f786e843ffe63e7"}, + "hpax": {:hex, :hpax, "1.0.3", "ed67ef51ad4df91e75cc6a1494f851850c0bd98ebc0be6e81b026e765ee535aa", [:mix], [], "hexpm", "8eab6e1cfa8d5918c2ce4ba43588e894af35dbd8e91e6e55c817bca5847df34a"}, + "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"}, + "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"}, + "mint": {:hex, :mint, "1.7.1", "113fdb2b2f3b59e47c7955971854641c61f378549d73e829e1768de90fc1abf1", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "fceba0a4d0f24301ddee3024ae116df1c3f4bb7a563a731f45fdfeb9d39a231b"}, + "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"}, + "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"}, + "open_api_spex": {:hex, :open_api_spex, "3.22.2", "0b3c4f572ee69cb6c936abf426b9d84d8eebd34960871fd77aead746f0d69cb0", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0 or ~> 6.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "0a4fc08472d75e9cfe96e0748c6b1565b3b4398f97bf43fcce41b41b6fd3fb33"}, + "phoenix": {:hex, :phoenix, "1.8.5", "919db335247e6d4891764dc3063415b0d2457641c5f9b3751b5df03d8e20bbcf", [:mix], [{:bandit, "~> 1.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5.3", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "83b2bb125127e02e9f475c8e3e92736325b5b01b0b9b05407bcb4083b7a32485"}, + "phoenix_ecto": {:hex, :phoenix_ecto, "4.7.0", "75c4b9dfb3efdc42aec2bd5f8bccd978aca0651dbcbc7a3f362ea5d9d43153c6", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.1", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "1d75011e4254cb4ddf823e81823a9629559a1be93b4321a6a5f11a5306fbf4cc"}, + "phoenix_html": {:hex, :phoenix_html, "4.3.0", "d3577a5df4b6954cd7890c84d955c470b5310bb49647f0a114a6eeecc850f7ad", [:mix], [], "hexpm", "3eaa290a78bab0f075f791a46a981bbe769d94bc776869f4f3063a14f30497ad"}, + "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.6.2", "b18b0773a1ba77f28c52decbb0f10fd1ac4d3ae5b8632399bbf6986e3b665f62", [:mix], [{:file_system, "~> 0.2.10 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "d1f89c18114c50d394721365ffb428cce24f1c13de0467ffa773e2ff4a30d5b9"}, + "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"}, + "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"}, + "plug": {:hex, :plug, "1.19.1", "09bac17ae7a001a68ae393658aa23c7e38782be5c5c00c80be82901262c394c0", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "560a0017a8f6d5d30146916862aaf9300b7280063651dd7e532b8be168511e62"}, + "plug_crypto": {:hex, :plug_crypto, "2.1.1", "19bda8184399cb24afa10be734f84a16ea0a2bc65054e23a62bb10f06bc89491", [:mix], [], "hexpm", "6470bce6ffe41c8bd497612ffde1a7e4af67f36a15eea5f921af71cf3e11247c"}, + "postgrex": {:hex, :postgrex, "0.22.0", "fb027b58b6eab1f6de5396a2abcdaaeb168f9ed4eccbb594e6ac393b02078cbd", [:mix], [{:db_connection, "~> 2.9", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "a68c4261e299597909e03e6f8ff5a13876f5caadaddd0d23af0d0a61afcc5d84"}, + "rabbit_common": {:hex, :rabbit_common, "4.2.1", "1d64e391e12116b76b1425eb96b7552de51f0301093eba669b5334f4759cc1e8", [:make, :rebar3], [{:credentials_obfuscation, "3.5.0", [hex: :credentials_obfuscation, repo: "hexpm", optional: false]}, {:ranch, "2.2.0", [hex: :ranch, repo: "hexpm", optional: false]}, {:recon, "2.5.6", [hex: :recon, repo: "hexpm", optional: false]}, {:thoas, "1.2.1", [hex: :thoas, repo: "hexpm", optional: false]}], "hexpm", "ff509b07e639b1784898c28031e5204fea14260172e4fc339f94405586037e40"}, + "ranch": {:hex, :ranch, "2.2.0", "25528f82bc8d7c6152c57666ca99ec716510fe0925cb188172f41ce93117b1b0", [:make, :rebar3], [], "hexpm", "fa0b99a1780c80218a4197a59ea8d3bdae32fbff7e88527d7d8a4787eff4f8e7"}, + "recon": {:hex, :recon, "2.5.6", "9052588e83bfedfd9b72e1034532aee2a5369d9d9343b61aeb7fbce761010741", [:mix, :rebar3], [], "hexpm", "96c6799792d735cc0f0fd0f86267e9d351e63339cbe03df9d162010cefc26bb0"}, + "req": {:hex, :req, "0.5.17", "0096ddd5b0ed6f576a03dde4b158a0c727215b15d2795e59e0916c6971066ede", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "0b8bc6ffdfebbc07968e59d3ff96d52f2202d0536f10fef4dc11dc02a2a43e39"}, + "telemetry": {:hex, :telemetry, "1.4.1", "ab6de178e2b29b58e8256b92b382ea3f590a47152ca3651ea857a6cae05ac423", [:rebar3], [], "hexpm", "2172e05a27531d3d31dd9782841065c50dd5c3c7699d95266b2edd54c2dafa1c"}, + "telemetry_metrics": {:hex, :telemetry_metrics, "1.1.0", "5bd5f3b5637e0abea0426b947e3ce5dd304f8b3bc6617039e2b5a008adc02f8f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e7b79e8ddfde70adb6db8a6623d1778ec66401f366e9a8f5dd0955c56bc8ce67"}, + "telemetry_poller": {:hex, :telemetry_poller, "1.3.0", "d5c46420126b5ac2d72bc6580fb4f537d35e851cc0f8dbd571acf6d6e10f5ec7", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "51f18bed7128544a50f75897db9974436ea9bfba560420b646af27a9a9b35211"}, + "telemetry_registry": {:hex, :telemetry_registry, "0.3.2", "701576890320be6428189bff963e865e8f23e0ff3615eade8f78662be0fc003c", [:mix, :rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e7ed191eb1d115a3034af8e1e35e4e63d5348851d556646d46ca3d1b4e16bab9"}, + "thoas": {:hex, :thoas, "1.2.1", "19a25f31177a17e74004d4840f66d791d4298c5738790fa2cc73731eb911f195", [:rebar3], [], "hexpm", "e38697edffd6e91bd12cea41b155115282630075c2a727e7a6b2947f5408b86a"}, + "thousand_island": {:hex, :thousand_island, "1.4.3", "2158209580f633be38d43ec4e3ce0a01079592b9657afff9080d5d8ca149a3af", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6e4ce09b0fd761a58594d02814d40f77daff460c48a7354a15ab353bb998ea0b"}, + "uuid": {:hex, :uuid, "1.1.8", "e22fc04499de0de3ed1116b770c7737779f226ceefa0badb3592e64d5cfb4eb9", [:mix], [], "hexpm", "c790593b4c3b601f5dc2378baae7efaf5b3d73c4c6456ba85759905be792f2ac"}, + "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"}, + "websock_adapter": {:hex, :websock_adapter, "0.5.9", "43dc3ba6d89ef5dec5b1d0a39698436a1e856d000d84bf31a3149862b01a287f", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "5534d5c9adad3c18a0f58a9371220d75a803bf0b9a3d87e6fe072faaeed76a08"}, +} diff --git a/ops/chart/Chart.yaml b/ops/chart/Chart.yaml new file mode 100644 index 0000000..03cf710 --- /dev/null +++ b/ops/chart/Chart.yaml @@ -0,0 +1,14 @@ +apiVersion: v2 +name: workload-service +description: Workload service for quote and solicitation tasks +type: application +version: 0.1.0 +appVersion: "1.0.0" +keywords: + - elixir + - commanded + - cqrs +dependencies: + - name: common + version: "4.6.2" + repository: https://bjw-s-labs.github.io/helm-charts/ diff --git a/ops/chart/templates/common.tpl b/ops/chart/templates/common.tpl new file mode 100644 index 0000000..b70187e --- /dev/null +++ b/ops/chart/templates/common.tpl @@ -0,0 +1,4 @@ +{{/* +Render all resources provided by the common library +*/}} +{{- include "bjw-s.common.loader.all" . -}} diff --git a/ops/chart/values.yaml b/ops/chart/values.yaml new file mode 100644 index 0000000..d2feb4c --- /dev/null +++ b/ops/chart/values.yaml @@ -0,0 +1,247 @@ +controllers: + main: + enabled: true + type: deployment + replicas: 1 + initContainers: + migrate: + image: + repository: gitea.corredorconect.com/software-engineering/workload-service + tag: '{{ $.Chart.AppVersion }}' + command: + - "/bin/workload_service" + args: + - "eval" + - "WorkloadService.Release.migrate" + env: + MIX_ENV: prod + SECRET_KEY_BASE: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-secrets' + key: secretKeyBase + RELEASE_COOKIE: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-secrets' + key: cookie + DATABASE_URL: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-cluster-pg-app' + key: uri + containers: + main: + image: + repository: gitea.corredorconect.com/software-engineering/workload-service + tag: '{{ $.Chart.AppVersion }}' + env: + LOG_LEVEL: debug + MIX_ENV: prod + PORT: "8080" + PHX_HOST: "0.0.0.0" + PHX_SERVER: "true" + RABBITMQ_HOST: + value: "rabbitmq.rabbitmq.svc.cluster.local" + RABBITMQ_VHOST: + value: "application" + RABBITMQ_USERNAME: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-rabbitmq-user-user-credentials' + key: username + RABBITMQ_PASSWORD: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-rabbitmq-user-user-credentials' + key: password + RELEASE_COOKIE: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-secrets' + key: cookie + SECRET_KEY_BASE: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-secrets' + key: secretKeyBase + DATABASE_URL: + valueFrom: + secretKeyRef: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-cluster-pg-app' + key: uri + probes: + liveness: + enabled: true + custom: true + spec: + httpGet: + path: /health + port: 8080 + initialDelaySeconds: 30 + periodSeconds: 10 + readiness: + enabled: true + custom: true + spec: + httpGet: + path: /health/ready + port: 8080 + initialDelaySeconds: 5 + periodSeconds: 5 + resources: + requests: + cpu: 100m + memory: 256Mi + limits: + cpu: 500m + memory: 512Mi + +service: + main: + controller: main + type: ClusterIP + ports: + http: + port: 8080 + protocol: HTTP + +rawResources: + rabbitmq-user: + enabled: true + apiVersion: rabbitmq.com/v1beta1 + kind: User + sufix: rabbitmq-user + spec: + spec: + rabbitmqClusterReference: + name: rabbitmq + namespace: rabbitmq + tags: + - administrator + + rabbitmq-user-permission: + enabled: true + apiVersion: rabbitmq.com/v1beta1 + kind: Permission + sufix: rabbitmq-user-permission + spec: + spec: + rabbitmqClusterReference: + name: rabbitmq + namespace: rabbitmq + vhost: "application" + userReference: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-rabbitmq-user' + permissions: + write: ".*" + configure: ".*" + read: ".*" + + exchange-quote-requested: + enabled: true + apiVersion: rabbitmq.com/v1beta1 + kind: Exchange + suffix: exchange-quote-requested + spec: + spec: + name: workload_service.events.quote_requested + type: topic + durable: true + rabbitmqClusterReference: + name: rabbitmq + namespace: rabbitmq + + exchange-solicitation-requested: + enabled: true + apiVersion: rabbitmq.com/v1beta1 + kind: Exchange + suffix: exchange-solicitation-requested + spec: + spec: + name: workload_service.events.solicitation_requested + type: topic + durable: true + rabbitmqClusterReference: + name: rabbitmq + namespace: rabbitmq + + exchange-task-completed: + enabled: true + apiVersion: rabbitmq.com/v1beta1 + kind: Exchange + suffix: exchange-task-completed + spec: + spec: + name: workload_service.events.task_completed + type: topic + durable: true + rabbitmqClusterReference: + name: rabbitmq + namespace: rabbitmq + + password-generator: + enabled: true + apiVersion: generators.external-secrets.io/v1alpha1 + kind: Password + suffix: password-generator + spec: + spec: + length: 32 + noUpper: false + allowRepeat: true + secretKeys: + - cookie + - secretKeyBase + + external-secret: + enabled: true + apiVersion: external-secrets.io/v1 + kind: ExternalSecret + suffix: secrets + spec: + spec: + refreshInterval: 0s + secretStoreRef: + name: cluster-secrets-store + kind: ClusterSecretStore + target: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-secrets' + creationPolicy: Owner + dataFrom: + - sourceRef: + generatorRef: + apiVersion: generators.external-secrets.io/v1alpha1 + kind: Password + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-password-generator' + + cluster: + enabled: true + apiVersion: postgresql.cnpg.io/v1 + kind: Cluster + suffix: pg + spec: + spec: + description: "PostgreSQL cluster for workload-service" + instances: 1 + bootstrap: + initdb: + database: workload_service + owner: workload_service + storage: + size: 5Gi + + database: + enabled: true + apiVersion: postgresql.cnpg.io/v1 + kind: Database + suffix: database + spec: + spec: + name: workload_service + owner: workload_service + cluster: + name: '{{ include "bjw-s.common.lib.chart.names.fullname" $ }}-cluster-pg' + schemas: + - name: eventstore + owner: workload_service \ No newline at end of file diff --git a/priv/repo/migrations/20240101000001_create_tasks.exs b/priv/repo/migrations/20240101000001_create_tasks.exs new file mode 100644 index 0000000..46c0c23 --- /dev/null +++ b/priv/repo/migrations/20240101000001_create_tasks.exs @@ -0,0 +1,25 @@ +defmodule WorkloadService.Repo.Migrations.CreateTasks do + use Ecto.Migration + + def change do + create table(:tasks, primary_key: false) do + add :id, :string, primary_key: true + add :org_id, :string, null: false + add :application_id, :string, null: false + add :provider_id, :string, null: false + add :provider_name, :string + add :task_info, :map, default: %{} + add :submission, :map + add :attachments, {:array, :string}, default: [] + add :status, :string, null: false, default: "created" + add :version, :integer, default: 1 + + timestamps type: :utc_datetime + end + + create index(:tasks, [:application_id]) + create index(:tasks, [:org_id]) + create index(:tasks, [:provider_id]) + create index(:tasks, [:status]) + end +end \ No newline at end of file diff --git a/priv/repo/migrations/20260413000001_create_projection_versions.exs b/priv/repo/migrations/20260413000001_create_projection_versions.exs new file mode 100644 index 0000000..e891bbe --- /dev/null +++ b/priv/repo/migrations/20260413000001_create_projection_versions.exs @@ -0,0 +1,12 @@ +defmodule WorkloadService.Repo.Migrations.CreateProjectionVersions do + use Ecto.Migration + + def change do + create table(:projection_versions, primary_key: false) do + add(:projection_name, :text, primary_key: true) + add(:last_seen_event_number, :bigint) + + timestamps(type: :naive_datetime_usec) + end + end +end diff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exs new file mode 100644 index 0000000..126b097 --- /dev/null +++ b/priv/repo/seeds.exs @@ -0,0 +1,11 @@ +defmodule WorkloadService.Repo.Seeds do + @moduledoc """ + Seeds for development and testing. + """ + + alias WorkloadService.Repo + + def run do + IO.puts("No seeds defined for workload_service") + end +end diff --git a/rel/overlays/bin/migrate b/rel/overlays/bin/migrate new file mode 100644 index 0000000..a637bcc --- /dev/null +++ b/rel/overlays/bin/migrate @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu + +cd -P -- "$(dirname -- "$0")" +exec ./workload_service eval WorkloadService.Release.migrate diff --git a/rel/overlays/bin/migrate.bat b/rel/overlays/bin/migrate.bat new file mode 100644 index 0000000..19d561f --- /dev/null +++ b/rel/overlays/bin/migrate.bat @@ -0,0 +1 @@ +call "%~dp0\workload_service" eval WorkloadService.Release.migrate diff --git a/rel/overlays/bin/server b/rel/overlays/bin/server new file mode 100644 index 0000000..97337e3 --- /dev/null +++ b/rel/overlays/bin/server @@ -0,0 +1,5 @@ +#!/bin/sh +set -eu + +cd -P -- "$(dirname -- "$0")" +PHX_SERVER=true exec ./workload_service start diff --git a/rel/overlays/bin/server.bat b/rel/overlays/bin/server.bat new file mode 100644 index 0000000..99b79a5 --- /dev/null +++ b/rel/overlays/bin/server.bat @@ -0,0 +1,2 @@ +set PHX_SERVER=true +call "%~dp0\workload_service" start diff --git a/rel/vm.args.eex b/rel/vm.args.eex new file mode 100644 index 0000000..0f30234 --- /dev/null +++ b/rel/vm.args.eex @@ -0,0 +1,38 @@ +## --- memory optimisation (embedded/low-RAM targets) --- + +## disable carrier utilization limit ++MBacul 0 ++MHacul 0 + +## smaller carrier sizes ++MBsmbcs 64 ++MBlmbcs 128 ++MHsmbcs 64 ++MHlmbcs 128 + +## smaller main carrier ++MMscs 20 + +## --- scheduler tuning --- + ++S 1:1 ++SDcpu 1:1 ++SDio 1 + +## --- resource limits --- + ++t 100000 ++P 50000 ++Q 8192 + +## --- general --- + ++c false ++sbwt none ++sbwtdcpu none ++sbwtdio none ++swt very_low ++swtdcpu very_low ++swtdio very_low ++secio false ++K true \ No newline at end of file