def get_chunked_trace_output_file(self, session_id): dir_path = Path(self.rec_dir) rec_dir = dir_path.joinpath(session_id) x = SessionStore() x.ensure_directory_created(rec_dir) target_file = rec_dir.joinpath( PersistedSession.chunked_recording_filename) return target_file
class TraceSession: recording_directory: Path files_in_session: Set[str] excluded_files: Set[str] environment_during_run: dict event_buffer: List[Any] def __init__(self): self.files_in_session = set() self.excluded_files = set() self.environment_during_run = dict() self.session_store = SessionStore() def buffer_became_available(self, event_buffer): self.event_buffer = event_buffer def did_enter_traceable_file(self, filename: str): self.files_in_session.add(filename) def will_skip_file(self, filename: str): self.excluded_files.add(filename) def save(self): persistent_session = self.session_store.new_session(self.session_name) persistent_session.save_with_metadata(self.event_buffer, self.files_in_session, self.excluded_files)
async def load_sessions(sid): logging.debug('Loading sessions') store = SessionStore() all_names = store.all_sessions() result = [] for name in all_names: try: lazy_loaded = store.load_session(name) lazy_loaded.load_metadata() metadata = lazy_loaded.raw_metadata metadata['short_name'] = name except: metadata = dict() metadata['short_name'] = name metadata['events_in_session'] = 'missing meta' result.append(metadata) logging.debug(f'Sessions loaded, sending back to client {sid}') await shared.tracer_socket_server.emit('session_list_loaded', result, room=sid) pass
async def load_single_session(req, sid): logger.info('begin: load_single_session...') store = SessionStore() session_name = req.get('session_name') logging.info(f'Loading session {session_name}') ses = store.load_session(session_name) # await sio.emit('reply', to_string(buffer), room=sid) try: logger.info('sending reply...') file_as_bytes = ses.load_buffer().SerializeToString() logger.info('bytes loaded...') # todo maybe send back in chunks? await shared.tracer_socket_server.emit('reply', data=file_as_bytes , room=sid ) logger.info('Event sent') except Exception as ex: logger.exception('Failed to load session ' + session_name, exc_info=ex)
def test_write(): x = SessionStore() x.ensure_recording_directory_created() directory__joinpath = Path(x.recording_directory).joinpath('session_fake') x.ensure_directory_created(directory__joinpath) target_file = directory__joinpath.joinpath( PersistedSession.chunked_recording_filename) os.remove(target_file) write_once(target_file, 1) write_once(target_file, 2) write_once(target_file, 3)
def get_metadata_bytes(self, session_id, files_included: List[str], files_excluded: List[str]): dir_path = Path(self.rec_dir) rec_dir = dir_path.joinpath(session_id) x = SessionStore() target_chunk_file = rec_dir.joinpath( PersistedSession.chunked_recording_filename) bytes_written = target_chunk_file.stat().st_size metadata_file_path = rec_dir.joinpath( PersistedSession.metadata_filename) meta = TraceSessionMetadata() meta.files_in_session = files_included meta.excluded_files = files_excluded meta.file_size_in_bytes = bytes_written meta.file_size_on_disk = str(HumanReadableByteSize(bytes_written)) trace_in_progress = incoming_traces.get_session_with_id(session_id) meta.events_in_session = trace_in_progress.total_events meta.start_time = trace_in_progress.started_at meta.end_time = datetime.utcnow() meta.name = str(session_id) result = jsonpickle.dumps(meta, unpicklable=False) metadata_bytes = result.encode('utf-8') return metadata_bytes, metadata_file_path
def test_read(): x = SessionStore() x.ensure_recording_directory_created() directory__joinpath = Path(x.recording_directory).joinpath('session_fake') x.ensure_directory_created(directory__joinpath) header_size = struct.calcsize("i") target_file = directory__joinpath.joinpath( PersistedSession.chunked_recording_filename) with io.FileIO(target_file, 'r') as file_to_read: while True: header_bytes = file_to_read.read(header_size) if len(header_bytes) <= 0: print(f' -- Read to end') break next_chunk_length = struct.unpack('i', header_bytes)[0] print(f'next_chunk_length {next_chunk_length}') read_bytes = file_to_read.read(next_chunk_length) result = read_bytes.decode('utf-8') print(f'result {result}')
def __init__(self): x = SessionStore() x.ensure_recording_directory_created() self.rec_dir = x.recording_directory self.trace_files = dict() pass
def test_load_sessions(): x = SessionStore() print(x.all_sessions())
def test_session_store(): x = SessionStore() session = x.load_session('a') session.load_metadata() print(vars(session.metadata))
def __init__(self): self.files_in_session = set() self.excluded_files = set() self.environment_during_run = dict() self.session_store = SessionStore()