def run(self): queue = MessageQueue(config.POSIX_Q_NAME, O_CREAT, max_message_size=config.POSIX_Q_MAXSIZE) def cleaner(a, b): # закрываем posix queue тут try: queue.close() except: pass atexit.register(cleaner) signal.signal(signal.SIGTERM, cleaner) while True: try: # ждём чего-нибудь от джанги здесь (msg, _) = queue.receive() except SignalError: exit() # отделяем зёрна от плевел action = msg[:1] # 'd' - удаление, 'a' - добавление url = eval(msg[1:]) # а тут сами данные; делаем их питонячими if action == 'd': # оказывается, произошло удаление модели урла, удалить и # из очереди LoopProc.queue self._pipe.send(['remove', (0, url)]) continue if url['state'] == Url.WAIT and action == 'a': # кидаем в пайп QueueManager-у урл на добавление в работу self._pipe.send(['add', self._calculate_time(url)])
def connect(self): """ Connect to the message queues for remote memory :return True on success, else False """ try: self._rx_queue = MessageQueue(self.rx_queue_name, flags=O_RDONLY, read=True, write=False) except Exception as e: self.log.error("Unable to create rx_queue: %s" % e) return False try: self._tx_queue = MessageQueue(self.tx_queue_name, flags=O_WRONLY, read=False, write=True) except Exception as e: self.log.error("Unable to create tx_queue: %s" % e) self._rx_queue.close() return False self._rx_listener = RemoteMemoryRequestListener( self._rx_queue, self._avatar_queue, self._origin) self._rx_listener.daemon = True self._rx_listener.start() self.log.info("Successfully connected rmp") return True
def test_remote_memory_request(): magic1 = 0x4141414141414141 magic2 = 0x4242424242424242 magic3 = 0x4343434343434343 magic4 = 0x4444444444444444 magic5 = 4 q = queue.Queue() a = MessageQueue('/a', flags=O_CREAT | O_RDWR) b = MessageQueue('/b', flags=O_CREAT | O_RDWR) mprot1 = avatar2.protocols.remote_memory.RemoteMemoryProtocol( '/a', '/b', q) ret = mprot1.connect() assert_equal(ret, True) assert_not_equal(mprot1._rx_queue, None) assert_not_equal(mprot1._tx_queue, None) request = avatar2.protocols.remote_memory.RemoteMemoryReq( magic1, magic2, magic3, magic4, magic5, 1) a.send(request) msg = q.get() assert_equal(msg.id, magic1) assert_equal(msg.pc, magic2) assert_equal(msg.address, magic3) assert_equal(msg.value, magic4) assert_equal(msg.size, magic5)
def create_mq(self): self.delete_on_destruct = True self.logger.info('Attempting to create messsage_queue: ' + self.name) try: self.mq = MessageQueue(self.name, MessageQueue.O_CREAT) self.valid = True except: self.mq = None e = sys.exc_info()[0] self.logger.info('Error creating message_queue:' + e.__repr__()) return None
def read_window_list_from_queue(stop, window): mq = MessageQueue("/lcarswm-active-window-list") while True: try: s, _ = mq.receive(.4) GLib.idle_add(window.on_list_update, window, s.decode("utf-8")) except BusyError: pass if stop(): break mq.close()
def __init__(self): try: unlink_message_queue("/gyro") except: pass self.mqueue = MessageQueue('/gyro', flags=O_CREX, max_messages=MAX_MSG) try: self.gyro = mpu6050(0x68) except: raise Exception("Could not connect to Gyroscope MPU6050") self.angleFront = 0. self.angleSide = 0.
def __init__(self): try: unlink_message_queue("/spotgamepad") unlink_message_queue("/cameramotion") except: pass self.motionqueue = MessageQueue('/spotgamepad', flags=O_CREX, max_messages=MAX_MSG) self.cameraqueue = MessageQueue('/cameramotion', flags=O_CREX, max_messages=MAX_MSG) # Initialize Gamepad self.gamepad = evdev.InputDevice(INPUT_DEVICE)
def _init_mq(n, **kw): try: from posix_ipc import MessageQueue key = f"/.{n}" except ImportError: from sysv_ipc import MessageQueue key = n return MessageQueue(key, flags=os.O_CREAT, **kw)
def do_exit(mq): """ Executed when the program is finished. It is generally not useful to call on it's own as it's job is to clean up message queues and shut the application. Args: mq: A list of message queues to close. """ try: logger.info('Cleaning up.') logger.info(' - closing & destructing MessageQueue') MessageQueue.close(mq) MessageQueue.unlink_message_queue(mq) logger.info('Finished.') except ExistentialError as e: pass finally: sys.exit(0)
def connect_mq(self): self.delete_on_destruct = False self.logger.info('Attemping to connect to message_queue:' + self.name) try: MessageQueue(self.name, threading.O_RDONLY) self.valid = True except ExistentialError as e: self.logger.info(' - Could not connect to message_queue::' + e.__repr__()) self.mq = None
def enable_interrupts(self): if isinstance(self._origin, QemuTarget): # TODO: Make this more clean, i.e., check for remote memory rmem_rx_qname = self._origin.protocols.remote_memory.rx_queue_name rmem_tx_qname = self._origin.protocols.remote_memory.tx_queue_name # the tx-queue for qemu is the rx-queue for avatar and vice versa self._origin.protocols.monitor.execute_command( 'avatar-armv7m-enable-irq', { 'irq_rx_queue_name': self._tx_queue_name, 'irq_tx_queue_name': self._rx_queue_name, 'rmem_rx_queue_name': rmem_tx_qname, 'rmem_tx_queue_name': rmem_rx_qname }) else: raise Exception("V7MInterruptProtocol is not implemented for %s" % self._origin.__class__) try: self._rx_queue = MessageQueue(self._rx_queue_name, flags=O_RDONLY, read=True, write=False) except Exception as e: self.log.error("Unable to create rx_queue: %s" % e) return False try: self._tx_queue = MessageQueue(self._tx_queue_name, flags=O_WRONLY, read=False, write=True) except Exception as e: self.log.error("Unable to create tx_queue: %s" % e) self._rx_queue.close() return False self.daemon = True self.start() self.log.info("Enabled Interrupt Forwarding for %s" % self._origin) return True
def open_queue(name, create=False, consume=False): """Open a message queue via a context manager The message queue will automatically be closed when the context ends. The message queue may also optionally be created and/or consumed. If the "consume" flag is True, the message queue will be unlinked as well when the context ends. Args: name (str): the name of the message queue create (bool): whether to create the message queue or try to open a pre-existing one. consume (bool): whether or not to unlink the message queue when the context ends. Yields: posix_ipc.MessageQueue: the message queue """ flags = 0 if create: flags = posix_ipc.O_CREX queue = MessageQueue(name, flags=flags) try: yield queue finally: queue.close() if consume: queue.unlink()
def pi(n): pids = [] unit = n / 10 q = Queue("/pi", flags=os.O_CREAT) for i in range(10): mink = unit * i maxk = mink + unit pid = os.fork() if pid > 0: pids.append(pid) else: s = slice(mink, maxk) q.send(str(s)) q.close() sys.exit(0) sums = [] for pid in pids: sums.append(float(q.receive()[0])) os.waitpid(pid, 0) q.close() q.unlink() return math.sqrt(sum(sums) * 8)
class SpotGyro(): def __init__(self): try: unlink_message_queue("/gyro") except: pass self.mqueue = MessageQueue('/gyro', flags=O_CREX, max_messages=MAX_MSG) try: self.gyro = mpu6050(0x68) except: raise Exception("Could not connect to Gyroscope MPU6050") self.angleFront = 0. self.angleSide = 0. def get_position(self): try: accelval = self.gyro.get_accel_data() gyroval = self.gyro.get_gyro_data() self.angleFront = 0.80 * ( self.angleFront + float(gyroval['y']) * 0.01 / 131 ) + 0.20 * atan2(accelval['x'], accelval['z']) * 180 / 3.14159 self.angleSide = 0.80 * ( self.angleSide + float(gyroval['x']) * 0.01 / 131 ) + 0.20 * atan2(accelval['y'], accelval['z']) * 180 / 3.14159 if self.mqueue.current_messages >= MAX_MSG: self.mqueue.receive() self.mqueue.send('{"front":"' + str(self.angleFront) + '","side":"' + str(self.angleSide) + '","time":"' + str(time()) + '"}') except Exception: pass
def __init__(self): Gtk.Window.__init__(self, title="lcarsde app menu") self.css_provider = Gtk.CssProvider() self.css_provider.load_from_data(css) scroll_container = Gtk.ScrolledWindow() scroll_container.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self.app_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8) spacer = Gtk.Label(label="") spacer.get_style_context().add_class("spacer") spacer.get_style_context().add_provider( self.css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.app_container.pack_end(spacer, True, True, 0) scroll_container.add(self.app_container) self.add(scroll_container) self.entries = {} self.set_decorated(False) self.get_style_context().add_class("window") self.get_style_context().add_provider(self.css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.sendQueue = MessageQueue("/lcarswm-app-menu-messages") self.stop_threads = False self.thread = Thread(target=self.read_window_list_from_queue, args=(lambda: self.stop_threads, self)) self.thread.daemon = True self.connect("realize", self.on_create) self.connect("destroy", self.on_destroy)
def accept_new_client(mq): """ When a process connects to the request queue, this function is called to connect to the private queue for that process. Throws an exception if it can't connect. Args: mq: The echometrics request queue Returns:The private messagequeue associated with the clint or None. """ try: q_name = mq.receive()[0] print 'Client request:', q_name client_q = MessageQueue(q_name, O_RDWR) print ' -- connected' return client_q except: logger.info('error connecting to:' + q_name) return None
class SpotGamepad(): def __init__(self): try: unlink_message_queue("/spotgamepad") unlink_message_queue("/cameramotion") except: pass self.motionqueue = MessageQueue('/spotgamepad', flags=O_CREX, max_messages=MAX_MSG) self.cameraqueue = MessageQueue('/cameramotion', flags=O_CREX, max_messages=MAX_MSG) # Initialize Gamepad self.gamepad = evdev.InputDevice(INPUT_DEVICE) def read_event(self): for event in self.gamepad.read_loop(): if event.type == evdev.ecodes.EV_ABS: absevent = evdev.categorize(event) # If motion button if evdev.ecodes.bytype[absevent.event.type][ absevent.event.code] == 'ABS_HAT0Y': code = absevent.event.value if code == -1: self.send_msg( 'spotgamepad', '{"action":"forward","time":"' + str(time()) + '"}') elif code == 1: self.send_msg( 'spotgamepad', '{"action":"backward","time":"' + str(time()) + '"}') else: self.send_msg( 'spotgamepad', '{"action":"stop","time":"' + str(time()) + '"}') if evdev.ecodes.bytype[absevent.event.type][ absevent.event.code] == 'ABS_HAT0X': code = absevent.event.value if code == -1: self.send_msg( 'spotgamepad', '{"action":"left","time":"' + str(time()) + '"}') elif code == 1: self.send_msg( 'spotgamepad', '{"action":"right","time":"' + str(time()) + '"}') else: self.send_msg( 'spotgamepad', '{"action":"stop","time":"' + str(time()) + '"}') # If body position joystick if evdev.ecodes.bytype[absevent.event.type][ absevent.event.code] == 'ABS_X': if absevent.event.value < 128: self.send_msg( 'spotgamepad', '{"action":"bodyleft","time":"' + str(time()) + '"}') elif absevent.event.value > 128: self.send_msg( 'spotgamepad', '{"action":"bodyright","time":"' + str(time()) + '"}') else: self.send_msg( 'spotgamepad', '{"action":"stop","time":"' + str(time()) + '"}') if evdev.ecodes.bytype[absevent.event.type][ absevent.event.code] == 'ABS_Y': if absevent.event.value < 128: self.send_msg( 'spotgamepad', '{"action":"bodyfront","time":"' + str(time()) + '"}') elif absevent.event.value > 128: self.send_msg( 'spotgamepad', '{"action":"bodyback","time":"' + str(time()) + '"}') else: self.send_msg( 'spotgamepad', '{"action":"stop","time":"' + str(time()) + '"}') # If camera position joystick if evdev.ecodes.bytype[absevent.event.type][ absevent.event.code] == 'ABS_Z': print('lateral camera: ' + str(absevent.event.value)) if evdev.ecodes.bytype[absevent.event.type][ absevent.event.code] == 'ABS_RZ': print('front camera: ' + str(absevent.event.value)) # If action button if event.type == evdev.ecodes.EV_KEY: keyevent = evdev.categorize(event) # Laydown if laydown_button in evdev.ecodes.bytype[keyevent.event.type][ keyevent.event.code]: if keyevent.event.value == 0: self.send_msg( 'spotgamepad', '{"action":"laydown","time":"' + str(time()) + '"}') # Wake up if wakeup_button in evdev.ecodes.bytype[keyevent.event.type][ keyevent.event.code]: if keyevent.event.value == 0: self.send_msg( 'spotgamepad', '{"action":"wakeup","time":"' + str(time()) + '"}') def send_msg(self, queue, msg): if self.cameraqueue.current_messages >= MAX_MSG: self.cameraqueue.receive() if self.motionqueue.current_messages >= MAX_MSG: self.motionqueue.receive() if queue == 'spotgamepad': self.motionqueue.send(msg) elif queue == 'cameramotion': self.cameraqueue.send(msg)
class message_queue: O_CREAT = threading.O_CREAT O_RDONLY = threading.O_RDONLY def __init__(self, mq_name, mode=O_CREAT): log_format = '%(asctime)-15s : %(levelname)s : line %(lineno)-4d in %(module)s.%(funcName)s > %(message)s' logging.basicConfig(level=logging.DEBUG, format=log_format) self.logger = logging.getLogger('mq-mq_name') self.name = mq_name self.lock = threading.Lock() self.valid = False self.delete_on_destruct = False if mode is message_queue.O_CREAT: self.create_mq() else: # RD_ONLY but need verify for RDWR and WR_ONLY self.connect_mq() return def create_mq(self): self.delete_on_destruct = True self.logger.info('Attempting to create messsage_queue: ' + self.name) try: self.mq = MessageQueue(self.name, MessageQueue.O_CREAT) self.valid = True except: self.mq = None e = sys.exc_info()[0] self.logger.info('Error creating message_queue:' + e.__repr__()) return None def connect_mq(self): self.delete_on_destruct = False self.logger.info('Attemping to connect to message_queue:' + self.name) try: MessageQueue(self.name, threading.O_RDONLY) self.valid = True except ExistentialError as e: self.logger.info(' - Could not connect to message_queue::' + e.__repr__()) self.mq = None def send(self, message): if not self.valid: self.logger.info('Cannot send message:' + self.name + 'is invalid.') try: self.mq.send(message) except: e = sys.exc_info()[0] self.logger.info('Error sending message:' + e.__repr__()) def receive(self, timeout=0): if not self.valid: self.logger.info('Cannot receive messages:' + self.name + 'is invalid.') return try: message = self.mq.receive(timeout) return message except: e = sys.exc_info()[0] self.logger.info('Error receiving message:' + e.__repr__()) return None def delete_when_finished(self, delete_when_finished): # probably should test type for bool_type self.delete_on_destruct = delete_when_finished def __enter__(self): return def __exit__(self): if not self.delete_on_destruct return try: self.logger.info('Unlinking MessageQueue:' + self.name) unlink_message_queue(self.name) except ExistentialError as e: pass
from posix_ipc import MessageQueue as MsgQ import sysv_ipc import os if __name__ == '__main__': q = MsgQ("/tmp", flags=os.O_CREAT, mode=0666) q.send("adfg") rec = q.receive(1) print rec q.close() q.unlink() q2 = sysv_ipc.MessageQueue(16842753, flags=sysv_ipc.IPC_CREAT) q2.send("sferogh", type=1)
class LcarsdeAppMenu(Gtk.Window): """ Application menu main window """ def __init__(self): Gtk.Window.__init__(self, title="lcarsde app menu") self.css_provider = Gtk.CssProvider() self.css_provider.load_from_data(css) scroll_container = Gtk.ScrolledWindow() scroll_container.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self.app_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8) spacer = Gtk.Label(label="") spacer.get_style_context().add_class("spacer") spacer.get_style_context().add_provider( self.css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.app_container.pack_end(spacer, True, True, 0) scroll_container.add(self.app_container) self.add(scroll_container) self.entries = {} self.set_decorated(False) self.get_style_context().add_class("window") self.get_style_context().add_provider(self.css_provider, Gtk.STYLE_PROVIDER_PRIORITY_USER) self.sendQueue = MessageQueue("/lcarswm-app-menu-messages") self.stop_threads = False self.thread = Thread(target=self.read_window_list_from_queue, args=(lambda: self.stop_threads, self)) self.thread.daemon = True self.connect("realize", self.on_create) self.connect("destroy", self.on_destroy) def on_create(self, window): # mark myself as the app menu self.get_property("window").set_utf8_property("LCARSDE_APP_MENU", "LCARSDE_APP_MENU") self.thread.start() def on_destroy(self, window): self.stop_threads = True self.sendQueue.close() self.thread.join() @staticmethod def read_window_list_from_queue(stop, window): mq = MessageQueue("/lcarswm-active-window-list") while True: try: s, _ = mq.receive(.4) GLib.idle_add(window.on_list_update, window, s.decode("utf-8")) except BusyError: pass if stop(): break mq.close() @staticmethod def on_list_update(self, list_string): data_list = list_string.splitlines() if data_list[0] != "list": return updated_window_elements = dict( (window_id, (class_name, is_active == "active")) for window_id, class_name, is_active in ( window_element.split("\t") for window_element in data_list[1:])) known_windows = list(self.entries.keys()) self.cleanup_windows(known_windows, updated_window_elements) self.handle_current_windows(known_windows, updated_window_elements) self.show_all() def cleanup_windows(self, known_windows, updated_window_elements): for known_window_id in known_windows: if known_window_id not in updated_window_elements.keys(): entry = self.entries[known_window_id] self.app_container.remove(entry) del self.entries[known_window_id] def handle_current_windows(self, known_windows, updated_window_elements): for (window_id, (class_name, is_active)) in updated_window_elements.items(): if window_id in known_windows: self.update_window(window_id, class_name, is_active) else: self.add_window(window_id, class_name, is_active) def update_window(self, window_id, class_name, is_active): entry = self.entries[window_id] entry.update_label(class_name) entry.update_activity(is_active) def add_window(self, window_id, class_name, is_active): entry = WindowEntry(window_id, class_name, is_active, self.css_provider, self.sendQueue) self.app_container.pack_start(entry, False, False, 0) self.entries[window_id] = entry
class ARMV7MInterruptProtocol(Thread): """ This protocol has two purposes: a) injecting interrupts into an analysis target b) extracting interrupt exits and putting them into the avatar queue (b) is necessary in cases where two targets need to be synched on the interrupts. The way a v7m-nvic implements interrupt return is to put a magic value into $pc, and the hardware does the actual magic of popping from the interrupt stack and restoring the context. However, the magic value defines the type of the interrupt return, and is hence synchronized on interrupt exit, alongside with the interrupt number :param origin: Reference to the Target utilizing this protocol :param rx_queue_name: Name of the queue for receiving :param tx_queue_name: Name of the queue for sending """ def __init__(self, origin, rx_queue_name, tx_queue_name): super(self.__class__, self).__init__() self._rx_queue_name = rx_queue_name self._tx_queue_name = tx_queue_name self._rx_queue = None self._tx_queue = None self._avatar_queue = origin.avatar.queue self._origin = origin self._close = Event() self._closed = Event() self._close.clear() self._closed.clear() self.log = logging.getLogger('%s.%s' % (origin.log.name, self.__class__.__name__) ) if origin else \ logging.getLogger(self.__class__.__name__) def run(self): while True: if self._close.is_set(): break request = None try: request = self._rx_queue.receive(0.5) except: continue req_struct = V7MRemoteInterruptNotification.from_buffer_copy( request[0]) if RINOperation(req_struct.operation) == RINOperation.ENTER: msg = RemoteInterruptEnterMessage(self._origin, req_struct.id, req_struct.num_irq) elif RINOperation(req_struct.operation) == RINOperation.EXIT: msg = RemoteInterruptExitMessage(self._origin, req_struct.id, req_struct.type, req_struct.num_irq) self.log.debug( "Received an InterruptExitRequest for irq %d (%x)" % (req_struct.num_irq, req_struct.type)) else: msg = None raise Exception( ("Received V7MRemoteInterrupt Notification with" "unknown operation type %d") % req_struct.operation) self._avatar_queue.put(msg) self._closed.set() def stop(self): self._close.set() self._closed.wait() def enable_interrupts(self): if isinstance(self._origin, QemuTarget): # TODO: Make this more clean, i.e., check for remote memory rmem_rx_qname = self._origin.protocols.remote_memory.rx_queue_name rmem_tx_qname = self._origin.protocols.remote_memory.tx_queue_name # the tx-queue for qemu is the rx-queue for avatar and vice versa self._origin.protocols.monitor.execute_command( 'avatar-armv7m-enable-irq', { 'irq_rx_queue_name': self._tx_queue_name, 'irq_tx_queue_name': self._rx_queue_name, 'rmem_rx_queue_name': rmem_tx_qname, 'rmem_tx_queue_name': rmem_rx_qname }) else: raise Exception("V7MInterruptProtocol is not implemented for %s" % self._origin.__class__) try: self._rx_queue = MessageQueue(self._rx_queue_name, flags=O_RDONLY, read=True, write=False) except Exception as e: self.log.error("Unable to create rx_queue: %s" % e) return False try: self._tx_queue = MessageQueue(self._tx_queue_name, flags=O_WRONLY, read=False, write=True) except Exception as e: self.log.error("Unable to create tx_queue: %s" % e) self._rx_queue.close() return False self.daemon = True self.start() self.log.info("Enabled Interrupt Forwarding for %s" % self._origin) return True def ignore_interrupt_return(self, interrupt_number): if isinstance(self._origin, QemuTarget): self.log.info("Disable handling of irq return for %d" % interrupt_number) self._origin.protocols.monitor.execute_command( 'avatar-armv7m-ignore-irq-return', {'num_irq': interrupt_number}) def unignore_interrupt_return(self, interrupt_number): if isinstance(self._origin, QemuTarget): self.log.info("Re-enable handling of irq return for %d" % interrupt_number) self._origin.protocols.monitor.execute_command( 'avatar-armv7m-unignore-irq-return', {'num_irq': interrupt_number}) def inject_interrupt(self, interrupt_number, cpu_number=0): if isinstance(self._origin, QemuTarget): self.log.info("Injecting interrupt %d" % interrupt_number) self._origin.protocols.monitor.execute_command( 'avatar-armv7m-inject-irq', { 'num_irq': interrupt_number, 'num_cpu': cpu_number }) def set_vector_table_base(self, base, cpu_number=0): if isinstance(self._origin, QemuTarget): self.log.info("Setting vector table base to 0x%x" % base) self._origin.protocols.monitor.execute_command( 'avatar-armv7m-set-vector-table-base', { 'base': base, 'num_cpu': cpu_number }) def send_interrupt_exit_response(self, id, success): response = V7MInterruptNotificationAck(id, success, RINOperation.EXIT.value) try: self._tx_queue.send(response) self.log.debug("Send RemoteInterruptExitResponse with id %d" % id) return True except Exception as e: self.log.error("Unable to send response: %s" % e) return False def send_interrupt_enter_response(self, id, success): response = V7MInterruptNotificationAck(id, success, RINOperation.ENTER.value) try: self._tx_queue.send(response) self.log.debug("Send RemoteInterruptEnterResponse with id %d" % id) return True except Exception as e: self.log.error("Unable to send response: %s" % e) return False def __del__(self): self.shutdown() def shutdown(self): self.stop() if self._rx_queue: try: self._rx_queue.unlink() self._rx_queue.close() self._rx_queue = None except ExistentialError: self.log.warning("Tried to close/unlink non existent rx_queue") if self._tx_queue: try: self._tx_queue.unlink() self._tx_queue.close() self._tx_queue = None except ExistentialError: self.log.warning("Tried to close/unlink non existent tx_queue")
def run(self): # overrides threading.Thread.run() """ Overrides threading.Thread.run() Creates initial connection to expected message queues; echometrics, frames, and tracks. It polls each one waiting for the read-ready flag to be set and consumes the data. It reformats the data into an object and writes it out to clients who are registered. Returns ------- None """ logger.info('Creating message_queues: ' + self.display_q_name) display_q = MessageQueue(self.display_q_name, O_CREAT) em_q = MessageQueue(self.em_q_name, O_CREAT) # TODO: READ THE NIMS FRAMEBUFFER NAME FROM THE YAML try: # connect to nims ingestor to get backscatter data nims_framebuffer = '/' + self.config['FRAMEBUFFER_NAME'] logger.info('Connecting to ' + nims_framebuffer) framebuffer_q = MessageQueue(nims_framebuffer, O_RDONLY) framebuffer_q.send(self.display_q_name) logger.info(" - sent queue: " + self.display_q_name) except ExistentialError as e: logger.info(' - Could not connect to ' + nims_framebuffer + '::' + e.__repr__()) try: # connect to nims tracker to get track data (probably out of sync) tracker_name = '/' + self.config['TRACKER_NAME'] logger.info('Connecting to ' + tracker_name) trackbuffer_q = MessageQueue(tracker_name, O_RDONLY) except ExistentialError as e: logger.info(' - Could not connect to ' + tracker_name + '::' + e.__repr__()) try: # connect to the echometrics queue for periodic em data em_queue_name = self.config['ECHOMETRICS']['queue_name'] logger.info('Connecting to ' + em_queue_name) em_request_q = MessageQueue(em_queue_name, O_RDONLY) em_request_q.send(self.em_q_name) except: logger.info(' - Could not connect to ' + em_queue_name) poller = select.poll() poller.register(em_q.mqd, select.POLLIN) poller.register(display_q.mqd, select.POLLIN) poller.register(trackbuffer_q.mqd, select.POLLIN) time.sleep( 1 ) # apparently necessary to create this latency for the frame_buffer app? while True: frame_buffer = None track_buffer = None em_buffer = None mq_state = poller.poll() for state in mq_state: mqd = state[0] if mqd == em_q.mqd: buf = em_q.receive()[0] em_buffer = ast.literal_eval(buf) elif mqd == display_q.mqd: frame = frames.frame_message(display_q.receive()[0]) if frame.valid is False: logger.info('Received invalid message: ignoring') continue try: #logger.info(' -- Connecting to ' + frame.shm_location) shm_frame = SharedMemory(frame.shm_location, O_RDONLY, size=frame.frame_length) except StandardError as e: logger.info(' -- Error connecting to', frame.shm_location, '::', e.__repr__()) continue mapped = mmap(shm_frame.fd, shm_frame.size) shm_frame.close_fd() frame_buffer = frames.frame_buffer( mapped.read(frame.frame_length)) mapped.close() if frame_buffer.valid is False: logger.info(' -- Error Parsing Frame') continue image = np.array(frame_buffer.image) image = image.reshape((frame_buffer.num_samples[0], frame_buffer.num_beams[0])) image = image[0:-1:4, ::] frame_buffer.image = image.flatten().tolist() frame_buffer.num_samples = (frame_buffer.num_samples[0] / 4, 0) elif mqd == trackbuffer_q.mqd: track_buffer = frames.track_message( trackbuffer_q.receive()[0]) clients = copy.copy(self.clients) for client in clients: try: if frame_buffer: client.send_image(frame_buffer) if track_buffer: client.send_tracks(track_buffer) if em_buffer: client.send_metrics(em_buffer) except StandardError as e: logger.info("Error sending data to client") print sys.exc_info() continue return
class RemoteMemoryProtocol(object): """ This class listens to memoryforward requests and lifts them to avatar messages. Likewise it can be directed to emit memoryforward-response messages :param rx_queue_name: Name of the queue for receiving :param tx_queue_name: Name of the queue for sending :param avatar_queue: Queue to dispatch received requests to :param origin: Reference to the Target utilizing this protocol """ def __init__(self, rx_queue_name, tx_queue_name, avatar_queue, origin=None): self._rx_queue = None self._tx_queue = None self._rx_listener = None self.rx_queue_name = rx_queue_name self.tx_queue_name = tx_queue_name self._avatar_queue = avatar_queue self._origin = origin self.log = logging.getLogger('%s.%s' % (origin.log.name, self.__class__.__name__) ) if origin else \ logging.getLogger(self.__class__.__name__) def connect(self): """ Connect to the message queues for remote memory :return True on success, else False """ try: self._rx_queue = MessageQueue(self.rx_queue_name, flags=O_RDONLY, read=True, write=False) except Exception as e: self.log.error("Unable to create rx_queue: %s" % e) return False try: self._tx_queue = MessageQueue(self.tx_queue_name, flags=O_WRONLY, read=False, write=True) except Exception as e: self.log.error("Unable to create tx_queue: %s" % e) self._rx_queue.close() return False self._rx_listener = RemoteMemoryRequestListener( self._rx_queue, self._avatar_queue, self._origin) self._rx_listener.daemon = True self._rx_listener.start() self.log.info("Successfully connected rmp") return True def __del__(self): self.shutdown() def shutdown(self): if self._rx_listener: self._rx_listener.stop() self._rx_listener = None if self._rx_queue: try: self._rx_queue.unlink() self._rx_queue.close() self._rx_queue = None except ExistentialError: self.log.warning("Tried to close/unlink non existent rx_queue") if self._tx_queue: try: self._tx_queue.unlink() self._tx_queue.close() self._tx_queue = None except ExistentialError: self.log.warning("Tried to close/unlink non existent tx_queue") def send_response(self, id, value, success): response = RemoteMemoryResp(id, value, success) try: self._tx_queue.send(response) self.log.debug("Send RemoteMemoryResponse with id %d, %x" % (id, value)) return True except Exception as e: self.log.error("Unable to send response: %s" % e) return False
def main(): signal.signal(signal.SIGINT, signal_handler) global continue_running continue_running = True yaml_path = os.path.join(os.getenv("NIMS_HOME", "../build"), "config.yaml") try: config = ruamel.yaml.load(open(yaml_path, "r"), ruamel.yaml.RoundTripLoader) except: import yaml stream = file(config) config = yaml.load(stream) if type(config) == StringType: config = ast.literal_eval(config) logger.info('Configuration Path: ' + yaml_path) emmq_name = os.getenv('EMMQ_NAME', '/em_mq') + repr(os.getpid()) nims_fb_name = '/' + config['FRAMEBUFFER_NAME'] bin_ping = int(config['ECHOMETRICS']['ping_bin']) bin_depth = int(config['ECHOMETRICS']['depth_bin']) mode = int(config['SONAR_TYPE']) logger.info('Starting realtime_echometrics ...') logger.info(' -- echoMetrics MessageQueue: ' + emmq_name) logger.info(' -- framebuffer MessageQueue: ' + nims_fb_name) logger.info(' -- ping bin size: ' + str(bin_ping)) logger.info(' -- depth bin size: ' + str(bin_depth)) logger.info(' -- mode = some mode') logger.info('Creating MessageQueue: ' + emmq_name) em_request_mq_name = config['ECHOMETRICS']['queue_name'] # we need a queue for requesting backscatter data and a queue for pushing em data em_request_mq = MessageQueue(em_request_mq_name, O_CREAT) em_clients_mq = [] em_mq = MessageQueue(emmq_name, O_CREAT) try: #logger.info('Connecting to' + nims_fb_name) framebuffer_mq = MessageQueue(nims_fb_name, O_RDONLY) framebuffer_mq.send(emmq_name) logger.info(" -- sent private queue: " + emmq_name) except ExistentialError as e: logger.error(' -- Could not connect to' + nims_fb_name + e.__repr__()) # here, unless specified in the log, both processes are at least ready to communicate poller = select.poll() poller.register(em_mq.mqd, select.POLLIN) poller.register(em_request_mq.mqd, select.POLLIN) current_frames = [] #file_ = open('metrics.csv', 'w+') #need_hdr = True #import csv #csvwriter = csv.writer(file_, delimiter=',') logger.info('Starting fetch cycle.') while continue_running: mq_state = poller.poll() for state in mq_state: if state[0] == em_mq.mqd: frame_buffer = fetch_framebuffer(em_mq) if frame_buffer: if mode == 1: # multbeam frame_buffer = compress_beams(frame_buffer) current_frames.append(frame_buffer) if state[ 0] == em_request_mq.mqd: # TODO catch error to drop this person. client = accept_new_client(em_request_mq) if client: em_clients_mq.append(client) if len(current_frames) >= bin_ping: echo_metrics = calculate_echometrics(current_frames, bin_depth) echo_metrics['pingid'] = frame_buffer.ping_num[0] current_frames = [] #if need_hdr: #csvwriter.writerow(echo_metrics.keys()) #need_hdr == False #csvwriter.writerow(echo_metrics.values()) for q in em_clients_mq: try: print 'sending echometrics to' + q.name q.send(str(echo_metrics)) except Exception as e: logger.info( 'error writing to client q, removing from active clients.' ) print e.__repr__() em_clients_mq.remove(q) do_exit(em_mq) return