def validate(self): if not self.validate_es: return if not self.es.ping(): raise InvalidConfiguration('Can not connect to elasticsearch') try: self.es.indices.get_template(name=self.template_name) except NotFoundError: raise InvalidConfiguration(self.template_not_found_msg)
def validate(self) -> None: if not self.is_enabled(): return if self.storage_options is not None and self.storage_options[ "options"] is None: raise InvalidConfiguration( "`chart-rendering.storage.options` must be configured if `chart-rendering.storage.backend` is configured" ) if not self.service_url: raise InvalidConfiguration( "`chart-rendering.chartcuterie.url` is not configured")
def validate(self): if not self.is_enabled(): return if not self.service_url: raise InvalidConfiguration( "`chart-rendering.chartcuterie.url` is not configured")
def check_versions(service, versions, required, recommended=None): """ Check that hosts fulfill version requirements. :param service: service label, such as ``Redis`` :param versions: mapping of host to ``Version`` :param required: lowest supported ``Version``. If any host does not fulfill this requirement, an ``InvalidConfiguration`` exception is raised. :param recommended: recommended version. If any host does not fulfill this requirement, a ``PendingDeprecationWarning`` is raised. """ # x = (host, version) must_upgrade = dict([x for x in versions.items() if required > x[1]]) if must_upgrade: raise InvalidConfiguration( make_upgrade_message(service, "must", required, must_upgrade)) if recommended: # x = (host, version) should_upgrade = dict( [x for x in versions.items() if recommended > x[1]]) if should_upgrade: warnings.warn( make_upgrade_message(service, "should", recommended, should_upgrade), PendingDeprecationWarning, )
def get_cluster_from_options(setting, options, cluster_manager=clusters): cluster_option_name = 'cluster' default_cluster_name = 'default' cluster_constructor_option_names = frozenset(('hosts',)) options = options.copy() cluster_options = {key: options.pop(key) for key in set(options.keys()).intersection(cluster_constructor_option_names)} if cluster_options: if cluster_option_name in options: raise InvalidConfiguration( 'Cannot provide both named cluster ({!r}) and cluster configuration ({}) options.'.format( cluster_option_name, ', '.join(map(repr, cluster_constructor_option_names)), ) ) else: warnings.warn( DeprecatedSettingWarning( '{} parameter of {}'.format( ', '.join(map(repr, cluster_constructor_option_names)), setting, ), '{}["{}"]'.format( setting, cluster_option_name, ), removed_in_version='8.5', ), stacklevel=2 ) cluster = rb.Cluster(pool_cls=_shared_pool, **cluster_options) else: cluster = cluster_manager.get(options.pop(cluster_option_name, default_cluster_name)) return cluster, options
def validate(self) -> None: if self._counter_bucket_size <= 0: raise InvalidConfiguration( "counter bucket size must be at least 1") if self._duration_bucket_size <= 0: raise InvalidConfiguration( "duration bucket size must be at least 1") if self._counter_time_window < 0: raise InvalidConfiguration( "counter time window must be nonnegative") if self._duration_time_window < 0: raise InvalidConfiguration( "duration time window must be nonnegative")
def validate(self) -> None: if not 0 < self._counter_bucket_size <= 60: raise InvalidConfiguration( "counter bucket size must be 1-60 seconds") if not 0 < self._duration_bucket_size <= 60: raise InvalidConfiguration( "duration bucket size must be 1-60 seconds") if self._counter_time_window < 60: raise InvalidConfiguration( "counter time window must be at least a minute") if self._duration_time_window < 60: raise InvalidConfiguration( "duration time window must be at least a minute")
def get_cluster_from_options(setting, options, cluster_manager=clusters): cluster_option_name = "cluster" default_cluster_name = "default" cluster_constructor_option_names = frozenset(("hosts",)) options = options.copy() cluster_options = { key: options.pop(key) for key in set(options.keys()).intersection(cluster_constructor_option_names) } if cluster_options: if cluster_option_name in options: raise InvalidConfiguration( "Cannot provide both named cluster ({!r}) and cluster configuration ({}) options.".format( cluster_option_name, ", ".join(map(repr, cluster_constructor_option_names)) ) ) else: warnings.warn( DeprecatedSettingWarning( "{} parameter of {}".format( ", ".join(map(repr, cluster_constructor_option_names)), setting ), f'{setting}["{cluster_option_name}"]', removed_in_version="8.5", ), stacklevel=2, ) cluster = rb.Cluster(pool_cls=_shared_pool, **cluster_options) else: cluster = cluster_manager.get(options.pop(cluster_option_name, default_cluster_name)) return cluster, options
def check_cluster_versions(cluster, required, recommended=Version((3, 0, 4)), label=None): try: with cluster.all() as client: results = client.info() except Exception as e: # Any connection issues should be caught here. raise InvalidConfiguration(unicode(e)) versions = {} for id, info in results.value.items(): host = cluster.hosts[id] # NOTE: This assumes there is no routing magic going on here, and # all requests to this host are being served by the same database. key = '{host}:{port}'.format(host=host.host, port=host.port) versions[key] = Version(map(int, info['redis_version'].split('.', 3))) check_versions( 'Redis' if label is None else 'Redis (%s)' % (label, ), versions, required, recommended, )
def validate(self): try: if self.is_redis_cluster: self.cluster.ping() else: with self.cluster.all() as client: client.ping() except Exception as e: raise InvalidConfiguration(six.text_type(e))
def validate_dynamic_cluster(is_redis_cluster, cluster): try: if is_redis_cluster: cluster.ping() else: with cluster.all() as client: client.ping() except Exception as e: raise InvalidConfiguration(str(e))
def check_cluster_versions(cluster, required, recommended=None, label=None): try: with cluster.all() as client: results = client.info() except Exception as e: # Any connection issues should be caught here. raise InvalidConfiguration(str(e)) versions = {} for id, info in results.value.items(): host = cluster.hosts[id] # NOTE: This assumes there is no routing magic going on here, and # all requests to this host are being served by the same database. key = f"{host.host}:{host.port}" versions[key] = Version(map(int, info["redis_version"].split(".", 3))) check_versions("Redis" if label is None else f"Redis ({label})", versions, required, recommended)
def validate(self): logger.info('Validating Redis version...') try: with self.cluster.all() as client: results = client.info() except Exception as e: # Any connection issues should be caught here. raise InvalidConfiguration(unicode(e)) versions = {} for id, info in results.value.items(): host = self.cluster.hosts[id] # NOTE: This assumes there is no routing magic going on here, and # all requests to this host are being served by the same database. key = '{host}:{port}'.format(host=host.host, port=host.port) versions[key] = Version( map(int, info['redis_version'].split('.', 3))) check_versions('Redis (TSDB)', versions, Version((2, 8, 9)), Version((3, 0, 4)))
def get_cluster_from_options(backend, options, cluster_manager=clusters): cluster_option_name = 'cluster' default_cluster_name = 'default' cluster_constructor_option_names = frozenset(('hosts', )) options = options.copy() cluster_options = { key: options.pop(key) for key in set(options.keys()).intersection( cluster_constructor_option_names) } if cluster_options: if cluster_option_name in options: raise InvalidConfiguration( 'Cannot provide both named cluster ({!r}) and cluster configuration ({}) options.' .format( cluster_option_name, ', '.join(map(repr, cluster_constructor_option_names)), )) else: warnings.warn( 'Providing Redis cluster configuration options ({}) to {!r} is ' 'deprecated, please update your configuration to use named Redis ' 'clusters ({!r}).'.format( ', '.join(map(repr, cluster_constructor_option_names)), backend, cluster_option_name, ), DeprecationWarning, stacklevel=2) cluster = rb.Cluster(pool_cls=_shared_pool, **cluster_options) else: cluster = cluster_manager.get( options.pop(cluster_option_name, default_cluster_name)) return cluster, options
def validate(self): try: self.conn.ping() except Exception as e: raise InvalidConfiguration(unicode(e))
def validate(self) -> None: if self._counter_bucket_size <= 0: raise InvalidConfiguration("counter bucket size must be at least 1") if self._histogram_bucket_size <= 0: raise InvalidConfiguration("histogram bucket size must be at least 1")
def validate(self): try: with self.cluster.all() as client: client.ping() except Exception as e: raise InvalidConfiguration(unicode(e))
def validate(self) -> None: try: self.client.ping() except Exception as e: raise InvalidConfiguration(str(e))