baleen 0.1.1 → 0.1.2

data/lib/baleen/message/base.rb

@@ -1,55 +1,24 @@
-require "json"
+require 'baleen/utils/highlighter'
 
 module Baleen
   module Message
-
-    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
-
-    class Decoder
-      include Baleen::Message
-
-      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
-    end
-
     class Base
 
-      def initialize
+      include Serializable
+
+      def initialize()
         @params = {}
         @params[:klass] = self.class.to_s
       end
 
-      def method_missing(name, *args)
-        Base.class_eval{
-          define_method "#{name}" do
-            @params[name.to_sym]
-          end
-        }
-        send(name)
+      def results
+        nil
       end
 
-      def params
-        @params
+      def terminate?
+        false
       end
 
-      def to_json
-        @params.to_json
-      end
     end
-
   end
-
-end
+end

data/lib/baleen/message/exception.rb

@@ -0,0 +1,21 @@
+require 'baleen/utils/highlighter'
+
+module Baleen
+  module Message
+    class Exception < Baleen::Message::Base
+
+      def initialize(opt)
+        super()
+        @params[:message] = opt[:message]
+      end
+
+      def terminate?
+        true
+      end
+
+      def print_message
+        hl_error message
+      end
+    end
+  end
+end

data/lib/baleen/message/message.rb

@@ -1,2 +1,3 @@
-require "baleen/message/request"
-require "baleen/message/response"
+require "baleen/message/base"
+require "baleen/message/to_client"
+require "baleen/message/exception"

data/lib/baleen/message/to_client.rb

@@ -0,0 +1,32 @@
+require 'baleen/utils/highlighter'
+
+module Baleen
+  module Message
+    class ToClient < Baleen::Message::Base
+
+      def initialize(opt)
+        super()
+        @params[:message] = opt[:message]
+        @params[:level]   = opt[:level]
+      end
+
+      def terminate?
+        false
+      end
+
+      def print_message
+        case level
+          when "info"
+            hl_info message
+          when "warn"
+            hl_warn message
+          when "error"
+            hl_error message
+          else
+            hl_error "Unknown message level"
+            hl_error inspect
+        end
+      end
+    end
+  end
+end

data/lib/baleen/project.rb

@@ -0,0 +1,122 @@
+module Baleen
+  class Project
+
+      include Default
+
+      @@projects = {}
+
+      attr_reader :name, :config
+
+      def self.projects(name=nil)
+        if name
+          @@projects[name.to_sym]
+        else
+          @@projects
+        end
+      end
+
+      def self.load_project(config)
+        if File.exists?(config)
+          yaml = Baleen::Serializable.symbolize_keys(YAML.load_file(config))
+        else
+          hl_error "Config file not found"
+          raise Baleen::Error::ConfigMissing
+        end
+
+        yaml.each do |project, cfg|
+          if Baleen::Validation::Validator.check(cfg)
+            @@projects[project] = self.new(project, cfg)
+          end
+        end
+      end
+
+      def self.find_project(name, attribute, params={})
+        projects = Baleen::Project.projects
+
+        if name && attribute
+          raise "You cannot specify name and attribute at the same time"
+        elsif name
+          return projects[name.to_sym]
+        elsif attribute
+          projects.each do |project, attributes|
+            attributes.config.each do |attr, values|
+              if attr == attribute
+                params.each do |_k, _v|
+                  return nil unless values[_k] == _v
+                end
+                return projects[project]
+              end
+            end
+          end
+        end
+      end
+
+      def self.find_project_by_name(name)
+        find_project(name.to_sym, nil)
+      end
+
+      def self.find_project_by_ci(params)
+        find_project(nil, :ci, params)
+      end
+
+      def self.find_project_by_runner(params)
+        find_project(nil, :runner, params)
+      end
+
+      def self.find_project_by_framework(params)
+        find_project(nil, :framework, params)
+      end
+
+      def initialize(name, cfg)
+        @name = name
+        load_config(cfg)
+      end
+
+      def load_config(cfg)
+        if Baleen::Validation::Validator.check(cfg)
+          cfg[:runner][:before_command] ||= default_before_command
+          cfg[:runner][:concurrency]    ||= default_concurrency
+          cfg[:runner][:work_dir]       ||= default_work_dir
+          cfg[:runner][:image]
+
+          case cfg[:framework][:type]
+            when "cucumber"
+              cfg[:framework][:files] = cfg[:framework][:features] || default_features
+            else
+              raise "Passed unknown framework from config yml: #{cfg[:framework][:type]}"
+          end
+        end
+        @config = cfg
+      end
+
+      def ci
+        @config[:ci]
+      end
+
+      def image
+        @config[:runner][:image]
+      end
+
+      def branch
+        ci[:branch]
+      end
+
+      def repo
+        ci[:repo]
+      end
+
+      def url
+        ci[:url]
+      end
+
+      def task
+        Baleen::Task::Cucumber.new(
+          image: @config[:runner][:image],
+          work_dir: @config[:runner][:work_dir],
+          files: @config[:framework][:files],
+          before_command: @config[:runner][:before_command],
+          concurrency: @config[:runner][:concurrency].to_i,
+        )
+      end
+  end
+end

data/lib/baleen/result_display.rb

@@ -2,39 +2,47 @@ require "colorize"
 
 module Baleen
   class ResultDisplay
-    def initialize(result, start_time: nil, end_time: nil)
-      @result     = result.result
+    def initialize(result, start_time, end_time, output)
+      @result     = result
       @start_time = start_time
       @end_time   = end_time
+      @output     = output
+    end
+
+    def report_result
+      if @result
+        summary
+        detail
+      end
     end
 
     def summary
-      tests_result = pass_all? ? "Pass".green : "Fail".red
+      tests_result = pass_all? ? "Pass".blue : "Fail".red
       time = run_time
 
-      puts   ""
-      notice "[Summary]"
-      puts   "Result: ".yellow + tests_result
-      puts   "Time: ".yellow + time.green
-      puts   ""
+      @output.puts   ""
+      @output.puts   "[Summary]".yellow
+      @output.puts   "Result: ".yellow + tests_result
+      @output.puts   "Time: ".yellow + time.green
+      @output.puts   ""
     end
 
     def detail
-      notice "[Details]"
+      @output.puts "[Details]".yellow
       @result.each do |r|
-        puts "Id: ".yellow + "#{r[:container_id]}".green
-        puts "status code: ".yellow + "#{r[:status_code]}".green
-        puts "feature file: ".yellow + "#{r[:file]}".green
-        puts "logs:".yellow
-        puts "------------------------------------".yellow
-        puts "#{r[:log]}".green
+        @output.puts "Id: ".yellow + "#{r['container_id']}".green
+        @output.puts "status code: ".yellow + "#{r['status_code']}".green
+        @output.puts "feature file: ".yellow + "#{r['file']}".green
+        @output.puts "logs:".yellow
+        @output.puts "------------------------------------".yellow
+        @output.puts "#{r['log']}".green
       end
     end
 
     private
 
     def pass_all?
-      @result.all? {|r| r[:status_code] == 0}
+      @result.all? {|r| r['status_code'] == 0}
     end
 
     def run_time

data/lib/baleen/runner.rb

@@ -1,124 +1,67 @@
 require "baleen/error"
+require 'forwardable'
 
 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(socket, msg)
-      @socket     = socket
-      @queue      = []
-      @results    = []
-      @params     = DockerParam.new(msg.params)
+    def initialize(connection, task)
+      @task       = task
+      @connection = connection
     end
 
     def run
+      results = []
+      prepare_task
       create_runners.each do |runners|
-        @queue = runners
-        @queue.each do |runner|
-          runner.async.run
+        runners.map{|runner| runner.future.run}.each do |actor|
+          results << actor.value
         end
-        loop {break if monitor_runners}
-        @results += @queue.map {|runner| runner.status.params}
       end
-      msg = Message::Response::JobComplete.new(status: "done", results: @results.to_json)
-      @socket.puts(msg.to_json)
+      @task.results = results
+      yield @task
     end
 
     private
 
-    def create_runners
-      target_files.map {|file|
-        params = @params.dup
-        params.files = file
-        Runner.new(params)
-      }.each_slice(@params.concurrency).map {|r| r}
+    def prepare_task
+      @task.prepare
     end
 
-    def target_files
-      params = @params.dup
-      params.command = %{find #{params.files} | grep "\\.feature"}
-      runner = Runner.new(params)
-      runner.run
-      runner.status.log.split("\n")
+    def create_runners
+      @task.target_files.map {|file|
+        task = @task.dup
+        task.files = file
+        Runner.new(task, @connection)
+      }.each_slice(@task.concurrency).map {|r| r}
     end
 
-    def monitor_runners
-      @queue.all?{ |r| r.status }
-    end
   end
 
   class Runner
-    include Celluloid::IO
+    include Celluloid
+    extend Forwardable
 
-    attr_reader :status
+    def_delegator :@connection, :notify_info
 
-    def initialize(params)
-      @docker_client = Container::DockerClient.new
-      @status = nil
-      @params = params
+    def initialize(task, connection=nil)
+      @container = Docker::Container.create('Cmd' => [task.shell, task.opt, task.commands], 'Image' => task.image)
+      @connection = connection ? connection : Connection.new
+      @task = task
     end
 
     def run
-      start_runner do |result|
-        @status = Message::Response::RunnerFinish.new(
-           status_code: result.status_code,
-           container_id: result.container_id,
-           log: result.log,
-           file: @params.files,
-         )
-      end
-      sleep 0.1 # Stop a moment until RunnerManager checks the status
-    end
-
-    def start_runner
       max_retry = 3; count = 0
 
       begin
-        @docker_client.create_container(@params)
-        @docker_client.start_container
+        notify_info("Start container #{@container.id}")
+        @container.start
+        @container.wait(600) #TODO move to configuration
+        notify_info("Finish container #{@container.id}")
+
+        if @task.commit
+          notify_info("Committing the change of container #{@container.id}")
+          @container.commit({repo: @task.image}) if @task.commit
+        end
       rescue Excon::Errors::NotFound => e
         count += 1
         if count > max_retry
@@ -127,7 +70,13 @@ module Baleen
           retry
         end
       end
-      yield( @docker_client.result )
+
+      return {
+        status_code: @container.json["State"]["ExitCode"],
+        container_id: @container.id,
+        log: @container.attach(:stream => false, :stdout => true, :stderr => true, :logs => true),
+        file: @task.files,
+      }
     end
 
   end

data/lib/baleen/serializable.rb

@@ -0,0 +1,61 @@
+require "json"
+
+module Baleen
+  module Serializable
+
+    def self.deserialize(json_string)
+      params = JSON.parse(json_string)
+      klass = params.delete "klass"
+      Object.const_get(klass).new(symbolize_keys(params))
+    end
+
+    def self.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
+
+    # Dynamically define getter and setter for keys of @params
+    def method_missing(name, *args)
+      _name = name.to_s.sub("=", "")
+
+      if @params.has_key?(_name.to_sym)
+        self.class.class_eval{
+          define_method "#{_name}" do
+            @params[_name.to_sym]
+          end
+        }
+        self.class.class_eval{
+          define_method "#{_name}=" do |*args|
+           @params[_name.to_sym] = args.first
+          end
+        }
+        if name.to_s[-1, 1] == "="
+          send(name, args.first)
+        else
+          send(name)
+        end
+      else
+        raise NoMethodError.new("undefined method: #{name}", name, args)
+      end
+    end
+
+    def params
+      @params
+    end
+
+    def to_json
+      @params.to_json
+    end
+
+    def dup
+      copy_params = @params.dup
+      Object.const_get(self.class.to_s).new(copy_params)
+    end
+
+  end
+
+end

data/lib/baleen/server.rb

@@ -8,10 +8,13 @@ module Baleen
 
   class Server
     include Celluloid::IO
+    include Default
+
     finalizer :shutdown
 
-    def initialize(docker_host: "127.0.0.1", docker_port: 4243, port: 5533)
+    def initialize(docker_host, docker_port, port, project_file)
       Docker.url = "http://#{docker_host}:#{docker_port}"
+      Baleen::Project.load_project(project_file)
       @server = TCPServer.new("0.0.0.0", port)
       async.run
     end
@@ -21,7 +24,11 @@ module Baleen
     end
 
     def shutdown
-      @server.close if @server
+      begin
+        @server.close
+      rescue IOError
+        BL.info "Shutting down baleen-server..."
+      end
     end
 
     def handle_connection(socket)
@@ -31,36 +38,51 @@ module Baleen
       case ex
         when IOError; nil # when trying to close already closed socket
         else
-          warn "Unknown exception occured"
           puts ex.inspect
           raise ex
       end
     end
 
     def handle_request(socket)
-      message = socket.gets
+      json_request = socket.gets
 
-      if message.nil?
+      if json_request.nil?
         socket.close
         return
       end
-      msg = parse_request(message)
-
-      case msg
-        when Message::Request::ClientDisconnect
-          socket.close
-        when Message::Request::Cucumber
-          manager = RunnerManager.new(socket, msg)
-          manager.run
+
+      conn = Connection.new(socket)
+      request = parse_request(json_request)
+
+      begin
+        if request.is_a? Baleen::Task::RunProject
+          task = find_project(request.project, conn).task
         else
-          warn "Received unknown request"
-          puts msg.inspect
+          task = request # request itself is a task
+        end
+      rescue Baleen::Error::ProjectNotFound
+        return
+      end
+
+      RunnerManager.new(conn, task).run do |response|
+        conn.respond(response)
       end
     end
 
-    def parse_request(message)
-      Baleen::Message::Decoder.new(message).decode
+    def parse_request(request)
+      Serializable.deserialize(request)
+    end
+
+    def find_project(name, conn)
+      project = Baleen::Project.find_project_by_name(name.to_sym)
+
+      unless project
+        conn.notify_exception("No project found: #{name}")
+        raise Baleen::Error::ProjectNotFound
+      end
+
+      project
     end
   end
+end
 
-end

data/lib/baleen/task/base.rb

@@ -0,0 +1,55 @@
+module Baleen
+  module Task
+    class Base
+      include Serializable
+
+      def initialize
+        @params = {}
+        @params[:klass]          = self.class.to_s
+        @params[:shell]          = nil
+        @params[:opt]            = nil
+        @params[:work_dir]       = nil
+        @params[:files]          = nil
+        @params[:exe]            = nil
+        @params[:concurrency]    = nil
+        @params[:image]          = nil
+        @params[:before_command] = nil
+        @params[:command]        = nil
+        @params[:results]        = nil
+        @params[:status]         = nil
+        @params[:commit]         = nil
+      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 result
+        @params[:results]
+      end
+
+      def respond
+        nil
+      end
+
+      def terminate?
+        true
+      end
+
+    end
+  end
+end
+
+