sevenscale-adhearsion 0.7.1000

data/lib/adhearsion/component_manager.rb

@@ -0,0 +1,277 @@
+module Adhearsion
+
+  module Components
+    class Manager
+      attr_reader :active_components, :host_information, :started_components, :components_with_call_context
+      def initialize
+        @active_components            = {}
+        @started_components           = []
+        @components_with_call_context = {}
+      end
+
+      def [](component_name)
+        active_components[component_name].component_class.instance
+      end
+    
+      def component(component_name)
+        active_components[component_name]
+      end
+    
+      def has_component?(component_name)
+        active_components.has_key?(component_name)
+      end
+      
+      def component_gems
+        @repository ||= RubygemsRepository.new
+        @repository.adhearsion_gems
+      end
+    
+      def load
+        return unless File.exist?(AHN_ROOT.component_path)
+        component_directories = Dir.glob(File.join(AHN_ROOT.component_path, "*"))
+        component_directories.each do |component_directory|
+          component_name = File.basename(component_directory).to_sym
+          @active_components[component_name] = Component.new(self, component_name, component_directory)
+        end
+      end
+    
+      def start
+        @active_components.keys.each do |name|
+          @active_components[name].start
+        end
+      end
+
+      def stop
+        @started_components.reverse.each do |name|
+          @active_components[name].stop
+        end
+      end
+
+      class RubygemsRepository
+        def initialize
+          require 'rubygems'
+          Gem.manage_gems
+        end
+
+        def adhearsion_gems
+          gems = {}
+          Gem.source_index.each {|name, spec| gems[spec.name] = spec.full_gem_path if spec.requirements.include?("adhearsion")}
+          gems
+        end
+      end
+    end
+    
+    ClassToGetCallContext = Struct.new(:component_class, :instance_variable)
+    class ClassToGetCallContext
+      def instantiate_with_call_context(call_context, *args, &block)
+        component = component_class.allocate
+        component.instance_variable_set(("@"+instance_variable.to_s).to_sym, call_context)
+        component.send(:initialize, *args, &block)
+        component
+      end
+    end
+    
+    
+    #component behavior is shared across components
+    module Behavior
+      def self.included(component_class)
+        component_class.extend(ClassMethods)
+      end
+      
+      def component_name
+        Component.name
+      end
+
+      def component_description
+        Configuration.description || Component.name
+      end
+      
+      module ClassMethods
+        def add_call_context(params = {:as => :call_context})
+          attr_reader params[:as]
+          ComponentManager.components_with_call_context[name] = ClassToGetCallContext.new(self, params[:as])
+        end
+      end
+    end
+    
+    class Component
+      class << self
+        def prepare_component_class(component_module, name)
+          component_class_name = name.to_s.camelize
+          component_module.module_eval(<<-EVAL, __FILE__, __LINE__)
+            class #{component_class_name}
+              def self.name
+                '#{component_class_name}'
+              end
+              include Adhearsion::Components::Behavior
+            end
+          EVAL
+        end
+      end
+        
+      attr_reader :manager, :name, :path, :component_module, :component_class
+      def initialize(manager, name, path)
+        @manager = manager
+        @name    = name
+        @path    = path
+        unless File.exist?(main_file_name)
+          gem_path = @manager.component_gems[@name.to_s]
+          raise "The component '#{@name}' does not have the main file: #{main_file_name}" unless gem_path
+          @path = gem_path
+        end
+        @started = false
+      end
+      
+      def start
+        return if @started
+        manager.started_components << @name
+        @started = true
+        @component_module = ComponentModule.new(self) do |component_module|
+          Component.prepare_component_class(component_module, @name)
+          component_module.load_configuration_file
+        end
+        @component_module.require(File.join("lib", @name.to_s))
+      end
+      
+      def configuration
+        @component_module.const_get(:Configuration)
+      end
+      
+      def stop
+        #@component_class.unload if @component_class && @component_class.respond_to?(:unload)
+      end
+      
+      def configuration_file
+         File.join(path, configuration_file_name)
+      end
+      
+      private
+      
+        def main_file_name
+          File.join(@path, "lib", @name.to_s+".rb")
+        end
+      
+        def configuration_file_name
+          "configuration.rb"
+        end
+    end
+
+    class ComponentModule < Module
+      # The file with which the Script was instantiated.
+      attr_reader :main_file
+
+      # The directory in which main_file is located, and relative to which
+      # #load searches for files before falling back to Kernel#load.
+      attr_reader :dir
+
+      # A hash that maps <tt>filename=>true</tt> for each file that has been
+      # required locally by the script. This has the same semantics as <tt>$"</tt>,
+      # alias <tt>$LOADED_FEATURES</tt>, except that it is local to this script.
+      attr_reader :loaded_features
+
+      class << self
+        alias load new
+      end
+
+      # Creates new Script, and loads _main_file_ in the scope of the Script. If a
+      # block is given, the script is passed to it before loading from the file, and
+      # constants can be defined as inputs to the script.
+      attr_reader :component
+      def initialize(component)   # :yields: self
+        extend ComponentModuleMethods
+        @component       = component        
+        @loaded_features = {}
+
+        const_set :Component, component
+        const_set :Configuration, OpenStruct.new(:description => nil)
+
+        yield self if block_given?
+      end
+      
+      def load_configuration_file
+        load_in_module(component.configuration_file)
+      end
+
+      # Loads _file_ into this Script. Searches relative to the local dir, that is,
+      # the dir of the file given in the original call to
+      # <tt>Script.load(file)</tt>, loads the file, if found, into this Script's
+      # scope, and returns true. If the file is not found, falls back to
+      # <tt>Kernel.load</tt>, which searches on <tt>$LOAD_PATH</tt>, loads the file,
+      # if found, into global scope, and returns true. Otherwise, raises
+      # <tt>LoadError</tt>.
+      #
+      # The _wrap_ argument is passed to <tt>Kernel.load</tt> in the fallback case,
+      # when the file is not found locally.
+      #
+      # Typically called from within the main file to load additional sub files, or
+      # from those sub files.
+
+      def load(file, wrap = false)
+        load_in_module(File.join(component.path, file))
+        true
+      rescue MissingFile
+        super
+      end
+
+      # Analogous to <tt>Kernel#require</tt>. First tries the local dir, then falls
+      # back to <tt>Kernel#require</tt>. Will load a given _feature_ only once.
+      #
+      # Note that extensions (*.so, *.dll) can be required in the global scope, as
+      # usual, but not in the local scope. (This is not much of a limitation in
+      # practice--you wouldn't want to load an extension more than once.) This
+      # implementation falls back to <tt>Kernel#require</tt> when the argument is an
+      # extension or is not found locally.
+
+      def require(feature)
+        unless @loaded_features[feature]
+          @loaded_features[feature] = true
+          file = feature
+          file += ".rb" unless /\.rb$/ =~ file
+          load_in_module(File.join(component.path, file))
+        end
+      rescue MissingFile
+        @loaded_features[feature] = false
+        super
+      end
+
+      # Raised by #load_in_module, caught by #load and #require.
+      class MissingFile < LoadError; end
+
+      # Loads _file_ in this module's context. Note that <tt>\_\_FILE\_\_</tt> and
+      # <tt>\_\_LINE\_\_</tt> work correctly in _file_.
+      # Called by #load and #require; not normally called directly.
+
+      def load_in_module(file)
+        module_eval(File.read(file), File.expand_path(file))
+      rescue Errno::ENOENT => e
+        if /#{file}$/ =~ e.message
+          raise MissingFile, e.message
+        else
+          raise
+        end
+      end
+
+      def to_s
+        "#<#{self.class}:#{File.basename(component.path)}>"
+      end
+
+      module ComponentModuleMethods
+        # This is so that <tt>def meth...</tt> behaves like in Ruby's top-level
+        # context. The implementation simply calls
+        # <tt>Module#module_function(name)</tt>.
+        def method_added(name) # :nodoc:
+          module_function(name)
+        end
+
+        def start_component_after(*others)
+          others.each do |component_name|
+            component.manager.active_components[component_name].start
+          end
+        end
+
+      end
+    end
+  end
+  
+  ComponentManager = Components::Manager.new unless defined? ComponentManager
+end

data/lib/adhearsion/core_extensions/all.rb

@@ -0,0 +1,9 @@
+require 'English'
+require 'tmpdir'
+require 'tempfile'
+require 'active_support'
+
+# Require all other files here.
+Dir.glob File.join(File.dirname(__FILE__), "*rb") do |file|
+  require file
+end

data/lib/adhearsion/core_extensions/custom_daemonizer.rb

@@ -0,0 +1,45 @@
+# This is largely based on the Daemonize library by Travis Whitton and
+# Judson Lester. http://grub.ath.cx/daemonize. I cleaned it up a bit to
+# meet Adhearsion's quality standards.
+module Adhearsion
+  module CustomDaemonizer
+  
+    # Try to fork if at all possible retrying every 5 sec if the
+    # maximum process limit for the system has been reached
+    def safefork
+      begin
+        pid = fork
+        return pid if pid
+      rescue Errno::EWOULDBLOCK
+        sleep 5
+        retry
+      end
+    end
+
+    # This method causes the current running process to become a daemon
+    def daemonize(log_file='/dev/null')
+      oldmode = 0
+      srand # Split rand streams between spawning and daemonized process
+      safefork and exit # Fork and exit from the parent
+
+      # Detach from the controlling terminal
+      unless sess_id = Process.setsid
+        raise 'Cannot detach from controlled terminal'
+      end
+
+      # Prevent the possibility of acquiring a controlling terminal
+      if oldmode.zero?
+        trap 'SIGHUP', 'IGNORE'
+        exit if pid = safefork
+      end
+
+      Dir.chdir "/"   # Release old working directory
+      File.umask 0000 # Ensure sensible umask
+
+      STDIN.reopen "/dev/null"
+      STDOUT.reopen '/dev/null', "a"
+      STDERR.reopen log_file 
+      return oldmode ? sess_id : 0
+    end
+  end
+end

data/lib/adhearsion/core_extensions/global.rb

@@ -0,0 +1 @@
+Infinity = 1.0/0.0

data/lib/adhearsion/core_extensions/guid.rb

@@ -0,0 +1,5 @@
+module Kernel
+  def new_guid(args)
+    
+  end
+end

data/lib/adhearsion/core_extensions/metaprogramming.rb

@@ -0,0 +1,17 @@
+class Object
+  def metaclass
+    class << self
+      self
+    end
+  end
+  
+  def meta_eval(&block)
+    metaclass.instance_eval &block
+  end
+  
+  def meta_def(name, &block)
+    meta_eval do
+      define_method name, &block
+    end
+  end
+end

data/lib/adhearsion/core_extensions/numeric.rb

@@ -0,0 +1,4 @@
+class Numeric
+  def digit() self end
+  def digits() self end
+end

data/lib/adhearsion/core_extensions/pseudo_uuid.rb

@@ -0,0 +1,11 @@
+module PseudoUuidGenerator
+  def uuid
+    returning Array.new(32) { String.random_char } do |string|
+      [8, 13, 18, 23].each do |index|
+        string.insert index, '-'
+      end
+    end.join
+  end
+end
+
+include PseudoUuidGenerator

data/lib/adhearsion/core_extensions/publishable.rb

@@ -0,0 +1,73 @@
+module Adhearsion
+  class DrbDoor
+    
+    include Singleton
+    
+    def add(interface, name, meth)
+      @interfaces ||= {}
+      @interfaces[interface] ||= returning(Object.new) { |obj| obj.metaclass.send(:attr_accessor, :__methods) }
+      obj = @interfaces[interface]
+      obj.__methods ||= {}
+      obj.__methods[name] = meth
+      obj.instance_eval(<<-STR, __FILE__, __LINE__)
+        def #{name}(*args, &block)
+          begin
+            __methods["#{name}"].call(*args, &block)
+          rescue => exception
+            raise RuntimeError, exception.message, exception.backtrace
+          end
+        end
+      STR
+    end
+
+    def method_missing(name, *args, &block)
+      return Module.const_get(name) if name.to_s =~ /^[A-Z]/
+      super unless @interfaces && @interfaces.has_key?(name.to_s)
+      @interfaces[name.to_s]
+    end
+  end
+
+  module Publishable
+    def self.included(base)
+      base.send(:alias_method_chain, :initialize, :publishable)
+      base.extend(ClassMethods)
+    end
+
+    def initialize_with_publishable(*args, &block)
+      initialize_without_publishable(*args, &block)
+      self.class.published_instance_methods.each do |(sym, interface)|
+        DrbDoor.instance.add(interface, sym.to_s, self.method(sym))
+      end
+    end
+
+    module ClassMethods
+      attr_reader :interface
+      attr_reader :published_instance_methods
+    
+      def publish(options={}, &block)
+        @interface = options.delete(:through).to_s || self.to_s
+        begin
+          @capture = true
+          yield
+        ensure
+          @capture = false
+        end
+      end
+
+      def method_added(sym)
+        return if not @capture
+        if sym.to_s !~ /method_added/
+          @published_instance_methods ||= []
+          @published_instance_methods << [sym, @interface]
+        end
+      end
+
+      def singleton_method_added(sym)
+        return if not @capture
+        if sym.to_s !~ /method_added/
+          DrbDoor.instance.add(@interface, sym.to_s, method(sym.to_s))
+        end
+      end
+    end
+  end
+end

data/lib/adhearsion/core_extensions/relationship_properties.rb

@@ -0,0 +1,40 @@
+class Module
+  
+  # In OOP, relationships between classes should be treated as *properties* of those classes. Often, in a complex OO 
+  # architecture, you'll end up with many relationships that intermingle in monolithic ways, blunting the effectiveness of
+  # subclassing.
+  #
+  # For example, say you have an Automobile class which, in its constructor, instantiates a new Battery class and performs
+  # some operations on it such as calling an install() method. Let's also assume the Automobile class exposes a repair()
+  # method which uses a class-level method of Battery to diagnose your own instance of Battery. If the result of the 
+  # diagnosis shows that the Battery is bad, the Automobile will instantiate a new Battery object and replace the old battery
+  # with the new one.
+  #
+  # Now, what if you wish to create a new Automobile derived from existing technology: a HybridAutomobile subclass. For this
+  # particular HybridAutomobile class, let's simply say the only difference between it and its parent is which kind of
+  # Battery it uses -- it requires its own special subclass of Battery. With Automobile's current implementation, its 
+  # references to which Battery it instantiates and uses are embedded in the immutable method defintions. This 
+  # HybridAutomobile needs to override which Battery its superclass' methods use and nothing else.
+  #
+  # For this reason, the Battery class which Automobile uses is semantically a property which others may want to override.
+  # In OOP theory, we define overridable properties in the form of methods and override those methods in the subclasses.
+  #
+  # This method exposes one method which creates human-readable semantics to defining these relationships as properties. It's
+  # used as follows:
+  #
+  # class Automobile
+  #   relationship :battery => Battery
+  #   relationship :chassis => Chassis
+  #   # Other properties and instance methods here....
+  # end
+  #
+  # class HybridAutomobile < Automobile
+  #   relationship :battery => HybridBattery
+  # end
+  def relationships(relationship_mapping)
+    relationship_mapping.each_pair do |class_name, class_object|
+      define_method(class_name) { class_object } 
+    end
+  end
+  
+end

data/lib/adhearsion/core_extensions/string.rb

@@ -0,0 +1,26 @@
+class String
+  
+  def unindent
+    gsub(/^\s*/,'')
+  end
+  
+  def unindent!
+    gsub!(/^\s*/,'')
+  end
+  
+	def self.random_char
+		case random_digit = rand(62)
+			when  0...10 : random_digit.to_s
+			when 10...36 : (random_digit + 55).chr
+			when 36...62 : (random_digit + 61).chr
+		end
+	end
+
+	def self.random(length_of_string=8)
+		Array.new(length_of_string) { random_char }.join
+	end
+	
+  def nameify() downcase.gsub(/[^\w]/, '') end
+	def nameify!() replace nameify end
+	  
+end

data/lib/adhearsion/core_extensions/thread.rb

@@ -0,0 +1,13 @@
+class Thread
+  class << self
+    
+    # Syntactically sugar Thread.current since it's used so much.
+    #
+    # Allows:
+    #   Thread.me.extend DSL::Dialplan::ThreadMixin
+    #   Thread.my.call.io = io
+    
+    alias me current
+    alias my current
+  end
+end

data/lib/adhearsion/core_extensions/thread_safety.rb

@@ -0,0 +1,7 @@
+require 'thread'
+class Object
+  def synchronize(&block)
+    @mutex ||= Mutex.new
+    @mutex.synchronize &block
+  end
+end

data/lib/adhearsion/distributed/gateways/rest_gateway.rb

@@ -0,0 +1,9 @@
+module Adhearsion
+  module Distributed
+    module Gateway
+      module REST
+        
+      end
+    end
+  end
+end

data/lib/adhearsion/distributed/gateways/soap_gateway.rb

@@ -0,0 +1,9 @@
+module Adhearsion
+  module Distributed
+    module Gateway
+      module SOAP
+        
+      end
+    end
+  end
+end

data/lib/adhearsion/distributed/gateways/xmlrpc_gateway.rb

@@ -0,0 +1,9 @@
+module Adhearsion
+  module Distributed
+    module Gateway
+      module XMLRPC
+        
+      end
+    end
+  end
+end

data/lib/adhearsion/hooks.rb

@@ -0,0 +1,57 @@
+module Adhearsion
+
+
+  module Hooks
+    
+    class GenericHook
+
+      def initialize
+        @hooks = []
+      end
+
+      def create_hook(&block)
+        @hooks.synchronize do
+          @hooks << block
+        end
+      end
+
+      # TODO: This is hardly thread safe!
+      def trigger_hooks
+        @hooks.each &:call
+      end
+      
+    end
+
+    class HookWithArguments < GenericHook
+      def trigger_hooks(*args)
+        @hooks.each { |hook| hook.call(*args) }
+      end
+    end
+    
+    ThreadsJoinedAfterInitialized = GenericHook.new
+    
+    OnFailedCall     = HookWithArguments.new
+    OnHungupCall     = HookWithArguments.new
+    AfterInitialized = GenericHook.new
+    BeforeCall       = GenericHook.new
+    AfterCall        = GenericHook.new
+    TearDown         = GenericHook.new
+    
+    class << TearDown
+      def aliases
+        [:before_shutdown]
+      end
+      
+      def catch_termination_signals
+        %w'INT TERM'.each do |sig|
+          trap sig do
+            ahn_log "Shutting down gracefully at #{Time.now}."
+            Adhearsion::Hooks::TearDown.trigger_hooks
+            exit
+          end
+        end
+      end
+    end
+    
+  end
+end