right_agent 2.0.7-x86-mingw32

data/lib/right_agent/agent_identity.rb

@@ -0,0 +1,210 @@
+#
+# 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 identity management
+  class AgentIdentity
+
+    include ProtocolVersionMixin
+
+    # Cutover time at which agents began using new separator
+    SEPARATOR_EPOCH = Time.at(1256702400) unless defined?(SEPARATOR_EPOCH) # Tue Oct 27 21:00:00 -0700 2009
+
+    # Separator used to differentiate between identity components when serialized
+    ID_SEPARATOR = '-' unless defined?(ID_SEPARATOR)
+
+    # Separator used to differentiate between identity components prior to release 3.4
+    ID_SEPARATOR_OLD = '*' unless defined?(ID_SEPARATOR_OLD)
+
+    # Identity components
+    attr_reader :prefix, :agent_type, :token, :base_id
+
+    # Generate new id
+    #
+    # === Parameters
+    # prefix(String):: Prefix used to scope identity
+    # agent_type(String):: Agent type (e.g. 'core', 'instance')
+    # base_id(Integer):: Unique integer value
+    # token(String):: Unique identity token, will be generated randomly if not provided
+    # separator(String):: Character used to separate identity components, defaults to ID_SEPARATOR
+    #
+    # === Raise
+    # ArgumentError:: Invalid argument
+    def initialize(prefix, agent_type, base_id, token = nil, separator = nil)
+      err = "Prefix cannot contain '#{ID_SEPARATOR}'" if prefix && prefix.include?(ID_SEPARATOR)
+      err = "Prefix cannot contain '#{ID_SEPARATOR_OLD}'" if prefix && prefix.include?(ID_SEPARATOR_OLD)
+      err = "Agent type cannot contain '#{ID_SEPARATOR}'" if agent_type.include?(ID_SEPARATOR)
+      err = "Agent type cannot contain '#{ID_SEPARATOR_OLD}'" if agent_type.include?(ID_SEPARATOR_OLD)
+      err = "Agent type cannot be nil" if agent_type.nil?
+      err = "Agent type cannot be empty" if agent_type.size == 0
+      err = "Base ID must be a positive integer" unless base_id.kind_of?(Integer) && base_id >= 0
+      err = "Token cannot contain '#{ID_SEPARATOR}'" if token && token.include?(ID_SEPARATOR)
+      err = "Token cannot contain '#{ID_SEPARATOR_OLD}'" if token && token.include?(ID_SEPARATOR_OLD)
+      raise ArgumentError, err if err
+
+      @separator  = separator || ID_SEPARATOR
+      @prefix     = prefix
+      @agent_type = agent_type
+      @token      = token || self.class.generate
+      @base_id    = base_id
+    end
+
+    # Generate unique identity
+    #
+    # === Return
+    # id(String):: Random 128-bit hexadecimal string
+    def self.generate
+      bytes = Platform.rng.pseudorandom_bytes(16)
+      #Transform into hex string
+      id = bytes.unpack('H*')[0]
+    end
+
+    # Check validity of given serialized identity
+    #
+    # === Parameters
+    # serialized_id(String):: Serialized identity to be tested
+    #
+    # === Return
+    # (Boolean):: true if serialized identity is a valid, otherwise false
+    def self.valid?(serialized_id)
+      valid_parts?(self.compatible_serialized(serialized_id)) if serialized_id
+    end
+    
+    # Instantiate by parsing given token
+    #
+    # === Parameters
+    # serialized_id(String):: Valid serialized agent identity (use 'valid?' to check first)
+    #
+    # === Return
+    # (AgentIdentity):: Corresponding agent identity
+    #
+    # === Raise
+    # (ArgumentError):: Serialized agent identity is invalid
+    def self.parse(serialized_id)
+      prefix, agent_type, token, bid, separator = parts(self.compatible_serialized(serialized_id))
+      raise ArgumentError, "Invalid agent identity: #{serialized_id.inspect}" unless prefix && agent_type && token && bid
+      base_id = bid.to_i
+      raise ArgumentError, "Invalid agent identity base ID: #{bid ? bid : bid.inspect}" unless base_id.to_s == bid
+
+      AgentIdentity.new(prefix, agent_type, base_id, token, separator)
+    end
+
+    # Convert serialized agent identity to format valid for given protocol version
+    # Ignore identity that is not in serialized AgentIdentity format
+    #
+    # === Parameters
+    # serialized_id(String):: Serialized agent identity to be converted
+    # version(Integer):: Target protocol version
+    #
+    # === Return
+    # serialized_id(String):: Compatible serialized agent identity
+    def self.compatible_serialized(serialized_id, version = nil)
+      if version.nil? || ProtocolVersionMixin.can_handle_non_nanite_ids?(version)
+        serialized_id = serialized_id[7..-1] if serialized_id =~ /^nanite-|^mapper-|^router-/
+      else
+        serialized_id = "nanite-#{serialized_id}" if self.valid_parts?(serialized_id)
+      end
+      serialized_id
+    end
+
+    # Check whether identity corresponds to an instance agent
+    #
+    # === Return
+    # (Boolean):: true if id corresponds to an instance agent, otherwise false
+    def instance_agent?
+      agent_type == 'instance'
+    end
+
+    # Check whether identity corresponds to an instance agent
+    #
+    # === Parameters
+    # serialized_id(String):: Valid serialized agent identity (use 'valid?' to check first)
+    #
+    # === Return
+    # (Boolean):: true if id corresponds to an instance agent, otherwise false
+    def self.instance_agent?(serialized_id)
+      parts(serialized_id)[1] == 'instance'
+    end
+
+    # String representation of identity
+    #
+    # === Return
+    # (String):: Serialized identity
+    def to_s
+      "#{@prefix}#{@separator}#{@agent_type}#{@separator}#{@token}#{@separator}#{@base_id}"
+    end
+
+    # Comparison operator
+    #
+    # === Parameters
+    # other(AgentIdentity):: Other agent identity
+    #
+    # === Return
+    # (Boolean):: true if other is identical to self, otherwise false
+    def ==(other)
+      other.kind_of?(::RightScale::AgentIdentity) &&
+      prefix     == other.prefix     &&
+      agent_type == other.agent_type &&
+      token      == other.token      &&
+      base_id    == other.base_id
+    end
+
+    protected
+
+    # Split given serialized id into its parts
+    #
+    # === Parameters
+    # serialized_id(String):: Valid serialized agent identity (use 'valid?' to check first)
+    #
+    # === Return
+    # (Array):: Array of parts: prefix, agent type, token, base id and separator
+    def self.parts(serialized_id)
+      prefix = agent_type = token = bid = separator = nil
+      if serialized_id.include?(ID_SEPARATOR)
+        prefix, agent_type, token, bid = serialized_id.split(ID_SEPARATOR)
+        separator = ID_SEPARATOR
+      elsif serialized_id.include?(ID_SEPARATOR_OLD)
+        prefix, agent_type, token, bid = serialized_id.split(ID_SEPARATOR_OLD)
+        separator = ID_SEPARATOR_OLD
+      end
+      [ prefix, agent_type, token, bid, separator ]
+    end
+
+    # Check that given serialized identity has valid parts
+    #
+    # === Parameters
+    # serialized_id(String):: Serialized identity to be tested
+    #
+    # === Return
+    # (Boolean):: true if serialized identity is a valid identity token, otherwise false
+    def self.valid_parts?(serialized_id)
+      p = parts(serialized_id)
+      res = p.size == 5 &&
+            p[1] && p[1].size > 0 &&
+            p[2] && p[2].size > 0 &&
+            p[3] && p[3].to_i.to_s == p[3]
+    end
+
+  end # AgentIdentity
+
+end # RightScale

data/lib/right_agent/agent_tag_manager.rb

@@ -0,0 +1,237 @@
+#
+# 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
+
+  # Agent tags management
+  class AgentTagManager
+
+    include RightSupport::Ruby::EasySingleton
+
+    # (Agent) Agent being managed
+    attr_accessor :agent
+
+    # Retrieve current agent tags and give result to block
+    #
+    # === Parameters
+    # options(Hash):: Request options
+    #   :raw(Boolean):: true to yield raw tag response instead of deserialized tags
+    #   :timeout(Integer):: timeout in seconds before giving up and yielding an error message
+    #
+    # === Block
+    # Given block should take one argument which will be set with an array
+    # initialized with the tags of this instance
+    #
+    # === Return
+    # true:: Always return true
+    def tags(options = {})
+      # TODO remove use of agent identity when fully drop AMQP
+      do_query(nil, @agent.self_href || @agent.identity, options) do |result|
+        if result.kind_of?(Hash)
+          yield(result.size == 1 ? result.values.first['tags'] : [])
+        else
+          yield result
+        end
+      end
+    end
+
+    # Queries a list of servers in the current deployment which have one or more
+    # of the given tags.
+    #
+    # === Parameters
+    # tags(String, Array):: Tag or tags to query or empty
+    # options(Hash):: Request options
+    #   :raw(Boolean):: true to yield raw tag response instead of deserialized tags
+    #   :timeout(Integer):: timeout in seconds before giving up and yielding an error message
+    #
+    # === Block
+    # Given block should take one argument which will be set with an array
+    # initialized with the tags of this instance
+    #
+    # === Return
+    # true:: Always return true
+    def query_tags(tags, options = {})
+      tags = ensure_flat_array_value(tags) unless tags.nil? || tags.empty?
+      do_query(tags, nil, options) { |result| yield result }
+    end
+
+    # Queries a list of servers in the current deployment which have one or more
+    # of the given tags. Yields the raw response (for responding locally).
+    #
+    # === Parameters
+    # tags(String, Array):: Tag or tags to query or empty
+    # hrefs(Array):: hrefs of resources to query with empty or nil meaning all instances in deployment
+    # options(Hash):: Request options
+    #   :timeout(Integer):: timeout in seconds before giving up and yielding an error message
+    #
+    # === Block
+    # Given block should take one argument which will be set with the raw response
+    #
+    # === Return
+    # true:: Always return true
+    def query_tags_raw(tags, hrefs = nil, options = {})
+      tags = ensure_flat_array_value(tags) unless tags.nil? || tags.empty?
+      options = options.merge(:raw => true)
+      do_query(tags, hrefs, options) { |raw_response| yield raw_response }
+    end
+
+    # Add given tags to agent
+    #
+    # === Parameters
+    # new_tags(String, Array):: Tag or tags to be added
+    #
+    # === Block
+    # A block is optional. If provided, should take one argument which will be set with the
+    # raw response
+    #
+    # === Return
+    # true always return true
+    def add_tags(new_tags)
+      new_tags = ensure_flat_array_value(new_tags) unless new_tags.nil? || new_tags.empty?
+      do_update(new_tags, []) { |raw_response| yield raw_response if block_given? }
+    end
+
+    # Remove given tags from agent
+    #
+    # === Parameters
+    # old_tags(String, Array):: Tag or tags to be removed
+    #
+    # === Block
+    # A block is optional. If provided, should take one argument which will be set with the
+    # raw response
+    #
+    # === Return
+    # true always return true
+    def remove_tags(old_tags)
+      old_tags = ensure_flat_array_value(old_tags) unless old_tags.nil? || old_tags.empty?
+      do_update([], old_tags) { |raw_response| yield raw_response if block_given? }
+    end
+
+    # Clear all agent tags
+    #
+    # === Block
+    # Given block should take one argument which will be set with the raw response
+    #
+    # === Return
+    # true::Always return true
+    def clear
+      do_update([], @agent.tags) { |raw_response| yield raw_response }
+    end
+
+    private
+
+    def agent_check
+      raise ArgumentError.new("Must set agent= before using tag manager") unless @agent
+    end
+
+    # Runs a tag query with an optional list of tags.
+    #
+    # === Parameters
+    # tags(Array):: Tags to query or empty or nil
+    # hrefs(Array):: hrefs of resources to query with empty or nil meaning all instances in deployment
+    # options(Hash):: Request options
+    #   :raw(Boolean):: true to yield raw tag response instead of unserialized tags
+    #   :timeout(Integer):: timeout in seconds before giving up and yielding an error message
+    #
+    # === Block
+    # Given block should take one argument which will be set with an array
+    # initialized with the tags of this instance
+    #
+    # === Return
+    # true:: Always return true
+    def do_query(tags = nil, hrefs = nil, options = {})
+      raw = options[:raw]
+      timeout = options[:timeout]
+
+      request_options = {}
+      request_options[:timeout] = timeout if timeout
+
+      agent_check
+      payload = {:agent_identity => @agent.identity}
+      payload[:tags] = ensure_flat_array_value(tags) unless tags.nil? || tags.empty?
+      payload[:hrefs] = ensure_flat_array_value(hrefs) unless hrefs.nil? || hrefs.empty?
+      request = RightScale::RetryableRequest.new("/router/query_tags", payload, request_options)
+      request.callback { |result| yield raw ? request.raw_response : result }
+      request.errback do |message|
+        Log.error("Failed to query tags (#{message})")
+        yield((raw ? request.raw_response : nil) || message)
+      end
+      request.run
+      true
+    end
+
+    # Runs a tag update with a list of new or old tags
+    #
+    # === Parameters
+    # new_tags(Array):: new tags to add or empty
+    # old_tags(Array):: old tags to remove or empty
+    # block(Block):: optional callback for update response
+    #
+    # === Block
+    # A block is optional. If provided, should take one argument which will be set with the
+    # raw response
+    #
+    # === Return
+    # true:: Always return true
+    def do_update(new_tags, old_tags, &block)
+      agent_check
+      raise ArgumentError.new("Cannot add and remove tags in same update") if new_tags.any? && old_tags.any?
+      tags = @agent.tags
+      tags += new_tags
+      tags -= old_tags
+      tags.uniq!
+
+      if new_tags.any?
+        request = RightScale::RetryableRequest.new("/router/add_tags", {:tags => new_tags})
+      elsif old_tags.any?
+        request = RightScale::RetryableRequest.new("/router/delete_tags", {:tags => old_tags})
+      else
+        return
+      end
+
+      if block
+        # Always yield raw response
+        request.callback do |_|
+          # Refresh agent's copy of tags on successful update
+          @agent.tags = tags
+          block.call(request.raw_response)
+        end
+        request.errback { |message| block.call(request.raw_response || message) }
+      end
+      request.run
+      true
+    end
+
+    # Ensures value is a flat array, making an array from the single value if necessary
+    #
+    # === Parameters
+    # value(Object):: any kind of value
+    #
+    # === Return
+    # result(Array):: flat array value
+    def ensure_flat_array_value(value)
+      value = Array(value).flatten.compact
+    end
+
+  end # AgentTagManager
+
+end # RightScale

data/lib/right_agent/audit_formatter.rb

@@ -0,0 +1,107 @@
+#
+# 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
+
+  # Standard formatter for audit entries
+  # Each method return a hash of two elements:
+  #   - :summary contains the updated summary of the audit entry
+  #   - :detail contains the details to be appended to the audit entry
+  class AuditFormatter
+
+    # Start new audit section
+    #
+    # === Parameters
+    # title(String):: New section title
+    #
+    # === Return
+    # entry(Hash):: Hash containing new audit entry summary and detail
+    def self.new_section(title)
+      title = '' unless title
+      entry = { :summary => title, :detail => "#{ '****' * 20 }\n*RS>#{ title.center(72) }****\n" }
+    end
+
+    # Update audit summary
+    #
+    # === Parameters
+    # status(String):: Updated audit status
+    #
+    # === Return
+    # entry(Hash):: Hash containing new audit entry summary and detail
+    def self.status(status)
+      entry = { :summary => status, :detail => wrap_text(status) }
+    end
+
+    # Append output to current audit section
+    #
+    # === Parameters
+    # text(String):: Output to be appended
+    #
+    # === Return
+    # entry(Hash):: Hash containing new audit entry detail
+    def self.output(text)
+      text += "\n" unless text[-1, 1] == "\n"
+      entry = { :detail => text }
+    end
+
+    # Append info text to current audit section
+    #
+    # === Parameters
+    # info(String):: Information to be appended
+    #
+    # === Return
+    # entry(Hash):: Hash containing new audit entry detail
+    def self.info(text)
+      entry = { :detail => wrap_text(text) }
+    end
+
+    # Append error text to current audit section
+    #
+    # === Parameters
+    # text(String):: Error message to be appended
+    #
+    # === Return
+    # entry(Hash):: Hash containing new audit entry detail
+    def self.error(text)
+      entry = { :detail => "*ERROR> #{text}\n" }
+    end
+
+    protected
+
+    # Wrap text to given number of columns
+    # Tries to be smart and only wrap when there is a space
+    #
+    # === Parameters
+    # txt(String):: Text to be wrapped
+    # prefix(String>:: Prefix for each wrapped line, default to '*RS) '
+    # col(Integer):: Maximum number of columns for each line, default to 80
+    #
+    # === Return
+    # wrapped_text(String):: Wrapped text
+    def self.wrap_text(txt, prefix = '*RS> ', col = 80)
+      txt = '' unless txt
+      wrapped_text = txt.gsub(/(.{1,#{col - prefix.size}})( +|$\n?)|(.{1,#{col - prefix.size}})/, "#{prefix}\\1\\3\n").rstrip + "\n"     
+    end
+
+  end
+
+end