torigoya_kit 0.0.11 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77a01b6fe9e41f3b05790e8818d55c831b46fc60
-  data.tar.gz: 51d22cfa528a46b4597fc83bd3d3695aafa2a9d2
+  metadata.gz: fb896dfb27fba5b772fb9c0b2562ca7e2dd2ccd4
+  data.tar.gz: 250b1853f23f08d132295b92888597d08b6af0a1
 SHA512:
-  metadata.gz: 8fdca898c31ef7f6f8ded53c2457a6eb777217b8c9f32a0074f2a351ac35c8461e12931e63be51dce8dda44d607f054eb00df3dda309c105b590f53434533724
-  data.tar.gz: 6436e9d9e8f47f280d309c3bb724c1f7d14dc5596d5cdd5ec80785d232e8ddd24548dff35faacd17c9625f1d785f5d045eda8f1f6cfd18bdde08f7657c9279e9
+  metadata.gz: 96ccd817a7fed70dadce93175d78deaacee4d87d9ed231b7aaa5de293f92241665043e464473d594e82bb17230390a4de56391b2b472e5109ca39ec9de359a54
+  data.tar.gz: 1048f3c0cf79e25fb4b3403b7f160722482999e76af44b41eaec7ce70ab75445bbb6474a81e5634537666960ab074b6175fb8bc1a4edca73206a28d53736575e

data/lib/torigoya_kit/client.rb

@@ -12,33 +12,33 @@ module TorigoyaKit
 
     ####
     def exec_ticket(ticket)
-      return get_session().exec_ticket(ticket)
+      return new_session().exec_ticket(ticket)
     end
 
     def exec_ticket_with_stream(ticket, &block)
-      return get_session().exec_ticket_with_stream(ticket, &block)
+      return new_session().exec_ticket_with_stream(ticket, &block)
     end
 
     ####
     def update_packages()
-      return get_session().update_packages()
+      return new_session().update_packages()
     end
 
     ####
     def reload_proc_table()
-      return get_session().reload_proc_table()
+      return new_session().reload_proc_table()
     end
 
     def update_proc_table()
-      return get_session().update_proc_table()
+      return new_session().update_proc_table()
     end
 
     def get_proc_table()
-      return get_session().get_proc_table()
+      return new_session().get_proc_table()
     end
 
     private
-    def get_session()
+    def new_session()
       return Session.new(@host, @port)
     end
   end # class Client

data/lib/torigoya_kit/protocol.rb

@@ -11,109 +11,114 @@ module TorigoyaKit
 	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
+	MessageKindIndexEnd					= 11
 	MessageKindInvalid					= 0xff
 
     #
-    HeaderLength = 5
+    HeaderLength = 2 + 1 + 4 + 4
 
     #
+    # Signature         [2]byte     //
+	# MessageKind       byte        //
+	# Version           [4]byte     // uint32, little endian
+	# Length            [4]byte     // uint32, little endian
+	# Message           []byte      // data, msgpacked
     class Packet
-      def initialize(kind, data)
+      Signature = "TG"
+
+      def initialize(kind, version, 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*")
+        @kind = [kind].pack("C*")               # byte
+        @version = [version].pack("V*")         # little endian, 32bit, unsigned int
+        @message = data.to_msgpack              # msgpacked
+        @length = [@message.size].pack("V*")    # little endian, 32bit, unsigned int
       end
-      attr_reader :kind, :size, :encoded_data
+      attr_reader :kind, :version, :message, :length
 
       #
       def to_binary
-        return @kind + @size + @encoded_data
+        return Signature + @kind + @version + @length + @message
       end
     end
 
-    #
-    def self.encode(kind, data = nil)
-      return Packet.new(kind, data).to_binary
+    class Frame
+      def initialize(kind, buffer)
+        @kind = kind
+        @raw_object = MessagePack.unpack(buffer)
+      end
+      attr_reader :kind, :raw_object
+
+      def get_object
+        case @kind
+        when MessageKindOutputs
+          return StreamOutputResult.from_hash(@raw_object)
+        when MessageKindResult
+          return StreamExecutedResult.from_hash(@raw_object)
+        when MessageKindSystemError
+          return StreamSystemError.new(@raw_object)
+        when MessageKindExit
+          return StreamExit.new(@raw_object)
+
+        when MessageKindSystemResult
+          return StreamSystemResult.new(@raw_object)
+        else
+          raise "Protocol :: Result kind(#{kind}) is not supported by clitnt side"
+        end
+      end
     end
 
-    def self.encode_to(io, kind, data = nil)
-      io.write(encode(kind, data))
+    class InvalidFrame < RuntimeError
     end
 
-    def self.get_responses(io)
-      results = []
-      decode_from_stream(io) do |r|
-        results << r
-      end
+    # ============================================================
 
-      return results
+    def self.encode(kind, version, data)
+      return Packet.new(kind, version, data).to_binary
     end
 
-    #
-    def self.decode(buffer)
+    def self.decode(buffer, expected_version)
       if buffer.size >= HeaderLength
+        # read signature
+        signature = buffer[0...2]
+        if signature != Packet::Signature
+          raise InvalidFrame.new("Invalid Signature")
+        end
+
         # read kind
-        kind = buffer[0].unpack("c")[0]         # 8bit char
+        kind = buffer[2].unpack("c")[0]         # 8bit signed char
+
+        # read version
+        version = buffer[3...7].unpack("I")[0]  # 32bit unsigned int(little endian)
+        if version != expected_version
+          raise InvalidFrame.new("Invalid Version")
+        end
 
         # read length
-        length = buffer[1..4].unpack("I")[0]    # 32bit unsigned int(little endian)
+        length = buffer[7...11].unpack("I")[0]  # 32bit unsigned int(little endian)
 
+        # read body
         if buffer.size >= HeaderLength + length
-          return true, kind, length, buffer[HeaderLength...(HeaderLength + length)]
+          next_buffer = buffer[(HeaderLength + length)...buffer.size]
+          return Frame.new(kind, buffer[HeaderLength...(HeaderLength + length)]), next_buffer
         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
+      return nil, buffer
     end
 
   end # class Protocol

data/lib/torigoya_kit/session.rb

@@ -10,7 +10,7 @@ require_relative 'protocol'
 
 module TorigoyaKit
   class Session
-    Version = "v2014/7/5"
+    Version = 20150715
 
     ########################################
     #
@@ -83,96 +83,52 @@ module TorigoyaKit
     ########################################
     #
     def exec_ticket_with_stream(ticket, &block)
-      write(Protocol::MessageKindTicketRequest, ticket)
-      read_stream(&block)
-    end
+      send(Protocol::MessageKindTicketRequest, ticket)
 
-    ########################################
-    #
-    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
+      recv_stream(&block)
     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 update_packages()
+      send(Protocol::MessageKindUpdateRepositoryRequest, nil)
 
-    ########################################
-    #
-    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})"
+      recv_stream() do |res|
+        if res.is_a?(StreamSystemResult)
+          return res.status
+        elsif res.is_a?(StreamSystemError)
+          raise res.message
+        else
+          raise "Unexpected error: unknown message was recieved (#{res.class})"
+        end
       end
     end
 
     ########################################
-    #########################################
     private
 
     ########################################
     #
-    def read()
-      accepted = false
+    def recv_frame_object()
       is_closed = false
 
       loop do
         begin
-          @buffer << @socket.readpartial(1024)
+          @buffer << @socket.readpartial(8096)
         rescue EOFError
           is_closed = true
         end
 
-        is_recieved, kind, length, content = Protocol.decode(@buffer)
-        unless is_recieved
+        frame, @buffer = Protocol.decode(@buffer, Version)
+        if frame.nil?
           if is_closed
-            break
+            break   # finish loop
           else
-            next
+            next    # try to read data
           end
         end
 
-        # set rest
-        @buffer = Protocol.cat_rest(@buffer, length)
-
-        return Protocol.decode_as_client(kind, MessagePack.unpack(content))
+        return frame.get_object()
       end # loop
 
       return nil
@@ -180,35 +136,21 @@ module TorigoyaKit
 
     ########################################
     #
-    def read_stream(&block)
+    def recv_stream(&block)
       loop do
-        o = read()
-        break if o.nil?
+        obj = recv_frame_object()
+        raise "object is empty" if obj.nil?
 
-        break if o.is_a?(StreamExit)
-        block.call(o) unless block.nil?
+        break if obj.is_a?(StreamExit)
+        block.call(obj) unless block.nil?
       end
     end
 
     ########################################
     #
-    def write(kind, *args)
-      expect_accepted_by_server()
-      Protocol.encode_to(@socket, kind, *args)
+    def send(kind, args)
+      @socket.write(Protocol.encode(kind, Version, 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

@@ -1,6 +1,8 @@
-# Copyright (c) 2014 yutopp
+# Copyright (c) 2014 - 2015 yutopp
 # Licenced under the MIT License (http://www.opensource.org/licenses/mit-license.php)
 
+require_relative 'typeutil'
+
 module TorigoyaKit
   class ResultMode
     CompileMode = 0
@@ -8,10 +10,6 @@ module TorigoyaKit
     RunMode     = 2
   end
 
-  #
-  class StreamAccept
-  end
-
   #
   class StreamOutput
     StdoutFd    = 0
@@ -20,19 +18,24 @@ module TorigoyaKit
     def initialize(fd, buffer)
       @fd = fd
       @buffer = buffer
+
+      validate
     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])
+    def self.from_hash(hash)
+      return StreamOutput.new(hash["fd"], hash["buffer"])
     end
 
     def to_s
       return "#{self.class}/[#{@fd} #{@buffer}]"
     end
+
+    private
+    def validate()
+      TypeUtil.nonnull_type_check(self, "fd", @fd, Integer)
+      TypeUtil.nonnull_type_check(self, "buffer", @buffer, String)
+    end
   end
 
   # related to MessageKindOutputs
@@ -41,53 +44,76 @@ module TorigoyaKit
       @mode = mode
       @index = index
       @output = output
+
+      validate
     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])
-                                    )
+    def self.from_hash(hash)
+      return StreamOutputResult.new(
+               hash["mode"],
+               hash["index"],
+               StreamOutput.from_hash(hash["output"])
+             )
     end
 
     def to_s
       return "#{self.class}/[#{@mode} #{@index} #{@output.to_s}]"
     end
+
+    private
+    def validate()
+      TypeUtil.nonnull_type_check(self, "mode", @mode, Integer)
+      TypeUtil.nonnull_type_check(self, "index", @index, Integer)
+      TypeUtil.nonnull_type_check(self, "output", @output, StreamOutput)
+    end
   end
 
   #
   class ExecutedResult
-    def initialize(cpu_time, memory, signal, return_code, command_line, status, error_message)
+    def initialize(exited, exit_status, signaled, signal, cpu_time, memory, s_es, s_em)
+      @exited = exited
+      @exit_status = exit_status
+      @signaled = signaled
+      @signal = signal
+
       @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
+      @system_error_status = s_es
+      @system_error_message = s_em
 
-      return ExecutedResult.new(tupled[0],
-                                tupled[1],
-                                tupled[2],
-                                tupled[3],
-                                tupled[4],
-                                tupled[5],
-                                tupled[6]
-                                )
+      validate
     end
+    attr_reader :exited, :exit_status, :signaled, :signal
+    attr_reader :used_cpu_time_sec, :used_memory_bytes
+    attr_reader :system_error_status, :system_error_message
 
-    def to_s
-      return "#{self.class}/[#{@used_cpu_time_sec} #{@used_memory_bytes} #{@signal} #{@return_code} #{@command_line} #{@status} #{@system_error_message}]"
+    def self.from_hash(hash)
+      return ExecutedResult.new(
+               hash["exited"],
+               hash["exit_status"],
+               hash["signaled"],
+               hash["signal"],
+               hash["used_cpu_time_sec"],
+               hash["used_memory_bytes"],
+               hash["system_error_status"],
+               hash["system_error_message"],
+             )
+    end
+
+    private
+    def validate()
+      TypeUtil.nonnull_boolean_type_check(self, "exited", @exited)
+      TypeUtil.nonnull_type_check(self, "exit_status", @exit_status, Integer)
+      TypeUtil.nonnull_boolean_type_check(self, "signaled", @signaled)
+      TypeUtil.nonnull_type_check(self, "signal", @signal, Integer)
+
+      TypeUtil.nonnull_type_check(self, "used_cpu_time_sec", @used_cpu_time_sec, Float)
+      TypeUtil.nonnull_type_check(self, "used_memory_bytes", @used_memory_bytes, Integer)
+
+      TypeUtil.nonnull_type_check(self, "system_error_status", @system_error_status, Integer)
+      TypeUtil.nonnull_type_check(self, "system_error_message", @system_error_message, String)
     end
   end
 
@@ -97,62 +123,71 @@ module TorigoyaKit
       @mode = mode
       @index = index
       @result = result
+
+      validate
     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])
-                                      )
+    def self.from_hash(hash)
+      return StreamExecutedResult.new(
+               hash["mode"],
+               hash["index"],
+               ExecutedResult.from_hash(hash["result"])
+             )
     end
 
     def to_s
       return "#{self.class}/[#{@mode} #{@index} #{@result.to_s}]"
     end
+
+    private
+    def validate()
+      TypeUtil.nonnull_type_check(self, "mode", @mode, Integer)
+      TypeUtil.nonnull_type_check(self, "index", @index, Integer)
+      TypeUtil.nonnull_type_check(self, "result", @result, ExecutedResult)
+    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)
+      validate
     end
+    attr_reader :message
 
     def to_s
       return "#{self.class}/[#{@message}]"
     end
+
+    private
+    def validate()
+      TypeUtil.nonnull_type_check(self, "message", @message, String)
+    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)
+      validate
     end
+    attr_reader :message
 
     def to_s
       return "#{self.class}/[#{@message}]"
     end
+
+    private
+    def validate()
+      TypeUtil.nonnull_type_check(self, "message", @message, String)
+    end
   end
 
   #
-  class StreamSystemStatusResult
+  class StreamSystemResult
     def initialize(status)
       @status = status
     end