librevox 0.9 → 1.0.0.alpha2

data/lib/librevox/applications.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Librevox
   # All applications should call `application` with the following parameters:
   #
@@ -8,8 +10,14 @@ module Librevox
   module Applications
     # Answers an incoming call or session.
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_answer
-    def answer &block
-      application "answer", &block
+    def answer
+      application "answer"
+    end
+
+    # Parks a call, keeping it active without routing it anywhere.
+    # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_park
+    def park
+      application "park"
     end
 
     # Make an attended transfer
@@ -17,27 +25,26 @@ module Librevox
     #   att_xfer("user/davis")
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_att_xfer
     # @todo Add support for origination_cancel_key
-    def att_xfer endpoint, &block
-      application "att_xfer", endpoint, &block
+    def att_xfer(endpoint)
+      application "att_xfer", endpoint
     end
 
     # Binds an application to the specified call legs.
-    # @example 
-    #   bind_meta_app :key          => 2,
-    #                 :listen_to    => "a",
-    #                 :respond_on   => "s",
-    #                 :application  => "execute_extension",
-    #                 :parameters   => "dx XML features"
+    # @example
+    #   bind_meta_app key: 2,
+    #                 listen_to: "a",
+    #                 respond_on: "s",
+    #                 application: "execute_extension",
+    #                 parameters: "dx XML features"
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_bind_meta_app
-    def bind_meta_app args={}, &block
+    def bind_meta_app(args = {})
       arg_string =
         args.values_at(:key, :listen_to, :respond_on, :application).join(" ")
       arg_string += "::#{args[:parameters]}" if args[:parameters]
 
-      application "bind_meta_app", arg_string, &block
+      application "bind_meta_app", arg_string
     end
 
-
     # Bridges an incoming call to an endpoint, optionally taking an array of
     # channel variables to set. If given an array of arrays, each contained
     # array of endpoints will be called simultaneously, with the next array
@@ -47,19 +54,16 @@ module Librevox
     #   bridge "user/coltrane", "user/backup-office"
     #   #=> user/coltrane,user/backup-office
     # @example With channel variables
-    #   bridge "user/coltrane", "user/backup-office", :some_var => "value"
+    #   bridge "user/coltrane", "user/backup-office", some_var: "value"
     #   #=> {some_var=value}user/coltrane,user/backup-office
     # @example With failover
     #   bridge ['user/coltrane', 'user/davis'], ['user/sun-ra', 'user/taylor']
     #   #=> user/coltrane,user/davis|user/sun-ra,user/taylor
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_bridge
-    def bridge *args, &block
+    def bridge(*args)
       variables = if args.last.is_a? Hash
-                    # We need to sort the key/value pairs to facilitate testing.
-                    # This can be removed once 1.8-compat is dropped.
-                    key_value_pairs = args.pop.sort {|x,y| x.to_s <=> y.to_s}
-                    key_value_pairs.map! {|k,v| "#{k}=#{v}"}
-                    "{#{key_value_pairs.join(",")}}"
+                    pairs = args.pop.map {|k,v| "#{k}=#{v}"}
+                    "{#{pairs.join(",")}}"
                   else
                     ""
                   end
@@ -70,38 +74,38 @@ module Librevox
                     args.join ","
                   end
 
-      application "bridge", variables + endpoints, &block
+      application "bridge", variables + endpoints
     end
 
     # Deflect a call by sending a REFER. Takes a SIP URI as argument, rerouting
     # the call to that SIP URI.
     #
     # Beware that REFER only can be used on established calls. If a call hasn't
-    # been established with e.g. the {#answer} application, you should use 
+    # been established with e.g. the {#answer} application, you should use
     # {#redirect} instead.
     # @example
     #   deflect "sip:miles@davis.com"
     # @see #redirect
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_deflect
-    def deflect uri, &block
-      application "deflect", uri, &block
+    def deflect(uri)
+      application "deflect", uri
     end
 
     # Exports a channel variable from the A leg to the B leg. Variables and
     # their values will be replicated in any new channels created from the one
     # export was called.
-    # 
-    # Set :local => false if the variable should only be exported to the B-leg.
+    #
+    # Set `local: false` if the variable should only be exported to the B-leg.
     #
     # @example
     #   export "some_var"
     # @example Only export to B-leg
-    #   export "some_var", :local => false
+    #   export "some_var", local: false
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_export
-    def export var, args={}, &block
-      nolocal = args[:local] == false ? "nolocal:" : "" # ugly!!111
+    def export(var, args = {})
+      nolocal = args[:local] == false ? "nolocal:" : ""
 
-      application "export", "#{nolocal}#{var}", &block
+      application "export", "#{nolocal}#{var}"
     end
 
     # Generate TGML tones
@@ -110,8 +114,8 @@ module Librevox
     # @example  Generate a DTMF string
     #   gentones "0800500005"
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_gentones
-    def gentones tgml , &block
-      application "gentones", tgml, &block
+    def gentones(tgml)
+      application "gentones", tgml
     end
 
     # Hang up current channel
@@ -120,21 +124,21 @@ module Librevox
     # @example Hang up with a reason
     #   hangup "USER_BUSY"
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_hangup
-    def hangup cause="", &block
-      application "hangup", cause, &block
+    def hangup(cause = "")
+      application "hangup", cause
     end
 
     # Plays a sound file and reads DTMF presses.
-    # @example 
+    # @example
     #   play_and_get_digits "please-enter.wav", "wrong-choice.wav",
-    #     :min          => 1,
-    #     :max          => 2,
-    #     :tries        => 3,
-    #     :terminators  => "#",
-    #     :timeout      => 5000,
-    #     :regexp       => '\d+'
+    #     min: 1,
+    #     max: 2,
+    #     tries: 3,
+    #     terminators: "#",
+    #     timeout: 5000,
+    #     regexp: '\d+'
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_play_and_get_digits
-    def play_and_get_digits file, invalid_file, args={}, &block
+    def play_and_get_digits(file, invalid_file, args = {})
       min         = args[:min]          || 1
       max         = args[:max]          || 2
       tries       = args[:tries]        || 3
@@ -146,29 +150,29 @@ module Librevox
       args = [min, max, tries, timeout, terminators, file, invalid_file,
         variable, regexp].join " "
 
-      params = {:variable => variable}
+      params = {variable: variable}
 
-      application "play_and_get_digits", args, params, &block
+      application "play_and_get_digits", args, params
     end
 
     # Plays a sound file on the current channel.
     # @example
     #   playback "/path/to/file.wav"
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_playback
-    def playback file, &block
-      application "playback", file, &block
+    def playback(file)
+      application "playback", file
     end
 
     # Pre-answer establishes early media but does not answer.
     # @example
-    #   pre_anser
+    #   pre_answer
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_pre_answer
-    def pre_answer &block
-      application "pre_answer", &block
+    def pre_answer
+      application "pre_answer"
     end
 
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_read
-    def read file, args={}, &block
+    def read(file, args = {})
       min         = args[:min]          || 1
       max         = args[:max]          || 2
       terminators = args[:terminators]  || "#"
@@ -178,9 +182,9 @@ module Librevox
       arg_string = "%s %s %s %s %s %s" % [min, max, file, variable, timeout,
         terminators]
 
-      params = {:variable => variable}
+      params = {variable: variable}
 
-      application "read", arg_string, params, &block
+      application "read", arg_string, params
     end
 
     # Records a message, with an optional limit on the maximum duration of the
@@ -188,11 +192,11 @@ module Librevox
     # @example Without limit
     #   record "/path/to/new/file.wac"
     # @example With 20 second limit
-    #   record "/path/to/new/file.wac", :limit => 20
+    #   record "/path/to/new/file.wac", limit: 20
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_record
-    def record path, params={}, &block
+    def record(path, params = {})
       args = [path, params[:limit]].compact.join(" ")
-      application "record", args, &block
+      application "record", args
     end
 
     # Redirect a channel to another endpoint. You must take care to not
@@ -206,48 +210,57 @@ module Librevox
     #   redirect "sip:freddie@hubbard.org"
     # @see #deflect
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_redirect
-    def redirect uri, &block
-      application "redirect", uri, &block
+    def redirect(uri)
+      application "redirect", uri
     end
 
     # Send SIP session respond code.
     # @example Send 403 Forbidden
     #   respond 403
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_respond
-    def respond code, &block
-      application "respond", code.to_s, &block
+    def respond(code)
+      application "respond", code.to_s
     end
 
     # Sets a channel variable.
     # @example
     #   set "some_var", "some value"
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_set
-    def set variable, value, &block
-      application "set", "#{variable}=#{value}", &block
+    def set(variable, value)
+      application "set", "#{variable}=#{value}"
+    end
+
+    # Sets multiple channel variables in a single application call.
+    # @example
+    #   multiset "var1" => "val1", "var2" => "val2"
+    # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_multiset
+    def multiset(vars)
+      args = "^^|" + vars.map { |k, v| "#{k}=#{v}" }.join("|")
+      application "multiset", args
     end
 
     # Transfers the current channel to a new context.
     # @example
     #   transfer "new_context"
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_transfer
-    def transfer context, &block
-      application "transfer", context, &block
+    def transfer(context)
+      application "transfer", context
     end
 
     # Unbinds a previously bound key with bind_meta_app
     # @example
     #   unbind_meta_app 3
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_unbind_meta_app
-    def unbind_meta_app key, &block
-      application "unbind_meta_app", key.to_s, &block
+    def unbind_meta_app(key)
+      application "unbind_meta_app", key.to_s
     end
 
     # Unset a channel variable.
     # @example
     #   unset "foo"
     # @see http://wiki.freeswitch.org/wiki/Misc._Dialplan_Tools_unset
-    def unset variable, &block
-      application "unset", variable, &block
+    def unset(variable)
+      application "unset", variable
     end
   end
 end

data/lib/librevox/client.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'io/stream'
+
+module Librevox
+  class Client
+    def initialize(handler, endpoint, **options)
+      @handler = handler
+      @endpoint = endpoint
+      @options = options
+    end
+
+    attr :endpoint
+
+    def connect(socket)
+      stream = IO::Stream(socket)
+      connection = Protocol::Connection.new(stream)
+
+      listener = @handler.new(connection, @options)
+
+      session_task = Async { listener.run_session }
+      connection.read_loop { |msg| listener.receive_message(msg) }
+    ensure
+      session_task&.stop
+      connection.close
+    end
+
+    def run
+      loop do
+        @endpoint.connect do |socket|
+          connect(socket)
+        end
+      rescue IOError, Errno::ECONNREFUSED, Errno::ECONNRESET => e
+        Librevox.logger.error "Connection lost: #{e.message}. Reconnecting in 1s."
+        sleep 1
+      end
+    end
+  end
+end

data/lib/librevox/command_socket.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 require 'socket'
-require 'librevox/response'
-require 'librevox/commands'
-require 'librevox/applications'
+require 'io/stream'
 
 module Librevox
   class CommandSocket
     include Librevox::Commands
 
-    def initialize args={}
+    def initialize(args = {})
       @server   = args[:server] || "127.0.0.1"
       @port     = args[:port] || "8021"
       @auth     = args[:auth] || "ClueCon"
@@ -17,39 +17,25 @@ module Librevox
 
     def connect
       @socket = TCPSocket.open(@server, @port)
-      @socket.print "auth #{@auth}\n\n"
+      stream = IO::Stream(@socket)
+      @connection = Protocol::Connection.new(stream)
+      @connection.write "auth #{@auth}\n\n"
       read_response
     end
 
-    def command *args
-      @socket.print "#{super(*args)}\n\n"
+    def command(*args)
+      @connection.write "#{super(*args)}\n\n"
       read_response
     end
 
     def read_response
-      response = Librevox::Response.new
-      until response.command_reply? or response.api_response?
-        response.headers = read_headers 
-      end
-
-      length = response.headers[:content_length].to_i
-      response.content = @socket.read(length) if length > 0
-
-      response
-    end
-
-    def read_headers
-      headers = ""
-
-      while line = @socket.gets and !line.chomp.empty?
-        headers += line
+      while msg = @connection.read_message
+        return msg if msg.command_reply? || msg.api_response?
       end
-
-      headers
     end
 
     def close
-      @socket.close
+      @connection.close
     end
   end
 end

data/lib/librevox/commands.rb

@@ -1,23 +1,23 @@
+# frozen_string_literal: true
+
 module Librevox
   # All commands should call `command` with the following parameters:
   #
   #   `name` - name of the command
   #   `args` - arguments as a string (optional)
-  #
-  # Commands *must* pass on any eventual block passed to them.
   module Commands
     # Executes a generic API command, optionally taking arguments as string.
     # @example
     #   socket.command "fsctl", "hupall normal_clearing"
     # @see http://wiki.freeswitch.org/wiki/Mod_commands
-    def command name, args=""
-      msg = "api #{name}"
-      msg << " #{args}" if args && !args.empty?
-      msg
+    def command(name, args = "")
+      parts = ["api", name]
+      parts << args if args && !args.empty?
+      parts.join(" ")
     end
 
-    def status &block
-      command "status", &block
+    def status
+      command "status"
     end
 
     # Access the hash table that comes with FreeSWITCH.
@@ -25,53 +25,53 @@ module Librevox
     #   socket.hash :insert, :realm, :key, "value"
     #   socket.hash :select, :realm, :key
     #   socket.hash :delete, :realm, :key
-    def hash *args, &block
-      command "hash", args.join("/"), &block
+    def hash(*args)
+      command "hash", args.join("/")
     end
 
     # Originate a new call.
     # @example Minimum options
-    #   socket.originate 'sofia/user/coltrane', :extension => "1234"
+    #   socket.originate 'sofia/user/coltrane', extension: "1234"
     # @example With :dialplan and :context
     # @see http://wiki.freeswitch.org/wiki/Mod_commands#originate
-    def originate url, args={}, &block
+    def originate(url, args = {})
       extension = args.delete(:extension)
       dialplan  = args.delete(:dialplan)
       context   = args.delete(:context)
 
       vars = args.map {|k,v| "#{k}=#{v}"}.join(",")
 
-      arg_string = "{#{vars}}" + 
+      arg_string = "{#{vars}}" +
         [url, extension, dialplan, context].compact.join(" ")
-      command "originate", arg_string, &block
+      command "originate", arg_string
     end
 
     # FreeSWITCH control messages.
     # @example
     #   socket.fsctl :hupall, :normal_clearing
     # @see http://wiki.freeswitch.org/wiki/Mod_commands#fsctl
-    def fsctl *args, &block
-      command "fsctl", args.join(" "), &block
+    def fsctl(*args)
+      command "fsctl", args.join(" ")
     end
 
-    def hupall cause=nil, &block
-      command "hupall", cause, &block
+    def hupall(cause = nil)
+      command "hupall", cause
     end
 
     # Park call.
     # @example
     #   socket.uuid_park "592567a2-1be4-11df-a036-19bfdab2092f"
     # @see http://wiki.freeswitch.org/wiki/Mod_commands#uuid_park
-    def uuid_park uuid, &block
-      command "uuid_park", uuid, &block
+    def uuid_park(uuid)
+      command "uuid_park", uuid
     end
 
-    # Bridge two call legs together. At least one leg must be anwered.
+    # Bridge two call legs together. At least one leg must be answered.
     # @example
     #   socket.uuid_bridge "592567a2-1be4-11df-a036-19bfdab2092f", "58b39c3a-1be4-11df-a035-19bfdab2092f"
     # @see http://wiki.freeswitch.org/wiki/Mod_commands#uuid_bridge
-    def uuid_bridge uuid1, uuid2, &block
-      command "uuid_bridge", "#{uuid1} #{uuid2}", &block
+    def uuid_bridge(uuid1, uuid2)
+      command "uuid_bridge", "#{uuid1} #{uuid2}"
     end
   end
 end

data/lib/librevox/listener/base.rb

@@ -1,16 +1,23 @@
-require 'eventmachine'
-require 'librevox/response'
-require 'librevox/commands'
+# frozen_string_literal: true
+
+require 'async/queue'
+require 'async/semaphore'
 
 module Librevox
   module Listener
-    class Base < EventMachine::Protocols::HeaderAndContentProtocol
+    class Base
+      def initialize(connection = nil)
+        @connection = connection
+        @reply_queue = Async::Queue.new
+        @command_mutex = Async::Semaphore.new(1)
+      end
+
       class << self
         def hooks
           @hooks ||= Hash.new {|hash, key| hash[key] = []}
         end
 
-        def event event, &block
+        def event(event, &block)
           hooks[event] << block
         end
       end
@@ -22,12 +29,12 @@ module Librevox
       class CommandDelegate
         include Librevox::Commands
 
-        def initialize listener
+        def initialize(listener)
           @listener = listener
         end
 
-        def command *args, &block
-          @listener.command super(*args), &block
+        def command(*args)
+          @listener.command(super(*args))
         end
       end
 
@@ -41,47 +48,59 @@ module Librevox
         @command_delegate ||= CommandDelegate.new(self)
       end
 
-      def command msg, &block
-        send_data "#{msg}\n\n"
-
-        @command_queue.push(block)
+      def command(msg)
+        @command_mutex.acquire do
+          write "#{msg}\n\n"
+          @reply_queue.dequeue
+        end
       end
 
       attr_accessor :response
-      alias :event :response
-
-      def post_init
-        @command_queue = []
-      end
 
-      def receive_request header, content
-        @response = Librevox::Response.new(header, content)
+      def receive_message(response)
+        @response = response
         handle_response
       end
 
       def handle_response
-        if response.api_response? && @command_queue.any?
-          @command_queue.shift.call(response)
+        if response.reply?
+          @reply_queue.push(response)
+          return
         end
 
         if response.event?
-          on_event(response.dup)
-          invoke_event_hooks
+          resp = response
+          Async do
+            on_event(resp)
+            invoke_event_hooks(resp)
+          end
         end
       end
 
       # override
-      def on_event event
+      def on_event(event)
       end
 
-      alias :done :close_connection_after_writing
+      def write(data)
+        @connection&.write(data)
+      end
+
+      def run_session
+      end
+
+      def disconnect
+        @connection&.close
+      end
 
       private
-      def invoke_event_hooks
-        event = response.event.downcase.to_sym
-        self.class.hooks[event].each {|block|
-          instance_exec(response.dup, &block)
-        }
+
+      def invoke_event_hooks(resp)
+        event_name = resp.event.downcase.to_sym
+        hooks = self.class.hooks[event_name]
+
+        hooks.each do |block|
+          instance_exec(resp, &block)
+        end
       end
     end
   end