def ssl_wrap_socket_with_ocsp(*args, **kwargs): # Extract host_name hostname_index = get_args( ssl_.ssl_wrap_socket).args.index("server_hostname") server_hostname = (args[hostname_index] if len(args) > hostname_index else kwargs.get("server_hostname", None)) # Remove context if present ssl_context_index = get_args( ssl_.ssl_wrap_socket).args.index("ssl_context") context_in_args = len(args) > ssl_context_index ssl_context = (args[hostname_index] if context_in_args else kwargs.get( "ssl_context", None)) if not isinstance(ssl_context, PyOpenSSLContext): # Create new default context if context_in_args: new_args = list(args) new_args[ssl_context_index] = None args = tuple(new_args) else: del kwargs["ssl_context"] # Fix ca certs location ca_certs_index = get_args(ssl_.ssl_wrap_socket).args.index("ca_certs") ca_certs_in_args = len(args) > ca_certs_index if not ca_certs_in_args and not kwargs.get("ca_certs"): kwargs["ca_certs"] = certifi.where() ret = ssl_.ssl_wrap_socket(*args, **kwargs) global FEATURE_OCSP_MODE global FEATURE_OCSP_RESPONSE_CACHE_FILE_NAME from .ocsp_asn1crypto import SnowflakeOCSPAsn1Crypto as SFOCSP log.debug( "OCSP Mode: %s, " "OCSP response cache file name: %s", FEATURE_OCSP_MODE.name, FEATURE_OCSP_RESPONSE_CACHE_FILE_NAME, ) if FEATURE_OCSP_MODE != OCSPMode.INSECURE: v = SFOCSP( ocsp_response_cache_uri=FEATURE_OCSP_RESPONSE_CACHE_FILE_NAME, use_fail_open=FEATURE_OCSP_MODE == OCSPMode.FAIL_OPEN, ).validate(server_hostname, ret.connection) if not v: raise OperationalError( msg=("The certificate is revoked or " "could not be validated: hostname={}".format( server_hostname)), errno=ER_OCSP_RESPONSE_CERT_STATUS_REVOKED, ) else: log.info("THIS CONNECTION IS IN INSECURE " "MODE. IT MEANS THE CERTIFICATE WILL BE " "VALIDATED BUT THE CERTIFICATE REVOCATION " "STATUS WILL NOT BE CHECKED.") return ret
def add(self, hook_type, name=None, func=None): """ add the handler function to spectific event. Args: hook_type (str): the spectific event name name (str): the handler function name, default None func (func): the handler function, default None """ if not func or not callable(func): raise TypeError( "The hook function is empty or it is not a function") if name == None: name = "hook_%s" % id(func) # check validity if not isinstance(name, str) or name.strip() == "": raise TypeError("The hook name must be a non-empty string") if hook_type not in self._registered_hooks: raise ValueError("hook_type: %s does not exist" % (hook_type)) if name in self._registered_hooks[hook_type]: raise ValueError( "name: %s has existed in hook_type:%s, use modify method to modify it" % (name, hook_type)) else: args_num = len(get_args(func).args) if args_num != self._hook_params_num[hook_type]: raise ValueError( "The number of parameters to the hook hook_type:%s should be %i" % (hook_type, self._hook_params_num[hook_type])) self._registered_hooks[hook_type][name] = func
def validate_args(fn, *args, **kwargs): """Check that the supplied args are sufficient for calling a function. >>> validate_args(lambda a: None) Traceback (most recent call last): ... MissingArgs: Missing argument(s): a >>> validate_args(lambda a, b, c, d: None, 0, c=1) Traceback (most recent call last): ... MissingArgs: Missing argument(s): b, d :param fn: the function to check :param arg: the positional arguments supplied :param kwargs: the keyword arguments supplied """ argspec = get_args(fn) num_defaults = len(argspec.defaults or []) required_args = argspec.args[:len(argspec.args) - num_defaults] def isbound(method): return getattr(method, '__self__', None) is not None if isbound(fn): required_args.pop(0) missing = [arg for arg in required_args if arg not in kwargs] missing = missing[len(args):] if missing: raise MissingArgs(missing)
def findall(self, **kwargs): """ Find all items with attributes matching ``**kwargs``. """ found = [] searches = kwargs.items() detailed = True list_kwargs = {} list_argspec = get_args(self.list) if 'detailed' in list_argspec.args: detailed = ("human_id" not in kwargs and "name" not in kwargs and "display_name" not in kwargs) list_kwargs['detailed'] = detailed if 'is_public' in list_argspec.args and 'is_public' in kwargs: is_public = kwargs['is_public'] list_kwargs['is_public'] = is_public if is_public is None: tmp_kwargs = kwargs.copy() del tmp_kwargs['is_public'] searches = tmp_kwargs.items() if 'search_opts' in list_argspec.args: # pass search_opts in to do server side based filtering. # TODO(jogo) not all search_opts support regex, find way to # identify when to use regex and when to use string matching. # volumes does not support regex while servers does. So when # doing findall on servers some client side filtering is still # needed. if "human_id" in kwargs: list_kwargs['search_opts'] = {"name": kwargs["human_id"]} elif "name" in kwargs: list_kwargs['search_opts'] = {"name": kwargs["name"]} elif "display_name" in kwargs: list_kwargs['search_opts'] = {"name": kwargs["display_name"]} if "all_tenants" in kwargs: all_tenants = kwargs['all_tenants'] list_kwargs['search_opts']['all_tenants'] = all_tenants searches = [(k, v) for k, v in searches if k != 'all_tenants'] listing = self.list(**list_kwargs) for obj in listing: try: if all( getattr(obj, attr) == value for (attr, value) in searches): if detailed: found.append(obj) else: found.append(self.get(obj.id)) except AttributeError: continue return found
def dict_to_protobuf(protobuf_class, js_dict, ignore_unknown_fields=False): # type: (type(Message), dict, bool) -> Message message = protobuf_class() # Protobuf versions 3.6.* and 3.7.0 require a different number of parameters in the _Parser's # constructor. In the case of 3.6.*, we pass only the argument ignore_unknown_fields, but in # the case of 3.7.0, we pass in one additional None parameter. To be future proof(ish), pass in # None to any subsequent parameter. num_of_args = len(get_args(_Parser.__init__).args) none_args = [None] * (num_of_args - 2) # Subtract 2 for self and ignore_unknown_fields. parser = _CustomParser(ignore_unknown_fields, *none_args) parser.ConvertMessage(js_dict, message) return message
def dict_to_protobuf(protobuf_class, js_dict, ignore_unknown_fields=False): # type: (type(Message), dict, bool) -> Message message = protobuf_class() # Protobuf versions 3.6.* and 3.7.0 require a different number of parameters in the _Parser's # constructor. In the case of 3.6.*, we pass only the argument ignore_unknown_fields, but in # the case of 3.7.0, we pass in one additional None parameter. To be future proof(ish), pass in # None to any subsequent parameter. num_of_args = len(get_args(_Parser.__init__).args) none_args = [None] * (num_of_args - 2 ) # Subtract 2 for self and ignore_unknown_fields. parser = _CustomParser(ignore_unknown_fields, *none_args) parser.ConvertMessage(js_dict, message) return message
def monkeypatch_bar_rate(monkeypatch): # Converting to List instead to unpacking the Tuple # because get_args returns different tuple sizes between py versions. args = list(get_args(ProgressBar.format_meter))[0] rate_arg_idx = args.index('rate') def override_rate(func): @wraps(func) def wrapper(*args, **kwargs): args = list(args) if 'rate' in args: args[rate_arg_idx] = 10 ** 6 elif 'rate' in kwargs: kwargs['rate'] = 10 ** 6 return func(*args, **kwargs) return wrapper monkeypatch.setattr('shub.image.utils.ProgressBar.format_meter', staticmethod(override_rate(ProgressBar.format_meter)))
def _getargnames(self, func): """Return an iterator over all arg names, including nested arg names and varargs. Goes in the order of the functions argspec, with varargs and keyword args last if present.""" args = get_args(func) if fullArg: ( args_names, varargs_names, varkws_names, _, kwonlyargs_names, _, _, ) = args else: (args_names, varargs_names, varkws_names, _) = args if not self.print_self: args_names.remove("self") return chain( flatten(args_names), filter(None, [varargs_names, varkws_names]), (flatten(kwonlyargs_names) if fullArg else []), )