hecks 5.0.0 → 7.0.0

data/lib/hecks/projections/command_schema/shape.rb

@@ -0,0 +1,95 @@
+require_relative "../../forms/field_shape"
+
+module Hecks
+  module Projections
+    module CommandSchema
+      # One declared attribute as a JSON Schema, in the same branch order as
+      # `Forms::FieldShape.resolve` so a form and a schema agree about what a field is: a list, a
+      # reference, an `admits:` set, a value object (closed set, money, a single field or a group),
+      # then a primitive.
+      #
+      # A `pattern:` is emitted as authored: the runtime searches it, as JSON Schema does, and the
+      # pattern subset keeps `^` and `$` to text anchors that every engine reads the same way.
+      #
+      # The wire accepts a single-field value object as its bare value or as an object holding the
+      # field, so the schema allows both; a multi-field value object must be an object.
+      module Shape
+        JSON_TYPES = { "String" => "string", "Integer" => "integer", "Float" => "number",
+                       "TrueClass" => "boolean", "FalseClass" => "boolean" }.freeze
+
+        PRIMITIVES = Bluebook::Attribute::PRIMITIVES
+
+        module_function
+
+        # @param attribute [Bluebook::Attribute] a command's attribute
+        # @param aggregate [Bluebook::Aggregate] the aggregate that owns the command
+        # @return [Hash{String => Object}] the property's schema, with its default if it has one
+        def property(attribute, aggregate)
+          schema = scalar(attribute, aggregate)
+          schema = { "type" => "array", "items" => schema } if attribute.list?
+          attribute.default.nil? ? schema : schema.merge("default" => attribute.default)
+        end
+
+        # @return [Hash{String => Object}] an object schema over `attributes`; a field is required
+        #   unless it is optional or has a default the runtime fills
+        def object(attributes, aggregate)
+          { "type"                 => "object",
+            "properties"           => attributes.to_h { |inner| [inner.name.to_s, property(inner, aggregate)] },
+            "required"             => required_names(attributes),
+            "additionalProperties" => false }
+        end
+
+        # @return [Array<String>] the names a payload must carry: not optional, no default to fill
+        def required_names(attributes)
+          required = attributes.reject { |inner| inner.optional? || !inner.default.nil? }
+          required.map { |inner| inner.name.to_s }
+        end
+
+        def scalar(attribute, aggregate)
+          return { "type" => "string", "x-references" => attribute.target_name.to_s } if attribute.reference?
+          return admitted(attribute, aggregate) if attribute.admits
+          return value_object(attribute, aggregate) unless PRIMITIVES.include?(attribute.type)
+
+          primitive(attribute)
+        end
+
+        def primitive(attribute)
+          schema = { "type" => JSON_TYPES.fetch(attribute.type.to_s, "string") }
+          attribute.pattern ? schema.merge("pattern" => attribute.pattern.to_s) : schema
+        end
+
+        def admitted(attribute, aggregate)
+          set = Forms::FieldShape.admitted_set(attribute, aggregate)
+          return primitive(attribute) unless set
+
+          members = enum(set)
+          own = Forms::FieldShape.own_value_object(attribute, aggregate)
+          inner = own && Forms::ValueObjectShape.sole_attribute(own)
+          inner ? bare_or_object(inner.name, members) : members
+        end
+
+        def value_object(attribute, aggregate)
+          shape = Forms::FieldShape.own_value_object(attribute, aggregate)
+          return primitive(attribute) unless shape
+          return bare_or_object(shape.attributes.first.name, enum(shape)) if shape.closed_set?
+
+          inner = Forms::ValueObjectShape.sole_attribute(shape)
+          return bare_or_object(inner.name, property(inner, aggregate)) if inner
+
+          object(shape.attributes, aggregate)
+        end
+
+        # @return [Hash{String => Object}] the closed set's members, by their discriminant
+        def enum(set)
+          { "type" => "string", "enum" => Forms::FieldShape.closed_set_options(set) }
+        end
+
+        # @return [Hash{String => Object}] the bare value, or an object holding it as `field`
+        def bare_or_object(field, schema)
+          { "anyOf" => [schema, { "type" => "object", "properties" => { field.to_s => schema },
+                                  "required" => [field.to_s], "additionalProperties" => false }] }
+        end
+      end
+    end
+  end
+end

data/lib/hecks/projections/command_schema.rb

@@ -0,0 +1,74 @@
+require "json"
+require_relative "../naming"
+require_relative "../projector"
+require_relative "command_schema/shape"
+
+module Hecks
+  module Projections
+    # A JSON Schema (draft 2020-12) for every command's payload, projected from the bluebook's IR:
+    # the facts a caller passes in `with:`. It is the cheap local check a client runs before it
+    # asks the server, and the portable description of what a command takes.
+    #
+    # A schema cannot hold a rule over stored state, so the command's `given`s, `ensures` and
+    # lifecycle `from:` ride along as `x-` annotations (their text, for display), and `x-role` names
+    # who may run it. `Dispatcher#validate` stays the authority on those.
+    #
+    #     Projector.call(:command_schema, bluebook: bluebook)
+    #     # => { "Banking/Account/Open.schema.json" => "{...}", ... }
+    module CommandSchema
+      extend Projector::Target
+
+      projects_as :command_schema, emits: :files
+
+      DIALECT = "https://json-schema.org/draft/2020-12/schema".freeze
+
+      module_function
+
+      # @param bluebook [Bluebook::Declaration] the bluebook being projected
+      # @param options [Hash] unused
+      # @return [Hash{String => String}] each command's schema file by path, entity commands too
+      def call(bluebook:, options: {})
+        bluebook.aggregates.each_with_object({}) do |aggregate, files|
+          commands_of(aggregate, aggregate.hecks_name).each do |path, command|
+            files["#{bluebook.name}/#{path}.schema.json"] = render(document(bluebook, aggregate, path, command))
+          end
+        end
+      end
+
+      # @return [String] the schema as indented JSON ending in a newline
+      def render(schema) = "#{JSON.pretty_generate(schema)}\n"
+
+      # One command's schema.
+      #
+      # @param bluebook [Bluebook::Declaration] the owning bluebook
+      # @param aggregate [Bluebook::Aggregate] the aggregate that owns the command
+      # @param path [String] `Aggregate/Command` or `Aggregate/Entity.Command`
+      # @param command [Bluebook::Command] the command
+      # @return [Hash{String => Object}] the schema
+      def document(bluebook, aggregate, path, command)
+        verb = "#{bluebook.name}::#{path.tr("/", ".")}"
+        head = { "$schema" => DIALECT, "$id" => "#{bluebook.name}/#{path}", "title" => verb,
+                 "description" => command.goal.to_s }.reject { |_, value| value.to_s.empty? }
+        head.merge(Shape.object(command.attributes, aggregate)).merge(annotations(command, verb))
+      end
+
+      # @return [Array<Array(String, Bluebook::Command)>] each command of `aggregate` and its
+      #   entities
+      #   with its path, such as `["Account/Open", command]`
+      def commands_of(aggregate, prefix)
+        own = aggregate.commands.map { |command| ["#{prefix}/#{command.hecks_name}", command] }
+        own + aggregate.entities.flat_map { |entity| commands_of(entity, "#{prefix}/#{entity.hecks_name}") }
+      end
+
+      # What a schema cannot validate, as text for a client to show: the rules over state, the role
+      # and the events. Empty ones are left out.
+      def annotations(command, verb)
+        { "x-verb" => verb, "x-role" => command.role, "x-from" => command.from,
+          "x-givens" => rules(command.givens), "x-ensures" => rules(command.ensures),
+          "x-emits" => Array(command.emits).map(&:to_s) }.reject { |_, value| value.nil? || value == [] }
+      end
+
+      def rules(list) = list.map { |rule| { "description" => rule.description, "canonical" => rule.canonical } }
+    end
+  end
+end

data/lib/hecks/projections/context_map_diagram.rb

@@ -0,0 +1,135 @@
+require_relative "../bluebook/model_check"
+
+module Hecks
+  module Projections
+    # A context map drawn as a Mermaid flowchart in the standard notation (ADR 0135): each edge
+    # runs from the upstream context to the downstream one, with the end marks of Evans's context
+    # map. The declared relationships and the wiring's derived edges are drawn together: a coupling
+    # the map does not declare is dashed and red, a relationship the wiring never uses is grey, and
+    # an attach the map leaves implied (ADR 0155) is dotted and labelled `attaches`.
+    module ContextMapDiagram
+      # The edge label each declared kind is drawn with.
+      LABELS = {
+        customer_supplier:    "U/S → D/C",
+        conformist:           "U → D/CF",
+        anticorruption_layer: "U → D/ACL",
+        open_host:            "U/OHS+PL → D",
+        shared_kernel:        "SK",
+        partnership:          "P"
+      }.freeze
+
+      # What a Mermaid node id cannot hold, so a context named with spaces still draws.
+      NOT_AN_IDENTIFIER = /\W/
+
+      UNDECLARED_STYLE = "stroke:#c00,stroke-width:2px,stroke-dasharray:5".freeze
+      UNUSED_STYLE     = "stroke:#999,color:#999".freeze
+      IMPLIED_STYLE    = "stroke:#678,stroke-dasharray:2".freeze
+
+      module_function
+
+      # @param map [Bluebook::ContextMap, nil] the declared map, or none to draw the wiring alone
+      # @param edges [Array<Hash>] `Projections::ContextRelationships.call`
+      # @return [String] the Mermaid source
+      def call(map:, edges:)
+        map &&= map.implying(edges)
+        links = declared_links(map, edges) + undeclared_links(map, edges)
+        lines = ["flowchart LR", *node_lines(map, edges), *links.map { |link| link[:line] }]
+        lines.concat(style_lines(links))
+        lines.concat(separate_ways_lines(map))
+        lines.join("\n")
+      end
+
+      # The diagram, followed by what holding the wiring to the map finds, one Mermaid comment a
+      # line.
+      # A system with no declared map is drawn from its wiring alone and says so.
+      #
+      # @param map [Bluebook::ContextMap, nil] the declared map
+      # @param edges [Array<Hash>] `Projections::ContextRelationships.call`
+      # @return [String] the Mermaid source and its findings
+      def report(map:, edges:)
+        notes = map ? findings_lines(map, edges) : ["  %% no context map is declared; the wiring is drawn alone"]
+        [call(map: map, edges: edges), *notes].join("\n")
+      end
+
+      # @api private
+      def findings_lines(map, edges)
+        found = Bluebook::ModelCheck.context_map_findings(map, edges)
+        return ["  %% the wiring matches the declared map"] if found.empty?
+
+        found.map { |finding| "  %% #{finding.severity} #{finding.kind} #{finding.subject}: #{finding.message}" }
+      end
+
+      # @api private
+      def declared_links(map, edges)
+        return [] unless map
+
+        map.relationships.map do |relationship|
+          used = edges.any? { |edge| Bluebook::ModelCheck.edge_uses?(edge, relationship) }
+          { line: declared_line(relationship), style: link_style(relationship, used) }
+        end
+      end
+
+      # @api private
+      def link_style(relationship, used)
+        return IMPLIED_STYLE if relationship.implied
+
+        used ? nil : UNUSED_STYLE
+      end
+
+      # @api private
+      def undeclared_links(map, edges)
+        edges.reject { |edge| covered?(map, edge) }.map do |edge|
+          { line: "  #{id(edge[:to])} -. \"#{edge[:kind]}\" .-> #{id(edge[:from])}", style: UNDECLARED_STYLE }
+        end
+      end
+
+      # @api private
+      def covered?(map, edge)
+        map&.relationships&.any? { |relationship| Bluebook::ModelCheck.edge_uses?(edge, relationship) }
+      end
+
+      # @api private
+      def declared_line(relationship)
+        from = id(relationship.upstream)
+        to   = id(relationship.downstream)
+        label = LABELS.fetch(relationship.kind)
+        return "  #{from} -. \"attaches · #{label}\" .-> #{to}" if relationship.implied
+
+        case relationship.kind
+        when :shared_kernel then "  #{from} -- \"#{label}\" --- #{to}"
+        when :partnership   then "  #{from} <-- \"#{label}\" --> #{to}"
+        else "  #{from} -- \"#{label}\" --> #{to}"
+        end
+      end
+
+      # @api private
+      def node_lines(map, edges)
+        teams = (map&.contexts || []).to_h { |context| [context.name.to_s, context.team] }
+        node_names(map, edges).map { |name| "  #{id(name)}[\"#{[name, teams[name]].compact.join("<br/>")}\"]" }
+      end
+
+      # @api private
+      def node_names(map, edges)
+        declared = map ? map.context_names : []
+        (declared + edges.flat_map { |edge| [edge[:from], edge[:to]] }).uniq
+      end
+
+      # Mermaid styles an edge by its position among the links.
+      #
+      # @api private
+      def style_lines(links)
+        links.each_with_index.filter_map do |link, index|
+          "  linkStyle #{index} #{link[:style]}" if link[:style]
+        end
+      end
+
+      # @api private
+      def separate_ways_lines(map)
+        (map&.separate_ways || []).map { |left, right| "  %% separate ways: #{left} | #{right}" }
+      end
+
+      # @api private
+      def id(name) = name.to_s.gsub(NOT_AN_IDENTIFIER, "_")
+    end
+  end
+end

data/lib/hecks/projections/context_relationships.rb

@@ -0,0 +1,125 @@
+require_relative "../naming"
+
+module Hecks
+  module Projections
+    # The relationships between the contexts a registry holds, read off what each one already
+    # declares: an `attaches` is a shared kernel, a policy with `across` is customer/supplier, a
+    # hecksagon `translates` is the anti-corruption layer, and a bare `subscribe` is a listener.
+    #
+    # It reads a whole registry, not one bluebook, so it is a plain module and not a registered
+    # `Projector` target. Each edge points from the context that depends to the one it depends on.
+    module ContextRelationships
+      Edge = Struct.new(:from, :to, :kind, :via) do
+        # @return [Hash{Symbol => String, nil}] the edge as plain data
+        def to_h = { from: from, to: to, kind: kind.to_s, via: via }
+      end
+
+      module_function
+
+      # @param registry [Runtime::Registry] a registry whose bluebooks and hecksagons are loaded
+      # @param owners [Hash{String => Array<String>}, nil] each aggregate name to the contexts that
+      #   declare it across a whole corpus, for a translates whose source is in another registry
+      # @return [Array<Hash>] every edge, ordered by dependent context, dependency and kind
+      def call(registry:, owners: nil)
+        edges(registry, owners).sort_by { |edge| [edge.from, edge.to, edge.kind.to_s, edge.via.to_s] }.map(&:to_h)
+      end
+
+      # @param registry [Runtime::Registry] a registry whose bluebooks and hecksagons are loaded
+      # @return [String] one line per edge, `From --kind--> To (via)`
+      def text(registry:)
+        call(registry: registry).map do |edge|
+          via = edge[:via] ? " (#{edge[:via]})" : ""
+          "#{edge[:from]} --#{edge[:kind]}--> #{edge[:to]}#{via}"
+        end.join("\n")
+      end
+
+      # @api private
+      def edges(registry, owners)
+        found = registry.hecksagons.values.flat_map do |hecksagon|
+          attach_edges(hecksagon) + translate_edges(registry, hecksagon, owners) + subscription_edges(hecksagon)
+        end
+        found += registry.bluebooks.values.flat_map { |bluebook| across_edges(bluebook) }
+        found.uniq.reject { |edge| redundant_subscription?(edge, found) }
+      end
+
+      # A context attaching its own vendored package shares nothing with another context.
+      #
+      # @api private
+      def attach_edges(hecksagon)
+        hecksagon.attachments.filter_map do |attachment|
+          next if attachment.declaration_name.to_s == hecksagon.domain.to_s
+
+          Edge.new(hecksagon.domain.to_s, attachment.declaration_name.to_s, :shared_kernel, nil)
+        end
+      end
+
+      # @api private
+      def across_edges(bluebook)
+        bluebook.policies.select(&:target_domain).map do |policy|
+          Edge.new(bluebook.name.to_s, policy.target_domain.to_s, :customer_supplier, policy.name.to_s)
+        end
+      end
+
+      # @api private
+      def translate_edges(registry, hecksagon, owners)
+        policies = registry.bluebook(hecksagon.domain)&.policies || []
+        hecksagon.translates.filter_map do |name|
+          policy = policies.find { |candidate| candidate.name.to_s == name.to_s }
+          source = policy && source_context(registry, policy, owners)
+          Edge.new(hecksagon.domain.to_s, source, :acl, name.to_s) if source
+        end
+      end
+
+      # A `translates` names the foreign event by its aggregate (`on Thing::ThingFired`), so the
+      # context is whichever loaded bluebook declares that aggregate: one in this registry first,
+      # then the corpus's single owner, and the aggregate's own name when neither is known.
+      #
+      # @api private
+      def source_context(registry, policy, owners)
+        aggregate = Naming.qualifier(policy.on_event)
+        return unless aggregate
+
+        local = declaring_bluebook(registry, aggregate, policy.on_event)
+        (local&.name || sole_owner(owners, aggregate) || aggregate).to_s
+      end
+
+      # Two bluebooks may name an aggregate alike (Deploy's `Tenant` request and Tenancy's `Tenant`
+      # fact), so of those declaring it the one that emits the event is the source: from a command,
+      # or from a port operation that answers or refuses with it.
+      #
+      # @api private
+      def declaring_bluebook(registry, aggregate, event)
+        declaring = registry.bluebooks.values.select { |bluebook| bluebook.aggregate(aggregate) }
+        declaring.find { |bluebook| emits?(bluebook, event) } || declaring.first
+      end
+
+      # @api private
+      def emits?(bluebook, event)
+        emitted = Bluebook::ModelCheck.emitted_events(bluebook).map { |name| Naming.last_segment(name) }
+        emitted.include?(Naming.last_segment(event))
+      end
+
+      # @api private
+      def sole_owner(owners, aggregate)
+        found = Array(owners && owners[aggregate])
+        found.first if found.size == 1
+      end
+
+      # @api private
+      def subscription_edges(hecksagon)
+        hecksagon.subscriptions.filter_map do |subscribed|
+          context = Naming.qualifier(subscribed)
+          Edge.new(hecksagon.domain.to_s, context, :subscription, subscribed) if context
+        end
+      end
+
+      # A subscription that a stronger edge to the same context already explains adds nothing.
+      #
+      # @api private
+      def redundant_subscription?(edge, found)
+        edge.kind == :subscription &&
+          found.any? { |other| other.from == edge.from && other.to == edge.to && other.kind != :subscription }
+      end
+    end
+  end
+end

data/lib/hecks/projections/deploy/box/access.rb

@@ -40,9 +40,9 @@ module Hecks
           # @param plan [Settings::Plan] the resolved settings
           # @return [String] YAML list items, one per prefix, ending in a newline
           def secret_resources(plan)
-            named = [plan.origin_secret, plan.tunnel_service&.token_secret].compact
+            named = [plan.origin_secret].compact
             arns = (plan.secret_prefixes + named).map { |name| name.end_with?("*") ? name : "#{name}-*" }
-            arns.uniq.map { |pattern| "#{" " * 18}- !Sub \"#{SECRET_ARN}#{pattern}\"\n" }.join.chomp
+            secret_items(arns.uniq, 18).chomp
           end
 
           # The statement that lets a production box overwrite the secrets named as writable.
@@ -53,8 +53,7 @@ module Hecks
             return "" if plan.writable_secrets.empty?
 
             arns = plan.writable_secrets.map { |name| name.end_with?("*") ? name : "#{name}-*" }.uniq
-            resources = arns.map { |pattern| "#{" " * 20}- !Sub \"#{SECRET_ARN}#{pattern}\"\n" }.join
-            template("writable-secrets.yaml.tmpl", "RESOURCES" => resources.chomp).chomp
+            template("writable-secrets.yaml.tmpl", "RESOURCES" => secret_items(arns, 20).chomp).chomp
           end
 
           private
@@ -65,6 +64,10 @@ module Hecks
             writes.empty? ? rows : rows + s3_write_rows(writes)
           end
 
+          def secret_items(patterns, indent)
+            patterns.map { |pattern| "#{" " * indent}- !Sub \"#{SECRET_ARN}#{pattern}\"\n" }.join
+          end
+
           def s3_arn(path) = "arn:${AWS::Partition}:s3:::#{path}"
         end
       end

data/lib/hecks/projections/deploy/box/caddy.rb

@@ -27,7 +27,8 @@ module Hecks
           # @return [String] the `handle` blocks for each route, then the default
           def route_blocks(plan)
             routes = plan.routes.each_with_index.map { |route, i| route_block(plan, route, i + 1) }
-            "#{routes.join}handle {\n#{upstream(plan.default.port)}}\n"
+            default = plan.default
+            "#{routes.join}handle {\n#{upstream(default.port)}}\n"
           end
 
           # One upstream. A request that arrives while its container is being replaced

data/lib/hecks/projections/deploy/box/compose.rb

@@ -7,6 +7,9 @@ module Hecks
         # What the box's Compose file is rendered from: the script that renders it and the
         # `services.json` it reads. Mixed into `Box`, which supplies `template`.
         module Compose
+          # An empty JSON object, however the json gem spaced it.
+          EMPTY_OBJECT = /\{\s*\}/
+
           # @param plan [Settings::Plan] the resolved settings
           # @param region [String] the validated region
           # @return [String] the script that renders the Compose file, from `services.json` or from
@@ -31,9 +34,8 @@ module Hecks
             services = plan.containers.to_h { |c| [c.name, service_entry(plan, c)] }
             document = { "services" => services, "origin" => origin_entry(plan) }
             document["task_definition"] = plan.task_definition if plan.task_definition
-            document["tunnel"] = tunnel_entry(plan.tunnel_service) if plan.tunnel_service
             # An empty object prints as `{}` or `{` newline `}`, depending on the json gem.
-            "#{JSON.pretty_generate(document).gsub(/\{\s*\}/, "{}")}\n"
+            "#{JSON.pretty_generate(document).gsub(EMPTY_OBJECT, "{}")}\n"
           end
 
           # A container's entry. With a task definition the image, environment and secrets are read
@@ -50,12 +52,6 @@ module Hecks
               "env" => container.env, "secrets" => container.secrets }
           end
 
-          # @param tunnel [Settings::Tunnel] the declared tunnel service
-          # @return [Hash{String => Object}] its entry in `services.json`
-          def tunnel_entry(tunnel)
-            { "url" => "http://127.0.0.1:#{tunnel.port}", "token_secret" => tunnel.token_secret, "image" => tunnel.image }
-          end
-
           private
 
           def origin_entry(plan)

data/lib/hecks/projections/deploy/box/edge.rb

@@ -23,7 +23,8 @@ module Hecks
           # @param plan [Settings::Plan] the resolved settings, with a `cdn`
           # @return [String] the CloudFront stack
           def edge_yaml(plan)
-            values = { "STACK" => plan.infra_name, "ALIASES" => plan.cdn.aliases.join(","),
+            cdn = plan.cdn
+            values = { "STACK" => plan.infra_name, "ALIASES" => cdn.aliases.join(","),
                        "ORIGIN_HEADER" => plan.origin_header, "ORIGIN_SECRET" => plan.origin_secret }
             template("edge.yaml.tmpl", values)
           end

data/lib/hecks/projections/deploy/box/hosting.rb

@@ -36,8 +36,9 @@ module Hecks
           # @param plan [Settings::Plan] the resolved settings
           # @return [String] the Makefile fragment the box `Makefile` includes
           def hosting_mk(plan)
+            hosting = plan.hosting
             Box.template("hosting.mk.tmpl", "SERVICE"        => plan.containers.first.name,
-                                            "URL"            => plan.hosting.public_url.to_s,
+                                            "URL"            => hosting.public_url.to_s,
                                             "SMOKE_RECIPE"   => Box::SMOKE_RECIPE,
                                             "SERVICE_RECIPE" => service_recipe)
           end
@@ -59,14 +60,15 @@ module Hecks
             args = "service=$(SERVICE) $(if $(EXISTING_TAG),existing_tag=$(EXISTING_TAG)) " \
                    "$(if $(LOCAL_IMAGE),local_image=$(LOCAL_IMAGE))"
             direct = "bash ./deploy-service.sh $(SERVICE)"
-            Box::RollRecipe.call(command: "service_roll.run", args: args, direct: direct)
+            Box::RollRecipe.call(command: "service_roll.run!", args: args, direct: direct)
           end
 
           # @param plan [Settings::Plan] the resolved settings
           # @param region [String] the validated AWS region
           # @return [String] `smoke-after-deploy.sh`
           def smoke_after_deploy_sh(plan, region)
-            image_stack = plan.hosting.stack
+            hosting = plan.hosting
+            image_stack = hosting.stack
             Box.template("smoke-after-deploy.sh.tmpl",
                          "STACK" => plan.infra_name, "SETTINGS" => smoke_constants(plan, region),
                          "SETTLE_CHECKS" => settle_checks(plan),

data/lib/hecks/projections/deploy/box/hosting_parts.rb

@@ -7,11 +7,14 @@ module Hecks
         # The pieces `Hosting` splices into its scripts: the settings each script starts with, the
         # service case arms and the sentences that say what a roll does. Extended onto `Hosting`.
         module HostingParts
+          # The start of every line, where a comment marker goes.
+          LINE_START = /^/
+
           # @param plan [Settings::Plan] the resolved settings
           # @return [String] the sentence that says what the roll puts on the box
           def mode_summary(plan)
             file = plan.task_definition ? "mode-summary-taskdef.tmpl" : "mode-summary-services.tmpl"
-            Box.template(file, {}).gsub(/^/, "# ").chomp
+            Box.template(file, {}).gsub(LINE_START, "# ").chomp
           end
 
           private
@@ -19,8 +22,7 @@ module Hecks
           # @param plan [Settings::Plan] the resolved settings
           # @return [String] the comment lines that list what "settled" means
           def settle_checks(plan)
-            stacks = plan.hosting.stack ? "the box stack and the #{plan.hosting.stack} stack are" : "the box stack is"
-            checks = ["#{stacks} CREATE_COMPLETE or UPDATE_COMPLETE, never rolled back or failed;",
+            checks = ["#{settled_stacks(plan.hosting)} CREATE_COMPLETE or UPDATE_COMPLETE, never rolled back or failed;",
                       "every container and the proxy of the box's Compose project is up and has stayed up;"]
             if plan.task_definition
               checks << "each container runs the image of the task definition it was rolled from (the latest " \
@@ -29,18 +31,22 @@ module Hecks
             checks.map { |line| "#      - #{line}" }.join("\n")
           end
 
+          def settled_stacks(hosting)
+            hosting.stack ? "the box stack and the #{hosting.stack} stack are" : "the box stack is"
+          end
+
           def deploy_constants(plan, region)
-            lines = { "REGION" => region }
-            if plan.task_definition
-              lines["FAMILY"] = plan.task_definition
-              lines["IMAGE_STACK"] = plan.hosting.stack
-            else
-              lines["BOX_STACK"] = plan.box_stack
-              lines["BOX_DIR"] = "/opt/#{plan.infra_name}"
-            end
-            constants(lines)
+            lines = plan.task_definition ? taskdef_constants(plan) : box_constants(plan)
+            constants({ "REGION" => region }.merge(lines))
           end
 
+          def taskdef_constants(plan)
+            hosting = plan.hosting
+            { "FAMILY" => plan.task_definition, "IMAGE_STACK" => hosting.stack }
+          end
+
+          def box_constants(plan) = { "BOX_STACK" => plan.box_stack, "BOX_DIR" => "/opt/#{plan.infra_name}" }
+
           def smoke_constants(plan, region)
             hosting = plan.hosting
             watched = [plan.box_stack, hosting.stack].compact
@@ -80,9 +86,18 @@ module Hecks
               else
                 "ECR_REPOSITORY=#{Shellwords.escape(container.repository)}"
               end
+            setting += build_vars(container) if container.dockerfile
             "    #{Shellwords.escape(container.name)}) #{setting} ;;"
           end
 
+          # The build a service needs before its image is pushed, as `VAR=value` the case arm adds;
+          # only a container that declares a Dockerfile gets them.
+          def build_vars(container)
+            dockerfile = Shellwords.escape(container.dockerfile)
+            context    = Shellwords.escape(container.build_context)
+            " BUILD_DOCKERFILE=#{dockerfile} BUILD_CONTEXT=#{context}"
+          end
+
           def repository_step(plan)
             plan.task_definition ? "#{part("deploy-service.taskdef.part")}\n\n" : ""
           end

data/lib/hecks/projections/deploy/box/logging.rb

@@ -66,7 +66,7 @@ module Hecks
             return { "COMPOSE_LOG_NOTE" => "", **local_log_values } unless plan.cloudwatch_logs?
 
             { "COMPOSE_LOG_NOTE" => COMPOSE_LOG_NOTE, "LOG_DEF" => awslogs_definition(plan, region),
-              "LOG_SERVICE" => "log(#{service})", "LOG_CADDY" => 'log("caddy")', "LOG_TUNNEL" => 'log("cloudflared")' }
+              "LOG_SERVICE" => "log(#{service})", "LOG_CADDY" => 'log("caddy")' }
           end
 
           # The `deploy-box.sh` pieces that stop a roll onto a stack without the log group.
@@ -89,8 +89,7 @@ module Hecks
           end
 
           def local_log_values
-            { "LOG_DEF" => "def log: #{JSON_FILE};", "LOG_SERVICE" => "log", "LOG_CADDY" => "log",
-              "LOG_TUNNEL" => "log" }
+            { "LOG_DEF" => "def log: #{JSON_FILE};", "LOG_SERVICE" => "log", "LOG_CADDY" => "log" }
           end
         end
       end