def __init__(self, timestamp: datetime, sensor: str, target: str, power: float, metadata: Dict[str, Any] = {}):
"""
Initialize a Power report using the given parameters.
:param datetime timestamp: Report timestamp
:param str sensor: Sensor name
:param str target: Target name
:param float power: Power value
:param dict metadata: Metadata values, can be anything that add useful information
"""
Report.__init__(self, timestamp, sensor, target, metadata)
self.power = power
def __init__(self, timestamp: datetime, sensor: str, target: str, groups: Dict[str, Dict]):
"""
Initialize an HWPC report using the given parameters.
:param datetime timestamp: Timestamp of the report
:param str sensor: Sensor name
:param str target: Target name
:param Dict groups: Events groups
"""
Report.__init__(self, timestamp, sensor, target)
#: (dict): Events groups
self.groups = groups
def from_csv_lines(lines: CsvLines) -> PowerReport:
"""
:param lines: list of pre-parsed lines. a line is a tuple composed with :
- the file name where the line were read
- a dictionary where key is column name and value is the value read from the line
:return: a PowerReport that contains value from the given lines
"""
if len(lines) != 1:
raise BadInputData('a power report could only be parsed from one csv line', None)
file_name, row = lines[0]
try:
sensor_name = row['sensor']
target = row['target']
timestamp = Report._extract_timestamp(row['timestamp'])
power = float(row['power'])
metadata = {}
for key in row.keys():
if key not in CSV_HEADER_POWER:
metadata[key] = row[key]
return PowerReport(timestamp, sensor_name, target, power, metadata)
except KeyError as exn:
raise BadInputData('missing field ' + str(exn.args[0]) + ' in csv file ' + file_name, row) from exn
except ValueError as exn:
raise BadInputData(exn.args[0], row) from exn
def __init__(self,
timestamp: datetime,
sensor: str,
target: str,
usage: Dict,
global_cpu_usage: float,
metadata: Dict[str, Any] = {}):
"""
Initialize an Procfs report using the given parameters.
:param datetime timestamp: Timestamp of the report
:param str sensor: Sensor name
:param str target: Target name
:param Dict[str,float] usage : CGroup name and cpu_usage
:param float global_cpu_usage : The global CPU usage, with untracked process
"""
Report.__init__(self, timestamp, sensor, target, metadata)
#: (dict): Events groups
self.usage = usage
self.global_cpu_usage = global_cpu_usage
def from_csv_lines(lines: CsvLines) -> ProcfsReport:
""" Extract a ProcfsReport from a csv"""
sensor_name = None
target = None
timestamp = None
usage = {}
global_cpu_usage = None
metadata = {}
for file_name, row in lines:
cgroup_name = file_name[:-4] if file_name[
len(file_name) - 4:] == '.csv' else file_name
try:
if sensor_name is None:
sensor_name = row['sensor']
target = row['target']
timestamp = Report._extract_timestamp(row['timestamp'])
global_cpu_usage = row['global_cpu_usage']
else:
if sensor_name != row['sensor']:
raise BadInputData(
'csv line with different sensor name are mixed into one report',
{})
if target != row['target']:
raise BadInputData(
'csv line with different target are mixed into one report',
{})
if timestamp != ProcfsReport._extract_timestamp(
row['timestamp']):
raise BadInputData(
'csv line with different timestamp are mixed into one report',
{})
if global_cpu_usage != row['global_cpu_usage']:
raise BadInputData(
'Different cpu usage are provided in one report',
{})
ProcfsReport._create_cgroup(row, cgroup_name, usage)
for key, value in row.items():
if key not in CSV_HEADER_PROCFS:
metadata[key] = value
except KeyError as exn:
raise BadInputData(
'missing field ' + str(exn.args[0]) + ' in csv file ' +
file_name, {}) from exn
except ValueError as exn:
raise BadInputData(exn.args[0], row) from exn
return ProcfsReport(timestamp, sensor_name, target, usage,
global_cpu_usage, metadata)
def from_json(data: Dict) -> Report:
"""
Generate a report using the given data.
:param data: Dictionary containing the report attributes
:return: The HWPC report initialized with the given data
"""
try:
ts = Report._extract_timestamp(data['timestamp'])
metadata = {} if 'metadata' not in data else data['metadata']
return PowerReport(ts, data['sensor'], data['target'], data['power'], metadata)
except KeyError as exn:
raise BadInputData('PowerReport require field ' + str(exn.args[0]) + ' in json document', data) from exn
except ValueError as exn:
raise BadInputData(exn.args[0], data) from exn