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()