示例#1
0
文件: Pinger.py 项目: sys-git/PyRQ
    def run(self):
        host = self._qs.details().host()
        port = self._qs.details().port()
        sys.stderr.write("Pinger listening on %(H)s:%(P)s with q: %(Q)s...\r\n"%{"Q":self._qRx, "H":host, "P":port})
        try:
            while True:
                #   Ping everything back!
                try:
                    data = self._qRx.get(block=True, timeout=1)
                except Empty, _e:
                    pass
                else:
#                    pydevd.settrace(stdoutToServer = True, stderrToServer = True)
                    sys.stderr.write("Pinger got data: %(D)s...\r\n"%{"D":data})
                    if isinstance(data, Ping):
                        replyTo = data.replyTo()
                        host = replyTo.host()
                        port = replyTo.port()
                        quiet = data.quiet()
                        if not quiet: sys.stderr.write("Pinger pinging data back to %(H)s:%(P)s\r\n"%{"H":host, "P":port})
                        m = MarshallerFactory.get(MarshallerFactory.DEFAULT)
                        qw = QueueWriter(target=replyTo, autoConnect=True, marshaller=m)
                        qw.put(Ping(data=data.data()))
        except Exception, _e:
            sys.stderr.write("Pinger got error: %(D)s...\r\n"%{"D":traceback.format_exc()})
示例#2
0
 def _onTest(self):
     quiet=self._parent.debugger.quiet
     iface = QueueWriter( target=self._parent.details,
                          autoConnect=True,
                          marshaller=MarshallerFactory.get(MarshallerFactory.DEFAULT, quiet=quiet),
                          quiet=quiet)
     iface.start()
     iface.put(DEBUG_SOMETHING())
     iface.close()
示例#3
0
 def __init__(self, peerName, theTime, details, quiet):
     self._peerName = peerName
     self._methods = []
     methods = iMockDebuggerSink()._getMethods()
     self._methods = methods
     self._terminate = False
     self._details = details
     self._qw = None
     self._startMutex = Semaphore(0)
     self._q = Queue()
     self.quiet= quiet
     self._marshaller = MarshallerFactory.get(MarshallerFactory.DEFAULT, quiet=quiet)
     self._qw = QueueWriter(target=details, autoConnect=True, marshaller=self._marshaller, quiet=quiet)
     self._qw.start()
     self.thread = None
示例#4
0
class ServerSink(iMockDebuggerSink):
    def __init__(self, peerName, theTime, details, quiet):
        self._peerName = peerName
        self._methods = []
        methods = iMockDebuggerSink()._getMethods()
        self._methods = methods
        self._terminate = False
        self._details = details
        self._qw = None
        self._startMutex = Semaphore(0)
        self._q = Queue()
        self.quiet= quiet
        self._marshaller = MarshallerFactory.get(MarshallerFactory.DEFAULT, quiet=quiet)
        self._qw = QueueWriter(target=details, autoConnect=True, marshaller=self._marshaller, quiet=quiet)
        self._qw.start()
        self.thread = None
    def start(self):
        t = threading.Thread(target=self.run, args=[self._startMutex])
        t.setName("ServerSink.%(P)s"%{"P":self._peerName})
        t.setDaemon(True)
        self.thread = t
        self.thread.start()
        return "server.sink.started"
    def close(self):
        self._terminate = True
        try:    self.thread.join()
        except: pass
        try:    self._qw.close()
        except: pass
        try:    self._q.close()
        except: pass
        return "server.sink.closed"
    def waitUntilRunning(self, block=True, timeout=None):
        self._startMutex.acquire(block=block, timeout=timeout)
        return self
    def __getattribute__(self, name):
        if name in object.__getattribute__(self, "_methods"):
            q = self._q
            def wrapper(self, *args, **kwargs):
                ServerSink._testPickleability((name, args, kwargs))
                q.put((name, args, kwargs))
            return wrapper
        return object.__getattribute__(self, name)
    def run(self, startMutex):
        startMutex.release()
        while self._terminate==False:
            try:
                data = self._q.get(block=True, timeout=1)
            except Empty:   pass
            else:
                ServerSink._testPickleability(data)
                try:
                    self._qw.put(data, block=True, timeout=10)
                except Exception, _e:
                    break
示例#5
0
def _loadHost(options, handlerClazz, **kwargs):
    servicesClazzpath = options.servicesClazzpath
    servicesClazz = options.servicesClazz
    quiet = options.quiet
    if (servicesClazzpath!=None) and (len(servicesClazzpath)>0) and (servicesClazz!=None) and (len(servicesClazz)>0):
        services = _importModule(options.servicesClazzpath, options.servicesClazz)
        from PyRQ import PyRQTimeUtils
        PyRQTimeUtils.set_getTime(services.getSystemUptimeInteger)
        PyRQTimeUtils.set_delayTime(services.timeSleep)
        b = PyRQTimeUtils.getTime()
        if not quiet: sys.stderr.write("subprocess getTime()...%(T)s\r\n"%{"T":b})
    if options.handlerClazz!=None:
        handlerClazz = _getClass(options.handlerClazz)
        hC = Linkage.create(handlerClazz)
    else:
        msg = "No HandlerClazz specified!!!"
        sys.stderr.write(msg)
        raise Exception(msg)
#        hC = Linkage.create(RRQHandler)
#        handlerClazz = _getClass(".".join([hC.clazzpath(), hC.clazz()]))
    if not quiet: sys.stderr.write("BootQueueServer::handlerClazz... %(H)s  .  %(P)s\r\n"%{"H":hC.clazzpath(), "P":hC.clazz()})
    from multiprocessing.queues import Queue
    mt = options.marshallerType
    mt = int(mt)
    target=Queue()
    kwargs["maxClients"] = options.maxClients
    kwargs["quiet"] = quiet
    kwargs["recvChunkSize"] = int(options.socketRecvChunkSize)
    kwargs["readTimeout"] = int(options.socketReadTimeout)
    kwargs["loggerModule"] = _loadLoggingModule(options.loggingModule)
    qs = QueueServer(host=options.host,
                     port=options.port,
                     marshaller=MarshallerFactory.get(mt, quiet=quiet),
                     target=target,
                     handlerClazz=handlerClazz,
                     **kwargs)
    qs.start().waitUntilRunning()
    if options.ackHost and options.ackPort:
        #    Send the ack back!
        if not quiet: sys.stderr.write("BootQueueServer::load...[0.1]: %(H)s:%(P)s[1]\r\n"%{"H":options.ackHost, "P":options.ackPort})
        from PyRQ.Core.QueueWriter.QueueWriter import QueueWriter
#        import pydevd
#        pydevd.settrace(stdoutToServer = True, stderrToServer = True)
        qw = QueueWriter(target=QueueServerDetails(options.ackHost, options.ackPort),
                        marshaller=MarshallerFactory.get(mt, quiet=quiet),
                        autoConnect=True,
                        sockTimeout=10,
                        quiet=quiet
                        )
        if not quiet: sys.stderr.write("BootQueueServer::load...[1.0]\r\n")
        qw.start()
        details = qs.details()
        if not quiet: sys.stderr.write("BootQueueServer::load...[1.2]: %(D)s\r\n"%{"D":details})
        qw.put(details)
        if not quiet: sys.stderr.write("BootQueueServer::load...[1.2]\r\n")
    #    Now we have a queue which we can use to receive messages on:    'target'.
    importedModule = None
    if options.clazzpath!=None and options.clazz!=None:
        if not quiet: sys.stderr.write("BootQueueServer::load...Launching %(P)s.%(C)s with target queue: %(Q)s\r\n"%{"P":options.clazzpath, "C":options.clazz, "Q":target})
        try:
            importedModule = _importModule(options.clazzpath, options.clazz)(qs)
        except Exception, _e:
            sys.stderr.write("Error Launching %(P)s.%(C)s with target queue: %(Q)s\r\n%(T)s\r\n"%{"P":options.clazzpath, "C":options.clazz, "Q":target, "T":traceback.format_exc()})