sant0sk1-adhearsion 0.7.999

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/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/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/events_support.rb

@@ -0,0 +1,26 @@
+# gem 'theatre', '>= 0.8.0'
+# require 'theatre'
+
+module Adhearsion
+  module Events
+    
+    class << self
+      
+      def framework_theatre
+        defined?(@@framework_theatre) ? @@framework_theatre : reinitialize_theatre!
+      end
+      
+      def reinitialize_theatre!
+        @@framework_theatre.gracefully_stop! if defined? @@framework_theatre
+      rescue
+        # Recover and reinitalize
+      ensure
+        # TODO: Extract number of threads to use from AHN_CONFIG
+        @@framework_theatre = Theatre::Theatre.new
+        return @@framework_theatre
+      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

data/lib/adhearsion/host_definitions.rb

@@ -0,0 +1,63 @@
+require 'yaml'
+
+module Adhearsion
+  class HostDefinition
+    
+    SUPPORTED_KEYS = [:host, :username, :password, :key, :name]
+    
+    cattr_reader :definitions
+    @@definitions ||= []
+    
+    class << self
+      def import_from_data_structure(local_definitions)
+        case local_definitions
+          when Array
+            local_definitions.each do |definition|
+              raise HostDefinitionException, "Unrecognized definition: #{definition}" unless definition.is_a?(Hash)
+            end
+            local_definitions.map { |definition| new definition }
+          when Hash
+            local_definitions.map do |(name,definition)|
+              new definition.merge(:name => name)
+            end
+          else
+            raise HostDefinitionException, "Unrecognized definition #{local_definitions}"
+        end
+      end
+      
+      def import_from_yaml(yaml_string)
+        import_from_data_structure YAML.load(yaml_string)
+      end
+      
+      def import_from_yaml_file(file)
+        import_from_yaml YAML.load_file(file)
+      end
+      
+      def clear_definitions!
+        definitions.clear
+      end
+    end
+    
+    attr_reader :name, :host, :username, :password, :key
+    def initialize(hash)
+      @host, @username, @password, @key, @name = hash.values_at(*SUPPORTED_KEYS)
+      @name ||= new_guid
+      
+      unrecognized_keys = hash.keys - SUPPORTED_KEYS
+      raise HostDefinitionException, "Unrecognized key(s): #{unrecognized_keys.map(&:inspect).to_sentence}" if unrecognized_keys.any? 
+      raise HostDefinitionException, "You must supply a password or key!" if username && !(password || key)
+      raise HostDefinitionException, "You must supply a username!" unless username
+      raise HostDefinitionException, 'You cannot supply both a password and key!' if password && key
+      raise HostDefinitionException, 'You must supply a host!' unless host
+      
+      self.class.definitions << self
+    end
+    
+    class HostDefinitionException < Exception
+      
+    end
+    
+  end
+  
+  
+end