bougyman-freeswitcher 0.0.9

data/lib/fsr/cmd/sofia.rb

@@ -0,0 +1,40 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class Sofia < Command
+      def initialize(fs_socket = nil)
+        @fs_socket = fs_socket # FSR::CommandSocket obj
+      end
+
+      # sofia status
+      def status(args = {})
+        require "fsr/cmd/sofia/status" # Require sofia/status
+        Status.new(@fs_socket, args)
+      end
+
+      # sofia profile
+      def profile(args = nil)
+        require "fsr/cmd/sofia/profile" # Require sofia/profile
+        if args == nil
+          Profile.new(@fs_socket, :command_string => "")
+        else
+          Profile.new(@fs_socket, args)
+        end
+      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 = "sofia"
+      end
+    end
+
+  register(:sofia, Sofia) 
+  end
+end

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

@@ -0,0 +1,75 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class Sofia 
+      class Profile < Command
+        attr_reader :options
+        attr_accessor :fs_socket, :command_string, :name, :action
+
+        VALID_ACTIONS = [:start, :stop, :restart, :rescan]
+        def initialize(fs_socket = nil, options = nil)
+          @fs_socket = fs_socket # FSR::CommandSocket object
+          if options.kind_of?(String)
+            @command_string = options
+          else
+            raise "options must be a String or Hash" unless options.kind_of?(Hash)
+            @options = options
+            @action = @options[:action]
+            if @action
+              raise "Invalid action, must specify one of #{VALID_ACTIONS.inspect}" unless VALID_ACTIONS.include?(@action)
+              @name = @options[:name]
+              raise "Invalid profile name" unless @name.to_s.match(/\w/)
+            else
+              @command_string = @options[:command_string] # If user wants to send a raw "sofia profile"
+            end
+          end
+          @command_string ||= ""
+        end
+
+        VALID_ACTIONS.each do |action|
+          define_method(action, lambda { |name| @action, @name = action, name;self })
+        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
+
+        def self.start(profile, socket = FSR::CommandSocket.new)
+          new(socket, :name => profile, :action => :start)
+        end
+
+        # Restart a sip_profile
+        def self.restart(profile, socket = FSR::CommandSocket.new)
+          new(socket, :name => profile, :action => :restart)
+        end
+
+        # Stop a sip_profile
+        def self.stop(profile, socket = FSR::CommandSocket.new)
+          new(socket, :name => profile, :action => :stop)
+        end
+
+        # Rescan a sip_profile
+        def self.rescan(profile, socket = FSR::CommandSocket.new)
+          new(socket, :name => profile, :action => :rescan)
+        end
+
+        # This method builds the API command to send to the freeswitch event socket
+        def raw
+          raise "Invalid action, must specify (start|stop|restart|rescan) as an action or pass a command_string" unless @command_string or @action
+          if @action
+            if @action_options
+              "sofia profile %s %s %s" % [@name, @action, @action_options]
+            else
+              "sofia profile %s %s" % [@name, @action]
+            end
+          else
+            "sofia profile %s" % @command_string
+          end.to_s.strip
+        end
+      end
+    end
+  end
+end

data/lib/fsr/cmd/sofia/status.rb

@@ -0,0 +1,39 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class Sofia 
+      class Status < Command
+        attr_reader :fs_socket
+
+        def initialize(fs_socket = nil, args = {})
+          @fs_socket = fs_socket # FSR::CommandSocket object
+          @status  = args[:status] # Status type; profile or gateway
+          @name = args[:name] # Name of profile or gateway
+          # If status is given, make sure it's profile or gateway
+          unless @status.nil?
+            raise "status must be profile or gateway" unless @status =~ /profile|gateway/i
+          end
+          if @status
+            raise "must provide a profile or gateway name" unless @name
+          end
+        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
+          if @status and @name
+            orig_command = "sofia status #{@status} #{@name}"
+          else
+            orig_command = "sofia status"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fsr/cmd/sofia_contact.rb

@@ -0,0 +1,31 @@
+# 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 SofiaContact < Command
+      attr_reader :contact
+
+      def initialize(fs_socket = nil, contact = {})
+        @fs_socket = fs_socket # FSR::CommandSocket obj
+        @contact = contact[:contact]
+        puts @contact
+      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 = "sofia_contact #{@contact}"
+      end
+    end
+
+  register(:sofia_contact, SofiaContact)
+  end
+end

data/lib/fsr/cmd/status.rb

@@ -0,0 +1,25 @@
+require "fsr/app"
+module FSR
+  module Cmd
+    class Status < Command
+
+      def initialize(fs_socket = nil)
+        @fs_socket = fs_socket # FSR::CommandSocket obj
+      end
+
+      # Send the command to the event socket, using bgapi 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 = "status"
+      end
+    end
+
+    register(:status, Status)
+  end
+end

data/lib/fsr/command_socket.rb

@@ -0,0 +1,29 @@
+require "fsr/event_socket"
+require "fsr/cmd"
+module FSR
+  class CommandSocket < EventSocket
+    include Cmd
+
+    def initialize(args = {})
+      @server = args[:server] || "127.0.0.1"
+      @port = args[:port] || "8021"
+      @auth = args[:auth] || "ClueCon"
+      @socket = TCPSocket.new(@server, @port)
+      super(@socket)
+      # Attempt to login or raise an exception
+      unless login
+        raise "Unable to login, check your password!"
+      end
+    end
+    
+    # Method to authenticate to FreeSWITCH
+    def login
+      #Clear buf from initial socket creation/opening
+      response 
+      # Send auth string to FreeSWITCH
+      self << "auth #{@auth}"
+      #Return response, clear buf for rest of commands
+      response 
+    end
+  end
+end

data/lib/fsr/database.rb

@@ -0,0 +1,7 @@
+# Logic to initialize the database here
+require "sequel"
+module FSR
+  module Database
+  end
+end
+

data/lib/fsr/database/call_limit.rb

@@ -0,0 +1,21 @@
+require "fsr/database"
+module FSR
+  module Database
+    module CallLimit
+      DB = Sequel.connect("sqlite:///" + File.join(FSR::FS_DB_PATH, "call_limit.db"))
+      class LimitData < Sequel::Model
+      end
+      LimitData.set_dataset :limit_data
+
+      class DbData < Sequel::Model
+      end
+      DbData.set_dataset :db_data
+
+      class GroupData < Sequel::Model
+      end
+      GroupData.set_dataset :group_data
+
+      LimitData.db, DbData.db, GroupData.db = [DB] * 3
+    end
+  end
+end

data/lib/fsr/database/core.rb

@@ -0,0 +1,30 @@
+require "fsr/database"
+# This module maps to the Free Switch core.db database
+#
+# TODO Separate these models into their own subdirectories
+module FSR
+  module Database
+    module Core
+      DB = Sequel.connect("sqlite://" + File.join(FSR::FS_DB_PATH, "core.db"))
+
+      class Complete < Sequel::Model
+      end
+      Complete.set_dataset :complete
+
+      class Alias < Sequel::Model
+      end
+
+      class Channel < Sequel::Model
+      end
+
+      class Call < Sequel::Model
+      end
+
+      class Interface < Sequel::Model
+      end
+
+      class Task < Sequel::Model
+      end
+    end
+  end
+end

data/lib/fsr/event_socket.rb

@@ -0,0 +1,41 @@
+module FSR
+  class EventSocket
+    attr_reader :socket
+
+    def initialize(socket)
+      @socket = socket
+    end
+
+    # Send a command and return response
+    def say(cmd)
+      @socket.send("#{cmd}\n\n",0)
+      response
+    end
+
+    # Send a command, do not return response
+    def <<(cmd)
+      @socket.send("#{cmd}\n\n",0)
+    end
+
+    # Grab result from command and create a hash, simple but works.
+    def get_header_and_body
+      headers, body = {}, ""
+      until line = @socket.gets and line.chomp.empty?
+        if (kv = line.chomp.split(/:\s+/,2)).size == 2
+          headers.store *kv
+        end
+      end
+      if (content_length = headers["Content-Length"].to_i) > 0
+        Log.debug "content_length is #{content_length}, grabbing from socket"
+        body << @socket.read(content_length)
+      end
+      headers.merge("body" => body.strip)
+    end
+
+    # Scrub result into a hash
+    def response
+      get_header_and_body
+    end
+
+  end
+end

data/lib/fsr/fake_socket.rb

@@ -0,0 +1,68 @@
+## Fake socket used for mock testing ##
+#
+require 'stringio'
+
+module FSR
+  class FakeSocket
+    def initialize(remote_host, remote_port)
+      @remote_host, @remote_port = remote_host, remote_port
+
+      @input = StringIO.new('')
+      @buffer = []
+    end
+
+    def hostname
+      'localhost'
+    end
+
+    def address
+      '127.0.0.1'
+    end
+
+    def eof?
+      @input.eof?
+    end
+    alias closed? eof?
+
+    def close
+    end
+
+    def print(*args)
+      @buffer << args.join
+    end
+
+    def read(len)
+      @input.read(len)
+    end
+
+    def fake_input
+      @input
+    end
+
+    def fake_buffer
+      @buffer
+    end
+  end
+end
+
+require 'bacon'
+Bacon.summary_at_exit
+
+describe FSR::FakeSocket do
+  it 'can be initialized' do
+    @socket = FSR::FakeSocket.new('google.com', 80)
+    @socket.should.not.be.nil
+  end
+
+  it 'can be filled with input which is then read' do
+    @socket.fake_input.write('foobar')
+    @socket.fake_input.pos = 0
+    @socket.read(6).should == 'foobar'
+    @socket.read(1).should == nil
+  end
+
+  it 'can receive input' do
+    @socket.print('foo')
+    @socket.fake_buffer.should == ['foo']
+  end
+end

data/lib/fsr/listener.rb

@@ -0,0 +1,10 @@
+module FSR
+  module Listener 
+
+    def receive_data(data)
+      FSR::Log.debug "Received #{data}"
+    end
+
+  end
+end
+FSL = FSR::Listener

data/lib/fsr/listener/header_and_content_response.rb

@@ -0,0 +1,21 @@
+require 'fsr/listener'
+
+module FSR
+  module Listener
+    class HeaderAndContentResponse
+
+      attr_reader :headers, :content
+
+      def initialize(args = {})
+        @headers = args[:headers]
+        @content =  args[:content]
+      end
+      
+      # Keep backward compat with the other 2 people who use FSR
+      def body
+        @content
+      end
+
+    end
+  end
+end