bard 2.0.0.beta → 2.0.0

data/lib/bard/config.rb

@@ -1,222 +1,79 @@
-require "bard/server"
 require "bard/target"
+require "bard/plugins/ssh/target_methods"
+require "bard/plugins/ping/target_methods"
 
 module Bard
   class Config
-    def self.current(working_directory: Dir.getwd)
-      project_name = File.basename(working_directory)
-      path = File.join(working_directory, "bard.rb")
-      new(project_name, path: path)
+    def self.current
+      new(detect_project_name, path: "bard.rb")
+    end
+
+    def self.detect_project_name
+      git_common_dir = `git rev-parse --git-common-dir 2>/dev/null`.chomp
+      dirname = if $?.success? && !git_common_dir.empty?
+        File.dirname(File.expand_path(git_common_dir))
+      else
+        Dir.getwd
+      end
+      File.basename(dirname)
     end
 
     attr_reader :project_name, :targets
 
     def initialize(project_name = nil, path: nil, source: nil)
-      # Support both positional and keyword argument for project_name
       @project_name = project_name
-      @servers = {}  # Unified hash for both Server and Target instances
-      @data_paths = []
-      @backup = nil
-      @ci_system = nil
-
-      # Load default configuration (creates Server instances for backward compat)
+      @targets = {}
       load_defaults if project_name
 
-      # Load user configuration
       if path && File.exist?(path)
         source = File.read(path)
       end
       if source
-        instance_eval(source)
+        instance_eval(source, path)
       end
     end
 
-    # Backward compatible accessor
-    def servers
-      @servers
-    end
-
-    # New v2.0 accessor (same as servers)
-    def targets
-      @servers
+    def remove_target(key)
+      @targets.delete(key.to_sym)
     end
 
-    # Old v1.x API - creates Server instances
-    def server(key, &block)
-      key = key.to_sym
-      @servers[key] = Server.define(project_name, key, &block)
-    end
-
-    # New v2.0 API - creates Target instances
     def target(key, &block)
       key = key.to_sym
-      @servers[key] ||= Target.new(key, self)
-      @servers[key].instance_eval(&block) if block
-      @servers[key]
-    end
-
-    # Get a server/target by key
-    def [](key)
-      key = key.to_sym
-      # Fallback to staging if production not defined
-      if @servers[key].nil? && key == :production
-        key = :staging
+      unless @targets[key].is_a?(Target)
+        @targets[key] = Target.new(key, self)
       end
-      @servers[key]
+      @targets[key].instance_eval(&block) if block
+      @targets[key]
     end
 
-    # Data paths configuration
-    def data(*paths)
-      if paths.empty?
-        @data_paths
-      else
-        @data_paths = paths
-      end
-    end
-
-    def data_paths
-      @data_paths
-    end
-
-    def backup(value = nil, &block)
-      if block_given?
-        @backup = BackupConfig.new(&block)
-      elsif value == false
-        @backup = BackupConfig.new { disabled }
-      elsif value.nil? # Getter
-        @backup ||= BackupConfig.new { bard }
-      else
-        raise ArgumentError, "backup accepts false or a block"
-      end
+    def [](key)
+      @targets[key.to_sym]
     end
 
-    def backup_enabled?
-      backup == true
-    end
+    private
 
-    def github_pages url
-      urls = []
-      uri = url.start_with?("http") ? URI.parse(url) : URI.parse("https://#{url}")
-      hostname = uri.hostname.sub(/^www\./, '')
-      urls = [hostname]
-      if hostname.count(".") < 2
-        urls << "www.#{hostname}"
-      end
+    def load_defaults
+      target :local
 
-      target :production do
-        github_pages url
-        ssh false
-        ping(*urls) if urls.any?
+      target :gubs do
+        ssh "botandrose@cloud.hackett.world:22022",
+          path: "Sites/#{config.project_name}"
+        url false
       end
 
-      backup false
-    end
-
-    # CI configuration
-    def ci(system = nil)
-      if system.nil?
-        @ci_system
-      else
-        @ci_system = system
+      target :ci do
+        ssh "jenkins@staging.botandrose.com:22022",
+          path: "jobs/#{config.project_name}/workspace"
+        url false
       end
-    end
-
-    def ci_system
-      @ci_system
-    end
 
-    def ci_instance(branch)
-      return nil if @ci_system == false
-
-      require "bard/ci"
-
-      # Use the existing CI class which handles auto-detection
-      case @ci_system
-      when :local
-        CI.new(project_name, branch, local: true)
-      when :github_actions, :jenkins, nil
-        # CI class auto-detects between github_actions and jenkins
-        CI.new(project_name, branch)
-      when false
-        nil
-      else
-        CI.new(project_name, branch)
+      staging_defaults = proc do
+        ssh "www@staging.botandrose.com:22022"
+        url "#{config.project_name}.botandrose.com"
       end
-    end
-
-    private
-
-    # Load default server configurations (v1.x compatible)
-    def load_defaults
-      @servers[:local] = Server.new(
-        project_name,
-        :local,
-        false,
-        "./",
-        ["#{project_name}.local"],
-      )
-      @servers[:gubs] = Server.new(
-        project_name,
-        :gubs,
-        "botandrose@cloud.hackett.world:22022",
-        "Sites/#{project_name}",
-        false,
-      )
-      @servers[:ci] = Server.new(
-        project_name,
-        :ci,
-        "jenkins@staging.botandrose.com:22022",
-        "jobs/#{project_name}/workspace",
-        false,
-      )
-      @servers[:staging] = Server.new(
-        project_name,
-        :staging,
-        "www@staging.botandrose.com:22022",
-        project_name,
-        ["#{project_name}.botandrose.com"],
-      )
-    end
-  end
-
-  class BackupConfig
-    attr_reader :destinations
-
-    def initialize(&block)
-      @destinations = []
-      instance_eval(&block) if block_given?
-    end
-
-    def bard
-      @bard = true
-    end
-
-    def bard?
-      !!@bard
-    end
-
-    def disabled
-      @disabled = true
-    end
-
-    def disabled?
-      !!@disabled
-    end
-
-    def enabled?
-      !disabled?
-    end
-
-    def s3(name, **kwargs)
-      @destinations << {
-        name: name,
-        type: :s3,
-        **kwargs,
-      }
-    end
 
-    def self_managed?
-      @destinations.any?
+      target :staging, &staging_defaults
+      target :production, &staging_defaults
     end
   end
 end

data/lib/bard/copy.rb

@@ -1,120 +1,45 @@
-require "uri"
-require "bard/command"
-
 module Bard
-  class Copy < Struct.new(:path, :from, :to, :verbose)
-    def self.file path, from:, to:, verbose: false
-      new(path, from, to, verbose).scp
-    end
-
-    def self.dir path, from:, to:, verbose: false
-      new(path, from, to, verbose).rsync
-    end
+  class Copy
+    @handlers = []
 
-    def scp
-      if from.key == :local
-        scp_using_local :to, to
-      elsif to.key == :local
-        scp_using_local :from, from
-      else
-        scp_as_mediator
+    class << self
+      def inherited(subclass)
+        super
+        @handlers.unshift(subclass)
       end
-    end
-
-    def scp_using_local direction, target_or_server
-      # Support both new Target (with server attribute) and old Server
-      ssh_server = target_or_server.respond_to?(:server) ? target_or_server.server : target_or_server
-
-      gateway = ssh_server.gateway ? "-oProxyCommand='ssh #{ssh_server.gateway} -W %h:%p'" : ""
 
-      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
-
-      from_and_to = [path, target_or_server.scp_uri(path)]
-      from_and_to.reverse! if direction == :from
-
-      command = ["scp", gateway, ssh_key, *from_and_to].join(" ")
-      Bard::Command.run! command, verbose: verbose
-    end
-
-    def scp_as_mediator
-      from_server = from.respond_to?(:server) ? from.server : from
-      to_server = to.respond_to?(:server) ? to.server : to
-
-      raise NotImplementedError if from_server.gateway || to_server.gateway || from_server.ssh_key || to_server.ssh_key
-      command = "scp -o ForwardAgent=yes #{from.scp_uri(path)} #{to.scp_uri(path)}"
-      Bard::Command.run! command, verbose: verbose
-    end
-
-    def rsync
-      if from.key == :local
-        rsync_using_local :to, to
-      elsif to.key == :local
-        rsync_using_local :from, from
-      else
-        rsync_as_mediator
+      def file(path, from:, to:, verbose: false)
+        handler_for!(from, to).new(path, from, to, verbose).file
       end
-    end
-
-    def rsync_using_local direction, target_or_server
-      # Support both new Target (with server attribute) and old Server
-      ssh_server = target_or_server.respond_to?(:server) ? target_or_server.server : target_or_server
 
-      # Get ssh_uri - it might be a URI object (old Server), string (new SSHServer), or mock
-      ssh_uri_value = ssh_server.respond_to?(:ssh_uri) ? ssh_server.ssh_uri : nil
-      if ssh_uri_value.respond_to?(:port)
-        # Already a URI-like object (old Server or mock)
-        ssh_uri = ssh_uri_value
-      elsif ssh_uri_value.is_a?(String)
-        # String from new SSHServer
-        ssh_uri = URI("ssh://#{ssh_uri_value}")
-      else
-        # Fallback
-        ssh_uri = ssh_uri_value
+      def dir(path, from:, to:, verbose: false)
+        handler_for!(from, to).new(path, from, to, verbose).dir
       end
 
-      gateway = ssh_server.gateway ? "-oProxyCommand=\"ssh #{ssh_server.gateway} -W %h:%p\"" : ""
+      private
 
-      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
-      ssh = "-e'ssh #{gateway} -p#{ssh_uri.port || 22}'"
-
-      from_and_to = ["./#{path}", target_or_server.rsync_uri(path)]
-      from_and_to.reverse! if direction == :from
-      from_and_to[-1].sub! %r(/[^/]+$), '/'
-
-      command = "rsync #{ssh} --delete --info=progress2 -az #{from_and_to.join(" ")}"
-      Bard::Command.run! command, verbose: verbose
+      def handler_for!(from, to)
+        handler = @handlers.find { |h| h.can_handle?(from, to) }
+        raise "No copy handler for #{from.key} -> #{to.key}" unless handler
+        handler
+      end
     end
 
-    def rsync_as_mediator
-      from_server = from.respond_to?(:server) ? from.server : from
-      to_server = to.respond_to?(:server) ? to.server : to
+    attr_reader :path, :from, :to, :verbose
 
-      raise NotImplementedError if from_server.gateway || to_server.gateway || from_server.ssh_key || to_server.ssh_key
-
-      # Get ssh_uri - it might be a URI object (old Server), string (new SSHServer), or mock
-      from_uri_value = from_server.respond_to?(:ssh_uri) ? from_server.ssh_uri : nil
-      if from_uri_value.respond_to?(:port)
-        from_uri = from_uri_value
-      elsif from_uri_value.is_a?(String)
-        from_uri = URI("ssh://#{from_uri_value}")
-      else
-        from_uri = from_uri_value
-      end
-
-      to_uri_value = to_server.respond_to?(:ssh_uri) ? to_server.ssh_uri : nil
-      if to_uri_value.respond_to?(:port)
-        to_uri = to_uri_value
-      elsif to_uri_value.is_a?(String)
-        to_uri = URI("ssh://#{to_uri_value}")
-      else
-        to_uri = to_uri_value
-      end
+    def initialize(path, from, to, verbose)
+      @path = path
+      @from = from
+      @to = to
+      @verbose = verbose
+    end
 
-      from_str = "-p#{from_uri.port || 22} #{from_uri.user}@#{from_uri.host}"
-      to_str = to.rsync_uri(path).sub(%r(/[^/]+$), '/')
+    def file
+      raise NotImplementedError
+    end
 
-      command = %(ssh -A #{from_str} 'rsync -e \"ssh -A -p#{to_uri.port || 22} -o StrictHostKeyChecking=no\" --delete --info=progress2 -az #{from.path}/#{path} #{to_str}')
-      Bard::Command.run! command, verbose: verbose
+    def dir
+      raise NotImplementedError
     end
   end
 end

data/lib/bard/plugins/data.rb

@@ -0,0 +1,56 @@
+require "bard/command"
+require "bard/copy"
+require "bard/plugins/ssh"
+require "bard/plugins/url"
+
+class Bard::CLI
+  option :from, default: "production"
+  option :to, default: "local"
+  desc "data --from=production --to=local", "copy database and assets from from to to"
+  def data
+    from = config[options[:from]]
+    to = config[options[:to]]
+
+    from.require_capability!(:ssh) unless from.key == :local
+    to.require_capability!(:ssh) unless to.key == :local
+
+    if to.key == :production
+      url = to.url
+      puts yellow "WARNING: You are about to push data to production, overwriting everything that is there!"
+      answer = ask("If you really want to do this, please type in the full HTTPS url of the production server:")
+      if answer != url
+        puts red("!!! ") + "Failed! We expected #{url}. Is this really where you want to overwrite all the data?"
+        exit 1
+      end
+    end
+
+    puts "Dumping #{from.key} database to file..."
+    from.run! "bin/rake db:dump"
+
+    puts "Transfering file from #{from.key} to #{to.key}..."
+    Bard::Copy.file "db/data.sql.gz", from: from, to: to, verbose: true
+
+    puts "Loading file into #{to.key} database..."
+    to.run! "bin/rake db:load"
+
+    config.data.each do |path|
+      puts "Synchronizing files in #{path}..."
+      Bard::Copy.dir path, from: from, to: to, verbose: true
+    end
+  rescue Bard::Command::Error => e
+    puts red("!!! ") + "Running command failed: #{yellow(e.message)}"
+    exit 1
+  end
+end
+
+require "bard/config"
+
+class Bard::Config
+  def data(*paths)
+    if paths.empty?
+      @data_paths ||= []
+    else
+      @data_paths = paths
+    end
+  end
+end

data/lib/bard/{ci → plugins/deploy/ci}/github_actions.rb

@@ -1,13 +1,12 @@
 require "time"
-require "bard/github"
-require "bard/ci/runner"
+require "bard/plugins/github"
+require "bard/plugins/deploy/ci/runner"
 
 module Bard
   class CI
     class GithubActions < Runner
-
       def exists?
-        true
+        File.exist?(".github/workflows/ci.yml")
       end
 
       def console

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

@@ -0,0 +1,176 @@
+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/{ci → plugins/deploy/ci}/local.rb

@@ -1,10 +1,9 @@
-require "open3"
-require "bard/ci/runner"
+require "tempfile"
+require "bard/plugins/deploy/ci/runner"
 
 module Bard
   class CI
     class Local < Runner
-
       def exists?
         true
       end
@@ -16,7 +15,8 @@ module Bard
       protected
 
       def start
-        @stdin, @stdout_and_stderr, @wait_thread = Open3.popen2e("CLEAN=true bin/rake ci")
+        @output_file = Tempfile.new("bard-ci")
+        @wait_thread = Process.detach(spawn("CLEAN=true bin/rake ci", [:out, :err] => @output_file))
       end
 
       def building?
@@ -47,9 +47,9 @@ module Bard
           sleep(2)
         end
 
-        @stdin.close
-        @console = @stdout_and_stderr.read
-        @stdout_and_stderr.close
+        @output_file.rewind
+        @console = @output_file.read
+        @output_file.close!
       end
     end
   end