mtrudel-adhearsion 0.8.3

data/lib/adhearsion/component_manager/component_tester.rb

@@ -0,0 +1,55 @@
+module ComponentTester
+  
+  class << self
+    
+    ##
+    #
+    #
+    # @return [Module] an anonymous module which includes the ComponentTester module.
+    #
+    def new(component_name, component_directory)
+      component_directory = File.expand_path component_directory
+      main_file = component_directory + "/#{component_name}/#{component_name}.rb"
+      
+      component_manager = Adhearsion::Components::ComponentManager.new(component_directory)
+      component_module  = Adhearsion::Components::ComponentManager::ComponentDefinitionContainer.load_file main_file
+      
+      Module.new do
+        
+        extend ComponentTester
+        
+        (class << self; self; end).send(:define_method, :component_manager)   { component_manager   }
+        (class << self; self; end).send(:define_method, :component_name)      { component_name      }
+        (class << self; self; end).send(:define_method, :component_module)    { component_module    }
+        (class << self; self; end).send(:define_method, :component_directory) { component_directory }
+        
+        
+        define_method(:component_manager)   { component_manager   }
+        define_method(:component_name)      { component_name      }
+        define_method(:component_module)    { component_module    }
+        define_method(:component_directory) { component_directory }
+        
+        def self.const_missing(name)
+          component_module.const_get name
+        end
+        
+      end
+    end
+  end
+  
+  def helper_method(name)
+    Object.new.extend(component_module).method(name)
+  end
+  
+  def config
+    component_manager.configuration_for_component_named component_name
+  end
+  
+  def initialize!
+    metadata = component_module.metaclass.send(:instance_variable_get, :@metadata)
+    if metadata && metadata[:initialization_block].kind_of?(Proc)
+      metadata[:initialization_block].call
+    end
+  end
+  
+end

data/lib/adhearsion/component_manager/spec_framework.rb

@@ -0,0 +1,24 @@
+require 'adhearsion/component_manager/component_tester'
+begin
+  require 'spec'
+rescue LoadError
+  abort 'You do not have the "rspec" gem installed! You must install it to continue.\n\nsudo gem install rspec\n\n'
+end
+
+begin
+  require 'rr'
+rescue LoadError
+  abort 'You do not have the "rr" gem installed! You must install it to continue.\n\nsudo gem install rr\n\n'  
+end
+
+module ComponentConfigurationSpecHelper
+  def mock_component_config_with(new_config)
+    Object.send(:remove_const, :COMPONENTS) rescue nil
+    Object.send(:const_set, :COMPONENTS, OpenStruct.new(new_config))
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+  config.include ComponentConfigurationSpecHelper
+end

data/lib/adhearsion/events_support.rb

@@ -0,0 +1,84 @@
+%w[theatre jicksta-theatre].each do |theatre_gem_name|
+  # Some older versions of the master branch required the theatre gem be installed. This is deprecation logic to inform the
+  # user to uninstall the gem if they happened to have used theatre in the past.
+  begin
+    gem theatre_gem_name
+  rescue LoadError
+    # Good. It should not be installed.
+  else
+    abort <<-MESSAGE
+It seems you have the "#{theatre_gem_name}" gem installed. As of Dec. 7th, 2008 Theatre has been rolled into Adhearsion
+and will be distributed with it.
+
+Please uninstall the gem by doing "sudo gem uninstall #{theatre_gem_name}".
+
+You will not need to install it again in the future. Sorry for the inconvenience.
+    MESSAGE
+  end
+end
+
+require 'theatre'
+
+
+module Adhearsion
+  module Events
+    
+    DEFAULT_FRAMEWORK_EVENT_NAMESPACES = %w[
+      /after_initialized
+      /shutdown
+      /asterisk/manager_interface
+      /asterisk/before_call
+      /asterisk/after_call
+      /asterisk/hungup_call
+      /asterisk/failed_call
+    ]
+    
+    class << self
+      
+      def framework_theatre
+        defined?(@@framework_theatre) ? @@framework_theatre : reinitialize_theatre!
+      end
+      
+      def trigger(*args)
+        framework_theatre.trigger(*args)
+      end
+      
+      def trigger_immediately(*args)
+        framework_theatre.trigger_immediately(*args)
+      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
+        DEFAULT_FRAMEWORK_EVENT_NAMESPACES.each do |namespace|
+          register_namespace_name namespace
+        end
+        return @@framework_theatre
+      end
+      
+      def register_namespace_name(name)
+        framework_theatre.register_namespace_name name
+      end
+      
+      def stop!
+        Events.trigger :shutdown
+        framework_theatre.graceful_stop!
+        framework_theatre.join
+      end
+      
+      def register_callback(namespace, block_arg=nil, &method_block)
+        raise ArgumentError, "Cannot supply two blocks!" if block_arg && block_given?
+        block = method_block || block_arg
+        raise ArgumentError, "Must supply a callback!" unless block
+        
+        framework_theatre.register_callback_at_namespace(namespace, block)
+      end
+      
+    end
+    
+  end
+end

data/lib/adhearsion/foundation/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/foundation/blank_slate.rb

@@ -0,0 +1,5 @@
+class BlankSlate
+  instance_methods.each do |method| 
+    undef_method method unless method =~ /^__/ || method == 'instance_eval'
+  end
+end

data/lib/adhearsion/foundation/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/foundation/event_socket.rb

@@ -0,0 +1,203 @@
+##
+# EventSocket is a small abstraction of TCPSocket which causes it to behave much like an EventMachine Connection object for
+# the sake of better testability. The EventMachine Connection paradigm (as well as other networking libraries such as the 
+# Objective-C HTTP library) uses callbacks to signal different stages of a socket's lifecycle. 
+#
+# A handler can be registered in one of two ways: through registrations on an object yielded by the constructor or 
+# pre-defined on the object given as a constructor parameter. Below is an example definition which uses the block way:
+#
+#   EventSocket.new do |handler|
+#     def handler.receive_data(data)
+#       # Do something here
+#     end
+#     def handler.disconnected
+#       # Do something here
+#     end
+#     def handler.connected
+#       # Do something here
+#     end
+#   end
+#
+# Note: this is also a valid way of defining block callbacks:
+#
+#   EventSocket.new do |handler|
+#     handler.receive_data { |data| do_something }
+#     handler.disconnected { do_something }
+#     handler.connected    { do_something }
+#   end
+#
+# and here is an example of using a handler object:
+#
+#   class MyCallbackHandler
+#     def receive_data(data) end
+#     def connected() end
+#     def disconnected() end
+#   end
+#   EventSocket.new(MyCallbackHandler.new)
+#
+# If you wish to ask the EventSocket what state it is in, you can call the Thread-safe EventSocket#state method. The 
+# supported states are:
+#
+#  - :new
+#  - :connected
+#  - :stopped
+#  - :connection_dropped
+#
+# Note: the EventSocket's state will be changed before these callbacks are executed. For example, if your "connected" 
+# callback queried its own EventSocket for its state, it will have already transitioned to the connected() state.
+#
+# Warning: If an exception occurs in your EventSocket callbacks, they will be "eaten" and never bubbled up the call stack. 
+# You should always wrap your callbacks in a begin/rescue clause and handle exceptions explicitly.
+#
+require "thread"
+require "socket"
+
+class EventSocket
+
+  class << self
+    
+    ##
+    # Creates and returns a connected EventSocket instance.
+    #
+    def connect(*args, &block)
+      instance = new(*args, &block)
+      instance.connect!
+      instance
+    end
+  end
+
+  MAX_CHUNK_SIZE = 256 * 1024
+  
+  def initialize(host, port, handler=nil, &block)
+    raise ArgumentError, "Cannot supply both a handler object and a block" if handler && block_given?
+    raise ArgumentError, "Must supply either a handler object or a block" if !handler && !block_given?
+    
+    @state_lock = Mutex.new
+    @host  = host
+    @port  = port
+    
+    @state = :new
+    @handler = handler || new_handler_from_block(&block)
+  end
+  
+  def state
+    @state_lock.synchronize { @state }
+  end
+  
+  def connect!
+    @state_lock.synchronize do
+      if @state.equal? :connected
+        raise ConnectionError, "Already connected!"
+      else
+        @socket = TCPSocket.new(@host, @port)
+        @state  = :connected
+      end
+    end
+    @handler.connected rescue nil
+    @reader_thread = spawn_reader_thread
+    self
+  rescue => error
+    @state = :failed
+    raise error
+  end
+  
+  ##
+  # Thread-safe implementation of write.
+  #
+  # @param [String] data Data to write
+  #
+  def send_data(data)
+    # Note: TCPSocket#write is intrinsically Thread-safe
+    @socket.write data
+  rescue
+    connection_dropped!
+  end
+    ##
+  # Disconnects this EventSocket and sets the state to :stopped
+  #
+  def disconnect!
+    @state_lock.synchronize do
+      @socket.close rescue nil
+      @state = :stopped
+    end
+  end
+  
+  ##
+  # Joins the Thread which reads data off the socket.
+  #
+  def join
+    @state_lock.synchronize do
+      if @state.equal? :connected
+        @reader_thread.join
+      else
+        nil
+      end
+    end
+  end
+  
+  def receive_data(data)
+    @handler.receive_data(data)
+  end
+  
+  protected
+  
+  def connection_dropped!
+    @state_lock.synchronize do
+      unless @state.equal? :connection_dropped
+        @state = :connection_dropped
+        @handler.disconnected
+      end
+    end
+  end
+  
+  def spawn_reader_thread
+    Thread.new(&method(:reader_loop))
+  end
+  
+  def reader_loop
+    until state.equal? :stopped
+      data = @socket.readpartial(MAX_CHUNK_SIZE)
+      @handler.receive_data data
+    end
+  rescue EOFError
+    connection_dropped!
+  end
+
+  def new_handler_from_block(&handler_block)
+    handler = Object.new
+    handler.metaclass.send :attr_accessor, :set_callbacks
+    handler.set_callbacks = {:receive_data => false, :disconnected => false, :connected => false }
+    
+    def handler.receive_data(&block)
+      self.metaclass.send(:remove_method, :receive_data)
+      self.metaclass.send(:define_method, :receive_data) { |data| block.call data }
+      set_callbacks[:receive_data] = true
+    end
+    def handler.connected(&block)
+      self.metaclass.send(:remove_method, :connected)
+      self.metaclass.send(:define_method, :connected) { block.call }
+      set_callbacks[:connected] = true
+    end
+    def handler.disconnected(&block)
+      self.metaclass.send(:remove_method, :disconnected)
+      self.metaclass.send(:define_method, :disconnected) { block.call }
+      set_callbacks[:disconnected] = true
+    end
+    
+    def handler.singleton_method_added(name)
+      set_callbacks[name.to_sym] = true
+    end
+    
+    yield handler
+    
+    handler.set_callbacks.each_pair do |callback_name,was_set|
+      handler.send(callback_name) {} unless was_set
+    end
+    
+    handler
+    
+  end
+
+  class ConnectionError < Exception; end
+  
+end

data/lib/adhearsion/foundation/future_resource.rb

@@ -0,0 +1,36 @@
+require "thread"
+
+class FutureResource
+  
+  def initialize
+    @resource_lock          = Monitor.new
+    @resource_value_blocker = @resource_lock.new_cond
+  end
+  
+  def set_yet?
+    @resource_lock.synchronize { defined? @resource }
+  end
+  
+  def resource
+    @resource_lock.synchronize do
+      @resource_value_blocker.wait unless defined? @resource
+      @resource
+    end
+  end
+  
+  def resource=(resource)
+    @resource_lock.synchronize do
+      raise ResourceAlreadySetException if defined? @resource
+      @resource = resource
+      @resource_value_blocker.broadcast
+      @resource_value_blocker = nil # Don't really need it anymore.
+    end
+  end
+  
+  class ResourceAlreadySetException < Exception
+    def initialize
+      super "Cannot set this resource twice!"
+    end
+  end
+  
+end