def run(self):
context = zmq.Context()
socket = context.socket(zmq.ROUTER)
monitor = socket.get_monitor_socket()
ip = get_ip()
port_zmq = str(self.__port)
socket.bind("tcp://" + ip + ":" + port_zmq)
poller = zmq.Poller()
poller.register(monitor, zmq.POLLIN | zmq.POLLERR)
poller.register(socket, zmq.POLLIN | zmq.POLLERR)
EVENT_MAP = {}
for name in dir(zmq):
if name.startswith('EVENT_'):
value = getattr(zmq, name)
EVENT_MAP[value] = name
self.__devices_access.selector = poller
while True:
socks = dict(poller.poll())
if socket in socks:
[identity, message] = socket.recv_multipart()
message = pickle.loads(message)
try:
func = getattr(self, message[0])
ret = func(*message[1:])
ret = pickle.dumps(ret)
socket.send_multipart([identity, ret])
except AttributeError:
socket.send_multipart([identity, b"Error"])
if monitor in socks:
evt = recv_monitor_message(monitor)
evt.update({'description': EVENT_MAP[evt['event']]})
# logger.info("Event: {}".format(evt))
if self.__devices_access.fileno() in socks:
dev_ac = self.__devices_access
try:
poller.unregister(dev_ac)
logger.debug("The ADC device unregistered from the poller "
"selector")
except KeyError:
logger.warning("The ADC device not available to unregister"
" from the poller selector, expose")
[timestamp, pre_post, data] = dev_ac.retrieve_ADC_data()
data = {
'function_name': 'update_data',
'args':
[timestamp, pre_post, data, dev_ac.unique_ADC_name]
}
self.server_publisher.send_message(data)
def main():
import logging.config
from .logging_conf import DEFAULT_CONFIG
logging.config.dictConfig(DEFAULT_CONFIG)
pg.setConfigOption('background', 'k')
pg.setConfigOption('foreground', 'w')
parser = argparse.ArgumentParser()
parser.add_argument('--port',
nargs=1,
help='port used on the current machine')
parser.add_argument('--port_server',
nargs=1,
help='port used on the server')
parser.add_argument('--ip_server',
nargs=1,
help='IP address of the server')
args = parser.parse_args()
if not args.ip_server:
logging.error("IP of the server not provided. Exiting")
exit()
if (args.port is None):
port = 8001
else:
port = int(args.port[0])
server_port = None
if args.port_server:
server_port = args.port_server[0]
else:
server_port = server_expose_to_user_port
ip_server = args.ip_server[0]
addr = get_ip()
GUI_idx = addr + "_" + str(port)
GUI_name = "GUI" + "_" + GUI_idx + "._http._tcp.local."
print(server_port)
zmq_rpc = ZMQ_RPC(ip_server, server_port)
app = QApplication([])
win = MainWindow(zmq_rpc)
GUI = GUI_Class(win.ui, zmq_rpc, GUI_name)
threading_widget_zmq = ThreadServerExposeZMQ(GUI, port)
zmq_rpc.send_RPC('register_user_app', GUI_name, addr, port)
win.GUI_name = GUI_name
app.exec()
def monitorSlot(self):
context = zmq.Context()
socket = context.socket(zmq.ROUTER)
ip = get_ip()
socket.bind("tcp://" + ip + ":" + str(self.port_GUI))
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN | zmq.POLLERR)
while True:
socks = dict(poller.poll())
if socket in socks:
[identity, message] = socket.recv_multipart()
self.signal.emit(message)
def monitorSlot(self, return_queue):
self.return_queue = return_queue
context = zmq.Context()
socket = context.socket(zmq.ROUTER)
ip = get_ip()
socket.bind("tcp://" + ip + ":" + str(self.port_testbench))
poller = zmq.Poller()
poller.register(socket, zmq.POLLIN | zmq.POLLERR)
while True:
socks = dict(poller.poll())
if socket in socks:
[identity, message] = socket.recv_multipart()
data = serialization.deserialize(message)
getattr(self, data['function_name'])(*data['args'])
def add_service(self, zeroconf, type, name):
if name.startswith("ADC"):
info = zeroconf.get_service_info(type, name)
addr = str(socket.inet_ntoa(info.address))
port = int(info.properties[b'port'])
data = {
'function_name': 'register_ADC',
'args': [name, addr, port]
}
self.publisher.send_message(data)
server_addr = get_ip()
data = {
'function_name': 'set_server_address',
'args': [name, server_addr]
}
self.publisher.send_message(data)
def run(self):
"""
Called when the object of the class is created.
It listens for messages from
Device Applications (socket_ADC_listener),
User Applications (socket_user_listener)
and from Zeroconf (zeroconf_listener) in the loop.
The monitor socket is used to monitor the state of ZeroMQ connection.
The message contains the name of the method to call. Since communication
with the User Applications is synchronous, the socket_user_listener
sends back the data returned by the called funciton. In case of
socket_ADC_listener and zeroconf_listener the communication is
asynchronous
"""
EVENT_MAP = {}
for name in dir(zmq):
if name.startswith('EVENT_'):
value = getattr(zmq, name)
EVENT_MAP[value] = name
context = zmq.Context()
socket_user_listener = context.socket(zmq.ROUTER)
monitor = socket_user_listener.get_monitor_socket()
socket_ADC_listener = context.socket(zmq.ROUTER)
socket_zeroconf_listener = context.socket(zmq.ROUTER)
server_ip = get_ip()
socket_user_listener.bind("tcp://" + server_ip + ":" +
str(self.__port_user))
socket_ADC_listener.bind("tcp://" + server_ip + ":" +
str(self.__port_device))
socket_zeroconf_listener.bind("ipc:///tmp/zeroconf")
poller = zmq.Poller()
poller.register(monitor, zmq.POLLIN | zmq.POLLERR)
poller.register(socket_user_listener, zmq.POLLIN | zmq.POLLERR)
poller.register(socket_ADC_listener, zmq.POLLIN | zmq.POLLERR)
poller.register(socket_zeroconf_listener, zmq.POLLIN | zmq.POLLERR)
while True:
socks = dict(poller.poll())
if socket_user_listener in socks:
[identity, message] = socket_user_listener.recv_multipart()
message = pickle.loads(message)
try:
func = getattr(self, message[0])
ret = func(*message[1:])
ret = pickle.dumps(ret)
socket_user_listener.send_multipart([identity, ret])
except AttributeError:
socket_user_listener.send_multipart([identity, b"Error"])
if monitor in socks:
evt = recv_monitor_message(monitor)
evt.update({'description': EVENT_MAP[evt['event']]})
logger.info("Event: {}".format(evt))
if socket_ADC_listener in socks:
[identity, message] = socket_ADC_listener.recv_multipart()
data = serialization.deserialize(message)
try:
getattr(self, data['function_name'])(*data['args'])
except AttributeError as e:
logger.error("Attribute error: {}".format(e))
if socket_zeroconf_listener in socks:
[identity, message] = socket_zeroconf_listener.recv_multipart()
data = pickle.loads(message)
try:
getattr(self.__connection_manager,
data['function_name'])(*data['args'])
except AttributeError as e:
logger.error("Attribute error: {}".format(e))
def main():
logging.config.dictConfig(DEFAULT_CONFIG)
parser = argparse.ArgumentParser()
parser.add_argument('--port', nargs=1,
help='port used on the current machine',
type=int, default=[8000])
parser.add_argument('--pci_addr', nargs=1,
help='pci address of the desired board',
type=int, default=[0x01])
parser.add_argument('--ip_server', nargs=1,
help='IP address of the server')
parser.add_argument('--port_server', nargs=1,
help='port of the server')
args = parser.parse_args()
port = int(args.port[0])
pci_addr = int(args.pci_addr[0])
addr = get_ip()
ADC_idx = addr + '_' + str(port)
unique_ADC_name = 'ADC' + '_' + ADC_idx + '._http._tcp.local.'
pci_addr = pci_addr
trtl = 'trtl-000' + str(pci_addr)
if args.ip_server:
ip_server = {'addr': args.ip_server[0]}
else:
ip_server = {'addr': None}
port_server = None
if args.port_server:
port_server = args.port_server[0]
else:
port_server = server_expose_to_device_port
serv_expose = ServerExpose(port, port_server, pci_addr, trtl, unique_ADC_name)
zeroconf_service = None
zeroconf_info = None
if(args.ip_server is None):
zeroconf_info = zeroconf.ServiceInfo("_http._tcp.local.",
unique_ADC_name, zeroconf.socket.inet_aton(addr),
8000, properties={'addr': addr, 'port': str(port)})
zeroconf_service = zeroconf.Zeroconf()
zeroconf_service.register_service(zeroconf_info)
else:
serv_expose.set_server_address(ip_server['addr'])
data = {'function_name': 'register_ADC',
'args': [unique_ADC_name, addr, port]}
serv_expose.server_publisher.send_message(data)
try:
print("Application starting")
serv_expose.run()
except KeyboardInterrupt:
if(zeroconf_service is not None):
zeroconf_service.unregister_service(zeroconf_info)
else:
data = {'function_name': 'unregister_ADC',
'args': [unique_ADC_name]}
serv_expose.server_publisher.send_message(data)
time.sleep(0.1) # otherwise the message is lost
os._exit(1)