cl("Already registered") return threadHandle else: cl("New listener") existingProcessor.addListener(newProcessor) self.thread2ClientId[threadHandle].append(clientId) return clientId else: cl("New Processor") self.thread2ClientId[threadHandle] = [clientId] self.thread2Processor[threadHandle] = newProcessor newProcessor.start() #newProcessor.msg("subClassRun", {}) ncl('returnning:', threadHandle) return threadHandle def getThreadInst(self, threadHandle): return self.thread2Processor[threadHandle] def stop(self): cl('-----------------------exist server called') for threadHandle in self.thread2Processor: self.thread2Processor[threadHandle].msg("exitThread", {}) stop.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(xmlRpcServerWithThread(gXmlRpcServerPort))
class folderInfoStorageServer(threadSvrBase.xmlRpcServerWithThread): ''' classdocs ''' def __init__(self, port): ''' Constructor ''' super(folderInfoStorageServer, self).__init__(port) def create(self, outputFolder, rootPath): threadInst = workThread(outputFolder, rootPath) clientId = self.createProcessor(threadInst) ncl(clientId) threadInst.msg("gen", {}) return "OK" create.exposed = True def notify(self, param): cl(param) threadInst = self.getThreadInst(param.replace("folder://", "recursive://")) threadInst.msg("scanComplete", {}) notify.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(folderInfoStorageServer(gXmlRpcServerPort))
if newObjUuid is None: cl("item deleted, do not add it") continue ncl('before update obj uuid') ''' collection.updateObjUuidIfNeeded(itemUrl, newObjUuid) ''' if collection.isSame(objInCol, newObjUuid): ncl("no updates needed", objInCol, newObjUuid) continue collection.updateObjUuidRaw(objInCol, newObjUuid) ncl('new item added', objInCol) cl("notifying listener") self.notifyAll() class collectionManagementServer(xmlRpcServerWithWorkerThreadBase.xmlRpcServerWithWorkerThreadBase): def register(self, monitorUrl, xmlRpcServerUrl, dbPrefix = ""): #paramDict = {"rootFolder": monitorUrl, "serverUrl": xmlRpcServerUrl} newProcessor = dirScanner(monitorUrl, xmlRpcServerUrl, dbPrefix) targetCallbackServerUrl = self.createProcessor(newProcessor) if targetCallbackServerUrl == newProcessor.getFirstCallbackServerUrl(): newProcessor.msg("subClassRun", {}) return newProcessor.getThreadHndl() register.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(collectionManagementServer(8808))
def sampleMethodInternal(self, clientId): #Server will send message to this class and the #parent class will generate call to member in #a message loop print "Sample method called:", clientId class sampleServer(threadSvrBase.xmlRpcServerWithThread): ''' classdocs ''' def __init__(self, port): ''' Constructor ''' super(sampleServer, self).__init__(port) def sampleCreateOnServer(self): threadInst = sampleThread(clientId = "helloworld") return self.createProcessor(threadInst) sampleCreateOnServer.exposed = True def sampleMethod(self, threadHandle, clientId = "helloworld"): cl(threadHandle, clientId) t = self.thread2Processor[(threadHandle)] t.msg("sampleMethod", {"clientId":clientId}) sampleMethod.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(sampleServer(gXmlRpcServerPort))
classdocs ''' def __init__(self, port): super(XmlRpcServer2BeanstalkdServiceBridge, self).__init__(port) self.beanstalkd_service_command_tube_names = [] self.beanstalk = None def get_beanstalkd_instance(self): if self.beanstalk is None: self.beanstalk = beanstalkc.Connection(host=gBeanstalkdServerHost, port=gBeanstalkdServerPort) return self.beanstalk self.beanstalk.ignore('default') def subscribe(self, beanstalkd_tube_name): self.beanstalkd_service_command_tube_names.append(beanstalkd_tube_name) return "added: "+beanstalkd_tube_name subscribe.exposed = True def stop(self): #Send messages to all beanstalkd service for i in self.beanstalkd_service_command_tube_names: print "add item to tube:", i stop_beanstalkd_service(i, self.get_beanstalkd_instance()) stop.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(XmlRpcServer2BeanstalkdServiceBridge(gXmlRpcServerPort))
def __init__(self, port): ''' Constructor ''' xmlRpcServerWithWorkerThreadBase.xmlRpcServerWithWorkerThreadBase.__init__(self, port) self.threadList = list() #Create a sync service def addSync(self, taskUuid, folderPath, encZipPath, passwd, workingPath): threadInst = syncThread(taskUuid, folderPath, encZipPath, passwd, workingPath) self.createProcessor(threadInst) #Add additional notify info so the notification from dir scanner #will be dispatched to specific thread encZipPathMonitorUrl, folderPathMonitorUrl = threadInst.getNotificationHandler() self.threadList.append((encZipPathMonitorUrl, folderPathMonitorUrl, threadInst)) addSync.exposed = True def notify(self, notifyParam): cl("notify called", notifyParam) for i in self.threadList: if (i[0] == notifyParam) or (i[1] == notifyParam): i[2].msg("subClassRun", {"notificationSource": notifyParam}) notify.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(syncXmlRpcServer(8807))
yield objInCol folderObj = self.objDb.getFsObjFromFullPath(self.rootFolder) self.objDb.updateObjByUuid(folderObj["uuid"], {"folderCollectionId": self.targetCollectionId}) cl(folderObj, {"folderCollectionId": self.targetCollectionId}) class folderCollectionServer(threadSvrBase.notifierServer): ''' classdocs ''' def __init__(self, port): ''' Constructor ''' super(folderCollectionServer, self).__init__(port) def create(self, rootPath, retNum, username, passwd, notifyServer = None): threadInst = workThread(rootPath, username, passwd, notifyServer = notifyServer) res = threadInst.getPartialResult(retNum) clientId = self.createProcessor(threadInst) ncl(clientId) threadInst.msg("gen", {}) return threadInst.partialRes create.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(folderCollectionServer(gXmlRpcServerPort))
self.threadHndl2ProcessorListDict[threadHandle] = [callbackServerUrl] self.threadHndlAndProcessorHndl2ThreadDict[(threadHandle, callbackServerUrl)] = newProcessor newProcessor.start() #newProcessor.msg("subClassRun", {}) cl('returnning:', callbackServerUrl) return callbackServerUrl def stop(self): cl('-----------------------exist server called') for callbackHndl in self.threadHndl2ProcessorListDict: self.threadHndlAndProcessorHndl2ThreadDict[(callbackHndl, self.threadHndl2ProcessorListDict[callbackHndl][0])].msg("exitThread", {}) stop.exposed = True def register(self, serverUrl): paramDict = {"serverUrl": serverUrl} newProcessor = serverThread(paramDict) return self.createProcessor(newProcessor) register.exposed = True def complete(self, threadHandle, processorHndl): cl(threadHandle, processorHndl) t = self.threadHndlAndProcessorHndl2ThreadDict[(threadHandle, processorHndl)] t.complete(processorHndl) complete.exposed = True if __name__ == '__main__': # Set up site-wide config first so we get a log if errors occur. xmlRpcServerBase.startMainServer(xmlRpcServerWithWorkerThreadBase(gXmlRpcServerPort))