def program_session_create_or_add(connection: Connection, hostname: str,
username: str, elapsed_seconds: int,
program_name: str,
pids: Iterable[int]) -> int:
"Either create a new program session or update an existing one."
program = Program.search(connection, name=program_name)
program_session = ProgramSession.search(connection,
program=program.id,
hostname=hostname,
username=username,
end=None)
if program_session is None:
program_session_id = ProgramSession.insert(
connection,
end=None,
hostname=hostname,
pids=",".join(sorted(pids)),
program=program.id,
start=datetime.datetime.now(),
username=username,
)
LOGGER.debug("Created new program session %s", program_session_id)
else:
program_session_id = program_session.id
ProgramSession.update(
connection,
program_session_id,
pids=",".join(sorted(pids)),
)
LOGGER.debug("Updated program session %d to have pids %s",
program_session_id, sorted(pids))
return program_session_id
def test_session_close(self):
"Can we close a session after opening it?"
program_session_id = self.make_program_session()
program_session = ProgramSession.get(self.db, program_session_id)
self.assertEqual(program_session.end, None)
queries.program_session_close(self.db, program_session.id)
program_session = ProgramSession.get(self.db, program_session_id)
self.assertNotEqual(program_session.end, None)
def get_program_sessions_current(
connection: Connection) -> Iterable[ProgramSession]:
"""Get the program sessions that are interesting to enforcement.
This includes all sessions, opened and closed, since the start
of the earlier of the start of the week or month as well as any
open sessions.
"""
now = datetime.datetime.now()
program_sessions_open = list(ProgramSession.list(connection, end=None))
month_start = datetime.datetime(
year=now.year,
month=now.month,
day=1,
hour=0,
minute=0,
second=0,
)
week_start = now - datetime.timedelta(days=now.isoweekday() - 1)
week_start = datetime.datetime(
year=week_start.year,
month=week_start.month,
day=week_start.day,
hour=0,
minute=0,
second=0,
)
earliest = min(month_start, week_start)
program_sessions_past = list(
queries.program_session_list_since(connection, earliest))
return program_sessions_past + program_sessions_open
def program_session_list_by_program(
connection: Connection, program_id: int) -> Iterable[ProgramSession]:
"""Get all the program sessions for a particular program."""
for data in connection.cursor.execute(
"SELECT id, end, start, program FROM ProgramSession WHERE program == ? ORDER BY start",
(program_id, )):
yield ProgramSession(
id_=data[0],
end=data[1],
start=data[2],
program_id=data[3],
)
def test_session_create_or_add_create(self):
"Can we create a session when one does not exist?"
program_session_id = queries.program_session_create_or_add(
self.db,
elapsed_seconds=0,
hostname="testhost",
program_name="Minecraft",
pids=[],
username="******",
)
results = ProgramSession.get(self.db, program_session_id)
self.assertEqual(results.program, self.program_id)
def make_program_session(self,
end: Optional[datetime.datetime] = None,
start: Optional[datetime.datetime] = None) -> int:
return ProgramSession.insert(
self.db,
end=end,
hostname="testhost",
pids="",
program=self.program_id,
start=start or datetime.datetime.now(),
username="******",
)
def test_week_split(self):
"Can we capture time spent this week outside this month?"
# program session for this week, but not this month
ProgramSession.insert(
self.db,
end = datetime.datetime(2020, 2, 1, 10, 0, 0),
hostname = "testhost",
pids = "",
program = self.programs[0],
start = datetime.datetime(2020, 2, 1, 9, 10, 0),
username = "******",
)
# program session last month, last week
ProgramSession.insert(
self.db,
end = datetime.datetime(2020, 1, 25, 10, 0, 0),
hostname = "testhost",
pids = "",
program = self.programs[1],
start = datetime.datetime(2020, 1, 25, 9, 0, 0),
username = "******",
)
# program session earlier today
ProgramSession.insert(
self.db,
end = datetime.datetime(2020, 2, 2, 10, 0, 0),
hostname = "testhost",
pids = "",
program = self.programs[1],
start = datetime.datetime(2020, 2, 2, 9, 0, 0),
username = "******",
)
with freezegun.freeze_time("2020-02-02 11:00:00"):
result = enforcement.get_program_sessions_current(self.db)
self.assertEqual(len(result), 2)
def program_session_close_except(
connection: Connection,
hostname: str,
exempt_program_names: Iterable[str],
) -> None:
"Close all program_sessions, except any for the named programs."
now = datetime.datetime.now()
programs = Program.list(connection)
program_id_to_name = {program.id: program.name for program in programs}
open_sessions = ProgramSession.list(connection,
hostname=hostname,
end=None)
for program_session in open_sessions:
program_name = program_id_to_name[program_session.program]
if program_name in exempt_program_names:
continue
ProgramSession.update(
connection,
program_session.id,
end=now,
)
LOGGER.info("Ended program session %s", program_session.id)
def program_session_list_since(
connection: Connection,
moment: datetime.datetime,
programs: Optional[List[int]],
username: Optional[str] = None) -> Iterable[ProgramSession]:
"""Get all program sessions that started after a moment."""
if programs is None:
where = "start > ?"
bindings = [
moment,
]
else:
where = "start > ? AND program IN ({})".format(",".join(["?"] *
len(programs)))
bindings = [moment] + programs
if username is not None:
where += " AND username = ?"
bindings.append(username)
return ProgramSession.list_where(
connection,
where=where,
bindings=bindings,
)