def __init__(self, metric_name, metric_value, metric_type, metric_creation_timestamp=None): assert PanoptesValidators.valid_nonempty_string( metric_name), 'metric_name must be a non-empty str' assert PanoptesValidators.valid_number( metric_value), 'metric_value must be number' assert PanoptesMetricValidators.valid_panoptes_metric_type( metric_type ), u'metric_type must be an attribute of PanoptesMetricType' assert (metric_creation_timestamp is None) or PanoptesValidators.valid_number(metric_creation_timestamp), \ u'metric_creation_timestamp should be None or a number' if not _VALID_KEY.match(metric_name): raise ValueError( u'metric name "%s" has to match pattern: (letter|"_") (letter | digit | "_")*' % metric_name) self.__data = dict() self.__data[u'metric_creation_timestamp'] = round(metric_creation_timestamp, METRICS_TIMESTAMP_PRECISION) if \ metric_creation_timestamp is not None else round(time(), METRICS_TIMESTAMP_PRECISION) self.__data[u'metric_name'] = metric_name self.__data[u'metric_value'] = metric_value self.__metric_type_raw = metric_type self.__data[u'metric_type'] = METRIC_TYPE_NAMES[metric_type].lower()
def _parse_x509_configuration(self): """ Parses the config spec to provide some details on the x509 communication. This is effectively requests over x509 based on the value of _x509_secure_connection. 0 - x509 communications 1 - x509 where available (optional) 2 - x509 mandatory (no connection made without x509) cert and key must be available for 1 & 2. """ self._x509_secure_connection = int(self._plugin_x509_configuration.get(u'x509_secured_requests', self._default_x509_configuration[ u'x509_secured_requests'])) assert PanoptesValidators.valid_positive_integer(self._x509_secure_connection),\ u'x509 secure connection must be a positive integer' assert self._x509_secure_connection < 3, u'x509 secure connection cannot be greater than 2' cert_location = self._plugin_x509_configuration.get(u'x509_cert_location', self._default_x509_configuration[u'x509_cert_location']) assert PanoptesValidators.valid_nonempty_string(cert_location), u'cert location must be a valid string' cert_filename = self._plugin_x509_configuration.get(u'x509_cert_filename', self._default_x509_configuration[u'x509_cert_filename']) assert PanoptesValidators.valid_nonempty_string(cert_filename), u'cert filename must be a valid string' self._x509_certificate_file = u'{}/{}'.format(cert_location, cert_filename) key_location = self._plugin_x509_configuration.get(u'x509_key_location', self._default_x509_configuration[u'x509_key_location']) assert PanoptesValidators.valid_nonempty_string(key_location), u'key location must be a valid string' key_filename = self._plugin_x509_configuration.get(u'x509_key_filename', self._default_x509_configuration[u'x509_key_filename']) assert PanoptesValidators.valid_nonempty_string(key_filename), u'key filename must be a valid string' self._x509_key_file = u'{}/{}'.format(key_location, key_filename)
def __init__(self, resource, group_type, interval, creation_timestamp=None): assert PanoptesMetricValidators.valid_panoptes_resource( resource), u'resource must be an instance of PanoptesResource' assert PanoptesValidators.valid_nonempty_string( group_type), u'group_type must be a non-empty string' assert PanoptesValidators.valid_nonzero_integer( interval), u'interval must a integer greater than zero' self.__data = dict() self.__metrics_index = { metric_type: list() for metric_type in METRIC_TYPE_NAMES } self.__data[u'metrics_group_type'] = group_type self.__data[u'metrics_group_interval'] = interval self.__data[u'metrics_group_creation_timestamp'] = round(time(), METRICS_TIMESTAMP_PRECISION) \ if creation_timestamp is None else creation_timestamp self.__data[ u'metrics_group_schema_version'] = METRICS_GROUP_SCHEMA_VERSION self.__data[u'resource'] = resource self.__data[u'metrics'] = set() self.__data[u'dimensions'] = set() self._data_lock = threading.Lock()
def test_valid_numeric_snmp_oid(self): self.assertTrue( PanoptesValidators.valid_numeric_snmp_oid( u".1.3.6.1.4.1.2636.3.1.13.1.6.2.1.0.0")) self.assertFalse( PanoptesValidators.valid_numeric_snmp_oid( u"1.3.6.1.4.1.2636.3.1.13.1.6.2.1.0.0"))
def bulk_walk(self, oid, non_repeaters=0, max_repetitions=10): """ Takes a single numeric oid and fetches oids under it's subtree using GETBULKs Args: oid (str): A numeric oid non_repeaters (int): A non-negative integer max_repetitions (int): A non-negative integer Returns: list(PanoptesSNMPVariable): A list of PanoptesSNMPVariables within the subtree of the provided oid """ assert PanoptesValidators.valid_numeric_snmp_oid(oid), u'oid must be numeric string with a leading period' assert PanoptesValidators.valid_positive_integer(non_repeaters), u'non_repeaters must a positive integer' assert PanoptesValidators.valid_positive_integer(max_repetitions), u'max_repetitions must a positive integer' assert self._easy_snmp_session is not None, u'PanoptesSNMPSession not initialized' base_oid = oid varbinds = list() running = 1 while running: results = self.get_bulk(oid=oid, non_repeaters=non_repeaters, max_repetitions=max_repetitions, base_oid=base_oid) varbinds.extend(results) if len(results) < max_repetitions: break oid = base_oid + u'.' + results[-1].index return varbinds
def get_bulk(self, oid, non_repeaters=0, max_repetitions=10, base_oid=None): """ Takes a single numeric oid and returns a list of PanoptesSNMPVariables which start with the oid Args: oid (str): A numeric oid non_repeaters (int): A non-negative integer max_repetitions (int): A non-negative integer base_oid (str): An optional numeric oid which is used to set the oid in the returned PanoptesSNMPVariables Returns: list(): A list of PanoptesSNMPVariables starting with the provided oid """ assert PanoptesValidators.valid_numeric_snmp_oid(oid), u'oid must be numeric string with a leading period' assert PanoptesValidators.valid_positive_integer(non_repeaters), u'non_repeaters must a positive integer' assert PanoptesValidators.valid_positive_integer(max_repetitions), u'max_repetitions must a positive integer' assert (base_oid is None) or PanoptesValidators.valid_numeric_snmp_oid( base_oid), u'oid must be numeric string with a leading period' assert self._easy_snmp_session is not None, u'PanoptesSNMPSession not initialized' try: varbinds = self._easy_snmp_session.get_bulk(oids=oid, non_repeaters=non_repeaters, max_repetitions=max_repetitions) result = list() for varbind in varbinds: if varbind.oid.startswith(base_oid): result.append(PanoptesSNMPVariable(queried_oid=base_oid if base_oid else oid, oid=varbind.oid, index=varbind.oid_index, value=varbind.value, snmp_type=varbind.snmp_type)) return result except Exception as e: raise self._wrap_panoptes_snmp_exception(e)
def __init__(self, panoptes_context, plugin_type, plugin_type_display_name, celery_config, lock_timeout, plugin_scheduler_task, plugin_subtype=None): assert PanoptesContextValidators.valid_panoptes_context( panoptes_context), u'panoptes_context must be an instance of PanoptesContext' assert PanoptesValidators.valid_nonempty_string(plugin_type), u'plugin_type must be a non-empty str' assert PanoptesValidators.valid_nonempty_string(plugin_type_display_name), \ u'plugin_type_display_name must be a non-empty str' assert PanoptesCeleryValidators.valid_celery_config( celery_config), u'celery_config must be an instance of PanoptesCeleryConfig' assert PanoptesValidators.valid_nonzero_integer(lock_timeout), u'lock_timeout must be an int greater than zero' assert PanoptesValidators.valid_callback(plugin_scheduler_task), u'plugin_scheduler_task must be a callable' assert plugin_type is None or PanoptesValidators.valid_nonempty_string(plugin_type), u'plugin_type must be a ' \ u'None or a non-empty str' self._panoptes_context = panoptes_context self._config = self._panoptes_context.config_dict self._logger = self._panoptes_context.logger self._shutdown_plugin_scheduler = threading.Event() self._plugin_scheduler_celery_beat_service = None self._celery_config = celery_config self._celery = None self._t = None self._lock = None self._plugin_type = plugin_type self._plugin_subtype = plugin_subtype self._plugin_type_display_name = plugin_type_display_name self._lock_timeout = lock_timeout self._plugin_scheduler_task = plugin_scheduler_task self._tour_of_duty = PanoptesTourOfDuty(splay_percent=50) self._cycles_without_lock = 0
def add_metadata(self, key, value): """ Add a metadata key/value pair Args: key(str): The syntax for a key is the same as for valid Python identifier: (letter|"_") (letter | digit "_") value(str): A pipe (|) is a special reserved character and cannot be present in a value Returns: None Raises: ValueError: If the key or value don't match the acceptable string patterns, a ValueError is raised Examples: add_metadata('os_name', 'Advanced Core OS') add_metadata('os_version', '2.6.1-GR1-P16') """ assert PanoptesValidators.valid_nonempty_string(key), u'key must be a non-empty str or unicode' assert PanoptesValidators.valid_nonempty_string(value), u'value must be a non-empty str or unicode' if not self.__class__._metadata_key.match(key): raise ValueError(u'metadata key "%s" has to match pattern: (letter|"_") (letter | digit | "_")*' % key) if u'|' in value: raise ValueError(u'metadata value "%s" cannot contain |' % value) self.__data[u'resource_metadata'][key] = value
def __init__(self, host, port, timeout, retries, context, our_identity, their_identity): """ Starts a SNMP V3 connection with the given parameters - works only with TLS Args: host (str): The host to interact with SNMP port (int): The port on the host timeout (int): Non-zero seconds to wait for connection and replies retries (int): The number of times to retry a failed query context (str): A non-empty SNMP v3 context our_identity (str): The fingerprint or filename of the certificate to present to the host their_identity (str): The fingerprint or filename of the certificate to expect from the host Returns: None: The session is initiated and stored locally """ super(PanoptesSNMPV3TLSConnection, self).__init__(host, port, timeout, retries) assert PanoptesValidators.valid_nonempty_string(context), u'context must be a non-empty string' assert PanoptesValidators.valid_nonempty_string(our_identity), u'our_identity must be a non-empty string' assert PanoptesValidators.valid_nonempty_string(their_identity), u'their_identity must be a non-empty string' self._context = context self._our_identity = our_identity self._their_identity = their_identity try: self._easy_snmp_session = easysnmp.Session(hostname=self._host, remote_port=self._port, timeout=self._timeout, retries=self._retries, version=3, use_numeric=True, transport=u'tlstcp', context=self._context, our_identity=self._our_identity, their_identity=self._their_identity) except Exception as e: raise self._wrap_panoptes_snmp_exception(e)
def getset(self, key, value, expire=604800): """ Set the value associated with the key in the key/value store and returns the previously set value This does an 'upsert' - inserts the key/value if it does not exist and updates the value if the key exists Args: key (str): The key whose value should be set value (str): The value to set expire (int): A positive integer that, if sets, would expire the key in the number of seconds specified Returns: None: Nothing. Passes through exceptions in case of failure """ assert PanoptesValidators.valid_nonempty_string( key), u'key must be a non-empty str' assert PanoptesValidators.valid_nonempty_string( value), u'key value be a non-empty str' assert PanoptesValidators.valid_nonzero_integer( expire), u'expire must be an integer greater than zero' value = self._get_redis_shard(key).getset(self._normalized_key(key), value.encode('utf-8')) self._get_redis_shard(key).expire(self._normalized_key(key), expire) if value is not None: return value.decode('utf-8')
def get_enrichment_keys(self, resource_id, namespace): """ Returns enrichment keys for matching resource_id and namespace Args: resource_id (str): Panoptes resource id namespace (str): Enrichment namespace Returns: enrichment_keys (list): enrichment keys(label) """ assert PanoptesValidators().valid_nonempty_string(resource_id), u'resource_id must be a string' assert PanoptesValidators().valid_nonempty_string(namespace), u'enrichment namespace must be a string' if resource_id == u'self': resource_id = self._resource_id try: return list(self._enrichment_data[resource_id][namespace].keys()) except KeyError: try: self._preload_data(resource_id, namespace) return list(self._enrichment_data[resource_id][namespace].keys()) except Exception as e: raise PanoptesEnrichmentCacheError(u'Failed to get data for resource {} namespace {} from enrichment ' u'cache object: {} plugin_name' .format(resource_id, namespace, repr(e), self._plugin_name))
def get_enrichment_value(self, resource_id, namespace, enrichment_key): """ Returns enrichment value for matching resource_id, namespace and enrichment_key Args: resource_id (str): Panoptes resource id namespace (str): Enrichment namespace enrichment_key (str): Enrichment set key Returns: enrichment_set (dict): key, value pairs of enrichment """ assert PanoptesValidators().valid_nonempty_string(resource_id), u'resource_id must be a string' assert PanoptesValidators().valid_nonempty_string(namespace), u'enrichment namespace must be a string' assert PanoptesValidators().valid_nonempty_string(enrichment_key), u'enrichment_key must be a string' if resource_id == u'self': resource_id = self._resource_id try: return self._enrichment_data[resource_id][namespace][enrichment_key] except KeyError: try: self._preload_data(resource_id, namespace) return self._enrichment_data[resource_id][namespace][enrichment_key] except Exception as e: raise PanoptesEnrichmentCacheError( u'Failed to get data for resource {} namespace {} enrichment_key {} ' u'from enrichment cache object: {} plugin_name: {}'.format( resource_id, namespace, enrichment_key, repr(e), self._plugin_name))
def __init__(self, host, port, timeout, retries): assert PanoptesValidators.valid_nonempty_string(host), u'host must a non-empty string' assert PanoptesValidators.valid_port(port), u'port must be an integer between 1 and 65535' assert PanoptesValidators.valid_nonzero_integer(timeout), u'timeout must be a integer greater than zero' assert PanoptesValidators.valid_positive_integer(retries), u'retries must a non-negative integer' self._host = host self._port = port self._timeout = timeout self._retries = retries self._easy_snmp_session = None
def get_resources(self, site=None, plugin_name=None): """ Get all resources from the Redis store The serialization that this expects in Redis is: key: 'resource:resource_site:<sitename>:resource_class:<class>:resource_subclass:<subclass>:resouce_type :<type>:resource_id:<id>:resource_endpoint:endpoint' value: 'timestamp:<unix epoch>{:meta:<key name>:<value>}*' Args: site (str, None): An optional string which filters resources by site plugin_name (str, None): An optional string which filters resources by the plugin they were discovered through Returns: PanoptesResourceSet: All resources fetched from the Redis store """ assert PanoptesValidators.valid_none_or_string(site), u'site should be None or a str' assert PanoptesValidators.valid_none_or_string(plugin_name), u'plugin_name should be None or a str' logger = self.__panoptes_context.logger resources = PanoptesResourceSet() key_namespace = u'' if plugin_name: key_namespace += u'plugin|' + plugin_name + u'|' if site: key_namespace += u'site|' + site + u'|' key_namespace += u'*' logger.info(u'Trying to get all resources under key namespace "%s"' % key_namespace) start = time() for key in self.__kv.find_keys(pattern=key_namespace): logger.debug(u'Attempting to get resource under key "%s"' % key) try: resource = self.get_resource(key) logger.debug(u'Found resource "%s"' % resource) except: logger.exception(u'Error trying to get "%s", skipping resource' % key) continue resources.add(resource) end = time() logger.info(u'Fetched %d resource(s) in %.2f seconds' % (len(resources), end - start)) return resources
def test_valid_port(self): self.assertTrue(PanoptesValidators.valid_port(1)) self.assertFalse(PanoptesValidators.valid_port(1.0)) self.assertFalse(PanoptesValidators.valid_port(65540)) self.assertFalse(PanoptesValidators.valid_port(0)) self.assertFalse(PanoptesValidators.valid_port(-1)) self.assertFalse(PanoptesValidators.valid_port(u"0")) self.assertFalse(PanoptesValidators.valid_port(u"1")) self.assertFalse(PanoptesValidators.valid_port(True)) self.assertFalse(PanoptesValidators.valid_port(False))
def test_valid_nonempty_iterable_of_strings(self): class SampleIterator(object): def __init__(self, item): self.test_list = list() self.test_list.append(item) def __iter__(self): return iter(self.test_list) def __len__(self): return len(self.test_list) self.assertTrue( PanoptesValidators.valid_nonempty_iterable_of_strings(list(u'x'))) self.assertTrue( PanoptesValidators.valid_nonempty_iterable_of_strings(set(u'x'))) self.assertTrue( PanoptesValidators.valid_nonempty_iterable_of_strings( SampleIterator(u'x'))) self.assertFalse( PanoptesValidators.valid_nonempty_iterable_of_strings(u'x')) self.assertFalse( PanoptesValidators.valid_nonempty_iterable_of_strings([])) self.assertFalse( PanoptesValidators.valid_nonempty_iterable_of_strings([u''])) self.assertFalse( PanoptesValidators.valid_nonempty_iterable_of_strings([u'x', u''])) self.assertFalse( PanoptesValidators.valid_nonempty_iterable_of_strings( [u'x', set(u'x')]))
def __init__(self, resource_site, resource_class, resource_subclass, resource_type, resource_id, resource_endpoint, resource_creation_timestamp=None, resource_plugin=None, resource_ttl=const.RESOURCE_MANAGER_RESOURCE_EXPIRE): assert PanoptesValidators.valid_nonempty_string(resource_site), u'resource_site must be a non-empty str' assert PanoptesValidators.valid_nonempty_string(resource_class), u'resource_class must be a non-empty str' assert PanoptesValidators.valid_nonempty_string(resource_subclass), u'resource_subclass must be a non-empty' assert PanoptesValidators.valid_nonempty_string(resource_type), u'resource_type must be a non-empty str' assert PanoptesValidators.valid_nonempty_string(resource_id), u'resource_id must be a non-empty str' assert PanoptesValidators.valid_nonempty_string(resource_endpoint), u'resource_endpoint must be a non-empty str' assert PanoptesValidators.valid_none_or_nonempty_string( resource_plugin), u'resource_plugin must be None or a non-empty str' assert PanoptesValidators.valid_nonzero_integer(resource_ttl), u'resource_ttl must be an integer greater than 0' self.__data = OrderedDict() self.__data[u'resource_site'] = str(resource_site) self.__data[u'resource_class'] = str(resource_class) self.__data[u'resource_subclass'] = str(resource_subclass) self.__data[u'resource_type'] = str(resource_type) self.__data[u'resource_id'] = str(resource_id) self.__data[u'resource_endpoint'] = str(resource_endpoint) self.__data[u'resource_metadata'] = OrderedDict() if not resource_creation_timestamp: self.__data[u'resource_creation_timestamp'] = time() else: self.__data[u'resource_creation_timestamp'] = resource_creation_timestamp self.__data[u'resource_plugin'] = resource_plugin self.__data[u'resource_metadata'][u'_resource_ttl'] = str(resource_ttl)
def __init__(self, panoptes_context, logger_name, config, key_value_store, secrets_store, data=None): assert PanoptesContextValidators.valid_panoptes_context( panoptes_context ), u'panoptes_context must be an instance of PanoptesContext' assert PanoptesValidators.valid_nonempty_string( logger_name), u'logger_name must be a non-empty str' assert config is None or isinstance(config, dict), u'config must be a dict' assert isinstance( secrets_store, PanoptesKeyValueStore ), u'secrets_store must be an instance of PanoptesKeyValueStore' assert isinstance( key_value_store, PanoptesKeyValueStore ), u'key_value_store must be an instance of PanoptesKeyValueStore' self._panoptes_context = panoptes_context self._logger = panoptes_context.logger.getChild(logger_name) self._config = config self._kv_store = key_value_store self._secrets_store = secrets_store self._data = data self._sites = panoptes_context.config_object.sites self._snmp_defaults = panoptes_context.config_object.snmp_defaults self._x509_defaults = panoptes_context.config_object.x509_defaults
def __init__(self, namespace, schema_validator, enrichment_ttl, execute_frequency): assert PanoptesValidators().valid_nonempty_string(namespace), u'enrichment namespace must be a string' assert isinstance(schema_validator, PanoptesEnrichmentSchemaValidator), \ u'schema_validator must be an instance of PanoptesEnrichmentSchemaValidator' assert PanoptesValidators().valid_nonzero_integer(enrichment_ttl), \ u'enrichment_ttl must be a valid nonzero integer' assert PanoptesValidators().valid_nonzero_integer(execute_frequency), \ u'execute_frequency must be a valid nonzero integer' self.__data = dict() self.__data[u'metadata'] = dict() self.__data[u'namespace'] = namespace self.__data[u'data'] = set() self.__schema_validator = schema_validator self.__data[u'metadata'][u'_enrichment_group_creation_timestamp'] = time.time() self.__data[u'metadata'][u'_enrichment_ttl'] = enrichment_ttl self.__data[u'metadata'][u'_execute_frequency'] = execute_frequency
def _smart_add_dimension(self, method, dimension_name, index): dimension = method(index) if dimension is not None and PanoptesValidators.valid_nonempty_string(str(dimension)): self._interface_metrics_group.add_dimension(PanoptesMetricDimension(dimension_name, str(dimension))) else: self._interface_metrics_group.add_dimension(PanoptesMetricDimension(dimension_name, _DEFAULT_DIMENSION_VALUE))
def __init__(self, host, port, timeout, retries, community): """ Starts a SNMP V2 connection with the given parameters Args: host (str): The host to interact with SNMP port (int): The port on the host timeout (int): Non-zero seconds to wait for connection and replies retries (int): The number of times to retry a failed query community (str): The community string to use Returns: None: The session is initiated and stored locally """ super(PanoptesSNMPV2Connection, self).__init__(host, port, timeout, retries) assert PanoptesValidators.valid_nonempty_string(community), u'community_string must a non-empty string' self._community = community try: self._easy_snmp_session = easysnmp.Session(hostname=self._host, remote_port=self._port, timeout=self._timeout, retries=self._retries, version=2, use_numeric=True, community=self._community) except Exception as e: raise self._wrap_panoptes_snmp_exception(e)
def __init__(self, key, value={None: None}): assert PanoptesValidators().valid_nonempty_string(key), u'enrichment key must be a string' assert isinstance(value, dict), u'enrichment value must be a dict' if value == {None: None}: value = {} self.__data = dict() self._key = key self.__data[self._key] = value
def _get_snmp_community_string(self): """ This method sets the community string that should be used. It looks up the community string in the following order of preference 1. A community string specified in the plugin configuration file 2. A community string related to the site in which the resource resides from the 'secrets' store 3. The default community string specified in the Panoptes configuration file Returns: None """ logger = self._plugin_context.logger # Try and get community string from the plugin configuration self._community = self._plugin_snmp_configuration.get(u'community') if self._community: assert PanoptesValidators.valid_nonempty_string( self._community), u'SNMP community must be a non-empty string' return # Else lookup the site-specific community string site = self._plugin_context.data.resource_site try: logger.debug( u'Going to get fetch SNMP community string using key "{}" for site "{}"' .format(self.community_string_key, site)) self._community = self._plugin_context.secrets.get_by_site( self.community_string_key, site) except Exception as e: raise PanoptesSNMPException( u'Could not fetch SNMP community string for site "{}" using key "{}": {}' .format(site, self.community_string_key, repr(e))) if self._community: assert PanoptesValidators.valid_nonempty_string( self._community), u'SNMP community must be a non-empty string' return # Else return default community string self._community = self._default_snmp_configuration.get(u'community') assert PanoptesValidators.valid_nonempty_string( self._community), u'SNMP community must be a non-empty string'
def test_valid_positive_integer(self): self.assertTrue(PanoptesValidators.valid_positive_integer(0)) self.assertTrue( PanoptesValidators.valid_positive_integer(2**(2**(2**(2**2))))) self.assertFalse(PanoptesValidators.valid_positive_integer(False)) self.assertFalse(PanoptesValidators.valid_positive_integer(True)) self.assertFalse(PanoptesValidators.valid_positive_integer(u"")) self.assertFalse(PanoptesValidators.valid_positive_integer(1.0)) self.assertFalse(PanoptesValidators.valid_positive_integer(-5)) self.assertTrue(PanoptesValidators.valid_positive_integer(-0))
def test_valid_nonzero_integer(self): self.assertFalse(PanoptesValidators.valid_nonzero_integer(-1)) self.assertFalse(PanoptesValidators.valid_nonzero_integer(0)) self.assertFalse(PanoptesValidators.valid_nonzero_integer(-0)) self.assertFalse(PanoptesValidators.valid_nonzero_integer(1.0)) self.assertFalse(PanoptesValidators.valid_nonzero_integer(u"")) self.assertFalse(PanoptesValidators.valid_nonzero_integer(False)) self.assertFalse(PanoptesValidators.valid_nonzero_integer(True)) self.assertTrue( PanoptesValidators.valid_nonzero_integer(2**(2**(2**(2**2)))))
def add_resource(self, plugin_signature, resource): assert PanoptesValidators.valid_nonempty_string(plugin_signature), u'plugin_signature must be a non-empty str' assert PanoptesResourceValidators.valid_panoptes_resource(resource), u'resource must be a non-empty instance ' \ u'of PanoptesResource' key, value = self._serialize_resource(resource) try: self.__kv.set(key, value, expire=int(resource.resource_ttl)) except Exception as e: raise PanoptesResourceError(u'Error trying to add resource "%s": %s' % (resource, str(e)))
def _parse_snmp_configuration(self): self._connection_factory_module = self._plugin_snmp_configuration.get(u'connection_factory_module', self._default_snmp_configuration[ u'connection_factory_module']) assert PanoptesValidators.valid_nonempty_string( self._connection_factory_module), u'SNMP connection factory module must be a non-empty string' self._connection_factory_class = self._plugin_snmp_configuration.get(u'connection_factory_class', self._default_snmp_configuration[ u'connection_factory_class']) assert PanoptesValidators.valid_nonempty_string( self._connection_factory_class), u'SNMP connection factory class must be a non-empty string' self._community_string_key = self._plugin_snmp_configuration.get(u'community_string_key', self._default_snmp_configuration.get( u'community_string_key')) assert PanoptesValidators.valid_nonempty_string( self._community_string_key), u'SNMP community string key must be a non-empty string' self._port = int( self._plugin_snmp_configuration.get(u'port', self._default_snmp_configuration[u'port'])) assert PanoptesValidators.valid_port(self._port), u'SNMP port must be a valid TCP/UDP port number' self._proxy_port = int( self._plugin_snmp_configuration.get(u'proxy_port', self._default_snmp_configuration[u'proxy_port'])) assert PanoptesValidators.valid_port(self._proxy_port), u'SNMP proxy port must be a valid TCP/UDP port number' self._timeout = int( self._plugin_snmp_configuration.get(u'timeout', self._default_snmp_configuration[u'timeout'])) assert PanoptesValidators.valid_nonzero_integer( self._timeout), u'SNMP timeout must be a positive integer' self._retries = int( self._plugin_snmp_configuration.get(u'retries', self._default_snmp_configuration[u'retries'])) assert PanoptesValidators.valid_nonzero_integer( self._retries), u'SNMP retries must be a positive integer' self._non_repeaters = int(self._plugin_snmp_configuration.get(u'non_repeaters', self._default_snmp_configuration[ u'non_repeaters'])) assert PanoptesValidators.valid_positive_integer( self._non_repeaters), u'SNMP non-repeaters must be a positive integer' self._max_repetitions = int( self._plugin_snmp_configuration.get(u'max_repetitions', self._default_snmp_configuration[u'max_repetitions'])) assert PanoptesValidators.valid_nonzero_integer( self._max_repetitions), u'SNMP max-repetitions must be a positive integer'
def send_messages(self, topic, key, messages, partitioning_key=None): """ Send messages to the specified topic This method tries to ensures that the topic exists before trying to send a message to it. If auto-creation of topics is enabled, then this should always succeed (barring Kafka/Zookeeper failures) Args: topic (str): The topic to which the message should be sent key (str): The key for the message messages (str): The message to send partitioning_key (str): If provided, then it would be used to select the partition for the message instead \ of the message key Returns: None: Nothing. Passes through exceptions in case of failure """ assert PanoptesValidators.valid_nonempty_string(topic), u'topic must be a non-empty string' assert PanoptesValidators.valid_nonempty_string(key), u'key must be a non-empty string' assert PanoptesValidators.valid_nonempty_string(messages), u'messages must be a non-empty string' self._kafka_client.ensure_topic_exists(topic) if partitioning_key: # We do this hack so that the partitioning key can be different from the message key partition = self._kafka_producer._next_partition(topic, partitioning_key.encode('utf-8')) self._kafka_producer._send_messages( topic, partition, messages.encode('utf-8'), key=key.encode('utf-8') ) else: # In this case, the message key is used as the partitioning key self._kafka_producer.send_messages( topic, key.encode('utf-8'), messages.encode('utf-8') )
def __init__(self, count=10, timeout=10, hostname='localhost'): assert PanoptesValidators.valid_nonzero_integer(count), 'count must be integer > 0' assert PanoptesValidators.valid_nonempty_string(hostname), 'hostname must be nonempty string' assert PanoptesValidators.valid_nonzero_integer(timeout), 'timeout must be integer > 0' super(PanoptesPingDirect, self).__init__() try: resp = subprocess.check_output( ['/bin/ping', '-c', str(count), '-w', str(timeout), hostname], stderr=subprocess.STDOUT, universal_newlines=True # return string not bytes ) self._get_ping_stats(resp) except subprocess.CalledProcessError as e: self._get_ping_stats(e.output) if self._response['packets_transmitted'] is not None: raise PanoptesPingTimeoutException("Ping timed out with response: " + str(self._response)) raise PanoptesPingException(e.output) except Exception as e: raise PanoptesPingException(str(e))
def upsert_metadata(self, metadata_key, metadata_value): """ Adds metadata key / value pairs to PanoptesEnrichmentGroup Args: metadata_key (str): metadata key metadata_value (str or int or float): metadata value Returns: None """ assert PanoptesValidators().valid_nonempty_string(metadata_key), u'metadata_key must be a string' if metadata_key.startswith(u'_'): raise ValueError(u'Failed to update reserved metadata') assert \ PanoptesValidators().valid_nonempty_string(metadata_value) or \ PanoptesValidators().valid_number(metadata_value), u'metadata_value must be any of string / float / integer' self.__data[u'metadata'][metadata_key] = metadata_value