emissary 1.3.0

data/lib/emissary/errors.rb

@@ -0,0 +1,106 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+module Emissary
+
+  class Error< StandardError
+    class ConnectionError < StandardError; end
+    class InvalidMessageFormat < StandardError; end
+    class NotImplementedError < StandardError; end
+    
+    attr_reader :origin
+
+    def self.new(*args) #:nodoc:
+      allocate.instance_eval(<<-EOS, __FILE__, __LINE__)
+        alias :original_instance_of? :instance_of?
+        alias :original_kind_of? :kind_of?
+  
+        def instance_of? klass
+          self.original_instance_of? klass or origin.instance_of? klass
+        end
+    
+        def kind_of? klass
+          self.original_kind_of? klass or origin.kind_of? klass
+        end
+
+        # Call a superclass's #initialize if it has one
+        initialize(*args)
+
+        self
+      EOS
+    end
+
+    def initialize(origin = Exception, message = '')
+      
+      case origin
+        when Exception
+          @origin = origin
+        when Class
+          @origin = origin.new message
+        else
+          @origin = Exception.new message
+      end
+
+      super message
+    end
+
+    def origin_backtrace
+      origin.backtrace
+    end
+
+    def origin_message
+      origin.message
+    end
+    
+    def message
+      "#{super}\n\t#{self.backtrace.join("\n\t")}\n" +
+      "Origin: #{origin.class}: #{origin_message}\n\t#{origin_backtrace.join("\n\t")}"
+    end
+  end
+end
+
+if __FILE__ == $0
+  class Emissary::TrackingError < Emissary::Error; end
+  class Emissary::NetworkEncapsulatedError < Emissary::Error; end
+  def a() raise ArgumentError, 'testing'; end
+  def b() a; end
+  def c() b; end
+  def d() c; end
+  def test() d; end
+
+  begin
+    begin
+      begin
+        begin
+          test
+        rescue Exception => e
+          raise Emissary::Error.new e, 'general error'
+        end
+      rescue Emissary::Error => e
+        puts "----------------- 1 -----------------\n#{e.message}"
+        raise Emissary::TrackingError.new(e, 'testing tracking')
+      end
+    rescue Emissary::Error => e
+      puts "----------------- 2 -----------------\n#{e.message}"
+      raise Emissary::NetworkEncapsulatedError.new(e, 'testing network encapsulated')
+    end
+  rescue Emissary::Error => e
+    puts "----------------- 3 -----------------\n#{e.message}"
+  end
+  
+  [ Exception, ArgumentError, Emissary::Error, Emissary::TrackingError, Emissary::NetworkEncapsulatedError].each do |k|
+    puts "e.kind_of?(#{k.name}): #{e.kind_of? k}"
+  end
+end

data/lib/emissary/gem_helper.rb

@@ -0,0 +1,183 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+require 'rubygems/spec_fetcher'
+require 'rubygems/dependency_installer'
+require 'rubygems/uninstaller'
+
+module Emissary
+  class GemHelper
+    attr_reader :name, :version
+    
+    def initialize(name)
+      @name    = name
+      @version = current_version
+    end
+    
+    def version
+      (v = @version.to_s.delete('<>!=~ ').strip).empty? ? 0 : v
+    end
+    
+    def normalize_version value
+      case value
+        when Gem::Requirement, Gem::Version
+          value
+        
+        when /^(<|<=|=|!=|>|>=|~>)\s*[0-9.]+$/
+          Gem::Requirement.new value
+          
+        when /^[0-9.]+$/, String, Fixnum
+          Gem::Version.new value
+        
+        when :current
+          Gem::Version.new(self.version)
+          
+        when :all, :any, :installed, :available
+          Gem::Requirement.default
+        
+        when :newer_than_me, :latest, :newest
+          Gem::Requirement.new "> #{self.version}"
+        
+        when :older_than_me
+          Gem::Requirement.new "< #{self.version}"
+      end
+    end
+  
+    def updateable?
+      installed? && !versions(:newer_than_me).empty?
+    end
+    
+    def is_a_provider? version = :current
+      return false unless (spec = Gem.source_index.find_name(@name, normalize_version(version)).first)
+      !Gem::DependencyList.from_source_index(Gem.source_index).ok_to_remove?(spec.full_name)
+    end
+    alias :have_dependents? :is_a_provider?
+    alias :has_dependents?  :is_a_provider? 
+    
+    def removable? version = :current, ignore_dependents = false
+      installed?(version) && (!!ignore_dependents || !have_dependents?(version))
+    end
+    
+    def installable? version = :any
+      !versions(:any).empty? && !installed?(version) && normalize_version(version) > @version 
+    end
+    
+    def installed? version = :any
+      !Gem.source_index.search(Gem::Dependency.new(name, normalize_version(version))).empty?
+    end
+    
+    def current_version
+      return Gem::Version.new(0) unless installed?
+      specs = Gem.source_index.search(Gem::Dependency.new(name, normalize_version(:newest)))
+      specs.map { |spec| spec.version }.sort{ |a,b| a <=> b }.first
+    end
+    
+    def versions which = :all
+      # don't include others for latest/newest - do include otherwise
+      others = [:latest, :newest ].include?(which) ? false : true
+      dependency = Gem::Dependency.new(name, normalize_version(which))
+      list = Gem::SpecFetcher.fetcher.find_matching(dependency, others).map do |spec, source_uri|
+        _, version = spec
+        [version, source_uri]
+      end.sort { |a,b| b[0] <=> a[0] }
+      
+      which != :installed ? list : list.select { |v| installed? v[0]  } 
+    end
+  
+    def dependents version = :current
+      specs = Gem.source_index.find_name(@name, normalize_version(version))
+      specs.inject([]) do |list,spec|
+        list |= spec.dependent_gems
+        list
+      end
+    end
+  
+    def install version = :latest, source = :default
+      return @version unless installable? version
+      
+      source = URI.parse(source).to_s rescue :default
+      
+      options = {}
+      options[:version], source_uri = case version
+        when :latest
+          ver, uri = versions(:newer_than_me).first
+          [ ver, source == :default ? uri : source ]
+        else
+          ver, uri = versions(:newer_than_me).select { |v| v[0] == normalize_version(version) }.flatten
+          [ ver, source == :default ? uri : source ]
+      end
+          
+      raise ArgumentError, "Bad version '#{version.inspect}' - can't install specified version." unless options[:version]
+
+      with_gem_source(source_uri) do
+        installer = Gem::DependencyInstaller.new options
+        installer.install name, options[:version]
+        @version = Gem::Version.new(normalize_version(options[:version]).to_s.delete('<>!=~ '))
+      end
+    end
+  
+    def update version = :latest, source = :default, keep_old = true
+      return false unless updateable?
+      uninstall(@version, false) unless keep_old
+      install version, source 
+    end
+    
+    def uninstall version = :current, ignore_deps = false, remove_execs = false
+      options = {}
+      options[:ignore] = !!ignore_deps
+      options[:executables] = !!remove_execs
+  
+      options[:version] = case version
+        when :current
+          @version
+        when :all
+          options[:all] = true
+          Gem::Requirement.default
+        else
+          versions(:all).select { |v| v[0] == normalize_version(version) }.flatten[0]
+      end
+  
+      return true if not installed? version 
+      raise ArgumentError, "Cannot uninstall version #{version.inspect} - is it installed? [#{options.inspect}]" unless options[:version]
+  
+      unless removable?(version, !!ignore_deps)
+        msg = ['Refusing to uninstall gem required by other gems:']
+        dependents(options[:version]).each do |gem, dep, satlist|
+          msg << "    Gem '#{gem.name}-#{gem.version}' depends on '#{dep.name}' (#{dep.requirement})";
+        end
+        raise Exception, msg.join("\n")
+      end
+  
+      Gem::Uninstaller.new(name, options).uninstall
+      Gem.refresh 
+      @version = Gem::Version.new '0'
+    end
+    alias :remove :uninstall
+
+  private
+  
+    def with_gem_source(source)
+      begin
+        original_sources = Gem.sources.dup
+        Gem.sources.replace [source]
+        return yield
+      ensure
+        Gem.sources.replace original_sources
+        Gem.refresh
+      end
+    end
+  end
+
+end

data/lib/emissary/identity.rb

@@ -0,0 +1,183 @@
+#   Copyright 2010 The New York Times
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+#
+require 'net/http'
+require 'socket'
+
+module Emissary
+  class Identity
+    
+    INTERNAL_IDENTITY_GLOB = ::File.join(Emissary::LIBPATH, 'emissary', 'identity', '*.rb')
+    EXTERNAL_IDENTITY_GLOB = ::File.join(Emissary::EXTERNAL_IDENTITIES, '*.rb')
+    
+    attr_reader :loaded, :methods
+    alias :loaded? :loaded
+
+    private :initialize
+    
+    def initialize
+      @loaded     = false
+      @methods    = nil
+      @identities = nil
+    end
+
+    def self.instance
+      @@instance ||= self.new
+    end
+    
+    def self.new(*largs)
+      # prevent subclasses from being instantiated directly, except through
+      # the identities() method of this parent class. This class is just a
+      # simple method factory and the children shouldn't need to be accessed
+      # except through the interface provided here.
+      if self == Emissary::Identity
+        raise Exception, "Cannot instantiate singleton class directly - use #{self.name}#instance" unless __caller__ == :instance
+      else
+        klass = self.name.split(/::/)[0..-2].join '::'; subklass = self.name.split(/::/).last
+        raise Exception, "Cannot instantiate '#{klass}' subclass '#{subklass}' directly" unless __caller__ == :identities
+      end
+
+      allocate.instance_eval(<<-EOS, __FILE__, __LINE__)
+        load_identities unless self.class != Emissary::Identity
+        self
+      EOS
+    end
+
+    # Delegation Factory - Uses registered high priority subclasses 
+    # for delegation of method calls, falling back to lower priority 
+    # subclasess when the method isn't available or throws a :pass
+    # in the higher priority subclass
+    #
+    def method_missing name, *args
+      # don't perform lookups on subclasses
+      super name, *args unless self.class == Emissary::Identity
+      
+      name = name.to_sym
+      unless (@methods||={}).has_key? name
+        method_delegate = value = nil
+
+        # loop through each possible identity, higher priority identities
+        # first (0 == low, > 0 == higher). 
+        identities.each do |id,object|
+          value = nil
+          if object.respond_to?(name)
+            method_delegate = catch(:pass) {
+              value = object.__send__(name, *args) # test for :pass request
+              object
+            }
+            break unless method_delegate.nil?
+          end
+        end
+        
+        # if we've gone through all the possible delegates, then pass it
+        # up to the superclass (in this case, Object)
+        if method_delegate.nil?
+          return super(name, *args)
+        end
+        
+        @methods[name] = method_delegate
+        return value
+      end
+ 
+      return @methods[name].__send__(name, *args)
+    end
+
+    def self.register name, opts = {}
+      priority = if name != :unix
+        opts[:priority].to_i > 0 ? opts.delete(:priority).to_i : 1
+      else
+        # unix identity always gets zero - though this locks us
+        # into *nix as our base. XXX maybe rethink this?
+        0 
+      end
+      
+      (self.registry[priority] ||= [])  << name
+    end
+
+    def self.exclude names
+      @@exclusions ||= []
+      @@exclusions |= (names.is_a?(String) ? names.split(/\s*,\s*/) : names.to_a.collect { |n| n.to_s.to_sym })
+    end
+
+    # Exclude an identity type when delegating identity method calls
+    #
+    def self.exclusions
+      @@exclusions ||= []
+      @@exclusions.to_a.map! { |e| e.to_sym }
+    end
+
+    def to_s
+      s = ''
+      s << '#<%s:0x%x ' % [ self.class, self.__id__ * 2]
+      s << to_h.inject([]) { |a,(k,v)| a << %Q|@#{k}="#{v}"| }.join(', ')
+      s << '>'
+    end
+
+    # Retrieve a list of all the available identifers through reflection of the subclasses
+    #
+    def identifiers
+      identities.inject([]) do |list,(id,object)|
+        list |= object.public_methods - object.class.superclass.public_methods - self.public_methods;  list
+      end.sort.collect { |id| id.to_sym }
+    end
+
+    # Retreive a hash of all identifiers and their values
+    #
+    def to_h
+      Hash[(identifiers).zip(identifiers.collect { |identifier| self.send(identifier) })]
+    end
+
+    private
+    
+    def self.registry
+      @@registry ||= []
+    end
+    
+    # Loads all available identities included with this gem
+    #
+    def load_identities
+      return unless not !!loaded? 
+
+      Dir[INTERNAL_IDENTITY_GLOB, EXTERNAL_IDENTITY_GLOB].reject do |id|
+        self.class.exclusions.include?("/#{id.to_s.downcase}.rb")
+      end.each do |file|
+        ::Emissary.logger.info "Loading Identity: #{file}"
+        require File.expand_path(file)
+      end
+
+      @loaded = true
+    end
+
+    # Generates list of possible identities after removing registered exclusions
+    # and then ordering them highest priority (> 0) to lowest priority (== 0)
+    #
+    def identities
+      @@identities ||= begin
+        self.class.registry.reverse.flatten.reject do |id|
+          id.nil? || self.class.exclusions.include?(id)
+        end.inject([]) do |a,id|
+          a << [ id.to_s, ::Emissary.klass_const("Emissary::Identity::#{id.to_s.capitalize}").new ]; a
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  puts "-----> Name: " + (Emissary.identity.name rescue 'Could not acquire name')
+  puts "-----> P IP: " + (Emissary.identity.public_ip rescue 'Could not acquire public ip')
+  puts "-----> L IP: " + (Emissary.identity.local_ip rescue 'Could not acquire local_ip')
+  puts "-- Identity: " + (Emissary.identity.to_s rescue 'identity not set...')
+end