kinetic-ruby 0.3.8 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1ac835296c563ed8d45dd417494aaeab11221a6b
-  data.tar.gz: 5d76a53e2bc1a5256c41a820659581d9ed0499e2
+  metadata.gz: baa7b2b2078f4a6d89936a205aecb57c9d5f2f4b
+  data.tar.gz: e670900a889bab053e1adb4b8fb6d90e9275c102
 SHA512:
-  metadata.gz: a89c19cca9552a89c0c0dc36947afc0f79818b40127b6fdae049eff08ad94f79200523eb81a554b93d5e964aeb2ce195d406dae315f0bbd8f4013a9825894f5e
-  data.tar.gz: d2896d44f2e55b7aa5754857a39f816924e63e0ef208f1b576579134d5579e3252b5ea505b47ca09561a79e549a7bffcdc8ecdcc33d89fdbb9c1e2fcac86d589
+  metadata.gz: a875dd98f18161bdd2de90b117ac7d572186228bc595f707fbf4ab383af0e14a629ee0e62af76f00b133a1037f9c264e2cd478d7908863722b99f5a2208a353c
+  data.tar.gz: 8d77c7d4b5693adc2c584891989b45cbca2f2da239a24ca8e95cb9275ef7f9fbb3067b30bf1ba311c38d04c2a95ff46bd5303b27d3b12348f6e0843dee3f612c

data/Rakefile

@@ -1,60 +1,114 @@
-HERE = File.expand_path(File.dirname(__FILE__))
-$LOAD_PATH.unshift File.join(HERE, 'lib')
-
 require 'rake'
 require 'rake/clean'
+$LOAD_PATH.unshift File.expand_path('lib')
 require 'kinetic-ruby'
 
-load 'tasks/kinetic-ruby.rake'
+KineticRuby::Rake::load_tasks()
 
 CLEAN.include ['*.gem', '*.log']
 
+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}"
+    end
+    sleep 1.0
+    raise "Failed connecting a client to Kinetic Ruby server!" unless $kinetic_server.connected
+    client.exit
+    client.join(2.0)
+    $kinetic_server.shutdown unless $kinetic_server.nil?
+    $kinetic_server = nil
+    sleep 2.0
+    report "Kinetic Ruby server test successful!"
+  end
+end
+
 desc "Run example"
 task :example do
-  kr = KineticRuby::Proto.new
+  kl = KineticRuby::Logger.new
+  kr = KineticRuby::Proto.new(kl)
   kr.test_kinetic_proto
 end
 
 desc "Run example w/o logging"
 task :example_no_log do
-  kr = KineticRuby::Proto.new(KineticRuby::Logger::LOG_LEVEL_NONE)
+  kl = KineticRuby::Logger.new(KineticRuby::Logger::LOG_LEVEL_NONE)
+  kr = KineticRuby::Proto.new(kl)
   kr.test_kinetic_proto
 end
 
 desc "Run example w/ verbose logging"
 task :example_verbose_log do
-  kr = KineticRuby::Proto.new(KineticRuby::Logger::LOG_LEVEL_VERBOSE)
+  kl = KineticRuby::Logger.new(KineticRuby::Logger::LOG_LEVEL_VERBOSE)
+  kr = KineticRuby::Proto.new(kl)
   kr.test_kinetic_proto
 end
 
-task :default => [:example]
+task :update_version_info do
+  require 'erb'
+  proto_ver = ''
+  FileUtils.cd 'vendor/kinetic-protocol' do
+    proto_ver = 'v' + `git describe --tags 2> /dev/null`.strip
+    proto_ver = 'v<Unknown!>' if proto_ver !~ /^v\d+\.\d+\.\d+/
+  end
+  template = File.read('lib/version.rb.erb')
+  content = ERB.new(template).result(binding)
+  File.open('lib/version.rb', "w+"){|f| f.write(content) }
+  new_ver = content.match(/  VERSION = '(.+)'.+ PROTOCOL_VERSION = '(.+)'/m)
+  raise "Failed to parse updated version info!" unless new_ver
+  if ((new_ver[1] != KineticRuby::VERSION) ||
+      (new_ver[2] != KineticRuby::PROTOCOL_VERSION))
+    report "Kinetic Ruby version info has changed! You must re-run Rake to resync!\nExiting..."
+    exit 1
+  end
+end
 
 desc "Build kinetic-ruby gem"
-task :build do
-  banner "Building kinetic-ruby gem v#{KineticRuby::VERSION} using Kinetic Protocol #{KineticRuby::KINETIC_PROTOCOL_VERSION}"
+task :build => :update_version_info do
+  report("Building kinetic-ruby gem v#{KineticRuby::VERSION} w/ Kinetic Protocol #{KineticRuby::PROTOCOL_VERSION}", true)
   sh "gem build kinetic-ruby.gemspec"
-  puts
+  report
+end
+
+# desc "Build and install kinetic-ruby gem"
+task :install => :build do
+  report("Installing KineticRuby gem v#{KineticRuby::VERSION}", true)
+  sh "sudo gem uninstall --all kinetic-ruby"
+  sh "sudo gem install --no-doc kinetic-ruby-#{KineticRuby::VERSION}.gem"
 end
 
 task :release => :ci do
-  banner "Publishing kinetic-ruby gem v#{KineticRuby::VERSION} to RubyGems"
-  proto_ver = KineticRuby::KINETIC_PROTOCOL_VERSION
+  report("Publishing kinetic-ruby gem v#{KineticRuby::VERSION} to RubyGems", true)
+  proto_ver = KineticRuby::PROTOCOL_VERSION
   if proto_ver !~ /v\d+\.\d+\.\d+/
     raise "Can only publish gem with a release tag of Kinetic Protocol!\n" +
       "  reported Kinetic Protocol version: "
   end
-  puts "Releasing gem built w/ Kinetic Protocol #{proto_ver}"
+  report "Releasing gem built w/ Kinetic Protocol #{proto_ver}"
   sh "gem push kinetic-ruby-#{KineticRuby::VERSION}.gem"
-  puts
+  report
 end
 
-task :ci =>[:clobber, :example, :example_no_log, :build]
+task :default => [:example, 'test:server']
+
+task :ci =>[:clobber, :example, :example_no_log, 'test:server', :build] do
+  report("Kinetic Ruby Test Results", true)
+  report "SUCCESSFUL!"
+end
 
 #############################################
 # Helper methods and goodies
 
-def banner(msg)
-  puts
+def report(msg='', banner=false)
+  $stderr.flush
+  if banner
+    len = msg.length
+    msg = "\n#{msg}\n#{'-'*len}" 
+  end
   puts msg
-  puts "-"*msg.length
+  $stdout.flush
 end

data/lib/kinetic-ruby.rb

@@ -1,18 +1,19 @@
-require_relative 'kinetic_logger'
-require_relative 'kinetic_proto'
-require_relative 'kinetic_server'
+# Preload all library files
+require 'fileutils'
 
-module KineticRuby
-
-  VERSION = '0.3.8'
-  DEFAULT_KINETIC_PORT = 8123
-  TEST_KINETIC_PORT = 8999
-
-  kp_tag = ''
-  FileUtils.cd "./vendor/kinetic-protocol" do
-    kp_tag = 'v' + `git describe --tags`.strip
-    kp_tag = "<Unknown Kinetic Protocol version!>" if kp_tag !~ /^v\d+\.\d+\.\d+/
+FileUtils.cd(File.dirname(__FILE__)) do
+  Dir['./**/*.rb'].each do |f|
+    mod = f.sub(/.rb/, '')
+    require mod
   end
-  KINETIC_PROTOCOL_VERSION = kp_tag
+end
 
+module KineticRuby
+  module Rake
+    def self.load_tasks
+      Dir["#{File.dirname(__FILE__)}/../tasks/**/*.rake"].each do |tasks|
+        load tasks
+      end
+    end
+  end
 end

data/lib/kinetic_logger.rb

@@ -1,9 +1,6 @@
 module KineticRuby
+
   class Logger
-    def initialize(logging_level=LOG_LEVEL_INFO, stream=$stdout)
-      set_log_level(logging_level)
-      @stream = stream
-    end
 
     LOG_LEVELS = [
       LOG_LEVEL_NONE = 0,
@@ -12,32 +9,52 @@ module KineticRuby
       LOG_LEVEL_VERBOSE = 3,
     ]
 
-    def set_log_level(level)
-      if !LOG_LEVELS.include? level
-        raise "\nInvalid LOG_LEVEL specified!\nValid levels:\n\t" +
-          LOG_LEVELS.map{|l|"#{self.class}::#{l}"}.join("\n\t") + "\n\n"
-      end
-      @level = level
+    def initialize(log_level=LOG_LEVEL_INFO, stream=$stdout)
+      set_level log_level
+      @stream = stream
+    end
+
+    def level=(log_level)
+      set_level(log_level)
+    end
+
+    def level
+      @level.dup
     end
 
-    def log_info(msg='')
-      log_message(msg) if @level >= LOG_LEVEL_INFO
+    def log_info(msg='', banner=nil)
+      log_message(msg, banner) if @level >= LOG_LEVEL_INFO
     end
+    alias logi log_info
     alias log log_info
 
-    def log_err(msg='')
-      log_message(msg, $stderr) if @level >= LOG_LEVEL_ERROR
+    def log_err(msg='', banner=nil)
+      log_message(msg, banner) if @level >= LOG_LEVEL_ERROR
     end
+    alias loge log_err
 
-    def log_verbose(msg='')
-      log_message(msg) if @level >= LOG_LEVEL_VERBOSE
+    def log_verbose(msg='', banner=nil)
+      log_message(msg, banner) if @level >= LOG_LEVEL_VERBOSE
     end
+    alias logv log_verbose
 
-    def log_message(msg='')
-      $stderr.flush
-      @stream.flush
+  private
+
+    def set_level(log_level)
+      if !LOG_LEVELS.include? log_level
+        raise "\nInvalid LOG_LEVEL specified: #{log_level}\nValid levels:\n  " +
+          LOG_LEVELS.map{|l|"#{self.class}::#{l}"}.join("\n  ") + "\n\n"
+      end
+      @level = log_level
+    end
+
+    LOG_BANNER = "\n----------------------------------------"
+
+    def log_message(msg, banner)
+      msg += LOG_BANNER if (banner && msg && !msg.empty?)
       @stream.puts msg
       @stream.flush
     end
+
   end
 end

data/lib/kinetic_pdu.rb

@@ -0,0 +1,71 @@
+module KineticRuby
+
+  attr_reader :header, :protobuf, :value
+
+  class PDU
+
+    def initialize(logger, raw=nil)
+      raise "Invalid logger specified!" unless logger
+      @logger = logger
+      parse(raw)
+    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)
+    end
+
+    def length
+      len = 0
+      len += HEADER_LENGTH if @header
+      len += @header[:protobuf_length] if @protobuf
+      len += @header[:value_length] if @value
+      return len
+    end
+    alias size length
+
+  private
+
+    HEADER_LENGTH = 1 + 4 + 4 # version_prefix + protobuf_length + value_length
+    
+    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))
+      }
+    end
+
+    def parse_protobuf(raw)
+      min_length = (HEADER_LENGTH + @header[:protobuf_length])
+      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)
+    end
+    
+    def parse_value(raw)
+      min_length = (HEADER_LENGTH + @header[:protobuf_length] + @header[:value_length])
+      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
+
+    def parse_nbo_int32(data)
+      raise "Not enough data to parse NBO integer!" unless data.length >= 4
+      val = 0
+      data.each_byte do |byte|
+        val <<= 8
+        val += byte
+      end
+      return val
+    end
+
+  end
+
+end

data/lib/kinetic_proto.rb

@@ -1,48 +1,31 @@
 require 'yaml'
-require 'fileutils'
-require_relative 'kinetic_logger'
-require_relative 'kinetic_server'
 
 module KineticRuby
 
   class Proto
 
-    def initialize(log_level = KineticRuby::Logger::LOG_LEVEL_INFO)
-      require_relative "protobuf/kinetic.pb"
+    VERSION_PREFIX = 'F'
+
+    def initialize(logger)
+      @logger = logger
       @message_out = nil
       @message_in = nil
-      @logger = KineticRuby::Logger.new(log_level)
     end
 
     def decode(buf)
       @message_in = Seagate::Kinetic::Message.decode(buf)
-
       @logger.log
-      @logger.log "#{@message_in.class} - Decoding"
-      @logger.log  "-----------------------------------"
-
-      @logger.log "  command:"
-      @message_in.command.to_yaml.each_line{|l| @logger.log "    #{l}"}
+      @logger.log("\n#{@message_in.class} - Decoding", true)
+      @logger.log '  command:'
+      @message_in.command.to_yaml.each_line{|line| @logger.log '    ' + line}
       @logger.log
     end
 
     def test_encode
       pb = Seagate::Kinetic::Message.new
 
-      @logger.log
-      @logger.log "#{pb.class} - Encoding"
-      @logger.log  "---------------------------------------"
-
-      @logger.log_verbose "  fields:"
-      pb.fields.sort.each{|f| @logger.log_verbose "    #{f}"}
-      @logger.log_verbose
-
-      @logger.log_verbose "  hmac:"
-      pb.hmac = "0123456789ABCDEF0123"
-      @logger.log_verbose "    #{pb.hmac.inspect}"
-      @logger.log_verbose
-
-      @logger.log "  command:"
+      @logger.log("\n#{pb.class} - Encoding", true)
+      pb.hmac = '0123456789ABCDEF0123'
       pb.command = Seagate::Kinetic::Message::Command.new(
         header: Seagate::Kinetic::Message::Header.new(
           clusterVersion: 0x1122334455667788,
@@ -55,24 +38,26 @@ module KineticRuby
           ),
         status: Seagate::Kinetic::Message::Status.new(
             code: Seagate::Kinetic::Message::Status::StatusCode::NO_SUCH_HMAC_ALGORITHM,
-            statusMessage: "The specified HMAC security algorithm does not exist!",
-            detailedMessage: "YOUCH!"
+            statusMessage: 'The specified HMAC security algorithm does not exist!',
+            detailedMessage: 'YOUCH!'
           ),
       )
-      pb.command.to_yaml.each_line{|l| @logger.log("    #{l}")}
-      @logger.log
-
+      encoded = pb.encode
       @message_out = pb
 
-      @logger.log "  encoded:"
-      encoded = pb.encode
-      @logger.log_verbose
-      @logger.log_verbose "    Inspection: #{encoded.inspect}"
-      @logger.log_verbose
+      @logger.log_verbose '  fields:'
+      pb.fields.sort.each{|f| @logger.log_verbose("    #{f}")}
+      @logger.log_verbose "  hmac:\n    #{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 "    Content:"
-      encoded.to_yaml.each_line{|l| @logger.log_verbose "    #{l}"}
-      @logger.log_verbose
-      @logger.log "    Length: #{encoded.length} bytes"
+      encoded.to_yaml.each_line{|line| @logger.log_verbose "      #{line}"}
+      
       @logger.log
 
       return encoded
@@ -88,7 +73,7 @@ module KineticRuby
       end
 
       @logger.log
-      @logger.log "Kinetic Protocol protobuf encode/decode test passed!"
+      @logger.log 'Kinetic Protocol protobuf encode/decode test passed!'
       @logger.log
     end
 

data/lib/kinetic_server.rb

@@ -1,47 +1,46 @@
-require_relative 'kinetic-ruby'
+require 'socket'
 
 $kinetic_server = nil
 
 module KineticRuby
 
+  DEFAULT_KINETIC_PORT = 8123
+  TEST_KINETIC_PORT = 8999
+
   class Server
 
-    def initialize(port = nil, logger = nil)
-      port ||= DEFAULT_KINETIC_PORT
-      raise "Invalid Kinetic test server port specified (port: #{port})" if !port || port < 0
-      @port = port
-      @logger = logger
+    attr_reader :host, :port, :connected
+
+    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
+      @logger = Logger.new(log_level)
+      @proto = Proto.new(@logger)
       @server = nil
       @worker = nil
-      @listeners = []
-    end
-
-    def report(message='')
-      $stderr.flush
-      $stdout.flush
-      puts message
-      $stderr.flush
-      $stdout.flush
+      @clients = []
+      @logger.log "Kinetic Ruby test device server started!"
     end
 
-    def report_banner(message)
-      report "\n#{message}\n#{'='*message.length}\n\n"
+    def connected
+      !@server.nil?
     end
 
     def report_buffer(buf)
       bytes = buf.bytes
       row_len = 16
-      report "Raw Data (length=#{buf.count}):"
+      @logger.log "Raw Data (length=#{buf.count}):"
       while !bytes.empty?
         row_len = bytes.count >= row_len ? row_len : bytes.count
-        report "  row_len: #{row_len}"
+        @logger.log "  row_len: #{row_len}"
         row = bytes.slice!(row_len)
-        report "  row: #{row.inspect}"
+        @logger.log "  row: #{row.inspect}"
         msg = "  "
         row.each do |b|
           msg += sprintf("0x%02X", b)
         end
-        report msg
+        @logger.log msg
       end
       report
     end
@@ -49,67 +48,101 @@ module KineticRuby
     def start
       return unless @server.nil?
 
-      @server = TCPServer.new @port
-      @listeners = []
+      @server = TCPServer.new(@host, @port)
 
       # Setup handler for signaled shutdown (via ctrl+c)
       trap("INT") do
-        report "Kinetic Test Server: INT triggered Kintic Test Server shutdown"
+        @logger.log "Kinetic Test Server: INT triggered Kintic Test Server shutdown"
         shutdown
       end
 
       # Create worker thread for test server to run in so we can continue
       @worker = Thread.new do
-        report "Kinetic Test Server: Listening for Kinetic clients..."
+        @logger.log "Kinetic Test Server: Listening for Kinetic clients..."
         loop do
-          @listeners << Thread.start(@server.accept) do |client|
-            report "Kinetic Test Server: Connected to #{client.inspect}"
-            request = ""
-            while request += client.getc # Read characters from socket
+          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
 
-              request_match = request.match(/^read\((\d+)\)/)
+          next if client.nil?
+
+          @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
+
+            if (data.nil? || data.empty?)
+              @logger.log "Kinetic Test Server: Client #{client.inspect} disconnected!"
+              disconnect = true
+              next
+            end
+
+            # Incrementally parse PDU until complete
+            if request[0] == KineticRuby::Proto::VERSION_PREFIX && request.length >= 9
+              pdu ||= PDU.new(@Logger)
+              pdu.update(request)
+            end
 
+            # Otherwise, handle custom test requests
+            if pdu.nil?
+              request_match = request.match(/^read\((\d+)\)/)
               if request_match
                 len = request_match[1].to_i
-                response = "G"*len
-                report "Kinetic Test Server: Responding to 'read(#{len})' w/ '#{response}'"
+                response = 'G'*len
+                @logger.log "Kinetic Test Server: Responding to 'read(#{len})' w/ '#{response}'"
                 client.write response
                 request = ''
-
               elsif request =~ /^readProto()/
-                proto = KineticRuby::Proto.new
-                response = proto.test_encode
-                report "Kinetic Test Server: Responding to 'read(#{len})' w/ dummy protobuf (#{response.length} bytes)"
+                response = @proto.test_encode
+                @logger.log "Kinetic Test Server: Responding to 'read(#{len})' w/ dummy @protobuf (#{response.length} bytes)"
                 client.write response
                 request = ''
-
-              # elsif request.length > 20
-              #   report_banner "Received unknown data: length=#{request.length}"
-              #   report "  requst.inspect"
-              #   report_buffer(request)
-
               end
-
             end
-            report "Kinetic Test Server: Client #{client.inspect} disconnected!"
+
+            @logger.log "Kinetic Test Server: Client #{client.inspect} disconnected!"
+            client.close
+            @logger.log "Kinetic Test Server: Client connection shutdown successfully"
           end
         end
       end
-
     end
 
     def shutdown
       return if @server.nil?
-      report "Kinetic Test Server: shutting down..."
-      @listeners.each do |client|
-        client.join(0.3) if client.alive?
+      @logger.log "Kinetic Test Server: shutting down..."
+      if @worker
+        @worker.exit
+        @worker.join(2)
+        @worker = nil
       end
-      @listeners = []
-      @worker.exit
-      @worker = nil
-      @server.close
-      @server = nil
-      report "Kinetic Test Server: shutdown complete"
+      if @server
+        @server.close
+        @server = nil
+      end
+      @logger.log "Kinetic Test Server: shutdown complete"
     end
 
   end

data/lib/version.rb

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

data/lib/version.rb.erb

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

data/tasks/kinetic-ruby.rake

@@ -1,21 +1,31 @@
 require 'rake'
-require 'socket'
 require_relative '../kinetic-ruby' unless defined? KineticRuby
 
-namespace :server do
+namespace :kinetic do
+  namespace :server do
 
-  desc "Start Kinetic Test Server"
-  task :start, :port, :log do |t, args|
-    $kinetic_server ||= KineticRuby::Server.new(args[:port], args[:log])
-    $kinetic_server.start
-  end
+    desc "Start Kinetic Test Server"
+    task :start, :port, :log do |t, args|
+      if args[:port]
+        if args[:log]
+          $kinetic_server ||= KineticRuby::Server.new(args[:port], args[:log])
+        else
+          $kinetic_server ||= KineticRuby::Server.new(args[:port])
+        end
+      else
+        $kinetic_server ||= KineticRuby::Server.new
+      end
+      $kinetic_server.start
+      sleep 2.0
+    end
 
-  desc "Shutdown Kinetic Test Server"
-  task :shutdown do
-    $kinetic_server.shutdown unless $kinetic_server.nil?
-    $kinetic_server = nil
-  end
+    desc "Shutdown Kinetic Test Server"
+    task :shutdown do
+      $kinetic_server.shutdown unless $kinetic_server.nil?
+      $kinetic_server = nil
+    end
 
+  end
 end
 
 # This block of code will be run prior to Rake instance terminating

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kinetic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.3.8
+  version: 0.5.0
 platform: ruby
 authors:
 - Greg Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-29 00:00:00.000000000 Z
+date: 2014-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -54,7 +54,8 @@ dependencies:
         version: '0'
 description: Seagate Kinetic Protocol implementation and examples for developing Kinetic
   clients in Ruby
-email: greg.williams@atomicobject.com
+email:
+- greg.williams@atomicobject.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -62,24 +63,26 @@ files:
 - README.md
 - Rakefile
 - LICENSE
-- ./lib/kinetic-ruby.rb
-- ./lib/kinetic_logger.rb
-- ./lib/kinetic_proto.rb
-- ./lib/kinetic_server.rb
-- ./lib/protobuf/kinetic.pb.rb
-- ./tasks/kinetic-ruby.rake
-- ./vendor/kinetic-protocol/kinetic.proto
-- ./vendor/kinetic-protocol/README.md
+- lib/kinetic-ruby.rb
+- lib/kinetic_logger.rb
+- lib/kinetic_pdu.rb
+- lib/kinetic_proto.rb
+- lib/kinetic_server.rb
+- lib/protobuf/kinetic.pb.rb
+- lib/version.rb
+- lib/version.rb.erb
+- tasks/kinetic-ruby.rake
+- vendor/kinetic-protocol/kinetic.proto
+- vendor/kinetic-protocol/README.md
 homepage: http://github.com/atomicobject/kinetic-ruby
 licenses:
 - LGPL-2.1
 metadata: {}
 post_install_message: 
-rdoc_options:
-- --charset=UTF-8
+rdoc_options: []
 require_paths:
 - lib
-- tasks
+- lib/protobuf
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - '>='
@@ -94,6 +97,6 @@ requirements: []
 rubyforge_project: 
 rubygems_version: 2.0.14
 signing_key: 
-specification_version: 2
+specification_version: 4
 summary: Seagate Kinetic Protocol library for Ruby using Kinetic Protocol v2.0.4
 test_files: []