right_agent 2.0.7-x86-mingw32

data/lib/right_agent/serialize/serializer.rb

@@ -0,0 +1,159 @@
+#
+# Copyright (c) 2009-2013 RightScale Inc
+#
+# 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.
+
+require 'rubygems'
+require 'time'
+require 'date'
+require 'json'
+
+require File.normalize_path(File.join(File.dirname(__FILE__), 'message_pack'))
+
+# Monkey patch common classes to support MessagePack serialization
+# As with JSON, unserializing them is manual using existing methods such as parse
+class Date
+  def to_msgpack(*a); to_s.to_msgpack(*a) end
+end
+
+class Time
+  def to_msgpack(*a); to_s.to_msgpack(*a) end
+end
+
+class DateTime
+  def to_msgpack(*a); to_s.to_msgpack(*a) end
+end
+
+module RightScale
+  
+  # Cascade serializer supporting MessagePack and JSON serialization formats
+  # as well as secure serialization
+  class Serializer
+
+    class SerializationError < StandardError
+      attr_accessor :action, :packet
+      def initialize(action, packet, serializers, msg = nil)
+        @action, @packet = action, packet
+        msg = " (#{msg})" if msg && !msg.empty?
+        super("Could not #{action} packet using #{serializers.inspect}#{msg}")
+      end
+    end
+
+    # (Symbol) Preferred serialization format
+    attr_reader :format
+
+    # Initialize the serializer
+    # Do not cascade serializers if :secure is specified
+    #
+    # === Parameters
+    # preferred_format(Symbol|String):: Preferred serialization format: :msgpack, :json, or :secure
+    #
+    # === Raises
+    # ArgumentError:: If preferred format is not supported
+    def initialize(preferred_format = nil)
+      @format = (preferred_format ||= DEFAULT_FORMAT).to_sym
+      raise ArgumentError, "Serializer format #{@format.inspect} not one of #{FORMATS.inspect}" unless FORMATS.include?(@format)
+      @secure = (@format == :secure)
+    end
+
+    # Serialize object using preferred serializer
+    # Do not cascade
+    #
+    # === Parameters
+    # packet(Object):: Object to be serialized
+    # format(Symbol):: Override preferred format
+    #
+    # === Return
+    # (String):: Serialized object
+    def dump(packet, format = nil)
+      cascade_serializers(:dump, packet, [@secure ? SecureSerializer : SERIALIZERS[format || @format]])
+    end
+
+    # Unserialize object using cascaded serializers with order chosen by peaking at first byte
+    #
+    # === Parameters
+    # packet(String):: Data representing serialized object
+    # id(String|nil):: Optional identifier of source of data for use
+    #   in determining who is the receiver
+    #
+    # === Return
+    # (Object):: Unserialized object
+    def load(packet, id = nil)
+      cascade_serializers(:load, packet, @secure ? [SecureSerializer] : order_serializers(packet), id)
+    end
+
+    private
+
+    # Supported serialization formats
+    SERIALIZERS = {:msgpack => MessagePack, :json => JSON}.freeze
+    MSGPACK_FIRST_SERIALIZERS = [MessagePack, JSON].freeze
+    JSON_FIRST_SERIALIZERS = MSGPACK_FIRST_SERIALIZERS.clone.reverse.freeze
+    FORMATS = (SERIALIZERS.keys + [:secure]).freeze
+    DEFAULT_FORMAT = :msgpack
+
+    # Apply serializers in order until one succeeds
+    #
+    # === Parameters
+    # action(Symbol):: Serialization action: :dump or :load
+    # packet(Object|String):: Object or serialized data on which action is to be performed
+    # serializers(Array):: Serializers to apply in order
+    # id(String):: Optional identifier of source of data for use in determining who is the receiver
+    #
+    # === Return
+    # (String|Object):: Result of serialization action
+    #
+    # === Raises
+    # SerializationError:: If none of the serializers can perform the requested action
+    def cascade_serializers(action, packet, serializers, id = nil)
+      errors = []
+      serializers.map do |serializer|
+        obj = nil
+        begin
+          obj = serializer == SecureSerializer ? serializer.send(action, packet, id) :  serializer.send(action, packet)
+        rescue SecureSerializer::MissingCertificate, SecureSerializer::InvalidSignature => e
+          errors << Log.format("Failed to #{action} with #{serializer.name}", e)
+        rescue Exception => e
+          errors << Log.format("Failed to #{action} with #{serializer.name}", e, :trace)
+        end
+        return obj if obj
+      end
+      raise SerializationError.new(action, packet, serializers, errors.join("\n"))
+    end
+
+    # Determine likely serialization format and order serializers accordingly
+    #
+    # === Parameters
+    # packet(String):: Data representing serialized object
+    #
+    # === Return
+    # (Array):: Ordered serializers
+    def order_serializers(packet)
+      # note the following code for getting the ascii value of the first byte is
+      # efficient for a large packet because it returns an enumerator for the
+      # internal byte array. it is actually more efficient than extracting the
+      # first character as a string and converting it to bytes.
+      # also, the following line works for both ruby 1.8 and ruby 1.9 since the
+      # definition of the bracket operator has changed.
+      packet.bytes.first > 127 ? MSGPACK_FIRST_SERIALIZERS : JSON_FIRST_SERIALIZERS
+    end
+
+  end # Serializer
+  
+end # RightScale

data/lib/right_agent/subprocess.rb

@@ -0,0 +1,38 @@
+#--  -*- mode: ruby; encoding: utf-8 -*-
+# Copyright: Copyright (c) 2011 RightScale, Inc.
+#
+# 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.
+#++
+
+module RightScale
+  module SubprocessFormatting
+    module_function
+
+    SIGNAL_LOOKUP = Signal.list.invert
+
+    def reason(status)
+      if status.exitstatus.nil?
+        "terminated with SIG#{SIGNAL_LOOKUP[status.termsig]}"
+      else
+        "exited with #{status.exitstatus}"
+      end
+    end
+  end
+end

data/lib/right_agent/tracer.rb

@@ -0,0 +1,124 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# 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.
+
+# This allows us to define class methods
+class Object
+  def metaclass
+    class << self
+      self
+    end
+  end
+end
+
+module RightScale
+
+  class Tracer
+
+    NON_TRACEABLE_CLASSES = [ 'Kernel', 'Module', 'Object' , 'SyslogLogger', 'RightSupport::Log::SystemLogger' ] +
+                            [ 'RightScale::Tracer', 'RightScale::Multiplexer' ] +
+                            [ 'RightScale::Log', 'RightScale::Log::Formatter' ]
+
+    NON_TRACEABLE_METHODS = [ :metaclass, :method_missing, :method_added, :blank_slate_method_added, :[], :[]= ]
+
+    NON_TRACEABLE_CLASS_METHODS = [ :initialize, :initialize_copy, :inherited, :new, :allocate, :superclass ]
+
+    # Add logs when entering and exiting instance and class methods
+    # defined on given class
+    #
+    # === Parameters
+    # klass(Class):: Class whose methods should be traced
+    #
+    # === Return
+    # true:: Always return true
+    def self.add_tracing_to_class(klass)
+      return true if NON_TRACEABLE_CLASSES.include?(klass.to_s)
+      (klass.public_instance_methods(all=false) + klass.private_instance_methods(all=false) +
+              klass.protected_instance_methods(all=false)).each do |m|
+        if traceable(m)
+          old_m = klass.instance_method(m)
+          klass.module_eval <<-EOM
+            alias :o_l_d_#{m} :#{m}
+            def #{m}(*args, &blk)
+              Log.debug("<<< #{klass}##{m}(" + args.map(&:inspect).join(',') + ")")
+              res = o_l_d_#{m}(*args, &blk)
+              Log.debug(">>> #{klass}##{m}")
+              res
+            end
+          EOM
+        end
+      end
+      (klass.public_methods(all=false) + klass.private_methods(all=false) +
+              klass.protected_methods(all=false)).each do |m|
+        if traceable(m, static=true)
+          old_m = klass.method(m)
+          klass.module_eval <<-EOM
+            class << self
+              alias :o_l_d_#{m} :#{m}
+              def #{m}(*args, &blk)
+                Log.debug("<<< #{klass}.#{m}(" + args.map(&:inspect).join(',') + ")")
+                res = o_l_d_#{m}(*args, &blk)
+                Log.debug(">>> #{klass}.#{m}")
+                res
+              end
+            end
+          EOM
+        end
+      end
+      true
+    end
+
+    # Can method be traced?
+    #
+    # === Parameters
+    # m(String):: Method name
+    # static(Boolean):: Whether method is a class method
+    #
+    # === Return
+    # traceable(Boolean):: true if method can be traced, false otherwise
+    def self.traceable(m, static=false)
+      traceable = !NON_TRACEABLE_METHODS.include?(m.to_sym) && m =~ /[a-zA-Z0-9]$/
+      traceable &&= !NON_TRACEABLE_CLASS_METHODS.include?(m.to_sym) if static
+      traceable
+    end
+
+    # Add tracing to all classes in given namespaces
+    #
+    # === Parameters
+    # namespaces(Array|String):: Namespace(s) of classes whose methods should be traced
+    #
+    # === Return
+    # true:: Always return true
+    def self.add_tracing_to_namespaces(namespaces)
+      namespaces = [ namespaces ] unless namespaces.respond_to?(:inject)
+      regexps = namespaces.inject([]) { |reg, n| reg << "^#{n}::" }
+      unless regexps.empty?
+        ObjectSpace.each_object(Class) do |c|
+          if c.to_s =~ /#{regexps.join('|')}/
+            add_tracing_to_class(c)
+          end
+        end
+      end 
+      true
+    end
+
+  end
+end

data/right_agent.gemspec

@@ -0,0 +1,101 @@
+# -*-ruby-*-
+# Copyright: Copyright (c) 2011-2013 RightScale, Inc.
+#
+# 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.
+
+require 'rubygems'
+require 'rbconfig'
+
+Gem::Specification.new do |spec|
+  spec.name      = 'right_agent'
+  spec.version   = '2.0.7'
+  spec.date      = '2014-02-28'
+  spec.authors   = ['Lee Kirchhoff', 'Raphael Simon', 'Tony Spataro', 'Scott Messier']
+  spec.email     = 'lee@rightscale.com'
+  spec.homepage  = 'https://github.com/rightscale/right_agent'
+  spec.platform  = Gem::Platform::RUBY
+  spec.summary   = 'Agent for interfacing server with RightScale system'
+  spec.has_rdoc  = true
+  spec.rdoc_options = ["--main", "README.rdoc", "--title", "RightAgent"]
+  spec.extra_rdoc_files = ["README.rdoc"]
+  spec.required_ruby_version = '>= 1.8.7'
+  spec.require_path = 'lib'
+
+  spec.add_dependency('right_support', ['>= 2.4.1', '< 3.0'])
+  spec.add_dependency('right_amqp', '~> 0.7')
+  spec.add_dependency('rest-client', '1.7.0.alpha')
+  spec.add_dependency('faye-websocket', '0.7.0')
+  spec.add_dependency('eventmachine', ['>= 0.12.10', '< 2.0'])
+  spec.add_dependency('net-ssh', '~> 2.0')
+
+  # TEAL HACK: rake gem may override current RUBY_PLATFORM to allow building
+  # gems for all supported platforms from any platform. rubygems 1.8.x makes it
+  # necessary to produce platform-specific gems with context-sensitive gemspecs
+  # in order to retain Windows (or Linux)-specific gem requirements. this works
+  # from any platform because there is no native code to pre-compile and package
+  # with this gem.
+  gem_platform = defined?(::RightScale::MultiPlatformGemTask.gem_platform_override) ?
+    ::RightScale::MultiPlatformGemTask.gem_platform_override :
+    nil
+  gem_platform ||= ::RbConfig::CONFIG['host_os']
+  case gem_platform
+  when /mswin/i
+    spec.add_dependency('win32-api', ['>= 1.4.5', '< 1.4.7'])
+    spec.add_dependency('win32-dir', '~> 0.3.5')
+    spec.add_dependency('win32-process', '~> 0.6.1')
+    spec.add_dependency('msgpack', ['>= 0.4.4', '< 0.5'])
+    spec.add_dependency('json', '1.4.6')
+    spec.platform = 'x86-mswin32-60'
+  when /mingw/i
+    spec.add_dependency('ffi')
+    spec.add_dependency('win32-dir', '>= 0.3.5')
+    spec.add_dependency('win32-process', '>= 0.6.1')
+    spec.add_dependency('msgpack', ['>= 0.4.4', '< 0.6'])
+    spec.add_dependency('json', '~> 1.4')
+    spec.platform = 'x86-mingw32'
+  when /win32|dos|cygwin|windows/i
+    raise ::NotImplementedError, 'Unsupported Ruby-on-Windows variant'
+  else
+    # ffi is not currently needed by Linux but it does no harm to have it and it
+    # allows bundler to generate a consistent Gemfile.lock when it is declared
+    # for both mingw and Linux.
+    spec.add_dependency('ffi')
+    spec.add_dependency('msgpack', ['>= 0.4.4', '< 0.6'])
+    spec.add_dependency('json', '~> 1.4')
+  end
+
+  spec.description = <<-EOF
+RightAgent provides a foundation for running an agent on a server to interface
+in a secure fashion with other agents in the RightScale system using RightNet,
+which operates in either HTTP or AMQP mode. When using HTTP, RightAgent
+makes requests to RightApi servers and receives requests using long-polling or
+WebSockets via the RightNet router. To respond to requests it posts to the
+HTTP router. When using AMQP, RightAgent uses RabbitMQ as the message bus and
+the RightNet router as the routing node to make requests; to receives requests
+routed to it by the RightNet router, it establishes a queue on startup. The
+packets are structured to invoke services in the agent represented by actors
+and methods. The RightAgent may respond to these requests with a result packet
+that the router then routes to the originator.
+EOF
+
+  candidates = Dir.glob("{lib,spec}/**/*") +
+               ["LICENSE", "README.rdoc", "Rakefile", "right_agent.gemspec"]
+  spec.files = candidates.sort
+end

data/spec/actor_registry_spec.rb

@@ -0,0 +1,80 @@
+#
+# Copyright (c) 2009-2011 RightScale Inc
+#
+# 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.
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe RightScale::ActorRegistry do
+  
+  class ::WebDocumentImporter
+    include RightScale::Actor
+    expose_non_idempotent :import, :cancel
+    expose_idempotent :special
+
+    def import; 1 end
+    def cancel; 0 end
+    def special; 2 end
+  end
+
+  module ::Actors
+    class ComedyActor
+      include RightScale::Actor
+      expose :fun_tricks
+      def fun_tricks
+        :rabbit_in_the_hat
+      end
+    end
+  end
+
+  before(:each) do
+    @registry = RightScale::ActorRegistry.new
+  end
+
+  it "should know about all services" do
+    @registry.register(WebDocumentImporter.new, nil)
+    @registry.register(Actors::ComedyActor.new, nil)
+    @registry.services.sort.should == ["/actors/comedy_actor/fun_tricks", "/web_document_importer/cancel",
+                                       "/web_document_importer/import", "/web_document_importer/special"]
+  end
+
+  it "should not register anything except RightScale::Actor" do
+    lambda { @registry.register(String.new, nil) }.should raise_error(ArgumentError)
+  end
+
+  it "should register an actor" do
+    importer = WebDocumentImporter.new
+    @registry.register(importer, nil)
+    @registry.actors['web_document_importer'].should == importer
+  end
+
+  it "should log info message that actor was registered" do
+    importer = WebDocumentImporter.new
+    flexmock(RightScale::Log).should_receive(:info).with("[actor] #{importer.class.to_s}").once
+    @registry.register(importer, nil)
+  end
+
+  it "should handle actors registered with a custom prefix" do
+    importer = WebDocumentImporter.new
+    @registry.register(importer, 'monkey')
+    @registry.actor_for('monkey').should == importer
+  end
+  
+end # RightScale::ActorRegistry