FreeSWITCHeR 0.0.8

data/lib/fsr/app/answer.rb

@@ -0,0 +1,21 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class Answer < Application
+      def initialize
+      end
+
+      def arguments
+        []
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: %s\n\n" % [app_name]
+      end
+
+    end
+
+    register(:answer, Answer)
+  end
+end

data/lib/fsr/app/bridge.rb

@@ -0,0 +1,33 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class Bridge < Application
+      attr_reader :options
+
+      def initialize(target, opts = {})
+        # These are options that will precede the target address
+        @target = target
+        @options = opts || {}
+      end
+
+      def arguments
+        [@target]
+      end
+
+      def modifiers
+        @options.map { |k,v| "%s=%s" % [k, v] }.join(",")
+      end
+
+      def raw
+        "%s({%s}%s)" % [app_name, modifiers, arguments.join(" ")]
+      end
+
+      def self.execute(target, opts = {})
+        self.new(target, opts).raw
+      end
+    end
+
+    register(:bridge, Bridge)
+  end
+end

data/lib/fsr/app/conference.rb

@@ -0,0 +1,29 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class Conference < Application
+      attr_reader :target, :profile
+
+      def initialize(conference_name, conference_profile = nil)
+        # These are options that will precede the target address
+        @target = conference_name
+        @profile = conference_profile || "ultrawideband"
+      end
+
+      def arguments
+        ["%s@%s" % [@target, @profile]]
+      end
+
+      def self.execute(conference_name, conference_profile = nil)
+        self.new(conference_name, conference_profile).raw
+      end
+
+      def self.[](conference_name)
+        self.execute(conference_name)
+      end
+    end
+
+    register(:conference, Conference)
+  end
+end

data/lib/fsr/app/fifo.rb

@@ -0,0 +1,38 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class Fifo < Application
+      attr_accessor :name, :direction
+      attr_reader :options
+
+      def self.<<(name)
+        new(name)
+      end
+
+      def self.>>(name)
+        new(name, "out", :wait => true)
+      end
+
+      def initialize(name, direction = nil, options = nil)
+        # These are options that will precede the target address
+        @name = name
+        @direction = direction || "in"
+        raise "Direction must be 'in' or 'out'" unless @direction.match(/^(?:in|out)$/)
+        @options = options || {}
+        raise "options must be a hash" unless @options.kind_of?(Hash)
+      end
+
+      def arguments
+        @args = [@name, @direction]
+        if @direction == "out"
+          @args << (options[:wait] ? "wait" : "nowait")
+        end
+        @args
+      end
+
+    end
+
+    register(:fifo, Fifo)
+  end
+end

data/lib/fsr/app/fs_break.rb

@@ -0,0 +1,21 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class FSBreak < Application
+      def initialize
+      end
+
+      def arguments
+        []
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: break\n\n"
+      end
+
+    end
+
+    register(:fs_break, FSBreak)
+  end
+end

data/lib/fsr/app/fs_sleep.rb

@@ -0,0 +1,24 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class FSSleep < Application
+      attr_reader :milliseconds
+
+      def initialize(milliseconds)
+        # milliseconds to sleep 
+        @milliseconds = milliseconds
+      end
+      def arguments
+        [@milliseconds]
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: sleep\nexecute-app-arg: %s\n\n" % [arguments.join(" ")]
+      end
+
+    end
+
+    register(:fs_sleep, FSSleep)
+  end
+end

data/lib/fsr/app/hangup.rb

@@ -0,0 +1,22 @@
+require "fsr/app"
+module FSR
+  module App
+    # http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_hangup
+    class Hangup < Application
+      def initialize(data = nil)
+        @data = data
+      end
+
+      def arguments
+        @data
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\n\n" % [app_name, arguments]
+      end
+
+    end
+
+    register(:hangup, Hangup)
+  end
+end

data/lib/fsr/app/log.rb

@@ -0,0 +1,24 @@
+require "fsr/app"
+module FSR
+  module App
+    # http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_log
+    class Log < Application
+      attr_reader :level, :text
+
+      def initialize(level = 1, text = "")
+        @level = level
+        @text = text
+      end
+
+      def arguments
+        [@level, @text]
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join(" ")]
+      end
+    end
+
+    register(:log, Log)
+  end
+end

data/lib/fsr/app/playback.rb

@@ -0,0 +1,23 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class Playback < Application
+      attr_reader :wavfile
+
+      def initialize(wavfile)
+        # wav file you wish to play, full path 
+        @wavfile = wavfile
+      end
+      def arguments
+        [@wavfile]
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join(" ")] 
+      end
+    end
+
+    register(:playback, Playback)
+  end
+end

data/lib/fsr/app/set.rb

@@ -0,0 +1,22 @@
+require "fsr/app"
+module FSR
+  module App
+    # http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_set
+    class Set < Application
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+
+      def arguments
+        [@key, @value]
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join("=")] 
+      end
+    end
+
+    register(:set, Set)
+  end
+end

data/lib/fsr/app/speak.rb

@@ -0,0 +1,25 @@
+
+require "fsr/app"
+module FSR
+  module App
+    class Speak < Application
+      attr_reader :message
+
+      def initialize(message, opts = {})
+        # wav file you wish to play, full path 
+        @message = message
+        @voice = opts[:voice] || "slt"
+      end
+
+      def arguments
+        ["flite", @voice, @message]
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join("|")] 
+      end
+    end
+
+    register(:speak, Speak)
+  end
+end

data/lib/fsr/app/transfer.rb

@@ -0,0 +1,24 @@
+require "fsr/app"
+module FSR
+  module App
+    class Transfer < Application
+      attr_reader :destination_number, :dialplan, :context
+
+      def initialize(destination_number, dialplan = nil, context = nil)
+        @destination_number = destination_number
+        @dialplan = dialplan || "XML"
+        @context = context || "default"
+      end
+
+      def arguments
+        [@destination_number, @dialplan, @context]
+      end
+
+      def sendmsg
+        "call-command: execute\nexecute-app-name: %s\nexecute-app-arg: %s\nevent-lock:true\n\n" % [app_name, arguments.join(" ")]
+      end
+    end
+
+    register(:transfer, Transfer)
+  end
+end

data/lib/fsr/cmd.rb

@@ -0,0 +1,57 @@
+module FSR
+  module Cmd
+    class Command
+    end
+
+    COMMANDS = {}
+    LOAD_PATH = [File.join(FSR::ROOT, "fsr", "cmd")]
+
+    def self.register(command, obj)
+      COMMANDS[command.to_sym] = obj
+
+      code = "def %s(*args, &block) COMMANDS[%p].new(self, *args, &block) end" % [command, command]
+      Cmd.module_eval(code)
+    end
+
+    def self.list
+      COMMANDS.keys
+    end
+
+    def self.load_command(command, force_reload = false)
+      # If we get a path specification and it's an existing file, load it
+      if File.file?(command)
+        if force_reload
+          return load(command)
+        else
+          return require(command)
+        end
+      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)
+        Log.debug "Trying to load #{command_file}"
+        if force_reload
+          load command_file.to_s + ".rb"
+        else
+          require command_file
+        end
+      else
+        raise "#{command} not found in #{LOAD_PATH.join(":")}"
+      end
+    end
+
+    # 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) }
+      end
+      list
+    end
+
+    def commands
+      FSR::Cmd.list
+    end
+  end
+end
+FSC = FSR::Cmd

data/lib/fsr/cmd/fsctl.rb

@@ -0,0 +1,41 @@
+# A lot of methods are missing here. The only one implemented is max_sessions
+# The max_sessions getter currently returns the raw result but could instead return an Integer
+
+require "fsr/app"
+module FSR
+  module Cmd
+    class Fsctl < Command
+      attr_reader :command
+
+      def initialize(fs_socket = nil)
+        @fs_socket = fs_socket # FSR::CommandSocket obj
+      end
+
+      # Get max sessions
+      def max_sessions
+        @command = "max_sessions"
+        run
+      end
+
+      # Set max sessions
+      def max_sessions=(sessions)
+        @command = "max_sessions #{sessions}"
+        run
+      end
+
+      # Send the command to the event socket, using api by default.
+      def run(api_method = :api)
+        orig_command = "%s %s" % [api_method, raw]
+        Log.debug "saying #{orig_command}"
+        @fs_socket.say(orig_command)
+      end
+    
+      # This method builds the API command to send to the freeswitch event socket
+      def raw
+        orig_command = "fsctl #{@command}"
+      end
+    end
+
+  register(:fsctl, Fsctl)
+  end
+end

data/lib/fsr/cmd/originate.rb

@@ -0,0 +1,46 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class Originate < Command
+      attr_accessor :target, :endpoint
+      attr_reader :fs_socket, :target_options
+
+      def initialize(fs_socket = nil, args = {})
+        # 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)
+        
+        @fs_socket = fs_socket # This socket must support say and <<
+        @target = args[:target] # The target address to call
+        # The origination endpoint (can be an extension (use a string) or application)
+        @endpoint = args[:endpoint] || args[:application]
+
+        @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.
+      def run(api_method = :bgapi)
+        orig_command = "%s %s" % [api_method, raw]
+        Log.debug "saying #{orig_command}"
+        @fs_socket.say(orig_command)
+      end
+
+      # This method builds the API command to send to the freeswitch event socket
+      def raw
+        target_opts = @target_options.keys.sort { |a,b| a.to_s <=> b.to_s }.map { |k| "%s=%s" % [k, @target_options[k]] }.join(",")
+        if @endpoint.kind_of?(String)
+          orig_command = "originate {#{target_opts}}#{@target} #{@endpoint}"
+        elsif @endpoint.kind_of?(FSR::App::Application)
+          orig_command = "originate {#{target_opts}}#{@target} '&#{@endpoint.raw}'"
+        else
+          raise "Invalid endpoint"
+        end
+      end
+    end
+
+    register(:originate, Originate)
+  end
+end