right_agent 0.5.1

data/lib/right_agent/command.rb

@@ -0,0 +1,30 @@
+#
+# 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.
+
+COMMAND_BASE_DIR = File.join(File.dirname(__FILE__), 'command')
+
+require File.normalize_path(File.join(COMMAND_BASE_DIR, 'command_constants'))
+require File.normalize_path(File.join(COMMAND_BASE_DIR, 'command_parser'))
+require File.normalize_path(File.join(COMMAND_BASE_DIR, 'command_serializer'))
+require File.normalize_path(File.join(COMMAND_BASE_DIR, 'command_io'))
+require File.normalize_path(File.join(COMMAND_BASE_DIR, 'command_runner'))
+require File.normalize_path(File.join(COMMAND_BASE_DIR, 'command_client'))

data/lib/right_agent/command/agent_manager_commands.rb

@@ -0,0 +1,134 @@
+#
+# 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
+
+  # Commands exposed by agent that has an AgentManager actor
+  class AgentManagerCommands
+
+    # List of command names associated with description
+    # The commands should be implemented in methods in this class named '<name>_command'
+    # where <name> is the name of the command.
+    COMMANDS = {
+      :list             => 'List all available commands with their description',
+      :set_log_level    => 'Set log level to options[:level]',
+      :get_log_level    => 'Get log level',
+      :ping             => 'Ping agent',
+      :stats            => 'Get statistics about agent operation',
+      :terminate        => 'Terminate agent'
+    }
+
+    # Build hash of commands associating command names with block
+    #
+    # === Parameter
+    # agent_manager(AgentManager):: Agent manager used by ping and stats commands
+    #
+    # === Return
+    # cmds(Hash):: Hash of command blocks keyed by command names
+    def self.get(agent_manager)
+      cmds = {}
+      target = new(agent_manager)
+      COMMANDS.each { |k, v| cmds[k] = lambda { |opts, conn| opts[:conn] = conn; target.send("#{k.to_s}_command", opts) } }
+      cmds
+    end
+
+    # Initialize command server
+    #
+    # === Parameter
+    # agent_manager(AgentManager):: Agent manager used by ping and stats commands
+    def initialize(agent_manager)
+      @agent_manager = agent_manager
+      @serializer = Serializer.new
+    end
+
+    protected
+
+    # List command implementation
+    #
+    # === Parameters
+    # opts(Hash):: Should contain the connection for sending data
+    #
+    # === Return
+    # true:: Always return true
+    def list_command(opts)
+      usage = "Agent exposes the following commands:\n"
+      COMMANDS.reject { |k, _| k == :list || k.to_s =~ /test/ }.each do |c|
+        c.each { |k, v| usage += " - #{k.to_s}: #{v}\n" }
+      end
+      CommandIO.instance.reply(opts[:conn], usage)
+    end
+
+    # Set log level command
+    #
+    # === Return
+    # true:: Always return true
+    def set_log_level_command(opts)
+      Log.level = opts[:level] if [ :debug, :info, :warn, :error, :fatal ].include?(opts[:level])
+      CommandIO.instance.reply(opts[:conn], Log.level)
+    end
+
+    # Get log level command
+    #
+    # === Return
+    # true:: Always return true
+    def get_log_level_command(opts)
+      CommandIO.instance.reply(opts[:conn], Log.level)
+    end
+
+    # Ping command
+    #
+    # === Parameters
+    # opts[:conn](EM::Connection):: Connection used to send reply
+    #
+    # === Return
+    # true
+    def ping_command(opts)
+      CommandIO.instance.reply(opts[:conn], @serializer.dump(@agent_manager.ping))
+    end
+
+    # Stats command
+    #
+    # === Parameters
+    # opts[:conn](EM::Connection):: Connection used to send reply
+    # opts[:reset](Boolean):: Whether to reset stats
+    #
+    # === Return
+    # true
+    def stats_command(opts)
+      CommandIO.instance.reply(opts[:conn], @serializer.dump(@agent_manager.stats({:reset => opts[:reset]})))
+    end
+
+    # Terminate command
+    #
+    # === Parameters
+    # opts[:conn](EM::Connection):: Connection used to send reply
+    #
+    # === Return
+    # true:: Always return true
+    def terminate_command(opts)
+      CommandIO.instance.reply(opts[:conn], 'Terminating')
+      @agent_manager.terminate
+    end
+
+  end # AgentManagerCommands
+
+end # RightScale

data/lib/right_agent/command/command_client.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
+
+  class CommandClient
+
+    # Agent response if any
+    attr_accessor :response
+
+    # Create client
+    #
+    # === Parameters
+    # socket_port(Integer):: Socket port on which to connect to agent
+    # cookie(String):: Cookie associated with command server
+    def initialize(socket_port, cookie)
+      @socket_port = socket_port
+      @cookie = cookie
+      @pending = 0
+    end
+
+    # Stop command client
+    #
+    # === Block
+    # Given block gets called back once last response has been received or timeout
+    def stop(&close_handler)
+      if @pending > 0
+        @close_timeout = EM::Timer.new(@last_timeout) { close_handler.call(timeout=true) }
+        @close_handler = lambda { @close_timeout.cancel; close_handler.call(timeout=false) }
+      else
+        close_handler.call(timeout=false)
+      end
+    end
+
+    # Send command to running agent
+    #
+    # === Parameters
+    # options(Hash):: Hash of options and command name
+    #   options[:name]:: Command name
+    #   options[:...]:: Other command specific options, passed through to agent
+    # verbose(Boolean):: Whether client should display debug info
+    # timeout(Integer):: Number of seconds we should wait for a reply from the agent
+    #
+    # === Block
+    # handler: Command results handler
+    #
+    # === Return
+    # true:: Always return true
+    #
+    # === Raise
+    # RuntimeError:: Timed out waiting for result, raised in EM thread
+    def send_command(options, verbose=false, timeout=20, &handler)
+      return if @closing
+      @last_timeout = timeout
+      manage_em = !EM.reactor_running?
+      response_handler = lambda do
+        EM.stop if manage_em
+        handler.call(@response) if handler && @response
+        @pending -= 1
+        @close_handler.call if @close_handler && @pending == 0
+      end
+      send_handler = lambda do
+        @pending += 1
+        command = options.dup
+        command[:verbose] = verbose
+        command[:cookie] = @cookie
+        EM.next_tick { EM.connect('127.0.0.1', @socket_port, ConnectionHandler, command, self, response_handler) }
+        EM.add_timer(timeout) { EM.stop; raise 'Timed out waiting for agent reply' } if manage_em
+      end
+      if manage_em
+        EM.run { send_handler.call }
+      else
+        send_handler.call
+      end
+      true
+    end
+
+    protected
+
+    # EventMachine connection handler which sends command to agent
+    # and waits for response
+    module ConnectionHandler
+
+      # Initialize command
+      #
+      # === Parameters
+      # command(Hash):: Command to be sent
+      # client(RightScale::CommandClient):: Client whose response field should be initialized
+      # callback(Proc):: Called back after response has been set
+      def initialize(command, client, callback)
+        @command = command
+        @parser = CommandParser.new do |data|
+          close_connection
+          client.response = data
+          callback.call
+        end
+      end
+
+      # Send command to agent
+      # Called by EventMachine after connection with agent has been established
+      #
+      # === Return
+      # true:: Always return true
+      def post_init
+        puts "Sending command #{@command.inspect}" if @command[:verbose]
+        send_data(CommandSerializer.dump(@command))
+        true
+      end
+
+      # Handle agent response
+      def receive_data(data)
+        @parser.parse_chunk(data)
+      end
+    end
+
+  end
+end

data/lib/right_agent/command/command_constants.rb

@@ -0,0 +1,42 @@
+#
+# 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 CommandConstants
+
+    # Ports used for command protocol
+    BASE_INSTANCE_AGENT_SOCKET_PORT         = 60000
+    BASE_INSTANCE_AGENT_CHECKER_SOCKET_PORT = 61000
+
+    BASE_CORE_AGENT_SOCKET_PORT             = 70000
+    BASE_LABORER_AGENT_SOCKET_PORT          = 71000
+    BASE_REPLICANT_AGENT_SOCKET_PORT        = 72000
+    BASE_PROXY_AGENT_SOCKET_PORT            = 73000
+    BASE_LIBRARY_AGENT_SOCKET_PORT          = 74000
+    BASE_WASABI_AGENT_SOCKET_PORT           = 75000
+
+    BASE_MAPPER_SOCKET_PORT                 = 79000
+
+  end
+end

data/lib/right_agent/command/command_io.rb

@@ -0,0 +1,128 @@
+# Copyright (c) 2009-2011 RightScale, Inc, All Rights Reserved Worldwide.
+#
+# THIS PROGRAM IS CONFIDENTIAL AND PROPRIETARY TO RIGHTSCALE
+# AND CONSTITUTES A VALUABLE TRADE SECRET.  Any unauthorized use,
+# reproduction, modification, or disclosure of this program is
+# strictly prohibited.  Any use of this program by an authorized
+# licensee is strictly subject to the terms and conditions,
+# including confidentiality obligations, set forth in the applicable
+# License Agreement between RightScale.com, Inc. and
+# the licensee.
+
+require 'singleton'
+
+module RightScale
+
+  # Class which allows listening for data and sending data on sockets
+  # This allows other processes running on the same machine to send commands to
+  # the agent without having to go through RabbitMQ.
+  class CommandIO
+
+    include Singleton
+
+    # ensure uniqueness of handler to avoid confusion.
+    raise "#{ServerInputHandler.name} is already defined" if defined?(ServerInputHandler)
+
+    # EventMachine connection
+    # Define event loop callbacks handler
+    module ServerInputHandler
+
+      # Keep block used to handle incoming data
+      #
+      # === Parameters
+      # handler(Proc):: Incoming data handler should take two arguments:
+      #                   * First argument contains command
+      #                   * Second argument contains connection used to reply
+      def initialize(handler)
+        @handler = handler
+        @parser = CommandParser.new { |cmd| handler.call(cmd, self) }
+      end
+
+      # EventMachine loop callback called whenever there is data coming from the socket
+      #
+      # === Parameter
+      # data(String):: Incoming data
+      #
+      # === Return
+      # true:: Always return true
+      def receive_data(data)
+        @parser.parse_chunk(data)
+        true
+      end
+
+    end
+
+    # Is listener currently waiting for input?
+    #
+    # === Return
+    # true:: If 'listen' was last called
+    # false:: Otherwise
+    def listening
+      !@conn.nil?
+    end
+
+    # Open command socket and wait for input on it
+    # This can only be called again after 'stop_listening' was called
+    #
+    # === Parameters
+    # socket_port(Integer):: Socket port on which to listen
+    #
+    # === Block
+    # The given block should take two arguments:
+    #   * First argument will be given the commands sent through the socket
+    #     Commands should be serialized using RightScale::CommandSerializer.
+    #   * Second argument contains the connection that should be given back to
+    #     +reply+ to send reply
+    #
+    # === Return
+    # true:: Always return true
+    #
+    # === Raise
+    # (RightScale::Exceptions::Argument):: If block is missing
+    # (RightScale::Exceptions::Application):: If +listen+ has already been called and +stop+ hasn't since
+    # (RightScale::Exceptions::Application):: If port is already bound
+    def listen(socket_port, &block)
+      raise Exceptions::Argument, 'Missing listener block' unless block_given?
+      raise Exceptions::Application, 'Already listening' if listening
+      begin
+        @conn = EM.start_server('127.0.0.1', socket_port, ServerInputHandler, block)
+      rescue Exception => e
+        raise Exceptions::IO, 'Listen port unavailable' if e.message =~ /no acceptor/
+      end
+      true
+    end
+
+    # Stop listening for commands
+    # Do nothing if already stopped
+    #
+    # === Return
+    # true:: If command listener was listening
+    # false:: Otherwise
+    def stop_listening
+      res = !@conn.nil?
+      if res
+        EM.stop_server(@conn)
+        @conn = nil
+      end
+      res
+    end
+
+    # Write given data to socket, must be listening
+    #
+    # === Parameters
+    # conn(EM::Connection):: Connection used to send data
+    # data(String):: Data that should be written
+    # close_after_writing(TrueClass|FalseClass):: Whether TCP connection with client should be
+    #                                             closed after reply is sent
+    #
+    # === Return
+    # true:: Always return true
+    def reply(conn, data, close_after_writing=true)
+      conn.send_data(CommandSerializer.dump(data))
+      conn.close_connection_after_writing if close_after_writing
+      true
+    end
+
+  end
+
+end