vx-worker 0.2.0.pre28

data/lib/vx/worker/consumers/job_logs_consumer.rb

@@ -0,0 +1,13 @@
+require 'vx/common/amqp'
+
+module Vx
+  module Worker
+    class JobLogsConsumer
+
+      include Vx::Common::AMQP::Consumer
+
+      exchange 'vx.jobs.log'
+
+    end
+  end
+end

data/lib/vx/worker/consumers/job_status_consumer.rb

@@ -0,0 +1,13 @@
+require 'vx/common/amqp'
+
+module Vx
+  module Worker
+    class JobStatusConsumer
+
+      include Vx::Common::AMQP::Consumer
+
+      exchange 'vx.jobs.status'
+
+    end
+  end
+end

data/lib/vx/worker/consumers/jobs_consumer.rb

@@ -0,0 +1,28 @@
+require 'vx/common/amqp'
+require 'vx/message'
+
+module Vx
+  module Worker
+    class JobsConsumer
+
+      include Vx::Common::AMQP::Consumer
+
+      exchange 'vx.jobs'
+      queue    'vx.worker.jobs'
+      ack      true
+
+      model Message::PerformJob
+
+      def perform(message)
+        Worker.logger.tagged self.class.consumer_id do
+          job         = Job.new message
+          number      = Thread.current[:consumer_id] || 0
+          path_prefix = "/tmp/.test/job.#{number}"
+          Worker.perform(job, path_prefix)
+          ack!
+        end
+      end
+
+    end
+  end
+end

data/lib/vx/worker/docker.rb

@@ -0,0 +1,32 @@
+require 'vx/common'
+
+module Vx
+  module Worker
+
+    class Docker
+
+      include Common::Helper::Middlewares
+
+      attr_reader :job
+
+      middlewares do
+        use LogJob
+        use UpdateJobStatus
+        use Timeout
+        use StartConnector
+        use RunScript
+      end
+
+      def initialize(job, _)
+        @job         = job
+      end
+
+      def perform
+        env = OpenStruct.new job: job
+        run_middlewares(env){ |_| 0 }
+      end
+
+    end
+
+  end
+end

data/lib/vx/worker/ext/string.rb

@@ -0,0 +1,10 @@
+class String
+  def compact
+    gsub(/\n/, ' ').gsub(/ +/, ' ').strip
+  end
+
+  def camelize
+    split("_").each {|s| s.capitalize! }.join("")
+  end
+end
+

data/lib/vx/worker/helper/config.rb

@@ -0,0 +1,11 @@
+module Vx
+  module Worker
+    module Helper::Config
+
+      def config
+        Worker.config
+      end
+
+    end
+  end
+end

data/lib/vx/worker/helper/logger.rb

@@ -0,0 +1,11 @@
+module Vx
+  module Worker
+    module Helper::Logger
+
+      def logger
+        Worker.logger
+      end
+
+    end
+  end
+end

data/lib/vx/worker/initializers/amqp.rb

@@ -0,0 +1,3 @@
+require 'vx/common/amqp'
+
+Vx::Common::AMQP.setup(Vx::Worker.logger, url: Vx::Worker.config.amqp_url)

data/lib/vx/worker/job.rb

@@ -0,0 +1,49 @@
+require 'vx/message'
+require 'vx/common'
+
+module Vx
+  module Worker
+    class Job
+
+      include Helper::Logger
+
+      attr_reader :output, :message, :output_counter
+
+      def initialize(perform_job_message)
+        @output_counter = 0
+        @message        = perform_job_message
+        @output         = Common::OutputBuffer.new(&method(:publish_job_log_message))
+      end
+
+      def add_to_output(str)
+        output << str
+        logger.debug str.strip if logger.level == 0
+      end
+
+      def add_command_to_output(cmd)
+        add_to_output "$ #{cmd}\n"
+      end
+
+      def add_trace_to_output(log)
+        add_to_output log.split(/\n/).map{|i| " ===> #{i}\n" }.join
+      end
+
+      def release
+        output.close
+      end
+
+      def publish_job_log_message(str)
+        @output_counter += 1
+        log = Message::JobLog.new(
+          build_id: message.id,
+          job_id:   message.job_id,
+          tm:       output_counter,
+          log:      str
+        )
+        JobLogsConsumer.publish log
+        log
+      end
+
+    end
+  end
+end

data/lib/vx/worker/local.rb

@@ -0,0 +1,32 @@
+require 'vx/common'
+
+module Vx
+  module Worker
+
+    class Local
+
+      include Common::Helper::Middlewares
+
+      attr_reader :job
+
+      middlewares do
+        use LogJob
+        use UpdateJobStatus
+        use Timeout
+        use StartConnector
+        use RunScript
+      end
+
+      def initialize(job, _)
+        @job = job
+      end
+
+      def perform
+        env = OpenStruct.new job: job
+        run_middlewares(env){ |_| 0 }
+      end
+
+    end
+
+  end
+end

data/lib/vx/worker/middlewares/log_job.rb

@@ -0,0 +1,19 @@
+module Vx
+  module Worker
+
+    LogJob = Struct.new(:app) do
+
+      include Helper::Logger
+
+      def call(env)
+        logger.tagged("job #{env.job.message.id}.#{env.job.message.job_id}") do
+          logger.info "starting job"
+          rs = app.call env
+          logger.info "done job"
+          rs
+        end
+      end
+
+    end
+  end
+end

data/lib/vx/worker/middlewares/run_script.rb

@@ -0,0 +1,84 @@
+require 'vx/common'
+
+module Vx
+  module Worker
+
+    RunScript = Struct.new(:app) do
+
+      include Helper::Logger
+      include Helper::Config
+      include Common::Helper::UploadShCommand
+
+      def call(env)
+        if env.spawner
+          code = run_script(env)
+          run_after_script(env)
+
+          if code == 0
+            app.call env
+          else
+            case read_state(env)
+            when "script"
+              code
+            else
+              code * -1
+            end
+          end
+        else
+          app.call env
+        end
+      end
+
+      private
+
+        def run_script(env)
+          file = [env.spawner.work_dir, ".ci_build.sh"].join("/")
+
+          script = [upload_sh_command(file, script_content(env))]
+          script << "env - HOME=$HOME bash #{file}"
+          script = script.join(" && ")
+
+          env.spawner.spawn script, read_timeout: read_timeout, &env.job.method(:add_to_output)
+        end
+
+        def run_after_script(env)
+          file = [env.spawner.work_dir, ".ci_after_build.sh"].join("/")
+
+          script = [upload_sh_command(file, after_script_content(env))]
+          script << "env - HOME=$HOME bash #{file}"
+          script = script.join(" && ")
+
+          env.spawner.spawn script, read_timeout: read_timeout, &env.job.method(:add_to_output)
+        end
+
+        def script_content(env)
+          buf = ["set -e"]
+          buf << "echo before_script > #{env.spawner.work_dir}/.ci_state"
+          buf << env.job.message.before_script
+          buf << "echo script > #{env.spawner.work_dir}/.ci_state"
+          buf << env.job.message.script
+          buf.join("\n")
+        end
+
+        def after_script_content(env)
+          buf = ["set -e"]
+          buf << env.job.message.after_script
+          buf.join("\n")
+        end
+
+        def read_state(env)
+          buf = ""
+          state_file = "#{env.spawner.work_dir}/.ci_state"
+          env.spawner.spawn "cat #{state_file}" do |out|
+            buf << out
+          end
+          buf.strip
+        end
+
+        def read_timeout
+          10 * 60
+        end
+
+    end
+  end
+end

data/lib/vx/worker/middlewares/start_connector.rb

@@ -0,0 +1,32 @@
+require 'socket'
+require 'pathname'
+require 'vx/container_connector'
+
+module Vx
+  module Worker
+
+    StartConnector = Struct.new(:app) do
+
+      include Helper::Config
+      include Helper::Logger
+
+      def call(env)
+        options = config.connector_options
+        options.merge! logger: logger
+        env.connector = ContainerConnector.lookup(config.run, options)
+        env.connector.start do |spawner|
+          env.job.add_to_output "using #{Socket.gethostname}##{spawner.id}\n"
+          logger.tagged("#{spawner.id}") do
+            begin
+              env.spawner = spawner
+              app.call env
+            ensure
+              env.spawner = spawner
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/vx/worker/middlewares/timeout.rb

@@ -0,0 +1,22 @@
+require 'timeout'
+
+module Vx
+  module Worker
+
+    Timeout = Struct.new(:app) do
+
+      def call(env)
+        rs = nil
+        ::Timeout.timeout(_timeout) do
+          rs = app.call env
+        end
+        rs
+      end
+
+      def _timeout
+        30 * 60
+      end
+
+    end
+  end
+end

data/lib/vx/worker/middlewares/update_job_status.rb

@@ -0,0 +1,69 @@
+require 'vx/message'
+require 'vx/common/error_notifier'
+
+module Vx
+  module Worker
+
+    UpdateJobStatus = Struct.new(:app) do
+
+      include Helper::Logger
+
+      STARTED  = 2
+      FINISHED = 3
+      BROKEN   = 4
+      FAILED   = 5
+
+      def call(env)
+
+        update_status env.job, STARTED
+        rs = -1
+        begin
+          rs = app.call env
+        rescue ::Timeout::Error => e
+          env.job.add_to_output("\n\nERROR: #{e.message}\n")
+        rescue ::Exception => e
+          env.job.add_to_output("\n\nERROR: #{e.inspect}\n")
+          logger.error("ERROR: #{e.inspect}\n    BACKTRACE:\n#{e.backtrace.map{|i| "    #{i}" }.join("\n")}")
+          Common::ErrorNotifier.notify(e)
+        end
+
+        msg = "\nDone. Your build exited with %s.\n"
+        env.job.add_to_output(msg % rs.abs)
+
+        case
+        when rs == 0
+          update_status env.job, FINISHED
+        when rs > 0
+          update_status env.job, BROKEN
+        when rs < 0
+          update_status env.job, FAILED
+        end
+
+        rs
+      end
+
+      private
+
+        def update_status(job, status)
+          publish_status create_message(job, status)
+        end
+
+        def create_message(job, status)
+          tm = Time.now
+          Message::JobStatus.new(
+            build_id: job.message.id,
+            job_id:   job.message.job_id,
+            status:   status,
+            tm:       tm.to_i,
+            matrix:   job.message.matrix_keys
+          )
+        end
+
+        def publish_status(message)
+          logger.info "delivered job status #{message.inspect}"
+          JobStatusConsumer.publish message
+        end
+
+    end
+  end
+end

data/lib/vx/worker/version.rb

@@ -0,0 +1,5 @@
+module Vx
+  module Worker
+    VERSION = "0.2.0.pre28"
+  end
+end

data/lib/vx/worker.rb

@@ -0,0 +1,83 @@
+require 'rubygems'
+require 'pathname'
+require 'thread'
+
+require File.expand_path("../worker/ext/string", __FILE__)
+require File.expand_path("../worker/version",    __FILE__)
+
+module Vx
+  module Worker
+
+    autoload :JobsConsumer,          File.expand_path("../worker/consumers/jobs_consumer",             __FILE__)
+    autoload :JobLogsConsumer,       File.expand_path("../worker/consumers/job_logs_consumer",         __FILE__)
+    autoload :JobStatusConsumer,     File.expand_path("../worker/consumers/job_status_consumer",       __FILE__)
+    autoload :Configuration,         File.expand_path("../worker/configuration",                       __FILE__)
+    autoload :Job,                   File.expand_path("../worker/job",                                 __FILE__)
+    autoload :Local,                 File.expand_path("../worker/local",                               __FILE__)
+    autoload :Docker,                File.expand_path("../worker/docker",                              __FILE__)
+    autoload :CLI,                   File.expand_path("../worker/cli",                                 __FILE__)
+    autoload :OutputBuffer,          File.expand_path("../worker/output_buffer",                       __FILE__)
+
+    autoload :LogJob,                File.expand_path("../worker/middlewares/log_job",                 __FILE__)
+    autoload :UpdateJobStatus,       File.expand_path("../worker/middlewares/update_job_status",       __FILE__)
+    autoload :Timeout,               File.expand_path("../worker/middlewares/timeout",                 __FILE__)
+    autoload :StartConnector,        File.expand_path("../worker/middlewares/start_connector",         __FILE__)
+    autoload :RunScript,             File.expand_path("../worker/middlewares/run_script",              __FILE__)
+
+    module Helper
+      autoload :Logger,              File.expand_path("../worker/helper/logger",                       __FILE__)
+      autoload :Config,              File.expand_path("../worker/helper/config",                       __FILE__)
+    end
+
+    extend self
+
+    @@root   = Pathname.new File.expand_path('../../..', __FILE__)
+    @@config_mutex = Mutex.new
+
+    def logger
+      if ENV['CI_WORKER_SILENT']
+        config.null_logger
+      else
+        config.logger
+      end
+    end
+
+    def configure
+      yield config
+      config
+    end
+
+    def config
+      @config ||= begin
+        @@config_mutex.synchronize do
+          Configuration.new
+        end
+      end
+    end
+
+    def root
+      @@root
+    end
+
+    def perform(job, path_prefix)
+      rs = run_class.new(job, path_prefix).perform
+      job.release
+      rs
+    end
+
+    def run_class
+      self.const_get(config.run.to_s.camelize)
+    end
+
+    def reset_config!
+      @config = nil
+    end
+
+    def initialize!
+      root.join("lib/vx/worker/initializers").children.each do |e|
+        require e
+      end
+    end
+
+  end
+end

data/spec/lib/worker/configuration_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Vx::Worker::Configuration do
+  let(:config) { Vx::Worker.config }
+  subject { config }
+
+  its(:run)                  { should eq :docker }
+  its(:docker)               { should be         }
+  its(:timeout)              { should eq 1800    }
+  its(:amqp_url)             { should be_nil     }
+  its(:connector_options)    { should eq config.docker }
+  its(:connector_remote_dir) { should eq config.docker.remote_dir }
+
+  context "docker" do
+    subject { config.docker }
+
+    its(:user)       { should be }
+    its(:password)   { should be }
+    its(:init)       { should be }
+    its(:image)      { should be }
+    its(:remote_dir) { should be }
+  end
+
+  context "local" do
+    subject { config.local }
+
+    its(:remote_dir){ should be }
+  end
+
+  context ".configure" do
+    subject {
+      Vx::Worker.configure do |c|
+        c.run = "local"
+        c.docker.image = 'image'
+      end
+    }
+    its(:run)           { should eq :local  }
+    its("docker.image") { should eq 'image' }
+  end
+end

data/spec/lib/worker/docker_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Vx::Worker::Docker, docker: true do
+  let(:options) { { } }
+  let(:job)     { create :job, options }
+  let(:local)   { described_class.new job, nil }
+  subject { local }
+
+  context "perform" do
+    subject { local.perform }
+    it { should eq 0 }
+
+    before do
+      Vx::Worker.config.run = "docker"
+    end
+
+    context "when fail before_script" do
+      let(:options) { { before_script: "false" } }
+      it { should eq(-1) }
+    end
+
+    context "when fail script" do
+      let(:options) { { script: "false" } }
+      it { should eq(1) }
+    end
+  end
+
+end