adhearsion 2.0.0.alpha2 → 2.0.0.alpha3

data/lib/adhearsion/outbound_call.rb

@@ -41,14 +41,14 @@ module Adhearsion
 
       write_and_await_response(Punchblock::Command::Dial.new(options), wait_timeout).tap do |dial_command|
         @dial_command = dial_command
-        Adhearsion.active_calls << self
+        Adhearsion.active_calls << current_actor
       end
     end
 
     def run_router
       catching_standard_errors do
-        dispatcher = Adhearsion.router.handle self
-        dispatcher.call self
+        dispatcher = Adhearsion.router.handle current_actor
+        dispatcher.call current_actor
       end
     end
 

data/lib/adhearsion/plugin.rb

@@ -105,6 +105,20 @@ module Adhearsion
         end
       end
 
+      ##
+      # Register generator classes
+      #
+      # @example
+      #     FooBar = Class.new Adhearsion::Plugin do
+      #       generators :'my_plugin:foo_generator' => FooGenerator
+      #     end
+      #
+      def generators(mapping)
+        mapping.each_pair do |name, klass|
+          Generators.add_generator name, klass
+        end
+      end
+
       def subclasses
         @subclasses ||= []
       end

data/lib/adhearsion/punchblock_plugin.rb

@@ -23,11 +23,16 @@ module Adhearsion
     end
 
     init :punchblock do
-      Initializer.start
+      Initializer.init
+    end
+
+    run :punchblock do
+      Initializer.run
     end
 
     class << self
       delegate :client, :to => Initializer
+      delegate :connection, :to => Initializer
 
       def validate_number(value)
         return 1.0/0.0 if ["Infinity", 1.0/0.0].include? value

data/lib/adhearsion/punchblock_plugin/initializer.rb

@@ -1,12 +1,12 @@
 module Adhearsion
   class PunchblockPlugin
     class Initializer
-      cattr_accessor :config, :client, :dispatcher, :attempts
+      cattr_accessor :config, :client, :connection, :dispatcher, :attempts
 
       self.attempts = 0
 
       class << self
-        def start
+        def init
           self.config = Adhearsion.config[:punchblock]
           connection_class = case (self.config.platform || :xmpp)
           when :xmpp
@@ -25,7 +25,7 @@ module Adhearsion
             :mixers_domain      => self.config.mixers_domain
           }
 
-          connection = connection_class.new connection_options
+          self.connection = connection_class.new connection_options
           self.client = ::Punchblock::Client.new :connection => connection
 
           # Tell the Punchblock connection that we are ready to process calls.
@@ -65,7 +65,9 @@ module Adhearsion
           Events.punchblock proc { |e| e.respond_to?(:call_id) }, :call_id do |event|
             dispatch_call_event event
           end
+        end
 
+        def run
           connect
         end
 
@@ -119,6 +121,7 @@ module Adhearsion
             when :booting, :rejecting
               call.reject :decline
             when :running
+              call.accept
               dispatcher = Adhearsion.router.handle call
               dispatcher.call call
             else
@@ -129,11 +132,8 @@ module Adhearsion
 
         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
+            call.deliver_message! event
+            latch.countdown! if latch
           else
             logger.error "Event received for inactive call #{event.call_id}: #{event.inspect}"
           end

data/lib/adhearsion/tasks/configuration.rb

@@ -1,6 +1,6 @@
 namespace :config do
   desc "Show configuration values; accepts a parameter: [nil|platform|<plugin-name>|all]"
-  task :show, :name, :needs => :environment do |t, args|
+  task :show, [:name] => [:environment] do |t, args|
     name = args.name.nil? ? :all : args.name.to_sym
     puts "\nAdhearsion.config do |config|\n\n"
     puts Adhearsion.config.description name, :show_values => true

data/lib/adhearsion/version.rb

@@ -1,5 +1,5 @@
 module Adhearsion #:nodoc:
-  VERSION = '2.0.0.alpha2'
+  VERSION = '2.0.0.alpha3'
 
   class PkgVersion
     include Comparable

data/spec/adhearsion/call_controller/dial_spec.rb

@@ -6,11 +6,11 @@ module Adhearsion
       include CallControllerTestHelpers
 
       let(:to) { 'sip:foo@bar.com' }
-      let(:other_call_id)   { rand }
+      let(:other_call_id)   { new_uuid }
       let(:other_mock_call) { flexmock OutboundCall.new, :id => other_call_id }
 
       let(:second_to)               { 'sip:baz@bar.com' }
-      let(:second_other_call_id)    { rand }
+      let(:second_other_call_id)    { new_uuid }
       let(:second_other_mock_call)  { flexmock OutboundCall.new, :id => second_other_call_id }
 
       let(:mock_end)      { flexmock Punchblock::Event::End.new, :reason => :hangup }
@@ -18,26 +18,26 @@ module Adhearsion
 
       let(:latch) { CountDownLatch.new 1 }
 
-      def mock_dial
-        flexmock(OutboundCall).new_instances.should_receive(:dial).and_return true
-      end
-
       describe "#dial" do
-        it "should create a new call and return it" do
-          mock_dial
-          t = Thread.new do
-            subject.dial(to, {}, latch).should be_a OutboundCall
+        it "should dial the call to the correct endpoint and return it" do
+          other_mock_call
+          flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+          flexmock(other_mock_call).should_receive(:dial).with(to, :from => 'foo').once
+          dial_thread = Thread.new do
+            subject.dial(to, :from => 'foo').should be_a OutboundCall
           end
-          latch.countdown!
-          t.join
+          sleep 0.1
+          other_mock_call << mock_end
+          dial_thread.join.should be_true
         end
 
-        it "should dial the call to the correct endpoint" do
+        it "should default the caller ID to that of the original call" do
           other_mock_call
+          flexmock call, :from => 'sip:foo@bar.com'
           flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
-          flexmock(other_mock_call).should_receive(:dial).with(to, :from => 'foo').once
+          flexmock(other_mock_call).should_receive(:dial).with(to, :from => 'sip:foo@bar.com').once
           dial_thread = Thread.new do
-            subject.dial to, :from => 'foo'
+            subject.dial to
           end
           sleep 0.1
           other_mock_call << mock_end
@@ -49,6 +49,7 @@ module Adhearsion
             other_mock_call
 
             flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(other_mock_call).should_receive(:hangup).once
             flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
 
             latch = CountDownLatch.new 1
@@ -65,11 +66,33 @@ module Adhearsion
             latch.wait(1).should be_true
           end
 
+          it "unblocks the original controller if the original call ends" do
+            other_mock_call
+
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(other_mock_call).should_receive(:hangup).once
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+
+            latch = CountDownLatch.new 1
+
+            Thread.new do
+              subject.dial to
+              latch.countdown!
+            end
+
+            latch.wait(1).should be_false
+
+            call << mock_end
+
+            latch.wait(1).should be_true
+          end
+
           it "joins the new call to the existing one on answer" do
             other_mock_call
 
             flexmock(other_mock_call).should_receive(:dial).once
             flexmock(other_mock_call).should_receive(:join).once.with(call)
+            flexmock(other_mock_call).should_receive(:hangup).once
             flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
 
             latch = CountDownLatch.new 1
@@ -86,6 +109,29 @@ module Adhearsion
 
             latch.wait(1).should be_true
           end
+
+          it "hangs up the new call when the dial unblocks" do
+            other_mock_call
+
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(other_mock_call).should_receive(:join).once.with(call)
+            flexmock(other_mock_call).should_receive(:hangup).once
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+
+            latch = CountDownLatch.new 1
+
+            Thread.new do
+              subject.dial to
+              latch.countdown!
+            end
+
+            latch.wait(1).should be_false
+
+            other_mock_call << mock_answered
+            call << mock_end
+
+            latch.wait(1).should be_true
+          end
         end
 
         describe "with multiple third parties specified" do
@@ -95,10 +141,11 @@ module Adhearsion
 
             flexmock(other_mock_call).should_receive(:dial).once
             flexmock(other_mock_call).should_receive(:join).once.with(call)
-            flexmock(other_mock_call).should_receive(:hangup!).never
+            flexmock(other_mock_call).should_receive(:hangup).once
 
             flexmock(second_other_mock_call).should_receive(:dial).once
-            flexmock(second_other_mock_call).should_receive(:hangup!).once
+            flexmock(second_other_mock_call).should_receive(:join).never
+            flexmock(second_other_mock_call).should_receive(:hangup).twice
 
             flexmock(OutboundCall).should_receive(:new).and_return other_mock_call, second_other_mock_call
             latch = CountDownLatch.new 1
@@ -114,6 +161,49 @@ module Adhearsion
             other_mock_call << mock_answered
             other_mock_call << mock_end
 
+            latch.wait(1).should be_false
+
+            second_other_mock_call << mock_end
+
+            latch.wait(2).should be_true
+
+            t.join
+            calls = t.value
+            calls.should have(2).calls
+            calls.each { |c| c.should be_a OutboundCall }
+          end
+
+          it "unblocks when the joined call unjoins, allowing it to proceed further" do
+            other_mock_call
+            second_other_mock_call
+
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(other_mock_call).should_receive(:join).once.with(call)
+            flexmock(other_mock_call).should_receive(:hangup).once
+
+            flexmock(second_other_mock_call).should_receive(:dial).once
+            flexmock(second_other_mock_call).should_receive(:join).never
+            flexmock(second_other_mock_call).should_receive(:hangup).twice
+
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call, second_other_mock_call
+            latch = CountDownLatch.new 1
+
+            t = Thread.new do
+              calls = subject.dial [to, second_to]
+              latch.countdown!
+              calls
+            end
+
+            latch.wait(1).should be_false
+
+            other_mock_call << mock_answered
+            other_mock_call << Punchblock::Event::Unjoined.new(:other_call_id => call.id)
+            other_mock_call << mock_end
+
+            latch.wait(1).should be_false
+
+            second_other_mock_call << mock_end
+
             latch.wait(2).should be_true
 
             t.join
@@ -130,6 +220,7 @@ module Adhearsion
             other_mock_call
 
             flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(other_mock_call).should_receive(:hangup).once
             flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
 
             latch = CountDownLatch.new 1

data/spec/adhearsion/call_controller_spec.rb

@@ -29,41 +29,7 @@ module Adhearsion
     describe "execution on a call" do
       before do
         flexmock subject, :execute_component_and_await_completion => nil
-        flexmock call, :write_and_await_response => nil
-      end
-
-      context "when auto-accept is enabled" do
-        before do
-          Adhearsion.config.platform.automatically_accept_incoming_calls = true
-        end
-
-        it "should accept the call" do
-          subject.should_receive(:accept).once.ordered
-          subject.should_receive(:run).once.ordered
-          subject.execute!
-        end
-
-        context "and accept is skipped" do
-          before { subject.skip_accept! }
-
-          it "should not accept the call" do
-            subject.should_receive(:accept).never
-            subject.should_receive(:run).once
-            subject.execute!
-          end
-        end
-      end
-
-      context "when auto-accept is disabled" do
-        before do
-          Adhearsion.config.platform.automatically_accept_incoming_calls = false
-        end
-
-        it "should not accept the call" do
-          subject.should_receive(:accept).never
-          subject.should_receive(:run).once
-          subject.execute!
-        end
+        flexmock call.wrapped_object, :write_and_await_response => nil
       end
 
       it "catches Hangup exceptions and logs the hangup" do
@@ -137,9 +103,8 @@ module Adhearsion
 
       before do
         flexmock subject, :execute_component_and_await_completion => nil
-        flexmock call, :write_and_await_response => nil
+        flexmock call.wrapped_object, :write_and_await_response => nil
         flexmock(Events).should_receive(:trigger).with(:exception, Exception).never
-        Adhearsion.config.platform.automatically_accept_incoming_calls = true
       end
 
       it "should invoke another controller before returning to the current controller" do
@@ -155,12 +120,6 @@ module Adhearsion
         subject.execute!
       end
 
-      it "should not attempt to accept the call again" do
-        call.should_receive(:accept).once
-
-        subject.execute!
-      end
-
       it "should allow the outer controller to cease execution and handle remote hangups" do
         subject[:second_controller] = SecondControllerWithRemoteHangup
 
@@ -195,11 +154,10 @@ module Adhearsion
       subject { PassController.new call }
 
       before do
-        flexmock(call).should_receive(:write_and_await_response).and_return nil
+        flexmock(call.wrapped_object).should_receive(:write_and_await_response).and_return nil
         flexmock subject, :execute_component_and_await_completion => nil
         flexmock(SecondController).new_instances.should_receive(:md_check).once.with :foo => 'bar'
         flexmock(Events).should_receive(:trigger).with(:exception, Exception).never
-        Adhearsion.config.platform.automatically_accept_incoming_calls = true
       end
 
       let(:latch) { CountDownLatch.new 1 }
@@ -208,18 +166,12 @@ module Adhearsion
         subject.should_receive(:before).once.ordered
         call.should_receive(:answer).once.ordered
         subject.should_receive(:after).never.ordered
-        call.should_receive(:hangup!).once.ordered
+        call.wrapped_object.should_receive(:hangup).once.ordered
 
         call.execute_controller subject, latch
         latch.wait(1).should be_true
       end
 
-      it "should not attempt to accept the call again" do
-        call.should_receive(:accept).once
-
-        CallController.exec subject
-      end
-
       it "should execute after_call callbacks before passing control" do
         subject.should_receive(:before).once.ordered
         subject.should_receive(:foobar).once.ordered
@@ -296,13 +248,6 @@ module Adhearsion
       end
     end
 
-    describe '#accept' do
-      it "should delegate to the call" do
-        flexmock(call).should_receive(:accept).once.with(:foo)
-        subject.accept :foo
-      end
-    end
-
     describe '#answer' do
       it "should delegate to the call" do
         flexmock(call).should_receive(:answer).once.with(:foo)
@@ -319,7 +264,7 @@ module Adhearsion
 
     describe '#hangup' do
       it "should delegate to the call" do
-        flexmock(call).should_receive(:hangup!).once.with(:foo)
+        flexmock(call).should_receive(:hangup).once.with(:foo)
         subject.hangup :foo
       end
     end
@@ -378,13 +323,11 @@ describe ExampleCallController do
 
   before do
     flexmock subject, :execute_component_and_await_completion => nil
-    flexmock call, :write_and_await_response => nil
-    Adhearsion.config.platform.automatically_accept_incoming_calls = true
+    flexmock call.wrapped_object, :write_and_await_response => nil
   end
 
-  it "should execute the before_call callbacks before accepting the call" do
+  it "should execute the before_call callbacks before processing the call" do
     subject.should_receive(:setup_models).twice.ordered
-    subject.should_receive(:accept).once.ordered
     subject.should_receive(:join_to_conference).once.ordered
     subject.execute!
   end