event_socket connection lib for twisted python apps

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@5828 d0543943-73ff-0310-b7d9-9358b9ac24b2

scripts/socket/freepy/fshelper.py

@@ -0,0 +1,400 @@
+#!/usr/bin/env python
+
+""" 
+FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+Copyright (C) 2005/2006, Anthony Minessale II <anthmct@yahoo.com>
+
+Version: MPL 1.1
+
+The contents of this file are subject to the Mozilla Public License Version
+1.1 (the "License"); you may not use this file except in compliance with
+the License. You may obtain a copy of the License at
+http://www.mozilla.org/MPL/
+
+Software distributed under the License is distributed on an "AS IS" basis,
+WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+for the specific language governing rights and limitations under the
+License.
+
+The Original Code is FreeSWITCH Modular Media Switching Software Library / Soft-Switch Application
+
+The Initial Developer of the Original Code is
+Anthony Minessale II <anthmct@yahoo.com>
+Portions created by the Initial Developer are Copyright (C)
+the Initial Developer. All Rights Reserved.
+
+Contributor(s): Traun Leyden <tleyden@branchcut.com>
+"""
+
+
+from twisted.internet import reactor, defer
+from twisted.internet.protocol import ClientFactory
+import freepy
+
+class FsHelper(ClientFactory):
+
+    def __init__(self, host=None, passwd=None, port=None):
+        if host:
+            self.host = host
+        if passwd:
+            self.passwd = passwd
+        if port:
+            self.port = port        
+            
+        self.freepyd = None
+        self.connection_deferred = None
+
+    def reset(self):
+        self.freepyd = None
+        self.connection_deferred = None
+        
+    def connect(self):
+            
+        if self.freepyd:
+            # if we have a protocol object, we are connected (since we always
+            # null it upon any disconnection)
+            return defer.succeed("Connected")
+
+        if self.connection_deferred:
+            # we are already connecting, return existing dfrd
+            return self.connection_deferred
+        
+        self.connection_deferred = defer.Deferred()
+        self.connection_deferred.addCallback(self.dologin)
+        self.connection_deferred.addErrback(self.generalError)
+        print "freepy connecting to %s:%s" % (self.host, self.port)
+        reactor.connectTCP(self.host, self.port, self)
+        return self.connection_deferred
+
+    def conncb(self, freepyd):
+        self.freepyd = freepyd
+        deferred2callback = self.connection_deferred
+        self.connection_deferred = None
+        deferred2callback.callback("Connected")
+
+
+    def generalError(self, failure):
+        print "General error: %s" % failure
+        return failure
+
+    def startedConnecting(self, connector):
+        pass
+    
+    def buildProtocol(self, addr):
+        return freepy.FreepyDispatcher(self.conncb, self.discocb)
+    
+    def clientConnectionLost(self, connector, reason):
+        print "clientConnectionLost! conn=%s, reason=%s" % (connector,
+                                                            reason)
+        self.connection_deferred = None        
+        self.freepyd = None
+    
+    def clientConnectionFailed(self, connector, reason):
+        print "clientConnectionFailed! conn=%s, reason=%s" % (connector,
+                                                              reason)
+        self.freepyd = None
+        deferred2callback = self.connection_deferred
+        self.connection_deferred = None                
+        deferred2callback.errback(reason)
+
+    def discocb(self, reason):
+        print "disconnected.  reason: %s" % reason
+        self.freepyd = None
+
+    def dologin(self, connectmsg):
+        return self.freepyd.login(self.passwd)                                     
+
+    def originate(self, party2dial, dest_ext_app, bgapi=True):
+        """
+        party2dial - the first argument to the originate command,
+                     eg, sofia/profile_name/1234@domain.com
+        dest_ext_app - the second argument to the originate command,
+                       eg, &park() or 4761
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  ([(True, 'Reply-Text: +OK Job-UUID: d07ad7de-2406-11dc-aea3-e3b2e56b7a2c')],)
+
+        """
+
+        def originate_inner(ignored):
+            deferreds = []
+            deferred = self.freepyd.originate(party2dial,
+                                              dest_ext_app,
+                                              bgapi)
+            return deferred
+
+        d = self.connect()
+        d.addCallback(originate_inner)
+        return d
+
+
+
+
+    def dialconf(self, people2dial, conf_name, bgapi=True):
+        """
+        conf_name - name of conf TODO: change to match db
+        people2dial - an array of dictionaries:
+                     'name': name
+                     'number': number
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  ([(True, 'Reply-Text: +OK Job-UUID: d07ad7de-2406-11dc-aea3-e3b2e56b7a2c')],)
+
+                  Its a bit ugly because its a deferred list callback.
+
+        """
+
+        def dialconf_inner(ignored):
+            deferreds = []
+            for person2dial in people2dial:
+                sofia_url = person2dial['number']
+                deferred = self.freepyd.confdialout(conf_name,
+                                                    sofia_url,
+                                                    bgapi)
+                deferreds.append(deferred)
+            return defer.DeferredList(deferreds)
+
+        d = self.connect()
+        d.addCallback(dialconf_inner)
+        return d
+
+    def listconf(self, conf_name):
+        """
+        conf_name - name of conf 
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  TODO: add this
+        """
+        def listconf_inner(ignored):
+            deferred = self.freepyd.listconf(conf_name)
+            return deferred
+
+        d = self.connect()
+        d.addCallback(listconf_inner)
+        return d
+
+    def confkick(self, member_id, conf_name, bgapi=True):
+        """
+        conf_name - name of conf
+        member_id - member id of user to kick, eg, "7"
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  TODO: add this
+        """
+        def confkick_inner(ignored):
+            #if type(member_id) == type(""):
+            #    member_id = int(member_id)
+            deferred = self.freepyd.confkick(member_id, conf_name, bgapi)
+            return deferred
+
+        d = self.connect()
+        d.addCallback(confkick_inner)
+        return d
+
+    def confdtmf(self, member_id, conf_name, dtmf, bgapi=True):
+        """
+        Send dtmf(s) to a conference
+        conf_name - name of conf
+        member_id - member id of user to kick, eg, "7", or "all"
+        dtmf - a single dtmf or a string of dtms, eg "1" or "123"
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  TODO: add this
+        """
+        def confdtmf_inner(ignored):
+            print "confdtmf_inner called"
+            deferred = self.freepyd.confdtmf(member_id, conf_name, dtmf, bgapi)
+            return deferred
+
+        d = self.connect()
+        d.addCallback(confdtmf_inner)
+        return d
+
+
+    def confsay(self, conf_name, text2speak, bgapi=True):
+        """
+        conf_name - name of conf
+        text2speak - text to speak
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  TODO: add this
+        """
+        def confsay_inner(ignored):
+            deferred = self.freepyd.confsay(conf_name, text2speak, bgapi)
+            return deferred
+
+        d = self.connect()
+        d.addCallback(confsay_inner)
+        return d
+
+    def confplay(self, conf_name, snd_url, bgapi=True):
+        """
+        conf_name - name of conf
+        snd_url - url to sound file
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  TODO: add this
+        """
+        def confplay_inner(ignored):
+            deferred = self.freepyd.confplay(conf_name, snd_url, bgapi)
+            return deferred
+
+        d = self.connect()
+        d.addCallback(confplay_inner)
+        return d
+
+    def confstop(self, conf_name, bgapi=True):
+        """
+        stop playback of all sounds
+        
+        conf_name - name of conf
+        returns - a deferred that will be called back with a result
+                  like:
+
+                  TODO: add this
+        """
+        def confstop_inner(ignored):
+            deferred = self.freepyd.confstop(conf_name, bgapi)
+            return deferred
+
+        d = self.connect()
+        d.addCallback(confstop_inner)
+        return d
+
+
+    def showchannels(self, bgapi=True):
+
+        def showchannels_inner(ignored):
+            df = self.freepyd.showchannels(bgapi)
+            return df
+
+        d = self.connect()
+        d.addCallback(showchannels_inner)
+        return d
+
+    def killchan(self, uuid, bgapi=True):
+
+        def killchan_inner(ignored):
+            df = self.freepyd.killchan(uuid, bgapi)
+            return df
+
+        d = self.connect()
+        d.addCallback(killchan_inner)
+        return d
+
+
+    def sofia_profile_restart(self, profile_name, bgapi=True):
+
+        def sofia_profile_restart_inner(ignored):
+            df = self.freepyd.sofia_profile_restart(profile_name,
+                                                    bgapi)
+            return df
+
+        d = self.connect()
+        d.addCallback(sofia_profile_restart_inner)
+        return d
+
+
+    def sofia_status_profile(self, profile_name, bgapi=True):
+
+        def sofia_status_profile_inner(ignored):
+            df = self.freepyd.sofia_status_profile(profile_name,
+                                                    bgapi)
+            return df
+
+        d = self.connect()
+        d.addCallback(sofia_status_profile_inner)
+        return d
+
+
+class FsHelperTest:
+    def __init__(self, fshelper):
+        self.fshelper=fshelper
+        pass
+
+    def test_dialconf(self):
+
+        people2dial = [{'name':'freeswitch',
+                        'number':'888@conference.freeswitch.org'},
+                       {'name':'mouselike',
+                        'number':'904@mouselike.org'}]
+        d = self.fshelper.dialconf(people2dial, "freeswitch", bgapi=False)
+        def failed(error):
+            print "Failed to dial users!"
+            reactor.stop()
+            return error
+        d.addErrback(failed)
+        def worked(*args):
+            print "Worked! Dialed user result: %s" % str(args)
+            #reactor.stop()
+        d.addCallback(worked)        
+        return d
+
+    def test_listconf(self):
+
+        d = self.fshelper.listconf("freeswitch")
+        def failed(failure):
+            print "Failed to list users!"
+            reactor.stop()
+            return failure
+        d.addErrback(failed)
+        def worked(*args):
+            print "List of users in conf: %s" % str(args)
+            return args[0]
+        d.addCallback(worked)
+        return d
+
+    def test_confkick(self, member_id="6", conf_name="freeswitch"):
+
+        d = self.fshelper.confkick(member_id, conf_name)
+        def failed(failure):
+            print "Failed to kick user!"
+            reactor.stop()
+            return failure
+        d.addErrback(failed)
+        def worked(*args):
+            print "Kicked user from conf, result: %s" % str(args)
+        d.addCallback(worked)
+        
+
+def test1():
+    kick_everyone = False
+    fshelper = FsHelper("mydomain.com")
+    fsht = FsHelperTest(fshelper)
+    fsht.test_dialconf()
+    d = fsht.test_listconf()
+    def kickeveryone(members):
+        print "Kickeveryone called w/ %s (type: %s)" % (members,
+                                                        type(members))
+        for member in members:
+            fsht.test_confkick(member.member_id)
+
+    def failed(failure):
+        print "failed: %s" % str(failure)
+        reactor.stop()
+    if kick_everyone:
+        d.addCallback(kickeveryone)        
+        d.addErrback(failed)
+    #fsht.test_confkick()
+    #d = fshelper.connect()
+    #def connected(*args):
+    #    fsht.test_dialconf()
+    #    fsht.test_listconf()
+    #d.addCallback(connected)
+    reactor.run()
+
+def test2():
+    fshelper = FsHelper("mydomain.com")
+    fshelper.sofia_profile_restart("mydomain.com")
+    reactor.run()    
+    
+if __name__=="__main__":
+    #test1()
+    test2()