def __init__(self):
self._zmq = ZmqRemoteProcedureCall()
self._requestSocket = self._zmq.requestSocket('localhost',
MyServer.REPLY_PORT)
self._subscriberSocket = self._zmq.subscriberSocket(
'localhost', MyPublisher.PUBLISHER_PORT, conflate=True)
self._requestSocketOnPublisher = self._zmq.requestSocket(
'localhost', MyPublisher.REPLY_PORT)
self._logger = Logger.of('MyClient')
def __init__(self, timeModule=time):
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(message)s')
self._zmq = ZmqRemoteProcedureCall()
self._replySocket = self._zmq.replySocket(self.REPLY_PORT)
self._timeMod = timeModule
self._isTerminated = False
self._logger = Logger.of('MyServer')
self.loop()
class MyServer():
SUCCESS = 123
REPLY_PORT = 4010
RUNNING_MESSAGE = 'imrunning'
TIME_TO_EXECUTE = 2
def __init__(self, timeModule=time):
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(message)s')
self._zmq = ZmqRemoteProcedureCall()
self._replySocket = self._zmq.replySocket(self.REPLY_PORT)
self._timeMod = timeModule
self._isTerminated = False
self._logger = Logger.of('MyServer')
self.loop()
def loop(self):
self._logger.notice("%s" % self.RUNNING_MESSAGE)
while not self._isTerminated:
self._logger.notice('looping')
self._zmq.handleRequest(self, self._replySocket, multi=False)
self._timeMod.sleep(0.1)
self._logger.notice("Terminating")
def returnSuccessAfter2Seconds(self):
self._logger.notice('invoked returnSuccessAfter2Seconds')
self._timeMod.sleep(self.TIME_TO_EXECUTE)
return self.SUCCESS
def raiseAnException(self):
self._logger.notice('invoked raiseAnException')
raise MyException('wanted Exception')
def getSomethingWithALogger(self, value):
return HasALogger(value)
@staticmethod
def startUpServer():
MyServer()
@staticmethod
def commandToSpawn():
cmd= 'python -c "from %s import MyServer; '\
'MyServer.startUpServer()"' % MyServer.__module__
return cmd
def deformableMirror(hostname, port):
from plico_dm.client.deformable_mirror_client import DeformableMirrorClient
from plico.rpc.zmq_remote_procedure_call import ZmqRemoteProcedureCall
from plico.rpc.zmq_ports import ZmqPorts
from plico.rpc.sockets import Sockets
rpc = ZmqRemoteProcedureCall()
zmqPorts = ZmqPorts(hostname, port)
sockets = Sockets(zmqPorts, rpc)
return DeformableMirrorClient(rpc, sockets)
def instrument(hostname, port):
from tipico.client.instrument_client import InstrumentClient
from plico.rpc.zmq_remote_procedure_call import ZmqRemoteProcedureCall
from plico.rpc.zmq_ports import ZmqPorts
from plico.rpc.sockets import Sockets
rpc = ZmqRemoteProcedureCall()
zmqPorts = ZmqPorts(hostname, port)
sockets = Sockets(zmqPorts, rpc)
return InstrumentClient(rpc, sockets)
def setUp(self):
self._setUpBasicLogging()
self.server = None
self._wasSuccessful = False
self._removeTestFolderIfItExists()
self._makeTestDir()
self.configuration = Configuration()
self.configuration.load(self.CONF_FILE)
self.rpc = ZmqRemoteProcedureCall()
calibrationRootDir = self.configuration.calibrationRootDir()
self._setUpCalibrationTempFolder(calibrationRootDir)
class MyClient():
def __init__(self):
self._zmq = ZmqRemoteProcedureCall()
self._requestSocket = self._zmq.requestSocket('localhost',
MyServer.REPLY_PORT)
self._subscriberSocket = self._zmq.subscriberSocket(
'localhost', MyPublisher.PUBLISHER_PORT, conflate=True)
self._requestSocketOnPublisher = self._zmq.requestSocket(
'localhost', MyPublisher.REPLY_PORT)
self._logger = Logger.of('MyClient')
def callASuccessfulMethod(self, timeout):
return self._zmq.sendRequest(self._requestSocket,
'returnSuccessAfter2Seconds',
timeout=timeout)
def callAMethodThatRaisesMyException(self):
return self._zmq.sendRequest(self._requestSocket,
'raiseAnException',
timeout=2 * MyServer.TIME_TO_EXECUTE)
def getAnObjectThatHasALogger(self, value):
return self._zmq.sendRequest(self._requestSocket,
'getSomethingWithALogger', [value],
timeout=1)
def readFromPublisher(self):
timeoutInSec = 3.
obj = self._zmq.receivePickable(self._subscriberSocket, timeoutInSec)
self._logger.notice('read %d from publisher' % obj.getValue())
return obj
def getLastCounterFromPublisher(self):
value = self._zmq.sendRequest(self._requestSocketOnPublisher,
'getLastCounter', [],
timeout=1)
self._logger.notice('asked to publisher and got %d' % value)
return value
class MyPublisher():
REPLY_PORT = 4011
PUBLISHER_PORT = 4012
RUNNING_MESSAGE = 'imrunning'
CYCLE_PERIOD = 0.01
def __init__(self, timeModule=time):
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(message)s')
self._zmq = ZmqRemoteProcedureCall()
self._replySocket = self._zmq.replySocket(self.REPLY_PORT)
self._publisherSocket = self._zmq.publisherSocket(self.PUBLISHER_PORT)
self._counter = 0
self._timeMod = timeModule
self._isTerminated = False
self._logger = Logger.of('MyPublisher')
self.loop()
def loop(self):
self._logger.notice("%s" % self.RUNNING_MESSAGE)
while not self._isTerminated:
self._logger.notice('looping counter %d' % self._counter)
self._zmq.handleRequest(self, self._replySocket, multi=False)
anObject = MyObject(self._counter)
self._zmq.publishPickable(self._publisherSocket, anObject)
self._counter += 1
self._timeMod.sleep(self.CYCLE_PERIOD)
self._logger.notice("Terminating")
def getLastCounter(self):
return self._counter
@staticmethod
def startUp():
MyPublisher()
@staticmethod
def commandToSpawn():
cmd= 'python -c "from %s import MyPublisher; '\
'MyPublisher.startUp()"' % MyServer.__module__
return cmd
def _createZmqBasedRPC(self):
zmqPorts = ZmqPorts.fromConfiguration(self._configuration,
self._configurationSection)
self._rpc = ZmqRemoteProcedureCall()
self._sockets = Sockets(zmqPorts, self._rpc)