baleen 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fc7921b0867d0a73836d50b562b35e7cf9692d7f
+  data.tar.gz: 43d2f2f70271efdd4407247e55e0341ffeb689ae
+SHA512:
+  metadata.gz: 2c9f0dab84c29a08f66fe481fa110c26ec6a8bf06b20826077c29cc2333696d7693209ea569d0a587a899144fa5bcefb42be29b4ff2824d4b06be2e68e6d8b78
+  data.tar.gz: 8ec1a88eac0e64c7402f9a2414c88bb9352a08fda0e68b8fdd3c0d90064e311a331c573f1bdfe4e3550d849f133fc5fe46a80949709e718e20c811e337b7c67a

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+poc/db/.*sqlite3
+poc/log/*

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in baleen.gemspec
+gemspec
+
+gem 'docker-client', path: File.expand_path("/Users/kimh/git/docker-ruby", __FILE__)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Kim, Hirokuni
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Baleen
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'baleen'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install baleen
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/baleen.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'baleen/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "baleen"
+  spec.version       = Baleen::VERSION
+  spec.authors       = ["Kim, Hirokuni"]
+  spec.email         = ["kimh@kvh.co.jp"]
+  spec.description   = %q{Ballen allows you to run standard ruby tests in parallel and isolated environment}
+  spec.summary       = %q{Parallel and container-based test runner powered by Docker}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "interactive_editor"
+
+  spec.add_runtime_dependency 'celluloid'
+  spec.add_runtime_dependency 'celluloid-io'
+  spec.add_runtime_dependency 'colorize'
+  spec.add_runtime_dependency 'thor'
+
+end
+

data/bin/baleen

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require "thor"
+
+class BaleenCommand < Thor
+
+  desc "cucumber", "Running cucumber features"
+  option :image, :required => true
+  option :work_dir, :default => "./"
+  option :files, :default => "features"
+  option :before_command, :default => nil
+  def cucumber
+    puts options[:image]
+  end
+end
+
+BaleenCommand.start

data/lib/baleen/client.rb

@@ -0,0 +1,45 @@
+require 'celluloid/io'
+require 'celluloid/autostart'
+
+module Baleen
+  class Client
+    include Celluloid::IO
+    finalizer :close
+
+    def initialize(host, port=12345)
+      @socket = TCPSocket.open(host, port)
+      @result = "running"
+      async.response
+    end
+
+    def request(request)
+      @socket.puts(request.to_json)
+    end
+
+    def response
+      loop { break if handle_response(@socket.gets) }
+    end
+
+    def close
+      @socket.close if @socket
+      info "connection closed"
+
+    rescue IOError; nil
+    end
+
+    def handle_response(response)
+      if response.nil?
+        raise RuntimeError, 'Connection closed by server'
+      end
+
+      info "Got response"
+      @result = Baleen::Message::Decoder.new(response).decode
+      true
+    end
+
+    def result
+      @result
+    end
+
+  end
+end

data/lib/baleen/container.rb

@@ -0,0 +1,49 @@
+module Baleen
+  module Container
+
+    class DockerClient
+      Result = Struct.new("Result", :status_code, :container_id, :log)
+
+      def initialize(containers)
+        @containers = containers
+      end
+
+      def create_container(params)
+        @container = @containers.create([params.shell, params.opt, params.commands], params.image)
+      end
+
+      def start_container
+        id = @container["Id"]
+
+        info "Start container #{id}"
+        @containers.start(id)
+        @containers.wait(id)
+        info "Finish container #{id}"
+      end
+
+      def result
+        id  = @container["Id"]
+        rst = @containers.show(id)
+        log = @containers.logs(id)
+
+        Result.new(
+          rst["State"]["ExitCode"],
+          rst["ID"],
+          log
+        )
+      end
+
+      def kill_all
+        @containers.list.each do |container|
+          @containers.kill(container["Id"])
+        end
+      end
+
+      def status
+        info @containers.list
+      end
+
+    end
+
+  end
+end

data/lib/baleen/job.rb

@@ -0,0 +1,19 @@
+module Baleen
+  class Job
+
+    def initialize(client, msg)
+      @client = client
+      @msg = msg
+    end
+
+    def start
+      @client.request(@msg.params)
+    end
+
+    def result
+      @client.result
+    end
+
+  end
+
+end

data/lib/baleen/messages/messages.rb

@@ -0,0 +1,48 @@
+require "json"
+
+module Baleen
+  module Message
+
+    class Decoder
+
+      def initialize(json_string)
+        @params = JSON.parse(json_string)
+      end
+
+      def decode
+        klass = @params.delete "klass"
+        Object.const_get(klass).new(symbolize_keys(@params))
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.inject({}){|new_hash, key_value|
+          key, value = key_value
+          value = symbolize_keys(value) if value.is_a?(Hash)
+          new_hash[key.to_sym] = value
+          new_hash
+        }
+      end
+    end
+
+    class Base
+      attr_accessor :json_msg
+
+      def initialize
+        @params = {}
+        @params[:klass] = self.class.to_s
+      end
+
+      def params
+        @params
+      end
+
+      def to_json
+        @params.to_json
+      end
+    end
+
+  end
+
+end

data/lib/baleen/messages/request.rb

@@ -0,0 +1,31 @@
+require "json"
+
+module Baleen
+  module Message
+    module Request
+
+      class ClientDisconnect < Base
+        def initialize(opt = {}); super() end
+      end
+
+      class PingPong < Base
+        def initialize(opt = {}); super() end
+      end
+
+      class Cucumber < Base
+        def initialize(image: "kimh/baleen-poc", work_dir: "./", files: "./features", shell: "/bin/bash", opt: "-c", exe: "bundle exec cucumber", before_command: nil, command: nil)
+          super()
+          @params[:image]          = image
+          @params[:shell]          = shell
+          @params[:opt]            = opt
+          @params[:work_dir]       = work_dir
+          @params[:files]          = files
+          @params[:exe]            = exe
+          @params[:before_command] = before_command
+          @params[:command]        = command
+        end
+      end
+
+    end
+  end
+end

data/lib/baleen/messages/response.rb

@@ -0,0 +1,29 @@
+module Baleen
+  module Message
+    module Response
+
+      class JobComplete < Base
+        def initialize(opt = {})
+          super()
+          @params[:status_code]   = opt[:status_code]
+          @params[:log ]          = opt[:log]
+          @params[:container_id ] = opt[:log]
+        end
+
+        def status_code;  @params[:status_code] end
+        def log;          @params[:log] end
+        def container_id; @params[:container_id] end
+      end
+
+      class RunnerFinish < Base
+        def initialize(opt = {})
+          super()
+          @params[:status] = opt[:status]
+        end
+
+        def status;  @params[:status] end
+      end
+
+    end
+  end
+end

data/lib/baleen/runner.rb

@@ -0,0 +1,119 @@
+module Baleen
+
+  class DockerParam
+    def initialize(params)
+      @params = params
+    end
+
+    def method_missing(name, *args)
+      DockerParam.class_eval{
+        define_method "#{name}" do
+          @params[name.to_sym]
+        end
+
+        define_method "#{name}=" do |*args|
+          @params[name.to_sym] = args.first
+        end
+      }
+      send(name)
+    end
+
+    def commands
+      %{
+        #{@params[:before_command]}
+        cd #{@params[:work_dir]}
+        #{command}
+      }
+    end
+
+    def command
+      @params[:command] ||= %{#{@params[:exe]} #{@params[:files]}}
+    end
+
+    def command=(c)
+      @params[:command] = c
+    end
+
+    def dup
+      copy_params = @params.dup
+      Object.const_get(self.class.to_s).new(copy_params)
+    end
+  end
+
+  class RunnerManager
+    include Celluloid::IO
+
+    CONCURRENCY=2
+
+    def initialize(containers, socket, msg)
+      @containers = containers
+      @socket     = socket
+      @queue      = []
+      @params     = DockerParam.new(msg.params)
+    end
+
+    def run
+      create_runners.each do |runners|
+        @queue = runners
+        @queue.each do |runner|
+          runner.async.run
+        end
+        loop {break if monitor_runners}
+      end
+
+      msg = Message::Response::RunnerFinish.new(status: "done")
+      @socket.puts(msg.to_json)
+    end
+
+    private
+
+    def create_runners
+      target_files.map {|file|
+        @params.files = file
+        Runner.new(@containers, @params)
+      }.each_slice(CONCURRENCY).map {|r| r}
+    end
+
+    def target_files
+      params = @params.dup
+      params.command = %{find #{params.files} | grep "\\.feature"}
+      runner = Runner.new(@containers, params)
+      runner.run
+      runner.status.log.split("\n")
+    end
+
+    def monitor_runners
+      @queue.all?{ |r| r.status }
+    end
+  end
+
+  class Runner
+    include Celluloid::IO
+
+    attr_reader :status
+
+    def initialize(containers, params)
+      @docker_client = Container::DockerClient.new(containers)
+      @status = nil
+      @params = params
+    end
+
+    def run
+      start_runner do |result|
+        @status = Message::Response::JobComplete.new(
+           status_code: result.status_code,
+           container_id: result.container_id,
+           log: result.log
+         )
+      end
+      sleep 0.1 # Stop a moment until RunnerManager checks the status
+    end
+
+    def start_runner
+      @docker_client.create_container(@params)
+      @docker_client.start_container
+      yield( @docker_client.result )
+    end
+
+  end
+end

data/lib/baleen/server.rb

@@ -0,0 +1,75 @@
+require 'docker'
+require 'awesome_print'
+require 'socket'
+require 'celluloid/io'
+require 'celluloid/autostart'
+require 'json'
+
+module Baleen
+
+  class Server
+    include Celluloid::IO
+    finalizer :shutdown
+
+    attr_accessor :containers
+
+    def initialize(host, port: 4243)
+      @base_url = "http://#{host}:#{port}"
+      @docker = Docker::API.new(base_url: @base_url)
+      @containers = @docker.containers
+      @server = TCPServer.new("127.0.0.1", 12345)
+      async.run
+    end
+
+    def run
+      loop { async.handle_connection @server.accept }
+    end
+
+    def shutdown
+      @server.close if @server
+    end
+
+    def handle_connection(socket)
+      loop { handle_request(socket) }
+
+    rescue Exception => ex
+      case ex
+        when IOError; nil # when trying to close already closed socket
+        else
+          warn "Unknown exception occured"
+          ap ex
+          raise ex
+      end
+    end
+
+    def handle_request(socket)
+      message = socket.gets
+
+      if message.nil?
+        socket.close
+        return
+      end
+      msg = parse_request(message)
+
+      case msg
+        when Message::Request::PingPong
+          socket.puts "pong"
+        when Message::Request::ClientDisconnect
+          socket.close
+        when Message::Request::Cucumber
+          manager = RunnerManager.new(@containers, socket, msg)
+          manager.run
+        else
+          warn "Received unknown request"
+          ap msg
+      end
+    end
+
+    def parse_request(message)
+      #info "Got request from client"
+      #ap message
+      Baleen::Message::Decoder.new(message).decode
+    end
+  end
+
+end

data/lib/baleen/task.rb

@@ -0,0 +1,44 @@
+module Baleen
+  module Task
+
+    class Command
+      def initialize(work_dir, files, bundler)
+        @work_dir = work_dir
+        @files = files
+        @bundler = bundler
+        @before = []
+        build_default_arg
+      end
+
+      def before(commands=nil)
+        commands = sanitize_and_tokenize(commands) if commands
+        commands ? @before = commands : @before
+      end
+
+      def commands
+        @before ? @before + @args : @args
+      end
+
+      def <<(arg)
+        @args << arg
+      end
+
+      private
+
+      def build_default_arg
+        exe = @bundler ? "bundle exec cucumber" : "cucumber"
+        @args = ["cd #{@work_dir}", "#{exe} #{@files}"]
+      end
+
+      def sanitize_and_tokenize(arg)
+        # sanitize
+        arg = arg.strip.gsub(/^ */, '').gsub(/\n+/, "\n")
+        # tokenize
+        arg = arg.gsub(";", "\n")
+        arg.split("\n")
+      end
+    end
+
+  end
+end
+

data/lib/baleen/utils/colored_puts.rb

@@ -0,0 +1,17 @@
+require "colorize"
+
+module Kernel
+  private
+
+  def info(msg)
+    puts msg.green
+  end
+
+  def warn(msg)
+    puts msg.yellow
+  end
+
+  def error(msg)
+    puts msg.red
+  end
+end

data/lib/baleen/version.rb

@@ -0,0 +1,3 @@
+module Baleen
+  VERSION = "0.0.2"
+end

data/lib/baleen.rb

@@ -0,0 +1,5 @@
+require "baleen/version"
+
+module Baleen
+  # Your code goes here...
+end

data/poc/.gitignore

@@ -0,0 +1,15 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the default SQLite database.
+/db/*.sqlite3
+
+# Ignore all logfiles and tempfiles.
+/log/*.log
+/tmp