cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/salesforce_api/org_schema_models.py

@@ -0,0 +1,226 @@
+from typing import Mapping, Sequence
+
+import sqlalchemy.types as types
+from sqlalchemy import (
+    Boolean,
+    Column,
+    ForeignKey,
+    Integer,
+    PrimaryKeyConstraint,
+    String,
+    Table,
+)
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+from sqlalchemy.orm.collections import attribute_mapped_collection
+
+Base = declarative_base()
+
+
+class SpecializedType(types.TypeDecorator):
+    """A baseclass for custom datatypes. E.g. sequences and mappings
+
+    Custom types are types that are not directly supported by SQL Alchemy
+    """
+
+    impl = types.PickleType
+
+    def process_bind_param(self, value, dialect):
+        assert isinstance(value, (self.typ, type(None))), (value, self.typ)
+        if not value:
+            return None
+        return self.empty_value.__class__(value)
+
+    def process_result_value(self, value, dialect):
+        if not value:
+            return self.empty_value
+        return value
+
+    def copy(self, **kw):
+        return self.__class__(self.impl.length)
+
+
+class SequenceType(SpecializedType):
+    """Store sequences in an optimized tuple format"""
+
+    typ = Sequence
+    empty_value = ()
+
+
+class MappingType(SpecializedType):
+    """Store mappings in an optimized dict format"""
+
+    typ = Mapping
+    empty_value = {}
+
+
+class OrgSchemaModelMixin:
+    def __getitem__(self, attr):
+        try:
+            return getattr(self, attr)
+        except AttributeError:
+            raise KeyError(attr)
+
+    def __repr__(self):
+        fields = self.__dict__.copy()
+        name = fields.pop("name", "<UNNAMED>")
+        fields.pop("_sa_instance_state")
+        return f"<{self.__class__.__name__} {name} {fields}>"
+
+    def __eq__(self, other):
+        "Useful mostly for unit tests"
+        my_state = self.__dict__.copy()
+        my_state.pop("_sa_instance_state")
+        other_state = other.__dict__.copy()
+        other_state.pop("_sa_instance_state", None)
+        return my_state == other_state
+
+
+class SObject(OrgSchemaModelMixin, Base):
+    __tablename__ = "sobjects"
+    name = Column(String, primary_key=True, sqlite_on_conflict_primary_key="REPLACE")
+    activateable = Column(Boolean)
+    childRelationships = Column(SequenceType)
+    compactLayoutable = Column(Boolean)
+    createable = Column(Boolean)
+    custom = Column(Boolean)
+    customSetting = Column(Boolean)
+    deepCloneable = Column(Boolean)
+    defaultImplementation = Column(String)
+    deletable = Column(Boolean)
+    deprecatedAndHidden = Column(Boolean)
+    extendedBy = Column(String)
+    extendsInterfaces = Column(String)
+    feedEnabled = Column(Boolean)
+    fields = relationship(
+        "Field",
+        collection_class=attribute_mapped_collection("name"),
+        back_populates="parent",
+    )
+    hasSubtypes = Column(Boolean)
+    label = Column(String)
+    labelPlural = Column(String)
+    implementedBy = Column(String)
+    implementsInterfaces = Column(String)
+    isInterface = Column(Boolean)
+    isSubtype = Column(Boolean)
+    keyPrefix = Column(String)
+    layoutable = Column(Boolean)
+    listviewable = Column(String)
+    lookupLayoutable = Column(String)
+    mergeable = Column(Boolean)
+    mruEnabled = Column(Boolean)
+    namedLayoutInfos = Column(SequenceType)
+    networkScopeFieldName = Column(String)
+    queryable = Column(Boolean)
+    recordTypeInfos = Column(SequenceType)
+    replicateable = Column(Boolean)
+    retrieveable = Column(Boolean)
+    searchLayoutable = Column(Boolean)
+    searchable = Column(Boolean)
+    sobjectDescribeOption = Column(String)
+    triggerable = Column(Boolean)
+    undeletable = Column(Boolean)
+    updateable = Column(Boolean)
+    urls = Column(MappingType)
+    supportedScopes = Column(SequenceType)
+    actionOverrides = Column(SequenceType)
+    count = Column(Integer)
+    last_modified_date = Column(String)
+
+    @property
+    def extractable(self):
+        return self.createable and self.queryable and self.retrieveable
+
+
+field_references = Table(
+    "references",
+    Base.metadata,
+    Column("field_name", Integer, ForeignKey("fields.name")),
+    Column("object_name", Integer, ForeignKey("sobjects.name")),
+)
+
+
+class Field(OrgSchemaModelMixin, Base):
+    __tablename__ = "fields"
+    __table_args__ = (
+        PrimaryKeyConstraint(
+            "sobject", "name", name="foo", sqlite_on_conflict="REPLACE"
+        ),
+    )
+
+    sobject = Column(String, ForeignKey("sobjects.name"), nullable=False)
+    parent = relationship("SObject", back_populates="fields")
+    name = Column(String, nullable=False)
+    aggregatable = Column(Boolean)
+    aiPredictionField = Column(Boolean)
+    autoNumber = Column(Boolean)
+    byteLength = Column(Integer)
+    calculated = Column(Boolean)
+    calculatedFormula = Column(String)
+    cascadeDelete = Column(Boolean)
+    caseSensitive = Column(Boolean)
+    compoundFieldName = Column(String)
+    controllerName = Column(String)
+    createable = Column(Boolean)
+    custom = Column(Boolean)
+    defaultValue = Column(String)
+    defaultValueFormula = Column(String)
+    defaultedOnCreate = Column(Boolean)
+    dependentPicklist = Column(Boolean)
+    deprecatedAndHidden = Column(Boolean)
+    digits = Column(Integer)
+    displayLocationInDecimal = Column(Boolean)
+    encrypted = Column(Boolean)
+    externalId = Column(Boolean)
+    extraTypeInfo = Column(types.PickleType)
+    filterable = Column(Boolean)
+    filteredLookupInfo = Column(types.PickleType)
+    formulaTreatNullNumberAsZero = Column(Boolean)
+    groupable = Column(Boolean)
+    highScaleNumber = Column(Boolean)
+    htmlFormatted = Column(Boolean)
+    idLookup = Column(Boolean)
+    inlineHelpText = Column(String)
+    label = Column(String)
+    length = Column(Integer)
+    mask = Column(String)
+    maskType = Column(String)
+    name = Column(String)
+    nameField = Column(Boolean)
+    namePointing = Column(Boolean)
+    nillable = Column(Boolean)
+    permissionable = Column(Boolean)
+    polymorphicForeignKey = Column(Boolean)
+    precision = Column(Integer)
+    queryByDistance = Column(Boolean)
+    referenceTargetField = Column(String)
+    referenceTo = Column(types.PickleType)
+    relationshipName = Column(String)
+    relationshipOrder = Column(Integer)
+    restrictedDelete = Column(Boolean)
+    restrictedPicklist = Column(Boolean)
+    scale = Column(Integer)
+    searchPrefilterable = Column(Boolean)
+    soapType = Column(String)
+    sortable = Column(Boolean)
+    type = Column(String)
+    unique = Column(Boolean)
+    updateable = Column(Boolean)
+    writeRequiresMasterRead = Column(Boolean)
+    picklistValues = Column(types.PickleType)
+
+    @property
+    def requiredOnCreate(self):
+        defaulted = (
+            self.defaultValue is not None  # has a real default value
+            or self.nillable  # None is a valid default value
+            or self.defaultedOnCreate  # defaulted some other way
+        )
+        return self.createable and not defaulted
+
+
+class FileMetadata(Base):
+    __tablename__ = "file_metadata"
+    name = Column(String, primary_key=True, sqlite_on_conflict_primary_key="REPLACE")
+    value = Column(String)

cumulusci/salesforce_api/package_install.py

@@ -0,0 +1,265 @@
+import functools
+import logging
+from typing import Optional, cast
+
+from simple_salesforce.api import SFType
+from simple_salesforce.exceptions import SalesforceMalformedRequest
+
+from cumulusci.core.config import OrgConfig
+from cumulusci.core.config.project_config import BaseProjectConfig
+from cumulusci.core.dependencies.utils import TaskContext
+from cumulusci.core.enums import StrEnum
+from cumulusci.core.exceptions import PackageInstallError, TaskOptionsError
+from cumulusci.core.utils import process_bool_arg
+from cumulusci.salesforce_api.exceptions import MetadataApiError
+from cumulusci.salesforce_api.metadata import ApiDeploy
+from cumulusci.salesforce_api.package_zip import InstallPackageZipBuilder
+from cumulusci.salesforce_api.utils import get_simple_salesforce_connection
+from cumulusci.utils.waiting import poll, retry
+from cumulusci.utils.yaml.model_parser import CCIModel
+
+logger = logging.getLogger(__name__)
+
+
+class SecurityType(StrEnum):
+    """Enum used to specify the component permissioning mode for a package install.
+
+    The values specified by the Tooling API are confusing, and PUSH is not documented.
+    We rename here for a little bit of clarity."""
+
+    FULL = "FULL"  # All profiles
+    CUSTOM = "CUSTOM"  # Custom profiles
+    ADMIN = "NONE"  # System Administrator only
+    PUSH = "PUSH"  # No profiles
+
+
+class NameConflictResolution(StrEnum):
+    """Enum used to specify how name conflicts will be resolved when installing an Unlocked Package."""
+
+    BLOCK = "Block"
+    RENAME = "RenameMetadata"
+
+
+# Unlocked Packages only. Default appears to be all but is not documented.
+class ApexCompileType(StrEnum):
+    ALL = "all"
+    PACKAGE = "package"
+
+
+# Unlocked Packages only. Default is mixed.
+class UpgradeType(StrEnum):
+    DELETE_ONLY = "delete-only"
+    DEPRECATE_ONLY = "deprecate-only"
+    MIXED = "mixed"
+
+
+class PackageInstallOptions(CCIModel):
+    """Options governing installation behavior for a managed or unlocked package."""
+
+    activate_remote_site_settings: bool = True
+    name_conflict_resolution: NameConflictResolution = NameConflictResolution.BLOCK
+    password: Optional[str] = None
+    security_type: SecurityType = SecurityType.FULL
+    apex_compile_type: Optional[ApexCompileType] = None
+    upgrade_type: Optional[UpgradeType] = None
+
+    @staticmethod
+    def from_task_options(task_options: dict) -> "PackageInstallOptions":
+        options = PackageInstallOptions()  # all parameters are defaulted
+
+        try:
+            if "security_type" in task_options:
+                options.security_type = SecurityType(task_options["security_type"])
+            if "activate_remote_site_settings" in task_options:
+                options.activate_remote_site_settings = process_bool_arg(
+                    task_options["activate_remote_site_settings"]
+                )
+            if "name_conflict_resolution" in task_options:
+                options.name_conflict_resolution = NameConflictResolution(
+                    task_options["name_conflict_resolution"]
+                )
+            if "password" in task_options:
+                options.password = task_options["password"]
+            if "apex_compile_type" in task_options:
+                options.apex_compile_type = ApexCompileType(
+                    task_options["apex_compile_type"]
+                )
+            if "upgrade_type" in task_options:
+                options.upgrade_type = UpgradeType(task_options["upgrade_type"])
+        except ValueError as e:
+            raise TaskOptionsError(f"Invalid task options: {e}")
+
+        return options
+
+
+PackageInstallOptions.update_forward_refs()
+
+PACKAGE_INSTALL_TASK_OPTIONS = {
+    "security_type": {
+        "description": "Which Profiles to install packages for (FULL = all profiles, NONE = admins only, PUSH = no profiles, CUSTOM = custom profiles). Defaults to FULL."
+    },
+    "name_conflict_resolution": {
+        "description": "Specify how to resolve name conflicts when installing an Unlocked Package. Available values are Block and RenameMetadata. Defaults to Block."
+    },
+    "activate_remote_site_settings": {
+        "description": "Activate Remote Site Settings when installing a package. Defaults to True."
+    },
+    "password": {"description": "The installation key for the managed package."},
+    "apex_compile_type": {
+        "description": "For Unlocked Packages only, whether to compile Apex in the package only (`package`) or in the whole org (`all`). `all` is the default behavior."
+    },
+    "upgrade_type": {
+        "description": "For Unlocked Package upgrades only, whether to deprecate removed components (`deprecate-only`), delete them (`delete-only`), or delete and deprecate based on safety (`mixed`). `mixed` is the default behavior."
+    },
+}
+
+DEFAULT_PACKAGE_RETRY_OPTIONS = {
+    "retries": 20,
+    "retry_interval": 5,
+    "retry_interval_add": 30,
+}
+
+RETRY_PACKAGE_ERRORS = [
+    "This package is not yet available",
+    "InstalledPackage version number",
+    "The requested package doesn't yet exist or has been deleted",
+    "unable to obtain exclusive access to this record",
+    "invalid cross reference id",
+]
+
+
+def _wait_for_package_install(tooling, request):
+    res = tooling.query(
+        f"SELECT Errors, Status FROM PackageInstallRequest WHERE Id='{request['id']}'"
+    )
+    request = res["records"][0]
+    if request["Status"] == "IN_PROGRESS":
+        logger.info("In Progress")
+        return False
+
+    if request["Status"] == "SUCCESS":
+        logger.info("Success")
+        return True
+
+    if request["Status"] == "ERROR":
+        logger.error("Error installing package")
+        raise PackageInstallError(
+            "\n".join(error["message"] for error in request["Errors"]["errors"])
+        )
+
+
+def _install_package_by_version_id(
+    project_config: BaseProjectConfig,
+    org_config: OrgConfig,
+    version_id: str,
+    options: PackageInstallOptions,
+):
+    """Install a 1gp or 2gp package using PackageInstallRequest"""
+    tooling = get_simple_salesforce_connection(
+        project_config, org_config, base_url="tooling"
+    )
+    PackageInstallRequest = cast(SFType, tooling.PackageInstallRequest)
+    PackageInstallRequest.base_url = PackageInstallRequest.base_url.replace(
+        "/sobjects/", "/tooling/sobjects/"
+    )
+    request = PackageInstallRequest.create(
+        {
+            "EnableRss": options.activate_remote_site_settings,
+            "NameConflictResolution": options.name_conflict_resolution,
+            "Password": options.password,
+            "SecurityType": options.security_type,
+            "SubscriberPackageVersionKey": version_id,
+            "UpgradeType": options.upgrade_type,
+            "ApexCompileType": options.apex_compile_type,
+        }
+    )
+    poll(functools.partial(_wait_for_package_install, tooling, request))
+
+
+def _should_retry_package_install(e: Exception) -> bool:
+    return isinstance(e, (SalesforceMalformedRequest, MetadataApiError)) and any(
+        err in str(e) for err in RETRY_PACKAGE_ERRORS
+    )
+
+
+def _install_package_by_namespace_version(
+    project_config: BaseProjectConfig,
+    org_config: OrgConfig,
+    namespace: str,
+    version: str,
+    install_options: PackageInstallOptions,
+    retry_options=None,
+):
+    task = TaskContext(
+        org_config=org_config, project_config=project_config, logger=logger
+    )
+
+    retry_options = {
+        **(retry_options or {}),
+        "should_retry": _should_retry_package_install,
+    }
+
+    def deploy():
+        package_zip = InstallPackageZipBuilder(
+            namespace=namespace,
+            version=version,
+            activateRSS=install_options.activate_remote_site_settings,
+            password=install_options.password,
+            securityType=install_options.security_type,
+        )
+        ApiDeploy(task, package_zip(), purge_on_delete=False)()
+
+    retry(
+        deploy,
+        **retry_options,
+    )
+
+
+def install_package_by_version_id(
+    project_config: BaseProjectConfig,
+    org_config: OrgConfig,
+    version_id: str,
+    install_options: PackageInstallOptions,
+    retry_options=None,
+):
+    """Install a 1gp or 2gp package using PackageInstallRequest, with retries"""
+    retry_options = {
+        **(retry_options or {}),
+        "should_retry": _should_retry_package_install,
+    }
+    retry(
+        functools.partial(
+            _install_package_by_version_id,
+            project_config,
+            org_config,
+            version_id,
+            install_options,
+        ),
+        **retry_options,
+    )
+
+
+def install_package_by_namespace_version(
+    project_config: BaseProjectConfig,
+    org_config: OrgConfig,
+    namespace: str,
+    version: str,
+    install_options: PackageInstallOptions,
+    retry_options=None,
+):
+    """Install a 1gp package by deploying InstalledPackage metadata, with retries"""
+    retry_options = {
+        **(retry_options or {}),
+        "should_retry": _should_retry_package_install,
+    }
+    retry(
+        functools.partial(
+            _install_package_by_namespace_version,
+            project_config,
+            org_config,
+            namespace,
+            version,
+            install_options,
+        ),
+        **retry_options,
+    )