def _insert_agent_device(self):
"""Insert first agent and device in the database.
Args:
None
Returns:
None
"""
# Initialize key variables
idx_agent = 1
idx_device = 1
# Add agent
if db_agent.idx_agent_exists(idx_agent) is False:
# Generate a UID and add a record in the database
record = Agent(id_agent=general.encode(self.reserved),
name=general.encode(self.reserved))
database = db.Database()
database.add(record, 1109)
# Add device
if db_device.idx_device_exists(idx_device) is False:
record = Device(description=general.encode(self.reserved),
devicename=general.encode(self.reserved))
database = db.Database()
database.add(record, 1106)
# Add to Agent / Device table
if db_deviceagent.device_agent_exists(idx_device, idx_agent) is False:
record = DeviceAgent(idx_device=idx_device, idx_agent=idx_agent)
database = db.Database()
database.add(record, 1107)
def _setup_db_deviceagent(data):
"""Create the database for DeviceAgent table testing.
Args:
None
Returns:
result: Tuple of (idx_device, idx_agent)
"""
# Initialize key variables
devicename = data['devicename']
description = data['device_description']
id_agent = data['id_agent']
agent_name = data['agent']
last_timestamp = data['timestamp']
# Add AgentName record to the database
record = AgentName(name=general.encode(agent_name))
database = db.Database()
database.add(record, 1031)
# Add Agent record to the database
record = Agent(id_agent=general.encode(id_agent))
database = db.Database()
database.add(record, 1031)
# Get idx_agent value from database
agent_info = db_agent.GetIDAgent(id_agent)
idx_agent = agent_info.idx_agent()
# Add record to the database
dev_record = Device(description=general.encode(description),
devicename=general.encode(devicename))
database = db.Database()
database.add(dev_record, 1034)
# Get idx of newly added device
device_info = db_device.GetDevice(devicename)
idx_device = device_info.idx_device()
# Update DeviceAgent table
if hagent.device_agent_exists(idx_device, idx_agent) is False:
# Add to DeviceAgent table
da_record = DeviceAgent(idx_device=idx_device, idx_agent=idx_agent)
database = db.Database()
database.add(da_record, 1020)
# Update DeviceAgent table with timestamp
database = db.Database()
session = database.session()
record = session.query(DeviceAgent).filter(
and_(DeviceAgent.idx_device == idx_device,
DeviceAgent.idx_agent == idx_agent)).one()
record.last_timestamp = last_timestamp
database.commit(session, 1042)
# Return
result = (idx_device, idx_agent)
return result
def test_valid(self):
"""Testing function valid."""
# Initialize key variables
devicename = self.data['devicename']
id_agent = self.data['id_agent']
last_timestamp = self.data['timestamp']
# Drop the database and create tables
unittest_setup_db.TestData()
# Add record to the database
record = Agent(id_agent=general.encode(id_agent))
database = db.Database()
database.add(record, 1040)
# Test must be good as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), True)
# Get idx_agent value from database
data = db_agent.GetIDAgent(id_agent)
idx_agent = data.idx_agent()
# Add record to the database
record = Device(devicename=general.encode(devicename))
database = db.Database()
database.add(record, 1024)
# Test must be good as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), True)
# Get idx of newly added device
device_info = db_device.GetDevice(devicename)
idx_device = device_info.idx_device()
# Update DeviceAgent table
if hagent.device_agent_exists(idx_device, idx_agent) is False:
# Add to DeviceAgent table
record = DeviceAgent(idx_device=idx_device, idx_agent=idx_agent)
database = db.Database()
database.add(record, 1055)
# Test must be good as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), True)
# Update database with timestamp
database = db.Database()
session = database.session()
record = session.query(DeviceAgent).filter(
and_(DeviceAgent.idx_device == idx_device,
DeviceAgent.idx_agent == idx_agent)).one()
record.last_timestamp = last_timestamp
database.commit(session, 1044)
# Test must fail as DeviceAgent last_timestamp not updated
result = validate._CheckDuplicates(self.data)
self.assertEqual(result.valid(), False)
def idx_agent(self):
"""Insert new agent into database if necessary.
Args:
None
Returns:
idx_agent: IDX value of agent from database
"""
# Initialize key variables
agent_name = self.agent_data['agent_name']
id_agent = self.agent_data['id_agent']
# Get information on agent from database
agent_data = db_agent.GetIDAgent(id_agent)
# Return if agent already exists in the table
if agent_data.exists() is True:
idx_agent = agent_data.idx_agent()
return idx_agent
# Get information on agent from database
name_data = db_agentname.GetAgentName(agent_name)
# Insert data into table if required
# Get idx_agentname
if name_data.exists() is False:
record = AgentName(
name=general.encode(agent_name))
database = db.Database()
try:
database.add(record, 1145)
except pymysql.IntegrityError:
# There may be a duplicate agent name if this is a brand
# new database and there is a flurry of updates from multiple
# agents. This is OK, pass.
#
# We are expecting a 'pymysql.err.IntegrityError' but for some
# reason it could not be caught.
pass
new_name_data = db_agentname.GetAgentName(agent_name)
idx_agentname = new_name_data.idx_agentname()
else:
idx_agentname = name_data.idx_agentname()
# Add record to the database
new_record = Agent(
id_agent=general.encode(id_agent),
idx_agentname=idx_agentname)
database = db.Database()
database.add(new_record, 1081)
# Get idx_agent value from database
new_agent_data = db_agent.GetIDAgent(id_agent)
idx_agent = new_agent_data.idx_agent()
return idx_agent
def __init__(self, idx_agent):
"""Function for intializing the class.
Args:
idx_agent: Agent idx_agent
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = ['idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Fix values passed
if isinstance(idx_agent, int) is False:
idx_agent = None
# Only work if the value is an integer
if isinstance(idx_agent, int) is True and idx_agent is not None:
# Get the result
database = db.Database()
session = database.session()
result = session.query(Agent).filter(Agent.idx_agent == idx_agent)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_agent'] = idx_agent
self.data_dict['idx_agentname'] = instance.idx_agentname
self.data_dict['id_agent'] = general.decode(
instance.id_agent)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
# Add the agent name to dict
if bool(self.data_dict['exists']) is True:
database = db.Database()
session = database.session()
result = session.query(AgentName.name).filter(
and_(
Agent.idx_agent == self.data_dict['idx_agent'],
Agent.idx_agentname == AgentName.idx_agentname)).one()
self.data_dict['agent'] = general.decode(result.name)
database.close()
def __init__(self, id_agent):
"""Function for intializing the class.
Args:
id_agent: Identifier of agent
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = ['idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Encode the id_agent
if isinstance(id_agent, str) is True:
value = id_agent.encode()
else:
value = None
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Agent).filter(Agent.id_agent == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['id_agent'] = id_agent
self.data_dict['idx_agent'] = instance.idx_agent
self.data_dict['idx_agentname'] = instance.idx_agentname
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
# Add the agent name to dict
if bool(self.data_dict['exists']) is True:
database = db.Database()
session = database.session()
result = session.query(AgentName.name).filter(
and_(Agent.idx_agent == self.data_dict['idx_agent'],
Agent.idx_agentname == AgentName.idx_agentname)).one()
self.data_dict['agent'] = general.decode(result.name)
database.close()
def last_contacts(ts_start):
"""Get the last time each timeseries datapoint was updated.
Args:
config: Configuration object
ts_start: Timestamp to start from
Returns:
data: List of dicts of last contact information
"""
# Initialize key variables
data = []
last_contact = defaultdict(lambda: defaultdict(dict))
# Get start and stop times
ts_stop = general.normalized_timestamp()
if ts_start > ts_stop:
ts_start = ts_stop
else:
ts_start = general.normalized_timestamp(ts_start)
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Data.value, Data.idx_datapoint,
Data.timestamp).filter(
and_(Data.timestamp >= ts_start,
Data.timestamp <= ts_stop))
# Add to the list of device idx values
for instance in result:
idx_datapoint = instance.idx_datapoint
timestamp = instance.timestamp
value = instance.value
# Update dictionary
if idx_datapoint in last_contact:
if timestamp > last_contact[idx_datapoint]['timestamp']:
last_contact[idx_datapoint]['timestamp'] = timestamp
last_contact[idx_datapoint]['value'] = value
else:
continue
else:
last_contact[idx_datapoint]['timestamp'] = timestamp
last_contact[idx_datapoint]['value'] = value
# Return the session to the pool after processing
database.close()
# Convert dict to list of dicts
for idx_datapoint in last_contact:
data_dict = {}
data_dict['idx_datapoint'] = idx_datapoint
data_dict['timestamp'] = last_contact[idx_datapoint]['timestamp']
data_dict['value'] = last_contact[idx_datapoint]['value']
data.append(data_dict)
# Return
return data
def _insert_config(self):
"""Insert first config in the database.
Args:
None
Returns:
None
"""
# Initialize key variables
key_values = [('version', '0.0.0.0')]
# Cycle through all the key value pairs
for item in key_values:
key = item[0]
value = item[1]
# Check if value exists and insert if not
if db_configuration.config_key_exists(key) is False:
record = Configuration(
config_key=general.encode(key),
config_value=general.encode(value))
database = db.Database()
database.add(record, 1108)
def get_all_names():
"""Get data on all names in the database.
Args:
None
Returns:
data: List of dicts of agent data.
"""
# Initialize important variables
data = []
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(AgentName)
# Massage data
for instance in result:
# Get next record
data_dict = defaultdict(dict)
data_dict['name'] = general.decode(instance.name)
data_dict['idx_agentname'] = instance.idx_agentname
data_dict['enabled'] = bool(instance.enabled)
data_dict['exists'] = True
# Append to list
data.append(data_dict)
# Return the session to the database pool after processing
database.close()
# Return
return data
def datapoint(self):
"""Update the database timestamp for the datapoint.
Args:
None
Returns:
None
"""
# Initialize key variables
idx_agent = self.idx_agent
idx_device = self.idx_device
last_timestamp = self.last_timestamp
data_dict = {'last_timestamp': last_timestamp}
# Access the database
database = db.Database()
session = database.session()
# Update
session.query(Datapoint).filter(
and_(Datapoint.idx_device == idx_device,
Datapoint.idx_agent == idx_agent,
Datapoint.enabled == 1)).update(data_dict)
database.commit(session, 1057)
def device_idx(idx_device):
"""Get list of all datapoint indexes for a specific device_idx.
Args:
idx_device: Device index
Returns:
listing: List of indexes
"""
# Initialize key variables
idx_datapoint_list = []
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(
Datapoint.idx_datapoint).filter(Datapoint.idx_device == idx_device)
# Add to the list of device idx_datapoint values
for instance in result:
idx_datapoint_list.append(instance.idx_datapoint)
# Return the connection to the pool
database.close()
# Return
return idx_datapoint_list
def __init__(self, code):
"""Function for intializing the class.
Args:
code: Department code
Returns:
None
"""
# Initialize important variables
value = code.encode()
self.data_dict = defaultdict(dict)
keys = ['idx_department', 'code', 'name', 'enabled']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Department).filter(Department.code == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_department'] = instance.idx_department
self.data_dict['code'] = general.decode(instance.code)
self.data_dict['name'] = general.decode(instance.name)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def idx_agent(self):
"""Insert new agent into database if necessary.
Args:
None
Returns:
idx_agent: IDX value of agent from database
"""
# Initialize key variables
agent_name = self.agent_data['agent_name']
id_agent = self.agent_data['id_agent']
# Get information on agent from database
data = agent.GetIDAgent(id_agent)
# Return if agent already exists in the table
if data.exists() is True:
idx_agent = data.idx_agent()
return idx_agent
# Add record to the database
record = Agent(id_agent=general.encode(id_agent),
name=general.encode(agent_name))
database = db.Database()
database.add(record, 1081)
# Get idx_agent value from database
data = agent.GetIDAgent(id_agent)
idx_agent = data.idx_agent()
return idx_agent
def get_all_device_agents():
"""Get list of all DeviceAgent indexes.
Args:
None
Returns:
listing: List of indexes
"""
data = []
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(DeviceAgent)
# Add to the list of device idx values
for instance in result:
data_dict = {}
data_dict['idx_agent'] = instance.idx_agent
data_dict['idx_device'] = instance.idx_device
data.append(data_dict)
# Return the session to the pool after processing
database.close()
# Return
return data
def agent_indices(idx_device):
"""Get list of all agent indexes for a specific device_idx.
Args:
None
Returns:
listing: List of indexes
"""
idx_list = []
# Fix values passed
if isinstance(idx_device, int) is False:
idx_device = None
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(
DeviceAgent.idx_agent).filter(DeviceAgent.idx_device == idx_device)
# Add to the list of device idx values
for instance in result:
idx_list.append(instance.idx_agent)
# Return the session to the pool after processing
database.close()
# Return
return idx_list
def all_device_indices():
"""Get list of all device indexes in database.
Args:
None
Returns:
listing: List of indexes
"""
idx_list = []
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(DeviceAgent.idx_device)
# Add to the list of device idx values
for instance in result:
idx_list.append(instance.idx_device)
# Return the session to the pool after processing
database.close()
# Return
return list(set(idx_list))
def idx_agent(self):
"""Insert new agent into database if necessary.
Args:
None
Returns:
idx_agent: IDX value of agent from database
"""
# Initialize key variables
agent_name = self.agent_data['agent_name']
id_agent = self.agent_data['id_agent']
# Get information on agent from database
agent_data = db_agent.GetIDAgent(id_agent)
# Return if agent already exists in the table
if agent_data.exists() is True:
idx_agent = agent_data.idx_agent()
return idx_agent
# Get information on agent from database
name_data = db_agentname.GetAgentName(agent_name)
# Insert data into table if required
# Get idx_agentname
if name_data.exists() is False:
record = AgentName(name=general.encode(agent_name))
database = db.Database()
database.add(record, 1081)
new_name_data = db_agentname.GetAgentName(agent_name)
idx_agentname = new_name_data.idx_agentname()
else:
idx_agentname = name_data.idx_agentname()
# Add record to the database
new_record = Agent(id_agent=general.encode(id_agent),
idx_agentname=idx_agentname)
database = db.Database()
database.add(new_record, 1081)
# Get idx_agent value from database
new_agent_data = db_agent.GetIDAgent(id_agent)
idx_agent = new_agent_data.idx_agent()
return idx_agent
def __init__(self, idx_datapoint):
"""Function for intializing the class.
Args:
idx_datapoint: Datapoint Index
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = [
'idx_datapoint', 'id_datapoint', 'idx_deviceagent',
'idx_department',
'idx_billcode', 'agent_label', 'agent_source', 'enabled',
'billable', 'base_type', 'timefixed_value', 'last_timestamp']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Only work if the value is an integer
if (isinstance(idx_datapoint, int) is True) and (
idx_datapoint is not None):
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(
Datapoint).filter(Datapoint.idx_datapoint == idx_datapoint)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_datapoint'] = instance.idx_datapoint
self.data_dict[
'id_datapoint'] = general.decode(
instance.id_datapoint)
self.data_dict[
'idx_deviceagent'] = instance.idx_deviceagent
self.data_dict['idx_department'] = instance.idx_department
self.data_dict['idx_billcode'] = instance.idx_billcode
self.data_dict[
'agent_label'] = general.decode(
instance.agent_label)
self.data_dict[
'agent_source'] = general.decode(
instance.agent_source)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['billable'] = bool(instance.billable)
self.data_dict['base_type'] = instance.base_type
self.data_dict[
'timefixed_value'] = instance.timefixed_value
self.data_dict['last_timestamp'] = instance.last_timestamp
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def listing(idx_deviceagent, base_type=None):
"""List of datapoint data for a specific idx_device, idx_agent combination.
Args:
idx_deviceagent: DeviceAgent index
base_type: base_type to filter by
Returns:
dict_list: List of dicts containing data
"""
# Initialize key variables
dict_list = []
# Process information
deviceagent = db_deviceagent.GetIDXDeviceAgent(idx_deviceagent)
if deviceagent.exists() is True:
# Establish a database session
database = db.Database()
session = database.session()
if base_type is None:
result = session.query(Datapoint).filter(
Datapoint.idx_deviceagent == idx_deviceagent)
else:
result = session.query(Datapoint).filter(
and_(
Datapoint.base_type == base_type,
Datapoint.idx_deviceagent == idx_deviceagent)
)
# Add to the list of device idx_datapoint values
for instance in result:
data_dict = {}
data_dict['idx_datapoint'] = instance.idx_datapoint
data_dict['id_datapoint'] = general.decode(instance.id_datapoint)
data_dict['idx_deviceagent'] = instance.idx_deviceagent
data_dict['idx_department'] = instance.idx_department
data_dict['idx_billcode'] = instance.idx_billcode
data_dict[
'agent_label'] = general.decode(instance.agent_label)
data_dict[
'agent_source'] = general.decode(instance.agent_source)
data_dict['enabled'] = bool(instance.enabled)
data_dict['billable'] = bool(instance.billable)
data_dict['base_type'] = instance.base_type
data_dict[
'timefixed_value'] = general.decode(instance.timefixed_value)
data_dict['last_timestamp'] = instance.last_timestamp
data_dict['exists'] = True
dict_list.append(data_dict)
# Return the connection to the pool
database.close()
# Return
return dict_list
def _update_timeseries(self):
"""Insert data into the database "iset_data" table.
Args:
mapping: Map of DIDs to database row index values
Returns:
success: True if successful
"""
# Initialize key variables
success = False
data = self.agent_data['timeseries']
datapoints = self.datapoints
data_list = []
timestamp_tracker = {}
# Update data
for item in data:
# Process datapoint values
id_datapoint = item['id_datapoint']
value = item['value']
timestamp = item['timestamp']
# Get data on datapoints
idx_datapoint = datapoints[id_datapoint]['idx_datapoint']
last_timestamp = datapoints[id_datapoint]['last_timestamp']
# Only update with data collected after
# the most recent DID update. Don't do anything more
if timestamp > last_timestamp:
data_list.append(
Data(
idx_datapoint=idx_datapoint,
value=value,
timestamp=timestamp
)
)
# Update DID's last updated timestamp
if idx_datapoint in timestamp_tracker:
timestamp_tracker[idx_datapoint] = max(
timestamp, timestamp_tracker[idx_datapoint])
else:
timestamp_tracker[idx_datapoint] = timestamp
# Update if there is data
if bool(data_list) is True:
# Do performance data update
database = db.Database()
success = database.add_all(data_list, 1056, die=False)
success = True
# Return
return success
def _dp_device_agent(idx_device, idx_agent, charted_data=True):
"""List of datapoint data for a specific device_idx, idx_agent combination.
Args:
idx_device: Device index
idx_agent: Agent index
charted_data: Return data for charted points if True.
Uncharted if False.
Returns:
dict_list: List of dicts containing data
"""
# Initialize key variables
dict_list = []
# Establish a database session
database = db.Database()
session = database.session()
if charted_data is True:
result = session.query(Datapoint).filter(
and_(Datapoint.timefixed_value == None,
Datapoint.idx_device == idx_device,
Datapoint.idx_agent == idx_agent))
else:
result = session.query(Datapoint).filter(
and_(Datapoint.timefixed_value != None,
Datapoint.idx_device == idx_device,
Datapoint.idx_agent == idx_agent))
# Add to the list of device idx_datapoint values
for instance in result:
data_dict = {}
data_dict['idx_datapoint'] = instance.idx_datapoint
data_dict['id_datapoint'] = general.decode(instance.id_datapoint)
data_dict['idx_agent'] = instance.idx_agent
data_dict['idx_device'] = instance.idx_device
data_dict['idx_department'] = instance.idx_department
data_dict['idx_billcode'] = instance.idx_billcode
data_dict['agent_label'] = general.decode(instance.agent_label)
data_dict['agent_source'] = general.decode(instance.agent_source)
data_dict['enabled'] = bool(instance.enabled)
data_dict['billable'] = bool(instance.billable)
data_dict['base_type'] = instance.base_type
data_dict['timefixed_value'] = general.decode(instance.timefixed_value)
data_dict['last_timestamp'] = instance.last_timestamp
data_dict['exists'] = True
dict_list.append(data_dict)
# Return the connection to the pool
database.close()
# Return
return dict_list
def idx_device(self):
"""Insert new device into database if necessary.
Args:
None
Returns:
idx_device: Index value for device record
"""
# Initialize key variables
devicename = self.agent_data['devicename']
# Get information on agent from database
device = db_device.GetDevice(devicename)
# Determine index value for device
if device.exists() is True:
idx_device = device.idx_device()
else:
# Add record to the database
record = Device(devicename=general.encode(devicename))
database = db.Database()
database.add(record, 1080)
# Get idx of newly added device
device_info = db_device.GetDevice(devicename)
idx_device = device_info.idx_device()
# Update DeviceAgent table
idx_agent = self._idx_agent
if db_deviceagent.device_agent_exists(idx_device, idx_agent) is False:
# Add to DeviceAgent table
new_record = DeviceAgent(idx_device=idx_device,
idx_agent=idx_agent)
database = db.Database()
database.add(new_record, 1038)
# Return
return idx_device
def __init__(self, config, idx_datapoint, start=None, stop=None):
"""Function for intializing the class.
Args:
config: Config object
idx_datapoint: idx_datapoint of datapoint
start: Starting timestamp
stop: Ending timestamp
Returns:
None
"""
# Initialize important variables
self.data = defaultdict(dict)
self.config = config
# Get the datapoint's base_type
datapointer = db_datapoint.GetIDXDatapoint(idx_datapoint)
self.base_type = datapointer.base_type()
self.agent_label = datapointer.agent_label()
# Redefine start times
if start is None:
self.ts_start = general.normalized_timestamp() - (3600 * 24)
else:
self.ts_start = general.normalized_timestamp(start)
# Redefine stop times
if stop is None:
self.ts_stop = general.normalized_timestamp()
else:
self.ts_stop = general.normalized_timestamp(stop)
# Fix edge cases
if self.ts_start > self.ts_stop:
self.ts_start = self.ts_stop
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Data.timestamp, Data.value).filter(
and_(Data.timestamp >= self.ts_start,
Data.timestamp <= self.ts_stop,
Data.idx_datapoint == idx_datapoint))
# Massage data
for instance in result:
self.data[instance.timestamp] = instance.value
# Return the session to the database pool after processing
database.close()
def _insert_department(self):
"""Insert first department in the database.
Args:
None
Returns:
None
"""
# Insert
if db_department.idx_department_exists(1) is False:
record = Department(code=general.encode(self.reserved),
name=general.encode(self.reserved))
database = db.Database()
database.add(record, 1102)
def _insert_billcode(self):
"""Insert first billcode in the database.
Args:
None
Returns:
None
"""
# Insert
if db_billcode.idx_billcode_exists(1) is False:
record = Billcode(code=general.encode(self.reserved),
name=general.encode(self.reserved))
database = db.Database()
database.add(record, 1104)
def __init__(self, idx_device, idx_agent):
"""Method initializing the class.
Args:
idx_device: Device idx
idx_agent: Agent idx
Returns:
None
"""
# Initialize key variables
self.data_dict = defaultdict(dict)
keys = [
'last_timestamp', 'idx_deviceagent', 'idx_agent', 'idx_device',
'enabled'
]
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Fix values passed
if isinstance(idx_device, int) is False:
idx_device = None
if isinstance(idx_agent, int) is False:
idx_agent = None
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(DeviceAgent).filter(
and_(DeviceAgent.idx_device == idx_device,
DeviceAgent.idx_agent == idx_agent))
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['last_timestamp'] = instance.last_timestamp
self.data_dict['idx_deviceagent'] = instance.idx_deviceagent
self.data_dict['idx_device'] = instance.idx_device
self.data_dict['idx_agent'] = instance.idx_agent
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def __init__(self, idx_deviceagent):
"""Function for intializing the class.
Args:
idx_deviceagent: DeviceAgent idx_deviceagent
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = [
'last_timestamp', 'idx_deviceagent', 'idx_agent', 'idx_device',
'enabled'
]
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Fix values passed
if isinstance(idx_deviceagent, int) is False:
idx_deviceagent = None
# Only work if the value is an integer
if isinstance(idx_deviceagent, int) is True and (idx_deviceagent
is not None):
# Get the result
database = db.Database()
session = database.session()
result = session.query(DeviceAgent).filter(
DeviceAgent.idx_deviceagent == idx_deviceagent)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_deviceagent'] = idx_deviceagent
self.data_dict['idx_agent'] = instance.idx_agent
self.data_dict['last_timestamp'] = instance.last_timestamp
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['idx_device'] = instance.idx_device
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
def _insert_datapoint(self):
"""Insert first datapoint in the database.
Args:
None
Returns:
None
"""
# Insert
if db_datapoint.idx_datapoint_exists(1) is False:
record = Datapoint(id_datapoint=general.encode(self.reserved),
agent_label=general.encode(self.reserved),
agent_source=general.encode(self.reserved))
database = db.Database()
database.add(record, 1047)
def get_datapoints(self):
"""Create dict of enabled datapoints and their corresponding indices.
Args:
None
Returns:
data: Dict keyed by datapoint ID,
with a tuple as its value (idx, idx_agent)
idx: Datapoint index
idx_agent: Agent index
last_timestamp: The last time the timestamp was updated
"""
# Initialize key variables
idx_agent = self._idx_agent
data = {}
# Update database
database = db.Database()
session = database.session()
result = session.query(Datapoint.id_datapoint, Datapoint.idx_datapoint,
Datapoint.idx_agent,
Datapoint.last_timestamp).filter(
and_(Datapoint.enabled == 1,
Datapoint.idx_agent == idx_agent))
# Massage data
for instance in result:
id_datapoint = instance.id_datapoint.decode('utf-8')
idx_datapoint = instance.idx_datapoint
idx_agent = instance.idx_agent
last_timestamp = instance.last_timestamp
data[id_datapoint] = {
'idx_datapoint': idx_datapoint,
'idx_agent': idx_agent,
'last_timestamp': last_timestamp
}
# Return the session to the database pool after processing
database.close()
# Return
return data
def __init__(self, devicename):
"""Function for intializing the class.
Args:
devicename: Devicename
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
keys = [
'idx_device', 'devicename', 'description', 'enabled']
for key in keys:
self.data_dict[key] = None
self.data_dict['exists'] = False
# Encode the id_agent
if isinstance(devicename, str) is True:
value = devicename.encode()
else:
value = None
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Device).filter(Device.devicename == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx_device'] = instance.idx_device
self.data_dict[
'devicename'] = devicename
self.data_dict[
'description'] = general.decode(instance.description)
self.data_dict['enabled'] = bool(instance.enabled)
self.data_dict['exists'] = True
break
# Return the session to the database pool after processing
database.close()
