right_agent 2.2.0-x86-mingw32 → 2.2.1-x86-mingw32

data/lib/right_agent/pid_file.rb

@@ -62,7 +62,7 @@ module RightScale
       end
       true
     end
-    
+
     # Write pid to pid file
     #
     # === Return
@@ -78,7 +78,7 @@ module RightScale
       end
       true
     end
-    
+
     # Update associated command protocol port
     #
     # === Parameters
@@ -89,6 +89,9 @@ module RightScale
     # true:: Always return true
     def set_command_options(options)
       content = { :listen_port => options[:listen_port], :cookie => options[:cookie] }
+      # This is requried to preserve cookie value to be saved as string,
+      # and not as escaped binary data
+      content[:cookie].force_encoding('utf-8')
       open(@cookie_file,'w') { |f| f.write(YAML.dump(content)) }
       File.chmod(0600, @cookie_file)
       true
@@ -103,10 +106,10 @@ module RightScale
       File.delete(@cookie_file) if File.exists?(@cookie_file)
       true
     end
-    
+
     # Read pid file content
     # Empty hash if pid file does not exist or content cannot be loaded
-    # 
+    #
     # === Return
     # content(Hash):: Hash containing 3 keys :pid, :cookie and :port
     def read_pid
@@ -137,7 +140,7 @@ module RightScale
     def to_s
       path = @pid_file
     end
-    
+
     private
 
     # Check whether there is a process running with the given pid

data/lib/right_agent/serialize/serializer.rb

@@ -27,6 +27,24 @@ require 'json'
 
 require File.normalize_path(File.join(File.dirname(__FILE__), 'message_pack'))
 
+module JSONSerializer
+  def self.load(source)
+
+    if source.respond_to? :to_str
+      source = source.to_str
+    elsif source.respond_to? :to_io
+      source = source.to_io.read
+    else
+      source = source.read
+    end
+    source.force_encoding("UTF-8") if source.respond_to?(:force_encoding)
+    JSON.load(source)
+  end
+
+  def self.dump(*args)
+    JSON.dump(*args)
+  end
+end
 
 # Monkey patch common classes to support MessagePack serialization
 # As with JSON, unserializing them is manual using existing methods such as parse
@@ -103,8 +121,8 @@ module RightScale
     private
 
     # Supported serialization formats
-    SERIALIZERS = {:msgpack => MessagePack, :json => JSON}.freeze
-    MSGPACK_FIRST_SERIALIZERS = [MessagePack, JSON].freeze
+    SERIALIZERS = {:msgpack => MessagePack, :json => JSONSerializer}.freeze
+    MSGPACK_FIRST_SERIALIZERS = [MessagePack, JSONSerializer].freeze
     JSON_FIRST_SERIALIZERS = MSGPACK_FIRST_SERIALIZERS.clone.reverse.freeze
     FORMATS = (SERIALIZERS.keys + [:secure]).freeze
     DEFAULT_FORMAT = :msgpack

data/right_agent.gemspec

@@ -25,8 +25,8 @@ require 'rbconfig'
 
 Gem::Specification.new do |spec|
   spec.name      = 'right_agent'
-  spec.version   = '2.2.0'
-  spec.date      = '2014-05-06'
+  spec.version   = '2.2.1'
+  spec.date      = '2014-05-07'
   spec.authors   = ['Lee Kirchhoff', 'Raphael Simon', 'Tony Spataro', 'Scott Messier']
   spec.email     = 'lee@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_agent'

data/spec/serialize/serializer_spec.rb

@@ -64,13 +64,13 @@ describe RightScale::Serializer do
 
     it "should use preferred serializer if specified and not cascade to others" do
       serializer = RightScale::Serializer.new(:json)
-      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [JSON]).once
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [JSONSerializer]).once
       serializer.dump("hello")
     end
 
     it "should raise SerializationError if packet could not be serialized and not try other serializer" do
       flexmock(MessagePack).should_receive(:dump).with("hello").and_raise(StandardError).once
-      flexmock(JSON).should_receive(:dump).with("hello").and_raise(StandardError).once
+      flexmock(JSONSerializer).should_receive(:dump).with("hello").and_raise(StandardError).once
       serializer = RightScale::Serializer.new(:msgpack)
       lambda { serializer.dump("hello") }.should raise_error(RightScale::Serializer::SerializationError)
       serializer = RightScale::Serializer.new(:json)
@@ -87,7 +87,7 @@ describe RightScale::Serializer do
     it "should be able to override preferred format" do
       serializer = RightScale::Serializer.new(:json)
       flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [MessagePack]).once
-      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [JSON]).never
+      flexmock(serializer).should_receive(:cascade_serializers).with(:dump, "hello", [JSONSerializer]).never
       serializer.dump("hello", :msgpack)
     end
 
@@ -133,13 +133,13 @@ describe RightScale::Serializer do
 
     it "should cascade through available serializers" do
       serializer = RightScale::Serializer.new
-      flexmock(serializer).should_receive(:cascade_serializers).with(:load, "olleh", [JSON, MessagePack], nil).once
+      flexmock(serializer).should_receive(:cascade_serializers).with(:load, "olleh", [JSONSerializer, MessagePack], nil).once
       serializer.load("olleh")
     end
 
     it "should try all supported formats (MessagePack, JSON)" do
       flexmock(MessagePack).should_receive(:load).with("olleh").and_raise(StandardError).once
-      flexmock(JSON).should_receive(:load).with("olleh").and_raise(StandardError).once
+      flexmock(JSONSerializer).should_receive(:load).with("olleh").and_raise(StandardError).once
       lambda { RightScale::Serializer.new.load("olleh") }.should raise_error(RightScale::Serializer::SerializationError)
     end
 
@@ -147,14 +147,14 @@ describe RightScale::Serializer do
       object = [1, 2, 3]
       serialized = object.to_json
       flexmock(MessagePack).should_receive(:load).with(serialized).never
-      flexmock(JSON).should_receive(:load).with(serialized).and_return(object).once
+      flexmock(JSONSerializer).should_receive(:load).with(serialized).and_return(object).once
       RightScale::Serializer.new(:msgpack).load(serialized)
     end
 
     it "should try MessagePack format first if looks like MessagePack even if JSON preferred" do
       object = [1, 2, 3]
       serialized = object.to_msgpack
-      flexmock(JSON).should_receive(:load).with(serialized).never
+      flexmock(JSONSerializer).should_receive(:load).with(serialized).never
       flexmock(MessagePack).should_receive(:load).with(serialized).and_return(object).once
       RightScale::Serializer.new(:json).load(serialized)
     end
@@ -180,7 +180,7 @@ describe RightScale::Serializer do
 
     it "should raise SerializationError if packet could not be unserialized" do
       flexmock(MessagePack).should_receive(:load).with("olleh").and_raise(StandardError).once
-      flexmock(JSON).should_receive(:load).with("olleh").and_raise(StandardError).once
+      flexmock(JSONSerializer).should_receive(:load).with("olleh").and_raise(StandardError).once
       serializer = RightScale::Serializer.new
       lambda { serializer.load("olleh") }.should raise_error(RightScale::Serializer::SerializationError)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: right_agent
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
   prerelease: 
 platform: x86-mingw32
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-06 00:00:00.000000000 Z
+date: 2014-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: right_support
@@ -444,7 +444,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -916798744986717735
+      hash: 354755465369324207
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.26