right_agent 0.10.13 → 0.13.5

data/lib/right_agent/history.rb

@@ -0,0 +1,136 @@
+#
+# 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.
+
+module RightScale
+
+  # Agent history manager
+  class History
+
+    # Initialize history
+    #
+    # === Parameters
+    # identity(String):: Serialized agent identity
+    def initialize(identity)
+      @pid = Process.pid
+      @history = File.join(AgentConfig.pid_dir, identity + ".history")
+    end
+
+    # Append event to history file
+    #
+    # === Parameters
+    # event(Object):: Event to be stored in the form String or {String => Object},
+    #   where String is the event name and Object is any associated JSON-encodable data
+    #
+    # === Return
+    # true:: Always return true
+    def update(event)
+      @last_update = {:time => Time.now.to_i, :pid => @pid, :event => event}
+      File.open(@history, "a") { |f| f.puts @last_update.to_json }
+      true
+    end
+
+    # Load events from history file
+    #
+    # === Return
+    # events(Array):: List of historical events with each being a hash of
+    #   :time(Integer):: Time in seconds in Unix-epoch when event occurred
+    #   :pid(Integer):: Process id of agent recording the event
+    #   :event(Object):: Event object in the form String or {String => Object},
+    #     where String is the event name and Object is any associated JSON-encodable data
+    def load
+      events = []
+      File.open(@history, "r") { |f| events = f.readlines.map { |l| JSON.load(l) } } if File.readable?(@history)
+      events
+    end
+
+    # Analyze history to determine service attributes like uptime and restart/crash counts
+    #
+    # === Return
+    # (Hash):: Results of analysis
+    #   :uptime(Integer):: Current time in service
+    #   :total_uptime(Integer):: Total time in service (but if there were crashes
+    #     this total includes recovery time, which makes it inaccurate)
+    #   :restarts(Integer|nil):: Number of restarts, if any
+    #   :graceful_exits(Integer|nil):: Number of graceful terminations, if any
+    #   :crashes(Integer|nil):: Number of crashes, if any
+    #   :last_crash_time(Integer|nil):: Time in seconds in Unix-epoch when last crash occurred, if any
+    def analyze_service
+      now = Time.now.to_i
+      if @last_analysis && @last_event == @last_update
+        if @last_analysis[:uptime] > 0
+          delta = now - @last_analysis_time
+          @last_analysis[:uptime] += delta
+          @last_analysis[:total_uptime] += delta
+        end
+      else
+        last_run = last_crash = @last_event = {:time => 0, :pid => 0, :event => nil}
+        restarts = graceful_exits = crashes = accumulated_uptime = 0
+        load.each do |event|
+          event = SerializationHelper.symbolize_keys(event)
+          case event[:event]
+          when "start"
+            case @last_event[:event]
+            when "stop", "graceful exit"
+              restarts += 1
+            when "start"
+              crashes += 1
+              last_crash = event
+            when "run"
+              crashes += 1
+              last_crash = event
+              # Accumulating uptime here although this will wrongly include recovery time
+              accumulated_uptime += (event[:time] - @last_event[:time])
+            end
+          when "run"
+            last_run = event
+          when "stop"
+            if @last_event[:event] == "run" && @last_event[:pid] == event[:pid]
+              accumulated_uptime += (event[:time] - @last_event[:time])
+            end
+          when "graceful exit"
+            graceful_exits += 1
+          else
+            next
+          end
+          @last_event = event
+        end
+        current_uptime = last_run[:pid] == @pid ? (now - last_run[:time]) : 0
+        @last_analysis = {
+          :uptime => current_uptime,
+          :total_uptime => accumulated_uptime + current_uptime
+        }
+        if restarts > 0
+          @last_analysis[:restarts] = restarts
+          @last_analysis[:graceful_exits] = graceful_exits
+        end
+        if crashes > 0
+          @last_analysis[:crashes] = crashes
+          @last_analysis[:last_crash_time] = last_crash[:time]
+        end
+      end
+      @last_analysis_time = now
+      @last_analysis
+    end
+
+  end # History
+
+end # RightScale

data/lib/right_agent/log.rb

@@ -29,7 +29,6 @@ RIGHTSCALE_LOG_DEFINED = true
 
 require 'logger'
 require 'right_support'
-require 'singleton'
 
 require File.expand_path(File.join(File.dirname(__FILE__), 'platform'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'multiplexer'))
@@ -42,7 +41,7 @@ module RightScale
 
     # Expecting use of RightScale patched Singleton so that clients of this
     # class do not need to use '.instance' in Log calls
-    include Singleton
+    include RightSupport::Ruby::EasySingleton
 
     # Default formatter for a Log
     class Formatter < Logger::Formatter
@@ -118,6 +117,7 @@ module RightScale
     def initialize
       # Was log ever used?
       @initialized = false
+      @logger = RightSupport::Log::NullLogger.new  # ensures respond_to? works before init is called
     end
 
     # Forward all method calls to underlying Logger object created with init
@@ -147,7 +147,6 @@ module RightScale
     # === Return
     # (true|false):: True if this object or its proxy responds to the names method, false otherwise
     def respond_to?(m)
-      init unless @initialized
       super(m) || @logger.respond_to?(m)
     end
 
@@ -354,6 +353,10 @@ module RightScale
         end
         if new_level != @level
           @logger.info("[setup] Setting log level to #{level_to_sym(new_level).to_s.upcase}")
+          if new_level == Logger::DEBUG && !RightScale::Platform.windows?
+            @logger.info("[setup] Check syslog configuration to ensure debug messages are not discarded!")
+          else
+          end
           @logger.level = @level = new_level
         end
         # Notify even if unchanged since don't know when callback was set

data/lib/right_agent/monkey_patches/ruby_patch.rb

@@ -51,6 +51,5 @@ RUBY_PATCH_BASE_DIR = File.join(File.dirname(__FILE__), 'ruby_patch')
 
 require File.normalize_path(File.join(RUBY_PATCH_BASE_DIR, 'array_patch'))
 require File.normalize_path(File.join(RUBY_PATCH_BASE_DIR, 'object_patch'))
-require File.normalize_path(File.join(RUBY_PATCH_BASE_DIR, 'singleton_patch'))
 
 end # Unless already defined

data/lib/right_agent/pid_file.rb

@@ -116,7 +116,7 @@ module RightScale
         open(@cookie_file,'r') do |f|
           command_options = (YAML.load(f.read) rescue {}) || {}
           content.merge!(command_options)
-        end if File.exists?(@cookie_file)
+        end if File.readable?(@cookie_file)
       end
       content
     end

data/lib/right_agent/platform.rb

@@ -30,7 +30,7 @@ unless defined?(RightScale::Platform)
 # some install-time gem dependency issues.
 
 require 'rbconfig'
-
+require 'right_support'
 
 
 # Load ruby interpreter monkey-patches first (to ensure File.normalize_path is defined, etc.).
@@ -69,7 +69,7 @@ module RightScale
   #     - suse?
   class Platform
 
-    include Singleton
+    include RightSupport::Ruby::EasySingleton
 
     # Generic platform family
     #

data/lib/right_agent/platform/linux.rb

@@ -514,11 +514,18 @@ module RightScale
           raise PackageManagerNotFound, "No package manager binary (apt, yum, zypper) found in /usr/bin"
         end
         
-        @output = `#{command}`
+        @output = run_installer_command(command)
         @output.scan(regex) { |package| failed_packages << package.first }
         raise PackageNotFound, "The following packages were not available: #{failed_packages.join(', ')}" unless failed_packages.empty?
         return true
       end
+
+      protected
+
+      # A test hook so we can mock the invocation of the installer.
+      def run_installer_command(cmd)
+        `#{cmd}`
+      end
     end
 
   end # Platform

data/lib/right_agent/platform/windows.rb

@@ -219,7 +219,7 @@ module RightScale
 
       # Path to right link configuration and internal usage scripts
       def private_bin_dir
-        return pretty_path(File.join(right_link_home_dir, 'right_link', 'scripts', 'windows'))
+        return pretty_path(File.join(right_link_home_dir, 'bin'))
       end
 
       def sandbox_dir

data/lib/right_agent/sender.rb

@@ -781,41 +781,49 @@ module RightScale
     end
 
     # Handle response to a request
+    # Acknowledge response after delivering it
     # Only to be called from primary thread
     #
     # === Parameters
     # response(Result):: Packet received as result of request
+    # header(AMQP::Frame::Header|nil):: Request header containing ack control
     #
     # === Return
     # true:: Always return true
-    def handle_response(response)
-      token = response.token
-      if response.is_a?(Result)
-        if result = OperationResult.from_results(response)
-          if result.non_delivery?
-            @non_delivery_stats.update(result.content.nil? ? "nil" : result.content.inspect)
-          elsif result.error?
-            @result_error_stats.update(result.content.nil? ? "nil" : result.content.inspect)
+    def handle_response(response, header = nil)
+      begin
+        ack_deferred = false
+        token = response.token
+        if response.is_a?(Result)
+          if result = OperationResult.from_results(response)
+            if result.non_delivery?
+              @non_delivery_stats.update(result.content.nil? ? "nil" : result.content.inspect)
+            elsif result.error?
+              @result_error_stats.update(result.content.nil? ? "nil" : result.content.inspect)
+            end
+            @result_stats.update(result.status)
+          else
+            @result_stats.update(response.results.nil? ? "nil" : response.results)
           end
-          @result_stats.update(result.status)
-        else
-          @result_stats.update(response.results.nil? ? "nil" : response.results)
-        end
 
-        if handler = @pending_requests[token]
-          if result && result.non_delivery? && handler.kind == :send_retryable_request &&
-             [OperationResult::TARGET_NOT_CONNECTED, OperationResult::TTL_EXPIRATION].include?(result.content)
-            # Log and ignore so that timeout retry mechanism continues
-            # Leave purging of associated request until final response, i.e., success response or retry timeout
+          if handler = @pending_requests[token]
+            if result && result.non_delivery? && handler.kind == :send_retryable_request &&
+               [OperationResult::TARGET_NOT_CONNECTED, OperationResult::TTL_EXPIRATION].include?(result.content)
+              # Log and ignore so that timeout retry mechanism continues
+              # Leave purging of associated request until final response, i.e., success response or retry timeout
+              Log.info("Non-delivery of <#{token}> because #{result.content}")
+            else
+              ack_deferred = true
+              deliver(response, handler, header)
+            end
+          elsif result && result.non_delivery?
             Log.info("Non-delivery of <#{token}> because #{result.content}")
           else
-            deliver(response, handler)
+            Log.debug("No pending request for response #{response.to_s([])}")
           end
-        elsif result && result.non_delivery?
-          Log.info("Non-delivery of <#{token}> because #{result.content}")
-        else
-          Log.debug("No pending request for response #{response.to_s([])}")
         end
+      ensure
+        header.ack unless ack_deferred || header.nil?
       end
       true
     end
@@ -1130,13 +1138,7 @@ module RightScale
     def publish_with_timeout_retry(request, parent, count = 0, multiplier = 1, elapsed = 0, broker_ids = nil)
       published_broker_ids = publish(request, broker_ids)
 
-      if published_broker_ids.empty?
-        # Could not publish request to any brokers, so respond with non-delivery
-        # to allow requester, e.g., IdempotentRequest, to retry
-        result = OperationResult.non_delivery("request send failed")
-        @non_delivery_stats.update(result.content)
-        handle_response(Result.new(request.token, request.reply_to, result, @identity))
-      elsif @retry_interval && @retry_timeout && parent
+      if @retry_interval && @retry_timeout && parent && !published_broker_ids.empty?
         interval = [(@retry_interval * multiplier) + (@request_stats.avg_duration || 0), @retry_timeout - elapsed].min
         EM.add_timer(interval) do
           begin
@@ -1178,26 +1180,40 @@ module RightScale
     # === Parameters
     # response(Result):: Packet received as result of request
     # handler(Hash):: Associated request handler
+    # header(AMQP::Frame::Header|nil):: Request header containing ack control
     #
     # === Return
     # true:: Always return true
-    def deliver(response, handler)
-      @request_stats.finish(handler.receive_time, response.token)
+    def deliver(response, handler, header)
+      begin
+        ack_deferred = false
+        @request_stats.finish(handler.receive_time, response.token)
 
-      @pending_requests.delete(response.token) if PendingRequests::REQUEST_KINDS.include?(handler.kind)
-      if parent = handler.retry_parent
-        @pending_requests.reject! { |k, v| k == parent || v.retry_parent == parent }
-      end
+        @pending_requests.delete(response.token) if PendingRequests::REQUEST_KINDS.include?(handler.kind)
+        if parent = handler.retry_parent
+          @pending_requests.reject! { |k, v| k == parent || v.retry_parent == parent }
+        end
 
-      if handler.response_handler
-        EM.__send__(@single_threaded ? :next_tick : :defer) do
+        if handler.response_handler
           begin
-            handler.response_handler.call(response)
-          rescue Exception => e
-            Log.error("Failed processing response #{response.to_s([])}", e, :trace)
-            @exception_stats.track("response", e, response)
+            ack_deferred = true
+            EM.__send__(@single_threaded ? :next_tick : :defer) do
+              begin
+                handler.response_handler.call(response)
+              rescue Exception => e
+                Log.error("Failed processing response #{response.to_s([])}", e, :trace)
+                @exception_stats.track("response", e, response)
+              ensure
+                header.ack if header
+              end
+            end
+          rescue Exception
+            header.ack if header
+            raise
           end
         end
+      ensure
+        header.ack unless ack_deferred || header.nil?
       end
       true
     end

data/right_agent.gemspec

@@ -24,8 +24,8 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name      = 'right_agent'
-  spec.version   = '0.10.13'
-  spec.date      = '2013-02-07'
+  spec.version   = '0.13.5'
+  spec.date      = '2012-10-03'
   spec.authors   = ['Lee Kirchhoff', 'Raphael Simon', 'Tony Spataro']
   spec.email     = 'lee@rightscale.com'
   spec.homepage  = 'https://github.com/rightscale/right_agent'
@@ -37,8 +37,8 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 1.8.7'
   spec.require_path = 'lib'
 
-  spec.add_dependency('right_support', ['>= 1.3', '< 3.0'])
-  spec.add_dependency('right_amqp', '~> 0.3')
+  spec.add_dependency('right_support', ['>= 2.4.1', '< 3.0'])
+  spec.add_dependency('right_amqp', '~> 0.4')
   spec.add_dependency('json', ['~> 1.4'])
   spec.add_dependency('eventmachine', '~> 0.12.10')
   spec.add_dependency('right_popen', '~> 1.0.11')

data/spec/actor_registry_spec.rb

@@ -26,14 +26,12 @@ describe RightScale::ActorRegistry do
   
   class ::WebDocumentImporter
     include RightScale::Actor
-    expose :import, :cancel
+    expose_non_idempotent :import, :cancel
+    expose_idempotent :special
 
-    def import
-      1
-    end
-    def cancel
-      0
-    end
+    def import; 1 end
+    def cancel; 0 end
+    def special; 2 end
   end
 
   module ::Actors
@@ -53,7 +51,8 @@ describe RightScale::ActorRegistry do
   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"]
+    @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

data/spec/actor_spec.rb

@@ -25,17 +25,14 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 describe RightScale::Actor do
   class ::WebDocumentImporter
     include RightScale::Actor
-    expose :import, :cancel
+    expose_non_idempotent :import, :cancel
+    expose_idempotent :special
 
-    def import
-      1
-    end
-    def cancel
-      0
-    end
-    def continue
-      1
-    end
+    def import; 1 end
+    def cancel; 0 end
+    def continue; 1 end
+    def special; 2 end
+    def more_special; 3 end
   end
 
   module ::Actors
@@ -52,35 +49,88 @@ describe RightScale::Actor do
     include RightScale::Actor
     expose :non_existing
   end
-  
-  describe ".expose" do
+
+  before :each do
+    @log = flexmock(RightScale::Log)
+    @log.should_receive(:warning).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+    @log.should_receive(:error).by_default.and_return { |m| raise RightScale::Log.format(*m) }
+  end
+
+  describe "expose" do
+
     before :each do
       @exposed = WebDocumentImporter.instance_variable_get(:@exposed).dup
     end
-    
+
     after :each do
       WebDocumentImporter.instance_variable_set(:@exposed, @exposed)
     end
-    
-    
-    it "should single expose method only once" do
-      3.times { WebDocumentImporter.expose(:continue) }
-      WebDocumentImporter.provides_for("webfiles").should == ["/webfiles/import", "/webfiles/cancel", "/webfiles/continue"]
+
+    context "idempotent" do
+
+      it "exposes as idempotent" do
+        WebDocumentImporter.expose_idempotent(:more_special)
+        WebDocumentImporter.provides_for("webfiles").sort.should == [
+          "/webfiles/cancel", "/webfiles/import", "/webfiles/more_special", "/webfiles/special"]
+        WebDocumentImporter.idempotent?(:special).should be_true
+        WebDocumentImporter.idempotent?(:more_special).should be_true
+      end
+
+      it "treats already exposed non-idempotent method as non-idempotent" do
+        @log.should_receive(:warning).with(/Method cancel declared both idempotent and non-idempotent/).once
+        WebDocumentImporter.expose_idempotent(:cancel)
+        WebDocumentImporter.provides_for("webfiles").sort.should == [
+          "/webfiles/cancel", "/webfiles/import", "/webfiles/special"]
+        WebDocumentImporter.idempotent?(:cancel).should be_false
+      end
+
     end
+
+    context "non_idempotent" do
+
+      it "exposes as non-idempotent" do
+        WebDocumentImporter.expose_non_idempotent(:continue)
+        WebDocumentImporter.provides_for("webfiles").sort.should == [
+          "/webfiles/cancel", "/webfiles/continue", "/webfiles/import", "/webfiles/special"]
+        WebDocumentImporter.idempotent?(:import).should be_false
+        WebDocumentImporter.idempotent?(:cancel).should be_false
+        WebDocumentImporter.idempotent?(:continue).should be_false
+      end
+
+      it "treats already exposed idempotent method as non-idempotent" do
+        @log.should_receive(:warning).with(/Method special declared both idempotent and non-idempotent/).once
+        WebDocumentImporter.expose_non_idempotent(:special)
+        WebDocumentImporter.provides_for("webfiles").sort.should == [
+          "/webfiles/cancel", "/webfiles/import", "/webfiles/special"]
+        WebDocumentImporter.idempotent?(:special).should be_false
+      end
+
+      it "defaults expose method to declare non_idempotent" do
+        WebDocumentImporter.expose(:continue)
+        WebDocumentImporter.provides_for("webfiles").sort.should == [
+          "/webfiles/cancel", "/webfiles/continue", "/webfiles/import", "/webfiles/special"]
+        WebDocumentImporter.idempotent?(:continue).should be_false
+      end
+
+    end
+
   end
-  
-  describe ".default_prefix" do
+
+  describe "default_prefix" do
+
     it "is calculated as default prefix as const path of class name" do
       Actors::ComedyActor.default_prefix.should == "actors/comedy_actor"
       WebDocumentImporter.default_prefix.should == "web_document_importer"
     end
+
   end
 
-  describe ".provides_for(prefix)" do
+  describe "provides_for" do
+
     before :each do
       @provides = Actors::ComedyActor.provides_for("money")
     end
-    
+
     it "returns an array" do
       @provides.should be_kind_of(Array)
     end
@@ -90,10 +140,23 @@ describe RightScale::Actor do
       wdi_provides = WebDocumentImporter.provides_for("webfiles")
       wdi_provides.should include("/webfiles/import")
       wdi_provides.should include("/webfiles/cancel")
+      wdi_provides.should include("/webfiles/special")
     end
-    
-    it "should not include methods not existing in the actor class" do
+
+    it "excludes methods not existing in the actor class" do
+      @log.should_receive(:warning).with("Exposing non-existing method non_existing in actor money").once
       Actors::InvalidActor.provides_for("money").should_not include("/money/non_existing")
     end
+
   end
+
+  describe "idempotent?" do
+
+    it "returns whether idempotent" do
+      WebDocumentImporter.idempotent?(:import).should be_false
+      WebDocumentImporter.idempotent?(:special).should be_true
+    end
+
+  end
+
 end