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