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 _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 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 _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 _insert_agent_device(self):
"""Insert first agent and device in the database.
Args:
None
Returns:
None
"""
# Initialize key variables
idx_agentname = 1
idx_agent = 1
idx_device = 1
# Add agent name
if db_agentname.idx_agentname_exists(idx_agentname) is False:
# Generate a name add a record in the database
record = AgentName(
name=general.encode(self.reserved))
database = db.Database()
database.add(record, 1019)
# Add agent
if db_agent.idx_agent_exists(idx_agent) is False:
# Generate an Agent ID and add a record in the database
record = Agent(id_agent=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 _add_datapoint(self, source):
"""Insert new datapoint into database.
Args:
source: Dict of datapoint source information
{'id_agent': id_agent,
'id_datapoint': id_datapoint,
'agent_label': agent_label,
'agent_source': source,
'description': description,
'base_type': base_type}
id_agent: Agent Identifier
id_datapoint: Datapoint ID
label: Datapoint label created by agent
source: Source of the data (subsystem being tracked)
description: Description provided by agent config file
base_type = SNMP base type (Counter32, Counter64, Gauge etc.)
Returns:
None
"""
# Initialize key variables
idx_agent = self._idx_agent
idx_device = self._idx_device
id_datapoint = source['id_datapoint']
agent_label = source['agent_label']
agent_source = source['agent_source']
base_type = source['base_type']
# Insert record
record = Datapoint(id_datapoint=general.encode(id_datapoint),
idx_agent=idx_agent,
idx_device=idx_device,
agent_label=general.encode(agent_label),
agent_source=general.encode(agent_source),
base_type=base_type)
database = db.Database()
database.add(record, 1082)
def setup_db_IDXConfiguration():
"""Create the database for Configuration table testing.
Args:
None
Returns:
None
"""
# Initialize key variables
idx_configuration = 1
# Get Configuration
config_key = general.hashstring('_INFOSET_TEST_')
config_value = general.hashstring('_INFOSET_TEST_VALUE_')
# Create a dict of all the expected values
expected = {
'config_key': config_key,
'config_value': config_value,
'idx_configuration': idx_configuration,
'enabled': 1,
'exists': True
}
# Drop the database and create tables
initialize_db()
# Insert data into database
data = Configuration(
config_key=general.encode(expected['config_key']),
config_value=general.encode(expected['config_value']),
enabled=expected['enabled'])
database = db.Database()
database.add_all([data], 1045)
# Return
return expected
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 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 _update_timefixed(self):
"""Update timefixed data into the database "iset_datapoint" table.
Args:
mapping: Map of DIDs to database row index values
Returns:
success: True if successful
"""
# Initialize key variables
success = True
data = self.agent_data['timefixed']
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 update. Don't do anything more
if timestamp > last_timestamp:
data_list.append((idx_datapoint, value))
# 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:
# Create a database session
# NOTE: We only do a single commit on the session.
# This is much faster (20x based on testing) than
# instantiating the database, updating records, and committing
# after every iteration of the "for loop"
database = db.Database()
session = database.session()
# Update timefixed data
for item in data_list:
(idx_datapoint, value) = item
data_dict = {'timefixed_value': general.encode(value)}
session.query(Datapoint).filter(
Datapoint.idx_datapoint == idx_datapoint).update(data_dict)
# Commit data
database.commit(session, 1037)
# Return
return success
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 = data['agent']
last_timestamp = data['timestamp']
# Add AgentName record to the database
record = AgentName(
name=general.encode(agent))
database = db.Database()
database.add(record, 1130)
# 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']
agent_name = self.data['agent']
last_timestamp = self.data['timestamp']
# Drop the database and create tables
unittest_db.initialize_db()
# Add record to the database
record = Agent(id_agent=general.encode(id_agent),
name=general.encode(agent_name))
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, 1021)
# 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 test_encode(self):
"""Test function test_encode."""
# Initialize key variables
expected = b'carrot'
result = general.encode("carrot")
self.assertEqual(result, expected)
