cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/core/config/__init__.py

@@ -0,0 +1,125 @@
+# IMPORT ORDER MATTERS!
+
+# constants used by MetaCI
+FAILED_TO_CREATE_SCRATCH_ORG = "Failed to create scratch org"
+
+from cumulusci.core.config.base_config import BaseConfig
+from cumulusci.core.exceptions import TaskImportError
+from cumulusci.core.utils import import_global
+
+
+class ConnectedAppOAuthConfig(BaseConfig):
+    """Salesforce Connected App OAuth configuration"""
+
+    client_id: str
+    client_secret: str
+    login_url: str
+    callback_url: str
+
+
+class FlowConfig(BaseConfig):
+    """A flow with its configuration merged"""
+
+    description: str
+    steps: dict
+    group: str
+    checks: list
+    project_config: "BaseProjectConfig"
+    title: str
+    slug: str
+    tier: str
+    preflight_message: str
+    error_message: str
+    tasks: dict  # deprecated
+
+
+from cumulusci.core.config.org_config import OrgConfig
+
+
+class ServiceConfig(BaseConfig):
+    url: str
+    username: str
+    password: str
+    token: str
+    email: str
+    client_id: str
+    client_secret: str
+    token_uri: str
+    callback_url: str
+    login_url: str
+    service_name: str
+    name: str
+    server_domain: str
+
+    def __init__(self, config, name=None, keychain=None):
+        """Services may need access to a keychain and the alias of their service."""
+        super().__init__(config, keychain)
+        self.name = name if name else ""
+
+
+class TaskConfig(BaseConfig):
+    """A task with its configuration merged"""
+
+    options: dict
+    class_path: str
+    description: str
+    group: str
+    ui_options: dict
+    name: str
+    checks: list
+    project_config: "BaseProjectConfig"
+
+    # TODO: What if an intermediate repo "allows" a downstream repo?
+    #       Only the top repo should be allowed to do so.
+
+    def get_class(self):
+        try:
+            return import_global(self.class_path)
+        except ModuleNotFoundError as e:
+            message = "Cannot load Python class for task:\n" + str(e)
+            if not self.source.allow_remote_code:
+                message += "\n".join(
+                    (
+                        "",
+                        str(self.source),
+                        "is not an approved source for running third party Python code.",
+                        "If this task is custom Python, that would explain the problem.",
+                        "Otherwise, it might just be a mistyped `class_name`.",
+                        "More info: https://cumulusci.readthedocs.io/en/stable/config.html?highlight=sources#tasks-and-flows-from-a-different-project",
+                    )
+                )
+            raise TaskImportError(message) from e
+
+    @property
+    def source(self):
+        return self.project_config.source
+
+
+from cumulusci.core.config.base_task_flow_config import BaseTaskFlowConfig
+
+# inherit from BaseTaskFlowConfig
+from cumulusci.core.config.project_config import BaseProjectConfig
+
+# inherit from SfdxOrgConfig
+from cumulusci.core.config.scratch_org_config import ScratchOrgConfig
+
+# inherit from OrgConfig
+from cumulusci.core.config.sfdx_org_config import SfdxOrgConfig
+
+# inherit from BaseProjectConfig
+from cumulusci.core.config.universal_config import UniversalConfig
+
+__all__ = (
+    "FAILED_TO_CREATE_SCRATCH_ORG",
+    "BaseConfig",
+    "ConnectedAppOAuthConfig",
+    "FlowConfig",
+    "OrgConfig",
+    "ServiceConfig",
+    "TaskConfig",
+    "BaseTaskFlowConfig",
+    "BaseProjectConfig",
+    "SfdxOrgConfig",
+    "ScratchOrgConfig",
+    "UniversalConfig",
+)

cumulusci/core/config/base_config.py

@@ -0,0 +1,111 @@
+import logging
+import os
+import warnings
+from functools import lru_cache
+from typing import Any, Dict, Optional
+
+# turn on strictness.
+# delete this when strictness is mandatory
+STRICT_GETATTR = os.environ.get("STRICT_GETATTR")
+CHECK_CONFIG_TYPES = os.environ.get("CHECK_CONFIG_TYPES")
+
+
+class BaseConfig(object):
+    """BaseConfig provides a common interface for nested access for all Config objects in CCI."""
+
+    defaults = {}
+    config: dict
+    logger: logging.Logger
+
+    def __init__(self, config: Optional[dict] = None, keychain=None):
+        if config is None:
+            self.config = {}
+        else:
+            types = self._all_allowed_names()
+            if CHECK_CONFIG_TYPES:
+                for k, v in config.items():
+                    type_for_value = types.get(k)
+                    if not type_for_value:
+                        warnings.warn(f"{k}: {v} not declared for {type(self)}")
+                    if (v is not None) and (type_for_value is not None):
+                        assert isinstance(
+                            v, type_for_value
+                        ), f"{k}: {v} should be of type {type_for_value}, not {type(v)} for {type(self)}"
+            self.config = config.copy()
+
+        self._init_logger()
+        self._load_config()
+
+    def _init_logger(self):
+        """Initializes self.logger"""
+        self.logger = logging.getLogger(__name__)
+
+    def _load_config(self):
+        """Subclasses may override this method to initialize :py:attr:`~config`"""
+        pass
+
+    @classmethod
+    def _allowed_names(cls) -> Dict[str, type]:
+        return getattr(cls, "__annotations__", {})
+
+    # long term plan is to get rid of this
+    def __getattr__(self, name: str) -> Any:
+        """Look up a property in a sub-dictionary
+
+        Property names should be declared in each Config class with type annotations.
+        """
+        if not name.startswith("_"):
+            first_part = name.split("__")[0]
+            if first_part not in self._all_allowed_names():
+                message = (
+                    f"Property `{first_part}` is unknown on class `{self.__class__.__name__}`. "
+                    + "Either declare it in the type declaration or use lookup() to look it up dynamically"
+                )
+                warnings.warn(
+                    message,
+                    DeprecationWarning,
+                )
+
+                assert not STRICT_GETATTR, message
+        return self.lookup(name, already_called_getattr=True)
+
+    @classmethod
+    @lru_cache
+    def _all_allowed_names(cls) -> Dict[str, type]:
+        "Allowed names from this class and its base classes"
+        allowed_names_from_all_base_classes = (
+            baseclass._allowed_names()  # type: ignore
+            for baseclass in cls.__mro__
+            if hasattr(baseclass, "_allowed_names")
+        )
+        ret = {}
+        for d in allowed_names_from_all_base_classes:
+            ret.update(d)
+        return ret
+
+    def lookup(
+        self, name: str, default: Any = None, already_called_getattr: bool = False
+    ) -> Any:
+        tree = name.split("__")
+        if name.startswith("_"):
+            raise AttributeError(f"Attribute {name} not found")
+        value: Any = None
+        value_found = False
+        config = self.config
+        if len(tree) > 1:
+            # Walk through the config dictionary using __ as a delimiter
+            for key in tree[:-1]:
+                config = config.get(key)
+                if config is None:
+                    break
+        if config and tree[-1] in config:
+            value = config[tree[-1]]
+            value_found = True
+
+        if value_found:
+            return value
+        else:
+            if not already_called_getattr and hasattr(self, name):
+                return getattr(self, name)
+            else:
+                return self.defaults.get(name, default)

cumulusci/core/config/base_task_flow_config.py

@@ -0,0 +1,82 @@
+from difflib import get_close_matches
+from typing import Any, Dict, List
+
+from cumulusci.core.config import BaseConfig, FlowConfig, TaskConfig
+from cumulusci.core.exceptions import (
+    CumulusCIException,
+    FlowNotFoundError,
+    TaskNotFoundError,
+)
+
+
+def list_infos(infos: dict) -> List[Dict[str, str]]:
+    rv = []
+    for info_name, info in infos.items():
+        if not info:
+            info = {}
+        rv.append(
+            {
+                "name": info_name,
+                "description": info.get("description", ""),
+                "group": info.get("group"),
+            }
+        )
+
+    return rv
+
+
+class BaseTaskFlowConfig(BaseConfig):
+    """Base class for all configs that contain tasks and flows"""
+
+    tasks: dict
+    flows: dict
+
+    def list_tasks(self) -> List[Dict[str, str]]:
+        """Returns a list of task info dictionaries with keys 'name' and 'description'"""
+        return list_infos(self.tasks)
+
+    def get_task(self, name: str) -> TaskConfig:
+        """Returns a TaskConfig"""
+        config = self.lookup(f"tasks__{name}")
+        if not config and name not in self.tasks:
+            # task does not exist
+            error_msg = f"Task not found: {name}"
+            suggestion = self.get_suggested_name(name, self.tasks)
+            if self.source and self.source.location:
+                suggestion += "\n"
+                suggestion += "Source of the problem:"
+                suggestion += str(self.source.location)
+            raise TaskNotFoundError(error_msg + suggestion)
+        elif not config:
+            # task exists but there is no config at all
+            error_msg = f"No configuration found for task: {name}"
+            raise CumulusCIException(error_msg)
+        elif "class_path" not in config:
+            # task exists and there is a config but it has no class_path defined and it is not a base task override
+            error_msg = f"Task has no class_path defined: {name}"
+            raise CumulusCIException(error_msg)
+
+        return TaskConfig(config)
+
+    def list_flows(self) -> List[Dict[str, str]]:
+        """Returns a list of flow info dictionaries with keys 'name' and 'description'"""
+        return list_infos(self.flows)
+
+    def get_flow(self, name: str) -> FlowConfig:
+        """Returns a FlowConfig"""
+        config = self.lookup(f"flows__{name}")
+        if not config:
+            error_msg = f"Flow not found: {name}"
+            suggestion = self.get_suggested_name(name, self.flows)
+            raise FlowNotFoundError(error_msg + suggestion)
+        return FlowConfig(config)
+
+    def get_suggested_name(self, name: str, steps: Dict[str, Any]) -> str:
+        """
+        Given a name that cannot be resolved and a list of tasks/flow dicts, returns the nearest match.
+        """
+        match_list = get_close_matches(name, steps.keys(), n=1)
+        if match_list:
+            return f'. Did you mean "{match_list[0]}"?'
+        else:
+            return ""

cumulusci/core/config/marketing_cloud_service_config.py

@@ -0,0 +1,83 @@
+from typing import Dict
+from urllib.parse import urlparse
+
+import requests
+
+from cumulusci.core.config.oauth2_service_config import OAuth2ServiceConfig
+from cumulusci.core.keychain import BaseProjectKeychain
+from cumulusci.oauth.client import OAuth2Client
+from cumulusci.utils.http.requests_utils import safe_json_from_response
+
+
+class MarketingCloudServiceConfig(OAuth2ServiceConfig):
+
+    refresh_token: str
+    oauth2_client: str
+    soap_instance_url: str
+    rest_instance_url: str
+    redirect_uri: str
+    access_token: str
+
+    def __init__(self, config, name, keychain):
+        super().__init__(config, name, keychain)
+        self._name = name
+        self._keychain = keychain
+
+    @classmethod
+    def connect(cls, keychain: BaseProjectKeychain, kwargs: Dict):
+        """This is called when a service is connected via `cci service connect`
+
+        @param keychain - A keychain for accessing services
+        @param kwargs - Any keyword arguments passed to `cci service connect`
+        """
+        client_config = keychain.get_service("oauth2_client", kwargs["oauth2_client"])
+        config = client_config.config.copy()
+        config["redirect_uri"] = config["callback_url"]
+        oauth2_client = OAuth2Client(config)
+        return oauth2_client.auth_code_flow()
+
+    @property
+    def tssd(self):
+        """A dynamic value that represents the end user's subdomain.
+        We can derive this value from either soap_instance_url or rest_instance_url
+        which are present upon successful completion of an OAuth2 flow."""
+        result = urlparse(self.config["rest_instance_url"])
+        return result.netloc.split(".")[0]
+
+    @property
+    def access_token(self):
+        return self._refresh_token()
+
+    def _refresh_token(self):
+        """Gets a fresh access token for the user.
+
+        The info dict passed back from the OAuth flow includes:
+        * access_token
+        * refresh_token
+        """
+        oauth2_client_config = self._keychain.get_service(
+            "oauth2_client", self.oauth2_client
+        )
+        oauth2_client = OAuth2Client(oauth2_client_config)
+        info = oauth2_client.refresh_token(self.refresh_token)
+        self.config.update(info)
+        self.save()
+        return info["access_token"]
+
+    def save(self):
+        assert self._keychain, "Keychain not set on MarketingCloudServiceConfig"
+        self._keychain.set_service("marketing_cloud", self._name, self)
+
+    def get_user_info(self) -> dict:
+        """Make a call to the Marketing Cloud REST API UserInfo endpoint.
+        Raises HTTPError for bad response status, otherwise returns the payload
+        in full."""
+        auth_uri = self.rest_instance_url.replace(".rest", ".auth")
+        headers = {
+            "Authorization": f"Bearer {self.access_token}",
+            "Content-Type": "application/json",
+        }
+        response = requests.get(f"{auth_uri}v2/userinfo", headers=headers)
+        response.raise_for_status()
+
+        return safe_json_from_response(response)

cumulusci/core/config/oauth2_service_config.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractclassmethod
+from typing import Dict
+
+from cumulusci.core.config import ServiceConfig
+
+
+class OAuth2ServiceConfig(ServiceConfig, ABC):
+    """Base class for services that require an OAuth2 Client
+    for establishing a connection."""
+
+    @abstractclassmethod  # type: ignore
+    def connect(cls) -> Dict:  # type: ignore
+        """This method is called when the service is first connected
+        via `cci service connect`. This method should perform the necessary
+        OAuth flow and return a dict of values that the service would like
+        stored in the services `config` dict."""
+        raise NotImplementedError