class NotificationHandler(object): def __init__(self): self.adx_inv_manager= DeviceManager() def info(self, ctxt, publisher_id, event_type, payload, metadata): LOG.info(event_type) if str(event_type).startswith("compute.instance"): #LOG.info("RECEIVED MESSAGE: %r" % (payload, )) image_url=str(payload['image_ref_url']) vadx_image_id = CONFIG.get("DEFAULT", "vadx_image_ids") if vadx_image_id in image_url: LOG.info("vadx instance notification received ") LOG.info("RECEIVED MESSAGE: %r" % (payload, )) self.adx_inv_manager.process_notification(event_type,payload) return else: LOG.info("Notification is not for vadx") else: #LOG.info("RECEIVED MESSAGE: %r" % (payload, )) pass def warn(self, ctxt, publisher_id, event_type, payload, metadata): pass def error(self, ctxt, publisher_id, event_type, payload, metadata): pass def debug(self, ctx, publisher_id, event_type, payload, metadata): pass
def udev_event_callback(action, device): global copy_thread, message_q if not copy_thread: copy_thread = DeviceManager(kwargs={ 'return_q': message_q, 'action': action, 'device': device }) copy_thread.start()
def sigterm_handler(): global _amqp_client DeviceManager.destroy_instance() DeviceZtpManager.destroy_instance() DeviceJobManager.destroy_instance() if _amqp_client is not None: _amqp_client.stop()
def init(): global s_channel global s_stub global s_device_manager start_perfdog_service(PERFDOG_SERVICE_PATH) s_channel = grpc.insecure_channel( '%s:%s' % (PERFDOG_SERVICE_IP, PERFDOG_SERVICE_PORT), options=[('grpc.max_receive_message_length', 100 * 1024 * 1024)]) s_stub = perfdog_pb2_grpc.PerfDogServiceStub(s_channel) s_stub.loginWithToken(perfdog_pb2.Token(token=PERFDOG_SERVICE_TOKEN)) s_device_manager = DeviceManager(s_stub) s_device_manager.start()
class DeviceServiceTestCase(unittest.TestCase): def setUp(self): self.device_manager = DeviceManager() def test_get_connected_devices(self): devices = self.device_manager.get_connected_devices() print("devices", devices) self.assertIsNotNone(devices) self.assertTrue(len(devices) > 0) def test_listener(self): listener = DeviceChangeListener() self.device_manager.register_device_change_listener(listener) while True: pass
def __init__(self, config_file_directory): self.config_file_directory = config_file_directory self.update_config() if self.config["board_type"] == "raspberry_pi": import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) self.device_manager = DeviceManager(self.config["devices"], self.config["board_type"], self.device_manager_callback) self.communication_manager = CommunicationManager( self.config["communication_protocols"], self.communication_manager_send_callback, self.communication_manager_receive_callback) time.sleep(5) self.device_manager.read_all()
def device_send(self, job_template, job_input, is_delete, retry): config_str = json.dumps(job_input, sort_keys=True) self.push_config_state = PushConfigState.PUSH_STATE_IN_PROGRESS start_time = None config_size = 0 forced_cfg_push = self.physical_router.forced_cfg_push try: config_size = len(config_str) current_config_hash = md5(config_str).hexdigest() if self.last_config_hash is None or ( current_config_hash != self.last_config_hash or forced_cfg_push): self._logger.info( "Config push for %s(%s) using job template %s, " "forced_push %s" % (self.physical_router.name, self.physical_router.uuid, str(job_template), forced_cfg_push)) self._logger.debug( "Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) device_manager = DeviceManager.get_instance() job_handler = JobHandler( job_template, job_input, [self.physical_router.uuid], device_manager.get_api_server_config(), self._logger, device_manager._amqp_client, self.physical_router.transaction_id, self.physical_router.transaction_descr, device_manager._args) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push(**device_manager.get_job_status_config()) end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str(end_time - start_time) self.last_config_hash = current_config_hash else: self._logger.debug("not pushing since no config change" " detected") self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, repr(e))) self._logger.error("Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str(time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
class SystemManager: config_file_directory = None config = {} device_manager, communication_manager = None, None #Updates config according to config file def update_config(self): logging.info("Config updated") with open(self.config_file_directory) as config_file: self.config = json.loads(config_file.read()) logging.debug("New config : " + json.dumps(self.config)) def device_manager_callback(self, data): self.communication_manager.send_all(data) def communication_manager_send_callback(self): pass def communication_manager_receive_callback(self, data): pass def __init__(self, config_file_directory): self.config_file_directory = config_file_directory self.update_config() if self.config["board_type"] == "raspberry_pi": import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) self.device_manager = DeviceManager(self.config["devices"], self.config["board_type"], self.device_manager_callback) if self.device_manager.connected > 0: self.communication_manager = CommunicationManager( self.config["communication_protocols"], self.communication_manager_send_callback, self.communication_manager_receive_callback) else: print('no sensor initiated') exit() time.sleep(5) self.device_manager.read_all()
def device_send(self, job_template, job_input, is_delete, retry): config_str = json.dumps(job_input, sort_keys=True) self.push_config_state = PushConfigState.PUSH_STATE_IN_PROGRESS start_time = None config_size = 0 try: config_size = len(config_str) current_config_hash = md5(config_str).hexdigest() if self.last_config_hash is None or\ current_config_hash != self.last_config_hash: self._logger.info("Config push for %s(%s) using job template %s" % (self.physical_router.name, self.physical_router.uuid, str(job_template))) self._logger.debug("Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) device_manager = DeviceManager.get_instance() job_handler = JobHandler(job_template, job_input, None if is_delete else [self.physical_router.uuid], device_manager.get_api_server_config(), self._logger, device_manager._amqp_client, device_manager._args) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push(**device_manager.get_job_status_config()) end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( end_time - start_time) self.last_config_hash = current_config_hash else: self._logger.debug("not pushing since no config change" " detected") self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, repr(e))) self._logger.error("Abstract config: %s" % json.dumps(job_input, indent=4, sort_keys=True)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
def run_device_manager(dm_logger, args): global _amqp_client global _zookeeper_client dm_logger.notice("Elected master Device Manager node. Initializing... ") dm_logger.introspect_init() DeviceZtpManager.get_instance().set_active() DeviceManager(dm_logger, args, _zookeeper_client, _amqp_client) if _amqp_client._consumer_gl is not None: gevent.joinall([_amqp_client._consumer_gl])
def device_send(self, job_template, job_input, is_delete, retry): config_str = json.dumps(job_input, sort_keys=True) self.push_config_state = PushConfigState.PUSH_STATE_IN_PROGRESS start_time = None config_size = 0 try: config_size = len(config_str) current_config_hash = md5(config_str).hexdigest() if self.last_config_hash is None or\ current_config_hash != self.last_config_hash: self._logger.info("config push for %s(%s) using job template %s" % (self.physical_router.name, self.physical_router.uuid, str(job_template))) self._logger.debug("playbook send message: %s" % json.dumps(job_input, indent=4, sort_keys=True)) device_manager = DeviceManager.get_instance() job_handler = JobHandler(job_template, job_input, None if is_delete else [self.physical_router.uuid], device_manager.get_analytics_config(), device_manager.get_vnc(), self._logger) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push() end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( end_time - start_time) self.last_config_hash = current_config_hash else: self._logger.debug("not pushing since no config change" " detected") self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, e.message)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
def _get_cameras(self): dev_manager = DeviceManager() cams = [] if not dev_manager.devices: return [] for dev in dev_manager.devices: if dev is Undefined: continue if not hasattr(dev, 'provides'): continue if IOService.services_all(self.requires, dev.provides): cams.append(dev) return cams
def find_devices(self): dev_manager = DeviceManager() cntrlrs = [] if not dev_manager.devices: return [] for dev in dev_manager.devices: if dev is Undefined: continue if not hasattr(dev, 'controller'): continue if not hasattr(dev, 'provides'): continue if IOService.services_all(self.requires, dev.controller.provides): cntrlrs.append(dev.controller) return cntrlrs
def main(_args) -> int: manager = DeviceManager() manager.register_device("coherent_pwr", DummySwitch(COHERENT_PIN, "coherent_pwr")) manager.register_device("hercules_pwr", DummySwitch(COHERENT_PIN, "hercules_pwr")) # Don't register board, its an internal device board = DummyBoard() board.hardware_init() board.add_hardware(manager.get_device("coherent_pwr")) board.add_hardware(manager.get_device("hercules_pwr")) ipc = TCPEndpoint(TCP_ADDRESS, manager) ipc.start() board.hardware_cleanup() return 0
def device_send(self, job_template, job_input, retry): config_str = json.dumps(job_input) self.push_config_state = PushConfigState.PUSH_STATE_INIT start_time = None config_size = 0 try: self._logger.debug("playbook send message: %s" % config_str) config_size = len(config_str) device_manager = DeviceManager.get_instance() job_handler = JobHandler(job_template, job_input, [self.physical_router.uuid], device_manager.get_analytics_config(), device_manager.get_vnc(), self._logger) self.commit_stats['total_commits_sent_since_up'] += 1 start_time = time.time() job_handler.push() end_time = time.time() self.commit_stats['commit_status_message'] = 'success' self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( end_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( end_time - start_time) self.push_config_state = PushConfigState.PUSH_STATE_SUCCESS except Exception as e: self._logger.error("Router %s: %s" % (self.physical_router.management_ip, e.message)) self.commit_stats[ 'commit_status_message'] = 'failed to apply config,\ router response: ' + e.message if start_time is not None: self.commit_stats['last_commit_time'] = \ datetime.datetime.fromtimestamp( start_time).strftime('%Y-%m-%d %H:%M:%S') self.commit_stats['last_commit_duration'] = str( time.time() - start_time) self.push_config_state = PushConfigState.PUSH_STATE_RETRY if retry\ else PushConfigState.PUSH_STATE_FAILED return config_size
def _managers_default(self): c = [] try: from experiment_manager import ExperimentManager c.append(ExperimentManager()) except: pass try: from device_manager import DeviceManager c.append(DeviceManager()) except: pass try: from control_manager import ControlManager c.append(ControlManager()) except: pass try: from global_state_manager import GlobalStateManager c.append(GlobalStateManager()) except: pass return c
#!/usr/bin/env python from device_manager import DeviceManager if __name__ == '__main__': import sys from PyQt5.QtWidgets import QApplication app = QApplication(sys.argv) dev_manager = DeviceManager() dev_manager.show() sys.exit(app.exec_())
import sys from device_model import DeviceListModel from service_model import ServiceListModel from device_manager import DeviceManager if __name__ == '__main__': QApplication.setGraphicsSystem("raster") app = QApplication(sys.argv) view = QDeclarativeView() engine = view.engine() engine.quit.connect(app.quit) if len(sys.argv) > 1: manager = DeviceManager(sys.argv[1]) else: manager = DeviceManager() deviceListModel = DeviceListModel(manager) serviceListModel = ServiceListModel() deviceListModel.deviceSelected.connect(serviceListModel.loadDevice) view.rootContext().setContextProperty("deviceManager", manager) view.rootContext().setContextProperty("deviceListModel", deviceListModel) view.rootContext().setContextProperty("serviceListModel", serviceListModel) context = view.rootContext() view.setSource(QUrl('./qml/bluez.qml')) view.setMinimumSize(480, 800)
def test_stop_all_devices(self): dm = DeviceManager() assert True is dm.stop_all_devices()
def __init__(self): self.adx_inv_manager= DeviceManager()
def udev_event_callback(action, device): global copy_thread, message_q if not copy_thread: copy_thread = DeviceManager(kwargs={'return_q': message_q, 'action': action, 'device': device}) copy_thread.start()
def test_is_device_open(self): dm = DeviceManager() assert True is dm.is_device_open('dev_name')
def test_get_all_devices_status(self): dm = DeviceManager() assert [True] == dm.get_all_devices_status()
def main(args): # Set up GUI pygame.init() pygame.mouse.set_visible(False) screen = pygame.display.set_mode((320, 240), 0, 32) pygame.display.set_caption('Card Dump') touch_ui.set_screen(screen) # Set up udev event monitoring udev_context = pyudev.Context() udev_monitor = pyudev.Monitor.from_netlink(udev_context) # Monitor all storage device related signals udev_monitor.filter_by('block', 'partition') global observer observer = pyudev.MonitorObserver(udev_monitor, udev_event_callback) observer.start() # Mount and check USB attached partitions for either "DCIM" or "card-dump" indicator # (friendly names are in ID_FS_LABEL(_ENC) property of a device) # sub-routine returns a three item tuple of lists. First is source candidate list, # second is destination candidate list, and third is the empty media list. source_candidates, destination_candidates, empties = DeviceManager.list_media() # if only one DCIM folder: use it as source # if multiple DCIM folders: which one is copied on this run? # if only one card-dump folder: use it as destination # if multiple card-dump folders: which one is used as destination on this run? source_set, destination_set = False, False if len(source_candidates) == 1: DeviceManager.set_source = source_candidates[0] source_set = True elif len(source_candidates) > 1: # Too many source candidates - ask user which one to copy # TODO: Implement "Too many source candidates" list(source_candidates) else: # No source candidates, one might be attached later list(source_candidates) if len(destination_candidates) == 1: DeviceManager.set_destination = destination_candidates[0] destination_set = True elif len(destination_candidates) > 1: # Too many destination candidates - ask user which one to copy # TODO: Implement "Too many destination candidates" list(destination_candidates) else: # No destination candidates, one might be attached later list(destination_candidates) # If there is at least one available "empty" USB media, and no source is set, ask the user # Is this in any way a proper scenario? I mean, if there's no DCIM folder, do we still offer user the # possibility of dump that card? if len(empties) > 0 and not source_set: list(empties) # If there is still at least one available "empty" USB media, and no destination is set, ask the user if len(empties) > 0 and not destination_set: list(empties) touch_ui.quit_button() pygame.display.flip() running = True while running: for event in pygame.event.get(): if event.type == QUIT: clean_up() sys.exit() running = False elif event.type == pygame.MOUSEBUTTONDOWN: # All interactions need to go here? # What's the pattern to check for GUI events? if touch_ui.quit_box_rect.collidepoint(pygame.mouse.get_pos()): clean_up() sys.exit() running = False elif touch_ui.start_copy_rect.collidepoint(pygame.mouse.get_pos()): touch_ui.mock_start_copy(inverse=True) pygame.display.flip() print("Start copying...") # Manual call for testing purposes udev_event_callback('add', 'foo') elif event.type == KEYDOWN and event.key == K_ESCAPE: clean_up(observer) running = False try: touch_ui.update_progress_bar(message_q.get_nowait()) pygame.display.flip() except Queue.Empty: continue pygame.display.update()
def test_get_failed_devices(self): dm = DeviceManager() assert [True] == dm.get_failed_devices()
def test_open_all_devices(self): dm = DeviceManager() assert True is dm.open_all_devices()
def test_access_device(self): dm = DeviceManager() assert True is dm.access_device('dev')
def test_test_device(self): dm = DeviceManager() assert True is DeviceManagertest_device('dev').
def test_get_device_status(self): dm = DeviceManager() assert True is dm.get_device_status('dev_name')
def main(args): # Set up GUI pygame.init() pygame.mouse.set_visible(False) screen = pygame.display.set_mode((320, 240), 0, 32) pygame.display.set_caption('Card Dump') touch_ui.set_screen(screen) # Set up udev event monitoring udev_context = pyudev.Context() udev_monitor = pyudev.Monitor.from_netlink(udev_context) # Monitor all storage device related signals udev_monitor.filter_by('block', 'partition') global observer observer = pyudev.MonitorObserver(udev_monitor, udev_event_callback) observer.start() # Mount and check USB attached partitions for either "DCIM" or "card-dump" indicator # (friendly names are in ID_FS_LABEL(_ENC) property of a device) # sub-routine returns a three item tuple of lists. First is source candidate list, # second is destination candidate list, and third is the empty media list. source_candidates, destination_candidates, empties = DeviceManager.list_media( ) # if only one DCIM folder: use it as source # if multiple DCIM folders: which one is copied on this run? # if only one card-dump folder: use it as destination # if multiple card-dump folders: which one is used as destination on this run? source_set, destination_set = False, False if len(source_candidates) == 1: DeviceManager.set_source = source_candidates[0] source_set = True elif len(source_candidates) > 1: # Too many source candidates - ask user which one to copy # TODO: Implement "Too many source candidates" list(source_candidates) else: # No source candidates, one might be attached later list(source_candidates) if len(destination_candidates) == 1: DeviceManager.set_destination = destination_candidates[0] destination_set = True elif len(destination_candidates) > 1: # Too many destination candidates - ask user which one to copy # TODO: Implement "Too many destination candidates" list(destination_candidates) else: # No destination candidates, one might be attached later list(destination_candidates) # If there is at least one available "empty" USB media, and no source is set, ask the user # Is this in any way a proper scenario? I mean, if there's no DCIM folder, do we still offer user the # possibility of dump that card? if len(empties) > 0 and not source_set: list(empties) # If there is still at least one available "empty" USB media, and no destination is set, ask the user if len(empties) > 0 and not destination_set: list(empties) touch_ui.quit_button() pygame.display.flip() running = True while running: for event in pygame.event.get(): if event.type == QUIT: clean_up() sys.exit() running = False elif event.type == pygame.MOUSEBUTTONDOWN: # All interactions need to go here? # What's the pattern to check for GUI events? if touch_ui.quit_box_rect.collidepoint(pygame.mouse.get_pos()): clean_up() sys.exit() running = False elif touch_ui.start_copy_rect.collidepoint( pygame.mouse.get_pos()): touch_ui.mock_start_copy(inverse=True) pygame.display.flip() print("Start copying...") # Manual call for testing purposes udev_event_callback('add', 'foo') elif event.type == KEYDOWN and event.key == K_ESCAPE: clean_up(observer) running = False try: touch_ui.update_progress_bar(message_q.get_nowait()) pygame.display.flip() except Queue.Empty: continue pygame.display.update()
def test_load_devices_from_db(self): dm = DeviceManager() assert True is dm.load_devices_from_db()
def sighup_handler(): if DeviceManager.get_instance() is not None: DeviceManager.get_instance().sighup_handler()
def setUp(self): self.device_manager = DeviceManager()
def test_close_all_devices(self): dm = DeviceManager() assert True is dm.close_all_devices()
def test_test_all_devices(self): dm = DeviceManager() assert [{"device_name": "xyz", "status": True} ] == dm.test_all_devices()
def test_update_device_property(self): dm = DeviceManager() assert True is dm.update_device_property('device')