bard 2.2.0 → 3.0.0

data/lib/bard/plugins/deploy/ci/github_actions.rb

@@ -1,202 +0,0 @@
-require "time"
-require "bard/plugins/github"
-require "bard/plugins/deploy/ci/runner"
-
-module Bard
-  class CI
-    class GithubActions < Runner
-      def exists?
-        File.exist?(".github/workflows/ci.yml")
-      end
-
-      def console
-        @run.console
-      end
-
-      def status
-        last_run = api.last_run
-        if last_run.building?
-          "Building..."
-        elsif last_run.success?
-          "Succeeded!"
-        elsif last_run.failure?
-          "Failed!\n\n#{last_run.console}"
-        else
-          raise "Unknown job status: #{last_run.inspect}"
-        end
-      end
-
-      protected
-
-      def start
-        @run = api.create_run!(branch)
-      end
-
-      def get_last_time_elapsed
-        api.last_successful_run&.time_elapsed
-      end
-
-      def building?
-        @run.building?
-      end
-
-      def success?
-        @run.success?
-      end
-
-      def get_state_data
-        {
-          "project_name" => project_name,
-          "branch" => branch,
-          "run_id" => @run.id,
-          "start_time" => @start_time,
-          "last_time_elapsed" => @last_time_elapsed
-        }
-      end
-
-      def restore_state(data)
-        @run = api.find_run(data["run_id"])
-        @start_time = data["start_time"]
-        @last_time_elapsed = data["last_time_elapsed"]
-      end
-
-      def poll_until_complete
-        while @run.building?
-          elapsed_time = Time.new.to_i - @start_time
-          yield elapsed_time, @last_time_elapsed
-          save_state
-          sleep(2)
-          @run = api.find_run(@run.id)
-        end
-      end
-
-      private
-
-      def api
-        @api ||= API.new(project_name)
-      end
-
-      class API < Struct.new(:project_name)
-        def last_run
-          response = client.get("actions/runs", event: "workflow_dispatch", per_page: 1)
-          if json = response["workflow_runs"][0]
-            Run.new(self, json)
-          end
-        end
-
-        def last_successful_run
-          successful_runs = client.get("actions/runs", event: "workflow_dispatch", status: "success", per_page: 1)
-          if json = successful_runs["workflow_runs"][0]
-            Run.new(self, json)
-          end
-        end
-
-        def find_run id
-          json = client.get("actions/runs/#{id}")
-          Run.new(self, json)
-        end
-
-        def create_run! branch
-          start_time = Time.now
-          client.post("actions/workflows/ci.yml/dispatches", ref: branch, inputs: { "git-ref": branch })
-          sha = `git rev-parse #{branch}`.chomp
-
-          loop do
-            runs = client.get("actions/runs", event: "workflow_dispatch", head_sha: sha, created: ">#{start_time.iso8601}")
-            if json = runs["workflow_runs"].first
-              return Run.new(self, json)
-            end
-            sleep 1
-          end
-        end
-
-        def find_job_by_run_id run_id
-          jobs = client.get("actions/runs/#{run_id}/jobs", filter: "latest", per_page: 1)
-          job_json = jobs["jobs"][0]
-          Job.new(self, job_json)
-        end
-
-        def download_logs_by_job_id job_id
-          client.get("actions/jobs/#{job_id}/logs")
-        end
-
-        private
-
-        def client
-          @client ||= Bard::Github.new(project_name)
-        end
-      end
-
-      class Run < Struct.new(:api, :json)
-        def id
-          json["id"]
-        end
-
-        def time_elapsed
-          job.time_elapsed
-        end
-
-        def building?
-          %w[in_progress queued requested waiting pending]
-            .include?(json["status"])
-        end
-
-        def success?
-          status == "completed" && conclusion == "success"
-        end
-
-        def failure?
-          conclusion == "failure"
-        end
-
-        def job
-          @job ||= api.find_job_by_run_id(id)
-        end
-
-        def console
-          job.logs
-        end
-
-        def branch
-          json["head_branch"]
-        end
-
-        def sha
-          json["head_sha"]
-        end
-
-        def status
-          json["status"]
-        end
-
-        def conclusion
-          json["conclusion"]
-        end
-
-        def started_at
-          Time.parse(json["run_started_at"])
-        end
-
-        def updated_at
-          Time.parse(json["updated_at"])
-        end
-      end
-
-      class Job < Struct.new(:api, :json)
-        def id
-          json["id"]
-        end
-
-        def time_elapsed
-          Time.parse(json["completed_at"]).to_i -
-            Time.parse(json["started_at"]).to_i
-        end
-
-        def logs
-          @logs ||= api.download_logs_by_job_id(id)
-        end
-      end
-    end
-  end
-end
-

data/lib/bard/plugins/deploy/ci/jenkins.rb

@@ -1,176 +0,0 @@
-require "json"
-require "bard/plugins/deploy/ci/runner"
-require "bard/secrets"
-
-module Bard
-  class CI
-    class Jenkins < Runner
-      def exists?
-        `curl -s -I #{ci_host}/` =~ /\b200 OK\b/ or create!
-      end
-
-      private def create!
-        git_url = `git remote get-url origin`.strip
-        config = JOB_CONFIG_XML.sub("GIT_URL", git_url)
-        if File.exist?("config/master.key")
-          master_key = File.read("config/master.key").strip
-          master_key_step = <<~XML.chomp
-            <hudson.tasks.Shell>
-                  <command>echo #{master_key} > config/master.key</command>
-                </hudson.tasks.Shell>
-
-          XML
-          config = config.sub("<builders>\n", "<builders>\n        #{master_key_step}")
-        end
-        `curl -s -X POST "http://#{auth}@ci.botandrose.com/createItem?name=#{project_name}" -H "Content-Type: application/xml" -d '#{config}'`
-      end
-
-      def console
-        raw = `curl -s #{ci_host}/lastBuild/console`
-        raw[%r{<pre.*?>(.+)</pre>}m, 1]
-      end
-
-      attr_accessor :last_response
-
-      protected
-
-      def wait_until_started
-        sleep(2) until started?
-      end
-
-      def start
-        command = "curl -s -I -X POST -L '#{ci_host}/buildWithParameters?GIT_REF=#{branch}'"
-        output = `#{command}`
-        @queueId = output[%r{Location: .+/queue/item/(\d+)/}, 1].to_i
-      end
-
-      def building?
-        retry_with_backoff do
-          self.last_response = `curl -s #{ci_host}/#{job_id}/api/json?tree=building,result`
-          raise "Blank response from CI" if last_response.empty?
-        end
-        last_response.include? '"building":true'
-      end
-
-      def success?
-        last_response.include? '"result":"SUCCESS"'
-      end
-
-      def get_state_data
-        {
-          "project_name" => project_name,
-          "branch" => branch,
-          "queue_id" => @queueId,
-          "job_id" => @job_id,
-          "start_time" => @start_time,
-          "last_time_elapsed" => @last_time_elapsed
-        }
-      end
-
-      def restore_state(data)
-        @queueId = data["queue_id"]
-        @job_id = data["job_id"]
-        @start_time = data["start_time"]
-        @last_time_elapsed = data["last_time_elapsed"]
-      end
-
-      private
-
-      def get_last_time_elapsed
-        response = retry_with_backoff do
-          response = `curl -s #{ci_host}/lastStableBuild/api/xml`
-          raise "Blank response from CI" if response.empty?
-          response
-        end
-        response.match(/<duration>(\d+)<\/duration>/)
-        $1 ? $1.to_i / 1000 : nil
-      rescue => e
-        puts "  Warning: Could not get last build duration: #{e.message}"
-        nil
-      end
-
-      def auth
-        @auth ||= "#{Bard::Secrets.fetch("jenkins-user")}:#{Bard::Secrets.fetch("jenkins-token")}"
-      end
-
-      def ci_host
-        "http://#{auth}@ci.botandrose.com/job/#{project_name}"
-      end
-
-      def started?
-        retry_with_backoff do
-          command = "curl -s -g '#{ci_host}/api/json?depth=1&tree=builds[queueId,number]'"
-          output = `#{command}`
-          raise "Blank response from CI" if output.empty?
-          builds = JSON.parse(output)["builds"]
-          raise "Build not found in builds list" if builds.empty?
-          builds.first["queueId"] == @queueId
-        end
-      end
-
-      def job_id
-        @job_id ||= begin
-          retry_with_backoff do
-            output = `curl -s -g '#{ci_host}/api/json?depth=1&tree=builds[queueId,number]'`
-            raise "Blank response from CI" if output.empty?
-            builds = JSON.parse(output)["builds"]
-            build = builds.find { |b| b["queueId"] == @queueId }
-            build["number"]
-          end
-        end
-      end
-      JOB_CONFIG_XML = <<~XML
-        <?xml version="1.0" encoding="UTF-8"?>
-        <project>
-          <actions/>
-          <description></description>
-          <keepDependencies>false</keepDependencies>
-          <properties>
-            <hudson.model.ParametersDefinitionProperty>
-              <parameterDefinitions>
-                <hudson.model.StringParameterDefinition>
-                  <name>GIT_REF</name>
-                  <description></description>
-                  <defaultValue>master</defaultValue>
-                </hudson.model.StringParameterDefinition>
-              </parameterDefinitions>
-            </hudson.model.ParametersDefinitionProperty>
-          </properties>
-          <scm class="hudson.plugins.git.GitSCM" plugin="git@3.3.0">
-            <configVersion>2</configVersion>
-            <userRemoteConfigs>
-              <hudson.plugins.git.UserRemoteConfig>
-                <url>GIT_URL</url>
-              </hudson.plugins.git.UserRemoteConfig>
-            </userRemoteConfigs>
-            <branches>
-              <hudson.plugins.git.BranchSpec>
-                <name>$GIT_REF</name>
-              </hudson.plugins.git.BranchSpec>
-            </branches>
-            <doGenerateSubmoduleConfigurations>false</doGenerateSubmoduleConfigurations>
-            <submoduleCfg class="list"/>
-            <extensions/>
-          </scm>
-          <canRoam>true</canRoam>
-          <disabled>false</disabled>
-          <blockBuildWhenDownstreamBuilding>false</blockBuildWhenDownstreamBuilding>
-          <blockBuildWhenUpstreamBuilding>false</blockBuildWhenUpstreamBuilding>
-          <triggers/>
-          <concurrentBuild>false</concurrentBuild>
-          <builders>
-            <hudson.tasks.Shell>
-              <command>bash -l -c bin/setup</command>
-            </hudson.tasks.Shell>
-            <hudson.tasks.Shell>
-              <command>bash -l -c bin/ci</command>
-            </hudson.tasks.Shell>
-          </builders>
-          <publishers/>
-          <buildWrappers/>
-        </project>
-      XML
-    end
-  end
-end
-

data/lib/bard/plugins/deploy/ci/local.rb

@@ -1,57 +0,0 @@
-require "tempfile"
-require "bard/plugins/deploy/ci/runner"
-
-module Bard
-  class CI
-    class Local < Runner
-      def exists?
-        true
-      end
-
-      def console
-        @console
-      end
-
-      protected
-
-      def start
-        @output_file = Tempfile.new("bard-ci")
-        @wait_thread = Process.detach(spawn("CLEAN=true bin/rake ci", [:out, :err] => @output_file))
-      end
-
-      def building?
-        ![nil, false].include?(@wait_thread.status)
-      end
-
-      def success?
-        @wait_thread.value.success?
-      end
-
-      def get_state_data
-        {
-          "project_name" => project_name,
-          "branch" => branch,
-          "start_time" => @start_time
-        }
-      end
-
-      def restore_state(data)
-        raise "Cannot resume local CI: process is no longer running. Start a new build with 'bard ci'."
-      end
-
-      def poll_until_complete
-        while building?
-          elapsed_time = Time.new.to_i - @start_time
-          yield elapsed_time, nil
-          save_state
-          sleep(2)
-        end
-
-        @output_file.rewind
-        @console = @output_file.read
-        @output_file.close!
-      end
-    end
-  end
-end
-

data/lib/bard/plugins/deploy/ci/runner.rb

@@ -1,112 +0,0 @@
-require "bard/plugins/deploy/ci/state"
-require "bard/retryable"
-
-module Bard
-  class CI
-    class Runner < Struct.new(:project_name, :branch, :sha)
-      include Bard::Retryable
-
-      @runners = {}
-
-      class << self
-        attr_reader :runners
-
-        def inherited(subclass)
-          super
-          name = extract_runner_name(subclass)
-          runners[name] = subclass if name
-        end
-
-        def [](name)
-          runners[name.to_sym]
-        end
-
-        # Returns the last registered runner (most recently loaded wins)
-        def default
-          runners.values.last
-        end
-
-        private
-
-        def extract_runner_name(klass)
-          klass.name&.split("::")&.last
-            &.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-            &.gsub(/([a-z\d])([A-Z])/, '\1_\2')
-            &.downcase
-            &.to_sym
-        end
-      end
-
-      def run
-        start
-        @start_time = Time.new.to_i
-        @last_time_elapsed = get_last_time_elapsed
-        save_state
-        wait_until_started
-
-        poll_until_complete { |elapsed, last_time| yield elapsed, last_time }
-
-        state.delete
-        success?
-      end
-
-      def resume
-        saved_state = state.load
-        raise "No saved CI state found for #{project_name}. Start a new build with 'bard ci'." if saved_state.nil?
-
-        restore_state(saved_state)
-        poll_until_complete { |elapsed, last_time| yield elapsed, last_time }
-
-        state.delete
-        success?
-      end
-
-      protected
-
-      def poll_until_complete
-        while building?
-          elapsed_time = Time.new.to_i - @start_time
-          yield elapsed_time, @last_time_elapsed
-          save_state
-          sleep(2)
-        end
-      end
-
-      def save_state
-        state.save(get_state_data)
-      end
-
-      def state
-        @state ||= State.new(project_name)
-      end
-
-      # Abstract methods - override in subclasses
-      def start
-        raise NotImplementedError, "#{self.class}#start not implemented"
-      end
-
-      def building?
-        raise NotImplementedError, "#{self.class}#building? not implemented"
-      end
-
-      def success?
-        raise NotImplementedError, "#{self.class}#success? not implemented"
-      end
-
-      def wait_until_started
-      end
-
-      def get_last_time_elapsed
-        nil
-      end
-
-      def get_state_data
-        raise NotImplementedError, "#{self.class}#get_state_data not implemented"
-      end
-
-      def restore_state(data)
-        raise NotImplementedError, "#{self.class}#restore_state not implemented"
-      end
-    end
-  end
-end

data/lib/bard/plugins/deploy/ci/state.rb

@@ -1,40 +0,0 @@
-require "json"
-require "fileutils"
-
-module Bard
-  class CI
-    class State
-      def initialize project_name
-        @project_name = project_name
-      end
-
-      def save data
-        FileUtils.mkdir_p(state_dir)
-        File.write(state_file, JSON.generate(data))
-      end
-
-      def load
-        return nil unless File.exist?(state_file)
-        JSON.parse(File.read(state_file))
-      end
-
-      def delete
-        File.delete(state_file) if File.exist?(state_file)
-      end
-
-      def exists?
-        File.exist?(state_file)
-      end
-
-      private
-
-      def state_dir
-        File.join(Dir.pwd, "tmp", "bard", "ci")
-      end
-
-      def state_file
-        File.join(state_dir, "#{@project_name}.json")
-      end
-    end
-  end
-end

data/lib/bard/plugins/deploy/ci.rb

@@ -1,38 +0,0 @@
-require "forwardable"
-require "bard/plugins/deploy/ci/runner"
-
-module Bard
-  class CI
-    def initialize(project_name, branch, runner_name: nil)
-      @project_name = project_name
-      @branch = branch
-      @runner_name = runner_name
-    end
-
-    extend Forwardable
-    delegate [:run, :resume, :exists?, :console, :status] => :runner
-
-    private
-
-    def runner
-      @runner ||= choose_runner_class.new(@project_name, @branch, sha)
-    end
-
-    def sha
-      @sha ||= `git rev-parse #{@branch}`.chomp
-    end
-
-    def choose_runner_class
-      if @runner_name
-        runner_class = Runner[@runner_name]
-        raise "Unknown CI runner: #{@runner_name}" unless runner_class
-        runner_class
-      else
-        runner_class = Runner.default
-        raise "No CI runner available" unless runner_class
-        runner_class
-      end
-    end
-  end
-end
-

data/lib/bard/plugins/deploy/ssh_strategy.rb

@@ -1,26 +0,0 @@
-require "bard/plugins/deploy/strategy"
-require "bard/copy"
-require "bard/plugins/ssh"
-
-module Bard
-  class DeployStrategy
-    class SSH < DeployStrategy
-      def deploy(clone: nil, branch: "master", force: false)
-        target.require_capability!(:ssh)
-
-        if clone
-          target.run! "git clone --branch #{branch} git@github.com:botandrosedesign/#{clone} #{target.path}", home: true
-          Bard::Copy.file "config/master.key", from: target.config[:local], to: target
-        elsif force
-          target.run! "git fetch origin #{branch}"
-          target.run! "git checkout -f origin/#{branch}"
-        else
-          target.run! "git pull --ff-only origin #{branch}"
-        end
-
-        target.run! "bin/setup"
-        target.run! "bard setup" if clone
-      end
-    end
-  end
-end