ok
Mini Shell
# 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
import argparse
import itertools
import logging
import sys
from datetime import datetime, timedelta, timezone
import sqlalchemy as sa
from sqlalchemy.exc import OperationalError, ProgrammingError
import lvestats.lib.commons.decorators
from lvestats.lib.bursting.history import HistoryShowBursting, TableDoesNotExistError
from lvestats.lib.commons.argparse_utils import ParseDatetime, check_non_negative_int
from lvestats.lib.commons.dateutil import gm_to_local, local_to_gm
from lvestats.lib.commons.func import get_ascii_table
from lvestats.lib.commons.logsetup import setup_logging
from lvestats.lib.config import ConfigError, read_config
from lvestats.lib.dbengine import make_db_engine, MakeDbException
from lvestats.orm import BurstingEventType, bursting_events_table
from lvestats.plugins.generic.burster.config import is_bursting_supported
log = setup_logging({},
caller_name='lve-bursting-info',
file_level=logging.WARNING,
console_level=logging.ERROR)
@lvestats.lib.commons.decorators.no_sigpipe
def main() -> None:
if not is_bursting_supported():
print('Bursting Limits feature is not supported in current environment')
sys.exit(1)
try:
cfg = read_config()
dbengine = make_db_engine(cfg=cfg)
output = _main(cfg, dbengine, sys.argv[1:])
if output:
print(output)
except TableDoesNotExistError as e:
print(e.message)
print('Enable Bursting Limits feature to create the table')
sys.exit(1)
except (OperationalError, ProgrammingError, ConfigError, MakeDbException) as e:
log.error('Error occurred while executing the "lve-bursting-info" utility',
exc_info=e)
sys.exit(1)
def _main(config: dict[str, str],
dbengine: sa.engine.base.Engine,
argv: list[str]) -> str:
namespace = _parse_args(config, argv)
# Convert date and time to UTC
period_from_utc = local_to_gm(getattr(namespace, 'from')) # 'from' is a reserved word
period_to_utc = local_to_gm(namespace.to)
history_show = HistoryShowBursting(
dbengine=dbengine,
period_from=period_from_utc,
period_to=period_to_utc,
uid=namespace.id,
server_id=namespace.server_id,
)
rows = history_show.get()
table = _build_table(rows, period_from_utc, period_to_utc)
return table
def _parse_args(config: dict[str, str], argv: list[str]) -> argparse.Namespace:
parser = argparse.ArgumentParser(
description="Utility for displaying bursting limits statistics")
parser.add_argument(
'--id',
type=check_non_negative_int,
help='display records only for the specified LVE id')
parser.add_argument(
'--server-id',
type=str,
default=config.get('server_id', 'localhost'),
help='used with central database for multiple servers, default "%(default)s"')
# filtering output data by time period
group_period = parser.add_argument_group()
datetime_now = datetime.now()
# default time delta is 1 hour
# if the value is modified, don't forget to fix the CLI message
default_timedelta = timedelta(hours=1)
group_period.add_argument(
'-f', '--from',
action=ParseDatetime,
default=datetime_now - default_timedelta,
nargs='+',
help='display records from the specified date and time; '
'if not provided, will assume the last 1-hour time frame',
metavar='YYYY-MM-DD[ HH:MM]')
group_period.add_argument(
'-t', '--to',
action=ParseDatetime,
default=datetime_now,
nargs='+',
help='display records up to the specified date and time; '
'if not provided, will include records up to the current time',
metavar='YYYY-MM-DD[ HH:MM]')
return parser.parse_args(argv)
def _build_table(rows: list[sa.engine.RowProxy],
dt_from: datetime,
dt_to: datetime) -> str:
"""
Build string representation of a console-displayable table
using the rows retrieved from the DB table.
"""
table_rows = _build_table_rows(rows,
dt_from.timestamp(),
dt_to.timestamp())
table = get_ascii_table(table_rows,
fields=['ID', 'From', 'To'],
padding_width=1)
return table
class TableRow(list):
DEFAULT_FORMAT = '%Y-%m-%d %H:%M:%S.%f'
def __init__(self,
lve_id: int,
start: float,
end: float,
format_: str = DEFAULT_FORMAT):
# Convert date and time to local
dt_start = gm_to_local(datetime.fromtimestamp(start, timezone.utc))
dt_end = gm_to_local(datetime.fromtimestamp(end, timezone.utc))
super().__init__([lve_id,
dt_start.strftime(format_),
dt_end.strftime(format_)])
def _build_table_rows(rows: list[sa.engine.RowProxy],
ts_from: float,
ts_to: float) -> list[TableRow]:
"""
Build table rows representing time frame intervals
when bursting was enabled for each LVE id.
"""
result: list[TableRow] = []
grouped_data = itertools.groupby(
rows, key=lambda row: row[bursting_events_table.c.lve_id])
for lve_id, group in grouped_data:
group = list(group)
first_event_idx = 0
ts_from_, ts_to_ = None, None
# If there is an event whose timestamp is less than 'ts_from',
# attempting to detect whether bursting was already enabled
# when the required time frame started
if group[0][bursting_events_table.c.timestamp] < ts_from:
first_event_idx = 1
if group[0][bursting_events_table.c.event_type] == BurstingEventType.STARTED.value:
ts_from_ = ts_from
# Construct intervals for the certain LVE id
for i in range(first_event_idx, len(group)):
if group[i][bursting_events_table.c.event_type] == BurstingEventType.STARTED.value:
if ts_from_ is None:
ts_from_ = group[i][bursting_events_table.c.timestamp]
continue
else:
if ts_from_ is None:
continue
ts_to_ = group[i][bursting_events_table.c.timestamp]
result.append(TableRow(lve_id, ts_from_, ts_to_))
ts_from_, ts_to_ = None, None
# Assuming bursting-enabled interval ends after the required time frame
if ts_from_ is not None:
result.append(TableRow(lve_id, ts_from_, ts_to))
return result
Zerion Mini Shell 1.0