kinetic-ruby 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b867b06ff9ff5869339c23c1e75c77e592a4927
-  data.tar.gz: 463579647bc42a1cb002bd24412696572c683e85
+  metadata.gz: 7f7c34a6be5838b4d0dfb7fdee59c5e4ce5678da
+  data.tar.gz: be5746db50b0fea02b0f89c91279b7dc74ea0771
 SHA512:
-  metadata.gz: 8e3e14bb6f463040bee482b4eb15eb9c64757d7a536add1e7a542b0476a02715349eb5d66b382aa92c860ca1ba77a172f7ad5ec26aa2de48da1b1a007e54bf14
-  data.tar.gz: b87f4e1e204d5b2781d910232b5854041a7ee000873b6150a5cf9da4109e75c3eaebdf8aa7f61c13ba93f8569ed9954a66ba0368b4dd061bdb4e247ebccd5e35
+  metadata.gz: 87433d1fa160efdac86af6f9e2eb22e43fbcad3f2def7fc3f309559b319e8a0acbdc6b9d10db007d102fc5e961a3ad92b81f6d049d05da33f7d9d3fc540a2bcc
+  data.tar.gz: 41389bc4b0bbc3cef02b0793e930767796669a09865dee1295c2d3b585fd12317a333035bd5df297c5ab8cd09428bd713fed174643e240e61cdadcd2ad7d9402

data/Rakefile

@@ -11,18 +11,17 @@ namespace :test do
   desc "Test Kinetic Ruby server"
   task :server => 'kinetic:server:start' do
     report "Started Kinetic Ruby server!"
-    sleep 2.0
     client = Thread.new do
-      report "Connecting test client to #{$kinetic_server.host}:#{$kinetic_server.port}..."
-      sh "telnet #{$kinetic_server.host} #{$kinetic_server.port}"
+      addr = $kinetic_server.host + ':' + $kinetic_server.port.to_s
+      report "Connecting test client to #{addr}\n"
+      client = TCPSocket.new('localhost', KineticRuby::DEFAULT_KINETIC_PORT)
+      raise "Failed connecting to server!" unless client
+      report "Connected to server!"
+      client.close
     end
-    sleep 1.0
-    raise "Failed connecting a client to Kinetic Ruby server!" unless $kinetic_server.connected
-    client.exit
-    client.join(2.0)
+    client.join 5.0
     $kinetic_server.shutdown unless $kinetic_server.nil?
     $kinetic_server = nil
-    sleep 2.0
     report "Kinetic Ruby server test successful!"
   end
 end
@@ -105,6 +104,7 @@ end
 
 def report(msg='', banner=false)
   $stderr.flush
+  $stdout.flush
   if banner
     len = msg.length
     msg = "\n#{msg}\n#{'-'*len}" 

data/lib/kinetic-ruby.rb

@@ -1,6 +1,6 @@
-# Preload all library files
+# Preload library files
 require 'fileutils'
-
+require 'socket'
 FileUtils.cd(File.dirname(__FILE__)) do
   Dir['./**/*.rb'].each do |f|
     mod = f.sub(/.rb/, '')
@@ -9,11 +9,17 @@ FileUtils.cd(File.dirname(__FILE__)) do
 end
 
 module KineticRuby
+
+  # Rake extensions for kinetic-ruby
   module Rake
+    # Call from Rakefile to load kinetic-ruby Rake tasks (after requiring this file)
     def self.load_tasks
       Dir["#{File.dirname(__FILE__)}/../tasks/**/*.rake"].each do |tasks|
         load tasks
       end
     end
+
+    # Autoload rake tasks if Rake already loaded
+    load_tasks if defined?(Rake)
   end
 end

data/lib/kinetic_constants

@@ -0,0 +1,2 @@
+module KineticRuby
+end

data/lib/kinetic_constants.rb

@@ -0,0 +1,4 @@
+module KineticRuby
+  DEFAULT_KINETIC_PORT = 8123
+  TEST_KINETIC_PORT = 8999
+end

data/lib/kinetic_logger.rb

@@ -12,6 +12,7 @@ module KineticRuby
     def initialize(log_level=LOG_LEVEL_INFO, stream=$stdout)
       set_level log_level
       @stream = stream
+      @prefix = ''
     end
 
     def level=(log_level)
@@ -22,6 +23,14 @@ module KineticRuby
       @level.dup
     end
 
+    def prefix=(msg)
+      @prefix = msg if msg
+    end
+
+    def prefix
+      @prefix.dup if @prefix
+    end
+
     def log_info(msg='', banner=nil)
       log_message(msg, banner) if @level >= LOG_LEVEL_INFO
     end
@@ -38,6 +47,14 @@ module KineticRuby
     end
     alias logv log_verbose
 
+    def log_exception(exception, desc=nil, level=LOG_LEVEL_ERROR)
+      log_err(desc) if (desc && !desc.empty?)
+      log_err "Exception #{exception.class} '#{exception.message}' occured at:"
+      exception.backtrace.each do |l|
+        log_err "  #{l}"
+      end
+    end
+
   private
 
     def set_level(log_level)
@@ -48,10 +65,9 @@ module KineticRuby
       @level = log_level
     end
 
-    LOG_BANNER = "\n----------------------------------------"
-
     def log_message(msg, banner)
-      msg += LOG_BANNER if (banner && msg && !msg.empty?)
+      msg = @prefix + msg if (@prefix && !@prefix.empty?)
+      msg += "\n" + @prefix + ('-'*40) if (banner && msg && !msg.empty?)
       @stream.puts msg
       @stream.flush
     end

data/lib/kinetic_pdu.rb

@@ -4,56 +4,122 @@ module KineticRuby
 
   class PDU
 
+    HEADER_LENGTH = 1 + 4 + 4 # version_prefix + protobuf_length + value_length
+
     def initialize(logger, raw=nil)
       raise "Invalid logger specified!" unless logger
       @logger = logger
-      parse(raw)
+      @header = nil
+      @protobuf = nil
+      @value = nil
+      parse(raw) unless raw.nil?
+    end
+
+    def complete?
+      complete = false
+      if @header && @protobuf
+        if @header['valueLength'] == 0
+          complete = true
+        elsif @value && (@value.length >= @header['valueLength'])
+          complete = true
+        end
+      end
+      return complete
     end
 
     def parse(raw)
-      @header = parse_header(raw)
-      @protobuf = parse_protobuf(raw) if @header
-      @value = parse_value(raw) if (@header && @protobuf)
-      return (@header && @protobuf && @value)
+      if parse_header(raw)
+        @logger.log 'PDU Header:'
+        @header.each_pair{|k,v| @logger.log "  #{k}: #{v}"}
+
+        if parse_protobuf(raw)
+          @logger.log 'PDU Protobuf:'
+          @protobuf.to_yaml.each_line{|l| @logger.log('  ' + l)}
+
+          if @header['valueLength'] > 0 && parse_value(raw)
+            @logger.log 'PDU Value:'
+            @logger.log "  #{@value.to_s}"
+          end
+        end
+      end
+
+      return complete?
+    end
+
+    def self.valid_header?(raw)
+      (
+        !raw.nil? &&
+        raw.length >= HEADER_LENGTH &&
+        raw[0] == KineticRuby::Proto::VERSION_PREFIX
+      )
     end
 
     def length
       len = 0
       len += HEADER_LENGTH if @header
-      len += @header[:protobuf_length] if @protobuf
-      len += @header[:value_length] if @value
+      len += @header['protobufLength'] if @protobuf
+      len += @header['valueLength'] if @value
       return len
     end
     alias size length
 
-  private
+    def dump
+      return unless complete?
+      
+      @logger.log('PDU Content', true)
 
-    HEADER_LENGTH = 1 + 4 + 4 # version_prefix + protobuf_length + value_length
+      # Log the header
+      @logger.log "  header:\n" +
+                  "    version_prefix:  #{@header['versionPrefix']}\n" +
+                  "    protobuf_length: #{@header['protobufLength']}\n" +
+                  "    value_length:    #{@header['valueLength']}\n"
+
+      # Log the protobuf
+      @logger.log "  protobuf:\n" + Proto.to_yaml(@protobuf, '    ')
+
+      # Log the value payload
+      @logger.log "  value: (#{value.length} bytes)\n"
+      if @logger.level >= Logger::LOG_LEVEL_VERBOSE
+        val = @value.dup
+        val_string = ''
+        while !val.empty?
+          val_string += "    #{val.slice!(i,8)}\n"
+        end
+        @logger.logv val_string
+      end
+    end
+
+  private
     
     def parse_header(raw)
-      return nil unless (raw && raw.length <= HEADER_LENGTH)
-      {
-        version_prefix: raw[0],
-        protobuf_length: parse_nbo_int32(raw.byteslice(1..4)),
-        value_length: parse_nbo_int32(raw.byteslice(5..9))
+      if (!raw || raw.length <= HEADER_LENGTH)
+        @logger.log "Haven't recevived the full PDU header yet..."
+        @logger.log "  header:  raw: #{raw.inspect}" unless (!raw || raw.empty?)
+        return nil
+      end
+      @header = {
+        'versionPrefix'  => raw[0],
+        'protobufLength' => parse_nbo_int32(raw.byteslice(1..4)),
+        'valueLength'    => parse_nbo_int32(raw.byteslice(5..8)),
       }
     end
 
     def parse_protobuf(raw)
-      min_length = (HEADER_LENGTH + @header[:protobuf_length])
+      min_length = (HEADER_LENGTH + @header['protobufLength'])
       return nil unless (@header && raw.length >= min_length)
       start_idx = HEADER_LENGTH
       end_idx = HEADER_LENGTH + min_length - 1
       protobuf = raw.byteslice(start_idx, end_idx)
-      Seagate::Kinetic::Message.decode(protobuf)
+      @protobuf = Seagate::Kinetic::Message.decode(protobuf)
     end
     
     def parse_value(raw)
-      min_length = (HEADER_LENGTH + @header[:protobuf_length] + @header[:value_length])
+      preamble_length = HEADER_LENGTH + @header['protobufLength']
+      min_length = preamble_length + 1
+      full_length = preamble_length + @header['valueLength']
       return nil unless (@header && @protobuf && raw.length >= min_length)
-      start_idx = HEADER_LENGTH + @header[:protobuf_length]
-      end_idx = start_idx + @header[:protobuf_length] - 1
-      @value = raw.byteslice(start_idx, end_idx)
+      end_idx = preamble_length + @header['protobufLength'] - 1
+      @value = raw.byteslice(preamble_length, end_idx)
     end
 
     def parse_nbo_int32(data)

data/lib/kinetic_proto.rb

@@ -12,19 +12,43 @@ module KineticRuby
       @message_in = nil
     end
 
-    def decode(buf)
-      @message_in = Seagate::Kinetic::Message.decode(buf)
-      @logger.log
-      @logger.log("\n#{@message_in.class} - Decoding", true)
-      @logger.log '  command:'
-      @message_in.command.to_yaml.each_line{|line| @logger.log '    ' + line}
-      @logger.log
+    def self.decode(buf, indent=0, logger=nil)
+      msg = Seagate::Kinetic::Message.decode(buf)
+
+      # Log the decoded protobuf
+      if logger
+        orig_prefix = logger.prefix
+        add_prefix = (indent.class == Fixnum) ? (' '*indent) : indent
+        add_prefix = ' ' * indent
+        logger.prefix = logger.prefix + add_prefix
+        logger.log 'message:'
+        logger.prefix = logger.prefix + '  '
+        self.to_yaml(msg).each_line{|line| logger.log(line) }
+        logger.prefix = orig_prefix
+        logger.log
+      end
+
+      return msg
+    end
+
+    def decode(buf, indent=0)
+      @message_in = Proto.decode(buf, indent, @logger)
+    end
+
+    def self.to_yaml(msg)
+      yaml = "message:\n"
+      msg.to_yaml.each_line{|line| yaml += "  #{line}"}
+      return yaml
+    end
+
+    def to_yaml(msg)
+      self.to_yaml(msg)
     end
 
     def test_encode
       pb = Seagate::Kinetic::Message.new
-
-      @logger.log("\n#{pb.class} - Encoding", true)
+      @logger.log
+      @logger.log("#{pb.class} - Encoding", true)
       pb.hmac = '0123456789ABCDEF0123'
       pb.command = Seagate::Kinetic::Message::Command.new(
         header: Seagate::Kinetic::Message::Header.new(
@@ -47,14 +71,16 @@ module KineticRuby
 
       @logger.log_verbose '  fields:'
       pb.fields.sort.each{|f| @logger.log_verbose("    #{f}")}
-      @logger.log_verbose "  hmac:\n    #{pb.hmac}"
+      @logger.log_verbose "  hmac:"
+      @logger.log_verbose "    #{pb.hmac}"
 
       @logger.log '  command:'
       pb.command.to_yaml.each_line{|l| @logger.log("    #{l}")}
       @logger.log '  encoded:'
       @logger.log '    Length: ' + encoded.length.to_s + ' bytes'
 
-      @logger.log_verbose "    Raw:\n      #{encoded.inspect}"
+      @logger.log_verbose "    Raw:"
+      @logger.log_verbose "      #{encoded.inspect}"
       @logger.log_verbose "    Content:"
       encoded.to_yaml.each_line{|line| @logger.log_verbose "      #{line}"}
       
@@ -65,10 +91,14 @@ module KineticRuby
 
     def test_kinetic_proto
       msg = test_encode
-      decode msg
+
+      @logger.log
+      @logger.log("Decoded Message", true)
+      decode(msg, 2)
 
       if @message_in != @message_out
-        @logger.log_err "Inbound/outbound messages do not match!\n\n"
+        @logger.log_err "Inbound/outbound messages do not match!"
+        @logger.log_err
         raise "\nKinetic Protocol message roundtrip FAILED!\n\n"
       end
 

data/lib/kinetic_server.rb

@@ -1,11 +1,144 @@
-require 'socket'
-
 $kinetic_server = nil
+require_relative 'kinetic_constants'
 
 module KineticRuby
 
-  DEFAULT_KINETIC_PORT = 8123
-  TEST_KINETIC_PORT = 8999
+  class Client
+    def initialize(socket, addr_info, logger)
+      @socket = socket
+      @addr = addr_info
+      @logger = logger
+    end
+
+    # Shutdown a client socket
+    def close
+      return unless @socket
+      @logger.log "Client socket #{@socket.inspect} disconnected!"
+      @socket.close
+      @socket = nil
+      @logger.logv "Client #{@socket.inspect} connection shutdown successfully"
+    end
+
+    # Return formatted address '<address>:<port>' for the socket
+    def self.address(socket)
+      return nil unless socket
+      raise "Socket appears to be disconnected!" if !socket.remote_address
+      "#{socket.remote_address.ip_address}:#{socket.remote_address.ip_port}"
+    end
+
+    # Return formatted address '<address>:<port>' of the client
+    def address
+      Client.address(@socket)
+    end
+
+    # Wait to receive data from the client
+    # @param max_len  Maximum number of bytes to receive
+    # @returns        Received data (length <= max_len) or nil upon failure
+    def receive(max_len=nil)
+      max_len ||= 1024
+
+      begin
+        data = @socket.recv(max_len)
+      rescue IO::WaitReadable
+        @logger.logv 'Retrying receive...'
+        IO.select([@socket])
+        retry
+      rescue Exception => e
+        if e.class != 'IOError' && e.message != 'closed stream'
+          @logger.log_exception(e, 'EXCEPTION during receive!')
+        end
+      end
+
+      if (data.nil? || data.empty?)
+        @logger.log "Client #{@socket.inspect} disconnected!"
+        data = ''
+      else
+        @logger.log "Received #{data.length} bytes"
+      end
+
+      return data
+    end
+    alias recv receive # provide 'standard' socket method as well
+
+    # Send data to the client
+    def send(data)
+      @socket.write(data)
+    end
+    alias write send # provide 'standard' socket method as well
+
+  end
+
+  class ClientProvider
+    def initialize(host, port, logger)
+      @host = host
+      @port = port
+      @logger = logger
+      @server = nil
+    end
+
+    # @brief    Listen for connection
+    # @return   Returns a Client upon connection, nil upon failure
+    def accept
+      client = nil
+      @server ||= TCPServer.new(@host, @port)
+      
+      begin
+        client = Client.new(@server.accept)
+      rescue Exception => e
+        @logger.log_exception(e, 'EXCEPTION during accept!') 
+      end
+
+      @logger.log 'Client dropped off!' if client.nil?
+      
+      return client
+    end
+
+    # @brief    Shutdown the socket server
+    def shutdown
+      return if @server.nil?
+      @server.close
+      @server = nil
+    end
+
+    # @brief        Starts a TCP socket server and yields block for each client (sequential)
+    # @param host   Host name or IPv4/6 address
+    # @param port   Port to listen on
+    # @param logger Logger to output to
+    def self.each_client(host, port, logger)
+      raise "No block supplied!" unless block_given?
+      logger.log "Listening for clients..."
+
+      # Service clients, one at a time (for now at least)
+      begin
+        Socket.tcp_server_loop(host, port) do |socket, addr|
+          
+          logger.log "New client connected on socket #{socket.inspect}"
+          
+          client = Client.new(socket, addr, logger)
+          raise "Failed to connect to client!" unless client
+          logger.log "Connected to #{client.address}"
+
+          begin
+            # Execute the supplied block with the connected client
+            yield(client, logger)
+            logger.log "Done servicing client #{client.address}"
+          ensure
+            logger.log "Closing client socket..."
+            # Make sure the client gets closed, since tcp_server_loop does NOT!
+            client.close
+            logger.log "Client socket shutdown!"
+          end
+          logger.log "Done with client #{client.address}"
+        end
+
+      rescue Exception => e
+        logger.log_exception(e, 'EXCEPTION during listen!')
+      end 
+
+      logger.log "Done listening for clients!"
+    end
+
+  end
 
   class Server
 
@@ -14,17 +147,11 @@ module KineticRuby
     def initialize(port = DEFAULT_KINETIC_PORT, log_level=Logger::LOG_LEVEL_INFO)
       @host = 'localhost'
       @port ||= DEFAULT_KINETIC_PORT
-      raise "Invalid Kinetic test server port specified (port: #{port})" if !@port || @port < 0
+      raise "Invalid server port specified: #{port}" if !@port || @port < 0
       @logger = Logger.new(log_level)
-      @proto = Proto.new(@logger)
-      @server = nil
+      @logger.prefix = 'KineticSim: '
       @worker = nil
-      @clients = []
-      @logger.log "Kinetic Ruby test device server started!"
-    end
-
-    def connected
-      !@server.nil?
+      @logger.log 'Kinetic device test server started!'
     end
 
     def report_buffer(buf)
@@ -46,103 +173,105 @@ module KineticRuby
     end
 
     def start
-      return unless @server.nil?
-
-      @server = TCPServer.new(@host, @port)
+      return unless @worker.nil?
 
       # Setup handler for signaled shutdown (via ctrl+c)
       trap("INT") do
-        @logger.log "Kinetic Test Server: INT triggered Kintic Test Server shutdown"
+        @logger.log "INT triggered shutdown"
         shutdown
       end
 
-      # Create worker thread for test server to run in so we can continue
+      # Create background thread for processing client requests
       @worker = Thread.new do
-        @logger.log "Kinetic Test Server: Listening for Kinetic clients..."
-        loop do
-          client = nil
-          begin
-            client, client_info = @server.accept
-          rescue Exception => e
-            @logger.log "Kinetic Test Server: EXCEPTION during accept!\n" +
-              "  #{e.inspect}\n" +
-              "  #{e.message}\n  #{e.backtrace.join("  \n")}"
-            next if client.nil?
-          end
-
-          next if client.nil?
+        
+        # Service client connections (sequentially)
+        ClientProvider.each_client(@host, @port, @logger) do |client|
 
-          @logger.log "Kinetic Test Server: Connected to #{client.inspect}"
           request = ''
-          data = nil
           pdu = nil
-          disconnect = false
-
-          while !disconnect
-            begin
-              data = client.recv(1024)
-            rescue IO::WaitReadable
-              @logger.log("IO:WaitReadable");
-              IO.select([client])
-              retry
-            rescue Exception => e
-              @logger.logv "Kinetic Test Server: EXCEPTION during receive!\n" +
-                "  #{e.inspect}\n" +
-                "  #{e.message}\n  #{e.backtrace.join("  \n")}"
-              disconnect = true
-              next
-            end
+          connected = true
+          raw_proto = nil
 
-            if (data.nil? || data.empty?)
-              @logger.log "Kinetic Test Server: Client #{client.inspect} disconnected!"
-              disconnect = true
-              next
+          # Process requests while client available
+          while connected && (data = client.receive)
+            if data.nil? || data.empty?
+              connected = false
+              break
             end
 
+            # Append received data to request for processing
+            request += data
+
             # Incrementally parse PDU until complete
-            if request[0] == KineticRuby::Proto::VERSION_PREFIX && request.length >= 9
-              pdu ||= PDU.new(@Logger)
-              pdu.update(request)
+            if PDU.valid_header? request
+              @logger.log 'Receiving a PDU...'
+              raw_pdu = request.bytes.map{|b| sprintf("%02X", b)}.join('')
+              @logger.log "  request[#{request.length}]: #{raw_pdu}"
+              pdu ||= PDU.new(@logger)
+              if pdu.parse(request)
+                @logger.log "Received PDU successfully!"
+              else
+                @logger.log "Waiting on remainder of PDU..."
+              end
             end
 
+            # Handle raw protobuf.. for tests
+            if raw_proto || request.match(/^\n/)
+                @logger.log "Appears to be a standalone protobuf incoming..."
+                pdu = nil
+                raw_proto ||= []
+                raw_proto += request.bytes
+                @logger.log "  protobuf: (#{raw_proto.length} bytes)"
+
             # Otherwise, handle custom test requests
-            if pdu.nil?
+            elsif pdu.nil?
+              @logger.logv "Checking for custom request: '#{request}'"
               request_match = request.match(/^read\((\d+)\)/)
               if request_match
                 len = request_match[1].to_i
                 response = 'G'*len
-                @logger.log "Kinetic Test Server: Responding to 'read(#{len})' w/ '#{response}'"
-                client.write response
+                @logger.log "Responding to 'read(#{len})' w/ '#{response}'"
+                client.send response
                 request = ''
+                pdu = nil
               elsif request =~ /^readProto()/
-                response = @proto.test_encode
-                @logger.log "Kinetic Test Server: Responding to 'read(#{len})' w/ dummy @protobuf (#{response.length} bytes)"
-                client.write response
+                response = Proto.new(@logger).test_encode
+                @logger.log "Responding to 'read(#{len})' w/ dummy protobuf (#{response.length} bytes)"
+                client.send response
                 request = ''
+                pdu = nil
+              elsif request.match(/^read/) && data.length < 7
+                @logger.log "no command match for request: '#{request}' (...yet)";
+              else
+                @logger.log "Unknown request! Aborting..."
+                request = ''
+                pdu = nil
+                connected = false
               end
             end
 
-            @logger.log "Kinetic Test Server: Client #{client.inspect} disconnected!"
-            client.close
-            @logger.log "Kinetic Test Server: Client connection shutdown successfully"
-          end
-        end
-      end
+          end #request service loop pass
+
+          @logger.log "Disconnecting from client..."
+
+        end #client connection
+
+        @logger.log "Client listener shutting down..."
+      end #worker thread
+
+      @logger.log "Listener shutdown successfully!"
+
     end
 
     def shutdown
-      return if @server.nil?
-      @logger.log "Kinetic Test Server: shutting down..."
+      return if @worker.nil?
+      @logger.log 'shutting down...'
       if @worker
         @worker.exit
-        @worker.join(2)
+        @worker.join 2.0
         @worker = nil
       end
-      if @server
-        @server.close
-        @server = nil
-      end
-      @logger.log "Kinetic Test Server: shutdown complete"
+      @logger.log 'shutdown complete'
     end
 
   end

data/lib/version.rb

@@ -1,4 +1,4 @@
 module KineticRuby
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
   PROTOCOL_VERSION = 'v2.0.4'
 end

data/lib/version.rb.erb

@@ -1,4 +1,4 @@
 module KineticRuby
-  VERSION = '0.6.0'
+  VERSION = '0.6.1'
   PROTOCOL_VERSION = '<%= proto_ver %>'
 end

data/tasks/kinetic-ruby.rake

@@ -21,8 +21,11 @@ namespace :kinetic do
 
     desc "Shutdown Kinetic Test Server"
     task :shutdown do
-      $kinetic_server.shutdown unless $kinetic_server.nil?
-      $kinetic_server = nil
+      if $kinetic_server
+        $kinetic_server.shutdown
+        sleep 5.0
+        $kinetic_server = nil
+      end
     end
 
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kinetic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Greg Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-31 00:00:00.000000000 Z
+date: 2014-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -64,6 +64,8 @@ files:
 - Rakefile
 - LICENSE
 - lib/kinetic-ruby.rb
+- lib/kinetic_constants
+- lib/kinetic_constants.rb
 - lib/kinetic_logger.rb
 - lib/kinetic_pdu.rb
 - lib/kinetic_proto.rb