right_agent 2.0.7-x86-mingw32

data/lib/right_agent/command/command_parser.rb

@@ -0,0 +1,87 @@
+#
+# 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
+
+  class CommandParser
+
+    # Register callback block
+    #
+    # === Block
+    # Block that will get called back whenever a command is successfully parsed
+    #
+    # === Raise
+    # (ArgumentError): If block is missing
+    def initialize &block
+      raise ArgumentError, 'Missing handler block' unless block
+      @callback = block
+      @buildup = ''
+    end
+
+    # Parse given input
+    # May cause multiple callbacks if multiple commands are successfully parsed
+    # Callback happens in next EM tick
+    #
+    # === Parameters
+    # chunk(String):: Chunck of serialized command(s) to be parsed
+    #
+    # === Return
+    # true:: If callback was called at least once
+    # false:: Otherwise
+    def parse_chunk(chunk)
+      @buildup << chunk
+      chunks = @buildup.split(CommandSerializer::SEPARATOR, -1)
+      if do_call = chunks.size > 1
+        commands = []
+        (0..chunks.size - 2).each do |i|
+          begin
+            commands << CommandSerializer.load(chunks[i])
+          rescue Exception => e
+            # log any exceptions caused by serializing individual chunks instead
+            # of halting EM. each command is discrete so we need to keep trying
+            # so long as there are more commands to process (although subsequent
+            # commands may lack context if previous commands failed).
+            Log.error("Failed parsing command chunk", e, :trace)
+          end
+        end
+        commands.each do |cmd|
+          EM.next_tick do
+            begin
+              @callback.call(cmd)
+            rescue Exception => e
+              # log any exceptions raised by callback instead of halting EM.
+              Log.error("Failed executing parsed command", e, :trace)
+            end
+          end
+        end
+        @buildup = chunks.last
+      end
+      do_call
+    rescue Exception => e
+      # log any other exceptions instead of halting EM.
+      Log.error("Failed parsing command chunk", e, :trace)
+    end
+
+  end # CommandParser
+
+end # RightScale

data/lib/right_agent/command/command_runner.rb

@@ -0,0 +1,118 @@
+#
+# 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
+
+  # Run commands exposed by an agent.
+  # External processes can send commands through a socket with the specified port.
+  # Command runner accepts connections and unserializes commands using YAML.
+  # Each command is expected to be a hash containing the :name and :options keys.
+  class CommandRunner
+    class << self
+      # (Integer) Port command runner is listening on
+      attr_reader :listen_port
+
+      # (String) Cookie used by command protocol
+      attr_reader :cookie
+    end
+
+    # Start a command runner listening on a local TCP port.
+    #
+    # === Parameters
+    # socket_port(Integer):: Base socket port on which to listen for connection,
+    #                        increment and retry if port already taken
+    # identity(String):: Agent identity
+    # commands(Hash):: Commands exposed by agent
+    # fiber_pool(NB::FiberPool):: Pool of initialized fibers to be used for executing
+    #   received commands in non-blocking fashion
+    #
+    # === Block
+    # If a block is provided, this method will yield after all setup has been completed,
+    # passing its PidFile to the block. This provides a customization hook, e.g. for
+    # changing the pid file's access mode or ownership.
+    #
+    # === Return
+    # cmd_options[:cookie](String):: Command protocol cookie
+    # cmd_options[:listen_port](Integer):: Command server listen port
+    #
+    # === Raise
+    # (Exceptions::Application):: If +start+ has already been called and +stop+ hasn't since
+    def self.start(socket_port, identity, commands, fiber_pool = nil)
+      cmd_options = nil
+      @listen_port = socket_port
+
+      begin
+        CommandIO.instance.listen(socket_port) do |c, conn|
+          begin
+            cmd_cookie = c[:cookie]
+            if cmd_cookie == @cookie
+              cmd_name = c[:name].to_sym
+              if commands.include?(cmd_name)
+                if fiber_pool
+                  fiber_pool.spawn { commands[cmd_name].call(c, conn) }
+                else
+                  commands[cmd_name].call(c, conn)
+                end
+              else
+                Log.warning("Unknown command '#{cmd_name}', known commands: #{commands.keys.join(', ')}")
+              end
+            else
+              Log.error("Invalid cookie used by command protocol client (#{cmd_cookie})")
+            end
+          rescue Exception => e
+            Log.warning("Command failed (#{e.message}) at\n#{e.backtrace.join("\n")}")
+          end
+        end
+
+        @cookie = AgentIdentity.generate
+        cmd_options = { :listen_port => @listen_port, :cookie => @cookie }
+        # Now update pid file with command port and cookie
+        pid_file = PidFile.new(identity)
+        if pid_file.exists?
+          pid_file.set_command_options(cmd_options)
+          yield(pid_file) if block_given?
+        else
+          Log.warning("Failed to update listen port in PID file - no pid file found for agent with identity #{identity}")
+        end
+
+        Log.info("[setup] Command server started listening on port #{@listen_port}")
+      rescue Exceptions::IO
+        # Port already taken, increment and retry
+        cmd_options = start(socket_port + 1, identity, commands)
+      end
+
+      cmd_options
+    end
+
+    # Stop command runner, cleanup all opened file descriptors and delete pipe
+    #
+    # === Return
+    # true:: If command listener was listening
+    # false:: Otherwise
+    def self.stop
+      CommandIO.instance.stop_listening
+      Log.info("[stop] Command server stopped listening")
+    end
+
+  end
+
+end

data/lib/right_agent/command/command_serializer.rb

@@ -0,0 +1,63 @@
+#
+# 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
+
+  class CommandSerializer
+
+    # String appended to serialized data to delimit between commands
+    SEPARATOR = "\n#GO\n"
+
+    # Serialize given command so it can be sent to command listener
+    #
+    # === Parameters
+    # command(Object):: Command to serialize
+    #
+    # === Return
+    # data(String):: Corresponding serialized data
+    def self.dump(command)
+      data = YAML::dump(command)
+      data += SEPARATOR
+    end
+
+    # Deserialize command that was previously serialized with +dump+
+    #
+    # === Parameters
+    # data(String):: String containing serialized data
+    #
+    # === Return
+    # command(Object):: Deserialized command
+    #
+    # === Raise
+    # (RightScale::Exceptions::IO): If serialized data is incorrect
+    def self.load(data)
+      command = YAML::load(data)
+      raise RightScale::Exceptions::IO, "Invalid serialized command:\n#{data}" unless command
+      command
+    rescue RightScale::Exceptions::IO
+      raise
+    rescue Exception => e
+      raise RightScale::Exceptions::IO, "Invalid serialized command: #{e.message}\n#{data}"
+    end
+  end
+end

data/lib/right_agent/connectivity_checker.rb

@@ -0,0 +1,179 @@
+#
+# 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.
+
+module RightScale
+
+  # Broker connectivity checker
+  # Checks connectivity when requested
+  class ConnectivityChecker
+
+    # Minimum number of seconds between restarts of the inactivity timer
+    MIN_RESTART_INACTIVITY_TIMER_INTERVAL = 60
+
+    # Number of seconds to wait for ping response from a RightNet router when checking connectivity
+    PING_TIMEOUT = 30
+
+    # Default maximum number of consecutive ping timeouts before attempt to reconnect
+    MAX_PING_TIMEOUTS = 3
+
+    # (EM::Timer) Timer while waiting for RightNet router ping response
+    attr_accessor :ping_timer
+
+    def initialize(sender, check_interval, ping_stats, exception_stats)
+      @sender = sender
+      @check_interval = check_interval
+      @ping_timeouts = {}
+      @ping_timer = nil
+      @ping_stats = ping_stats
+      @exception_stats = exception_stats
+      @last_received = Time.now
+      @message_received_callbacks = []
+      restart_inactivity_timer if @check_interval > 0
+    end
+
+    # Update the time this agent last received a request or response message
+    # and restart the inactivity timer thus deferring the next connectivity check
+    # Also forward this message receipt notification to any callbacks that have registered
+    #
+    # === Block
+    # Optional block without parameters that is activated when a message is received
+    #
+    # === Return
+    # true:: Always return true
+    def message_received(&callback)
+      if block_given?
+        @message_received_callbacks << callback
+      else
+        @message_received_callbacks.each { |c| c.call }
+        if @check_interval > 0
+          now = Time.now
+          if (now - @last_received) > MIN_RESTART_INACTIVITY_TIMER_INTERVAL
+            @last_received = now
+            restart_inactivity_timer
+          end
+        end
+      end
+      true
+    end
+
+    # Check whether broker connection is usable by pinging a router via that broker
+    # Attempt to reconnect if ping does not respond in PING_TIMEOUT seconds and
+    # if have reached timeout limit
+    # Ignore request if already checking a connection
+    #
+    # === Parameters
+    # id(String):: Identity of specific broker to use to send ping, defaults to any
+    #   currently connected broker
+    # max_ping_timeouts(Integer):: Maximum number of ping timeouts before attempt
+    #   to reconnect, defaults to MAX_PING_TIMEOUTS
+    #
+    # === Return
+    # true:: Always return true
+    def check(id = nil, max_ping_timeouts = MAX_PING_TIMEOUTS)
+      unless @terminating || @ping_timer || (id && !@sender.client.connected?(id))
+        @ping_id = id
+        @ping_timer = EM::Timer.new(PING_TIMEOUT) do
+          if @ping_id
+            begin
+              @ping_stats.update("timeout")
+              @ping_timer = nil
+              @ping_timeouts[@ping_id] = (@ping_timeouts[@ping_id] || 0) + 1
+              if @ping_timeouts[@ping_id] >= max_ping_timeouts
+                Log.error("Mapper ping via broker #{@ping_id} timed out after #{PING_TIMEOUT} seconds and now " +
+                          "reached maximum of #{max_ping_timeouts} timeout#{max_ping_timeouts > 1 ? 's' : ''}, " +
+                          "attempting to reconnect")
+                host, port, index, priority = @sender.client.identity_parts(@ping_id)
+                @sender.agent.connect(host, port, index, priority, force = true)
+              else
+                Log.warning("Mapper ping via broker #{@ping_id} timed out after #{PING_TIMEOUT} seconds")
+              end
+            rescue Exception => e
+              Log.error("Failed to reconnect to broker #{@ping_id}", e, :trace)
+              @exception_stats.track("ping timeout", e)
+            end
+          else
+            @ping_timer = nil
+          end
+        end
+
+        handler = lambda do |_|
+          begin
+            if @ping_timer
+              @ping_stats.update("success")
+              @ping_timer.cancel
+              @ping_timer = nil
+              @ping_timeouts[@ping_id] = 0
+              @ping_id = nil
+            end
+          rescue Exception => e
+            Log.error("Failed to cancel router ping", e, :trace)
+            @exception_stats.track("cancel ping", e)
+          end
+        end
+        request = Request.new("/router/ping", nil, {:from => @sender.identity, :token => AgentIdentity.generate})
+        @sender.pending_requests[request.token] = PendingRequest.new(Request, Time.now, handler)
+        ids = [@ping_id] if @ping_id
+        @ping_id = @sender.send(:publish, request, ids).first
+      end
+      true
+    end
+
+    # Prepare for agent termination
+    #
+    # === Return
+    # true:: Always return true
+    def terminate
+      @terminating = true
+      @check_interval = 0
+      if @ping_timer
+        @ping_timer.cancel
+        @ping_timer = nil
+      end
+      if @inactivity_timer
+        @inactivity_timer.cancel
+        @inactivity_timer = nil
+      end
+      true
+    end
+
+    protected
+
+    # Start timer that waits for inactive messaging period to end before checking connectivity
+    #
+    # === Return
+    # true:: Always return true
+    def restart_inactivity_timer
+      @inactivity_timer.cancel if @inactivity_timer
+      @inactivity_timer = EM::Timer.new(@check_interval) do
+        begin
+          check(id = nil, max_ping_timeouts = 1)
+        rescue Exception => e
+          Log.error("Failed connectivity check", e, :trace)
+          @exception_stats.track("check connectivity", e)
+        end
+      end
+      true
+    end
+
+  end # ConnectivityChecker
+
+end # RightScale