adhearsion 2.6.4 → 3.0.0.beta1

data/lib/adhearsion/call_controller/output/abstract_player.rb

@@ -26,13 +26,13 @@ module Adhearsion
         def new_output(options)
           defaults = {}
 
-          default_voice = Adhearsion.config.platform.media.default_voice || Adhearsion.config.punchblock[:default_voice]
+          default_voice = Adhearsion.config.core.media.default_voice
           defaults[:voice] = default_voice if default_voice
 
-          renderer = Adhearsion.config.platform.media.default_renderer || Adhearsion.config.punchblock[:media_engine]
+          renderer = Adhearsion.config.core.media.default_renderer
           defaults[:renderer] = renderer if renderer
 
-          Punchblock::Component::Output.new defaults.merge(options)
+          Adhearsion::Rayo::Component::Output.new defaults.merge(options)
         end
       end
     end

data/lib/adhearsion/call_controller/output/async_player.rb

@@ -12,13 +12,13 @@ module Adhearsion
         def output(content, options = {})
           options.merge! :ssml => content
           component = new_output options
-          component.register_event_handler Punchblock::Event::Complete do |event|
-            controller.logger.error event if event.reason.is_a?(Punchblock::Event::Complete::Error)
+          component.register_event_handler Adhearsion::Event::Complete do |event|
+            controller.logger.error event if event.reason.is_a?(Adhearsion::Event::Complete::Error)
             throw :pass
           end
           controller.write_and_await_response component
           component
-        rescue Punchblock::ProtocolError => e
+        rescue Adhearsion::ProtocolError => e
           raise PlaybackError, "Async output failed due to #{e.inspect}"
         end
       end

data/lib/adhearsion/call_controller/output/player.rb

@@ -19,7 +19,7 @@ module Adhearsion
           end
         rescue Call::Hangup
           raise
-        rescue Adhearsion::Error, Punchblock::ProtocolError => e
+        rescue Adhearsion::Error, Adhearsion::ProtocolError => e
           raise PlaybackError, "Output failed due to #{e.inspect}"
         end
       end

data/lib/adhearsion/call_controller/record.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'ruby_speech'
+
 module Adhearsion
   class CallController
     module Record
@@ -33,7 +35,7 @@ module Adhearsion
 
           interruptible = options.delete :interruptible
           @stopper_component  = interruptible ? setup_stopper(interruptible) : nil
-          @record_component   = Punchblock::Component::Record.new options
+          @record_component   = Adhearsion::Rayo::Component::Record.new options
         end
 
         #
@@ -51,26 +53,39 @@ module Adhearsion
         #
         # Set a callback to be executed when recording completes
         #
-        # @yield [Punchblock::Event::Complete] the complete Event for the recording
+        # @yield [Adhearsion::Event::Complete] the complete Event for the recording
         #
         def handle_record_completion(&block)
-          @record_component.register_event_handler Punchblock::Event::Complete, &block
+          @record_component.register_event_handler Adhearsion::Event::Complete, &block
         end
 
         private
 
         def setup_stopper(interrupt_digits)
           interrupt_digits = interrupt_digits == true ? '0123456789#*' : interrupt_digits.to_s
-          @stopper_component = Punchblock::Component::Input.new :mode => :dtmf,
+          @stopper_component = Adhearsion::Rayo::Component::Input.new :mode => :dtmf,
             :grammar => {
-              :value => @controller.grammar_accept(interrupt_digits)
+              :value => grammar_accept(interrupt_digits)
             }
-          @stopper_component.register_event_handler Punchblock::Event::Complete do |event|
+          @stopper_component.register_event_handler Adhearsion::Event::Complete do |event|
             @record_component.stop! unless @record_component.complete?
           end
           @stopper_component
         end
 
+        def grammar_accept(digits = '0123456789#*')
+          allowed_digits = '0123456789#*'
+          gram_digits = digits.chars.select { |x| allowed_digits.include? x }
+
+          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
+            rule id: 'inputdigits', scope: 'public' do
+              one_of do
+                gram_digits.each { |d| item { d.to_s } }
+              end
+            end
+          end
+        end
+
         def execute_stopper
           @controller.write_and_await_response @stopper_component if @stopper_component
         end
@@ -118,9 +133,9 @@ module Adhearsion
       # @option options [Boolean, String, Optional] :interruptible Allows the recording to be terminated by any single DTMF key, default is false
       #
       # @yield [event] Handle the recording completion event asyncronously.
-      # @yieldparam [Punchblock::Event::Complete] event the complete event for the recording
+      # @yieldparam [Adhearsion::Event::Complete] event the complete event for the recording
       #
-      # @return Punchblock::Component::Record
+      # @return Adhearsion::Rayo::Component::Record
       #
       def record(options = {})
         recorder = Recorder.new self, options

data/lib/adhearsion/calls.rb

@@ -94,7 +94,7 @@ module Adhearsion
           return unless reason
           Adhearsion::Events.trigger :exception, reason
           logger.error "Call #{call_id} terminated abnormally due to #{reason}. Forcing hangup."
-          PunchblockPlugin.client.execute_command Punchblock::Command::Hangup.new, :async => true, :call_id => call_id
+          Adhearsion.client.execute_command Adhearsion::Rayo::Command::Hangup.new, :async => true, :call_id => call_id
         end
       end
     end

data/lib/adhearsion/cli_commands/ahn_command.rb

@@ -40,70 +40,13 @@ module Adhearsion
       desc "start </path/to/directory>", "Start the Adhearsion server in the foreground with a console"
       method_option :noconsole, type: :boolean, aliases: %w{--no-console}
       def start(path = nil)
-        start_app path, options[:noconsole] ? :simple : :console
-      end
-
-      desc "daemon </path/to/directory>", "Start the Adhearsion server in the background"
-      method_option :pidfile, :type => :string, :aliases => %w(--pid-file)
-      def daemon(path = nil)
-        start_app path, :daemon, options[:pidfile]
-      end
-
-      desc "stop </path/to/directory>", "Stop a running Adhearsion server"
-      method_option :pidfile, :type => :string, :aliases => %w(--pid-file)
-      def stop(path = nil)
-        path = execute_from_app_dir! path
-
-        pid_file = if options[:pidfile]
-          File.exists?(File.expand_path(options[:pidfile])) ?
-            options[:pidfile] :
-            File.join(path, options[:pidfile])
-        else
-          path = Dir.pwd
-          File.join path, Adhearsion::Initializer::DEFAULT_PID_FILE_NAME
-        end
-        pid_file = File.expand_path pid_file
-
-        begin
-          pid = File.read(pid_file).to_i
-        rescue
-          raise PIDReadError, pid_file
-        end
-
-        raise PIDReadError, pid_file if pid.nil?
-
-        say "Stopping Adhearsion server at #{path} with pid #{pid}"
-        waiting_timeout = Time.now + 15
-        begin
-          ::Process.kill "TERM", pid
-          sleep 0.25 while process_exists?(pid) && Time.now < waiting_timeout
-          ::Process.kill "KILL", pid
-        rescue Errno::ESRCH
-        end
-
-        File.delete pid_file if File.exists? pid_file
-      end
-
-      desc "restart </path/to/directory>", "Restart the Adhearsion server"
-      method_option :pidfile, :type => :string, :aliases => %w(--pid-file)
-      def restart(path = nil)
         path = execute_from_app_dir! path
-        begin
-          invoke :stop
-        rescue PIDReadError => e
-          puts e.message
-        end
-        invoke :daemon
+        say "Starting Adhearsion server at #{Dir.pwd}"
+        Adhearsion::Initializer.start :console => !options[:noconsole]
       end
 
       protected
 
-      def start_app(path, mode, pid_file = nil)
-        path = execute_from_app_dir! path
-        say "Starting Adhearsion server at #{Dir.pwd}"
-        Adhearsion::Initializer.start :mode => mode, :pid_file => pid_file
-      end
-
       def execute_from_app_dir!(path)
         if in_app? and running_script_ahn?
           return Dir.pwd
@@ -130,12 +73,6 @@ module Adhearsion
         ScriptAhnLoader.in_ahn_application? or ScriptAhnLoader.in_ahn_application_subdirectory?
       end
 
-      def process_exists?(pid = nil)
-        # FIXME: Raise some error here
-        return false if pid.nil?
-        `ps -p #{pid} | sed -e '1d'`.strip.empty?
-      end
-
       def method_missing(action, *args)
         help
         raise UnknownCommand, [action, *args] * " "

data/lib/adhearsion/cli_commands/thor_errors.rb

@@ -26,11 +26,5 @@ module Adhearsion
         super "Directory #{path} does not belong to an Adhearsion project!"
       end
     end
-
-    class PIDReadError < Thor::Error
-      def initialize(path)
-        super "Could not read pid from the file #{path}"
-      end
-    end
   end
 end

data/lib/adhearsion/configuration.rb

@@ -7,22 +7,35 @@ module Adhearsion
 
     ConfigurationError = Class.new Adhearsion::Error # Error raised while trying to configure a non existent plugin
 
+    def self.validate_number(value)
+      return 1.0/0.0 if ["Infinity", 1.0/0.0].include? value
+      value.to_i
+    end
+
+    def self.default_port_for_platform(platform)
+      case platform
+        when :asterisk then 5038
+        when :xmpp then 5222
+        else nil
+      end
+    end
+
     ##
     # Initialize the configuration object
     #
-    # * &block platform configuration block
+    # * &block core configuration block
     # Adhearsion::Configuration.new do
     #   foo "bar", :desc => "My description"
     # end
     #
     # @return [Adhearsion::Configuration]
-    def initialize(&block)
-      initialize_environments
+    def initialize(env = :development, &block)
+      initialize_environments env
 
       Loquacious.env_config = true
       Loquacious.env_prefix = "AHN"
 
-      Loquacious::Configuration.for :platform do
+      Loquacious::Configuration.for :core do
         root nil, :desc => "Adhearsion application root folder"
 
         lib "lib", :desc => <<-__
@@ -31,30 +44,41 @@ module Adhearsion
           want these files to be loaded. This folder is relative to the application root folder.
         __
 
-        environment :development, :transform => Proc.new { |v| v.to_sym }, :desc => <<-__
-          Active environment. Supported values: development, production, staging, test
-        __
-
         process_name "ahn", :desc => <<-__
           Adhearsion process name, useful to make it easier to find in the process list
           Pro tip: set this to your application's name and you can do "killall myapp"
           Does not work under JRuby.
         __
 
+        event_threads 5, transform: Proc.new { |v| Adhearsion::Configuration.validate_number v }, desc: <<-__
+          The number of threads to include in the event worker pool."
+        __
+
         desc "Log configuration"
         logging {
           level :info, :transform => Proc.new { |v| v.to_sym }, :desc => <<-__
             Supported levels (in increasing severity) -- :trace < :debug < :info < :warn < :error < :fatal
           __
-          outputters ["log/adhearsion.log"], :transform => Proc.new { |val| Array(val) }, :desc => <<-__
-            An array of log outputters to use. The default is to log to stdout and log/adhearsion.log.
-            Each item must be either a string to use as a filename, or a valid Logging appender (see http://github.com/TwP/logging)
-          __
           formatter nil, :desc => <<-__
-            A log formatter to apply to all active outputters. If nil, the Adhearsion default formatter will be used.
+            A log formatter to apply to the stream. If nil, the Adhearsion default formatter will be used.
           __
         }
 
+        type                :xmpp            , :transform => Proc.new { |v| v.to_sym }, :desc => <<-__
+          Platform used 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 to connect to (where rayo/asterisk is located)"
+        port                Proc.new { Adhearsion::Configuration.default_port_for_platform type }, :transform => Proc.new { |v| Adhearsion::Configuration.validate_number v }, :desc => "Port used to connect"
+        certs_directory     nil              , :desc => "Directory containing certificates for securing the connection."
+        root_domain         nil              , :desc => "The root domain at which to address the server"
+        connection_timeout  60               , :transform => Proc.new { |v| Adhearsion::Configuration.validate_number v }, :desc => "The amount of time to wait for a connection"
+        reconnect_attempts  1.0/0.0          , :transform => Proc.new { |v| Adhearsion::Configuration.validate_number v }, :desc => "The number of times to (re)attempt connection to the server"
+        reconnect_timer     5                , :transform => Proc.new { |v| Adhearsion::Configuration.validate_number v }, :desc => "Delay between connection attempts"
+
         after_hangup_lifetime 1, :transform => Proc.new { |v| v.to_i }, :desc => <<-__
           Lifetime of a call after it has hung up. Should be set to the minimum functional value for your application. Call actors (threads) living after hangup consume more system resources and reduce the concurrent call capacity of your application.
         __
@@ -63,19 +87,57 @@ module Adhearsion
         media {
           default_voice nil, desc: 'The default voice used for all output. Set nil to use platform default.'
           default_renderer nil, desc: 'The default renderer used for all output. Set nil to use platform default.'
+
+          min_confidence 0.5, desc: 'The default minimum confidence level used for all recognizer invocations.', transform: Proc.new { |v| v.to_f }
+          timeout 5, desc: 'The default timeout (in seconds) used for all recognizer invocations.', transform: Proc.new { |v| v.to_i }
+          inter_digit_timeout 2, desc: 'The timeout used between DTMF digits and to terminate partial invocations', transform: Proc.new { |v| v.to_i }
+          recognizer nil, desc: 'The default recognizer used for all input. Set nil to use platform default.'
+          input_language 'en-US', desc: 'The default language set on generated grammars. Set nil to use platform default.'
         }
+
+        desc "Internationalisation"
+        i18n {
+          locale_path ["config/locales"], transform: Proc.new { |v| v.split ':' }, desc: <<-__
+            List of directories from which to load locale data, colon-delimited
+          __
+          audio_path "app/assets/audio", desc: <<-__
+            Base path from which audio files can be found. May be a filesystem path or some other URL (like HTTP)
+          __
+          fallback true, desc: <<-__
+            Whether to include text for translations that provide both text & audio. True or false.
+          __
+        }
+
+        desc "HTTP server"
+        http do
+          enable true, desc: "Enable or disable the HTTP server"
+          host "0.0.0.0", desc: "IP to bind the HTTP listener to"
+          port "8080", desc: "Port to bind the HTTP listener to"
+          rackup 'config.ru', desc: 'Path to Rack configuration file (relative to Adhearsion application root)'
+        end
       end
 
-      Loquacious::Configuration.for :platform, &block if block_given?
+      Loquacious::Configuration.for :core, &block if block_given?
 
       self
     end
 
-    def initialize_environments
+    def initialize_environments(active_environment)
       # Create a method per each valid environment that, when invoked, may execute
       # the block received if the environment is active
-      valid_environments.each do |enviro|
-        add_environment enviro
+      valid_environments.each do |env|
+        define_singleton_method env.to_sym do |*args, &block|
+          logger.trace "Ignoring configuration for inactive environment #{env}"
+        end
+      end
+
+      define_singleton_method active_environment do |*args, &block|
+        self.instance_eval(&block) unless block.nil?
+        self
+      end
+
+      if valid_environment?(active_environment)
+        logger.warn "You tried to initialize with an invalid environment name #{active_environment}; environment-specific config may not load successfully. Valid values are #{valid_environments}."
       end
     end
 
@@ -87,20 +149,10 @@ module Adhearsion
       @valid_environments ||= [:production, :development, :staging, :test]
     end
 
-    def add_environment(env)
-      return if self.class.method_defined? env.to_sym
-      self.class.send(:define_method, env.to_sym) do |*args, &block|
-        unless block.nil? || env != self.platform.environment.to_sym
-          self.instance_eval(&block)
-        end
-        self
-      end
-    end
-
     ##
     # Direct access to a specific configuration object
     #
-    # Adhearsion.config[:platform] => returns the configuration object associated to the Adhearsion platform
+    # Adhearsion.config[:core] => returns the configuration object associated with Adhearsion core
     #
     # @return [Loquacious::Configuration] configuration object or nil if the plugin does not exist
     def [](value)
@@ -119,33 +171,33 @@ module Adhearsion
 
     # root accessor
     def root
-      platform.root
+      core.root
     end
 
     ##
-    # Handle the Adhearsion platform configuration
+    # Handle the Adhearsion core configuration
     #
     # It accepts a block that will be executed in the Adhearsion config var environment
     # to update the desired values
     #
-    # Adhearsion.config.platform do
+    # Adhearsion.config.core do
     #   foo "bar", :desc => "My new description"
     # end
     #
-    # values = Adhearsion.config.platform
+    # values = Adhearsion.config.core
     # values.foo => "bar"
     #
     # @return [Loquacious::Configuration] configuration object or nil if the plugin does not exist
-    def platform(&block)
-      Loquacious::Configuration.for :platform, &block
+    def core(&block)
+      Loquacious::Configuration.for :core, &block
     end
 
     ##
-    # Fetchs the configuration info for the Adhearsion platform or a specific plugin
+    # Fetchs the configuration info for the Adhearsion core or a specific plugin
     # @param name [Symbol]
-    #     - :all      => Adhearsion platform and all the loaded plugins
-    #     - nil       => Adhearsion platform configuration
-    #     - :platform => Adhearsion platform configuration
+    #     - :all      => Adhearsion core and all the loaded plugins
+    #     - nil       => Adhearsion core configuration
+    #     - :core => Adhearsion core configuration
     #     - :<plugin-config-name> => Adhearsion plugin configuration
     #
     # @param args [Hash]
@@ -155,7 +207,7 @@ module Adhearsion
     def description(name, args = {:show_values => true})
       desc = StringIO.new
 
-      name.nil? and name = :platform
+      name.nil? and name = :core
       if name.eql? :all
         value = ""
         Loquacious::Configuration.instance_variable_get("@table").keys.map do |config|