bougyman-freeswitcher 0.1.4 → 0.3.0

data/lib/fsr/app.rb

@@ -25,9 +25,7 @@ module FSR
 
     def self.register(application, obj)
       APPLICATIONS[application.to_sym] = obj
-
-      code = REGISTER_CODE % [application, application]
-      App.module_eval(code)
+      App.module_eval(REGISTER_CODE % [application, application])
     end
      
     def self.list

data/lib/fsr/app/answer.rb

@@ -3,6 +3,8 @@ require "fsr/app"
 module FSR
   module App
     class Answer < Application
+      # Answer a call
+     
       def initialize
       end
 

data/lib/fsr/app/play_and_get_digits.rb

@@ -3,6 +3,8 @@ module FSR
   #http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_play_and_get_digits
   module App
     class PlayAndGetDigits < Application
+      attr_reader :chan_var
+
       def initialize(sound_file, invalid_file, min = 0, max = 10, tries = 3, timeout = 7000, terminators = ["#"], chan_var = "fsr_read_dtmf", regexp = "\d")
         @sound_file = sound_file
         @invalid_file = invalid_file
@@ -22,7 +24,15 @@ module FSR
       def sendmsg
         "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % ["play_and_get_digits", arguments.join(" ")]
       end
-
+      SENDMSG_METHOD = %q|
+        def play_and_get_digits(*args, &block)
+          me = super(*args)
+          @read_var = "variable_#{me.chan_var}"
+          sendmsg me
+          @queue.unshift Proc.new { update_session } 
+          @queue.unshift block if block_given?
+        end
+      |
     end
 
     register(:play_and_get_digits, PlayAndGetDigits)

data/lib/fsr/app/read.rb

@@ -3,6 +3,7 @@ module FSR
     # http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_read
   module App
     class Read < Application
+      attr_reader :chan_var
       def initialize(sound_file, min = 0, max = 10, chan_var = "fsr_read_dtmf", timeout = 10000, terminators = ["#"])
         @sound_file, @min, @max, @chan_var, @timeout, @terminators = sound_file, min, max, chan_var, timeout, terminators
       end
@@ -14,9 +15,18 @@ module FSR
       def sendmsg
         "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join(" ")]
       end
-
+      SENDMSG_METHOD = %q|
+        def read(*args, &block)
+          me = super(*args)
+          @read_var = "variable_#{me.chan_var}"
+          sendmsg me
+          @queue.unshift Proc.new { update_session } 
+          @queue.unshift block if block_given?
+        end
+      |
     end
-
     register(:read, Read)
+
+
   end
 end

data/lib/fsr/app/uuid_getvar.rb

@@ -1,11 +1,13 @@
 require "fsr/app"
 module FSR
-  #http://wiki.freeswitch.org/wiki/Mod_commands#uuid_getvar
+  #http://wiki.freeswitch.org/wiki/Mod_commands#uuid_setvar
   module App
     class UuidGetVar < Application
+      attr_reader :var, :uuid
+
       def initialize(uuid, var)
         @uuid = uuid # Unique channel ID
-        @var = var # Channel variable you wish to 'get'
+        @var = var # Channel variable you wish to 'set'
       end
 
       def arguments
@@ -16,6 +18,15 @@ module FSR
         "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join(" ")]
       end
 
+      SENDMSG_METHOD = %q|
+        def uuid_getvar(*args, &block)
+          me = super(*args)
+          @uuid_var = me.var
+          api_call = "api uuid_getvar #{me.uuid} #{me.var}\n\n"
+          send_data(api_call) 
+          @queue.unshift block if block_given?
+        end
+      |
     end
 
     register(:uuid_getvar, UuidGetVar)

data/lib/fsr/app/uuid_setvar.rb

@@ -3,10 +3,12 @@ module FSR
   #http://wiki.freeswitch.org/wiki/Mod_commands#uuid_setvar
   module App
     class UuidSetVar < Application
+      attr_reader :var, :uuid, :assignment
+
       def initialize(uuid, var, assignment)
         @uuid = uuid # Unique channel ID
         @var = var # Channel variable you wish to 'set'
-        @assignment
+        @assignment = assignment
       end
 
       def arguments
@@ -17,6 +19,14 @@ module FSR
         "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join(" ")]
       end
 
+      SENDMSG_METHOD = %q|
+        def uuid_setvar(*args, &block)
+          me = super(*args)
+          api_call = "api uuid_setvar #{me.uuid} #{me.var} #{me.assignment}\n\n"
+          send_data(api_call) 
+          @queue.unshift block if block_given?
+        end
+      |
     end
 
     register(:uuid_setvar, UuidSetVar)

data/lib/fsr/cmd.rb

@@ -1,10 +1,28 @@
 module FSR
   module Cmd
     class Command
+      DEFAULT_OPTIONS = {
+        :origination_caller_id_name => FSR::DEFAULT_CALLER_ID_NAME,
+        :origination_caller_id_number => FSR::DEFAULT_CALLER_ID_NUMBER,
+        :originate_timeout => 30,
+        :ignore_early_media => true
+      }
+
+      protected
+      def default_options(args = {}, defaults = nil, &block)
+        opts = if defaults.nil?
+          DEFAULT_OPTIONS.merge(args)
+        else
+          raise(ArgumentError, "defaults argument must ba a hash") unless defaults.kind_of?(Hash)
+          defaults.merge(args)
+        end
+        yield opts if block_given?
+      end
+
     end
 
     COMMANDS = {}
-    LOAD_PATH = [File.join(FSR::ROOT, "fsr", "cmd")]
+    LOAD_PATH = [Pathname(FSR::ROOT).join( "fsr", "cmd")]
 
     def self.register(command, obj)
       COMMANDS[command.to_sym] = obj
@@ -28,8 +46,8 @@ module FSR
       end
       Log.debug "Trying load paths"
       # If we find a file named the same as the command passed in LOAD_PATH, load it
-      if found_command_path = LOAD_PATH.detect { |command_path| File.file?(File.join(command_path, "#{command}.rb")) }
-        command_file = Pathname.new(found_command_path).join(command)
+      if found_command_path = LOAD_PATH.detect { |command_path| command_path.join("#{command}.rb").file? }
+        command_file = found_command_path.join(command)
         Log.debug "Trying to load #{command_file}"
         if force_reload
           load command_file.to_s + ".rb"
@@ -44,7 +62,7 @@ module FSR
     # Load all of the commands we find in Cmd::LOAD_PATH
     def self.load_all(force_reload = false)
       LOAD_PATH.each do |load_path|
-        Dir[File.join(load_path, "*.rb")].each { |command_file| load_command(command_file, force_reload) }
+        Dir[load_path.join("*.rb")].each { |command_file| load_command(command_file, force_reload) }
       end
       list
     end

data/lib/fsr/cmd/originate.rb

@@ -6,19 +6,35 @@ module FSR
       attr_reader :fs_socket, :target_options
 
       def initialize(fs_socket = nil, args = {})
+        # Using an argument hash may not be the the best way to go here, but as long as we're doing
+        # so we'll type check it
+        raise(ArgumentError, "args (Passed: <<<#{args}>>>) must be a hash") unless args.kind_of?(Hash)
+
         # These are options that will precede the target address
-        @target_options = args[:target_options] || {:ignore_early_media => true}
-        raise "#{@target_options} must be a hash" unless @target_options.kind_of?(Hash)
+        if args[:target_options]
+          raise(ArgumentError, "args[:target_options] (Passed: <<<#{args[:target_options]}>>>) must be a hash") unless args[:target_options].kind_of?(Hash)
+        else
+          args[:target_options] = {}
+        end
+        @target_options = default_options(args[:target_options]) do |o|
+          o[:origination_caller_id_number] = args[:caller_id_number] if args[:caller_id_number]
+          o[:origination_caller_id_name] = args[:caller_id_name] if args[:caller_id_name]
+          if o[:timeout]
+            o[:originate_timeout] = o.delete(:timeout)
+          elsif args[:timeout]
+            o[:originate_timeout] = args[:timeout]
+          end
+          o
+        end
+        raise(ArgumentError, "Origination timeout (#{@target_options[:originate_timeout]}) must be a positive integer") unless @target_options[:originate_timeout].to_i > 0
         
         @fs_socket = fs_socket # This socket must support say and <<
         @target = args[:target] # The target address to call
+        raise(ArgumentError, "Cannot originate without a :target set") unless @target.to_s.size > 0
         # The origination endpoint (can be an extension (use a string) or application)
         @endpoint = args[:endpoint] || args[:application]
+        raise(ArgumentError, "Cannot originate without an :endpoint set") unless @endpoint.to_s.size > 0
 
-        @target_options[:origination_caller_id_number] ||= args[:caller_id_number] || FSR::DEFAULT_CALLER_ID_NUMBER
-        @target_options[:origination_caller_id_name] ||= args[:caller_id_name] || FSR::DEFAULT_CALLER_ID_NAME
-        @target_options[:originate_timeout] ||= args[:timeout] || @target_options[:timeout] || 30
-        @target_options[:ignore_early_media] ||= true
       end
 
       # Send the command to the event socket, using bgapi by default.
@@ -39,6 +55,7 @@ module FSR
           raise "Invalid endpoint"
         end
       end
+
     end
 
     register(:originate, Originate)

data/lib/fsr/command_socket.rb

@@ -16,7 +16,7 @@ module FSR
       end
     end
     
-    # Method to authenticate to FreeSWITCH
+    # login - Method to authenticate to FreeSWITCH
     def login
       #Clear buf from initial socket creation/opening
       response 

data/lib/fsr/listener/inbound.rb

@@ -13,11 +13,16 @@ module FSR
         @auth = args[:auth] || "ClueCon"
       end
 
+      # post_init is called upon each "new" socket connection
       def post_init
         say("auth #{@auth}")
         say('event plain ALL')
       end
 
+      # receive_request is the callback method when data is recieved from the socket
+      #
+      # param header headers from standard Header and Content protocol
+      # param content content from standard Header and Content protocol
       def receive_request(header, content)
         hash_header = headers_2_hash(header)
         hash_content = headers_2_hash(content)
@@ -29,28 +34,32 @@ module FSR
         on_event(event)
       end
 
+      # say encapsulates #send_data for the user
+      #
+      # param line Line of text to send to the socket
       def say(line)
         send_data("#{line}\r\n\r\n")
       end
-
+      
+      # on_event is the callback method when an event is triggered
+      #
+      # param event The triggered event object
+      # return event The triggered event object
       def on_event(event)
         event
       end
 
-      # Add or replace a block to execute when the specified event occurs
-      #
-      # <b>Parameters</b>
-      # - event             : What event to trigger the block on. May be
-      #                       :CHANNEL_CREATE, :CHANNEL_DESTROY etc
-      # - block             : Block to execute
+      # add_event_hook adds an Event to listen for.  When that Event is triggered, it will call the defined block
       #
-      # <b>Returns/<b>
-      # - nil
+      # @param event The event to trigger the block on.  Examples, :CHANNEL_CREATE, :CHANNEL_DESTROY, etc
+      # @param block The block to execute when the event is triggered
       def self.add_event_hook(event, &block)
         HOOKS[event] = block 
       end
 
-      # Delete the block that was to be executed for the specified event.
+      # del_event_hook removes an Event.
+      #
+      # @param event The event to remove.  Examples, :CHANNEL_CREATE, :CHANNEL_DESTROY, etc
       def self.del_event_hook(event)
         HOOKS.delete(event)  
       end

data/lib/fsr/listener/outbound.rb

@@ -20,7 +20,13 @@ module FSR
                                    "end"
                                   ].join("\n")
 
-      APPLICATIONS.each { |app, obj| module_eval(SENDMSG_METHOD_DEFINITION % app.to_s) }
+      APPLICATIONS.each do |app, obj| 
+        if obj.const_defined?("SENDMSG_METHOD")
+          module_eval(obj::SENDMSG_METHOD)
+        else
+          module_eval(SENDMSG_METHOD_DEFINITION % app.to_s)
+        end
+      end
 
       # session_initiated is called when a @session is first created.
       # Overwrite this in your worker class with the call/channel
@@ -66,6 +72,7 @@ module FSR
 
       protected
       def post_init
+        @read_var = nil
         @session = nil # holds the session object
         @queue = [] # Keep track of queue for state machine
         send_data("connect\n\n")
@@ -77,36 +84,86 @@ module FSR
       #  to be picked up by #session_initiated or #receive_reply.
       #  If your listener is listening for events, this will also renew your @session
       #  each time you receive a CHANNEL_DATA event.
+      #
       # @param header The header of the request, as passed by HeaderAndContentProtocol
       # @param content The content of the request, as passed by HeaderAndContentProtocol
       #
       # @return [HeaderAndContentResponse] An EventMachine HeaderAndContentResponse
       def receive_request(header, content)
         hash_header = headers_2_hash(header)
-        hash_content = headers_2_hash(content)
+        if content.to_s.match(/:/)
+          hash_content = headers_2_hash(content)
+        else
+          hash_content = content
+        end
         session_header_and_content = HeaderAndContentResponse.new({:headers => hash_header, :content => hash_content})
         # If we're a new session, call session initiate
-        if @session.nil?
-          @session = session_header_and_content
-          @step = 0
-          @state = [:uninitiated]
-          session_initiated 
-          @state << :initiated
+        if session.nil?
+          establish_new_session(session_header_and_content)
+        elsif @uuid_var  and session_header_and_content.headers[:content_type] == "api/response"
+          FSR::Log.info("@uuid_var is set => #{session_header_and_content.inspect} : #{content}")
+          r, @uuid_var = session_header_and_content.content.strip, nil
+          @queue.pop.call(r) if @queue.size > 0
         elsif session_header_and_content.content[:event_name] # If content includes an event_name, it must be a response from an api command
-          if session_header_and_content.content[:event_name].to_s.match(/CHANNEL_DATA/i) # Anytime we see CHANNEL_DATA event, we want to update our @session
-            session_header_and_content = HeaderAndContentResponse.new({:headers => hash_header.merge(hash_content.strip_value_newlines), :content => {}})
-            @session = session_header_and_content
-            @step += 1 if @state.include?(:initiated)
-            @queue.pop.call unless @queue.empty?
-            receive_reply(hash_header)
-          end
+          check_for_updated_session(session_header_and_content, hash_content, hash_header)
         else
-          @step += 1 if @state.include?(:initiated)
-          @queue.pop.call unless @queue.empty?
-          receive_reply(session_header_and_content)
+          update_state_machine(session_header_and_content)
+        end
+      end
+
+      protected
+      def queue_pop
+        if @queue.size > 0
+          if @read_var and session.headers[@read_var.to_sym]
+            r, @read_var = @read_var.to_sym, nil
+            @queue.pop.call(session.headers[r])
+          else
+            @queue.pop.call
+          end
         end
       end
 
+      private
+      # establish_new_session is called once during a new session.
+      # This establishes and sets up the variables used to hold state.  
+      # Called from #receive_request
+      #
+      # @param header_and_content_hash HeaderAndContentProtocol object representing the session
+      #
+      # @return header_and_content_hash HeaderAndContentProtocol object representing the session
+      def establish_new_session(header_and_content_hash)
+        @session = header_and_content_hash
+        @step = 0
+        @state = [:uninitiated]
+        session_initiated 
+        @state << :initiated
+        header_and_content_hash
+      end
+      
+      # check_for_updated_session is called from #receive_request if a session has already been established
+      # This will overwrite @session with the new variables representing state.  
+      #
+      # @param header_and_content_hash HeaderAndContentProtocol object
+      # @param hash_content hash of content from standard Header and Content Protocol
+      # @param hash_header hash of headers from standard Header and Content Protocol
+      def check_for_updated_session(header_and_content_hash, hash_content, hash_header)
+        if header_and_content_hash.content[:event_name].to_s.match(/CHANNEL_DATA/i) # Anytime we see CHANNEL_DATA event, we want to update our @session
+          header_and_content_hash = HeaderAndContentResponse.new({:headers => hash_header.merge(hash_content.strip_value_newlines), :content => {}})
+          @session = header_and_content_hash
+          update_state_machine(header_and_content_hash.headers)
+        end
+      end
+
+      # update_state_machine when called will increment @step, 
+      # call the next block from @queue and dispatch the callback method
+      # #receive_reply
+      # @param response_header Response sent to #recieve_reply callback method
+      def update_state_machine(response_header)
+        @step += 1 if @state.include?(:initiated)
+        queue_pop
+        receive_reply(response_header)
+      end
+
     end
   end
 end

data/lib/fsr/version.rb

@@ -1,3 +1,3 @@
 module FSR
-  VERSION = "0.1.4"
+  VERSION = "0.3.0"
 end

data/spec/fsr/app/answer.rb

@@ -0,0 +1,12 @@
+require 'spec/helper'
+require "fsr/app"
+FSR::App.load_application("answer")
+
+describe "Testing FSR::App::Answer" do
+
+  it "answers the incoming call" do
+    ans = FSR::App::Answer.new
+    ans.sendmsg.should == "call-command: execute\nexecute-app-name: answer\n\n"
+  end
+
+end