right_agent 0.5.1

data/lib/right_agent/payload_formatter.rb

@@ -0,0 +1,104 @@
+#
+# Copyright (c) 2010-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
+
+  # Format the payload of requests and pushes for logging
+  # Individual agents may extend as needed
+  class PayloadFormatter
+
+    # Retrieve info log message for given request type and payload
+    #
+    # === Parameters
+    # type(String):: Request type
+    # payload(Hash):: Request payload
+    #
+    # === Return
+    # msg(String|NilClass):: Message to be logged or nil (don't log)
+    def self.log(type, payload)
+      @formatter ||= new
+      parts = type.split('/')
+      meth = "#{parts[1]}_#{parts[2]}".to_sym
+      res = nil
+      res = @formatter.__send__(meth, payload) if @formatter.respond_to?(meth)
+      res
+    end
+
+    protected
+
+    # booter/declare request log message
+    # Payload :
+    # { :agent_identity => ..., :r_s_version => ..., :resource_uid => ... }
+    #
+    # === Parameters
+    # payload(Hash):: Request payload
+    #
+    # === Return
+    # true:: Always return true
+    def booter_declare(payload)
+      msg = get(payload, :resource_uid)
+    end
+
+    # forwarder/schedule_right_script request log message
+    # Payload :
+    # { :audit_id => ..., :token_id => ..., :agent_identity => ..., account_id => ...,
+    #   :right_script_id => ..., :right_script => ..., :arguments => ... }
+    #
+    # === Parameters
+    # payload(Hash):: Request payload
+    #
+    # === Return
+    # true:: Always return true
+    def forwarder_schedule_right_script(payload)
+      msg = get(payload, :right_script) || "RightScript #{get(payload, :right_script_id)}"
+    end
+
+    # forwarder/schedule_recipe request log message
+    # Payload :
+    # { :audit_id => ..., :token_id => ..., :agent_identity => ..., account_id => ...,
+    #   :recipe_id => ..., :recipe => ..., :arguments => ..., :json => ... }
+    #
+    # === Parameters
+    # payload(Hash):: Request payload
+    #
+    # === Return
+    # true:: Always return true
+    def forwarder_schedule_recipe(payload)
+      msg = get(payload, :recipe) || "recipe #{get(payload, :recipe_id)}"
+    end
+
+    # Access Hash element where key could be a symbol or a string
+    #
+    # === Parameters
+    # hash(Hash):: Hash containing element to be accessed
+    # key(Symbol):: Key of element to be accessed (symbol)
+    #
+    # === Return
+    # elem(Object):: Corresponding element or nil if not found
+    def get(hash, key)
+      elem = hash[key] || hash[key.to_s]
+    end
+
+  end
+
+end
+

data/lib/right_agent/pid_file.rb

@@ -0,0 +1,159 @@
+#
+# 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
+
+  # Encapsulates an agent pid file
+  # A pid file contains three components:
+  #   - the PID of the process running the agent
+  #   - the port number that should be used to talk to the agent via the
+  #     command protocol
+  #   - the cookie used to authenticate a client talking to the agent via
+  #     the command protocol
+  class PidFile
+
+    class AlreadyRunning < Exception; end
+
+    attr_reader :identity
+
+    # Initialize pid file location from agent identity and pid directory
+    def initialize(identity, pid_dir = nil)
+      @identity = identity
+      @pid_dir = File.normalize_path(pid_dir || AgentConfig.pid_dir)
+      @pid_file = File.join(@pid_dir, "#{identity}.pid")
+      @cookie_file = File.join(@pid_dir, "#{identity}.cookie")
+    end
+
+    # Check whether pid file can be created
+    # Delete any existing pid file if process is not running anymore
+    #
+    # === Return
+    # true:: Always return true
+    #
+    # === Raise
+    # AlreadyRunning:: If pid file already exists and process is running
+    def check
+      if pid = read_pid[:pid]
+        if process_running?(pid)
+          raise AlreadyRunning.new("#{@pid_file} already exists and process is running (pid: #{pid})")
+        else
+          Log.info "removing stale pid file: #{@pid_file}"
+          remove
+        end
+      end
+      true
+    end
+    
+    # Write pid to pid file
+    #
+    # === Return
+    # true:: Always return true
+    def write
+      begin
+        FileUtils.mkdir_p(@pid_dir)
+        open(@pid_file,'w') { |f| f.write(Process.pid) }
+        File.chmod(0644, @pid_file)
+      rescue Exception => e
+        Log.error "Failed to create PID file: #{e.message}"
+        raise
+      end
+      true
+    end
+    
+    # Update associated command protocol port
+    #
+    # === Parameters
+    # options[:listen_port](Integer):: Command protocol port to be used for this agent
+    # options[:cookie](String):: Cookie to be used together with command protocol
+    #
+    # === Return
+    # true:: Always return true
+    def set_command_options(options)
+      content = { :listen_port => options[:listen_port], :cookie => options[:cookie] }
+      open(@cookie_file,'w') { |f| f.write(YAML.dump(content)) }
+      File.chmod(0600, @cookie_file)
+      true
+    end
+
+    # Delete pid file
+    #
+    # === Return
+    # true:: Always return true
+    def remove
+      File.delete(@pid_file) if exists?
+      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
+      content = {}
+      if exists?
+        open(@pid_file,'r') { |f| content[:pid] = f.read.to_i }
+        open(@cookie_file,'r') do |f|
+          command_options = YAML.load(f.read) rescue {}
+          content.merge!(command_options)
+        end if File.exists?(@cookie_file)
+      end
+      content
+    end
+
+    # Does pid file exist?
+    #
+    # === Return
+    # true:: If pid file exists
+    # false:: Otherwise
+    def exists?
+      File.exists?(@pid_file)
+    end
+
+    # Human representation
+    #
+    # === Return
+    # path(String):: Path to pid file
+    def to_s
+      path = @pid_file
+    end
+    
+    private
+
+    # Check whether there is a process running with the given pid
+    #
+    # === Parameters
+    # pid(Integer):: PID to check
+    #
+    # === Return
+    # true:: If there is a process running with the given pid
+    # false: Otherwise
+    def process_running?(pid)
+      Process.getpgid(pid) != -1
+    rescue Errno::ESRCH
+      false
+    end
+
+  end # PidFile
+
+end # RightScale

data/lib/right_agent/platform.rb

@@ -0,0 +1,319 @@
+#
+# 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 file may get required twice on Windows: once using long path and once
+# using short path. Since this is where we define the File.normalize_path
+# method to alleviate this issue, we have a chicken & egg problem. So detect if
+# we already required this file and skip the rest if that was the case.
+unless defined?(RightScale::Platform)
+
+# Note that the platform-specific submodules will be loaded on demand to resolve
+# some install-time gem dependency issues.
+
+require 'rbconfig'
+
+
+
+# Load ruby interpreter monkey-patches first (to ensure File.normalize_path is defined, etc.).
+require File.expand_path(File.join(File.dirname(__FILE__), 'monkey_patches', 'ruby_patch'))
+
+module RightScale
+  # Throw when the current platform is not supported for some reason
+  class PlatformNotSupported < Exception; end
+
+  # A utility class that provides information about the platform on which the RightAgent is running
+  # Available information includes:
+  #  - which flavor cloud (EC2, Rackspace, Eucalyptus, ..)
+  #  - which flavor operating system (Linux, Windows or Mac)
+  #  - which OS release (a numeric value that is specific to the OS)
+  #  - directories in which various bits of RightScale state may be found
+  #  - platform-specific information such as Linux flavor or release
+  #
+  # For platform information only used in specific contexts, the dispatch method may be used
+  #
+  # This is a summary of the information you can query by calling Platform's instance methods:
+  #  - .flavor
+  #  - .release
+  #  - .linux?
+  #  - .mac?
+  #  - .windows?
+  #  - .ec2?
+  #  - .rackspace?
+  #  - .eucalyptus?
+  #  - .filesystem
+  #     - right_scale_state_dir
+  #     - spool_dir
+  #     - cache_dir
+  #  - .linux (only available under Linux)
+  #     - ubuntu?
+  #     - centos?
+  #     - suse?
+  class Platform
+
+    include Singleton
+
+    # Generic platform family
+    #
+    # === Return
+    # family(Symbol):: One of :linux, :windows or :darwin
+    def family
+      @family ||= case RbConfig::CONFIG['host_os']
+                  when /mswin|win32|dos|mingw|cygwin/i then :windows
+                  when /darwin/i then :darwin
+                  when /linux/i then :linux
+                  end
+    end
+
+    # Is current platform linux?
+    #
+    # === Return
+    # true:: If current platform is linux
+    # false:: Otherwise
+    def linux?
+      return family == :linux
+    end
+
+    # Is current platform darwin?
+    #
+    # === Return
+    # true:: If current platform is darwin
+    # false:: Otherwise
+    def darwin?
+      return family == :darwin
+    end
+    # Is current platform windows?
+    #
+    # === Return
+    # true:: If current platform is Windows
+    # false:: Otherwise
+    def windows?
+      return family == :windows
+    end
+
+    # Call platform specific implementation of method whose symbol is returned
+    # by the passed in block. Arguments are passed through.
+    # e.g.
+    #
+    #   Platform.dispatch(2) { :echo }
+    #
+    # will result in 'echo_linux(2)' being executed in self if running on linux,
+    # 'echo_windows(2)' if running on Windows and 'echo_darwin(2)' if on Mac OS X.
+    # Note that the method is run in the instance of the caller.
+    #
+    # === Parameters
+    # args:: Pass-through arguments
+    #
+    # === Block
+    # Given block should not take any argument and return a symbol for the
+    # method that should be called
+    #
+    # === Return
+    # res(Object):: Result returned by platform specific implementation
+    def dispatch(*args, &blk)
+      raise "Platform.dispatch requires a block" unless blk
+      binding = blk.binding.eval('self')
+      meth = blk.call
+      target = dispatch_candidates(meth).detect do |candidate|
+        binding.respond_to?(candidate)
+      end
+      raise "No platform dispatch target found in #{binding.class} for " +
+            "'#{meth.inspect}', tried " + dispatch_candidates(meth).join(', ') unless target
+      binding.__send__(target, *args)
+    end
+
+    # Load platform specific implementation
+    #
+    # === Return
+    # true:: Always return true
+    def load_platform_specific
+      if linux?
+        require_linux
+      elsif darwin?
+        require_darwin
+      elsif windows?
+        require_windows
+      else
+        raise PlatformError.new('Unknown platform')
+      end
+    end
+
+    # Are we in an EC2 cloud?
+    #
+    # === Return
+    # true:: If machine is located in an Ec2 cloud
+    # false:: Otherwise
+    def ec2?
+      resolve_cloud_type if @ec2.nil?
+      @ec2
+    end
+
+    # Are we in a Rackspace cloud?
+    #
+    # === Return
+    # true:: If machine is located in an Rackspace cloud
+    # false:: Otherwise
+    def rackspace?
+      resolve_cloud_type if @rackspace.nil?
+      @rackspace
+    end
+
+    # Are we in a Eucalyptus cloud?
+    #
+    # === Return
+    # true:: If machine is located in an Eucalyptus cloud
+    # false:: Otherwise
+    def eucalyptus?
+      resolve_cloud_type if @eucalyptus.nil?
+      @eucalyptus
+    end
+
+    # Controller object
+    #
+    # === Return
+    # (Controller):: Platform-specific controller object
+    def controller
+      platform_service(:controller)
+    end
+
+    # Filesystem config object
+    #
+    # === Return
+    # (Filesystem):: Platform-specific filesystem config object
+    def filesystem
+      platform_service(:filesystem)
+    end
+
+    # VolumeManager config object
+    #
+    # === Return
+    # (VolumeManager):: Platform-specific volume manager config object
+    def volume_manager
+      platform_service(:volume_manager)
+    end
+
+    # Shell information object
+    #
+    # === Return
+    # (Object):: Platform-specific shell information object
+    def shell
+      platform_service(:shell)
+    end
+
+    # SSH information object
+    #
+    # === Return
+    # (Object):: Platform-specific ssh object
+    def ssh
+      platform_service(:ssh)
+    end
+
+    # Platform random number generator (RNG) facilities.
+    #
+    # === Return
+    # (Object):: Platform-specific RNG object
+    def rng
+      platform_service(:rng)
+    end
+
+    private
+
+    # Load platform specific implementation
+    def initialize
+      require File.expand_path(File.join(File.dirname(__FILE__), 'platform', family.to_s))
+      @filesystem = nil
+      @shell      = nil
+      @ssh        = nil
+      @controller = nil
+
+      @ec2        = nil
+      @rackspace  = nil
+      @eucalyptus = nil
+
+      init
+      
+      # Note that we must defer any use of filesystem until requested because
+      # Windows setup scripts attempt to use Platform before installing some
+      # of the required gems. Don't attempt to call code that requires gems in
+      # initialize().
+    end
+
+    def require_linux
+      require File.expand_path(File.join(File.dirname(__FILE__), 'platform', 'linux'))
+    end
+
+    def require_darwin
+      require File.expand_path(File.join(File.dirname(__FILE__), 'platform', 'darwin'))
+    end
+
+    def require_windows
+      require File.expand_path(File.join(File.dirname(__FILE__), 'platform', 'windows'))
+    end
+
+    # Determines which cloud we're on by the cheap but simple expedient of
+    # reading the RightScale cloud file
+    def resolve_cloud_type
+      cloud_type = File.read(File.join(self.filesystem.right_scale_state_dir, 'cloud')) rescue nil
+      @ec2 = false
+      @rackspace = false
+      @eucalyptus = false
+      case cloud_type
+        when 'ec2' then ec2 = true
+        when 'rackspace' then @rackspace = true
+        when 'eucalyptus' then @eucalyptus = true
+      end
+    end
+
+    # Retrieve platform specific service implementation
+    #
+    # === Parameters
+    # name(Symbol):: Service name, one of :filesystem, :shell, :ssh, :controller
+    #
+    # === Return
+    # res(Object):: Service instance
+    #
+    # === Raise
+    # RightScale::Exceptions::PlatformError:: If the service is not known
+    def platform_service(name)
+      instance_var = "@#{name.to_s}".to_sym
+      const_name = name.to_s.camelize
+
+      unless res = self.instance_variable_get(instance_var)
+        load_platform_specific
+        if linux?
+          res = Platform.const_get(const_name).new
+        elsif darwin?
+          res = Platform.const_get(const_name).new
+        elsif windows?
+          res = Platform.const_get(const_name).new
+        end
+      end
+      return res
+    end
+
+  end # Platform
+
+end # RightScale
+
+# Initialize for current platform
+RightScale::Platform.load_platform_specific
+
+end # Unless already defined