def __init__(self, idx_agent):
"""Function for intializing the class.
Args:
idx_agent: Agent idx
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
# Get the result
database = db.Database()
session = database.session()
result = session.query(Agent).filter(
Agent.idx == idx_agent)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['uid'] = jm_general.decode(instance.id)
self.data_dict['name'] = jm_general.decode(instance.name)
self.data_dict['enabled'] = instance.enabled
self.data_dict['last_timestamp'] = instance.last_timestamp
break
else:
log_message = ('Agent IDX %s not found.') % (idx_agent)
log.log2die(1035, log_message)
# Return the session to the database pool after processing
session.close()
def __init__(self, idx_agent):
"""Function for intializing the class.
Args:
idx: idx of agent
Returns:
None
"""
# Initialize important variables
self.data_point_dict = defaultdict(dict)
# Get the result
database = db.Database()
session = database.session()
result = session.query(Datapoint).filter(
Datapoint.idx_agent == idx_agent)
# Massage data
if result.count() > 0:
for instance in result:
agent_label = jm_general.decode(instance.agent_label)
idx = instance.idx
uncharted_value = jm_general.decode(instance.uncharted_value)
self.data_point_dict[agent_label] = (idx, uncharted_value)
else:
log_message = ('Agent idx %s not found.') % (idx_agent)
log.log2die(1050, log_message)
# Return the session to the database pool after processing
session.close()
def __init__(self, code):
"""Function for intializing the class.
Args:
code: BillType code
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
value = code.encode()
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(BillType).filter(BillType.code == value)
# Return the session to the database pool after processing
database.close()
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx'] = instance.idx
self.data_dict[
'code'] = jm_general.decode(instance.code)
self.data_dict[
'name'] = jm_general.decode(instance.name)
break
else:
log_message = ('BillType %s not found.') % (code)
log.log2die(1001, log_message)
def __init__(self, idx):
"""Function for intializing the class.
Args:
idx: Department Index
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Department).filter(Department.idx == idx)
# Return the session to the database pool after processing
database.close()
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx'] = instance.idx
self.data_dict[
'code'] = jm_general.decode(instance.code)
self.data_dict[
'name'] = jm_general.decode(instance.name)
break
else:
log_message = ('Department idx %s not found.') % (idx)
log.log2die(1097, log_message)
def __init__(self, uid):
"""Function for intializing the class.
Args:
uid: UID of agent
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
value = uid.encode()
self.uid = value
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Agent).filter(Agent.id == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx'] = instance.idx
self.data_dict['name'] = jm_general.decode(instance.name)
self.data_dict['enabled'] = instance.enabled
self.data_dict['last_timestamp'] = instance.last_timestamp
break
else:
log_message = ('uid %s not found.') % (value)
log.log2die(1035, log_message)
# Return the session to the database pool after processing
session.close()
def datapoint_host_agent(idx_host, idx_agent):
"""List of datapoint data for a specific host_idx, idx_agent combination.
Args:
idx_host: Host index
idx_agent: Agent index
Returns:
dict_list: List of dicts containing data
"""
# Initialize key variables
dict_list = []
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Datapoint).filter(
and_(
Datapoint.uncharted_value == None,
Datapoint.idx_host == idx_host,
Datapoint.idx_agent == idx_agent)
)
session.close()
# Add to the list of host idx values
for instance in result:
data_dict = {}
data_dict['idx'] = instance.idx
data_dict['id'] = jm_general.decode(instance.id)
data_dict['idx_agent'] = instance.idx_agent
data_dict['idx_host'] = instance.idx_host
data_dict['idx_department'] = instance.idx_department
data_dict['idx_billtype'] = instance.idx_billtype
data_dict[
'agent_label'] = jm_general.decode(instance.agent_label)
data_dict[
'agent_source'] = jm_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['uncharted_value'] = instance.uncharted_value
data_dict['last_timestamp'] = instance.last_timestamp
dict_list.append(data_dict)
# Return
return dict_list
def __init__(self, did):
"""Function for intializing the class.
Args:
did: Datapoint ID
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
value = did.encode()
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Datapoint).filter(Datapoint.id == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx'] = instance.idx
self.data_dict['id'] = instance.id
self.data_dict['idx_agent'] = instance.idx_agent
self.data_dict['idx_host'] = instance.idx_host
self.data_dict['idx_department'] = instance.idx_department
self.data_dict['idx_billtype'] = instance.idx_billtype
self.data_dict[
'agent_label'] = jm_general.decode(instance.agent_label)
self.data_dict[
'agent_source'] = jm_general.decode(instance.agent_source)
self.data_dict['enabled'] = instance.enabled
self.data_dict['billable'] = instance.billable
self.data_dict[
'base_type'] = jm_general.decode(instance.base_type)
self.data_dict['uncharted_value'] = instance.uncharted_value
self.data_dict['last_timestamp'] = instance.last_timestamp
break
else:
log_message = ('did %s not found.') % (did)
log.log2die(1085, log_message)
# Return the session to the database pool after processing
session.close()
def __init__(self, hostname):
"""Function for intializing the class.
Args:
hostname: Hostname
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
value = hostname.encode()
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(Host).filter(Host.hostname == value)
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx'] = instance.idx
self.data_dict[
'hostname'] = jm_general.decode(instance.hostname)
self.data_dict[
'description'] = jm_general.decode(instance.description)
self.data_dict['enabled'] = instance.enabled
self.data_dict['snmp_enabled'] = instance.snmp_enabled
self.data_dict[
'ip_address'] = jm_general.decode(instance.ip_address)
break
else:
log_message = ('Hostname %s not found.') % (hostname)
log.log2die(1000, log_message)
# Return the session to the database pool after processing
session.close()
def __init__(self, oid_values):
"""Function for intializing the class.
Args:
oid_values: OID
Returns:
None
"""
# Initialize important variables
self.data_dict = defaultdict(dict)
# Establish a database session
database = db.Database()
session = database.session()
result = session.query(OID).filter(OID.oid_values == oid_values)
# Return the session to the database pool after processing
database.close()
# Massage data
if result.count() == 1:
for instance in result:
self.data_dict['idx'] = instance.idx
self.data_dict[
'oid_values'] = jm_general.decode(instance.oid_values)
self.data_dict[
'oid_labels'] = jm_general.decode(instance.oid_labels)
self.data_dict[
'agent_label'] = jm_general.decode(instance.agent_label)
self.data_dict['base_type'] = instance.base_type
self.data_dict['multiplier'] = instance.multiplier
break
else:
log_message = ('OID %s not found.') % (oid_values)
log.log2die(1040, log_message)
def _datapoints(self):
"""Create the master dictionary for the host.
Args:
None
Returns:
value: Index value
"""
# Initialize key variables
snmp_params = self.snmp_params
master = self._master()
# Get sources
snmp_object = snmp_manager.Interact(snmp_params)
for labels_oid in master.keys():
sources = {}
oid_results = snmp_object.swalk(labels_oid)
# Return if there is an error
if bool(oid_results) is False:
log_message = (
'Failed to contact SNMP host %s. '
'Will collect data on next poll.'
'') % (self.hostname)
log.log2warn(1024, log_message)
return
for key, value in oid_results.items():
sources[_index(labels_oid, key)] = jm_general.decode(value)
# Get values
for labels_oid in master.keys():
for agent_label in master[labels_oid].keys():
# Initialize datapoints
datapoints = defaultdict(lambda: defaultdict(dict))
# Information about the OID
values_oid = master[labels_oid][agent_label]['values_oid']
base_type = master[labels_oid][agent_label]['base_type']
multiplier = master[labels_oid][agent_label]['multiplier']
# Get OID values
values = {}
oid_results = snmp_object.swalk(values_oid)
# Return if there is an error
if bool(oid_results) is False:
log_message = (
'Failed to contact SNMP host %s. '
'Will collect data on next poll.'
'') % (self.hostname)
log.log2warn(1022, log_message)
return
# Only process floating point values
for key, value in oid_results.items():
try:
_ = float(value)
except:
continue
values[_index(labels_oid, key)] = value * multiplier
# Create list of data for json
data = []
for index, value in values.items():
data.append([index, value, sources[index]])
# Finish up dict for json
datapoints[agent_label]['data'] = data
datapoints[agent_label]['base_type'] = base_type
# Populate agent
self.agent.populate(datapoints)
# Post data
self.agent.post()
