def validate_config_credentials(self): """Validate configured credentials""" # No credentials dict in the config try: credentials = self.config.credentials except AttributeError: raise MisconfiguredError( f"Missing credentials configuration for provider {self.provider}" ) # Empty credentials dict if not credentials: raise MisconfiguredError( f"Missing credentials for provider {self.provider}" ) # Credentials keys but values are None. missing_credentials = [ cred_name for cred_name, cred_value in credentials.items() if cred_value is None ] if missing_credentials: raise MisconfiguredError( "The following credentials are missing for provider {}: {}".format( self.provider, ", ".join(missing_credentials) ) )
def __init__(self, provider, config): super(OIDCAuthorizationCodeFlowAuth, self).__init__(provider, config) if getattr(self.config, "token_provision", None) not in ("qs", "header"): raise MisconfiguredError( 'Provider config parameter "token_provision" must be one of "qs" or "header"' ) if self.config.token_provision == "qs" and not getattr( self.config, "token_qs_key", ""): raise MisconfiguredError( 'Provider config parameter "token_provision" with value "qs" must have ' '"token_qs_key" config parameter as well') self.session = requests.Session()
def authenticate_user(self, state): """Authenticate user""" params = { "client_id": self.config.client_id, "response_type": self.RESPONSE_TYPE, "scope": self.SCOPE, "state": state, "redirect_uri": self.config.redirect_uri, } authorization_response = self.session.get( self.config.authorization_uri, params=params) login_document = etree.HTML(authorization_response.text) login_form = login_document.xpath(self.config.login_form_xpath)[0] try: # Get the form data to pass to the login form from config or from the login form login_data = { key: self._constant_or_xpath_extracted(value, login_form) for key, value in getattr( self.config, "additional_login_form_data", {}).items() } # Add the credentials login_data.update(self.config.credentials) auth_uri = getattr(self.config, "authentication_uri", None) # Retrieve the authentication_uri from the login form if so configured if self.config.authentication_uri_source == "login-form": # Given that the login_form_xpath resolves to an HTML element, if suffices to add '/@action' to get # the value of its action attribute to this xpath auth_uri = login_form.xpath( self.config.login_form_xpath.rstrip("/") + "/@action")[0] return self.session.post(auth_uri, data=login_data) except AttributeError as err: if "credentials" in err.args: raise MisconfiguredError( "Missing Credentials for provider: %s", self.provider)
def __init__(self, config): super(FilterLatestByName, self).__init__(config) name_pattern = config.pop("name_pattern") if not self.NAME_PATTERN_CONSTRAINT.search(name_pattern): raise MisconfiguredError( "Name pattern should respect the regex: {}".format( self.NAME_PATTERN_CONSTRAINT.pattern)) self.name_pattern = re.compile(name_pattern)
def authenticate(self): """Authenticate""" try: self.access_key = self.config.credentials["aws_access_key_id"] self.secret_key = self.config.credentials["aws_secret_access_key"] return self.access_key, self.secret_key except AttributeError as err: if "credentials" in err: raise MisconfiguredError( "Missing Credentials for provider: %s", self.provider)
def authenticate(self): """Authenticate""" try: headers = { header: value.format(**self.config.credentials) for header, value in self.config.headers.items() } return HeaderAuth(headers) except AttributeError as err: if "credentials" in err: raise MisconfiguredError( "Missing Credentials for provider: %s", self.provider )
def _init_api(self) -> None: """Initialize Sentinelsat API if needed (connection and link).""" if not self.api: try: logger.debug("Initializing Sentinelsat API") self.api = SentinelAPI( self.config.credentials["username"], self.config.credentials["password"], self.config.endpoint, ) except KeyError as ex: raise MisconfiguredError(ex) from ex else: logger.debug("Sentinelsat API already initialized")
def __filter_item_model_properties(self, item_model, product_type): """Filter item model depending on product type metadata and its extensions. Removes not needed parameters, and adds supplementary ones as part of eodag extension. :param item_model: item model from stac_config :type item_model: dict :param product_type: product type :type product_type: str :returns: filtered item model :rtype: dict """ try: product_type_dict = [ pt for pt in self.eodag_api.list_product_types( provider=self.provider) if pt["ID"] == product_type ][0] except IndexError: raise MisconfiguredError( "Product type {} not available for {}".format( product_type, self.provider)) result_item_model = copy.deepcopy(item_model) if product_type_dict["sensorType"] != "RADAR": result_item_model["stac_extensions"].remove("sar") extensions_names = self.get_stac_extensions_dict( result_item_model["stac_extensions"]).keys() for k, v in item_model["properties"].items(): # remove key if extension not in stac_extensions if ":" in k and k.split(":")[0] not in extensions_names: result_item_model["properties"].pop(k, None) # build jsonpath for eodag product properties and adapt path eodag_properties_dict = { k: string_to_jsonpath(k, v.replace("$.", "$.product.")) for k, v in DEFAULT_METADATA_MAPPING.items() if "$.properties." in v } # add missing properties as oseo:missingProperty for k, v in eodag_properties_dict.items(): if (v not in result_item_model["properties"].values() and k not in self.stac_config["metadata_ignore"]): result_item_model["properties"]["oseo:" + k] = string_to_jsonpath(k, v) return result_item_model
def authenticate(self): """Authenticate""" # First get the token try: response = requests.post(self.config.auth_uri, data=self.config.credentials) try: response.raise_for_status() except HTTPError as e: raise e else: if getattr(self.config, "token_type", "text") == "json": token = response.json()[self.config.token_key] else: token = response.text return RequestsTokenAuth(token, "header") except AttributeError as err: if "credentials" in err.args: raise MisconfiguredError( "Missing Credentials for provider: %s", self.provider)
def authenticate(self): """Authenticate""" method = getattr(self.config, "method", None) try: if not method: method = "basic" if method == "basic": return HTTPBasicAuth( self.config.credentials["username"], self.config.credentials["password"], ) if method == "digest": return HTTPDigestAuth( self.config.credentials["username"], self.config.credentials["password"], ) except AttributeError as err: if "credentials" in err.args: raise MisconfiguredError( "Missing Credentials for provider: %s", self.provider )
def __init__(self, provider, config): super(HTTPDownload, self).__init__(provider, config) if not hasattr(self.config, "base_uri"): raise MisconfiguredError( "{} plugin require a base_uri configuration key".format(self.__name__) )