FreeSWITCHeR 0.0.8

data/lib/fsr/listener/inbound.rb

@@ -0,0 +1,61 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fsr/listener'
+require 'fsr/listener/header_and_content_response.rb'
+
+module FSR
+  module Listener
+    class Inbound < EventMachine::Protocols::HeaderAndContentProtocol
+      HOOKS = {}
+
+      def initialize(args = {})
+        super
+        @auth = args[:auth] || "ClueCon"
+      end
+
+      def post_init
+        say("auth #{@auth}")
+        say('event plain ALL')
+      end
+
+      def receive_request(header, content)
+        hash_header = headers_2_hash(header)
+        hash_content = headers_2_hash(content)
+        event = HeaderAndContentResponse.new({:headers => hash_header, :content => hash_content})
+        event_name = event.content[:event_name].to_s.strip
+        unless event_name.empty?
+          HOOKS[event_name.to_sym].call(event) unless HOOKS[event_name.to_sym].nil?
+        end
+        on_event(event)
+      end
+
+      def say(line)
+        send_data("#{line}\r\n\r\n")
+      end
+
+      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
+      #
+      # <b>Returns/<b>
+      # - nil
+      def self.add_event_hook(event, &block)
+        HOOKS[event] = block 
+      end
+
+      # Delete the block that was to be executed for the specified event.
+      def self.del_event_hook(event)
+        HOOKS.delete(event)  
+      end
+
+    end
+
+  end
+end

data/lib/fsr/listener/inbound/event.rb

@@ -0,0 +1,42 @@
+require 'fsr/listener/inbound'
+module FSR
+  module Listener
+    module Inbound
+      class Event
+        def self.from(data)
+          instance = new
+
+          capture = header = {}
+          body = {}
+          
+          data.each_line do |line|
+            line.strip!
+
+          case line
+            when ''
+              capture = body
+            when /([a-zA-Z0-9-]+):\s*(.*)/
+              #capture[$1] = $2.strip
+              key, val = line.split(":")
+              capture[key] = val.to_s.strip
+            end
+          end
+          
+          instance.header.merge!(header)
+          instance.body.merge!(body)
+          instance
+        end
+        
+        attr_reader :header, :body
+
+        def initialize(header = {}, body = {})
+          @header, @body = header, body
+        end
+        
+        def [](key)
+          @header.merge(@body)[key]
+        end
+      end
+    end
+  end
+end

data/lib/fsr/listener/outbound.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'eventmachine'
+require 'fsr/listener'
+require 'fsr/listener/header_and_content_response'
+
+module FSR
+  load_all_applications
+  module Listener
+    class Outbound < EventMachine::Protocols::HeaderAndContentProtocol
+
+      # Include FSR::App to get all the applications defined as methods
+      include FSR::App
+
+      # Redefine the FSR::App methods to wrap sendmsg around them
+      SENDMSG_METHOD_DEFINITION = "def %s(*args, &block); sendmsg super; end"
+      APPLICATIONS.each { |app, obj| module_eval(SENDMSG_METHOD_DEFINITION % app.to_s) }
+
+      def post_init
+        @session = nil # holds the session object
+        send_data("connect\n\n")
+        FSR::Log.debug "Accepting connections."
+      end
+
+      def receive_request(header, content)
+        hash_header = headers_2_hash(header)
+        hash_content = headers_2_hash(content)
+        session = HeaderAndContentResponse.new({:headers => hash_header, :content => hash_content})
+        if @session.nil?
+          @session = self
+          session_initiated(session) 
+        else
+          receive_reply(session)
+        end
+      end
+
+      # Received data dispatches the data received by the EM socket,
+      # Either as a Session, a continuation of a Session, or as a Session's last CommandReply
+      
+      def session_initiated(session)
+        session
+      end
+
+      def receive_reply(session)
+        session
+      end
+
+      # sendmsg sends data to the EM app socket via #send_data, or
+      # returns the string it would send if #send_data is not defined.
+      # It expects an object which responds to either #sendmsg or #to_s, 
+      # which should return a EM Outbound Event Socket formatted instruction
+      
+      def sendmsg(message)
+        text = message.respond_to?(:sendmsg) ? message.sendmsg : message.to_s
+        FSR::Log.debug "sending #{text}"
+        message = "sendmsg\n%s\n" % text
+        self.respond_to?(:send_data) ? send_data(message) : message
+      end
+
+    end
+
+  end
+end

data/spec/fsr/app.rb

@@ -0,0 +1,8 @@
+require "spec/helper"
+describe "Basic FSR::App module" do
+  it "Aliases itself as FSA" do
+    require "fsr/app"
+    FSA.should == FSR::App 
+  end
+end
+

data/spec/fsr/app/bridge.rb

@@ -0,0 +1,17 @@
+require 'spec/helper'
+require "fsr/app"
+FSR::App.load_application("bridge")
+
+describe "Testing FSR::App::Bridge" do
+  # Utilize the [] shortcut to start a conference
+  it "Bridges a call, for FSR::Listener::Inbound" do
+    bridge = FSR::App::Bridge.new("user/bougyman")
+    bridge.raw.should == "bridge({}user/bougyman)"
+  end
+
+  it "Bridges a call, for FSR::Listener::Outbound" do
+    bridge = FSR::App::Bridge.new("user/bougyman")
+    bridge.sendmsg.should == "call-command: execute\nexecute-app-name: bridge\nexecute-app-arg: user/bougyman\n\n"
+  end
+
+end

data/spec/fsr/app/conference.rb

@@ -0,0 +1,12 @@
+require 'spec/helper'
+require "fsr/app"
+FSR::App.load_application("conference")
+
+describe "Testing FSR::App::Conference" do
+  # Utilize the [] shortcut to start a conference
+  it "Executes a conference using Conference[conf_spec]" do
+    conf = FSR::App::Conference["5290-192.168.6.30"]
+    conf.should == "conference(5290-192.168.6.30@ultrawideband)"
+  end
+
+end

data/spec/fsr/app/fifo.rb

@@ -0,0 +1,29 @@
+require 'spec/helper'
+require "fsr/app"
+FSR::App.load_application("fifo")
+
+describe "Testing FSR::App::Fifo" do
+  # Utilize the [] shortcut to start a conference
+  it "Puts a call into a queue, with #new" do
+    fifo = FSR::App::Fifo.new("myqueue", "in")
+    fifo.raw.should == "fifo(myqueue in)"
+  end
+
+  it "Puts a call into a queue, with <<" do
+    fifo = FSR::App::Fifo << "myqueue"
+    fifo.raw.should == "fifo(myqueue in)"
+  end
+
+  it "Adds a consumer to a queue, with #new" do
+    fifo = FSR::App::Fifo.new("myqueue", "out")
+    fifo.raw.should == "fifo(myqueue out nowait)"
+    fifo = FSR::App::Fifo.new("myqueue", "out", :wait => true)
+    fifo.raw.should == "fifo(myqueue out wait)"
+  end
+  
+  it "Adds a consumer to a queue, with >>" do
+    fifo = FSR::App::Fifo >> "myqueue"
+    fifo.raw.should == "fifo(myqueue out wait)"
+  end
+
+end

data/spec/fsr/cmd.rb

@@ -0,0 +1,8 @@
+require "spec/helper"
+describe "Basic FSR::Cmd module" do
+  it "Aliases itself as FSC" do
+    require "fsr/cmd"
+    FSC.should == FSR::Cmd 
+  end
+end
+

data/spec/fsr/cmd/originate.rb

@@ -0,0 +1,12 @@
+require 'spec/helper'
+require "fsr/cmd"
+FSR::Cmd.load_command("originate")
+
+describe "Testing FSR::Cmd::Originate" do
+  # Originate to an extension
+  it "Originates calls to extensions" do
+    originate = FSR::Cmd::Originate.new(nil, :target => "user/bougyman", :endpoint => "4000")
+    originate.raw.should == "originate {ignore_early_media=true,originate_timeout=30,origination_caller_id_name=FSR,origination_caller_id_number=8675309}user/bougyman 4000"
+  end
+
+end

data/spec/fsr/cmd/sofia.rb

@@ -0,0 +1,69 @@
+require 'spec/helper'
+require "fsr/cmd"
+FSR::Cmd.load_command("sofia")
+
+describe "Testing FSR::Cmd::Sofia" do
+  ## Sofia ##
+  # Interface to sofia
+  it "FSR::Cmd::Sofia should interface to sofia" do
+    sofia = FSR::Cmd::Sofia.new
+    sofia.raw.should == "sofia"
+  end
+
+  ## Sofia Status ##
+  it "FSR::Cmd::Sofia should allow status" do
+    sofia = FSR::Cmd::Sofia.new
+    status = sofia.status
+    status.raw.should == "sofia status"
+  end
+  # Sofia status profile internal
+  it "FSR::Cmd::Sofia should allow status profile internal" do
+    sofia = FSR::Cmd::Sofia.new
+    status = sofia.status(:status => 'profile', :name => 'internal')
+    status.raw.should == "sofia status profile internal"
+  end
+  # Sofia status gateway server 
+  it "FSR::Cmd::Sofia should allow status gateway server" do
+    sofia = FSR::Cmd::Sofia.new
+    status = sofia.status(:status => 'gateway', :name => 'server')
+    status.raw.should == "sofia status gateway server"
+  end
+
+  ## Sofia profile ##
+  it "FSR::Cmd::Sofia should allow profile" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile
+    profile.raw.should == "sofia profile"
+  end
+
+  it "FSR::Cmd::Sofia::Profile should allow raw string" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile('internal stop')
+    profile.raw.should == "sofia profile internal stop"
+  end
+
+  it "FSR::Cmd::Sofia::Profile should allow start" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.start('internal')
+    profile.raw.should == "sofia profile internal start"
+  end
+
+  it "FSR::Cmd::Sofia::Profile should allow stop" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.stop('internal')
+    profile.raw.should == "sofia profile internal stop"
+  end
+
+  it "FSR::Cmd::Sofia::Profile should allow restart" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.restart('internal')
+    profile.raw.should == "sofia profile internal restart"
+  end
+
+  it "FSR::Cmd::Sofia::Profile should allow rescan" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.rescan('internal')
+    profile.raw.should == "sofia profile internal rescan"
+  end
+
+end

data/spec/fsr/cmd/sofia/profile.rb

@@ -0,0 +1,58 @@
+require 'spec/helper'
+require "fsr/cmd"
+FSR::Cmd.load_command("sofia")
+
+describe "FSR::Cmd::Sofia::Profile" do
+
+  ## Sofia profile ##
+  it "should allow FSR::Cmd::Sofia.new.profile (no arguments) through Sofia instance" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile
+    profile.raw.should == "sofia profile"
+  end
+
+  it "should allow raw string as an argument through Sofia instance" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile('internal stop')
+    profile.raw.should == "sofia profile internal stop"
+  end
+
+  it "should start a profile by name through Sofia instance" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.start('internal')
+    profile.raw.should == "sofia profile internal start"
+  end
+
+  it "should stop a profile by name through Sofia instance" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.stop('internal')
+    profile.raw.should == "sofia profile internal stop"
+  end
+
+  it "should restart a profile by name through Sofia instance" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.restart('internal')
+    profile.raw.should == "sofia profile internal restart"
+  end
+
+  it "should rescan a profile by name through Sofia instance" do
+    sofia = FSR::Cmd::Sofia.new
+    profile = sofia.profile.rescan('internal')
+    profile.raw.should == "sofia profile internal rescan"
+  end
+
+  it "should start, stop, rescan, restart a profile by name with a class method" do
+    # pass nil as the socket until we get the MockSocket completed
+    FSR::Cmd::Sofia::Profile.start("foo", nil).raw.should == "sofia profile foo start"
+    FSR::Cmd::Sofia::Profile.stop("foo", nil).raw.should == "sofia profile foo stop"
+    FSR::Cmd::Sofia::Profile.restart("foo", nil).raw.should == "sofia profile foo restart"
+    FSR::Cmd::Sofia::Profile.rescan("foo", nil).raw.should == "sofia profile foo rescan"
+  end
+
+  it "should allow instantiation directly, with hash options" do
+    # pass nil as the socket until we get the MockSocket completed
+    profile = FSR::Cmd::Sofia::Profile.new(nil, {:name => 'internal', :action => :stop}) 
+    profile.raw.should == "sofia profile internal stop"
+  end
+
+end

data/spec/fsr/listener.rb

@@ -0,0 +1,12 @@
+require "spec/helper"
+require "fsr/listener"
+describe "Basic FSR::Listener module" do
+  it "Aliases itself as FSL" do
+    FSL.should == FSR::Listener 
+  end
+
+  it "Defines #receive_data" do
+    FSR::Listener.method_defined?(:receive_data).should == true
+  end
+end
+

data/spec/fsr/listener/inbound.rb

@@ -0,0 +1,19 @@
+require 'spec/helper'
+require "fsr/listener/inbound"
+
+# Bare class to use for testing
+class MyListener < FSR::Listener::Inbound
+end
+
+# helper to instantiate a new MyListener
+def my_listener
+  MyListener.new
+end
+
+describe "Testing FSR::Listener::Inbound" do
+
+  it "defines #post_init" do
+    FSR::Listener::Inbound.method_defined?(:post_init).should == true
+  end
+
+end

data/spec/fsr/listener/outbound.rb

@@ -0,0 +1,19 @@
+require 'spec/helper'
+require "fsr/listener/outbound"
+
+# Bare class to use for testing
+class MyListener < FSR::Listener::Outbound
+end
+
+# helper to instantiate a new MyListener
+def my_listener
+  MyListener.new
+end
+
+describe "Testing FSR::Listener::Outbound" do
+
+  it "defines #post_init" do
+    FSR::Listener::Outbound.method_defined?(:post_init).should == true
+  end
+
+end