async def on_asterisk_event(self, manager, event): event = dict(event) trace_events = __opts__.get('ami_trace_events') if trace_events: if isinstance(trace_events, bool): log.info('AMI event: %s', json.dumps(event, indent=2)) elif isinstance(trace_events, list) and event['Event'] in trace_events: log.info('AMI event: %s', json.dumps(event, indent=2)) # Inject system name in every message event['SystemName'] = __grains__['id'] # Send event to Salt's event map __salt__['event.fire'](event, 'AMI/{}'.format(event['Event']))
def on_message(self, message): """Listens for a "websocket client ready" message. Once that message is received an asynchronous job is stated that yields messages to the client. These messages make up salt's "real time" event stream. """ logger.debug('Got websocket message {0}'.format(message)) if message == 'websocket client ready': if self.connected: # TBD: Add ability to run commands in this branch logger.debug('Websocket already connected, returning') return self.connected = True while True: try: event = yield self.application.event_listener.get_event( self) self.write_message(json.dumps(event)) except Exception as err: logger.info( 'Error! Ending server side websocket connection. Reason = {0}' .format(str(err))) break self.close() else: # TBD: Add logic to run salt commands here pass
def db_set(table, record, column, value, if_exists=False): ''' Sets a column's value for a specific record. Args: table: A string - name of the database table. record: A string - identifier of the record. column: A string - name of the column. value: A string - the value to be set if_exists: A boolean - if True, it is not an error if the record does not exist. Returns: None on success and an error message on failure. CLI Example: .. code-block:: bash salt '*' openvswitch.db_set Interface br0 mac 02:03:04:05:06:07 ''' cmd = ['ovs-vsctl'] if if_exists: cmd += ['--if-exists'] cmd += ['set', table, record, '{0}={1}'.format(column, json.dumps(value))] result = __salt__['cmd.run_all'](cmd) if result['retcode'] != 0: return result['stderr'] else: return None
def datagram_received(self, data, addr): ''' On datagram receive. :param data: :param addr: :return: ''' message = data.decode() if message.startswith(self.signature): try: timestamp = float(message[len(self.signature):]) except TypeError: self.log.debug('Received invalid timestamp in package from {}'.format("{}:{}".format(*addr))) if self.disable_hidden: self._sendto('{0}:E:{1}'.format(self.signature, 'Invalid timestamp'), addr) return if datetime.datetime.fromtimestamp(timestamp) < (datetime.datetime.now() - datetime.timedelta(seconds=20)): if self.disable_hidden: self._sendto('{0}:E:{1}'.format(self.signature, 'Timestamp is too old'), addr) self.log.debug('Received outdated package from {}'.format("{}:{}".format(*addr))) return self.log.debug('Received "{}" from {}'.format(message, "{}:{}".format(*addr))) self._sendto('{0}:@:{1}'.format(self.signature, json.dumps(self.answer)), addr) else: if self.disable_hidden: self._sendto('{0}:E:{1}'.format(self.signature, 'Invalid packet signature').encode(), addr) self.log.debug('Received bad signature from {}:{}'.format(*addr))
def _interface_format(interfaces_data): ''' Formats interfaces from SLS file into valid JSON usable for zabbix API. Completes JSON with default values. :param interfaces_data: list of interfaces data from SLS file ''' if not interfaces_data: return list() interface_attrs = ('ip', 'dns', 'main', 'type', 'useip', 'port') interfaces_json = loads(dumps(interfaces_data)) interfaces_dict = dict() for interface in interfaces_json: for intf in interface: intf_name = intf interfaces_dict[intf_name] = dict() for intf_val in interface[intf]: for key, value in intf_val.items(): if key in interface_attrs: interfaces_dict[intf_name][key] = value interfaces_list = list() interface_ports = { 'agent': ['1', '10050'], 'snmp': ['2', '161'], 'ipmi': ['3', '623'], 'jmx': ['4', '12345'] } for key, value in interfaces_dict.items(): # Load interface values or default values interface_type = interface_ports[value['type'].lower()][0] main = '1' if six.text_type(value.get( 'main', 'true')).lower() == 'true' else '0' useip = '1' if six.text_type(value.get( 'useip', 'true')).lower() == 'true' else '0' interface_ip = value.get('ip', '') dns = value.get('dns', key) port = six.text_type( value.get('port', interface_ports[value['type'].lower()][1])) interfaces_list.append({ 'type': interface_type, 'main': main, 'useip': useip, 'ip': interface_ip, 'dns': dns, 'port': port }) interfaces_list = interfaces_list interfaces_list_sorted = sorted(interfaces_list, key=lambda k: k['main'], reverse=True) return interfaces_list_sorted
def get_banned(): """ Get banned IP addresses. CLI Example: salt asterisk asterisk.get_banned """ result = [] data = ipset_list('blacklist') lines = data.split('\n') for line in lines: # Try IP style found = RE_IPSET_ENTRY.search(line) if found: address, timeout, packets, bytes, comment = found.group(1), \ found.group(2), found.group(3), \ found.group(4), found.group(5) result.append({ 'address': found.group(1), 'timeout': int(found.group(2)), 'packets': int(found.group(3)), 'bytes': int(found.group(4)), 'comment': found.group(5) }) log.debug('Banned entries: {}'.format(json.dumps( ['{}: {}'.format(k['address'], k['comment']) for k in result], indent=2))) return result
def _load_file_salt_rendered(self, filepath): ''' loads in one test file ''' # use the salt renderer module to interpret jinja and etc tests = _render_file(filepath) # use json as a convenient way to convert the OrderedDicts from salt renderer mydict = loads(dumps(tests), object_pairs_hook=OrderedDict) for key, value in mydict.items(): self.test_dict[key] = value return
def _media_format(medias_data): ''' Formats medias from SLS file into valid JSON usable for zabbix API. Completes JSON with default values. :param medias_data: list of media data from SLS file ''' if not medias_data: return list() medias_json = loads(dumps(medias_data)) medias_attr = ('active', 'mediatype', 'period', 'severity', 'sendto') media_type = {'mail': 1, 'jabber': 2, 'sms': 3} media_severities = ('D', 'H', 'A', 'W', 'I', 'N') medias_dict = dict() for media in medias_json: for med in media: medias_dict[med] = dict() for medattr in media[med]: for key, value in medattr.items(): if key in medias_attr: medias_dict[med][key] = value medias_list = list() for key, value in medias_dict.items(): # Load media values or default values active = '0' if six.text_type(value.get( 'active', 'true')).lower() == 'true' else '1' mediatype_sls = six.text_type(value.get('mediatype', 'mail')).lower() mediatypeid = six.text_type(media_type.get(mediatype_sls, 1)) period = value.get('period', '1-7,00:00-24:00') sendto = value.get('sendto', key) severity_sls = value.get('severity', 'HD') severity_bin = six.text_type() for sev in media_severities: if sev in severity_sls: severity_bin += '1' else: severity_bin += '0' severity = six.text_type(int(severity_bin, 2)) medias_list.append({ 'active': active, 'mediatypeid': mediatypeid, 'period': period, 'sendto': sendto, 'severity': severity }) return medias_list
def _ordered_dict_to_dict(probes): '''Mandatory to be dict type in order to be used in the NAPALM Jinja template.''' return loads(dumps(probes))
def run_test(self, test_dict): ''' Run a single saltcheck test ''' start = time.time() global_output_details = __salt__['config.get']('saltcheck_output_details', False) output_details = test_dict.get('output_details', global_output_details) if self.__is_valid_test(test_dict): skip = test_dict.get('skip', False) if skip: return {'status': 'Skip', 'duration': 0.0} mod_and_func = test_dict['module_and_function'] assertion_section = test_dict.get('assertion_section', None) assertion_section_delimiter = test_dict.get('assertion_section_delimiter', DEFAULT_TARGET_DELIM) args = test_dict.get('args', None) kwargs = test_dict.get('kwargs', None) pillar_data = test_dict.get('pillar_data', test_dict.get('pillar-data', None)) if pillar_data: if not kwargs: kwargs = {} kwargs['pillar'] = pillar_data else: # make sure we clean pillar from previous test if kwargs: kwargs.pop('pillar', None) if mod_and_func in ["saltcheck.state_apply"]: assertion = "assertNotEmpty" else: assertion = test_dict['assertion'] expected_return = test_dict.get('expected_return', test_dict.get('expected-return', None)) assert_print_result = test_dict.get('print_result', True) actual_return = self._call_salt_command(mod_and_func, args, kwargs, assertion_section, assertion_section_delimiter) if assertion not in ["assertIn", "assertNotIn", "assertEmpty", "assertNotEmpty", "assertTrue", "assertFalse"]: expected_return = self._cast_expected_to_returned_type(expected_return, actual_return) if assertion == "assertEqual": assertion_desc = "==" value = self.__assert_equal(expected_return, actual_return, assert_print_result) elif assertion == "assertNotEqual": assertion_desc = "!=" value = self.__assert_not_equal(expected_return, actual_return, assert_print_result) elif assertion == "assertTrue": assertion_desc = "True is" value = self.__assert_true(actual_return) elif assertion == "assertFalse": assertion_desc = "False is" value = self.__assert_false(actual_return) elif assertion == "assertIn": assertion_desc = "IN" value = self.__assert_in(expected_return, actual_return, assert_print_result) elif assertion == "assertNotIn": assertion_desc = "NOT IN" value = self.__assert_not_in(expected_return, actual_return, assert_print_result) elif assertion == "assertGreater": assertion_desc = ">" value = self.__assert_greater(expected_return, actual_return) elif assertion == "assertGreaterEqual": assertion_desc = ">=" value = self.__assert_greater_equal(expected_return, actual_return) elif assertion == "assertLess": assertion_desc = "<" value = self.__assert_less(expected_return, actual_return) elif assertion == "assertLessEqual": assertion_desc = "<=" value = self.__assert_less_equal(expected_return, actual_return) elif assertion == "assertEmpty": assertion_desc = "IS EMPTY" value = self.__assert_empty(actual_return) elif assertion == "assertNotEmpty": assertion_desc = "IS NOT EMPTY" value = self.__assert_not_empty(actual_return) else: value = "Fail - bad assertion" else: value = "Fail - invalid test" end = time.time() result = {} result['status'] = value if output_details: if assertion_section: assertion_section_repr_title = '.{0}'.format('assertion_section') assertion_section_repr_value = '.{0}'.format(assertion_section) else: assertion_section_repr_title = '' assertion_section_repr_value = '' result['module.function [args]{0}'.format( assertion_section_repr_title )] = '{0} {1}{2}'.format( mod_and_func, dumps(args), assertion_section_repr_value, ) result['saltcheck assertion'] = '{0}{1} {2}'.format( ('' if expected_return is None else '{0} '.format(expected_return)), assertion_desc, ('hidden' if not assert_print_result else actual_return) ) result['duration'] = round(end - start, 4) return result
def _ordered_dict_to_dict(probes): '''.''' return loads(dumps(probes))
def _run_assertions( self, mod_and_func, args, data, module_output, output_details, assert_print_result, ): """ Run assertion against input """ value = {} assertion_section = data.get("assertion_section", None) assertion_section_delimiter = data.get("assertion_section_delimiter", DEFAULT_TARGET_DELIM) if assertion_section: module_output = salt.utils.data.traverse_dict_and_list( module_output, assertion_section, default=False, delimiter=assertion_section_delimiter, ) if mod_and_func in ["saltcheck.state_apply"]: assertion = "assertNotEmpty" else: assertion = data["assertion"] expected_return = data.get("expected_return", data.get("expected-return", None)) if assertion not in [ "assertIn", "assertNotIn", "assertEmpty", "assertNotEmpty", "assertTrue", "assertFalse", ]: expected_return = self._cast_expected_to_returned_type( expected_return, module_output) if assertion == "assertEqual": assertion_desc = "==" value["status"] = self.__assert_equal(expected_return, module_output, assert_print_result) elif assertion == "assertNotEqual": assertion_desc = "!=" value["status"] = self.__assert_not_equal(expected_return, module_output, assert_print_result) elif assertion == "assertTrue": assertion_desc = "True is" value["status"] = self.__assert_true(module_output) elif assertion == "assertFalse": assertion_desc = "False is" value["status"] = self.__assert_false(module_output) elif assertion == "assertIn": assertion_desc = "IN" value["status"] = self.__assert_in(expected_return, module_output, assert_print_result) elif assertion == "assertNotIn": assertion_desc = "NOT IN" value["status"] = self.__assert_not_in(expected_return, module_output, assert_print_result) elif assertion == "assertGreater": assertion_desc = ">" value["status"] = self.__assert_greater(expected_return, module_output) elif assertion == "assertGreaterEqual": assertion_desc = ">=" value["status"] = self.__assert_greater_equal( expected_return, module_output) elif assertion == "assertLess": assertion_desc = "<" value["status"] = self.__assert_less(expected_return, module_output) elif assertion == "assertLessEqual": assertion_desc = "<=" value["status"] = self.__assert_less_equal(expected_return, module_output) elif assertion == "assertEmpty": assertion_desc = "IS EMPTY" value["status"] = self.__assert_empty(module_output) elif assertion == "assertNotEmpty": assertion_desc = "IS NOT EMPTY" value["status"] = self.__assert_not_empty(module_output) else: value["status"] = "Fail - bad assertion" if output_details: if assertion_section: assertion_section_repr_title = " {}".format( "assertion_section") assertion_section_repr_value = " {}".format(assertion_section) else: assertion_section_repr_title = "" assertion_section_repr_value = "" value["module.function [args]{}".format( assertion_section_repr_title)] = "{} {}{}".format( mod_and_func, dumps(args), assertion_section_repr_value, ) value["saltcheck assertion"] = "{}{} {}".format( ("" if expected_return is None else "{} ".format(expected_return)), assertion_desc, ("hidden" if not assert_print_result else module_output), ) return value
def run_test(self, test_dict): """ Run a single saltcheck test """ start = time.time() global_output_details = __salt__["config.get"]( "saltcheck_output_details", False ) output_details = test_dict.get("output_details", global_output_details) if self.__is_valid_test(test_dict): skip = test_dict.get("skip", False) if skip: return {"status": "Skip", "duration": 0.0} mod_and_func = test_dict["module_and_function"] assertion_section = test_dict.get("assertion_section", None) assertion_section_delimiter = test_dict.get( "assertion_section_delimiter", DEFAULT_TARGET_DELIM ) args = test_dict.get("args", None) kwargs = test_dict.get("kwargs", None) pillar_data = test_dict.get( "pillar_data", test_dict.get("pillar-data", None) ) if pillar_data: if not kwargs: kwargs = {} kwargs["pillar"] = pillar_data else: # make sure we clean pillar from previous test if kwargs: kwargs.pop("pillar", None) if mod_and_func in ["saltcheck.state_apply"]: assertion = "assertNotEmpty" else: assertion = test_dict["assertion"] expected_return = test_dict.get( "expected_return", test_dict.get("expected-return", None) ) assert_print_result = test_dict.get("print_result", True) actual_return = self._call_salt_command( mod_and_func, args, kwargs, assertion_section, assertion_section_delimiter, ) if assertion not in [ "assertIn", "assertNotIn", "assertEmpty", "assertNotEmpty", "assertTrue", "assertFalse", ]: expected_return = self._cast_expected_to_returned_type( expected_return, actual_return ) if assertion == "assertEqual": assertion_desc = "==" value = self.__assert_equal( expected_return, actual_return, assert_print_result ) elif assertion == "assertNotEqual": assertion_desc = "!=" value = self.__assert_not_equal( expected_return, actual_return, assert_print_result ) elif assertion == "assertTrue": assertion_desc = "True is" value = self.__assert_true(actual_return) elif assertion == "assertFalse": assertion_desc = "False is" value = self.__assert_false(actual_return) elif assertion == "assertIn": assertion_desc = "IN" value = self.__assert_in( expected_return, actual_return, assert_print_result ) elif assertion == "assertNotIn": assertion_desc = "NOT IN" value = self.__assert_not_in( expected_return, actual_return, assert_print_result ) elif assertion == "assertGreater": assertion_desc = ">" value = self.__assert_greater(expected_return, actual_return) elif assertion == "assertGreaterEqual": assertion_desc = ">=" value = self.__assert_greater_equal(expected_return, actual_return) elif assertion == "assertLess": assertion_desc = "<" value = self.__assert_less(expected_return, actual_return) elif assertion == "assertLessEqual": assertion_desc = "<=" value = self.__assert_less_equal(expected_return, actual_return) elif assertion == "assertEmpty": assertion_desc = "IS EMPTY" value = self.__assert_empty(actual_return) elif assertion == "assertNotEmpty": assertion_desc = "IS NOT EMPTY" value = self.__assert_not_empty(actual_return) else: value = "Fail - bad assertion" else: value = "Fail - invalid test" end = time.time() result = {} result["status"] = value if output_details: if assertion_section: assertion_section_repr_title = ".{0}".format("assertion_section") assertion_section_repr_value = ".{0}".format(assertion_section) else: assertion_section_repr_title = "" assertion_section_repr_value = "" result[ "module.function [args]{0}".format(assertion_section_repr_title) ] = "{0} {1}{2}".format( mod_and_func, dumps(args), assertion_section_repr_value, ) result["saltcheck assertion"] = "{0}{1} {2}".format( ("" if expected_return is None else "{0} ".format(expected_return)), assertion_desc, ("hidden" if not assert_print_result else actual_return), ) result["duration"] = round(end - start, 4) return result
def _ordered_dict_to_dict(config): ''' Forced the datatype to dict, in case OrderedDict is used. ''' return loads(dumps(config))