freeswitcher 0.0.9

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/lib/fsr/listener/outbound.rb.orig

@@ -0,0 +1,131 @@
+require "yaml"
+require "fsr/listener"
+module FSR
+  load_all_applications
+  module Listener
+    module Outbound
+      include FSR::Listener
+
+      # 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
+
+      # 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 receive_data(data)
+        FSR::Log.debug("received #{data}")
+        if @session.nil? # if @session is nil, create a new Session object
+          @session = Session.new(data)
+          session_initiated(@session) if @session.initiated?
+        else
+          # If it's not nil, we add the data to this session, Session knows whether
+          # or not to create a CommandReply, complete a CommandReply, or simply add to
+          # its own @data array and @headers/@body structures
+          if @session.initiated?
+            @session << data
+            reply_received(@session.replies.last) if @session.replies.last.complete?
+          else
+            @session << data
+            session_initiated(@session) if @session.initiated?
+          end
+        end
+        @session
+      end
+
+      def session_initiated(session)
+        session
+      end
+
+      def reply_received(command_reply)
+        command_reply
+      end
+
+      alias :receive_response :reply_received
+      # 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
+
+
+      class SocketResponse
+        attr_accessor :headers, :body, :data
+        def initialize(data = "")
+          @data = [data]
+          @headers = {}
+          if data.match(/\n$/)
+            headers, @body = data.split("\n\n")
+            headers.each_line do |line|
+              key, value = line.split(":")
+              @headers[key] = value.to_s.strip
+            end
+          end
+          @body ||= ""
+          FSR::Log.debug("New #{self.class.name} created: #{self}")
+        end
+
+        def <<(data)
+          if data.match(/\n$/)
+            @data.last.match(/\n$/) ? @data << data : @data.last << data
+            extra_headers, more_body = @data.last.split("\n\n")
+            extra_headers.each_line do |line|
+              key, value = line.split(":")
+              @headers[key] = value.to_s.strip
+            end
+            @body << more_body unless more_body.nil?
+          else
+            @data.last.match(/\n$/) ? @data << data : @data.last << data
+          end
+          self
+        end
+      end
+
+      class Session < SocketResponse
+        attr_accessor :replies
+        def initialize(data = "")
+          super
+          @replies = []
+        end
+
+        def <<(data)
+          if initiated?
+            if @replies.empty? or @replies.last.complete?
+              @replies << CommandReply.new(data)
+            else
+              @replies.last << data
+            end
+          else
+            super
+          end
+        end
+
+        def initiated?
+          @headers.keys.include?("Control")
+        end
+        
+      end
+
+      class CommandReply < SocketResponse
+        # Set this to true for now, fill it in when we know what completed a reply
+        def complete?
+          true
+        end
+      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