vx-router 0.2.0.pre28

data/lib/vx/router/script_builder/prepare.rb

@@ -0,0 +1,58 @@
+require 'vx/common'
+
+module Vx
+  class Router
+    class ScriptBuilder
+
+      Prepare = Struct.new(:app) do
+
+        include Helper::TraceShCommand
+        include Common::Helper::UploadShCommand
+
+        def call(env)
+          name         = env.build.message.name
+          deploy_key   = env.build.message.deploy_key
+
+          repo_path    = "code/#{name}"
+          data_path    = "data/#{name}"
+          key_file     = "#{data_path}/key"
+          git_ssh_file = "#{data_path}/git_ssh"
+
+          sha          = env.build.message.sha
+          scm          = build_scm(env, sha, repo_path)
+          git_ssh      = scm.git_ssh.class.template(deploy_key && "$PWD/#{key_file}")
+
+          env.init.tap do |i|
+            i << "mkdir -p  #{data_path}"
+            i << "mkdir -p  #{repo_path}"
+
+            if deploy_key
+              i << "echo instaling keys"
+              i << upload_sh_command(key_file, deploy_key)
+              i << "chmod 0600 #{key_file}"
+            end
+
+            i << upload_sh_command(git_ssh_file, git_ssh)
+            i << "chmod 0750 #{git_ssh_file}"
+
+            i << "export GIT_SSH=$PWD/#{git_ssh_file}"
+            i << scm.make_fetch_command
+            i << "unset GIT_SSH"
+          end
+
+          app.call env
+        end
+
+        private
+
+          def build_scm(env, sha, path)
+            SCM::Git.new(env.build.message.src,
+                         sha,
+                         "$PWD/#{path}",
+                         branch: env.build.message.branch)
+          end
+
+      end
+    end
+  end
+end

data/lib/vx/router/script_builder/ruby.rb

@@ -0,0 +1,68 @@
+module Vx
+  class Router
+    class ScriptBuilder
+
+      Ruby = Struct.new(:app) do
+
+        ALIASES = {
+          '1.8.7' => "system"
+        }
+
+        include Helper::TraceShCommand
+
+        def call(env)
+          if rvm env
+            env.cache_key << "rvm-#{rvm env}"
+
+            env.before_install.tap do |i|
+              i << 'eval "$(rbenv init -)" || true'
+              i << "rbenv shell #{make_rbenv_version_command env}"
+              i << 'export BUNDLE_GEMFILE=${PWD}/Gemfile'
+              i << 'export GEM_HOME=$HOME/cached/rubygems'
+            end
+
+            env.announce.tap do |a|
+              a << trace_sh_command("ruby --version")
+              a << trace_sh_command("gem --version")
+              a << trace_sh_command("bundle --version")
+            end
+
+            env.install.tap do |i|
+              i << trace_sh_command("bundle install")
+              i << trace_sh_command("bundle clean --force")
+            end
+          end
+
+          app.call(env)
+        end
+
+        private
+
+          def rvm(env)
+            env.configuration.rvm.first
+          end
+
+          def make_rbenv_version_command(env)
+            select_rbenv_version_by_aliases(env) ||
+              select_rbenv_version(env)
+          end
+
+          def select_rbenv_version_by_aliases(env)
+            ALIASES[rvm(env)]
+          end
+
+          def select_rbenv_version(env)
+            %{
+              $(rbenv versions |
+                sed -e 's/^\*/ /' |
+                awk '{print $1}' |
+                grep -v 'system' |
+                grep '#{rvm env}' |
+                tail -n1)
+            }.compact
+          end
+
+      end
+    end
+  end
+end

data/lib/vx/router/script_builder/script.rb

@@ -0,0 +1,22 @@
+module Vx
+  class Router
+    class ScriptBuilder
+
+      Script = Struct.new(:app) do
+
+        include Helper::TraceShCommand
+
+        def call(env)
+          env.configuration.before_script.each do |c|
+            env.before_script << trace_sh_command(c)
+          end
+          env.configuration.script.each do |c|
+            env.script << trace_sh_command(c)
+          end
+          app.call(env)
+        end
+
+      end
+    end
+  end
+end

data/lib/vx/router/script_builder/webdav_cache.rb

@@ -0,0 +1,80 @@
+module Vx
+  class Router
+    class ScriptBuilder
+
+      WebdavCache = Struct.new(:app) do
+
+        include Helper::Config
+        include Helper::Logger
+
+        CASHER_URL = "https://raw.github.com/travis-ci/casher/production/bin/casher"
+        CASHER_BIN = "$HOME/.casher/bin/casher"
+
+        def call(env)
+          rs = app.call env
+
+          if config.webdav_cache_url
+            assign_url_to_env(env)
+            prepare(env)
+            fetch(env)
+            add(env)
+            push(env)
+          end
+
+          rs
+        end
+
+        private
+
+          def assign_url_to_env(env)
+            urls   = []
+            branch = env.build.message.branch
+            if branch != 'master'
+              urls << url_for(env, branch)
+            end
+            puts urls.inspect
+            urls << url_for(env, 'master')
+
+            env.webdav_fetch_url = urls
+            env.webdav_push_url  = url_for(env, branch)
+            env
+          end
+
+          def url_for(env, branch)
+            name = env.build.message.name.dup + "/" + branch
+
+            key = env.cache_key.join("-").gsub(/[^a-z0-9_\-.]/, '-')
+            "#{config.webdav_cache_url}/#{name}/#{key}.tgz"
+          end
+
+          def prepare(env)
+            cmd = %{
+              export CASHER_DIR=$HOME/.casher &&
+              ( mkdir -p $CASHER_DIR/bin &&
+                curl #{CASHER_URL} -s -o #{CASHER_BIN} &&
+                chmod +x #{CASHER_BIN} ) ||
+              true
+            }.compact
+            env.init << cmd
+          end
+
+          def fetch(env)
+            urls = env.webdav_fetch_url.join(" ")
+            env.init << "#{CASHER_BIN} fetch #{urls} || true"
+          end
+
+          def add(env)
+            env.init << "#{CASHER_BIN} add $HOME/cached || true"
+            env.init << "unset CASHER_DIR"
+          end
+
+          def push(env)
+            if env.webdav_push_url
+              env.after_script << "#{CASHER_BIN} push #{env.webdav_push_url}"
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/vx/router/version.rb

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

data/spec/lib/build_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+require 'vx/common'
+
+describe Vx::Router::Build do
+  let(:msg)   { create :message, 'PerformBuild' }
+  let(:build) { described_class.new msg }
+
+  subject { build }
+
+  context "just created" do
+    its(:message)        { should eq msg }
+    its(:output)         { should be_an_instance_of(Vx::Common::OutputBuffer)}
+    its(:output_counter) { should eq 0 }
+  end
+
+  context "publish_build_log_message" do
+    let(:data) { 'log' }
+    subject { build.publish_build_log_message data }
+
+    it { should be_an_instance_of(Vx::Message::BuildLog) }
+    its(:build_id) { should eq build.message.id }
+    its(:tm)       { should eq 1 }
+    its(:log)      { should eq data }
+
+    it "should increment counter" do
+      expect {
+        subject
+      }.to change(build, :output_counter).by(1)
+    end
+
+    it "should delivery message" do
+      expect {
+        subject
+      }.to change(Vx::Router::BuildLogsConsumer.messages, :count).by(1)
+      expect(last_build_log_message.log).to eq data
+    end
+  end
+
+  context "to_build_status_message" do
+    subject { build.to_build_status_message Vx::Router::Build::STARTED }
+
+    before do
+      build.jobs_count = 1
+    end
+
+    it { should be_an_instance_of(Vx::Message::BuildStatus) }
+    its(:build_id)   { should eq build.message.id }
+    its(:status)     { should eq 2 }
+    its(:tm)         { should be }
+    its(:jobs_count) { should eq 1 }
+  end
+
+  context "add_to_output" do
+    let(:data)     { 'data' }
+    let(:messages) { Vx::Router::BuildLogsConsumer.messages }
+    subject do
+      build.add_to_output(data)
+      build.output.flush
+      build
+    end
+
+    it "should delivery message" do
+      expect {
+        subject
+      }.to change(messages, :size).by(1)
+      expect(last_build_log_message.log).to eq data
+    end
+
+    it "should increment output_counter" do
+      expect {
+        subject
+      }.to change(build, :output_counter).by(1)
+      expect(last_build_log_message.tm).to eq 1
+    end
+  end
+
+  context "add_command_to_output" do
+    let(:data)     { 'data' }
+    let(:messages) { Vx::Router::BuildLogsConsumer.messages }
+    subject do
+      build.add_command_to_output(data)
+      build.output.flush
+      build
+    end
+
+    it "should delivery message" do
+      expect {
+        subject
+      }.to change(messages, :size).by(1)
+      expect(last_build_log_message.log).to eq "$ #{data}\n"
+    end
+
+    it "should increment output_counter" do
+      expect {
+        subject
+      }.to change(build, :output_counter).by(1)
+      expect(last_build_log_message.tm).to eq 1
+    end
+  end
+
+  context ".to_perform_job_message" do
+    let(:config) { create :configuration }
+    let(:job_id) { 2 }
+    subject { build.to_perform_job_message config, job_id }
+
+    it { should be_an_instance_of Vx::Message::PerformJob }
+
+    context "created message" do
+      its(:id)            { should eq build.message.id }
+      its(:name)          { should eq build.message.name }
+      its(:job_id)        { should eq job_id }
+      its(:before_script) { should be }
+      its(:script)        { should be }
+      its(:after_script)  { should be }
+      its(:matrix_keys)   { should eq ['rvm:2.0.0'] }
+    end
+  end
+
+  context "scm_class" do
+    subject { build.scm_class }
+    it { should eq Vx::SCM::Git }
+  end
+end

data/spec/lib/configuration_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Vx::Router::Configuration do
+  let(:config) { Vx::Router.config }
+  subject { config }
+
+  before { Vx::Router.reset_config! }
+
+  its(:timeout)  { should eq 1800 }
+  its(:amqp_url) { should be_nil }
+
+  context ".configure" do
+    subject {
+      Vx::Router.configure do |c|
+        c.timeout = 1
+        c.amqp_url = "2"
+      end
+    }
+    its(:timeout)       { should eq 1 }
+    its(:amqp_url)      { should eq "2" }
+    its(:workers)       { should eq 1 }
+  end
+end

data/spec/lib/router_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'fileutils'
+require 'pathname'
+
+describe Vx::Router do
+  let(:build)       { create :build }
+  let(:router)      { described_class.new build }
+  subject { router }
+
+  context "just created" do
+    its(:build) { should eq build }
+  end
+
+  context "#perform" do
+    subject { router.perform }
+    it { should be_true }
+  end
+
+  context "#update_build_status" do
+    let(:messages) { Vx::Router::BuildStatusConsumer.messages }
+    let(:first_message) { messages.first }
+    let(:last_message) { messages.last }
+
+    it "should delivery STARTED and FINISHED when success" do
+      router.update_build_status { true }
+      expect(messages).to have(2).items
+      expect(first_message.status).to eq Vx::Router::Build::STARTED
+      expect(last_message.status).to eq Vx::Router::Build::FINISHED
+    end
+
+    it "should delivery STARTED and FAILED when failed" do
+      router.update_build_status { false }
+      expect(messages).to have(2).items
+      expect(first_message.status).to eq Vx::Router::Build::STARTED
+      expect(last_message.status).to eq Vx::Router::Build::FAILED
+    end
+
+    it "should delivery STARTED and FAILED when exception raised" do
+      router.update_build_status { raise "Ignore Me" }
+      expect(messages).to have(2).items
+      expect(first_message.status).to eq Vx::Router::Build::STARTED
+      expect(last_message.status).to eq Vx::Router::Build::FAILED
+    end
+  end
+
+  context "#load_configuration" do
+    subject { router.load_configuration }
+
+    it "should build new BuildConfiguration instance from message" do
+      expect(subject).to be_true
+      expect(router.configuration).to be
+    end
+  end
+
+  context "#create_and_delivery_build_matrix" do
+    let(:messages) { Vx::Router::JobsConsumer.messages }
+    let(:message)  { messages.first }
+    subject { router.create_and_delivery_build_matrix }
+    before do
+      stub(router).configuration { create :configuration }
+    end
+
+    it "should create build matrix from source configuration and delivery its to jobs" do
+      expect(subject).to be_true
+      expect(messages).to have(1).item
+      expect(message.job_id).to eq 1
+    end
+
+    it "should publish job_status message with status = INITIALIZED" do
+      expect {
+        subject
+      }.to change(Vx::Router::JobStatusConsumer.messages, :count).by(1)
+      message = Vx::Router::JobStatusConsumer.messages.last
+      expect(message.build_id).to eq build.message.id
+      expect(message.job_id).to eq 1
+      expect(message.status).to eq 0
+    end
+  end
+
+end