def __init__(self, group_name, platform_name, nodes):
self.system_settings = nodes.system_settings
self._nodes = nodes
db_file_prefix = None
if internal_name(group_name) != 'inactive_group':
db_file_prefix = os.path.join('platforms', platform_name, 'groups')
# Default Cookies
defaults_kwargs = {
'group': internal_name(group_name),
'live_cookie': {'selected': 0},
'log_cookie': {'selected': []}
}
super(Group, self).__init__(
group_name, platform_name, db_file_prefix, **defaults_kwargs)
nodes_db_file = None
error_db_file = None
if internal_name(group_name) != 'inactive_group':
db_path = os.path.join('platforms', platform_name, 'groups', self['internal_name'])
nodes_db_file = os.path.join(db_path, 'nodes.db')
error_db_file = os.path.join(db_path, 'default_error.db')
self.nodes = GroupNodes(
self._nodes,
db_file=nodes_db_file
)
self.error = NodeError(
system_settings=self.system_settings,
db_file=error_db_file
)
def name_taken(self, address, prospective_name):
""" Checks if SNMP Agent/Command name is taken already. Returns True or False """
output = False
for object_key, object_value in self._object.items():
if address != object_key:
if internal_name(object_value['name']) == internal_name(
prospective_name):
output = True
break
return output
def warnings(self):
""" Returns list of warnings and the state of warnings """
unacknowledged_acks = False
new_warning = False
# Gather warning providers
nodes = self.select_nodes('all')
base_node = self._manager.bridge.base
statistics = self._manager
warning_providers = nodes.values() + [base_node, statistics]
# Merge all warnings
_warnings = dict()
for provider in warning_providers:
provider_id = internal_name(provider['name'])
if 'net_addr' in provider and provider['net_addr'] is not None:
provider_id = provider['net_addr']
_warnings.update(provider.error.get_error_messages(provider_id))
# Create dictionary of warnings in reverse chronological order
warnings = list()
for warning_time in sorted(_warnings.keys())[::-1]:
warning = _warnings[warning_time]
warnings.append(warning)
unacknowledged_acks |= warning['ack']
new_warning |= warning['new']
self._warnings_state = int(bool(len(warnings))) + int(bool(unacknowledged_acks)) + int(bool(new_warning))
return warnings
def __ack_update(self, warning_key, ack_value):
""" Update warning acknowledgements """
json_dict = dict()
warning_key_list = warning_key.split('-')
if len(warning_key_list) == 3:
provider_id = warning_key_list[0]
error_field = warning_key_list[1]
error_code = int(warning_key_list[2])
statistics = {internal_name(self.manager['name']): self.manager}
active_nodes = self.platforms.select_nodes('active')
providers = statistics
providers.update(active_nodes)
if provider_id in providers:
provider = providers[provider_id]
ack_value = not bool(int(ack_value))
provider.error.change_ack_state(error_field, error_code,
ack_value)
json_dict.update(self._json_for_ajax_update())
else:
# Can not locate node referenced by warning key
json_dict['alert'] = strings.NO_NODE
else:
# Unrecognized warning key
json_dict['alert'] = strings.UNKNOWN_ERROR
return json_dict
def __init__(self, **kwargs):
# Key 'internal_name' is required for ModifiedOrderedDict!!!
kwargs['internal_name'] = internal_name(kwargs['name'])
super(SNMPAgent, self).__init__(
defaults=kwargs
)
self.command_generator = cmdgen.CommandGenerator()
def _update_agent(self, agent_key):
""" Update/Create SNMP agents """
validate = True
# Get data from forms
agent_name = request.forms.snmp_name.encode('ascii', 'ignore')
ip_address = request.forms.ip_address.encode('ascii', 'ignore')
port = int(request.forms.port)
snmp_community = request.forms.snmp_community.encode('ascii', 'ignore')
snmp_version = int(request.forms.snmp_version)
# Validate
validate &= (len(agent_name) > 0)
validate &= not (self.name_taken(agent_key, agent_name))
validate &= validate_ip_address(ip_address)
return_dict = {'kwargs': {}, 'save_cookie': validate}
if validate:
# Create save dictionary
new_agent_key = internal_name(agent_name)
save_dict = {
'name': agent_name,
'ip_address': ip_address,
'port': port,
'snmp_community': snmp_community,
'snmp_version': snmp_version
}
if agent_key in self._object.keys():
if agent_key == new_agent_key:
self._object[agent_key].update(save_dict)
else:
self._object.insert_before(
agent_key, (new_agent_key, SNMPAgent(**save_dict)))
del self._object[agent_key]
# Update all SNMP tables
self._pages.platforms.update_snmp_dict(
'agent', agent_key, new_agent_key)
else:
self._object[new_agent_key] = SNMPAgent(**save_dict)
new_cookie = self._pages.get_cookie()
new_cookie['index'] = new_agent_key
return_dict['new_cookie'] = new_cookie
self._object.save()
else:
return_dict['kwargs']['alert'] = VALIDATION_FAIL
return return_dict
def _update_trap(self, trap_key):
""" Update/Create SNMP Commands """
validate = True
# Get data from forms
trap_name = request.forms.snmp_name.encode('ascii', 'ignore')
trap_oid = request.forms.oid.encode('ascii', 'ignore')
trap_value = request.forms.value.encode('ascii', 'ignore')
# Validate
validate &= (len(trap_name) > 0)
validate &= not (self.name_taken(trap_key, trap_name))
validate &= validate_oid(trap_oid)
return_dict = {'kwargs': {}, 'save_cookie': validate}
if validate:
# Create save dictionary
new_trap_key = internal_name(trap_name)
save_dict = {
'name': trap_name,
'oid': trap_oid,
'value': trap_value
}
if trap_key in self._object.keys():
self._object[trap_key].update(save_dict)
if trap_key == new_trap_key:
self._object[trap_key].update(save_dict)
else:
self._object.insert_before(trap_key,
(new_trap_key, save_dict))
del self._object[trap_key]
# Update all SNMP tables
self._pages.platforms.update_snmp_dict(
'trap', trap_key, new_trap_key)
else:
self._object[new_trap_key] = save_dict
new_cookie = self._pages.get_cookie()
new_cookie['index'] = new_trap_key
return_dict['new_cookie'] = new_cookie
self._object.save()
else:
return_dict['kwargs']['alert'] = VALIDATION_FAIL
return return_dict
def name_taken(self, address, prospective_name):
""" Checks if group_name is taken """
group_key = internal_name(prospective_name)
if 'group' in address:
old_group_key = bool(group_key == address['group'])
else:
old_group_key = False
group_key_taken = bool(
group_key in self._object[address['platform']].groups)
output = group_key_taken and not old_group_key
return output
def __init__(self, name, platform_name, db_file_prefix, **kwargs):
defaults = {
'name': name,
'internal_name': internal_name(name),
'platform': platform_name
}
db_file = None
if db_file_prefix is not None:
db_file = os.path.join(db_file_prefix,
defaults['internal_name'] + '.db')
defaults.update(kwargs)
# LOGGER.debug("Defaults = " + defaults['name'])
super(PlatformBase, self).__init__(db_file=db_file, defaults=defaults)
def __init__(self, name, data_field, header_name, header_position,
**kwargs):
""" Initializes base class for all header type instances. Following parameters are must haves across all
header type instances
:param name: Official name that might be displayed to user via web interface. This also used to
generate internal constant name that is used internally.
:param data_field: Raw data field that this constant is associated to.
This gets automatically filled in by Header class.
:param header_position:
:param kwargs:
:return: Initialized base class
"""
_internal_name = internal_name(name)
data_field_position = None
if data_field in DISPLAY_FIELDS:
data_field_position = DISPLAY_FIELDS.index(data_field)
# else:
# raise ValueError('name: {} data_field: {} header_name: {} header_position: {}'.format(
# name, data_field, header_name, header_position)
# )
defaults = {
# Global Must Haves
'name': name,
'internal_name': _internal_name,
'data_field': data_field,
'data_field_position': data_field_position,
'header_name': header_name,
'header_position': header_position,
'selected': False,
'_external': False
}
defaults.update(kwargs)
super(HeaderBase, self).__init__(defaults=defaults)
def _update_user(self, user_key):
""" Update/Create users """
return_dict = {'kwargs': {}, 'save_cookie': False}
admin = self._object.check_access('admin')
if not admin:
user_key = internal_name(self._object.current_user()['name'])
if admin or user_key in self._object.keys():
validate = True
access = 'no_access'
active = False
# Get data from forms
username = request.forms.username
password1 = request.forms.password1
password2 = request.forms.password2
if username:
username = username.encode('ascii', 'ignore')
password1 = password1.encode('ascii', 'ignore')
password2 = password2.encode('ascii', 'ignore')
# Validate data
validate_list = [username]
# Make sure following values are not blanks
for value in validate_list:
validate &= (len(value) > 0)
# Check if username is already in use
validate &= not (self.name_taken(user_key, username))
# Make sure both password fields match
validate &= (password1 == password2)
if admin:
access = request.forms.total_access.encode('ascii', 'ignore')
active = bool(request.forms.active)
# Check if admin exists already
validate &= self.admin_present(user_key, access, active)
if validate:
# Create save dictionary
save_dict = dict()
if username:
save_dict = {'name': username}
if len(password1) > 0:
save_dict.update({'password': password1})
if admin:
save_dict.update({'access': access, 'active': active})
# Load local buffers with save dictionary
self._object.update_user(user_key, save_dict)
if user_key in self._object.keys():
# Updating user properties
self._object[user_key].update(save_dict)
if username:
# Renaming user
new_user_key = internal_name(username)
if user_key != new_user_key:
default_dict = copy.deepcopy(
self._object[user_key])
self._object.insert_before(
user_key, (new_user_key, default_dict))
self._object[new_user_key].update(save_dict)
del self._object[user_key]
# Create new cookie
new_cookie = self._pages.get_cookie()
new_cookie['index'] = new_user_key
return_dict['new_cookie'] = new_cookie
return_dict['save_cookie'] = True
elif username:
# Creating new user
new_user_key = internal_name(username)
# FYI: self._object[new_user_key] will provide default value (since it does not exist yet)
self._object[new_user_key] = copy.deepcopy(
self._object[new_user_key])
self._object[new_user_key].update(save_dict)
self._object.save()
else:
return_dict['kwargs']['alert'] = VALIDATION_FAIL
else:
return_dict['kwargs']['alert'] = NO_USER
return return_dict
'ip_address': '',
'port': SNMP_AGENT_PORT,
'snmp_community': SNMP_COMMUNITY[0],
'snmp_version': SNMP_VERSIONS.index('SNMP v1')
}
TEST_AGENT = {
'name': 'Test Agent',
'ip_address': '192.168.0.123',
'port': SNMP_AGENT_PORT,
'snmp_community': SNMP_COMMUNITY[0],
'snmp_version': SNMP_VERSIONS.index('SNMP v1')
}
DEFAULT_AGENTS = OrderedDict()
DEFAULT_AGENTS[internal_name(TEST_AGENT['name'])] = copy.deepcopy(TEST_AGENT)
## Logger ##
LOGGER = logging.getLogger(__name__)
# LOGGER.setLevel(logging.DEBUG)
### FUNCTIONS ###
def print_snmp_results(error_indication, error_status, error_index, var_binds):
""" Check for errors and print out results. Use only for debugging! """
if error_indication:
print(error_indication)
else:
if error_status:
LOGGER.debug('{0} at {1}'.format(
str(error_status.prettyPrint()),
def _update_command(self, command_key):
""" Update/Create SNMP Commands """
validate = True
# Get data from forms
command_name = request.forms.snmp_name.encode('ascii', 'ignore')
command_type = request.forms.type.encode('ascii', 'ignore')
command_oid = request.forms.oid.encode('ascii', 'ignore')
value_type = request.forms.value_type.encode('ascii', 'ignore')
command_value = request.forms.value.encode('ascii', 'ignore')
# Validate
validate &= (len(command_name) > 0)
validate &= not (self.name_taken(command_key, command_name))
validate &= validate_oid(command_oid)
if value_type == 'integer' or value_type == 'time ticks':
validate &= command_value.isdigit()
if validate:
command_value = int(command_value)
elif value_type == 'OID':
validate &= validate_oid(command_value)
elif value_type == 'IP address':
validate &= validate_ip_address(command_value)
return_dict = {'kwargs': {}, 'save_cookie': validate}
if validate:
# Create save dictionary
new_command_key = internal_name(command_name)
save_dict = {
'name': command_name,
'type': command_type,
'oid': command_oid,
'value_type': value_type,
'value': command_value
}
if command_key in self._object.keys():
self._object[command_key].update(save_dict)
if command_key != new_command_key:
self._object.insert_before(command_key,
(new_command_key, save_dict))
del self._object[command_key]
# Update all SNMP tables
self._pages.platforms.update_snmp_dict(
'command', command_key, new_command_key)
else:
self._object[new_command_key] = save_dict
new_cookie = self._pages.get_cookie()
new_cookie['index'] = new_command_key
return_dict['new_cookie'] = new_cookie
self._object.save()
else:
return_dict['kwargs']['alert'] = VALIDATION_FAIL
return return_dict
