brut 0.20.2 → 0.21.0.pre.1

data/lib/brut/cli/apps/new/app.rb

@@ -161,6 +161,11 @@ class Brut::CLI::Apps::New::App < Brut::CLI::Commands::BaseCommand
           project_root: base.project_root,
           templates_dir:
         )
+      when "docker-deploy"
+        segments << Brut::CLI::Apps::New::Segments::DockerDeploy.new(
+          project_root: base.project_root,
+          templates_dir:
+        )
       when "demo"
         # handled above
       else
@@ -311,6 +316,11 @@ class Brut::CLI::Apps::New::App < Brut::CLI::Commands::BaseCommand
                      project_root:,
                      templates_dir:
                    )
+                 elsif segment_name == "docker-deploy"
+                   Brut::CLI::Apps::New::Segments::DockerDeploy.new(
+                     project_root:,
+                     templates_dir:
+                   )
                  end
       if !segment
         error "'#{segment_name}' is not a segment. Allowed values: sidekiq, heroku"

data/lib/brut/cli/apps/new/segments/docker_deploy.rb

@@ -0,0 +1,30 @@
+class Brut::CLI::Apps::New::Segments::DockerDeploy < Brut::CLI::Apps::New::Base
+  def self.friendly_name = "Generic Docker-based Deployment"
+  def self.segment_name = "docker-deploy"
+
+  def initialize(project_root:, templates_dir:)
+    @project_root  = project_root
+    @templates_dir = templates_dir / "segments" / "DockerDeploy"
+  end
+
+  def add!
+    operations = copy_files(@templates_dir, @project_root) + 
+                 other_operations
+
+    operations.each do |operation|
+      operation.call
+    end
+  end
+
+  def <=>(other)
+    if self.class == other.class
+      0
+    elsif other.class == Brut::CLI::Apps::New::Segments::Sidekiq
+      # If both docker and sidekiq segments are activated, we want to do heroku first,
+      # since Sidekiq will need to modify it.
+      -1
+    else
+      1
+    end
+  end
+end

data/lib/brut/cli/apps/new/segments/sidekiq.rb

@@ -47,6 +47,10 @@ class Brut::CLI::Apps::New::Segments::Sidekiq < Brut::CLI::Apps::New::Base
       # If both herkou and sidekiq segments are activated, we want to do heroku first,
       # since Sidekiq will need to modify it.
       1
+    elsif other.class == Brut::CLI::Apps::New::Segments::DockerDeploy
+      # If both herkou and sidekiq segments are activated, we want to do heroku first,
+      # since Sidekiq will need to modify it.
+      1
     else
       -1
     end
@@ -146,16 +150,12 @@ SIDEKIQ_BASIC_AUTH_PASSWORD=password
         code: "@sidekiq_segment.boot!"
       ),
       Brut::CLI::Apps::New::Ops::InsertCodeInMethod.new(
-        file: project_root / "deploy" / "docker_config.rb",
-        class_name: "HerokuConfig",
-        method_name: "additional_images",
+        file: project_root / "deploy" / "deploy_config.rb",
+        class_name: "AppDeployConfig",
+        method_name: "additional_processes",
         ignore_if_file_not_found: true,
         code: %{
-{
-  "sidekiq" => {
-    cmd: "bin/run sidekiq",
-  }
-}
+          process_description("worker", [ "bundle", "exec", "bin/run sidekiq" ])
         },
         where: :end
       ),

data/lib/brut/cli/apps/new/segments.rb

@@ -4,5 +4,6 @@ module Brut::CLI::Apps::New
     autoload :Demo, "brut/cli/apps/new/segments/demo"
     autoload :Sidekiq, "brut/cli/apps/new/segments/sidekiq"
     autoload :Heroku, "brut/cli/apps/new/segments/heroku"
+    autoload :DockerDeploy, "brut/cli/apps/new/segments/docker_deploy"
   end
 end

data/lib/brut/cli/commands/base_command.rb

@@ -155,13 +155,16 @@ private
     end
   end
 
-  # Convienience methods to defer to `Brut::CLI::Commands::ExecutionContext#stdout`'s  `puts`.
+  # Convienience method to defer to `Brut::CLI::Commands::ExecutionContext#stdout`'s  `puts`.
   # @!visibility public
   def puts(*args)
     if !options.quiet?
       self.execution_context.stdout.puts(*args)
     end
   end
+
+  # Convienience method to defer to `Brut::CLI::Commands::ExecutionContext#stdout`'s  `print`.
+  # @!visibility public
   def print(*args)
     if !options.quiet?
       self.execution_context.stdout.print(*args)
@@ -190,7 +193,8 @@ private
 
 
   # Runs whatever logic this command exists to execute.  This is the method you must implement, however `#execute` is the public
-  # API and what you should call if you want to programmatically execute a command.
+  # API and what you should call if you want to programmatically execute a command. In other words, **do not
+  # call this method in a test, call `execute` instead**.
   #
   # The default implementation will generate an error, which is suitable for an app or namespace command that require a subcommand.
   #

data/lib/brut/framework/app.rb

@@ -47,12 +47,13 @@ class Brut::Framework::App
   # Note that Brut will record the exception via OpenTelemetry so you should not do this in your handlers.  It
   # would be preferable to instead record an event if you want to have observability from your error handlers.
   #
-  # @param [Class|Integer|Range<Integer>] condition if given this specifies the conditions under which the given
+  # @param [Class|Integer|Range<Integer>|Symbol] condition if given this specifies the conditions under which the given
   #        block will handle the error.  If omitted, this block will handle any error that doesn't have a more
   #        specific handler configured.  Meaning of values:
   #        * A class - this is an exception class that, if caught, triggers the handler
   #        * An integer - this is an HTTP status code that, if returned, triggers the handler
   #        * A range of integers - this is a range of HTTP status codes that, if returned, triggers the handler
+  #        * If the symbol is `:catch_all`, this will be used to handle any error not handled by a more specific handler.
   # @yield [Exception] the block is given two named parameters: `exception:` and `http_status_code:`. Your block
   #        can declare both, either, or none.  Any that are declared will be given values.  At least one
   #        will be non-`nil`, however are encouraged to code defensively inside this block.

data/lib/brut/framework/config.rb

@@ -75,7 +75,10 @@ class Brut::Framework::Config
         Object,
         "Handle to the database",
       ) do |database_url|
-        Sequel.connect(database_url)
+        Sequel.connect(
+          database_url,
+          test: true, #XXX
+        )
       end
 
       c.store_ensured_path(
@@ -438,6 +441,15 @@ class Brut::Framework::Config
         end
       end
 
+      c.store(
+        "webhook_url_path_prefix",
+        String,
+        "The root url path under which Webhooks are placed.",
+        allow_app_override: true
+      ) do
+        "/webhooks"
+      end
+
     end
   end
 end

data/lib/brut/framework/mcp.rb

@@ -232,10 +232,7 @@ class Brut::Framework::MCP
         [
           {
             allow_if: ->(env) { 
-              brut_owned_path = env["brut.owned_path"] 
-              app_allowed = Brut.container.csrf_protector.allowed?(env)
-
-              brut_owned_path || app_allowed
+              Brut.container.csrf_protector.allowed?(env)
             },
             message: message,
           },

data/lib/brut/front_end/csrf_protector.rb

@@ -1,12 +1,16 @@
-# Base for custom logic around CSRF protection.  Brut configures `Rack::Protection::AuthenticityToken` for all requests, and
-# this happens early in the request.  The idea is that no real POST should be missing a CSRF token.  That said, there are times
-# when it must be skipped, such as for webhooks.  In that case, you can extend this class and configure it via
+# Stores logic around what POST requests should require CSRF protection.
+# Brut ideally wants *all* POST requests to require CSRF protection, however
+# sometimes this is not convienient, notably webhooks.  This class includes
+# that logic.
+#
+# You may specify your own implementation via
 # `Brut.container.override("csrf_protector", YourCustomCsrfProtector.new)` in your `App` class' initializer.
 #
 # @example
 #   class CsrfProtector < Brut::FrontEnd::CsrfProtector
 #     def allowed?(env)
-#       !!env["PATH_INFO"].to_s.match?(/^\/webhooks\//)
+#       super(env) ||
+#         !!env["PATH_INFO"].to_s.match?(/^\/api\//)
 #     end
 #   end
 #   # Then, in app.rb
@@ -23,8 +27,8 @@
 #
 class Brut::FrontEnd::CsrfProtector
 
-  # Return true if the request should be allowed without a CSRF token. This implementation returns false.
+  # Return true if the request should be allowed without a CSRF token. This implementation allows webhooks and paths that Brut owns explicitly
   def allowed?(env)
-    false
+    env["brut.webhook"]  || env["brut.owned_path"] 
   end
 end

data/lib/brut/front_end/handlers/instrumentation_handler.rb

@@ -75,7 +75,7 @@ class Brut::FrontEnd::Handlers::InstrumentationHandler < Brut::FrontEnd::Handler
 
     if span.nil? || traceparent.nil?
       SemanticLogger[self.class].info "Missing traceparent or span: #{@http_tracestate}, #{@http_traceparent}"
-      return http_status(400)
+      return http_status(200)
     end
 
     carrier = traceparent.as_carrier

data/lib/brut/front_end/middlewares/annotate_brut_owned_paths.rb

@@ -9,6 +9,8 @@ class Brut::FrontEnd::Middlewares::AnnotateBrutOwnedPaths < Brut::FrontEnd::Midd
     if env["PATH_INFO"] =~ /^\/__brut\//
       Brut.container.instrumentation.add_attributes(prefix: "brut", owned_path: true)
       env["brut.owned_path"] = true
+    elsif env["PATH_INFO"] =~ /^#{Regexp.escape(Brut.container.webhook_url_path_prefix)}\//
+      env["brut.webhook"] = true
     end
     @app.call(env)
   end

data/lib/brut/front_end/routing.rb

@@ -97,6 +97,28 @@ class Brut::FrontEnd::Routing
     route
   end
 
+  def register_webhook(path, method:)
+    path = path.gsub(/^\//,"")
+    full_path = "#{Brut.container.webhook_url_path_prefix}/#{path}"
+
+    if full_path =~ /^#{Regexp.escape(Brut.container.webhook_url_path_prefix)}#{Regexp.escape(Brut.container.webhook_url_path_prefix)}/
+      raise ArgumentError, "webhook '#{path}' should not start with #{Brut.container.webhook_url_path_prefix} - Brut will add that for you"
+    end
+
+    route = begin
+              Route.new(method, full_path)
+            rescue Brut::Framework::Errors::NoClassForPath => ex
+              if Brut.container.project_env.development?
+                MissingPath.new(method,full_path,ex)
+              else
+                raise ex
+              end
+            end
+    @routes << route
+    add_routing_method(route)
+    route
+  end
+
   def route(handler_class)
     route = @routes.detect { |route|
       handler_class_match = route.handler_class.name == handler_class.name

data/lib/brut/instrumentation/open_telemetry.rb

@@ -89,6 +89,11 @@ class Brut::Instrumentation::OpenTelemetry
     )
   end
 
+  # Returns a trace ID for the current request/span.  This is useful if you 
+  # need to connect the current OTel request/trace with another system, such
+  # as error reporting.
+  def current_trace_id = OpenTelemetry::Trace.current_span.context.hex_trace_id
+
 private
 
   class NormalizedAttributes

data/lib/brut/sinatra_helpers.rb

@@ -126,7 +126,7 @@ module Brut::SinatraHelpers
     #
     def form(path)
       route = Brut.container.routing.register_form(path)
-      self.define_handled_route(route, type: :form)
+      self.define_handled_route(route)
     end
 
     # Declare a form action that has no associated form elements.  This is used when you need to use a button to submit to the
@@ -137,7 +137,7 @@ module Brut::SinatraHelpers
     # to make sure there is no form defined.
     def action(path)
       route = Brut.container.routing.register_handler_only(path)
-      self.define_handled_route(route, type: :action)
+      self.define_handled_route(route)
     end
 
     # When you need to respond to a given path/method, but it's not a page nor a form.  For example, webhooks often
@@ -146,12 +146,24 @@ module Brut::SinatraHelpers
     # This will locate a handler class based on the same naming convention as for forms.
     def path(path, method:)
       route = Brut.container.routing.register_path(path, method: Brut::FrontEnd::HttpMethod.new(method))
-      self.define_handled_route(route,type: :generic)
+      self.define_handled_route(route)
+    end
+
+    # Define a webhook, where another server will post data to your app.
+    # This method services two purposes beyond using `path` or `action`:
+    #
+    # 1. It nests `relative_path` under `/webhooks` as a convention for
+    #    where all webhooks should go.
+    # 2. That convention will be used to skip CSRF protection for a POST
+    #    made to this endpoint, since you would not want that for a webhook.
+    def webhook(relative_path, method: :post)
+      route = Brut.container.routing.register_webhook(relative_path, method: Brut::FrontEnd::HttpMethod.new(method))
+      self.define_handled_route(route)
     end
 
   private
 
-    def define_handled_route(original_brut_route,type:)
+    def define_handled_route(original_brut_route)
 
       method = original_brut_route.http_method.to_s.upcase
       path   = original_brut_route.path_template

data/lib/brut/spec_support/cli_command_support.rb

@@ -7,22 +7,62 @@ module Brut::SpecSupport::CLICommandSupport
   # A subclass of {Brut::CLI::Executor} that remembers the commands it was asked to execute, instead of
   # actually executing them.  This allows inspection later to see if expected commands had been run.
   #
-  # This is used by the `have_executed` matcher.
+  # This is used by the `have_executed` matcher.  It also is useful when yielding a block to
+  # `test_execution_context` so that you can configure command line executions to raise errors or
+  # provide specific output.
   class CapturingExecutor < Brut::CLI::Executor
     attr_reader :commands_executed
+    def initialize(...)
+      super
+      @on_commands = {}
+    end
     def system!(*args)
       @commands_executed ||= []
-      if args.length == 1
-        @commands_executed << args[0]
-      else
-        @commands_executed << args
+      command = if args.length == 1
+                  args[0]
+                else
+                  args
+                end
+      @commands_executed << command
+      if @on_commands[command]
+        if @on_commands[command][:raise_error]
+          raise Brut::CLI::SystemExecError.new(command,1)
+        elsif @on_commands[command][:output]
+          output = @on_commands[command][:output]
+          yield(output)
+        end
       end
       nil
     end
+
+    # Configure the behavior of a specific command. This must be called before any 
+    # command line commands are invoked.
+    #
+    # @param [String] command the *exact* command line invocation you want to configure.
+    # @param [false|true] raise_error if true, an execption is raised when this command is executed.
+    # @param [String] output if not-nil, this output is produced by the command.
+    def on_command(command, raise_error: false, output: nil)
+      if raise_error
+        @on_commands[command] = { raise_error: }
+      elsif output
+        @on_commands[command] = { output: }
+      end
+    end
   end
   # Create an ExecutionContext suitable for any command, but which allows
   # manipulating the data as needed for your test, or to access the various IO streams
   # used by the command.
+  # @param [Array<String>] argv the arguments remaining on the command line after parsing
+  # @param [Hash<Symbol|String,String>] options hash of options. The preceding dashes **must be omitted**.  If strings are passed as keys, they are converted to symbols.
+  # @param [Hash<String,String>] env The UNIX environment to use.
+  # @param [StringIO] stdin IO to use as the standard input.
+  # @param [StringIO] stdout IO to use as the standard output. Note that you usually do not want to specify this, as the default is to create a `StringIO` which you can access directly from the returned execution context.
+  # @param [StringIO] stderr IO to use as the standard error. Note that you usually do not want to specify this, as the default is to create a `StringIO` which you can access directly from the returned execution context.
+  # @param [Brut::CLI::Executor] executor executor to use to execute sub commands. Note that you likely
+  # don't want to pass in a value for this. The default is an implementation that captures all the
+  # commands that were executed for your later inspection via the `have_executed` matcher.
+  # @yield [executor] If a block is passed, the executor is yielded to allow for configuration of its behavior.
+  # @yieldparam executor [Brut::CLI::Executor|Brut::SpecSupport::CLICommandSupport::CapturingExecutor] the executor.  If you used the default and did not provide your own, you'll get a `CapturingExecutor` that you can use to configure responses to command line invocations.
   def test_execution_context(
     argv: [],
     options: {},
@@ -31,13 +71,26 @@ module Brut::SpecSupport::CLICommandSupport
     stdout: StringIO.new,
     stderr: StringIO.new,
     executor: :default,
-    logger: :default
+    logger: :default,
+    &block
   )
     logger = if logger == :default
                Brut::CLI::Logger.new(app_name: $0, stdout:, stderr:)
              else
                logger
              end
+    executor = if executor == :default 
+                 CapturingExecutor.new(out: stdout, err: stderr, logger:)
+               else
+                 executor
+               end
+
+    if block
+      block.(executor)
+    end
+    options = options.map { |key,value|
+      [ key.to_sym, value ]
+    }.to_h
     Brut::CLI::Commands::ExecutionContext.new(
       argv:,
       options: Brut::CLI::Options.new({ "log-level": "error" }.merge(options)),
@@ -45,7 +98,7 @@ module Brut::SpecSupport::CLICommandSupport
       stdin:,
       stdout:,
       stderr:,
-      executor: executor == :default ? CapturingExecutor.new(out: stdout, err: stderr, logger:) : executor,
+      executor:
     )
   end
 end

data/lib/brut/spec_support/matchers/have_executed.rb

@@ -1,5 +1,6 @@
 RSpec::Matchers.define :have_executed do |commands|
   match do |execution_context|
+    commands = Array(commands)
     commands.all? { |command|
       if command.kind_of?(Regexp)
         execution_context.executor.commands_executed.any? { it.kind_of?(String) && it.match(command) }
@@ -10,6 +11,7 @@ RSpec::Matchers.define :have_executed do |commands|
   end
 
   failure_message do |execution_context|
+    commands = Array(commands)
     not_executed  = commands.reject { |command|
       if command.kind_of?(Regexp)
         execution_context.executor.commands_executed.any? { it.kind_of?(String) && it.match(command) }

data/lib/brut/version.rb

@@ -1,4 +1,4 @@
 module Brut
   # @!visibility private
-  VERSION = "0.20.2"
+  VERSION = "0.21.0.pre.1"
 end

data/templates/Base/dx/exec

@@ -9,18 +9,22 @@ SCRIPT_DIR=$( cd -- "$( dirname -- "${0}" )" > /dev/null 2>&1 && pwd )
 require_command "docker"
 load_docker_compose_env
 
-usage_description="Execute a command inside the app's container. Any command other than 'bash' will be run with bash -lc. Use -B to just run the command directly."
-usage_args="[-s service] [-B] command"
+usage_description="Execute a command inside the app's container. Any command other than 'bash' will be run with bash -lc. Use -B to just run the command directly. Use -A to avoid ssh-agent."
+usage_args="[-s service] [-B] [-A] command"
 usage_pre="exec.pre"
 usage_on_help "${usage_description}" "${usage_args}" "${usage_pre}" "" "${@}"
 
 SERVICE="${SERVICE_NAME:-${DEFAULT_SERVICE}}"
 INCLUDE_PREFIX_FOR_NON_BASH=true
-while getopts "s:B" opt "${@}"; do
+SSH_AGENT=true
+while getopts "s:AB" opt "${@}"; do
   case ${opt} in
     s )
       SERVICE="${OPTARG}"
       ;;
+    A )
+      SSH_AGENT=false
+      ;;
     B )
       INCLUDE_PREFIX_FOR_NON_BASH=false
       ;;
@@ -53,6 +57,9 @@ elif [ "$INCLUDE_PREFIX_FOR_NON_BASH" = "true" ]; then
 else
   COMMAND=("$@")
 fi
+if [ "$SSH_AGENT" = "true" ]; then
+  COMMAND=(ssh-agent "${COMMAND[@]}")
+fi
 
 log "🚂" "Running '${COMMAND[@]}' inside container with service name '${SERVICE}'"
 

data/templates/segments/DockerDeploy/deploy/Dockerfile

@@ -0,0 +1,126 @@
+# This is a multi-stage build, meaning one image will be built that
+# has necessarily dev tools in it, and that image is used to create artifacts
+# that will be copied into the second build, which will create the image
+# you deploy to production.
+#
+# # Maintaing this file
+#
+# You own this file now.  While there could be a way to create it from
+# the Dockerfile.dx, for now, you'll need to stay on top of it:
+#
+# 1 - ensure the versions of Ruby match
+# 2 - ensure the versions of NodeJS match
+# 3 - ensure that anything you installed in Dockerfile.dx to make 
+#     the app work or to pre-generate assets is set up here as well.
+#     You are advised to make that setup identical.
+#
+# You can test this locally but using the `--platform` flag to `brut deploy deploy`
+# and running a container locally.  You'll need all infrastructure available
+# but it can be done to test things before you deploy. If you need to.
+
+# Use Ruby 3.4 as a base.
+FROM ruby:3.4 AS base
+
+# bin/deploy will inject this value so that your app's GIT SHA1
+# is in the environment in production, thus allowing you to be more
+# sure of what's actually running.
+ARG app_git_sha1
+
+WORKDIR /brut-app
+
+# Install base packages
+#
+# - ca-certificates is needed for other installs 
+# - curl is needed generally for other installs and by Heroku
+# - gnupg is a PGP replacement used in making sure new APT repos work
+# - libjemalloc2 in theory speeds up Ruby
+# - lsb-release is used to generically access information for this OS's version
+# - wget allows us to copy/paste commands from vendors about how to install
+#   software even though it does the same thing as curl
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get update --quiet --yes && \
+    apt-get install --no-install-recommends --quiet --yes \
+      ca-certificates \
+      curl \
+      gnupg \
+      libjemalloc2 \
+      lsb-release \
+      postgresql-common \
+      rsync \
+      wget
+
+# Install the PostgreSQL client.  The latest version is not available
+# from Debian, so we set up our own. This should match what's in Dockerfile.dx
+# and ideally the version of Postgres used in production.
+#
+# Incancation is based on: https://www.postgresql.org/download/linux/debian/
+RUN /usr/share/postgresql-common/pgdg/apt.postgresql.org.sh -y && \
+    apt-get update --quiet --yes && \
+    apt-get --yes --quiet --no-install-recommends install postgresql-client-16 && \
+		rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
+
+# Set basic env vars for production
+ENV RACK_ENV="production" \
+    BUNDLE_DEPLOYMENT="1" \
+    BUNDLE_PATH="/usr/local/bundle" \
+    BUNDLE_WITHOUT="development"
+
+RUN rm -rf /var/lib/apt/lists/* /var/cache/apt/archives/*
+
+# This makes a new image that we'll throw away after building
+# needed artifacts.
+FROM base AS build
+
+# - build-essential is needed for almost any build tool we have to install
+# - git is needed to install some things
+# - libpq-dev is needed by postgres
+# - pkg-config is, I guess, not considered "essential" (as in build-essential),
+#   but still needed to install downstream stuff
+RUN --mount=type=cache,target=/var/cache/apt \
+    apt-get update --quiet --yes && \
+    apt-get install --no-install-recommends --quiet --yes \
+      build-essential \
+      git \
+      libpq-dev \
+      pkg-config
+
+# Copy NodeJS from the official image. This should be faster than
+# installing it via e.g. nvm
+COPY --from=node:22-slim /usr/local /usr/local
+
+# Copy Gemfile only as it may not change between deploys
+COPY Gemfile Gemfile.lock .
+
+# Install RubyGems from app's Gemfile
+RUN --mount=type=cache,target=${BUNDLE_PATH}/cache \
+    bundle install --verbose && \
+    rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git
+
+COPY package.json package-lock.json ./
+# Install Node Modules from package.json
+RUN npm clean-install --no-audit --no-fund --verbose
+
+COPY . .
+
+# Build all assets
+RUN BRUT_DEBUG=true bundle exec brut --log-level=debug build-assets all && \
+    rm -rf node_modules
+
+# We are now switching back to building the image that will be deployed.
+
+FROM base
+# Copy built artifacts from the throwaway image: gems, application
+COPY --from=build "${BUNDLE_PATH}" "${BUNDLE_PATH}"
+COPY --from=build /brut-app /brut-app
+
+# For security, set directories that will be written to be owned by non-root
+RUN groupadd --system --gid 1000 brut && \
+    useradd brut --uid 1000 --gid 1000 --create-home --shell /bin/bash && \
+    chown -R brut:brut logs tmp
+USER 1000:1000
+
+ENV APP_GIT_SHA1="${app_git_sha1}"
+
+# This is used to execute other commands.  When the app is run in production,
+# this script is used to run it.
+ENTRYPOINT ["/brut-app/deploy/docker-entrypoint"]

data/templates/segments/DockerDeploy/deploy/deploy_config.rb

@@ -0,0 +1,17 @@
+# This contains settings for your production Docker setup.
+# You own and maintain this file.  It is `require`d by brut deploy docker
+class AppDeployConfig < Brut::CLI::Apps::Deploy::DeployConfig
+
+  # Return an array of ProcessDescription instances, that you can
+  # create with the `process_description` method.
+  #
+  # For example, if you have the Sidekiq segment installed, `bin/run sidekiq`
+  # runs Sidekiq, so you would implement the method as follows:
+  #
+  #    def additional_processes = [
+  #      process_description("sidekiq", [ "bundle", "exec", "bin/run sidekiq" ]),
+  #    ]
+  #
+  def additional_processes
+  end
+end

data/templates/segments/DockerDeploy/deploy/docker-entrypoint

@@ -0,0 +1,15 @@
+#!/bin/bash -e
+
+# This is the Docker entrypoint, mean this script is used to execute
+# the command given to the RUN directive.
+#
+# The reason this exists is to load jemalloc. If you don't want to use
+# jemalloc, you can delete this script, as well as the ENTRYPOINT directive
+# in deploy/Dockerfile.
+
+# Enable jemalloc for reduced memory usage and latency.
+if [ -z "${LD_PRELOAD+x}" ] && [ -f /usr/lib/*/libjemalloc.so.2 ]; then
+  export LD_PRELOAD="$(echo /usr/lib/*/libjemalloc.so.2)"
+fi
+
+exec "${@}"