# coding=utf-8
#
# Copyright © Cloud Linux GmbH & Cloud Linux Software, Inc 2010-2023 All Rights Reserved
#
# Licensed under CLOUD LINUX LICENSE AGREEMENT
# http://cloudlinux.com/docs/LICENSE.TXT
from typing import Callable, TypedDict
import sqlalchemy as sa
from lvestats.orm import BurstingEventType, bursting_events_table
from ..common import LveId, Timestamp
from ..history import LveHistory, IntervalType, get_interval_type_after
from ..utils import bootstrap_gen
from .._logs import logger
class _OutBurstingEventRow(TypedDict):
lve_id: LveId
timestamp: Timestamp
event_type: BurstingEventType
def load_bursting_enabled_intervals_from_db(
engine: sa.engine.Engine,
cutoff: Timestamp,
server_id: str,
) -> dict[LveId, LveHistory]:
lve_to_asm = {}
with engine.begin() as conn:
first_events_stmt = (
sa.select([
bursting_events_table.c.lve_id,
sa.func.max(bursting_events_table.c.timestamp).label("timestamp"),
])
.where(sa.and_(
bursting_events_table.c.timestamp <= cutoff,
bursting_events_table.c.server_id == server_id,
))
.group_by(
bursting_events_table.c.lve_id
)
.alias('first_events')
)
all_events_stmt = (
sa.select([
bursting_events_table.c.server_id,
bursting_events_table.c.lve_id,
bursting_events_table.c.timestamp,
bursting_events_table.c.event_type,
])
.select_from(
bursting_events_table.outerjoin(
first_events_stmt,
bursting_events_table.c.lve_id == first_events_stmt.c.lve_id,
)
)
.where(sa.and_(
bursting_events_table.c.server_id == server_id,
bursting_events_table.c.timestamp >= sa.func.coalesce(
first_events_stmt.c.timestamp,
cutoff,
)
))
.order_by(
bursting_events_table.c.timestamp.asc(),
)
)
result = conn.execute(all_events_stmt)
assert isinstance(result, sa.engine.ResultProxy)
rows = result.fetchall()
assert rows is not None
for row in rows:
row: _OutBurstingEventRow
lve_id = row['lve_id']
try:
asm = lve_to_asm[lve_id]
except KeyError:
asm = lve_to_asm[lve_id] = _LveHistoryAssembler(lve_id, row)
asm.process_row(row)
return {lve_id: asm.create() for lve_id, asm in lve_to_asm.items()}
class _LveHistoryAssembler:
def __init__(self, lve_id: LveId, first_event: _OutBurstingEventRow) -> None:
self._lve_id = lve_id
self._first_interval_type = (
IntervalType.OVERUSING if first_event['event_type'] == BurstingEventType.STARTED else IntervalType.NORMAL
)
@bootstrap_gen
def assembler_gen():
prev_event = first_event
while True:
event: _OutBurstingEventRow = yield
if event['event_type'] == prev_event['event_type']:
logger.debug(
'Skipping consecutive "%s" events for lve_id=%s',
event['event_type'], lve_id,
)
continue
self._timestamps.append(event['timestamp'])
prev_event = event
self.process_row: Callable[[_OutBurstingEventRow], None] = assembler_gen().send
self._timestamps: list[Timestamp] = [first_event['timestamp']]
def create(self) -> LveHistory:
timestamps = self._timestamps
last_interval_type = get_interval_type_after(self._first_interval_type, len(timestamps))
if last_interval_type == IntervalType.OVERUSING:
timestamps = timestamps[:-1]
logger.warning("Last interval for lve_id=%s is not closed!", self._lve_id)
if len(timestamps) == 0:
return LveHistory()
return LveHistory(self._first_interval_type, tuple(timestamps))
|