brut 0.18.2 → 0.19.0

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

@@ -1,86 +0,0 @@
-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

@@ -1,226 +0,0 @@
-require "brut/cli"
-class Brut::CLI::Apps::HerokuContainerBasedDeploy < Brut::CLI::Apps::DeployBase
-  description "Deploy to Heroku using containers"
-  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"
-
-    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)
-      login_to_heroku_container_registry!(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} -a #{heroku_app_name}"
-        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)
-      logged_into_heroku = system("heroku whoami > /dev/null 2>&1")
-
-      if !logged_into_heroku
-        out.puts "You are not logged into Heroku."
-        out.puts
-        out.puts "There are two ways to do this:"
-        out.puts
-        out.puts "1 - Set HEROKU_API_KEY in your environment. You can get a"
-        out.puts "    value in a lot of ways, but a comand-line based one is"
-        out.puts
-        out.puts "    heroku authorizations:create -d 'container pushes' --expires-in 31536000"
-        out.puts
-        out.puts "    This reuqires logging into the CLI via heroku auth:login, but using the"
-        out.puts "    key will prevent you from having to login every day."
-        out.puts
-        out.puts "    See Brut's documentation for how to persist this value between rebuilds"
-        out.puts "    of your dev environment."
-        out.puts
-        out.puts "2 - heroku auth:login"
-        out.puts
-        out.puts "    This is simpler, however you will need to do this every day."
-        out.puts
-        exit 1
-      end
-      out.puts "You are logged into Heroku"
-    end
-
-    def login_to_heroku_container_registry!(options)
-      if !system("heroku container:login")
-        out.puts "Failed to login to Heroku Container Registry"
-        out.puts
-        out.puts "Since you are logged into Heroku, this should've passed, so there"
-        out.puts "may be something else wrong.  The command used was"
-        out.puts
-        out.puts "    heroku container:login"
-        out.puts
-        exit 1
-      end
-      out.puts "Logged into Heroku Container Registry"
-    end
-  end
-end

data/templates/segments/Heroku/bin/deploy

@@ -1,11 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler"
-Bundler.require
-require "pathname"
-require "brut/cli/apps/heroku_container_based_deploy"
-
-exit Brut::CLI.app(
-  Brut::CLI::Apps::HerokuContainerBasedDeploy,
-  project_root: Pathname($0).dirname / ".."
-)