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 __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 _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 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 _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 __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 __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,
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 _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 _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 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 __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 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, plugin_name, plugin_type, plugin_class,
plugin_info_class, plugin_data, panoptes_context,
plugin_agent_kv_store_class, plugin_kv_store_class,
plugin_secrets_store_class, plugin_logger_name,
plugin_result_class, results_callback):
assert PanoptesValidators.valid_nonempty_string(
plugin_name), u'plugin_name must be a non-empty string'
assert PanoptesValidators.valid_nonempty_string(
plugin_type), u'plugin_type must be a non-empty string'
assert PanoptesBasePluginValidators.valid_plugin_class(
plugin_class
), u'plugin_class must be instance of PanoptesBasePlugin'
assert PanoptesPluginInfoValidators.valid_plugin_info_class(
plugin_info_class
), u'plugin_info_class must be instance of PanoptesPluginInfo'
assert PanoptesValidators.valid_hashable_object(
plugin_data), u'plugin_data must be a valid hashable object'
assert PanoptesKeyValueStoreValidators.valid_kv_store_class(
plugin_kv_store_class
), u'plugin_kv_store_class must be a subclass of PanoptesKeyValueStore'
assert PanoptesKeyValueStoreValidators.valid_kv_store_class(
plugin_secrets_store_class
), u'plugin_secrets_store_class must be a subclass of PanoptesKeyValueStore'
assert PanoptesValidators.valid_nonempty_string(plugin_logger_name), u'plugin_logger_name must be a non-empty '\
u'string'
assert PanoptesValidators.valid_callback(
results_callback), u'plugin_callback must be a callable'
self._plugin_name = plugin_name
self._plugin_type = plugin_type
self._plugin_class = plugin_class
self._plugin_info_class = plugin_info_class
self._plugin_data = plugin_data
self._panoptes_context = panoptes_context
self._plugin_agent_kv_store_class = plugin_agent_kv_store_class
self._plugin_secrets_store_class = plugin_secrets_store_class
self._plugin_kv_store_class = plugin_kv_store_class
self._plugin_logger_name = plugin_logger_name
self._logger = self._panoptes_context.logger
self._plugin_result_class = plugin_result_class
self._results_callback = weakref.proxy(results_callback)
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 set_add(self, set_name, member):
"""
Add a member to the set associated in the the key/value store
This does an 'upsert' - inserts the set (and member) if it does not exist and updates the member if the set \
exists
Args:
set_name (str): The key whose value should be set
member (str): The value of the member to add to the set
Returns:
None: Nothing. Passes through exceptions in case of failure
"""
assert PanoptesValidators.valid_nonempty_string(
set_name), u'set_name must be a non-empty str'
assert PanoptesValidators.valid_nonempty_string(
member), u'member must be a non-empty str'
return self._get_redis_shard(set_name).sadd(
self._normalized_key(set_name), member.encode('utf-8'))
def get_by_site(self, secret_name, site, fallback_to_default=True):
assert PanoptesValidators.valid_nonempty_string(
secret_name), u'secret_name must be a non-empty str or unicode'
assert PanoptesValidators.valid_nonempty_string(
site), u'site must be a non-empty str or unicode'
assert type(fallback_to_default
) == bool, u'fallback_to_default must be a boolean'
secret_key = secret_name + u':' + site
try:
secret = super(PanoptesSecretsStore, self).get(key=secret_key)
return secret
except Exception as e:
if not fallback_to_default:
raise e
# If we didn't find a site based key AND fallback_to_default is set to true
secret_key = secret_name + u':default'
try:
secret = super(PanoptesSecretsStore, self).get(key=secret_key)
return secret
except Exception as e:
raise e
def config_filename(self, filename):
"""
Sets name of configuration file associated with the plugin - note that setting this does not change/reload the
configuration
Args:
filename (str): The name of configuration file associated with the plugin
Returns:
None
"""
assert PanoptesValidators.valid_nonempty_string(
filename), u'filename must be a non empty string'
self._config_filename = filename
def ttl(self, key):
"""
Return the Time to Live (TTL) in seconds, of the given key.
Args:
key (str): The key whose ttl should be obtained
Returns:
ttl (int): TTL of the key, in seconds
"""
assert PanoptesValidators.valid_nonempty_string(
key), u'key must be a non-empty str'
return self._get_redis_shard(key).ttl(self._normalized_key(key))
def __init__(self, context, path, timeout, retries=1, identifier=None):
"""
Creates and maintains state for a lock
Args:
path (str): A '/' separated path for the lock
timeout (int): in seconds. Must be a positive integer
retries (int): how many times to try before giving up. Zero implies try forever
identifier (str): Name to use for this lock contender. This can be useful for querying \
to see who the current lock contenders are
Returns:
PanoptesLock: lock
"""
assert PanoptesContextValidators.valid_panoptes_context(
context), u'context must be a valid PanoptesContext'
assert PanoptesValidators.valid_nonempty_string(path) and re.search(r"^/\S+", path), \
u'path must be a non-empty string that begins with /'
assert PanoptesValidators.valid_nonzero_integer(
timeout), u'timeout must be a positive integer'
assert PanoptesValidators.valid_positive_integer(
retries), u'retries must be a non-negative integer'
assert PanoptesValidators.valid_nonempty_string(
identifier), u'identifier must be a non-empty string'
self._context = context
self._logger = self._context.logger
self._path = path
self._timeout = timeout
self._retries = retries
self._identifier = identifier
self._lock = None
self._locked = False
self._calling_module = get_calling_module_name(3)
self._get_lock()
def get_resource(self, resource_key):
assert PanoptesValidators.valid_nonempty_string(resource_key), u'resource_key must be a non-empty str or' \
u' unicode'
logger = self.__panoptes_context.logger
try:
value = self.__kv.get(resource_key)
except Exception as e:
logger.exception(u'Error trying to get value from key-value store for key "%s"' % resource_key)
raise PanoptesResourceError(u'Error trying to fetch value for key "%s": %s ' % (resource_key, repr(e)))
if not value:
logger.exception(u'Error -- No resource found for key "%s"' % resource_key)
raise PanoptesResourceError(u'No resource found for key "%s"' % resource_key)
return self._deserialize_resource(resource_key, value)
def __init__(self, query, panoptes_context):
assert PanoptesValidators.valid_nonempty_string(query), u'query must be an instance of str'
assert panoptes_context and isinstance(panoptes_context,
PanoptesContext), u'panoptes_context must be an instance of ' \
u'PanoptesContext'
self._query = query
logger = panoptes_context.logger
logger.info(u'Parsing query expression: %s' % query)
try:
tokens = self._parse_query()
except ParseException as e:
logger.error(u'Error in parsing expression "%s": %s' % (query, str(e)))
raise e
else:
logger.debug(u'Tokens = %s' % tokens)
self._tokens = tokens
def get(self, key):
"""
Get the value associated with the key from the key/value store
Args:
key (str): The key whose value should be returned
Returns:
str: The value associated with the key. None if the key is not found in the key/value store. Passes \
through exceptions in case of failure
"""
assert PanoptesValidators.valid_nonempty_string(
key), u'key must be a non-empty str'
key = self._normalized_key(key)
value = self._get_redis_shard(key).get(key)
if value is not None:
return value.decode('utf-8')
def set_members(self, set_name):
"""
Get the members associated with the set from the key/value store
Args:
set_name (str): The set whose members should be returned
Returns:
list: The members associated with the set. None if the set is not found in the key/value store. Passes \
through exceptions in case of failure
"""
assert PanoptesValidators.valid_nonempty_string(
set_name), u'set_name must be a non-empty str'
result = {
member.decode('utf-8')
for member in self._get_redis_shard(set_name).smembers(
self._normalized_key(set_name))
}
return result
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 __init__(self, count=10, timeout=10, hostname=u'localhost'):
assert PanoptesValidators.valid_nonzero_integer(
count), u'count must be integer > 0'
assert PanoptesValidators.valid_nonempty_string(
hostname), u'hostname must be nonempty string'
assert PanoptesValidators.valid_nonzero_integer(
timeout), u'timeout must be integer > 0'
self._response = dict() # dictionary containing ping statistics
self._response[u'packets_transmitted'] = None
self._response[u'packets_received'] = None
self._response[u'packet_loss_pct'] = None
self._response[u'execution_time'] = None
self._response[u'round_trip_min'] = None
self._response[u'round_trip_avg'] = None
self._response[u'round_trip_max'] = None
self._response[u'round_trip_stddev'] = None
try:
resp = subprocess.check_output(
[
u'/bin/ping', u'-c',
str(count), u'-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[u'packets_transmitted'] is not None:
raise PanoptesPingTimeoutException(
u"Ping timed out with response: " + str(self._response))
raise PanoptesPingException(e.output)
except Exception as e:
raise PanoptesPingException(e.message)
def __init__(self, app_name):
assert PanoptesValidators.valid_nonempty_string(
app_name), u'app_name must be a non-empty string'
self._celery_app_name = app_name
def test_valid_nonempty_string(self):
self.assertFalse(PanoptesValidators.valid_nonempty_string(u""))
self.assertTrue(
PanoptesValidators.valid_nonempty_string(u"hello world"))
self.assertFalse(PanoptesValidators.valid_nonempty_string(0))