def test_listeners(self): listener = DummyStatusListener() listener.notify = MagicMock() status = Status() status.add_listener(listener) status.server.up = False listener.notify.assert_called_once_with() listener.notify.reset_mock() status.server.error_msg = "Everything's good" listener.notify.assert_called_once_with()
def read(self, chunk_handle, start_offset, numbytes): start_offset = int(start_offset) numbytes = int(numbytes) try: with open(os.path.join(self.root, chunk_handle), "r") as f: f.seek(start_offset) ret = f.read(numbytes) except Exception as e: return Status(-1, "ERROR: " + str(e)) else: return Status(0, ret)
def delete_file(self, file_path): status = self.check_valid_file(file_path) if status.v != 0: return status try: self.meta.mark_delete(file_path) except Exception as e: return Status(-1, "ERROR: " + str(e)) else: return Status( 0, "SUCCESS: file {} is marked deleted".format(file_path))
def test_copy_doesnt_copy_listeners(self): status = Status() listener = DummyStatusListener() listener.notify = MagicMock() status.add_listener(listener) copy = status.copy() status.server.error_msg = "a" listener.notify.assert_called_once_with() listener.notify.reset_mock() copy.server.error_msg = "b" listener.notify.assert_not_called()
def undelete_file(self, file_path): if file_path not in self.meta.files: return Status( -1, "ERROR: file {} doesn't exist, already garbage collected or never created" .format(file_path)) elif self.meta.files[file_path].delete is not True: return Status( -1, "ERROR: file {} is not marked deleted".format(file_path)) try: self.meta.unmark_delete(file_path) except Exception as e: return Status(-1, "ERROR: " + str(e)) else: return Status(0, "SUCCESS: file {} is restored".format(file_path))
def post_status(): global status action = request.args.get('action') # query print(f'post_status, action: {action}') status = Status(int(action)) pub_web.publish(status.value) return 'POST'
def create_new_file(self, file_path, chunk_handle): if file_path in self.files: return Status(-1, "ERROR: File exists already: {}".format(file_path)) fl = File(file_path) self.files[file_path] = fl status = self.create_new_chunk(file_path, -1, chunk_handle) return status
def test_components_registered(self): # Test that all components were registered # This is done through the copy method status = Status() status.server.up = False status.server.error_msg = "an error message" copy = status.copy() self.assertEqual(False, copy.server.up) self.assertEqual("an error message", copy.server.error_msg) time1 = datetime.now() time2 = datetime.now() status.controller.latest_local_scan_time = time1 status.controller.latest_remote_scan_time = time2 copy = status.copy() self.assertEqual(time1, copy.controller.latest_local_scan_time) self.assertEqual(time2, copy.controller.latest_remote_scan_time)
def append_file(self, file_path): status = self.check_valid_file(file_path) if status.v != 0: return None, None, status latest_chunk_handle = self.meta.get_latest_chunk(file_path) locs = self.meta.get_chunk_locs(latest_chunk_handle) status = Status(0, "Append handled") return latest_chunk_handle, locs, status
def test_event_names(self): serialize = SerializeStatus() status = Status() out = parse_stream(serialize.status(status)) self.assertEqual("status", out["event"]) status.server.up = False status.server.error_msg = "Bad stuff happened" out = parse_stream(serialize.status(status)) self.assertEqual("status", out["event"])
def test_controller_status_latest_remote_scan_failed(self): serialize = SerializeStatus() status = Status() out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertIsNone(data["controller"]["latest_remote_scan_failed"]) status.controller.latest_remote_scan_failed = True out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertEqual(True, data["controller"]["latest_remote_scan_failed"])
def test_server_status_error_msg(self): serialize = SerializeStatus() status = Status() out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertEqual(None, data["server"]["error_msg"]) status.server.up = False status.server.error_msg = "Bad stuff happened" out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertEqual("Bad stuff happened", data["server"]["error_msg"])
def test_controller_status_latest_remote_scan_error(self): serialize = SerializeStatus() status = Status() out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertIsNone(data["controller"]["latest_remote_scan_error"]) status.controller.latest_remote_scan_error = "remote server went boom" out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertEqual("remote server went boom", data["controller"]["latest_remote_scan_error"])
def test_controller_status_latest_remote_scan_time(self): serialize = SerializeStatus() status = Status() out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertIsNone(data["controller"]["latest_remote_scan_time"]) timestamp = datetime(2018, 11, 9, 21, 40, 18, tzinfo=timezone('UTC')) status.controller.latest_remote_scan_time = timestamp out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertEqual(str(1541799618.0), data["controller"]["latest_remote_scan_time"])
def read_file(self, file_path, offset, numbytes): status = self.check_valid_file(file_path) if status.v != 0: return status chunk_size = cfg.chunk_size start_chunk = offset // chunk_size all_chunks = list(self.meta.files[file_path].chunks.keys()) if start_chunk > len(all_chunks): return Status(-1, "ERROR: Offset is too large") start_offset = offset % chunk_size if numbytes == -1: end_offset = chunk_size end_chunk = len(all_chunks) - 1 else: end_offset = offset + numbytes - 1 end_chunk = end_offset // chunk_size end_offset = end_offset % chunk_size all_chunk_handles = all_chunks[start_chunk:end_chunk + 1] ret = [] for idx, chunk_handle in enumerate(all_chunk_handles): if idx == 0: stof = start_offset else: stof = 0 if idx == len(all_chunk_handles) - 1: enof = end_offset else: enof = chunk_size - 1 loc = self.meta.files[file_path].chunks[chunk_handle].locs[0] ret.append(chunk_handle + "*" + loc + "*" + str(stof) + "*" + str(enof - stof + 1)) ret = "|".join(ret) return Status(0, ret)
def test_controller_status_latest_remote_scan_time(self): serialize = SerializeStatus() status = Status() out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertIsNone(data["controller"]["latest_remote_scan_time"]) timestamp = datetime.now() time_float = time.mktime( timestamp.timetuple()) + timestamp.microsecond / 1E6 status.controller.latest_remote_scan_time = timestamp out = parse_stream(serialize.status(status)) data = json.loads(out["data"]) self.assertEqual(str(time_float), data["controller"]["latest_remote_scan_time"])
def test_copy_values(self): status = Status() status.server.up = False status.server.error_msg = "Bad error" copy = status.copy() self.assertEqual(False, copy.server.up) self.assertEqual("Bad error", copy.server.error_msg) # Modifying original doesn't touch copy status.server.up = True status.server.error_msg = "No error" self.assertEqual(True, status.server.up) self.assertEqual("No error", status.server.error_msg) self.assertEqual(False, copy.server.up) self.assertEqual("Bad error", copy.server.error_msg) # Modifying copy doesn't touch original copy.server.up = False copy.server.error_msg = "Worse error" self.assertEqual(True, status.server.up) self.assertEqual("No error", status.server.error_msg) self.assertEqual(False, copy.server.up) self.assertEqual("Worse error", copy.server.error_msg)
def setUp(self): self.context = MagicMock() self.controller = MagicMock() # Mock the base logger logger = logging.getLogger() handler = logging.StreamHandler(sys.stdout) logger.addHandler(handler) logger.setLevel(logging.DEBUG) formatter = logging.Formatter( "%(asctime)s - %(levelname)s - %(name)s - %(message)s") handler.setFormatter(formatter) self.context.logger = logger # Model files self.model_files = [] # Real status self.context.status = Status() # Real config self.context.config = Config() # Real auto-queue persist self.auto_queue_persist = AutoQueuePersist() # Capture the model listener def capture_listener(listener): self.model_listener = listener return self.model_files self.model_listener = None self.controller.get_model_files_and_add_listener = MagicMock() self.controller.get_model_files_and_add_listener.side_effect = capture_listener self.controller.remove_model_listener = MagicMock() # noinspection PyTypeChecker self.web_app_builder = WebAppBuilder(self.context, self.controller, self.auto_queue_persist) self.web_app = self.web_app_builder.build() self.test_app = TestApp(self.web_app)
def parse(b: bytes) -> Status: # print(" ".join(f"{int(b_):x}" for b_ in b)) model_code = int.from_bytes(b[3:5], "big") errors = int.from_bytes(b[8:10], "big") media_width = int(b[10]) media_type = int(b[11]) media_length = int(b[17]) status_type = int(b[18]) phase = int(b[19]) notification = int(b[22]) text_color = int(b[25]) # print(f"0x{text_color:x}") return Status(model=models.get(model_code, "Unknown"), media_width=media_width, media_length=media_length, media_type=media_types.get(media_type, "Unknown"), errors=errors, status_type=StatusType(status_type), phase=PhaseState(phase), notification=notification)
def test_property_values(self): status = Status() status.server.up = True status.server.error_msg = "Everything's good" self.assertEqual(True, status.server.up) self.assertEqual("Everything's good", status.server.error_msg)
def get_status(self): self._status = Status.from_dict(api.get_status(self._token)) return self._status
def __init__(self): # Parse the args args = self._parse_args() # Create/load config config = None self.config_path = os.path.join(args.config_dir, Seedsync.__FILE_CONFIG) create_default_config = False if os.path.isfile(self.config_path): try: config = Config.from_file(self.config_path) except (ConfigError, PersistError): Seedsync.__backup_file(self.config_path) # set config to default create_default_config = True else: create_default_config = True if create_default_config: # Create default config config = Seedsync._create_default_config() config.to_file(self.config_path) # Determine the true value of debug is_debug = args.debug or config.general.debug # Create context args ctx_args = Args() ctx_args.local_path_to_scanfs = args.scanfs ctx_args.html_path = args.html ctx_args.debug = is_debug ctx_args.exit = args.exit # Logger setup # We separate the main log from the web-access log logger = self._create_logger(name=Constants.SERVICE_NAME, debug=is_debug, logdir=args.logdir) Seedsync.logger = logger web_access_logger = self._create_logger( name=Constants.WEB_ACCESS_LOG_NAME, debug=is_debug, logdir=args.logdir) logger.info( "Debug mode is {}.".format("enabled" if is_debug else "disabled")) # Create status status = Status() # Create context self.context = Context(logger=logger, web_access_logger=web_access_logger, config=config, args=ctx_args, status=status) # Register the signal handlers signal.signal(signal.SIGTERM, self.signal) signal.signal(signal.SIGINT, self.signal) # Print context to log self.context.print_to_log() # Load the persists self.controller_persist_path = os.path.join( args.config_dir, Seedsync.__FILE_CONTROLLER_PERSIST) self.controller_persist = self._load_persist( ControllerPersist, self.controller_persist_path) self.auto_queue_persist_path = os.path.join( args.config_dir, Seedsync.__FILE_AUTO_QUEUE_PERSIST) self.auto_queue_persist = self._load_persist( AutoQueuePersist, self.auto_queue_persist_path)
def test_cannot_replace_component(self): status = Status() new_server = Status.ServerStatus() with self.assertRaises(ValueError) as e: status.server = new_server self.assertEqual("Cannot reassign component", str(e.exception))
def test_default_values(self): status = Status() self.assertEqual(True, status.server.up) self.assertEqual(None, status.server.error_msg) self.assertEqual(None, status.controller.latest_local_scan_time) self.assertEqual(None, status.controller.latest_remote_scan_time)
def callback(status): global STATUS print(f'[main.py]: got status {status}') STATUS = Status(status.data) publishers.status.publish(STATUS.value)