adhearsion 2.0.0.alpha1 → 2.0.0.alpha2

data/lib/adhearsion/linux_proc_name.rb

@@ -0,0 +1,41 @@
+module Adhearsion
+
+  # https://gist.github.com/1350729
+  #
+  # Eric Lindvall <eric@5stops.com>
+  # 
+  # Update the process name for the process you're running in.
+  #
+  # $0    => updates proc name for ps command
+  # prctl => updates proc name for lsof, top, killall commands (...)
+  #
+  # prctl does not work on OS X
+  #
+  module LinuxProcName
+    # Set process name
+    PR_SET_NAME = 15
+
+    class << self
+      attr_accessor :error
+
+      def set_proc_name(name)
+        $0 = name # process name in ps command
+        if error
+          logger.warn error
+          return false
+        end
+        return false unless LibC.respond_to?(:prctl)
+
+        # The name can be up to 16 bytes long, and should be null-terminated if
+        # it contains fewer bytes.
+        name = name.slice(0, 16)
+        ptr = FFI::MemoryPointer.from_string(name)
+        LibC.prctl(PR_SET_NAME, ptr.address, 0, 0) # process name in top, lsof, etc
+      ensure
+        ptr.free if ptr
+      end
+
+    end
+
+  end
+end

data/lib/adhearsion/outbound_call.rb

@@ -2,6 +2,8 @@ module Adhearsion
   class OutboundCall < Call
     attr_reader :dial_command
 
+    delegate :to, :from, :to => :dial_command, :allow_nil => true
+
     class << self
       def originate(to, opts = {})
         new.tap do |call|
@@ -15,10 +17,6 @@ module Adhearsion
       dial_command.call_id if dial_command
     end
 
-    def variables
-      {}
-    end
-
     def client
       PunchblockPlugin::Initializer.client
     end
@@ -34,7 +32,14 @@ module Adhearsion
 
     def dial(to, options = {})
       options.merge! :to => to
-      write_and_await_response(Punchblock::Command::Dial.new(options)).tap do |dial_command|
+      if options[:timeout]
+        wait_timeout = options[:timeout]
+        options[:timeout] = options[:timeout] * 1000
+      else
+        wait_timeout = 60
+      end
+
+      write_and_await_response(Punchblock::Command::Dial.new(options), wait_timeout).tap do |dial_command|
         @dial_command = dial_command
         Adhearsion.active_calls << self
       end

data/lib/adhearsion/plugin.rb

@@ -12,7 +12,6 @@ module Adhearsion
   # * create initializers
   # * add rake tasks to Adhearsion
   # * add/modify configuration files
-  # * add dialplan, rpc, console and events methods
   #
   # == How to create your Adhearsion Plugin
   #
@@ -25,19 +24,6 @@ module Adhearsion
   #     end
   #   end
   #
-  # == How to add a new dialplan method
-  #
-  #   module MyPlugin
-  #     class Plugin < Adhearsion::Plugin
-  #       dialplan :my_new_dialplan_method do
-  #         logger.info "this dialplan method is really awesome #{call.inspect}. It says 'hello world'"
-  #         speak "hello world"
-  #       end
-  #     end
-  #   end
-  #
-  # Create a new rpc, console or events methods is as ease just following this approach
-  #
   # == Execute a specific code while initializing Adhearison
   #
   #   module MyPlugin
@@ -49,7 +35,7 @@ module Adhearsion
   #   end
   #
   # As Rails::Railtie does, you can define the exact point when you want to load your plugin
-  # during the initilization process
+  # during the initialization process.
   #
   #   module MyPlugin
   #     class Plugin < Adhearsion::Plugin
@@ -65,81 +51,11 @@ module Adhearsion
 
     METHODS_OPTIONS = {:load => true, :scope => false}
 
-    SCOPE_NAMES = [:dialplan, :rpc, :events, :console]
-
     autoload :Configuration
     autoload :Collection
     autoload :Initializer
-    autoload :MethodsContainer
 
     class << self
-      # Metaprogramming to create the class methods that can be used in user defined plugins to
-      # create specific scope methods
-      SCOPE_NAMES.each do |name|
-
-        # This block will create the relevant methods to handle how to add new methods
-        # to Adhearsion scopes via an Adhearsion Plugin.
-        # The scope method should have a name and a lambda block that will be executed in the
-        # call ExecutionEnvironment context.
-        #
-        # class AhnPluginDemo < Adhearsion::Plugin
-        #   dialplan :adh_plugin_demo do
-        #     speak "hello world"
-        #   end
-        # end
-        #
-        # You could also defined a dialplan or other scope method as above, but you cannot access
-        # the ExecutionEnvironment methods from your specific method due to ruby restrictions
-        # when defining methods (the above lambda version should fit any requirement)
-        #
-        # class AhnPluginDemo < Adhearsion::Plugin
-        #   dialplan :adh_plugin_demo
-        #
-        #   def self.adh_plugin_demo
-        #     logger.debug "I can do fun stuff here, but I cannot access methods as speak"
-        #     logger.debug "I can make an HTTP request"
-        #     logger.debug "I can log to a specific logging system"
-        #     logger.debug "I can access database..."
-        #     logger.debug "but I cannot access call control methods"
-        #   end
-        #
-        # end
-        #
-        define_method name do |method_name, &block|
-          case method_name
-          when Array
-            method_name.each do |method|
-              send name, method
-            end
-            return
-          when Hash
-            args = method_name
-            method_name = method_name[:name]
-          end
-
-          options = args.nil? ? METHODS_OPTIONS : METHODS_OPTIONS.merge(args)
-          options[:load] or return
-          logger.debug "Adding method #{method_name} to scope #{name}"
-          @@methods_container[name].store({:class => self, :method => method_name}, block.nil? ? nil : block)
-        end
-
-        # This method is a helper to retrieve the specific module that holds the user
-        # defined scope methods
-        define_method "#{name.to_s}_module" do
-          Adhearsion::Plugin.methods_scope[name]
-        end
-
-        # Helper to add scope methods to any class/instance
-        define_method "add_#{name.to_s}_methods" do |object|
-          if object.kind_of?(Module)
-            object.send :include, Adhearsion::Plugin.methods_scope[name]
-          else
-            object.extend Adhearsion::Plugin.methods_scope[name]
-          end
-          object
-        end
-      end
-
       ##
       # Class method that allows any subclass (any Adhearsion plugin) to register rake tasks.
       #
@@ -189,13 +105,6 @@ module Adhearsion
         end
       end
 
-      def methods_scope
-        @methods_scope ||= Hash.new { |hash, key| hash[key] = Module.new }
-      end
-
-      # Keep methods to be added
-      @@methods_container = Hash.new { |hash, key| hash[key] = MethodsContainer.new }
-
       def subclasses
         @subclasses ||= []
       end
@@ -217,7 +126,7 @@ module Adhearsion
         @plugin_name = name
       end
 
-      def config name = nil
+      def config(name = nil, &block)
         if block_given?
           if name.nil?
             name = self.plugin_name
@@ -225,51 +134,16 @@ module Adhearsion
             self.plugin_name = name
           end
           ::Loquacious::Configuration.defaults_for name, &Proc.new
+          ::Loquacious.configuration_for plugin_name, &block
+        else
+          ::Loquacious.configuration_for plugin_name
         end
-
-        ::Loquacious.configuration_for plugin_name
       end
 
       def show_description
         ::Loquacious::Configuration.help_for plugin_name
       end
 
-      def load_plugins
-        load_methods
-        init_plugins
-      end
-
-      # Load plugins scope methods (scope = dialplan, console, etc)
-      def load_methods
-        unless @@methods_container.empty?
-
-          @@methods_container.each_pair do |scope, methods|
-
-            logger.debug "Loading #{methods.length} #{scope} methods"
-
-            methods.each_pair do |class_method, block|
-              klass, method = class_method[:class], class_method[:method]
-              if block.nil?
-                if klass.respond_to?(method)
-                  block = klass.method(method).to_proc
-                elsif klass.instance_methods.include?(method)
-                  block = klass.instance_method(method).bind(klass.new)
-                else
-                  logger.warn "Unable to load #{scope} method #{method} from plugin class #{klass}"
-                end
-              end
-
-              logger.debug "Defining method #{method}"
-              block.nil? and raise NoMethodError.new "Invalid #{scope} method: <#{method}>"
-              self.send("#{scope}_module").send(:define_method, method, &block)
-            end
-          end
-
-          # We need to extend Console class with the plugin defined methods
-          Adhearsion::Console.extend(self.console_module) unless self.console_module.instance_methods.empty?
-        end
-      end
-
       # Recursively initialization of all the loaded plugins
       def init_plugins *args
         initializers.tsort.each do |initializer|
@@ -277,21 +151,44 @@ module Adhearsion
         end
       end
 
+      def run_plugins *args
+        runners.tsort.each do |runner|
+          runner.run *args
+        end
+      end
+
       def initializers
         @initializers ||= Collection.new
       end
 
+      def runners
+        @runners ||= Collection.new
+      end
+
       # Class method that will be used by subclasses to initialize the plugin
       # @param name Symbol plugin initializer name
       # @param opts Hash
       #     * :before specify the plugin to be loaded before another plugin
       #     * :after  specify the plugin to be loaded after another plugin
-      def init(name, opts = {})
+      def init(name = nil, opts = {})
+        name = plugin_name unless name
         block_given? or raise ArgumentError, "A block must be passed while defining the Plugin initialization process"
         opts[:after] ||= initializers.last.name unless initializers.empty? || initializers.find { |i| i.name == opts[:before] }
         Adhearsion::Plugin.initializers << Initializer.new(name, nil, opts, &Proc.new)
       end
 
+      # Class method that will be used by subclasses to run the plugin
+      # @param name Symbol plugin initializer name
+      # @param opts Hash
+      #     * :before specify the plugin to be loaded before another plugin
+      #     * :after  specify the plugin to be loaded after another plugin
+      def run(name = nil, opts = {})
+        name = plugin_name unless name
+        block_given? or raise ArgumentError, "A block must be passed while defining the Plugin run process"
+        opts[:after] ||= runners.last.name unless runners.empty? || runners.find { |i| i.name == opts[:before] }
+        Adhearsion::Plugin.runners << Initializer.new(name, nil, opts, &Proc.new)
+      end
+
       def count
         subclasses.length
       end

data/lib/adhearsion/process.rb

@@ -57,7 +57,7 @@ module Adhearsion
 
     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."
+      logger.info "Transitioning from #{from} to #{to} with #{Adhearsion.active_calls.size} active calls due to #{event} event."
     end
 
     def request_stop
@@ -69,10 +69,13 @@ module Adhearsion
       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
+
+      Console.stop
     end
 
     def stop_when_zero_calls

data/lib/adhearsion/punchblock_plugin.rb

@@ -5,7 +5,7 @@ module Adhearsion
     autoload :Initializer
 
     config :punchblock do
-      platform         :xmpp            , :desc => <<-__
+      platform            :xmpp            , :transform => Proc.new { |v| v.to_sym }, :desc => <<-__
         Platform punchblock shall use to connect to the Telephony provider. Currently supported values:
         - :xmpp
         - :asterisk
@@ -13,17 +13,26 @@ module Adhearsion
       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)"
+      port                nil              , :transform => Proc.new { |v| PunchblockPlugin.validate_number v }, :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"
+      connection_timeout  60               , :transform => Proc.new { |v| PunchblockPlugin.validate_number v }, :desc => "The amount of time to wait for a connection"
+      reconnect_attempts  1.0/0.0          , :transform => Proc.new { |v| PunchblockPlugin.validate_number v }, :desc => "The number of times to (re)attempt connection to the server"
+      reconnect_timer     5                , :transform => Proc.new { |v| PunchblockPlugin.validate_number v }, :desc => "Delay between connection attempts"
     end
 
     init :punchblock do
       Initializer.start
     end
+
+    class << self
+      delegate :client, :to => Initializer
+
+      def validate_number(value)
+        return 1.0/0.0 if ["Infinity", 1.0/0.0].include? value
+        value.to_i
+      end
+    end
   end
 end

data/lib/adhearsion/punchblock_plugin/initializer.rb

@@ -36,7 +36,7 @@ module Adhearsion
           # 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!
+            connection.not_ready! if connection.connected?
           end
 
           # Make sure we stop everything when we shutdown
@@ -70,12 +70,19 @@ module Adhearsion
         end
 
         def connect
+          return unless Process.state_name == :booting
           m = Mutex.new
           blocker = ConditionVariable.new
+
           Events.punchblock ::Punchblock::Connection::Connected do
             m.synchronize { blocker.broadcast }
           end
 
+          Events.shutdown do
+            logger.info "Shutting down while connecting. Breaking the connection block."
+            m.synchronize { blocker.broadcast }
+          end
+
           Adhearsion::Process.important_threads << Thread.new do
             catching_standard_errors { connect_to_server }
           end

data/lib/adhearsion/router/route.rb

@@ -22,9 +22,7 @@ module Adhearsion
       def dispatcher
         @dispatcher ||= lambda do |call|
           controller = if target.respond_to?(:call)
-            DialplanController.new(call).tap do |controller|
-              controller.dialplan = target
-            end
+            CallController.new call, &target
           else
             target.new call
           end

data/lib/adhearsion/tasks.rb

@@ -1,22 +1,16 @@
 require 'adhearsion'
 
-%w<
-  configuration
-  testing
-  plugins
->.each do |file|
-  require "adhearsion/tasks/#{file}"
+Dir[File.join(File.dirname(__FILE__), "tasks/*.rb")].each do |file|
+  require 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"
-  task :about do
-    puts "Adhearsion version: #{Adhearsion::VERSION}"
-  end
+desc "Dump useful information about this application's Adhearsion environment"
+task :about do
+  puts "Adhearsion version: #{Adhearsion::VERSION}"
 end
 
-task :default => "adhearsion:about"
+task :default => :about