brut 0.16.0 → 0.18.0

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

@@ -0,0 +1,291 @@
+require "brut/cli"
+
+class Brut::CLI::Apps::Deploy < Brut::CLI::Commands::BaseCommand
+  def description = "Deploy your Brut-powered app to production"
+
+  def default_rack_env = nil
+
+  class Heroku < Brut::CLI::Commands::BaseCommand
+    def description = "Deploy to Heroku using container-based deployment"
+    def run
+      version = ""
+      git_guess = %{git rev-parse HEAD}
+      system!(git_guess) do |output|
+        version << output
+      end
+      version.strip!.chomp!
+      if version == ""
+        stderr.puts "Attempt to use git via command '#{git_guess}' to figure out the version failed"
+        return 1
+      end
+      short_version = version[0..7]
+      app_docker_files = AppDockerImages.new(
+        project_root: Brut.container.project_root,
+        organization: Brut.container.organization,
+        app_id: Brut.container.app_id,
+        short_version:
+      )
+      #add  heroku_image_name: "registry.heroku.com/#{heroku_app_name}/web",
+      #stdout.puts "Taggging images for Heroku"
+      #images.each do |name,metadata|
+      #  image_name        = metadata.fetch(:image_name)
+      #  heroku_image_name = metadata.fetch(:heroku_image_name)
+#
+#        stdout.puts "Tagging '#{image_name}' with '#{heroku_image_name}' for Heroku"
+#        command = %{docker tag #{image_name} #{heroku_image_name}}
+#        system!(command)
+#      end
+#
+#      if options.push?
+#        stdout.puts "Pushing to Heroku Registry"
+#        images.each do |name,metadata|
+#          heroku_image_name = metadata.fetch(:heroku_image_name)
+#
+#          stdout.puts "Pushing '#{heroku_image_name}'"
+#
+#          command = %{docker push #{docker_quiet_option} #{heroku_image_name}}
+#          system!(command)
+#        end
+#      else
+#        stdout.puts "Not pushing images"
+#      end
+#
+#      names = images.map(&:first).join(" ")
+#      deploy_command = "heroku container:release #{names} -a #{heroku_app_name}"
+#      if options.deploy?
+#        stdout.puts "Deploying images to Heroku"
+#        system!(deploy_command)
+#      else
+#        stdout.puts "Not deploying.  To deploy the images just pushed:"
+#        stdout.puts ""
+#        stdout.puts "  #{deploy_command}"
+#      end
+#    end
+    end
+  end
+
+  class AppDockerImages
+    attr_reader :docker_config_filename
+    def initialize(organization:, app_id:, project_root:, short_version:)
+      @docker_config_filename = project_root / "deploy" / "docker_config"
+      require_relative @docker_config_filename
+      if ! defined?(DockerConfig)
+        raise "#{@docker_config_filename} did not define the constant `DockerConfig` - it must to provide the configuration values to this script"
+      end
+
+      docker_config = DockerConfig.new
+
+      additional_images = (docker_confir.additional_images || {}).map { |name,config|
+        cmd = config.fetch(:cmd)
+        image_name = %{#{app_organization}/#{app_id}:#{short_version}-#{name}}
+        [
+          name,
+          {
+            cmd:,
+            image_name:,
+            dockerfile: "deploy/Dockerfile.#{name}",
+          },
+        ]
+      }.to_h
+
+      @images = {
+        "web" => {
+          cmd: "bin/run",
+          image_name: %{#{app_organization}/#{app_id}:#{short_version}-web},
+          dockerfile: "deploy/Dockerfile.web",
+        },
+        "release" => {
+          cmd: "bin/run",
+          image_name: %{#{app_organization}/#{app_id}:#{short_version}-web},
+          dockerfile: "deploy/Dockerfile.release",
+        },
+      }.merge(additional_images)
+    end
+
+    def each(&block)
+      if block.parameters.any? { it[0] != :keyreq }
+        raise "block for #{self.class}#each must only contain required keyword parameters"
+      end
+      @images.each do |name,metadata|
+        args = {}
+        block.params.each do |(_,param)|
+          if param == :name
+            args[:name] = name
+          else
+            args[param] = metadata.fetch(param)
+          end
+        end
+        block.(**args)
+      end
+    end
+  end
+
+  class Build < Brut::CLI::Commands::BaseCommand
+    def description = "Build artifacts for deployment"
+
+    class Docker < Brut::CLI::Commands::BaseCommand
+      def description = "Build a series of Docker images from a template Dockerfile"
+      def opts = [
+        [ "--platform=PLATFORM","Override default platform. Can be any Docker platform." ],
+        [ "--dry-run", "Only show what would happen, don't actually do anything" ],
+      ]
+
+      def run
+        version = ""
+        git_guess = %{git rev-parse HEAD}
+        system!(git_guess) do |output|
+          version << output
+        end
+        version.strip!.chomp!
+        if version == ""
+          stderr.puts "Attempt to use git via command '#{git_guess}' to figure out the version failed"
+          return 1
+        end
+        short_version = version[0..7]
+
+        app_docker_images = AppDockerImages.new(
+          project_root: Brut.container.project_root,
+          organization: Brut.container.organization,
+          app_id: Brut.container.app_id,
+          short_version:
+        )
+
+        FileUtils.chdir Brut.container.project_root do
+
+          stdout.puts "Generating Dockerfiles"
+          images.each do |name:, cmd:, dockerfile:|
+
+            stdout.puts "Creating '#{dockerfile}' for '#{name}' that will use command '#{cmd}'"
+
+            if !options.dry_run?
+              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
+          end
+
+          stdout.puts "Building images"
+          docker_quiet_option = if global_options.log_level != "debug"
+                                  "--quiet"
+                                else
+                                  ""
+                                end
+          images.each do |image_name:, dockerfile:|
+            stdout.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} .}
+            if options.dry_run?
+              stdout.puts "Would run '#{command}'"
+            else
+              system!(command)
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class Check < Brut::CLI::Commands::BaseCommand
+
+    def description = "Check that a deploy can be reasonably expected to succeed"
+    def default_command_class = Git
+    def opts = [
+      [ "--[no-]check-branch", "If true, requires that you are on 'main' (default true)" ],
+      [ "--[no-]check-changes", "If true, requires that you have committed all local changes (default true)" ],
+      [ "--[no-]check-push", "If true, requires that you are in sync with origin/main (default true)" ],
+    ]
+
+    class Git < Brut::CLI::Commands::BaseCommand
+      def description = "Perform the check assuming Git is the version-control system"
+      def opts = self.parent_command.opts
+
+      def run
+
+        checks_ignored = 0
+
+        options.set_default(:check_branch,  true)
+        options.set_default(:check_changes, true)
+        options.set_default(:check_push,    true)
+
+        branch = ""
+        system!("git branch --show-current") do |output|
+          branch << output
+        end
+        branch = branch.strip.chomp
+        if branch != "main"
+          stderr.puts "You are not on the 'main' branch, but on '#{branch}'"
+          if options.check_branch?
+            stderr.puts "You may only deploy from main"
+            return 1
+          else
+            checks_ignored += 1
+            stderr.puts "Ignoring..."
+          end
+        end
+
+        system!("git status") do |*| # reset local caches to account for Docker/host wierdness
+          # ignore
+        end
+        local_changes = ""
+        system!("git diff-index --name-only HEAD --") do |output|
+          local_changes << output
+        end
+        if local_changes.strip != ""
+          stderr.puts "You have un-committed changes:"
+          stderr.puts
+          local_changes.split(/\n/).each do |change|
+            checks_ignored += 1
+            stderr.puts "  #{change}"
+          end
+          stderr.puts
+          if options.check_changes?
+            stderr.puts "Commit or revert these, then push to origin"
+            return 1
+          else
+            checks_ignored += 1
+            stderr.puts "Ignoring..."
+          end
+        end
+
+        rev_list = ""
+        system!("git rev-list --left-right --count origin/main...main") do |output|
+          rev_list << output
+        end
+        remote_ahead, local_ahead = rev_list.strip.chomp.split(/\t/,2).map(&:to_i)
+        if remote_ahead != 0
+          stderr.puts "There are commits in origin you don't have."
+          if options.check_push?
+            stderr.puts "Pull those in, re-run bin/ci, THEN deploy"
+            return 1
+          else
+            checks_ignored += 1
+            stderr.puts "Ignoring..."
+          end
+        end
+
+        if local_ahead != 0
+          stderr.puts "You have not pushed to origin."
+          if options.check_push?
+            stderr.puts "Push to origin before deploying"
+            return 1
+          else
+            checks_ignored += 1
+            stderr.puts "Ignoring..."
+          end
+        end
+        if checks_ignored == 0
+          stdout.puts "All checks passed"
+        else
+          stdout.puts "#{checks_ignored} checks failed, but ignored"
+        end
+
+        0
+      end
+    end
+  end
+end
+

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

@@ -4,6 +4,12 @@ class Brut::CLI::Apps::HerokuContainerBasedDeploy < Brut::CLI::Apps::DeployBase
   default_command :deploy
   configure_only!
 
+  # Better way:
+  #
+  # brut deploy check  - do basic checks that a deploy should happen
+  # brut deploy build  - build artifacts for deploy e.g. Docker image
+  # brut deploy deploy - do the actual deployment (does a check, then build first)
+  # brut deploy        - defaults to brut deploy deploy
   class Deploy < Brut::CLI::Command
     description "Build images, push them to Heroku, and deploy them"
 
@@ -161,7 +167,7 @@ Manages a deploy process based on using Heroku's Container Registry. See
         end
 
         names = images.map(&:first).join(" ")
-        deploy_command = "heroku container:release #{names}"
+        deploy_command = "heroku container:release #{names} -a #{heroku_app_name}"
         if options.deploy?
           out.puts "Deploying images to Heroku"
           system!(deploy_command)

data/{mkbrut/lib/mkbrut → lib/brut/cli/apps/new}/add_segment.rb

@@ -1,7 +1,7 @@
 require "fileutils"
 require "erb"
 
-module MKBrut
+class Brut::CLI::Apps::New
   class AddSegment
     def initialize(current_dir:, add_segment_options:, out:, err:)
       @out = out
@@ -11,20 +11,20 @@ module MKBrut
 
       if @add_segment_options.dry_run?
         @out.puts "Dry Run"
-        MKBrut::Ops::BaseOp.dry_run = true
+        Brut::CLI::Apps::New::Ops::BaseOp.dry_run = true
       end
 
       templates_dir = Pathname(
-        Gem::Specification.find_by_name("mkbrut").gem_dir
+        Gem::Specification.find_by_name("brut").gem_dir
       ) / "templates"
 
       @segment = if @add_segment_options.segment_name == "sidekiq"
-                   MKBrut::Segments::Sidekiq.new(
+                   Brut::CLI::Apps::New::Segments::Sidekiq.new(
                      project_root: add_segment_options.project_root,
                      templates_dir:
                    )
                  elsif @add_segment_options.segment_name == "heroku"
-                   MKBrut::Segments::Heroku.new(
+                   Brut::CLI::Apps::New::Segments::Heroku.new(
                      project_root: add_segment_options.project_root,
                      templates_dir:
                    )

data/{mkbrut/lib/mkbrut → lib/brut/cli/apps/new}/add_segment_options.rb

@@ -1,4 +1,4 @@
-class MKBrut::AddSegmentOptions
+class Brut::CLI::Apps::New::AddSegmentOptions
   attr_reader :segment_name, :project_root
 
   def initialize(

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

@@ -0,0 +1,240 @@
+require "fileutils"
+require "erb"
+require "ostruct"
+
+class Brut::CLI::Apps::New::App < Brut::CLI::Commands::BaseCommand
+  def name = "new"
+  def description = "Create a Brut App or modify an existing one with new segments"
+  def args_description = "app_name"
+
+  def accepts = [
+    Brut::CLI::Apps::New::Prefix,
+    Brut::CLI::Apps::New::AppId,
+    Brut::CLI::Apps::New::Organization,
+    [ Pathname, ->(value) { Pathname(value) } ],
+  ]
+
+  def opts = [
+    [
+      "--dir=DIR",
+      Pathname,
+      "Path where you want your app created. Default is the current directory",
+    ],
+    [ 
+      "--app-id=ID",
+      Brut::CLI::Apps::New::AppId,
+      "App identifier, which must be able to be used as a hostname or other Internet identifier. Derived from your app name, if omitted"
+    ],
+    [
+      "--[no-]interactive",
+      "Don't ask for user input, just assume default answers",
+    ],
+    [
+      "--organization=ORG",
+      Brut::CLI::Apps::New::Organization,
+      "Organization name, e.g. what you'd use for GitHub. Defaults to the app-id value"
+    ],
+
+    [
+      "--prefix=PREFIX",
+      Brut::CLI::Apps::New::Prefix,
+      "Two-character prefix for external IDs and autonomous custom elements. Derived from your app-id, if omitted."
+    ],
+    [ 
+      "--segments=SEGMENTS",
+      Array,
+      "Comma-delimited list of segment names to add additional behavior to your new app. Current values: heroku, sidekiq, demo",
+    ],
+    [ 
+      "--dry-run",
+      "Only show what would happen, don't actually do anything"
+    ],
+    [
+      "--[no-]demo",
+      "Include, or not, additional files that demonstrate Brut's features (default is true for now)"
+    ],
+  ]
+
+  def run
+
+    app_name = argv[0]
+
+    if !app_name
+      stderr.puts "app_name is required"
+      return 1
+    end
+
+    options.set_default(:app_id, Brut::CLI::Apps::New::AppId.from_app_name(app_name))
+    options.set_default(:prefix, Brut::CLI::Apps::New::Prefix.from_app_id(options.app_id))
+    options.set_default(:organization, Brut::CLI::Apps::New::Prefix.from_app_id(options.app_id))
+    options.set_default(:demo, true)
+    options.set_default(:interactive, true)
+    options.set_default(:dir,Pathname.pwd)
+
+    segment_names = Set.new(options.segments)
+    if options.demo?
+      segment_names << "demo"
+    end
+
+    current_dir = options.dir.expand_path
+    versions = Brut::CLI::Apps::New::Versions.new
+
+    templates_dir = Pathname(
+      Gem::Specification.find_by_name("brut").gem_dir
+    ) / "templates"
+
+    base = Brut::CLI::Apps::New::Base.new(
+      app_name:,
+      options:,
+      versions:,
+      current_dir:,
+      templates_dir:
+    )
+    segments = [
+      Brut::CLI::Apps::New::Segments::BareBones.new(
+        app_name:,
+        options:,
+        versions:,
+        current_dir:,
+        templates_dir:,
+      ),
+    ]
+    if options.demo?
+      segments << Brut::CLI::Apps::New::Segments::Demo.new(
+        app_name:,
+        options:,
+        versions:,
+        current_dir:,
+        templates_dir:
+      )
+    end
+    segment_names.each do |segment|
+      case segment
+      when "heroku"
+        segments << Brut::CLI::Apps::New::Segments::Heroku.new(
+          project_root: base.project_root,
+          templates_dir:
+        )
+      when "sidekiq"
+        segments << Brut::CLI::Apps::New::Segments::Sidekiq.new(
+          project_root: base.project_root,
+          templates_dir:
+        )
+      when "demo"
+        # handled above
+      else
+        raise "Segment #{segment} is not supported"
+      end
+    end
+    segments.sort!
+
+    stdout.puts "Creating a new Brut app with these options:\n"
+    stdout.puts "App Name        : #{app_name}"
+    stdout.puts "Path to New App : #{current_dir / app_name}"
+    stdout.puts "App Id          : #{options.app_id}"
+    stdout.puts "Prefix          : #{options.prefix}"
+    stdout.puts "Organization    : #{options.organization}"
+    stdout.puts "Segments        : #{segments.map(&:class).map(&:segment_name).join(", ")}"
+    stdout.puts
+
+    if options.dry_run?
+      stdout.puts "Dry Run only"
+      Brut::CLI::Apps::New::Ops::BaseOp.dry_run = true
+    end
+
+    if options.interactive?
+      stdout.puts "Proceed? (Y/N)"
+      answer = stdin.gets
+      if answer.downcase.strip.chomp != "y"
+        stdout.puts "Aborting...."
+        exit
+      end
+    end
+
+    stdout.puts "Creating Base app"
+    base.create!
+    segments.each do |segment|
+      stdout.puts "Creating segment: #{segment.class.friendly_name}"
+      segment.add!
+    end
+    stdout.puts "#{options.app_name} was created\n\n"
+    stdout.puts "Time to get building:"
+    stdout.puts "1. cd #{current_dir / app_name}"
+    stdout.puts "2. dx/build"
+    stdout.puts "3. dx/start"
+    stdout.puts "4. [ in another terminal ] dx/exec bash"
+    stdout.puts "5. [ inside the Docker container ] bin/setup"
+    stdout.puts "6. [ inside the Docker container ] bin/dev"
+    stdout.puts "7. Visit http://localhost:6502 in your browser"
+    stdout.puts "8. [ inside the Docker container ] bin/setup help # to see more commands"
+  end
+
+  class Segment < Brut::CLI::Commands::BaseCommand
+    def description = "Add a segement to your app to provide additional pre-configured functionality"
+
+    def args_description = "segment_name"
+    
+    def accepts = [
+      [ Pathname, ->(value) { Pathname(value) } ],
+    ]
+
+    def opts = [
+      [
+        "--dir=DIR",
+        Pathname,
+        "Path to your app. Default is the current directory",
+      ],
+      [ 
+        "--dry-run",
+        "Only show what would happen, don't actually do anything"
+      ],
+    ]
+
+    def run
+      options.set_default(:dir,Pathname.pwd)
+
+      segment_name = argv[0]
+      if !segment_name
+        stderr.puts "segment_name is required"
+        return 1
+      end
+      if options.demo?
+        segment_names << "demo"
+      end
+
+      project_root = options.dir.expand_path
+      versions = Brut::CLI::Apps::New::Versions.new
+
+
+      if options.dry_run?
+        stdout.puts "Dry Run"
+        Brut::CLI::Apps::New::Ops::BaseOp.dry_run = true
+      end
+
+      templates_dir = Pathname(
+        Gem::Specification.find_by_name("brut").gem_dir
+      ) / "templates"
+
+      segment = if segment_name == "sidekiq"
+                   Brut::CLI::Apps::New::Segments::Sidekiq.new(
+                     project_root:,
+                     templates_dir:
+                   )
+                 elsif segment_name == "heroku"
+                   Brut::CLI::Apps::New::Segments::Heroku.new(
+                     project_root:,
+                     templates_dir:
+                   )
+                 end
+      if !segment
+        stderr.puts "'#{segment_name}' is not a segment. Allowed values: sidekiq, heroku"
+        return 1
+      end
+
+      stdout.puts "Adding #{segment_name} to this app"
+      segment.add!
+      segment.output_post_add_messaging(stdout:)
+      0
+    end
+  end
+end

data/{mkbrut/lib/mkbrut → lib/brut/cli/apps/new}/app_id.rb

@@ -1,4 +1,4 @@
-class MKBrut::AppId < MKBrut::InternetIdentifier
+class Brut::CLI::Apps::New::AppId < Brut::CLI::Apps::New::InternetIdentifier
   def self.from_app_name(app_name)
     self.new(app_name.to_s.gsub(/[^a-zA-Z0-9\-]/, "-").downcase)
   end

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

@@ -0,0 +1,29 @@
+class Brut::CLI::Apps::New
+  class AppName
+    def initialize(value)
+      identifier = value.to_s
+      if identifier.empty?
+        raise Brut::CLI::Apps::New::InvalidIdentifier, "app-name is required"
+      end
+
+      if identifier.length > 63
+        raise Brut::CLI::Apps::New::InvalidIdentifier, "app-name cannot be longer than 63 characters"
+      end
+
+      if identifier.start_with?("-") || identifier.end_with?("-")
+        raise Brut::CLI::Apps::New::InvalidIdentifier, "app-name cannot start or end with a hyphen"
+      end
+
+      if identifier.match?(/[^a-zA-Z\-_]/)
+        raise Brut::CLI::Apps::New::InvalidIdentifier, "app-name can only contain letters, hyphens, and underscores"
+      end
+      if identifier.match?(/__/) || identifier.match?(/--/)
+        raise Brut::CLI::Apps::New::InvalidIdentifier, "app-name can not have repeating underscores or hyphens"
+      end
+      @identifier = identifier.to_s.gsub(/_/,"-")
+    end
+
+    def to_s = @identifier
+    alias to_str to_s
+  end
+end

data/{mkbrut/lib/mkbrut → lib/brut/cli/apps/new}/base.rb

@@ -1,18 +1,21 @@
 require "pathname"
 require "securerandom"
 # Constructs the base of any Brut app.
-class MKBrut::Base
-  include MKBrut
+class Brut::CLI::Apps::New::Base
+  include Brut::CLI::Apps::New
 
-  class ErbBinding < MKBrut::ErbBindingDelegate
+  class ErbBinding < Brut::CLI::Apps::New::ErbBindingDelegate
     def session_secret = SecureRandom.hex(64)
   end
 
   attr_reader :project_root
-  def initialize(app_options:, current_dir:, templates_dir:)
-    @project_root  = current_dir / app_options.app_name
+  def initialize(app_name:, options:, versions:, current_dir:, templates_dir:)
+    @project_root  = current_dir / app_name
     @templates_dir = templates_dir / "Base"
-    @erb_binding   = ErbBinding.new(app_options)
+    @erb_binding   = ErbBinding.new(options:, app_name:, versions:)
+  end
+
+  def output_post_add_messaging(stdout:)
   end
 
   def create!

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

@@ -0,0 +1,23 @@
+# This exists because ERB can't working with a SimpleDelegator or
+# Delegate.
+class Brut::CLI::Apps::New::ErbBindingDelegate
+  attr_reader :app_name, :versions
+  def initialize(options:, app_name:, versions:)
+    @options  = options
+    @app_name = app_name
+    @versions = versions
+  end
+
+  # Not using Delegate because it won't work with ERB binding
+  def method_missing(syn,*args,&block)
+    if args.empty? && @options.respond_to?(syn)
+      @options.send(syn)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(syn,include_all)
+    @options.respond_to?(syn)
+  end
+end