torigoya_kit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82a26407253c5ae7ffc8a3174de840a837608bc4
+  data.tar.gz: 92531bc54c8dcad68b4a912f1800fa9f9fa84014
+SHA512:
+  metadata.gz: e9ff9c289032353b23984a022bd2f6951ca97dbb386293c4d4b2022cc974d1d6054822bcf47d2d11e1bc765ac72acb434ca12c4328436acdb783c33f9aba87c5
+  data.tar.gz: 64fc6d595dde4a30f8c39c9fb4d1d6f5881a2bd636201e2c5e2df5f68d1e3dd4078b7ea2636069d056e75256aa5f50db59f5656e6dfb2fbbd5c9b2d5f534f7ca

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in torigoya_kit.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 yutopp
+
+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 @@
+# TorigoyaKit
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'torigoya_kit'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install torigoya_kit
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/yutopp/torigoya_kit/fork )
+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 a new Pull Request

data/Rakefile

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

data/lib/torigoya_kit/client.rb

@@ -0,0 +1,45 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+require_relative 'session'
+
+module TorigoyaKit
+  class Client
+    def initialize(host, port)
+      @host = host
+      @port = port
+    end
+
+    ####
+    def exec_ticket(ticket)
+      return get_session().exec_ticket(ticket)
+    end
+
+    def exec_ticket_with_stream(ticket, &block)
+      return get_session().exec_ticket_with_stream(ticket, &block)
+    end
+
+    ####
+    def update_packages()
+      return get_session().update_packages()
+    end
+
+    ####
+    def reload_proc_table()
+      return get_session().reload_proc_table()
+    end
+
+    def update_proc_table()
+      return get_session().update_proc_table()
+    end
+
+    def get_proc_table()
+      return get_session().get_proc_table()
+    end
+
+    private
+    def get_session()
+      return Session.new(@host, @port)
+    end
+  end # class Client
+end # module TorigoyaKit

data/lib/torigoya_kit/package_utils.rb

@@ -0,0 +1,134 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+require 'yaml'
+require 'time'
+
+module TorigoyaKit
+  module Package
+
+    #
+    class Util
+      def self.package_name_regex
+        /^torigoya-([a-zA-Z0-9+]+)(-|_)(([a-zA-Z0-9]+\.?)+)(-1)?_.*\.deb$/
+      end
+
+      # return
+      # [name, raw_version]
+      def self.parse_package_name( package_name )
+        reg = package_name.scan( self.package_name_regex )
+        if reg[0].nil?
+          raise "#{package_name} is invalid package name..."
+        end
+
+        return reg[0].values_at( 0, 2 )
+      end
+    end
+
+
+    #
+    class Tag
+      def initialize( package_name )
+        #
+        @package_name = package_name
+        @name, version = Util.parse_package_name( package_name )
+        @version = version.gsub( /^(999.)(.*)/, "head" ).gsub( /^(888.)(.*)/, "dev" ).gsub( /^(777.)(.*)/, "stable" )
+        @display_version = version.gsub( /^(999.)/, "HEAD-" ).gsub( /^(888.)/, "DEV-" ).gsub( /^(777.)/, "STABLE-" )
+      end
+      attr_reader :package_name, :name, :version, :display_version
+    end
+
+
+    #
+    class AvailableProfile
+      def initialize( package_name, built_date )
+        @package_name = package_name
+        @built_date = built_date
+      end
+      attr_reader :package_name, :built_date
+
+      def to_yaml
+        return YAML.dump( {
+                            'package_name' => @package_name,
+                            'built_date' => @built_date
+                          } )
+      end
+
+      def self.from_yaml( yaml )
+        obj = YAML.load( yaml )
+        return self.new( obj['package_name'], obj['built_date'].instance_of?( String ) ? Time.parse( obj['built_date'] ) : obj['built_date'] )
+      end
+
+      def self.load_from_yaml( yaml_filename )
+        obj = YAML.load_file( yaml_filename )
+        return self.new( obj['package_name'], obj['built_date'].instance_of?( String ) ? Time.parse( obj['built_date'] ) : obj['built_date'] )
+      end
+    end
+
+
+    #
+    class ProfileHolder
+      def initialize( holder_path )
+        @holder_path = holder_path
+      end
+
+      def update_package( package_name, built_date )
+        profile_name = self.class.make_profile_name( package_name )
+        profile_path = "#{@holder_path}/#{profile_name}"
+        a_profile = AvailableProfile.new( package_name, built_date )
+
+        if File.exists?( profile_path )
+          # compare date
+          current_profile = AvailableProfile.load_from_yaml( profile_path )
+          if a_profile.built_date > current_profile.built_date
+            # update information
+            self.class.save_profile( profile_path, a_profile )
+          end
+        else
+          # save immediately
+          self.class.save_profile( profile_path, a_profile )
+        end
+
+        return profile_path
+      end
+
+      def delete_package( package_name )
+        profile_name = self.class.make_profile_name( package_name )
+        profile_path = "#{@holder_path}/#{profile_name}"
+
+        if File.exists?( profile_path )
+          system( "rm -f #{profile_path}" )
+        end
+
+        return profile_path
+      end
+
+      def list_profiles()
+        profs = []
+        Dir.chdir( @holder_path ) do
+          Dir.glob( '*.yml' ).sort_by {|f| File.mtime( f )}.reverse.each do |filename|
+            profs << AvailableProfile.load_from_yaml( filename )
+          end
+        end
+        return profs    # sorted old to new
+      end
+
+      def list_tag_and_date()
+        profs = list_profiles()
+        return profs.map{|e| { tags: Tag.new( e.package_name ), built_date: e.built_date } }
+      end
+
+      def self.save_profile( path, available_profile )
+        File.open( path, "w" ) do |f|
+          f.write( available_profile.to_yaml )
+        end
+      end
+
+      def self.make_profile_name( package_name )
+        tag = Tag.new( package_name )
+        return "#{tag.name}-#{tag.version}.yml"
+      end
+    end
+
+  end # module Packages
+end # module TorigoyaKit

data/lib/torigoya_kit/protocol.rb

@@ -0,0 +1,120 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+require 'msgpack'
+require_relative 'stream_result'
+
+module TorigoyaKit
+  #
+  class Protocol
+    #
+	MessageKindIndexBegin				= 0
+
+	# Sent from client
+	MessageKindAcceptRequest			= 0
+	MessageKindTicketRequest			= 1
+	MessageKindUpdateRepositoryRequest	= 2
+    MessageKindReloadProcTableRequest	= 3
+	MessageKindUpdateProcTableRequest	= 4
+	MessageKindGetProcTableRequest		= 5
+
+	# Sent from server
+    MessageKindAccept                   = 6
+	MessageKindOutputs					= 7
+	MessageKindResult					= 8
+	MessageKindSystemError				= 9
+	MessageKindExit						= 10
+
+    MessageKindSystemResult             = 11
+    MessageKindProcTable                = 12
+
+	#
+	MessageKindIndexEnd					= 12
+	MessageKindInvalid					= 0xff
+
+    #
+    HeaderLength = 5
+
+    #
+    class Packet
+      def initialize(kind, data)
+        if kind < MessageKindIndexBegin || kind > MessageKindIndexEnd
+          raise "invalid header"
+        end
+
+        @kind = [kind].pack("C*")
+        @encoded_data = data.to_msgpack
+        @size = [@encoded_data.size].pack("V*")
+      end
+      attr_reader :kind, :size, :encoded_data
+
+      #
+      def to_binary
+        return @kind + @size + @encoded_data
+      end
+    end
+
+    #
+    def self.encode(kind, data = nil)
+      return Packet.new(kind, data).to_binary
+    end
+
+    def self.encode_to(io, kind, data = nil)
+      io.write(encode(kind, data))
+    end
+
+    def self.get_responses(io)
+      results = []
+      decode_from_stream(io) do |r|
+        results << r
+      end
+
+      return results
+    end
+
+    #
+    def self.decode(buffer)
+      if buffer.size >= HeaderLength
+        # read kind
+        kind = buffer[0].unpack("c")[0]         # 8bit char
+
+        # read length
+        length = buffer[1..4].unpack("I")[0]    # 32bit unsigned int(little endian)
+
+        if buffer.size >= HeaderLength + length
+          return true, kind, length, buffer[HeaderLength...(HeaderLength + length)]
+        end
+      end
+
+      return false, nil, nil, nil
+    end
+
+    def self.cat_rest(buffer, length)
+      return buffer[(HeaderLength + length)..buffer.size]
+    end
+
+    #
+    def self.decode_as_client(kind, decoded)
+      case kind
+      when MessageKindAccept
+        return StreamAccept.new
+      when MessageKindOutputs
+        return StreamOutputResult.from_tuple(decoded)
+      when MessageKindResult
+        return StreamExecutedResult.from_tuple(decoded)
+      when MessageKindSystemError
+        return StreamSystemError.from_tuple(decoded)
+      when MessageKindExit
+        return StreamExit.from_tuple(decoded)
+
+      when MessageKindSystemResult
+        return StreamSystemStatusResult.new(decoded)
+      when MessageKindProcTable
+        return decoded
+      else
+        raise "Protocol :: Result kind(#{kind}) is not supported by clitnt side"
+      end
+    end
+
+  end # class Protocol
+end # module TorigoyaKit

data/lib/torigoya_kit/result.rb

@@ -0,0 +1,24 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+require_relative 'stream_result'
+
+module TorigoyaKit
+  class TicketResultUnit
+    def initialize()
+      @out = ""
+      @err = ""
+      @result = nil
+    end
+    attr_accessor :out, :err, :result
+  end
+
+  class TicketResult
+    def initialize
+      @compile = nil
+      @link = nil
+      @run = {}
+    end
+    attr_accessor :compile, :link, :run
+  end
+end # module TorigoyaKit

data/lib/torigoya_kit/session.rb

@@ -0,0 +1,214 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+require 'socket'
+require 'timeout'
+require_relative 'ticket'
+require_relative 'stream_result'
+require_relative 'result'
+require_relative 'protocol'
+
+module TorigoyaKit
+  class Session
+    Version = "v2014/7/5"
+
+    ########################################
+    #
+    def initialize(host, port)
+      # 5 sec
+      timeout(5) do
+        @socket = Socket.tcp(host, port)
+      end
+
+      @buffer = ""
+    end
+
+    ########################################
+    #
+    def exec_ticket(ticket)
+      result = TicketResult.new
+      exec_ticket_with_stream(ticket) do |res|
+        if res.is_a?(StreamOutputResult) || res.is_a?(StreamExecutedResult)
+          case res.mode
+          when ResultMode::CompileMode
+            result.compile = TicketResultUnit.new if result.compile.nil?
+          when ResultMode::LinkMode
+            result.link = TicketResultUnit.new if result.link.nil?
+          when ResultMode::RunMode
+            result.run[res.index] = TicketResultUnit.new if result.run[res.index].nil?
+          end
+
+          if res.is_a?(StreamOutputResult)
+            case res.output.fd
+            when StreamOutput::StdoutFd
+              case res.mode
+              when ResultMode::CompileMode
+                result.compile.out << res.output.buffer
+              when ResultMode::LinkMode
+                result.link.out << res.output.buffer
+              when ResultMode::RunMode
+                result.run[res.index].out << res.output.buffer
+              end
+            when StreamOutput::StderrFd
+              case res.mode
+              when ResultMode::CompileMode
+                result.compile.err << res.output.buffer
+              when ResultMode::LinkMode
+                result.link.err << res.output.buffer
+              when ResultMode::RunMode
+                result.run[res.index].err << res.output.buffer
+              end
+            end
+
+          elsif res.is_a?(StreamExecutedResult)
+            case res.mode
+            when ResultMode::CompileMode
+              result.compile.result = res.result
+            when ResultMode::LinkMode
+              result.link.result = res.result
+            when ResultMode::RunMode
+              result.run[res.index].result = res.result
+            end
+          end
+
+        elsif res.is_a?(StreamSystemError)
+          raise res.message
+        else
+          raise "Unexpected error: unknown message was recieved (#{res.class})"
+        end
+      end
+      return result
+    end
+
+    ########################################
+    #
+    def exec_ticket_with_stream(ticket, &block)
+      write(Protocol::MessageKindTicketRequest, ticket)
+      read_stream(&block)
+    end
+
+    ########################################
+    #
+    def update_packages()
+      write(Protocol::MessageKindUpdateRepositoryRequest)
+      res = read()
+      if res.is_a?(StreamSystemStatusResult)
+        return
+      elsif res.is_a?(StreamSystemError)
+        raise res.message
+      else
+        raise "Unexpected error: unknown message was recieved (#{res.class})"
+      end
+    end
+
+    ########################################
+    #
+    def reload_proc_table()
+      write(Protocol::MessageKindReloadProcTableRequest)
+      res = read()
+      if res.is_a?(StreamSystemStatusResult)
+        return
+      elsif res.is_a?(StreamSystemError)
+        raise res.message
+      else
+        raise "Unexpected error: unknown message was recieved (#{res.class})"
+      end
+    end
+
+    ########################################
+    #
+    def update_proc_table()
+      write(Protocol::MessageKindUpdateProcTableRequest)
+      res = read()
+      if res.is_a?(StreamSystemStatusResult)
+        return
+      elsif res.is_a?(StreamSystemError)
+        raise res.message
+      else
+        raise "Unexpected error: unknown message was recieved (#{res.class})"
+      end
+    end
+
+    ########################################
+    #
+    def get_proc_table()
+      write(Protocol::MessageKindGetProcTableRequest)
+      res = read()
+      if res.is_a?(Hash)
+        return res
+      elsif res.is_a?(StreamSystemError)
+        raise res.message
+      else
+        raise "Unexpected error: unknown message was recieved (#{res.class})"
+      end
+    end
+
+    ########################################
+    #########################################
+    private
+
+    ########################################
+    #
+    def read()
+      accepted = false
+      is_closed = false
+
+      loop do
+        begin
+          @buffer << @socket.readpartial(1024)
+        rescue EOFError
+          is_closed = true
+        end
+
+        is_recieved, kind, length, content = Protocol.decode(@buffer)
+        unless is_recieved
+          if is_closed
+            break
+          else
+            next
+          end
+        end
+
+        # set rest
+        @buffer = Protocol.cat_rest(@buffer, length)
+
+        return Protocol.decode_as_client(kind, MessagePack.unpack(content))
+      end # loop
+
+      return nil
+    end
+
+    ########################################
+    #
+    def read_stream(&block)
+      loop do
+        o = read()
+        break if o.nil?
+
+        break if o.is_a?(StreamExit)
+        block.call(o) unless block.nil?
+      end
+    end
+
+    ########################################
+    #
+    def write(kind, *args)
+      expect_accepted_by_server()
+      Protocol.encode_to(@socket, kind, *args)
+    end
+
+    ########################################
+    #
+    def expect_accepted_by_server
+      Protocol.encode_to(@socket, Protocol::MessageKindAcceptRequest, Version)
+      res = read()
+      if res.is_a?(StreamAccept)
+        return
+      elsif res.is_a?(StreamSystemError)
+        raise res.message
+      else
+        raise "Unexpected error: unknown message was recieved"
+      end
+    end
+  end # class Session
+end # module TorigoyaKit

data/lib/torigoya_kit/stream_result.rb

@@ -0,0 +1,161 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+module TorigoyaKit
+  class ResultMode
+    CompileMode = 0
+    LinkMode    = 1
+    RunMode     = 2
+  end
+
+  #
+  class StreamAccept
+  end
+
+  #
+  class StreamOutput
+    StdoutFd    = 0
+    StderrFd    = 1
+
+    def initialize(fd, buffer)
+      @fd = fd
+      @buffer = buffer
+    end
+    attr_reader :fd, :buffer
+
+    def self.from_tuple(tupled)
+      raise "type error [expected Array but #{message.class}] :: #{self}" unless tupled.is_a?(Array)
+      raise "invalid format(tuple size is different [expected 2 but #{tupled.size}] :: #{self})" unless tupled.size == 2
+
+      return StreamOutput.new(tupled[0], tupled[1])
+    end
+
+    def to_s
+      return "#{self.class}/[#{@fd} #{@buffer}]"
+    end
+  end
+
+  # related to MessageKindOutputs
+  class StreamOutputResult
+    def initialize(mode, index, output)
+      @mode = mode
+      @index = index
+      @output = output
+    end
+    attr_reader :mode, :index, :output
+
+    def self.from_tuple(tupled)
+      raise "type error [expected Array but #{message.class}] :: #{self}" unless tupled.is_a?(Array)
+      raise "invalid format(tuple size is different [expected 3 but #{tupled.size}] :: #{self})" unless tupled.size == 3
+
+      return StreamOutputResult.new(tupled[0],
+                                    tupled[1],
+                                    StreamOutput.from_tuple(tupled[2])
+                                    )
+    end
+
+    def to_s
+      return "#{self.class}/[#{@mode} #{@index} #{@output.to_s}]"
+    end
+  end
+
+  #
+  class ExecutedResult
+    def initialize(cpu_time, memory, signal, return_code, command_line, status, error_message)
+      @used_cpu_time_sec = cpu_time
+      @used_memory_bytes = memory
+      @signal = signal
+      @return_code = return_code
+      @command_line = command_line
+      @status = status
+      @system_error_message = error_message
+    end
+    attr_reader :used_cpu_time_sec, :used_memory_bytes, :signal, :return_code, :command_line, :status, :system_error_message
+
+    def self.from_tuple(tupled)
+      raise "type error [expected Array but #{message.class}] :: #{self}" unless tupled.is_a?(Array)
+      raise "invalid format(tuple size is different [expected 7 but #{tupled.size}] :: #{self})" unless tupled.size == 7
+
+      return ExecutedResult.new(tupled[0],
+                                tupled[1],
+                                tupled[2],
+                                tupled[3],
+                                tupled[4],
+                                tupled[5],
+                                tupled[6]
+                                )
+    end
+
+    def to_s
+      return "#{self.class}/[#{@used_cpu_time_sec} #{@used_memory_bytes} #{@signal} #{@return_code} #{@command_line} #{@status} #{@system_error_message}]"
+    end
+  end
+
+  # related to StreamExecutedResult
+  class StreamExecutedResult
+    def initialize(mode, index, result)
+      @mode = mode
+      @index = index
+      @result = result
+    end
+    attr_reader :mode, :index, :result
+
+    def self.from_tuple(tupled)
+      raise "type error [expected Array but #{message.class}] :: #{self}" unless tupled.is_a?(Array)
+      raise "invalid format(tuple size is different [expected 3 but #{tupled.size}] :: #{self})" unless tupled.size == 3
+
+      return StreamExecutedResult.new(tupled[0],
+                                      tupled[1],
+                                      ExecutedResult.from_tuple(tupled[2])
+                                      )
+    end
+
+    def to_s
+      return "#{self.class}/[#{@mode} #{@index} #{@result.to_s}]"
+    end
+  end
+
+  # related to MessageKindSystemError
+  class StreamSystemError
+    def initialize(message)
+      @message = message
+    end
+    attr_reader :message
+
+    def self.from_tuple(message)
+      raise "type error [expected String but #{message.class}] :: #{self}" unless message.is_a?(String)
+
+      return StreamSystemError.new(message)
+    end
+
+    def to_s
+      return "#{self.class}/[#{@message}]"
+    end
+  end
+
+  # related to MessageKindExit
+  class StreamExit
+    def initialize(message)
+      @message = message
+    end
+    attr_reader :message
+
+    def self.from_tuple(message)
+      raise "type error [expected String but #{message.class}] :: #{self}" unless message.is_a?(String)
+
+      return StreamExit.new(message)
+    end
+
+    def to_s
+      return "#{self.class}/[#{@message}]"
+    end
+  end
+
+  #
+  class StreamSystemStatusResult
+    def initialize(status)
+      @status = status
+    end
+    attr_reader :status
+  end
+end # module TorigoyaKit

data/lib/torigoya_kit/ticket.rb

@@ -0,0 +1,132 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+
+require 'msgpack'
+
+module TorigoyaKit
+  # contains source codes / inputs data
+  class SourceData
+    def self.make_with_compress(name, code)
+      return self.new(name, code, true)
+    end
+
+    def initialize(name, code, is_compressed = false)
+      @name = name
+      @code = if is_compressed then
+              else
+                code
+              end
+      @is_compressed = is_compressed
+    end
+    attr_reader :name, :code
+
+    def to_tuple
+      return [@name,
+              @code,
+              @is_compressed
+             ]
+    end
+
+    def to_msgpack(out = '')
+      return to_tuple.to_msgpack(out)
+    end
+  end
+
+  #
+  class ExecutionSetting
+    def initialize(command_line, structured_command, cpu_limit, memory_limit)
+      @command_line = command_line              # String
+      @structured_command = structured_command  # Array!(Array!String)
+      @cpu_limit = cpu_limit                    # uint64 / sec
+      @memory_limit = memory_limit              # uint64 / bytes
+    end
+
+    def to_tuple
+      return [@command_line,
+              @structured_command,
+              @cpu_limit,
+              @memory_limit
+             ]
+    end
+
+    def to_msgpack(out = '')
+      return to_tuple.to_msgpack(out)
+    end
+  end
+
+  #
+  class BuildInstruction
+    def initialize(compile_setting, link_setting)
+      @compile_setting = compile_setting    # ExecutionSetting
+      @link_setting = link_setting          # ExecutionSetting
+    end
+
+    def to_tuple
+      return [@compile_setting.to_tuple,
+              @link_setting.to_tuple
+             ]
+    end
+
+    def to_msgpack(out = '')
+      return to_tuple.to_msgpack(out)
+    end
+  end
+
+  #
+  class Input
+    def initialize(stdin, run_setting)
+      @stdin = stdin                # SourceData
+      @run_setting = run_setting    # ExecutionSetting
+    end
+
+    def to_tuple
+      return [@stdin, @run_setting]
+    end
+
+    def to_msgpack(out = '')
+      return to_tuple.to_msgpack(out)
+    end
+  end
+
+  #
+  class RunInstruction
+    def initialize(inputs)
+      @inputs = inputs      # Array!Input
+    end
+
+    def to_tuple
+      return [@inputs.map {|x| x.to_tuple}]
+    end
+
+    def to_msgpack(out = '')
+      return to_tuple.to_msgpack(out)
+    end
+  end
+
+  #
+  class Ticket
+    def initialize(base_name, proc_id, proc_version, source_codes, build_inst, run_inst)
+      @base_name = base_name
+      @proc_id = proc_id
+      @proc_version = proc_version
+      @source_codes = source_codes      # Array!SourceData
+      @build_inst = build_inst          # BuildInstruction
+      @run_inst = run_inst              # RunInstruction
+    end
+
+    def to_tuple
+      return [@base_name,
+              @proc_id,
+              @proc_version,
+              @source_codes.map {|x| x.to_tuple},
+              @build_inst.to_tuple,
+              @run_inst.to_tuple
+             ]
+    end
+
+    def to_msgpack
+      return to_tuple.to_msgpack()
+    end
+  end
+
+end # module TorigoyaKit

data/lib/torigoya_kit/version.rb

@@ -0,0 +1,3 @@
+module TorigoyaKit
+  VERSION = "0.0.1"
+end

data/lib/torigoya_kit.rb

@@ -0,0 +1,10 @@
+require "torigoya_kit/version"
+
+require_relative 'torigoya_kit/protocol'
+require_relative 'torigoya_kit/ticket'
+require_relative 'torigoya_kit/stream_result'
+require_relative 'torigoya_kit/result'
+require_relative 'torigoya_kit/session'
+require_relative 'torigoya_kit/client'
+
+require_relative 'torigoya_kit/package_utils.rb'

data/spec/cases/package_utils_spec.rb

@@ -0,0 +1,161 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+require 'tmpdir'
+require_relative '../spec_helper'
+
+describe :package_utils do
+  it "test_util" do
+    expect(TorigoyaKit::Package::Util.parse_package_name("torigoya-llvm-3.4_3.4_amd64.deb")).to eq ['llvm', '3.4']
+
+    expect(TorigoyaKit::Package::Util.parse_package_name("torigoya-llvm_999.2014.4.4.205650_amd64.deb")).to eq ['llvm', '999.2014.4.4.205650']
+
+    expect do
+      TorigoyaKit::Package::Util.parse_package_name("torigababa64.deb")
+    end.to raise_error RuntimeError
+  end
+
+  it "test_tag_1" do
+    tag = TorigoyaKit::Package::Tag.new("torigoya-llvm-3.4_3.4_amd64.deb")
+    expect(tag.package_name).to eq "torigoya-llvm-3.4_3.4_amd64.deb"
+    expect(tag.name).to eq "llvm"
+    expect(tag.version).to eq "3.4"
+    expect(tag.display_version).to eq "3.4"
+  end
+
+  it "test_tag_j1" do
+    tag = TorigoyaKit::Package::Tag.new("torigoya-java9_999.2014.4.8.e912167e7ecf_amd64.deb")
+    expect(tag.package_name).to eq "torigoya-java9_999.2014.4.8.e912167e7ecf_amd64.deb"
+    expect(tag.name).to eq "java9"
+    expect(tag.version).to eq "head"
+    expect(tag.display_version).to eq "HEAD-2014.4.8.e912167e7ecf"
+  end
+
+  it "test_tag_21" do
+    tag = TorigoyaKit::Package::Tag.new("torigoya-llvm_999.2014.4.4.205650_amd64.deb")
+    expect(tag.package_name).to eq "torigoya-llvm_999.2014.4.4.205650_amd64.deb"
+    expect(tag.name).to eq "llvm"
+    expect(tag.version).to eq "head"
+    expect(tag.display_version).to eq "HEAD-2014.4.4.205650"
+  end
+
+  it "test_tag_22" do
+    tag = TorigoyaKit::Package::Tag.new( "torigoya-llvm_888.2014.4.4.205650_amd64.deb" )
+    expect(tag.package_name).to eq "torigoya-llvm_888.2014.4.4.205650_amd64.deb"
+    expect(tag.name).to eq "llvm"
+    expect(tag.version).to eq "dev"
+    expect(tag.display_version).to eq "DEV-2014.4.4.205650"
+  end
+
+  it "test_tag_23" do
+    tag = TorigoyaKit::Package::Tag.new( "torigoya-llvm_777.2014.4.4.205650_amd64.deb" )
+    expect(tag.package_name).to eq "torigoya-llvm_777.2014.4.4.205650_amd64.deb"
+    expect(tag.name).to eq "llvm"
+    expect(tag.version).to eq "stable"
+    expect(tag.display_version).to eq "STABLE-2014.4.4.205650"
+  end
+
+  it "test_tag_2" do
+    expect do
+      tag = TorigoyaKit::Package::Tag.new( "torigababa64.deb" )
+    end.to raise_error(RuntimeError)
+  end
+
+  it "test_prof_update_exist" do
+    Dir.mktmpdir do |dir|
+      h = TorigoyaKit::Package::ProfileHolder.new( dir )
+
+      p_name = "torigoya-llvm_999.2014.4.4.205650_amd64.deb"
+      new_p_time = Time.now()
+
+      begin
+        f_path = h.update_package( p_name, new_p_time )
+
+        expect(f_path).to eq "#{dir}/llvm-head.yml"
+        expect(File.exists?(f_path)).to eq true
+      end
+    end # Dir
+  end
+
+  it "test_prof_update" do
+    Dir.mktmpdir do |dir|
+      h = TorigoyaKit::Package::ProfileHolder.new( dir )
+
+      p_name = "torigoya-llvm_999.2014.4.4.205650_amd64.deb"
+      new_p_time = Time.now()
+      updated_p_time = new_p_time + 100
+
+      begin
+        f_path = h.update_package( p_name, new_p_time )
+
+        expect(File.exists?(f_path)).to eq true
+        f_y = TorigoyaKit::Package::AvailableProfile.load_from_yaml(f_path)
+        expect(f_y.package_name).to eq p_name
+        expect(f_y.built_date).to eq new_p_time
+      end
+
+      begin
+        # Latest File
+        f_path = h.update_package(p_name, updated_p_time)
+
+        expect(File.exists?( f_path )).to eq true
+        f_y = TorigoyaKit::Package::AvailableProfile.load_from_yaml(f_path)
+        expect(f_y.package_name).to eq p_name
+        expect(f_y.built_date).to eq updated_p_time
+      end
+
+      begin
+        f_path = h.update_package(p_name, new_p_time)
+
+        expect(File.exists?(f_path)).to eq true
+        f_y = TorigoyaKit::Package::AvailableProfile.load_from_yaml(f_path)
+        expect(f_y.package_name).to eq p_name
+        expect(f_y.built_date).to eq updated_p_time
+      end
+    end # Dir
+  end
+
+  it "test_prof_delete" do
+    Dir.mktmpdir do |dir|
+      h = TorigoyaKit::Package::ProfileHolder.new(dir)
+
+      p_name = "torigoya-llvm_999.2014.4.4.205650_amd64.deb"
+      new_p_time = Time.now()
+
+      begin
+        f_path = h.update_package(p_name, new_p_time)
+        expect(File.exists?(f_path)).to eq true
+      end
+
+      begin
+        f_path = h.delete_package(p_name)
+        expect(File.exists?(f_path)).to eq false
+      end
+    end # Dir
+  end
+
+  it "test_prof_list" do
+    Dir.mktmpdir do |dir|
+      h = TorigoyaKit::Package::ProfileHolder.new(dir)
+
+      build_date = Time.now
+      pkgs = [{ name: "torigoya-llvm-3.4_3.4_amd64.deb", date: build_date },
+              { name: "torigoya-llvm_999.2014.4.4.205650_amd64.deb", date: build_date },                    ]
+
+      begin
+        pkgs.each do |e|
+          h.update_package(e[:name], e[:date])
+        end
+      end
+
+      begin
+        profs = h.list_profiles
+
+        expect(profs.length).to eq 2
+        expect(profs[0].package_name).to eq pkgs[0][:name]
+        expect(profs[0].built_date).to eq pkgs[0][:date]
+        expect(profs[1].package_name).to eq pkgs[1][:name]
+        expect(profs[1].built_date).to eq pkgs[1][:date]
+      end
+    end # Dir
+  end
+end

data/spec/cases/protocol_spec.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+require_relative '../spec_helper'
+
+describe :request_protocol do
+  b = TorigoyaKit::Protocol::Packet.new(TorigoyaKit::Protocol::MessageKindAcceptRequest, 12345)
+
+  it "size of kind should be 1" do
+    expect(b.kind.size).to eq 1
+  end
+
+  it "kind should be TorigoyaKit::Protocol::MessageKindAcceptRequest" do
+    expect(b.kind.bytes).to eq [0x00]
+  end
+
+  it "size of size should be 3" do
+    expect(b.size.size).to eq 4
+  end
+
+  it "size should be [0x03, 0x00, 0x00, 0x00]" do
+    expect(b.size.bytes).to eq [0x03, 0x00, 0x00, 0x00]
+  end
+
+  it "size of encoded_data should be 3" do
+    expect(b.encoded_data.size).to eq 3
+  end
+
+  it "encoded_data should be [205, 48, 57]" do
+    expect(b.encoded_data.bytes).to eq [205, 48, 57]
+  end
+end

data/spec/cases/session_spec.rb

@@ -0,0 +1,18 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+require_relative '../spec_helper'
+
+describe :session do
+  it "session proc exec_ticket" do
+    s = TorigoyaKit::Session.new("localhost", 49800)
+    p s.exec_ticket(make_ticket())
+  end
+
+  it "session proc update_proc_table" do
+    #s = TorigoyaKit::Session.new("localhost", 22222)
+    #s.update_packages()
+    #s.exec_ticket(make_ticket())
+    #s.update_proc_table()
+    #p s.get_proc_table()
+  end
+end

data/spec/cases/ticket_spec.rb

@@ -0,0 +1,15 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+require_relative '../spec_helper'
+
+describe :ticket do
+  ticket = make_ticket()
+
+  it "aaa" do
+    expect(ticket).not_to eq nil
+  end
+
+  it "aaa" do
+    expect(ticket.to_msgpack).not_to eq nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+# Copyright (c) 2014 yutopp
+# Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
+require 'torigoya_kit'
+
+def make_ticket
+  # source
+  source = TorigoyaKit::SourceData.new("prog.cpp", <<EOS
+#include <csignal>
+#include <iostream>
+
+int main() {
+    std::cout << "hello!" << std::endl;
+    std::raise(8);
+    std::cout << "unreachable!" << std::endl;
+}
+EOS
+)
+
+  # set of source
+  sources = [source]
+
+  # build instruction
+  bi = TorigoyaKit::BuildInstruction.new(TorigoyaKit::ExecutionSetting.new("", [], 10, 512 * 1024 * 1024),
+                                         TorigoyaKit::ExecutionSetting.new("", [], 10, 512 * 1024 * 1024)
+                                        )
+  # input
+  input = TorigoyaKit::Input.new(nil,
+                                 TorigoyaKit::ExecutionSetting.new("", [], 10, 512 * 1024 * 1024)
+                                 )
+
+  # inputs
+  inputs = [input]
+
+  # run instruction
+  ri = TorigoyaKit::RunInstruction.new(inputs)
+
+  # ticket!
+  ticket = TorigoyaKit::Ticket.new("aaa", 0, "test", sources, bi, ri)
+
+  return ticket
+end

data/torigoya_kit.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'torigoya_kit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "torigoya_kit"
+  spec.version       = TorigoyaKit::VERSION
+  spec.authors       = ["yutopp"]
+  spec.email         = ["yutopp@gmail.com"]
+  spec.summary       = %q{Toolkits for Torigoya}
+  spec.description   = %q{This library can control TorigoyaCage}
+  spec.homepage      = "http://yutopp.net/"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "msgpack"
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: torigoya_kit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- yutopp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: msgpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This library can control TorigoyaCage
+email:
+- yutopp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/torigoya_kit.rb
+- lib/torigoya_kit/client.rb
+- lib/torigoya_kit/package_utils.rb
+- lib/torigoya_kit/protocol.rb
+- lib/torigoya_kit/result.rb
+- lib/torigoya_kit/session.rb
+- lib/torigoya_kit/stream_result.rb
+- lib/torigoya_kit/ticket.rb
+- lib/torigoya_kit/version.rb
+- spec/cases/package_utils_spec.rb
+- spec/cases/protocol_spec.rb
+- spec/cases/session_spec.rb
+- spec/cases/ticket_spec.rb
+- spec/spec_helper.rb
+- torigoya_kit.gemspec
+homepage: http://yutopp.net/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Toolkits for Torigoya
+test_files:
+- spec/cases/package_utils_spec.rb
+- spec/cases/protocol_spec.rb
+- spec/cases/session_spec.rb
+- spec/cases/ticket_spec.rb
+- spec/spec_helper.rb