Rename validate_certs and only_safe_calls

There are other more common names in use in the outer layers.

Author: mdellweg

CHANGES/pulp-glue/+verify_ssh_dry_run.removal

@@ -0,0 +1 @@
+Rename the `PulpContext` `api_kwargs` parameters `validate_certs` to `verify_ssl` and `safe_calls_only` to `dry_run`.

pulp-glue/pulp_glue/common/authentication.py

@@ -16,12 +16,12 @@ def __init__(
         client_secret: str,
         token_url: str,
         scopes: t.Optional[t.List[str]] = None,
-        verify: t.Optional[t.Union[str, bool]] = None,
+        verify_ssl: t.Optional[t.Union[str, bool]] = None,
     ):
         self._token_server_auth = requests.auth.HTTPBasicAuth(client_id, client_secret)
         self._token_url = token_url
         self._scopes = scopes
-        self._verify = verify
+        self._verify_ssl = verify_ssl
 
         self._access_token: t.Optional[str] = None
         self._expire_at: t.Optional[datetime] = None
@@ -87,7 +87,7 @@ def _retrieve_token(self) -> None:
             self._token_url,
             data=data,
             auth=self._token_server_auth,
-            verify=self._verify,
+            verify=self._verify_ssl,
         )
 
         response.raise_for_status()

pulp-glue/pulp_glue/common/context.py

@@ -216,8 +216,8 @@ class PulpContext:
         domain: Name of the domain to interact with.
         fake_mode: In fake mode, no modifying calls will be performed.
             Where possible, instead of failing, the requested result will be faked.
-            This implies `safe_calls_only=True` on the `api_kwargs`.
-        verify: A boolean or a path to the CA bundle.
+            This implies `dry_run=True` on the `api_kwargs`.
+        verify_ssl: A boolean or a path to the CA bundle.
     """
 
     def echo(self, message: str, nl: bool = True, err: bool = False) -> None:
@@ -246,18 +246,21 @@ def __init__(
         timeout: t.Union[int, datetime.timedelta] = 300,
         domain: str = "default",
         fake_mode: bool = False,
-        verify: t.Optional[t.Union[bool, str]] = None,
+        verify_ssl: t.Optional[t.Union[bool, str]] = None,
+        verify: t.Optional[t.Union[bool, str]] = None,  # Deprecated
     ) -> None:
         self._api: t.Optional[OpenAPI] = None
         self._api_root: str = api_root
         self._api_kwargs = api_kwargs
-        self.verify = verify
-        if self.verify is None:
+        self.verify_ssl = verify_ssl
+        if self.verify_ssl is None:
             # Regrets, regrets...
-            self.verify = self._api_kwargs.pop("validate_certs", True)
-        if self.verify is True:
+            self.verify_ssl = (
+                verify if verify is not None else self._api_kwargs.pop("validate_certs", True)
+            )
+        if self.verify_ssl is True:
             # If this is "only" true and we have the PULP_CA_BUNDLE variable set, use it.
-            self.verify = os.environ.get("PULP_CA_BUNDLE", True)
+            self.verify_ssl = os.environ.get("PULP_CA_BUNDLE", True)
         self._needed_plugins: t.List[PluginRequirement] = [
             PluginRequirement("core", specifier=">=3.11.0")
         ]
@@ -269,7 +272,7 @@ def __init__(
         self.timeout: datetime.timedelta = timeout
         self.fake_mode: bool = fake_mode
         if self.fake_mode:
-            self._api_kwargs["safe_calls_only"] = True
+            self._api_kwargs["dry_run"] = True
 
     @classmethod
     def from_config_files(
@@ -338,19 +341,14 @@ def from_config(cls, config: t.Dict[str, t.Any]) -> "t.Self":
             api_kwargs["headers"] = dict(
                 (header.split(":", maxsplit=1) for header in config["headers"])
             )
-        for key in ["cert", "key", "user_agent", "cid"]:
+        for key in ["cert", "key", "user_agent", "cid", "dry_run"]:
             if key in config:
                 api_kwargs[key] = config[key]
-        for key0, key1 in [
-            ["verify_ssl", "validate_certs"],
-            ["dry_run", "safe_calls_only"],
-        ]:
-            if key0 in config:
-                api_kwargs[key1] = config[key0]
 
         return cls(
             api_root=config.get("api_root", "/pulp/"),
             domain=config.get("domain", "default"),
+            verify_ssl=config.get("verify_ssl", True),
             api_kwargs=api_kwargs,
         )
 
@@ -396,7 +394,7 @@ def api(self) -> OpenAPI:
             try:
                 self._api = OpenAPI(
                     doc_path=f"{self._api_root}api/v3/docs/api.json",
-                    verify=self.verify,
+                    verify_ssl=self.verify_ssl,
                     **self._api_kwargs,
                 )
             except OpenAPIError as e:

pulp-glue/pulp_glue/common/openapi.py

@@ -4,6 +4,7 @@
 import json
 import os
 import typing as t
+import warnings
 from collections import defaultdict
 from dataclasses import dataclass
 from io import BufferedReader
@@ -147,12 +148,14 @@ class OpenAPI:
         auth_provider: Object that returns requests auth objects according to the api spec.
         cert: Client certificate used for auth.
         key: Matching key for `cert` if not already included.
-        verify: Whether to check server TLS certificates agains a CA (requests semantic).
+        verify_ssl: Whether to check server TLS certificates agains a CA (requests semantic).
         refresh_cache: Whether to fetch the api doc regardless.
-        safe_calls_only: Flag to disallow issuing POST, PUT, PATCH or DELETE calls.
+        dry_run: Flag to disallow issuing POST, PUT, PATCH or DELETE calls.
         debug_callback: Callback that will be called with strings useful for logging or debugging.
         user_agent: String to use in the User-Agent header.
         cid: Correlation ID to send with all requests.
+        validate_certs: DEPRECATED use verify_ssl instead.
+        safe_calls_only: DEPRECATED use dry_run instead.
     """
 
     def __init__(
@@ -163,19 +166,28 @@ def __init__(
         auth_provider: t.Optional[AuthProviderBase] = None,
         cert: t.Optional[str] = None,
         key: t.Optional[str] = None,
-        verify: t.Optional[t.Union[bool, str]] = True,
+        verify_ssl: t.Optional[t.Union[bool, str]] = True,
         refresh_cache: bool = False,
-        safe_calls_only: bool = False,
+        dry_run: bool = False,
         debug_callback: t.Optional[t.Callable[[int, str], t.Any]] = None,
         user_agent: t.Optional[str] = None,
         cid: t.Optional[str] = None,
+        validate_certs: t.Optional[bool] = None,
+        safe_calls_only: t.Optional[bool] = None,
     ):
+        if validate_certs is not None:
+            warnings.warn("validate_certs is deprecated; use verify_ssl instead.")
+            verify_ssl = validate_certs
+        if safe_calls_only is not None:
+            warnings.warn("safe_calls_only is deprecated; use dry_run instead.")
+            dry_run = safe_calls_only
+
         self._debug_callback: t.Callable[[int, str], t.Any] = debug_callback or (lambda i, x: None)
         self._base_url: str = base_url
         self._doc_path: str = doc_path
-        self._safe_calls_only: bool = safe_calls_only
+        self._dry_run: bool = dry_run
         self._headers = CIMultiDict(headers or {})
-        self._verify = verify
+        self._verify_ssl = verify_ssl
         self._auth_provider = auth_provider
         self._cert = cert
         self._key = key
@@ -196,7 +208,7 @@ def __init__(
     def _setup_session(self) -> None:
         # This is specific requests library.
 
-        if self._verify is False:
+        if self._verify_ssl is False:
             urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
 
         self._session: requests.Session = requests.session()
@@ -214,7 +226,7 @@ def _setup_session(self) -> None:
             elif self._key:
                 raise OpenAPIError(_("Cert is required if key is set."))
         session_settings = self._session.merge_environment_settings(
-            self._base_url, {}, None, self._verify, None
+            self._base_url, {}, None, self._verify_ssl, None
         )
         self._session.verify = session_settings["verify"]
         self._session.proxies = session_settings["proxies"]
@@ -511,7 +523,7 @@ def _send_request(
             self._debug_callback(2, f"  {key}: {value}")
         if request.body is not None:
             self._debug_callback(3, f"{request.body!r}")
-        if self._safe_calls_only and method.upper() not in SAFE_METHODS:
+        if self._dry_run and method.upper() not in SAFE_METHODS:
             raise UnsafeCallError(_("Call aborted due to safe mode"))
         try:
             response = self._session.send(request)

pulp_cli/__init__.py

@@ -217,9 +217,9 @@ def _debug_callback(level: int, x: str) -> None:
         headers=dict((header.split(":", maxsplit=1) for header in headers)),
         cert=cert,
         key=key,
-        validate_certs=verify_ssl,
+        verify_ssl=verify_ssl,
         refresh_cache=refresh_api,
-        safe_calls_only=dry_run,
+        dry_run=dry_run,
         debug_callback=_debug_callback,
         user_agent=f"Pulp-CLI/{__version__}",
         cid=cid,

pulp_cli/config.py

@@ -155,6 +155,8 @@ def validate_config(config: t.Dict[str, t.Any], strict: bool = False) -> None:
         errors.append(_("'api_root' must begin and end with '/'"))
     if "format" in config and config["format"].lower() not in FORMAT_CHOICES:
         errors.append(_("'format' is not one of {choices}").format(choices=FORMAT_CHOICES))
+    if "verify_ssl" in config and not isinstance(config["verify_ssl"], bool):
+        errors.append(_("'verify_ssl' is not a bool"))
     if "dry_run" in config and not isinstance(config["dry_run"], bool):
         errors.append(_("'dry_run' is not a bool"))
     if "timeout" in config and not isinstance(config["timeout"], int):

pulp_cli/generic.py

@@ -144,9 +144,12 @@ def __init__(
         self.oauth2_client_secret = oauth2_client_secret
         if not api_kwargs.get("cert"):
             api_kwargs["auth_provider"] = PulpCLIAuthProvider(pulp_ctx=self)
+
+        verify_ssl: t.Optional[bool] = api_kwargs.pop("verify_ssl", None)
         super().__init__(
             api_root=api_root,
             api_kwargs=api_kwargs,
+            verify_ssl=verify_ssl,
             background_tasks=background_tasks,
             timeout=timeout,
             domain=domain,
@@ -269,7 +272,7 @@ def oauth2_client_credentials_auth(
                     token_url=flow["tokenUrl"],
                     # Try to request all possible scopes.
                     scopes=flow["scopes"],
-                    verify=self.pulp_ctx.verify,
+                    verify_ssl=self.pulp_ctx.verify_ssl,
                 )
             else:
                 self._memoized[key] = OAuth2ClientCredentialsAuth(
@@ -278,7 +281,7 @@ def oauth2_client_credentials_auth(
                     token_url=flow["tokenUrl"],
                     # Try to request all possible scopes.
                     scopes=flow["scopes"],
-                    verify=self.pulp_ctx.verify,
+                    verify_ssl=self.pulp_ctx.verify_ssl,
                 )
         return self._memoized[key]