def modifyDB(self, ret, cmd, *params):
        abspath = os.path.join(self.shell._path(self.workingDirectory).path, params[0])
        abspath = re.sub(r'\\+', '/', abspath)
        logging.getLogger("twisted").debug(cmd + abspath)
        #print cmd, abspath.decode('utf-8').encode('gbk')
        def printValue(value):
            logging.getLogger("twisted").debug("return:"+value)
        def printErr(e):
            logging.getLogger("twisted").debug("Err:" + e)
        from twisted.web.xmlrpc import Proxy
        try:
            proxy = Proxy('http://localhost:9999/rpc/')
            if cmd == 'del':
                method = 'deleted'
            elif cmd == 'stor':
                method = 'uploaded'
            else:
                print "unexpected db operation"
                return ret
            logging.getLogger("twisted").debug("before remote "+ method)

            print method, abspath.decode('utf-8').encode('gbk')
            proxy.callRemote(method, self.portal.realm.username, abspath).addCallbacks(printValue, printErr)   
        except Exception, e:
            logging.getLogger("twisted").debug(e)

def outputlevels(levellist,twisted=0,clientid=_id):
    """present a list of dmx channel levels, each scaled from
    0..1. list can be any length- it will apply to the first len() dmx
    channels.

    if the server is not found, outputlevels will block for a
    second."""

    global _dmx, _id

    if _dmx is None:
        url = networking.dmxServer.url
        if not twisted:
            _dmx = xmlrpclib.Server(url)
        else:
            from twisted.web.xmlrpc import Proxy
            _dmx = Proxy(url)

    if not twisted:
        try:
            _dmx.outputlevels(clientid, levellist)
        except socket.error, e:
            print "dmx server error %s, waiting" % e
            time.sleep(1)
        except xmlrpclib.Fault,e:
            print "outputlevels had xml fault: %s" % e
            time.sleep(1)

class AddDiary:

    def __init__(self, name, password):
        self.name = name
        self.password = password
        self.proxy = Proxy('http://advogato.org/XMLRPC')

    def __call__(self, filename):
        self.data = open(filename).read()
        d = self.proxy.callRemote('authenticate', self.name, self.password)
        d.addCallbacks(self.login, self.noLogin)

    def noLogin(self, reason):
        print("could not login")
        reactor.stop()

    def login(self, cookie):
        d = self.proxy.callRemote('diary.set', cookie, -1, self.data)
        d.addCallbacks(self.setDiary, self.errorSetDiary)

    def setDiary(self, response):
        reactor.stop()

    def errorSetDiary(self, error):
        print("could not set diary", error)
        reactor.stop()

    def uploadImage(self, name, data):
        exception = self.master.modules["commands"].exception

        user = yield self.config.get("user")
        passwd = yield self.config.get("pass")
        if user is None or passwd is None:
            raise exception(u"No blog username or password in config")

        blog = Proxy("http://commiesubs.com/xmlrpc.php")
        blog.queryFactory.noisy = False

        try:
            data = yield blog.callRemote("wp.uploadFile",
                0, # Blog ID
                user, # Username
                passwd, # Password
                { # Content
                    "name": name,
                    "type": "image/jpeg",
                    "bits": xmlrpclib.Binary(data),
                    "overwrite": True
                }
            )
        except:
            raise exception(u"Couldn't upload image")

        returnValue(data["url"])

 def _callRemote(self, method, *args, **kwds):
     proxy = Proxy("http://%s/XMLRPC" % self.host, user=self.username,
         password=self.password, allowNone=True)
     deferred = proxy.callRemote(method, *args, **kwds)
     deferred.addCallbacks(self.onResult, self.onError)
     deferred.addCallbacks(self._stopReactor, self._stopReactor)
     reactor.run()
     return 0

 def run(self):
     proxy = Proxy("http://%s/XMLRPC" % self.host, user=self.username,
         password=self.password, allowNone=True)
     deferred = proxy.callRemote('iterEvents', self.query, None, self.indices,
         self.limit, self.reverse, self.fields)
     deferred.addCallback(self.printResult)
     deferred.addErrback(self.printError)
     reactor.run()
     return 0

 def reload(self):
     if self._deferred != None:
         self._deferred.cancel()
     self._results.clear()
     proxy = Proxy(self._url, user=self._user, password=self._pass, allowNone=True)
     self._deferred = proxy.callRemote('iter', self._query)
     self._deferred.addCallback(self._getResult)
     self._deferred.addErrback(self._getError)
     logger.debug("searching with query '%s'" % self._query)

 def retryWithOtherProvider(self, error, nodeConfig, words, docId, filename):
     if self.providerSet:
         nextHost, nextPort = self.providerSet.pop()
         print "[webapp] trying to donwload %r from %s:%s" % (filename, nextHost, nextPort)
         proxy = Proxy(str('http://%s:%s' % (nextHost, nextPort)))
         d = proxy.callRemote('downloadFile', docId, words)
         d.addCallback(self.gotDataBack, nodeConfig, filename, words)
         d.addErrback(self.retryWithOtherProvider, nodeConfig, words, docId, filename)
         return d
     else:
         return self.onDownloadFileError('no provider available', filename)

    def _createPost(self, show, episode, version, info_link, img_link, comment = None, hovertext = None, retries = 0, retryer = None):
        exception = self.master.modules["commands"].exception

        end = " END" if episode == show.episode.total else ""
        title = u"{} {:02d}{}{}".format(show.name.english, episode, version, end)

        img_type = 'video loop="loop" onmouseover="this.play()" onmouseout="this.pause()"' if img_link.endswith("webm") else 'img'
        img = '<{} src="{}" title="{}" style="width: 100%; border-radius: 5px;" />'.format(img_type, img_link, "" if hovertext is None else hovertext.replace('"', '&quot;'))
        comment = "<br><br>{}".format(comment.encode("utf8")) if comment is not None else ""

        user = yield self.config.get("user")
        passwd = yield self.config.get("pass")
        if user is None or passwd is None:
            raise exception(u"No blog username or password in config")

        blog = Proxy("http://commiesubs.com/xmlrpc.php")
        blog.queryFactory.noisy = False
        slug = re.search("([^/]+)/?$", show.blog).group(1)
        categories = ["Releases"] #, "DxS a shit"]
        result = yield blog.callRemote("wp.getTerms", 0, user, passwd, "category")
        for term in result:
            if term["slug"] == slug:
                categories.append(term["name"])

        try:
            post_id = yield blog.callRemote("wp.newPost",
                0, # Blog ID
                user, # Username
                passwd, # Password
                { # Content
                    "post_type": "post",
                    "post_status": "publish",
                    "comment_status": "open",
                    "post_title": title.encode("utf8"),
                    "post_content": "{}<br><br><a href=\"{}\">Torrent</a>{}".format(img, info_link, comment),
                    "terms_names": {"category": categories}
                }
            )
        except Exception as e:
            if retries:
                self.master.modules["irc"].msg(u"#commie-staff", u"Failed to make blog post ({}), retrying in a minute. This was attempt #{:,d}".format(title, retries))
            raise e

        try:
            data = yield blog.callRemote("wp.getPost", 0, user, passwd, int(post_id))
        except:
            link = "<unknown url>"
        else:
            link = data["link"]

        if retries:
            self.master.modules["irc"].msg(u"#commie-staff", u"Created blog post ({}): {}".format(title, link))
        returnValue(link)

    def test_inbound_request_and_reply(self):
        address = self.transport.xmlrpc_server.getHost()
        url = 'http://' + address.host + ':' + str(address.port) + '/foo/'
        proxy = Proxy(url)
        x = proxy.callRemote('handleUSSD', {
            'TransactionId': '0001',
            'USSDServiceCode': '543',
            'USSDRequestString': '14321*1000#',
            'MSISDN': '275551234',
            'USSDEncoding': 'GSM0338',      # Optional
            'TransactionTime': '2013-07-05T22:58:47.565596'
            })
        [msg] = yield self.tx_helper.wait_for_dispatched_inbound(1)
        expected_inbound_payload = {
            'message_id': '',
            'content': None,
            'from_addr': '',    # msisdn
            'to_addr': '',      # service code
            'session_event': TransportUserMessage.SESSION_RESUME,
            'transport_name': self.tx_helper.transport_name,
            'transport_type': 'ussd',
            'transport_metadata': {
                'mtn_rwanda_ussd': {
                    'transaction_id': '0001',
                    'transaction_time': '2013-07-05T22:58:47.565596',
                },
            },
        }
        yield self.assert_inbound_message(
            expected_inbound_payload,
            msg,
            from_addr='275551234',
            to_addr='543',
            session_event=TransportUserMessage.SESSION_NEW)

        expected_reply = {'MSISDN': '275551234',
                          'TransactionId': '0001',
                          'TransactionTime': datetime.now().isoformat(),
                          'USSDEncoding': 'GSM0338',
                          'USSDResponseString': 'Test message',
                          'USSDServiceCode': '543',
                          'action': 'end'}

        self.tx_helper.make_dispatch_reply(
            msg, expected_reply['USSDResponseString'], continue_session=False)

        received_text = yield x
        for key in received_text.keys():
            if key == 'TransactionTime':
                self.assertEqual(len(received_text[key]),
                        len(expected_reply[key]))
            else:
                self.assertEqual(expected_reply[key], received_text[key])

 def start(self):
     proxy = Proxy("http://beatty.userland.com/RPC2")
     if TEST_ERRORS:
         i = self.i
         if i == 3:
             proxy = Proxy("http://illegal-host_name/")
         elif i == 6:
             proxy = Proxy("http://beatty.userland.com/")
         elif i == 8:
             proxy = Proxy("http://beatty.userland.com/testing_xmlrpc_error_case")
         
     return proxy.callRemote('examples.getStateName', self.i)

 def relayAnswer(self, answer, local=False): # local still unused
     """record and forward answers to a query.
     If local is True, then the answers come from a local query,
     and thus must not be recorded in the database"""
     print "P2pQuerier relayAnswer : %s documents" % len(answer.documents)
     query = self._receivedQueries.get(answer.queryId)
     if query:
         print " ... relaying Answer to originator ..."
     else:
         query = self._sentQueries.get(answer.queryId)
         if query:
             print " ... originator : we got mail :) ... "
         else:
             print " ... bailing out (bug?) : we had no query for this answer"
             return
     
     toSend = []
     
     for document in answer.documents:
         if not isinstance(document, dict):
             document = document.__dict__
         # TODO: record answer in database if local is False
         # auc : to cache them ?
         if not query.isKnown(document):
             abstract = makeAbstract(document['text'], query.getWords())
             document['text'] = untagText(removeSpace(abstract))
             query.addMatch(document)
             #toSend.append(document.asDictionnary())
             # above was meant to be like .asKwargs() ?
             # anyway, this stuff is xmlrpc-serializable (auc)
             toSend.append(document)
     
     if query.sender != self.nodeId: 
         try:
             # getNodeUrl seems not to exist yet
             #senderUrl = self.querier.getNodeUrl(query.sender)
             host = query.host 
             port = query.port
             print " ... will send answer to %s:%s" % (host, port)
             senderUrl = 'http://%s:%s' % (host, port)
             proxy = Proxy(senderUrl)
             d = proxy.callRemote('distributedQueryAnswer',
                                  query.qid,
                                  self.nodeId,
                                  toSend)
             d.addCallback(self.querier.registerNodeActivity)
             d.addErrback(P2pErrbacks.answerQueryProblem)
             P2pErrbacks.setAnswerTarget(senderUrl)
         except ValueError:
             print "unknown node %s" % query.sender
     else: # local would be true ? don't waste the answers ...
         self._notifyAnswerCallbacks(answer.queryId, toSend)

    def locateChild(self, request, segments):

        for filter in self.contentFilters:
            request.addResponseFilter(filter[0], atEnd=filter[1])

        # Examine cookies for wiki auth token; if there, ask the paired wiki
        # server for the corresponding record name.  If that maps to a
        # principal, assign that to authnuser.

        if not hasattr(request, "checkedWiki"):
            # Only do this once per request
            request.checkedWiki = True

            wikiConfig = config.Authentication.Wiki
            cookies = request.headers.getHeader("cookie")
            if wikiConfig["Enabled"] and cookies is not None:
                for cookie in cookies:
                    if cookie.name == wikiConfig["Cookie"]:
                        token = cookie.value
                        break
                else:
                    token = None

                if token is not None and token != "unauthenticated":
                    log.debug("Wiki sessionID cookie value: %s" % (token,))
                    proxy = Proxy(wikiConfig["URL"])
                    try:
                        username = (yield proxy.callRemote(wikiConfig["UserMethod"], token))
                    except Exception, e:
                        log.error("Failed to look up wiki token (%s)" % (e,))
                        username = None

                    if username is not None:
                        log.debug("Wiki lookup returned user: %s" % (username,))
                        principal = None
                        directory = request.site.resource.getDirectory()
                        record = directory.recordWithShortName("users", username)
                        log.debug("Wiki user record for user %s : %s" % (username, record))
                        if record:
                            # Note: record will be None if it's a /Local/Default user
                            for collection in self.principalCollections():
                                principal = collection.principalForRecord(record)
                                if principal is not None:
                                    break

                        if principal:
                            log.debug("Wiki-authenticated principal %s being assigned to authnUser" % (record.guid,))
                            request.authzUser = request.authnUser = davxml.Principal(
                                davxml.HRef.fromString("/principals/__uids__/%s/" % (record.guid,))
                            )

 def render_GET(self, request):
     key = request.args.get('key', [None])[0]
     if key is None or key != xml_key:
         return "fail"
     proxy = Proxy(xml_source)
     op = request.args.get('op', [None])[0]
     if op is not None:
         if op == 'store':
             proxy.callRemote(xml_method, xml_login, xml_password).addCallbacks(self.storeDocs, self.pr)
         elif op == 'compare' or op == 'update':
             proxy.callRemote(xml_method, xml_login, xml_password).addCallbacks(self.compareDocs, self.pr)
         elif op == 'descr':
             print "try to store"
             self.storeDescription(request)
     return "ok"

def cmd_search(request, text):
    if len(text) > 2048:
        defer.returnValue(dict(ok=False, desc='Search query is too long.'))
    service = Proxy('http://127.0.0.1:%d/' % config.search_port)
    start = time.time()
    try:
        result = yield service.callRemote('search', text)
    except Exception:
        log.msg('SEARCH ERROR:\n\n' + traceback.format_exc())
        defer.returnValue(dict(ok=False, desc='Sorry, search not available.'))

    t = time.time() - start
    log.msg('Queried "%s" by %s. Found %s results in %.3fs.' % (
        text, request.user['name'], result[0], t))
    defer.returnValue(dict(ok=True, format='search', search_result=result))

def playMusic():
    if request.method == 'POST':
        form=request.form
        tag =  [form.get(val) for val in ['tag']]
        print tag

        api=API8tracks(config.api_8tracks)

        mixset = api.mixset(tags=tag, sort='popular')
        print mixset
        url= "http://streamTaMaman.wav" # [stream.data['track_file_stream_url'] for stream in mixset.mixes[0].tracks_cache]
        proxy = Proxy('http://'+str(config.main_server.ip)+':'+str(config.main_server.rpc_port))
        proxy.callRemote('raspi.find_music_url',0,url).addCallbacks(return_value)
        reactor.run()
        # TODO : this is blocking, warning!!
    return json.dumps("haha")

    def __init__(self, server, **kwargs):
        self.next_id = 1000
        self.name = kwargs.get('name','Flickr')
        self.proxy = kwargs.get('proxy','false')
        self.refresh = int(kwargs.get('refresh',60))*60
        if self.proxy in [1,'Yes','yes','True','true']:
            self.proxy = True
        else:
            self.proxy = False

        self.urlbase = kwargs.get('urlbase','')
        if( len(self.urlbase)>0 and
            self.urlbase[len(self.urlbase)-1] != '/'):
            self.urlbase += '/'

        ignore_patterns = kwargs.get('ignore_patterns',[])
        ignore_file_pattern = re.compile('|'.join(['^\..*'] + list(ignore_patterns)))

        self.server = server
        self.update_id = 0
        self.flickr = Proxy('http://api.flickr.com/services/xmlrpc/')
        self.flickr_api_key = '837718c8a622c699edab0ea55fcec224'
        self.store = {}

        self.refresh_store_loop = task.LoopingCall(self.refresh_store)
        self.refresh_store_loop.start(self.refresh, now=False)

        louie.send('Coherence.UPnP.Backend.init_completed', None, backend=self)

 def test_inbound_faulty_request(self):
     address = self.transport.xmlrpc_server.getHost()
     url = 'http://' + address.host + ':' + str(address.port) + '/foo/'
     proxy = Proxy(url)
     try:
         yield proxy.callRemote('handleUSSD', {
             'TransactionId': '0001',
             'USSDServiceCode': '543',
             'USSDRequestString': '14321*1000#',
             'MSISDN': '275551234',
             'USSDEncoding': 'GSM0338',
         })
         [msg] = yield self.tx_helper.wait_for_dispatched_inbound(1)
     except xmlrpclib.Fault, e:
         self.assertEqual(e.faultCode, 8002)
         self.assertEqual(e.faultString, 'error')

 def setUp(self):
     self.root = resource.buildResource('127.0.0.1:99999')
     self.site = Site(self.root) # TODO: what is timeout?
     self.serv = reactor.listenTCP(0, self.site, interface='127.0.0.1')
     P = self.serv.getHost().port
     url = 'http://127.0.0.1:%d/cgi-bin/ArchiveDataServer.cgi'%P
     self.client = Proxy(url)

 def __init__(self, url):
     """
     Initialize the store. 
     """
     self.store=dict()
     self.url=url
     self.proxy=Proxy(self.url)
     self.error=False