brut 0.0.27 → 0.0.29

data/lib/brut/cli/app.rb

@@ -179,7 +179,9 @@ class Brut::CLI::App
 
   # Called after all setup has been executed. Brut will have been started/loaded.  This will *not* be called if anything
   # caused execution to be aborted.
-  def after_bootstrap
+  #
+  # @param [Brut::Framework::App] app Your Brut app.
+  def after_bootstrap(app:)
   end
 
   # Executes the command.  Called by {Brut::CLI::AppRunner}.
@@ -192,6 +194,7 @@ class Brut::CLI::App
     command.set_env_if_needed
     load_env(project_root:)
     command.before_execute
+    app = nil
     bootstrap_result = begin
                          require "#{project_root}/app/bootstrap"
                          bootstrap = Bootstrap.new
@@ -200,6 +203,7 @@ class Brut::CLI::App
                          else
                            bootstrap.bootstrap!
                          end
+                         app = bootstrap.app
                          continue_execution
                        rescue => ex
                          as_execution_result(command.handle_bootstrap_exception(ex))
@@ -207,7 +211,8 @@ class Brut::CLI::App
     if bootstrap_result.stop?
       return bootstrap_result
     end
-    after_bootstrap
+    after_bootstrap(app:)
+    command.after_bootstrap(app:)
     if self.class.configure_only?
       as_execution_result(command.execute)
     else

data/lib/brut/cli/apps/deploy_base.rb

@@ -0,0 +1,86 @@
+require "brut/cli"
+
+class Brut::CLI::Apps::DeployBase < Brut::CLI::App
+  def before_execute
+    ENV["RACK_ENV"] = "production"
+  end
+
+  class GitChecks
+    def initialize(out:, err:, executor:, warn_only: false)
+      @out       = out
+      @err       = err
+      @executor  = executor
+      @warn_only = warn_only
+    end
+
+    def check!
+      require_main_branch!
+      require_no_local_changes!
+      require_pushed_to_main!
+    end
+
+  private
+
+    def require_main_branch!
+      # XXX: This should be put into executor
+      current_branch = `git branch --show-current`.strip.chomp
+
+      if current_branch != "main"
+        @err.puts "You are not on the 'main' branch, but on the '#{current_branch}' branch"
+        @err.puts "You may only deploy from the 'main' branch"
+        if @warn_only
+          @err.puts "Ignoring"
+          return
+        else
+          exit 1
+        end
+      end
+    end
+
+    def require_no_local_changes!
+      @out.puts "Running 'git status' to reset local caches to account for Docker<->host oddities"
+      @executor.system!("git status")
+      local_changes = `git diff-index --name-only HEAD --`
+      if local_changes.strip != ""
+        @err.puts "You have local changes:"
+        local_changes.split(/\n/).each do |change|
+          @err.puts "    #{change}"
+        end
+        @err.puts "Commit these, run bin/ci, then push to origin/main"
+        if @warn_only
+          @err.puts "Ignoring"
+          return
+        else
+          exit 1
+        end
+      end
+    end
+
+    def require_pushed_to_main!
+      # XXX: This should be put into executor
+      git_status = `git rev-list --left-right --count origin/main...main`.strip.chomp
+      remote_ahead, local_ahead = git_status.split(/\t/,2).map(&:to_i)
+
+      if remote_ahead != 0
+        @err.puts "There are commits in origin you don't have. Pull those in, re-run bin/ci, THEN deploy"
+        if @warn_only
+          @err.puts "Ignoring"
+          return
+        else
+          exit 1
+        end
+      end
+
+      if local_ahead != 0
+        @out.puts "You have not pushed to origin. Do that before deploying"
+        if @warn_only
+          @err.puts "Ignoring"
+          return
+        else
+          exit 1
+        end
+      end
+    end
+  end
+end
+

data/lib/brut/cli/apps/heroku_container_based_deploy.rb

@@ -0,0 +1,194 @@
+require "brut/cli"
+class Brut::CLI::Apps::HerokuContainerBasedDeploy < Brut::CLI::Apps::DeployBase
+  description "Deploy to Heroku using containers"
+  default_command :deploy
+  configure_only!
+
+  class Deploy < Brut::CLI::Command
+    description "Build images, push them to Heroku, and deploy them"
+
+    detailed_description %{
+Manages a deploy process based on using Heroku's Container Registry. See
+
+    https://devcenter.heroku.com/articles/container-registry-and-runtime
+
+    for details. You are assumed to understand this.  This command will make the process somewhat easier.
+
+    This will use deploy/Dockerfile as a template to create one Dockerfile for each process you want to run in Heroku.  deploy/heroku_config.rb is where the processes and their commands are configured.
+
+    The release phase is included automatically, based on bin/release.
+}
+
+    opts.on("--platform=PLATFORM","Override default platform. Can be any Docker platform.")
+    opts.on("--[no-]dry-run", "Print the commands that would be run and don't actually do anything. Implies --skip-checks")
+    opts.on("--[no-]skip-checks", "Skip checks for code having been committed and pushed")
+    opts.on("--[no-]deploy", "After images are pushed, actually deploy them")
+    opts.on("--[no-]push", "After images are created, push them to Heroku's registry. If false, implies --no-deploy")
+
+    def after_bootstrap(app:)
+      @app_id       = app.id
+      @organization = app.organization
+    end
+
+    def execute
+      options.set_default(:deploy, true)
+      options.set_default(:push, true)
+      if !options.push?
+        options[:deploy] = false
+      end
+      local_repo_checks = Brut::CLI::Apps::DeployBase::GitChecks.new(
+        out: @out,
+        err: @err,
+        executor: @executor,
+        warn_only: options.skip_checks? || options.dry_run?
+      )
+      if options.dry_run?
+        def system!(*args)
+          out.puts "DRY RUN, NOT EXECUTING '#{args}'"
+        end
+      end
+
+      version = begin
+                  git_guess = %{git rev-parse HEAD}
+                  stdout, stderr, status = Open3.capture3(git_guess)
+                  if status.success?
+                    stdout.strip
+                  else
+                    raise "Attempt to use git via command '#{git_guess}' to figure out the version failed: #{stdout}#{stderr}"
+                  end
+                end
+      short_version = version[0..7]
+
+      platform = options.platform || "linux/amd64"
+      heroku_app_name = @app_id
+
+      out.puts "Reading HerokuConfig:"
+      require_relative Brut.container.project_root / "deploy" / "heroku_config"
+
+      additional_images = HerokuConfig.additional_images.map { |name,config|
+        cmd = config.fetch(:cmd)
+        out.puts "  - #{name} will run #{cmd} in production"
+        image_name = %{#{@organization}/#{@app_id}:#{short_version}-#{name}}
+        [
+          name,
+          {
+            cmd:,
+            image_name:,
+            dockerfile: "deploy/Dockerfile.#{name}",
+            heroku_image_name: "registry.heroku.com/#{heroku_app_name}/#{name}",
+          }
+        ]
+      }.to_h
+
+      images = {
+        "web" => {
+          cmd: "bin/run",
+          image_name: %{#{@organization}/#{@app_id}:#{short_version}-web},
+          dockerfile: "deploy/Dockerfile.web",
+          heroku_image_name: "registry.heroku.com/#{heroku_app_name}/web",
+        },
+        "release" => {
+          cmd: "bin/release",
+          image_name: %{#{@organization}/#{@app_id}:#{short_version}-release},
+          dockerfile: "deploy/Dockerfile.release",
+          heroku_image_name: "registry.heroku.com/#{heroku_app_name}/release",
+        },
+      }.merge(additional_images)
+
+      out.puts "  - release will run bin/release in production"
+
+      local_repo_checks.check!
+require_heroku_login!(options)
+
+      FileUtils.chdir Brut.container.project_root do
+
+        out.puts "Generating Dockerfiles"
+        images.each do |name,metadata|
+          cmd        = metadata.fetch(:cmd)
+          dockerfile = metadata.fetch(:dockerfile)
+
+          out.puts "Creating '#{dockerfile}' for '#{name}' that will use command '#{cmd}'"
+
+          File.open(dockerfile,"w") do |file|
+            file.puts "# DO NOT EDIT - THIS IS GENERATED"
+            file.puts "# To make changes, modifiy deploy/Dockerfile and run #{$0}"
+            file.puts File.read("deploy/Dockerfile")
+            file.puts
+            file.puts "# Added by #{$0}"
+            file.puts %{CMD [ "bundle", "exec", "#{cmd}" ]}
+          end
+        end
+
+        out.puts "Building images"
+        docker_quiet_option = if global_options.log_level != "debug"
+                                "--quiet"
+                              else
+                                ""
+                              end
+        images.each do |name,metadata|
+          image_name = metadata.fetch(:image_name)
+          dockerfile = metadata.fetch(:dockerfile)
+
+
+          out.puts "Creating docker image with name '#{image_name}' and platform '#{platform}'"
+          command = %{docker build #{docker_quiet_option} --build-arg app_git_sha1=#{version} --file #{Brut.container.project_root}/#{dockerfile} --platform #{platform} --tag #{image_name} .}
+          system!(command)
+        end
+
+        out.puts "Taggging images for Heroku"
+        images.each do |name,metadata|
+          image_name        = metadata.fetch(:image_name)
+          heroku_image_name = metadata.fetch(:heroku_image_name)
+
+          out.puts "Tagging '#{image_name}' with '#{heroku_image_name}' for Heroku"
+          command = %{docker tag #{image_name} #{heroku_image_name}}
+          system!(command)
+        end
+
+        if options.push?
+          out.puts "Pushing to Heroku Registry"
+          images.each do |name,metadata|
+            heroku_image_name = metadata.fetch(:heroku_image_name)
+
+            out.puts "Pushing '#{heroku_image_name}'"
+
+            command = %{docker push #{docker_quiet_option} #{heroku_image_name}}
+            system!(command)
+          end
+        else
+          out.puts "Not pushing images"
+        end
+
+        names = images.map(&:first).join(" ")
+        deploy_command = "heroku container:release #{names}"
+        if options.deploy?
+          out.puts "Deploying images to Heroku"
+          system!(deploy_command)
+        else
+          out.puts "Not deploying.  To deploy the images just pushed:"
+          out.puts ""
+          out.puts "  #{deploy_command}"
+        end
+      end
+    end
+  private
+    def require_heroku_login!(options)
+      if system("heroku whoami")
+        out.puts "You are logged in to Heroku"
+      else
+        out.puts "You are not logged into Heroku."
+        out.puts "Please run the following:"
+        out.puts ""
+        out.puts "heroku auth:login"
+        out.puts "heroku container:login"
+        out.puts ""
+        out.puts "Then, re-run this"
+        if options.dry_run?
+          out.puts "Dry run - ignoring"
+          return
+        end
+        exit 1
+      end
+    end
+  end
+end

data/lib/brut/cli/command.rb

@@ -198,6 +198,13 @@ class Brut::CLI::Command
   def before_execute
   end
 
+  # Called after all setup has been executed. Brut will have been started/loaded.
+  # This will *not* be called if anything caused execution to be aborted.
+  #
+  # @param [Brut::Framework::App] app Your Brut app.
+  def after_bootstrap(app:)
+  end
+
   # @!visibility private
   def set_env_if_needed
     if self.class.requires_project_env?
@@ -219,19 +226,6 @@ class Brut::CLI::Command
     raise ex
   end
 
-  # @!visibility private
-  def bootstrap!(project_root:, configure_only:)
-    require "bundler"
-    Bundler.require(:default, ENV["RACK_ENV"].to_sym)
-    if configure_only
-      require "#{project_root}/app/pre_boot"
-      Brut::Framework.new(app: ::App.new)
-    else
-      require "#{project_root}/app/boot"
-    end
-    continue_execution
-  end
-
 private
 
   # @!visibility public

data/lib/brut/cli/executor.rb

@@ -16,14 +16,40 @@ class Brut::CLI::Executor
     @err = err
   end
 
-  # Execute a command, logging it to the standard output and outputing the commands output and error to the standard output and error,
-  # respecitively
+  # Execute a command, logging it to the standard output and outputing the 
+  # commands output and error to the standard output and error, respectively. If 
+  # the command exits nonzero, the exit status is returned.
+  #
+  # Generally, you want to use {#system!} for commands that must succeed
+  # for the caller to continue.  Only use this method if you need 
+  # to do special error-handling when the underlying command fails.
+  #
+  # @see https://docs.ruby-lang.org/en/3.3/Open3.html#method-c-popen3
+  # @see #system!
+  #
+  # @param [String|Array] args Whatever you would give to `Kernel#system` or `Open3.popen3`.
+  # @return [int] 0 if the command completed normally, otherwise the nonzero exit status. **DO NOT TREAT THIS AS A BOOLEAN VALUE**
+  def system(*args)
+    self.system!(*args)
+    0
+  rescue Brut::CLI::SystemExecError => e
+    e.exit_status
+  end
+
+  # Execute a command, logging it to the standard output and outputing the 
+  # commands output and error to the standard output and error, respectively. If 
+  # the command exits nonzero, an exception is raised and your CLI app will
+  # also exit nonzero.
+  #
+  # If you need to handle  the command exiting nonzero, use {#system}
+  # instead, as it will not raise an exception.
   #
   # @see https://docs.ruby-lang.org/en/3.3/Open3.html#method-c-popen3
+  # @see #system
   #
   # @param [String|Array] args Whatever you would give to `Kernel#system` or `Open3.popen3`.
-  # @raise Brut::CLI::Error::SystemExecError if the spawed command exits nonzer
-  # @return [true]
+  # @raise Brut::CLI::Error::SystemExecError if the spawed command exits nonzero
+  # @return [int] Always returns 0
   def system!(*args)
     @out.puts "Executing #{args}"
     wait_thread = Open3.popen3(*args) do |_stdin,stdout,stderr,wait_thread|
@@ -52,6 +78,6 @@ class Brut::CLI::Executor
     else
       raise Brut::CLI::SystemExecError.new(args,wait_thread.value.exitstatus)
     end
-    true
+    0
   end
 end

data/lib/brut/cli/options.rb

@@ -12,6 +12,10 @@ class Brut::CLI::Options
   # Access an options value directly.
   # @param [String] key the key to use. This must be the exact name you used when calling `opts.on` or when creating the `OptionParser` for your app or command. Generally, use the {#method_missing}-provided version instead of this.
   def [](key) = @parsed_options[key]
+
+  def []=(key,value)
+    @parsed_options[key] = value
+  end
   # Check if `key` was provided on the command line.
   # @param [String] key the key to use. This must be the exact name you used when calling `opts.on` or when creating the `OptionParser` for your app or command.
   def key?(key) = @parsed_options.key?(key)

data/lib/brut/cli.rb

@@ -42,9 +42,10 @@ module Brut
     # Holds Brut-provided CLI apps that are set up in your project.
     module Apps
       autoload(:DB,"brut/cli/apps/db")
-      autoload(:DB,"brut/cli/apps/test")
-      autoload(:DB,"brut/cli/apps/build_assets")
-      autoload(:DB,"brut/cli/apps/scaffold")
+      autoload(:Test,"brut/cli/apps/test")
+      autoload(:BuildAssets,"brut/cli/apps/build_assets")
+      autoload(:Scaffold,"brut/cli/apps/scaffold")
+      autoload(:DeployBase,"brut/cli/apps/deploy_base")
     end
   end
 end

data/lib/brut/framework/container.rb

@@ -78,7 +78,7 @@ class Brut::Framework::Container
     self.validate_name!(name:,type:,allow_app_override:)
     if value == :use_block
       derive_with = block
-      @container[name] = { value: nil, derive_with: derive_with }
+      @container[name] = { derive_with: derive_with }
     else
       if type == :boolean
         value = !!value
@@ -111,9 +111,11 @@ class Brut::Framework::Container
       raise ArgumentError,"#{name} does not allow the app to override it"
     end
     if value == :use_block
-      @container[name] = { value: nil, derive_with: block }
+      @container[name][:derive_with] = block
+      @container[name].delete(:value)
     else
-      @container[name] = { value: value }
+      @container[name][:value] = value
+      @container[name].delete(:derive_with)
     end
   end
 
@@ -191,16 +193,16 @@ class Brut::Framework::Container
     # TODO: Provide a cleanr impl and better error checking if things go wrong
     x = @container.fetch(name)
 
-    value = x[:value]
+    has_value = x.key?(:value)
 
-    if !value.nil? || (x[:allow_nil] && value.nil?)
+    if has_value
       handle_path_values(name,x)
-      return value
+      return x[:value]
     end
 
     deriver = x[:derive_with]
     if deriver.nil?
-      raise "Something is seriously wrong. '#{name}' was stored in container without a derive_with value"
+      raise "Something is seriously wrong. '#{name}' was stored in container without a static value, but also without a derive_with key"
     end
 
     parameters = deriver.parameters(lambda: true)
@@ -218,6 +220,22 @@ class Brut::Framework::Container
     handle_path_values(name,x)
     x[:value]
   end
+
+  def reload
+    @container.each do |name, contained_value|
+      if contained_value.key?(:value) && contained_value[:type].to_s == "Class"
+        if contained_value.key?(:derive_with)
+          contained_value.delete(:value)
+        else
+          klass = contained_value[:value]
+          new_klass = klass.name.split(/::/).reduce(Module) { |mod,part|
+            mod.const_get(part)
+          }
+          contained_value[:value] = new_klass
+        end
+      end
+    end
+  end
 private
 
   def handle_path_values(name,contained_value)

data/lib/brut/framework/errors/abstract_method.rb

@@ -2,4 +2,11 @@
 # which methods a subclass is expected to override and for which no default behavior
 # makes sense.
 class Brut::Framework::Errors::AbstractMethod < Brut::Framework::Error
+  def initialize(method_name=nil)
+    if method_name
+      super("The method `#{method_name}` must be implemented")
+    else
+      super("An abstract method must be implemented")
+    end
+  end
 end

data/lib/brut/framework/errors.rb

@@ -27,9 +27,11 @@ module Brut
       # a method that a subclass must implement, but for which there is no useful default
       # implementation.
       #
+      # @param [String|Symbol] method_name name of the method that must be implemented. If omitted, the value is guessed from `caller_locations`
       # @raise [Brut::Framework::Errors::AbstractMethod]
-      def abstract_method!
-        raise Brut::Framework::Errors::AbstractMethod
+      def abstract_method!(method_name=nil)
+        method_name ||= caller_locations(1,1)[0].label
+        raise Brut::Framework::Errors::AbstractMethod.new(method_name)
       end
     end
     # Base class for errors thrown by Brut classes. Generally, Brut will not create its own version