adhearsion 1.2.6 → 2.0.0.alpha1

data/lib/adhearsion/plugin/collection.rb

@@ -0,0 +1,19 @@
+require 'tsort'
+
+module Adhearsion
+  class Plugin
+    class Collection < Array
+      include TSort
+
+      alias :tsort_each_node :each
+
+      def tsort_each_child(child, &block)
+        select { |i| i.before == child.name || i.name == child.after }.each &block
+      end
+
+      def +(other)
+        Collection.new(to_a + other.to_a)
+      end
+    end
+  end
+end

data/lib/adhearsion/plugin/initializer.rb

@@ -0,0 +1,37 @@
+module Adhearsion
+  class Plugin
+    class Initializer
+      attr_reader :name, :block
+
+      def initialize(name, context, options, &block)
+        options[:group] ||= :default
+        @name, @context, @options, @block = name, context, options, block
+      end
+
+      def before
+        @options[:before]
+      end
+
+      def after
+        @options[:after]
+      end
+
+      def belongs_to?(group)
+        @options[:group] == group || @options[:group] == :all
+      end
+
+      def run(*args)
+        @context.instance_exec *args, &block
+      end
+
+      def bind(context)
+        return self if @context
+        Initializer.new @name, context, @options, &block
+      end
+
+      def to_s
+        "#{self.name}: #{@options}"
+      end
+    end
+  end
+end

data/lib/adhearsion/plugin/methods_container.rb

@@ -0,0 +1,6 @@
+module Adhearsion
+  class Plugin
+    class MethodsContainer < Hash
+    end
+  end
+end

data/lib/adhearsion/process.rb

@@ -0,0 +1,94 @@
+require 'state_machine'
+require 'singleton'
+
+module Adhearsion
+  class Process
+    include Singleton
+
+    state_machine :initial => :booting do
+      before_transition :log_state_change
+      after_transition :on => :shutdown, :do => :request_stop
+      after_transition any => :stopped, :do => :final_shutdown
+      after_transition :on => :force_stop, :do => :die_now!
+
+      event :booted do
+        transition :booting => :running
+      end
+
+      event :shutdown do
+        # On first shutdown request, flag our state but continue otherwise normally.
+        transition :running => :stopping
+
+        # On second shutdown request, start rejecting new calls.
+        # This corresponds to the admin pressing CTRL+C twice.
+        transition :stopping => :rejecting
+
+        # On third shutdown request, hang up all active calls.
+        # This corresponds to the admin pressing CTRL+C three times.
+        transition :rejecting => :stopped
+
+        # If we are still booting, transition directly to stopped
+        transition :booting => :force_stop
+      end
+
+      event :hard_shutdown do
+        transition [:running, :stopping] => :rejecting
+      end
+
+      event :stop do
+        transition :rejecting => :stopped
+      end
+
+      event :force_stop do
+        transition all => :force_stopped
+      end
+
+      event :reset do
+        transition all => :booting
+      end
+    end
+
+    attr_accessor :important_threads
+
+    def initialize
+      @important_threads = ThreadSafeArray.new
+      super
+    end
+
+    def log_state_change(transition)
+      event, from, to = transition.event, transition.from_name, transition.to_name
+      logger.info "Transitioning from #{from} to #{to} with #{Adhearsion.active_calls.size} active calls."
+    end
+
+    def request_stop
+      Events.trigger_immediately :stop_requested
+      important_threads << Thread.new { stop_when_zero_calls }
+    end
+
+    def final_shutdown
+      Adhearsion.active_calls.each do |call|
+        call.hangup
+      end
+      # This should shut down any remaining threads.  Once those threads have
+      # stopped, important_threads will be empty and the process will exit
+      # normally.
+      Events.trigger_immediately :shutdown
+    end
+
+    def stop_when_zero_calls
+      until Adhearsion.active_calls.count == 0
+        logger.trace "Stop requested but we still have #{Adhearsion.active_calls.count} active calls."
+        sleep 0.2
+      end
+      final_shutdown
+    end
+
+    def die_now!
+      ::Process.exit 1
+    end
+
+    def self.method_missing(method_name, *args, &block)
+      instance.send method_name, *args, &block
+    end
+  end
+end

data/lib/adhearsion/punchblock_plugin.rb

@@ -0,0 +1,29 @@
+module Adhearsion
+  class PunchblockPlugin < Plugin
+    extend ActiveSupport::Autoload
+
+    autoload :Initializer
+
+    config :punchblock do
+      platform         :xmpp            , :desc => <<-__
+        Platform punchblock shall use to connect to the Telephony provider. Currently supported values:
+        - :xmpp
+        - :asterisk
+      __
+      username            "usera@127.0.0.1", :desc => "Authentication credentials"
+      password            "1"              , :desc => "Authentication credentials"
+      host                nil              , :desc => "Host punchblock needs to connect (where rayo or asterisk are located)"
+      port                nil              , :desc => "Port punchblock needs to connect (by default 5038 for Asterisk, 5222 for Rayo)"
+      root_domain         nil              , :desc => "The root domain at which to address the server"
+      calls_domain        nil              , :desc => "The domain at which to address calls"
+      mixers_domain       nil              , :desc => "The domain at which to address mixers"
+      connection_timeout  60               , :desc => "The amount of time to wait for a connection"
+      reconnect_attempts  1.0/0.0          , :desc => "The number of times to (re)attempt connection to the server"
+      reconnect_timer     5                , :desc => "Delay between connection attempts"
+    end
+
+    init :punchblock do
+      Initializer.start
+    end
+  end
+end

data/lib/adhearsion/punchblock_plugin/initializer.rb

@@ -0,0 +1,137 @@
+module Adhearsion
+  class PunchblockPlugin
+    class Initializer
+      cattr_accessor :config, :client, :dispatcher, :attempts
+
+      self.attempts = 0
+
+      class << self
+        def start
+          self.config = Adhearsion.config[:punchblock]
+          connection_class = case (self.config.platform || :xmpp)
+          when :xmpp
+            ::Punchblock::Connection::XMPP
+          when :asterisk
+            ::Punchblock::Connection::Asterisk
+          end
+          connection_options = {
+            :username           => self.config.username,
+            :password           => self.config.password,
+            :connection_timeout => self.config.connection_timeout,
+            :host               => self.config.host,
+            :port               => self.config.port,
+            :root_domain        => self.config.root_domain,
+            :calls_domain       => self.config.calls_domain,
+            :mixers_domain      => self.config.mixers_domain
+          }
+
+          connection = connection_class.new connection_options
+          self.client = ::Punchblock::Client.new :connection => connection
+
+          # Tell the Punchblock connection that we are ready to process calls.
+          Events.register_callback :after_initialization do
+            connection.ready!
+          end
+
+          # When a stop is requested, change our status to "Do Not Disturb"
+          # This should prevent the telephony engine from sending us any new calls.
+          Events.register_callback :stop_requested do
+            connection.not_ready!
+          end
+
+          # Make sure we stop everything when we shutdown
+          Events.register_callback :shutdown do
+            client.stop
+          end
+
+          # Handle events from Punchblock via events system
+          self.client.register_event_handler do |event|
+            Events.trigger :punchblock, event
+          end
+
+          Events.punchblock ::Punchblock::Connection::Connected do |event|
+            logger.info "Connected to Punchblock server"
+            self.attempts = 0
+          end
+
+          Events.punchblock ::Punchblock::Event::Offer do |offer|
+            dispatch_offer offer
+          end
+
+          Events.punchblock proc { |e| e.respond_to?(:source) }, :source do |event|
+            event.source.trigger_event_handler event
+          end
+
+          Events.punchblock proc { |e| e.respond_to?(:call_id) }, :call_id do |event|
+            dispatch_call_event event
+          end
+
+          connect
+        end
+
+        def connect
+          m = Mutex.new
+          blocker = ConditionVariable.new
+          Events.punchblock ::Punchblock::Connection::Connected do
+            m.synchronize { blocker.broadcast }
+          end
+
+          Adhearsion::Process.important_threads << Thread.new do
+            catching_standard_errors { connect_to_server }
+          end
+
+          # Wait for the connection to establish
+          m.synchronize { blocker.wait m }
+        end
+
+        def connect_to_server
+          begin
+            logger.info "Starting connection to server"
+            client.run
+          rescue ::Punchblock::DisconnectedError => e
+            # We only care about disconnects if the process is up or booting
+            if [:booting, :running].include? Adhearsion::Process.state_name
+              self.attempts += 1
+              Adhearsion::Process.reset unless Adhearsion::Process.state_name == :booting
+              logger.error "Connection lost. Attempting reconnect #{self.attempts} of #{self.config.reconnect_attempts}"
+              sleep self.config.reconnect_timer
+              retry unless self.attempts >= self.config.reconnect_attempts
+              logger.fatal "Connection retry attempts exceeded"
+              raise e
+            end
+          rescue ::Punchblock::ProtocolError => e
+            logger.fatal "The connection failed due to a protocol error: #{e.name}."
+            raise e
+          end
+        end
+
+        def dispatch_offer(offer)
+          catching_standard_errors do
+            call = Adhearsion.active_calls.from_offer offer
+            case Adhearsion::Process.state_name
+            when :booting, :rejecting
+              call.reject :decline
+            when :running
+              dispatcher = Adhearsion.router.handle call
+              dispatcher.call call
+            else
+              call.reject :error
+            end
+          end
+        end
+
+        def dispatch_call_event(event, latch = nil)
+          if call = Adhearsion.active_calls.find(event.call_id)
+            logger.debug "Event received for call #{call.id}: #{event.inspect}"
+            Thread.new do
+              call << event
+              latch.countdown! if latch
+            end
+          else
+            logger.error "Event received for inactive call #{event.call_id}: #{event.inspect}"
+          end
+        end
+      end
+    end # Punchblock
+  end # Plugin
+end # Adhearsion

data/lib/adhearsion/router.rb

@@ -0,0 +1,30 @@
+module Adhearsion
+  class Router
+    extend ActiveSupport::Autoload
+
+    autoload :Route
+
+    attr_reader :routes
+
+    def initialize(&block)
+      @routes = []
+      instance_exec &block
+    end
+
+    def route(*args, &block)
+      Route.new(*args, &block).tap do |route|
+        @routes << route
+      end
+    end
+
+    def match(call)
+      @routes.find { |route| route.match? call }
+    end
+
+    def handle(call)
+      return unless route = match(call)
+      logger.debug "Call #{call.id} passing through router matched route #{route}"
+      route.dispatcher
+    end
+  end
+end

data/lib/adhearsion/router/route.rb

@@ -0,0 +1,42 @@
+module Adhearsion
+  class Router
+    class Route
+      include HasGuardedHandlers
+
+      attr_reader :name, :target, :guards
+
+      def initialize(name, target = nil, *guards, &block)
+        @name = name
+        if block
+          @target, @guards = block, ([target] + guards)
+        else
+          @target, @guards = target, guards
+        end
+        @guards.compact!
+      end
+
+      def match?(call)
+        !guarded? guards, call
+      end
+
+      def dispatcher
+        @dispatcher ||= lambda do |call|
+          controller = if target.respond_to?(:call)
+            DialplanController.new(call).tap do |controller|
+              controller.dialplan = target
+            end
+          else
+            target.new call
+          end
+
+          call.execute_controller controller
+        end
+      end
+
+      def inspect
+        "#<#{self.class}:#{object_id} name=#{name} target=#{target} guards=#{guards}>"
+      end
+      alias :to_s :inspect
+    end
+  end
+end

data/lib/adhearsion/script_ahn_loader.rb

@@ -19,8 +19,8 @@ module Adhearsion
       # could not chdir, no problem just return
     end
 
-    def self.in_ahn_application?
-      File.exists? SCRIPT_AHN
+    def self.in_ahn_application?(path = '.')
+      Dir.chdir(path) { File.exists? SCRIPT_AHN }
     end
 
     def self.in_ahn_application_subdirectory?(path = Pathname.new(Dir.pwd))

data/lib/adhearsion/tasks.rb

@@ -1,16 +1,21 @@
-require 'rake/testtask'
 require 'adhearsion'
-require 'adhearsion/tasks/components'
-require 'adhearsion/tasks/database'
-require 'adhearsion/tasks/testing'
-require 'adhearsion/tasks/generating'
-require 'adhearsion/tasks/lint'
-require 'adhearsion/tasks/deprecations'
+
+%w<
+  configuration
+  testing
+  plugins
+>.each do |file|
+  require "adhearsion/tasks/#{file}"
+end
+
+Adhearsion::Plugin.load_tasks
+
+puts "\nAdhearsion configured environment: #{Adhearsion.config.platform.environment}\n" unless ARGV.empty?
 
 namespace :adhearsion do
-  desc "Dump useful information about this application's adhearsion environment"
+  desc "Dump useful information about this application's Adhearsion environment"
   task :about do
-    puts "Adhearsion version: #{Adhearsion::VERSION::STRING}"
+    puts "Adhearsion version: #{Adhearsion::VERSION}"
   end
 end