Example #1
0
 def setUp(self, quiet=True, eResult="hello.world", corruption="blah!"):
     self.eResult = eResult
     self.corruption = corruption
     self.quiet = quiet
     self.dm = MarshallerFactory.get(MarshallerFactory.DEFAULT, quiet=self.quiet)
     self.data = self.dm._package(self.eResult)
     if not self.quiet: sys.stderr.write("data: %(D)s"%{"D":self.data})
Example #2
0
 def _createResources(cwd, timeout, quiet):
     #    Create our listener:
     target = Queue()
     marshaller = MarshallerFactory.get(MarshallerFactory.DEFAULT, quiet=quiet)
     tQs = QueueServer(host="127.0.0.1", port=54000, target=target, marshaller=marshaller, quiet=quiet).start().waitUntilRunning()
     details = tQs.details()
     return (target, tQs, details)
Example #3
0
    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()})
Example #4
0
 def setUp(self,
           host="127.0.0.1",
           port="11223",
           portReplyTo=44332,
           marshaller=MarshallerFactory.DEFAULT,
           quiet=True,
           maxClients=1,
           recvChunkSize=1024,
           readTimeout=1
           ):
     self.details = None
     self.quiet = quiet
     self.host = host
     self.port = port
     self.portReplyTo = portReplyTo
     self.maxClients = maxClients
     self.recvChunkSize = recvChunkSize
     self.readTimeout = readTimeout
     self.TIMEOUT = 2
     self.target = Queue()
     self.m = MarshallerFactory.get(marshaller, quiet=self.quiet)
     self._createQueueServer()
     #    Create the QueueWriter:
     self.qw = QueueWriter(target=self.details,
                           quiet=self.quiet,
                           marshaller=self.m,
                           autoConnect=True)
Example #5
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()
Example #6
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
Example #7
0
 def setUp(self):
     self.logger = self._getLogger()
     self.quiet=True
     self.random = Random()
     self.timerTerminate = 0
     self._timers = []
     self.namespaces = []
     self.dummyQueue = Queue()
     self.iface = PyRQIface(ref="test", quiet=self.quiet, loggingModule=testLoggingModule)
     self.marshaller = MarshallerFactory.get(MarshallerFactory.DEFAULT, quiet=self.quiet)
     desiredPort = "19001"
     self.r = SubprocessQueueServer(
                                    desiredPort=desiredPort,
                                    handlerClazz=Linkage.create(TimeoutMockHandler),
                                    quiet=self.quiet,
        )
     PyRQIface.setGlobalPYRQ(self.r.details())
Example #8
0
    def setUp(self):
        self.quiet=True
        self.random = Random()
        self._timers = []
        self.namespaces = []
        self.iface = PyRQIface(quiet=self.quiet, ref="test")
        self.dummyQueue = Queue()
        self.marshaller = MarshallerFactory.get(MarshallerFactory.DEFAULT, quiet=self.quiet)
        desiredPort = "19001"
        self.r = SubprocessQueueServer(
                                       desiredPort=desiredPort,
                                       handlerClazz=Linkage.create(MockHandler),
                                       quiet=self.quiet
#           includePydevd="/home/francis/.eclipse/org.eclipse.platform_3.7.0_155965261/plugins/org.python.pydev.debug_2.5.0.2012040618/pysrc"
           )
        PyRQIface.setGlobalPYRQ(self.r.details())
        self.r.start().waitUntilRunning()
        pass
Example #9
0
 def __init__(self,
              namespace=None,
              marshaller=MarshallerFactory.DEFAULT,
              sockTimeout=10,
              quiet=False,
              PyRqDetails=None,
              ref="",
              loggingModule=None,
              loggingLevel=None,
              allowIfaceTimeouts=True,
              keepAlive=False,
              maxDataSize=None,
              ):
     if loggingModule==None:
         if PyRQIface.loggingModule==None:
             import logging
             loggingModule = logging
         else:
             loggingModule = PyRQIface.loggingModule
     self._loggingModule = loggingModule
     self.setFixedTimeout(PyRQIface.MINIMUM_SOCKET_LATENCY)
     if loggingLevel==None:
         loggingLevel=self._loggingModule.INFO
     self._loggingLevel = loggingLevel
     self._ref = ref
     self.setNamespace(namespace)
     self._quiet = quiet
     self.keepAlive(keepAlive)
     self._maxDataSize = maxDataSize
     self._marshaller = MarshallerFactory.get(marshaller, quiet=self._quiet, maxsize=self._maxDataSize)
     self._sockTimeout = sockTimeout
     self._sock = None
     self._closed = False
     self.allowIfaceTimeouts(allowIfaceTimeouts)
     self._lastSockname = PyRQIface.NOT_CONNECTED
     self._PyRqDetails = PyRqDetails
Example #10
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()})
Example #11
0
                attr = getattr(self._sink, name)
                attr(self, peerName, relativeTime, *args, **kwargs)
                return uu
            return genericSinkMethod
        return object.__getattribute__(self, name)

if __name__ == '__main__':
    md = RRQDebugger()
    a = md.finish_end("peerName", "relativeTime")
    print a
    md.start(filename="mock.file")
    a = md.setup_start("peerName123", "relativeTime123")
    print a
    #    Start a dummyQueueServer:
    q = Queue()
    m = MarshallerFactory.get(MarshallerFactory.DEFAULT)
    QS = QueueServer(port=22334, target=q, quiet=True, marshaller=m)
    QS.start()
    details = QS.details()
    md.start(server=details)
    a = md.setup_start("peerName123", "relativeTime123")
    print a
    data = q.get(block=True, timeout=10)
    QS.close()






Example #12
0
 def getMarshaller(self):
     return MarshallerFactory.get(self._marshallerType, quiet=self._quiet)