vx-common 0.2.0.pre28

data/lib/vx/common/tagged_logging.rb

@@ -0,0 +1,81 @@
+# from activesupport
+
+require 'logger'
+
+module Vx
+  module Common
+    module TaggedLogging
+
+      class Formatter < ::Logger::Formatter
+        Format = "[%s] %1s : %s\n"
+
+        def call(severity, time, progname, msg)
+          Format % [format_datetime(time),
+                    severity[0...1],
+                    msg2str("#{tags_text}#{msg}")]
+        end
+
+        def thread_id
+          Thread.current.object_id
+        end
+
+        def tagged(*tags)
+          new_tags = push_tags(*tags)
+          yield self
+        ensure
+          pop_tags(new_tags.size)
+        end
+
+        def push_tags(*tags)
+          tags.flatten.reject{|i| i.to_s.strip.empty? }.tap do |new_tags|
+            current_tags.concat new_tags
+          end
+        end
+
+        def pop_tags(size = 1)
+          current_tags.pop size
+        end
+
+        def clear_tags!
+          current_tags.clear
+        end
+
+        def current_tags
+          Thread.current[:activesupport_tagged_logging_tags] ||= []
+        end
+
+        private
+
+          def tags_text
+            tags = current_tags
+            if tags.any?
+              tags.collect { |tag| "[#{tag}] " }.join
+            end
+          end
+
+      end
+
+      def self.new(logger)
+        # Ensure we set a default formatter so we aren't extending nil!
+        logger.formatter = Formatter.new
+        logger.extend(self)
+      end
+
+      %w{ push_tags pop_tags clear_tags! }.each do |m|
+        define_method m do
+          formatter.send(m)
+        end
+      end
+
+      def tagged(*tags)
+        formatter.tagged(*tags) { yield self }
+      end
+
+      def flush
+        clear_tags!
+        super if defined?(super)
+      end
+
+    end
+  end
+end

data/lib/vx/common/version.rb

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

data/lib/vx/common.rb

@@ -0,0 +1,20 @@
+require File.expand_path("../common/version", __FILE__)
+
+module Vx
+  module Common
+    module Helper
+      autoload :Shell,           File.expand_path("../common/helper/shell",             __FILE__)
+      autoload :Middlewares,     File.expand_path("../common/helper/middlewares",       __FILE__)
+      autoload :UploadShCommand, File.expand_path("../common/helper/upload_sh_command", __FILE__)
+    end
+
+    autoload :OutputBuffer,  File.expand_path("../common/output_buffer",      __FILE__)
+    autoload :EnvFile,       File.expand_path("../common/env_file",           __FILE__)
+    autoload :ErrorNotifier, File.expand_path("../common/error_notifier",     __FILE__)
+  end
+
+  module SCM
+    autoload :Git, File.expand_path("../scm/git", __FILE__)
+  end
+
+end

data/lib/vx/scm/git/git_ssh.rb

@@ -0,0 +1,58 @@
+module Vx
+  module SCM
+
+    class Git
+
+      class GitSSH
+
+        include Common::Helper::Shell
+
+        attr_reader :deploy_key
+
+        def initialize(deploy_key)
+          @deploy_key = deploy_key
+        end
+
+        def open
+          begin
+            yield create
+          ensure
+            destroy
+          end
+        end
+
+        def create
+          key_location
+          location
+        end
+
+        def destroy
+          key_location.unlink if key_location
+          location.unlink
+          @location     = nil
+          @key_location = nil
+        end
+
+        def location
+          @location ||= write_tmp_file 'git', self.class.template(key_location && key_location.path), 0700
+        end
+
+        def key_location
+          if deploy_key
+            @key_location ||= write_tmp_file 'key', deploy_key, 0600
+          end
+        end
+
+        class << self
+          def template(key_location)
+            key = key_location ? "-i #{key_location}" : ""
+            out = ['#!/bin/sh']
+            out << "exec /usr/bin/ssh -A -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null #{key} $@"
+            out.join "\n"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/vx/scm/git.rb

@@ -0,0 +1,105 @@
+require 'ostruct'
+require File.expand_path("../git/git_ssh", __FILE__)
+
+module Vx
+  module SCM
+
+    class Git
+
+      include Common::Helper::Shell
+
+      COMMIT_RE = /^(.*) -:- (.*) \((.*)\) -:- (.*)$/
+
+      attr_reader :src, :sha, :path, :logger, :git_ssh, :branch
+
+      def initialize(src, sha, path, options = {}, &block)
+        @src             = src
+        @sha             = sha
+        @path            = path
+        @branch          = options[:branch]
+        @git_ssh         = GitSSH.new options[:deploy_key]
+        @logger          = block
+      end
+
+      def open
+        git_ssh.open do
+          yield if block_given?
+        end
+      end
+
+      def fetch
+        open do
+          run_git make_fetch_command
+        end
+      end
+
+      def self.make_export_command(from, to)
+        %{ (cd '#{from}' && git checkout-index -a -f --prefix='#{to}/') }.strip
+      end
+
+      def make_fetch_command(options = {})
+        depth        = options.key?(:depth) ? options[:depth] : 50
+        clone_branch = " --branch=#{branch}" if branch
+        clone_cmd    = "git clone -q --depth=#{depth}#{clone_branch} #{src} #{path}"
+        checkout_cmd = "git checkout -qf #{sha}"
+        fetch_cmd    = "git fetch -q origin"
+        cmd = %{
+            if [ -d #{path}/.git ] ; then
+              echo "$ #{fetch_cmd}" &&
+              cd #{path} &&
+        #{fetch_cmd} || exit $? ;
+            else
+              echo "$ #{clone_cmd}" &&
+        #{clone_cmd} || exit $? ;
+            fi ;
+            echo "$ #{checkout_cmd}" &&
+            cd #{path} &&
+        #{checkout_cmd}
+        }.gsub("\n", ' ').gsub(/\ +/, ' ').strip
+        cmd
+      end
+
+      def commit_info
+        rs = {}
+        if str = commit_info_string
+          if m = str.match(COMMIT_RE)
+            rs.merge!(
+              sha:     m[1],
+              author:  m[2],
+              email:   m[3],
+              message: m[4]
+            )
+          end
+        end
+        OpenStruct.new rs
+      end
+
+      private
+
+        def commit_info_string
+          output = ""
+          code = spawn commit_info_cmd, chdir: path do |io|
+            output << io
+          end
+          if code == 0
+            output.strip
+          else
+            nil
+          end
+        end
+
+        def commit_info_cmd
+          %{git log -1 --pretty=format:'%H -:- %cn (%ce) -:- %s'}
+        end
+
+        def run_git(cmd, options = {})
+          env = {
+            'GIT_SSH' => git_ssh.location.path
+          }
+          spawn(env, cmd, options, &logger)
+        end
+
+    end
+
+  end
+end

data/spec/lib/common/helper/middlewares_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+TestFirstMiddleware = Struct.new(:app) do
+  def call(env)
+    env << :first
+    app.call env
+  end
+end
+
+TestLastMiddleware = Struct.new(:app) do
+  def call(env)
+    env << :last
+    app.call env
+  end
+end
+
+class MiddlewaresTest
+  include Vx::Common::Helper::Middlewares
+
+  middlewares do
+    use TestFirstMiddleware
+    use TestLastMiddleware
+  end
+
+  def run
+    run_middlewares([]) do |env|
+      env << :app
+    end
+  end
+
+end
+
+describe Vx::Common::Helper::Middlewares do
+  let(:klass)  { MiddlewaresTest }
+  let(:object) { klass.new }
+  subject { object }
+
+  it "should run defined middlewares" do
+
+    expect(object.run).to eq [:first, :last, :app]
+  end
+
+end

data/spec/lib/common/helper/shell_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+describe Vx::Common::Helper::Shell do
+
+  let(:klass) { Class.new.tap{|i| i.send :include, described_class } }
+  let(:object) { klass.new }
+
+  subject { object }
+
+  context "path" do
+    it "should create Pathname" do
+      expect_method(:path, '/tmp').to eq Pathname.new('/tmp')
+    end
+  end
+
+  context "mkdir" do
+
+    after { FileUtils.rm_rf '/tmp/.a/' }
+
+    it "should create directories" do
+      expect_method(:mkdir, '/tmp/.a/b/c')
+      expect(File.directory? '/tmp/.a/b/c')
+    end
+  end
+
+  context "rm" do
+    before { FileUtils.mkdir_p '/tmp/.a/b/c' }
+    after  { FileUtils.rm_rf '/tmp/.a' }
+
+    it "should force remove" do
+      expect_method :rm, '/tmp/.a'
+      expect(File.exists? '/tmp/.a').to be_false
+    end
+  end
+
+  context "recreate" do
+    before { FileUtils.mkdir_p '/tmp/.a/b/c' }
+    after  { FileUtils.rm_rf '/tmp/.a' }
+
+    it "should remove and create directory" do
+      expect_method :recreate, '/tmp/.a/b'
+      expect(File.exists? '/tmp/.a/b/c').to be_false
+    end
+  end
+
+  context "write_file" do
+    let(:fname) { '/tmp/.a' }
+    after { FileUtils.rm_f fname }
+
+    it "should write content to file" do
+      expect_method :write_file, fname, 'content', 0611
+      expect(File.readable? fname).to be_true
+      expect(File.read fname).to eq 'content'
+    end
+  end
+
+  context "write_tmp_file" do
+    let(:tmp_file) { object.send :write_tmp_file, 'fname', 'content', 0611 }
+
+    after { FileUtils.rm_f tmp_file.path }
+
+    it "should create tmp file and write content" do
+      expect(tmp_file).to be
+      expect(File.readable? tmp_file.path).to be_true
+      expect(File.read tmp_file.path).to eq 'content'
+    end
+  end
+
+  context "read_file" do
+    let(:fname) { '/tmp/.a' }
+    before do
+      File.open fname, 'w' do |io|
+        io << "content"
+      end
+    end
+    after { FileUtils.rm_f fname }
+
+    it "should read file" do
+      expect_method(:read_file, fname).to eq 'content'
+    end
+
+    context "when file does not exists" do
+      it "should return nil" do
+        expect_method(:read_file, 'not_exists').to be_nil
+      end
+    end
+  end
+
+  context "bash" do
+    let(:output) { '' }
+
+    context "when command is string" do
+      it "should spawn bash command and return exit code" do
+        expect_method(:bash, "echo $HOME", &method(:add_to_output)).to eq 0
+        expect(output).to eq ENV['HOME'] + "\n"
+      end
+    end
+
+    context "when command is a file" do
+      let(:fname) { '/tmp/.a' }
+
+      before do
+        File.open fname, 'w' do |io|
+          io << "echo $HOME"
+        end
+      end
+
+      after { FileUtils.rm_f fname }
+
+      it "should spawn bash, execute file and return exit code" do
+        expect_method(:bash, file: fname, &method(:add_to_output)).to eq 0
+      end
+    end
+
+    context "when :ssh options passed" do
+      let(:ssh) { 'ssh' }
+
+      before do
+        mock(ssh).spawn("/usr/bin/env -i HOME=${HOME} bash -c command", {}) { 0 }
+      end
+
+      it "should execute command thougth :ssh" do
+        expect_method(:bash, 'command', ssh: ssh, &method(:add_to_output)).to eq 0
+      end
+
+    end
+
+    def add_to_output(out)
+      output << out
+    end
+  end
+
+  def expect_method(name, *args, &block)
+    expect(object.send(name, *args, &block))
+  end
+
+end

data/spec/lib/common/helper/upload_sh_command_spec.rb

@@ -0,0 +1,39 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'vx/common/spawn'
+require 'fileutils'
+
+describe Vx::Common::Helper::UploadShCommand do
+  let(:object) { Object.new }
+  subject { object }
+
+  before do
+    object.extend described_class
+    object.extend Vx::Common::Spawn
+  end
+
+  it { should be_respond_to(:upload_sh_command) }
+
+  context "#upload_sh_command" do
+    let(:file)    { '/tmp/.test' }
+    let(:content) { 'Дима' }
+    let(:cmd) { object.upload_sh_command file, content }
+
+    before { FileUtils.rm_rf file }
+    after { FileUtils.rm_rf file }
+
+    it "should be successful" do
+      object.spawn cmd do |out|
+        puts " ===> #{out}"
+      end
+
+      expect(File).to be_readable(file)
+      expect(File.read file).to eq content
+    end
+
+  end
+
+end
+
+

data/spec/lib/common/output_buffer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Vx::Common::OutputBuffer do
+  let(:collected) { "" }
+  let(:write)     { ->(str) { collected << str } }
+  let(:buffer)    { described_class.new(0.5, &write) }
+
+  after do
+    buffer.close
+  end
+
+  it { should be }
+
+  it "should add string to buffer" do
+    buffer << "1"
+    buffer << "2"
+    expect(collected).to eq ''
+    sleep 1
+    expect(collected).to eq '12'
+
+    buffer << '3'
+    expect(collected).to eq '12'
+    sleep 1
+    expect(collected).to eq '123'
+  end
+
+  it "should raise error when add to closed buffer" do
+    buffer.close
+    expect {
+      buffer << "1"
+    }.to raise_error
+  end
+
+  it "should flush buffer" do
+    buffer << "1"
+    sleep 0.1
+    expect(collected).to eq ''
+    buffer.flush
+    expect(collected).to eq '1'
+  end
+
+end

data/spec/lib/scm/git_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+require 'vx/message/testing'
+
+describe Vx::SCM::Git do
+  let(:path)       { '/tmp/.test/repo'               }
+  let(:message)    { Vx::Message::PerformBuild.test_message }
+  let(:src)        { message.src }
+  let(:sha)        { message.sha }
+  let(:deploy_key) { message.deploy_key }
+  let(:output)     { "" }
+  let(:options)    { {} }
+  let(:git)        {
+    described_class.new src, sha, path, options, &method(:add_to_output)
+  }
+
+  subject { git }
+
+  before do
+    FileUtils.rm_rf path
+    FileUtils.mkdir_p path
+  end
+
+  after  { FileUtils.rm_rf path }
+
+  context "just created" do
+    its(:src)                 { should eq src }
+    its(:sha)                 { should eq sha }
+    its(:path)                { should eq path }
+    its(:branch)              { should be_nil }
+    its("git_ssh.deploy_key") { should be_nil }
+  end
+
+  context "assign branch" do
+    let(:options) { { branch: 'master' } }
+    its(:branch)  { should eq 'master' }
+  end
+
+  context "assign deploy_key" do
+    let(:options) { { deploy_key: deploy_key } }
+    its("git_ssh.deploy_key") { should eq deploy_key }
+  end
+
+  context "fetch" do
+    let(:options) { { deploy_key: deploy_key } }
+    subject { git.fetch }
+
+    it { should eq 0 }
+
+    it "should create nessesary directories and checkout sha" do
+      subject
+      expect(File.directory? path).to be
+      expect(File.directory? "#{path}/.git").to be
+      Dir.chdir path do
+        expect((`git rev-parse HEAD`).strip).to eq sha
+      end
+    end
+
+    it "should capture output" do
+      subject
+      expect(output).to match(Regexp.escape "$ git clone -q --depth=50 #{src} #{path}")
+    end
+
+    context "twice" do
+      before { git.fetch }
+      it { should eq 0 }
+    end
+
+    context "with error" do
+      let(:src) { "/not-exists-repo.git"  }
+
+      it "should return 128 exitstatus and add error to output" do
+        expect(subject).to eq 128
+        expect(output).to match('does not exist')
+      end
+    end
+  end
+
+  context "make_fetch_command" do
+    include Vx::Common::Spawn
+
+    let(:options) { { deploy_key: deploy_key, branch: "master" } }
+    let(:run) do
+      git.open do
+        spawn(git_ssh_env, git.make_fetch_command, &method(:add_to_output))
+      end
+    end
+    subject { git.make_fetch_command }
+
+    before do
+      run
+    end
+
+    it { should be }
+
+    it "should be success" do
+      expect(run).to eq 0
+    end
+
+    it "should create nessesary directories and checkout sha" do
+      expect(File.directory? path).to be
+      expect(File.directory? "#{path}/.git").to be
+      Dir.chdir path do
+        expect((`git rev-parse HEAD`).strip).to eq sha
+      end
+    end
+
+    context "twice" do
+      it "should be" do
+        code = git.open do
+          spawn(git_ssh_env, git.make_fetch_command, &method(:add_to_output))
+        end
+        expect(code).to eq 0
+      end
+    end
+
+    context "with error" do
+      let(:src) { "/not-exists-repo.git"  }
+
+      it "should return 128 exitstatus and add error to output" do
+        expect(run).to eq 128
+      end
+    end
+
+    def git_ssh_env
+      { 'GIT_SSH' => git.git_ssh.location.path }
+    end
+  end
+
+  context ".make_export_command" do
+    let(:options)  { { deploy_key: deploy_key } }
+    let(:from)     { path }
+    let(:to)       { '/tmp/.test/export' }
+    let(:expected) { "(cd '#{ from }' && git checkout-index -a -f --prefix='#{ to}/')" }
+    subject { described_class.make_export_command from, to}
+    it { should eq expected }
+
+    context "run" do
+      before do
+        git.fetch
+        system subject
+      end
+
+      it "should be success" do
+        expect($?.to_i).to eq 0
+      end
+
+      it "should export repo" do
+        expect(File.readable? "#{to}/Gemfile").to be_true
+      end
+    end
+  end
+
+  context "commit_info" do
+    let(:options) { { deploy_key: deploy_key } }
+    subject { git.commit_info }
+    before  { git.fetch }
+
+    it "should be" do
+      expect(subject.sha).to     eq 'b665f90239563c030f1b280a434b3d84daeda1bd'
+      expect(subject.author).to  eq "Dmitry Galinsky"
+      expect(subject.email).to   eq 'dima.exe@gmail.com'
+      expect(subject.message).to eq 'first release'
+    end
+  end
+
+  def add_to_output(out)
+    puts "==> #{out}"
+    output << out
+  end
+end