cloudpub 1.5.0__py3-none-any.whl → 1.6.0__py3-none-any.whl

cloudpub/ms_azure/service.py

@@ -2,6 +2,7 @@
 import json
 import logging
 import os
+from enum import IntEnum
 from typing import Any, Dict, Iterator, List, Optional, Tuple, Union, cast
 
 from deepdiff import DeepDiff
@@ -18,6 +19,7 @@ from cloudpub.models.ms_azure import (
     AzureResource,
     ConfigureStatus,
     CustomerLeads,
+    DiskVersion,
     Listing,
     ListingAsset,
     ListingTrailer,
@@ -38,6 +40,7 @@ from cloudpub.models.ms_azure import (
 from cloudpub.ms_azure.session import PartnerPortalSession
 from cloudpub.ms_azure.utils import (
     AzurePublishingMetadata,
+    TechnicalConfigLookUpData,
     create_disk_version_from_scratch,
     is_azure_job_not_complete,
     is_sas_present,
@@ -69,6 +72,15 @@ AZURE_PRODUCT_RESOURCES = Union[
 ]
 
 
+class SasFoundStatus(IntEnum):
+    """Represent the submission target level of SAS found in a given product."""
+
+    missing = 0
+    draft = 1
+    preview = 2
+    live = 3
+
+
 class AzureService(BaseService[AzurePublishingMetadata]):
     """Service provider for Microsoft Azure using the Product Ingestion API."""
 
@@ -103,7 +115,10 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             The job ID to track its status alongside the initial status.
         """
-        log.debug("Received the following data to create/modify: %s" % json.dumps(data, indent=2))
+        if log.isEnabledFor(logging.DEBUG):
+            log.debug(
+                "Received the following data to create/modify: %s", json.dumps(data, indent=2)
+            )
         resp = self.session.post(path="configure", json=data)
         self._raise_for_status(response=resp)
         rsp_data = resp.json()
@@ -121,7 +136,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             The updated job status.
         """
-        log.debug(f"Query job details for \"{job_id}\"")
+        log.debug("Query job details for \"%s\"", job_id)
         resp = self.session.get(path=f"configure/{job_id}/status")
 
         # We don't want to fail if there's a server error thus we make a fake
@@ -129,9 +144,11 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         if resp.status_code >= 500:
             log.warning(
                 (
-                    f"Got HTTP {resp.status_code} from server when querying job {job_id} status."
-                    " Considering the job_status as \"pending\"."
-                )
+                    "Got HTTP %s from server when querying job %s status."
+                    " Considering the job_status as \"pending\".",
+                ),
+                resp.status_code,
+                job_id,
             )
             return ConfigureStatus.from_json(
                 {
@@ -177,24 +194,25 @@ class AzureService(BaseService[AzurePublishingMetadata]):
             error_message = f"Job {job_id} failed: \n{job_details.errors}"
             self._raise_error(InvalidStateError, error_message)
         elif job_details.job_result == "succeeded":
-            log.debug(f"Job {job_id} succeeded")
+            log.debug("Job %s succeeded", job_id)
         return job_details
 
-    def configure(self, resource: AzureResource) -> ConfigureStatus:
+    def configure(self, resources: List[AzureResource]) -> ConfigureStatus:
         """
         Create or update a resource and wait until it's done.
 
         Args:
-            resource (AzureResource):
-                The resource to create/modify in Azure.
+            resources (List[AzureResource]):
+                The list of resources to create/modify in Azure.
         Returns:
             dict: The result of job execution
         """
         data = {
             "$schema": self.CONFIGURE_SCHEMA.format(AZURE_API_VERSION=self.AZURE_API_VERSION),
-            "resources": [resource.to_json()],
+            "resources": [x.to_json() for x in resources],
         }
-        log.info("Data to configure: %s", json.dumps(data, indent=2))
+        if log.isEnabledFor(logging.DEBUG):
+            log.debug("Data to configure: %s", json.dumps(data, indent=2))
         res = self._configure(data=data)
         return self._wait_for_job_completion(job_id=res.job_id)
 
@@ -205,7 +223,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         params: Dict[str, str] = {}
 
         while has_next:
-            log.debug("Requesting the products list.")
+            log.info("Requesting the products list.")
             resp = self.session.get(path="/product", params=params)
             data = self._assert_dict(resp)
 
@@ -230,11 +248,26 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             list: A list with ProductSummary for all products in Azure.
         """
+        log.info("Listing the products on Azure server.")
         if not self._products:
             self._products = [p for p in self.products]
         return self._products
 
-    def get_product(self, product_id: str, first_target: str = "preview") -> Product:
+    def get_productid(self, product_name: str) -> str:
+        """Retrieve the desired product ID for the requested product name.
+
+        Args:
+            product_name (str): the product's name to retrieve its product ID.
+        Returns:
+            The requested product ID when found.
+        Raises NotFoundError when the product was not found.
+        """
+        for product in self.list_products():
+            if product.identity.name == product_name:
+                return product.id
+        raise NotFoundError(f"No such product with name {product_name}")
+
+    def get_product(self, product_id: str, target: str) -> Product:
         """
         Return the requested Product by its ID.
 
@@ -246,37 +279,31 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Args:
             product_durable_id (str)
                 The product UUID
-            first_target (str, optional)
-                The first target to lookup into. Defaults to ``preview``.
+            target (str)
+                The submission target to retrieve the product from.
         Returns:
             Product: the requested product
         """
-        targets = [first_target]
-        for tgt in ["preview", "draft", "live"]:
-            if tgt not in targets:
-                targets.append(tgt)
-
-        for t in targets:
-            log.debug("Requesting the product ID \"%s\" with state \"%s\".", product_id, t)
-            try:
-                resp = self.session.get(
-                    path=f"/resource-tree/product/{product_id}", params={"targetType": t}
-                )
-                data = self._assert_dict(resp)
-                return Product.from_json(data)
-            except (ValueError, HTTPError):
-                log.debug("Couldn't find the product \"%s\" with state \"%s\"", product_id, t)
+        log.info("Requesting the product ID \"%s\" with state \"%s\".", product_id, target)
+        try:
+            resp = self.session.get(
+                path=f"/resource-tree/product/{product_id}", params={"targetType": target}
+            )
+            data = self._assert_dict(resp)
+            return Product.from_json(data)
+        except (ValueError, HTTPError):
+            log.debug("Couldn't find the product \"%s\" with state \"%s\"", product_id, target)
         self._raise_error(NotFoundError, f"No such product with id \"{product_id}\"")
 
-    def get_product_by_name(self, product_name: str, first_target: str = "preview") -> Product:
+    def get_product_by_name(self, product_name: str, target: str) -> Product:
         """
         Return the requested Product by its name from Legacy CPP API.
 
         Args:
             product_name (str)
                 The product name according to Legacy CPP API.
-            first_target (str, optional)
-                The first target to lookup into. Defaults to ``preview``.
+            target (str, optional)
+                The submission target to retrieve the product from.
         Returns:
             Product: the requested product when found
         Raises:
@@ -285,7 +312,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         for product in self.products:
             if product.identity.name == product_name:
                 log.debug("Product alias \"%s\" has the ID \"%s\"", product_name, product.id)
-                return self.get_product(product.id, first_target=first_target)
+                return self.get_product(product.id, target=target)
         self._raise_error(NotFoundError, f"No such product with name \"{product_name}\"")
 
     def get_submissions(self, product_id: str) -> List[ProductSubmission]:
@@ -314,6 +341,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Returns:
             Optional[ProductSubmission]: The requested submission when found.
         """
+        log.info("Looking up for submission in state \"%s\" for \"%s\"", state, product_id)
         submissions = self.get_submissions(product_id)
         for sub in submissions:
             if sub.target.targetType == state:
@@ -369,47 +397,49 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         self._raise_error(NotFoundError, f"No such plan with name \"{plan_name}\"")
 
     def get_product_plan_by_name(
-        self, product_name: str, plan_name: str
+        self,
+        product_name: str,
+        plan_name: str,
+        target: str,
     ) -> Tuple[Product, PlanSummary]:
         """Return a tuple with the desired Product and Plan after iterating over all targets.
 
         Args:
             product_name (str): The name of the product to search for
             plan_name (str): The name of the plan to search for
-
+            target (str)
+                The submission target to retrieve the product/plan from.
         Returns:
             Tuple[Product, PlanSummary]: The Product and PlanSummary when fonud
         Raises:
-            NotFoundError whenever all targets are exhausted and no information was found
-        """
-        targets = ["preview", "draft", "live"]
-
-        for tgt in targets:
-            try:
-                product = self.get_product_by_name(product_name, first_target=tgt)
-                plan = self.get_plan_by_name(product, plan_name)
-                return product, plan
-            except NotFoundError:
-                continue
-        self._raise_error(
-            NotFoundError, f"No such plan with name \"{plan_name} for {product_name}\""
-        )
+            NotFoundError whenever no information was found in the respective submission target.
+        """
+        try:
+            product = self.get_product_by_name(product_name, target=target)
+            plan = self.get_plan_by_name(product, plan_name)
+            return product, plan
+        except NotFoundError:
+            self._raise_error(
+                NotFoundError, f"No such plan with name \"{plan_name} for {product_name}\""
+            )
 
-    def diff_offer(self, product: Product, first_target="preview") -> DeepDiff:
+    def diff_offer(self, product: Product, target: str) -> DeepDiff:
         """Compute the difference between the provided product and the one in the remote.
 
         Args:
             product (Product)
                 The local product to diff with the remote one.
-            first_target (str)
-                The first target to lookup into. Defaults to ``preview``.
+            target (str)
+                The submission target to retrieve the product from.
         Returns:
             DeepDiff: The diff data.
         """
-        remote = self.get_product(product.id, first_target=first_target)
+        remote = self.get_product(product.id, target=target)
         return DeepDiff(remote.to_json(), product.to_json(), exclude_regex_paths=self.DIFF_EXCLUDES)
 
-    def submit_to_status(self, product_id: str, status: str) -> ConfigureStatus:
+    def submit_to_status(
+        self, product_id: str, status: str, resources: Optional[List[AzureResource]] = None
+    ) -> ConfigureStatus:
         """
         Send a submission request to Microsoft with a new Product status.
 
@@ -418,9 +448,12 @@ class AzureService(BaseService[AzurePublishingMetadata]):
                 The product ID to submit the new status.
             status (str)
                 The new status: 'preview' or 'live'
+            resources (optional(list(AzureRerouce)))
+                Additional resources for modular push.
         Returns:
             The response from configure request.
         """
+        log.info("Submitting the status of \"%s\" to \"%s\"", product_id, status)
         # We need to get the previous state of the given one to request the submission
         prev_state_mapping = {
             "preview": "draft",
@@ -437,9 +470,12 @@ class AzureService(BaseService[AzurePublishingMetadata]):
 
         # Update the status with the expected one
         submission.target.targetType = status
+        cfg_res: List[AzureResource] = [submission]
+        if resources:
+            log.info("Performing a modular push to \"%s\" for \"%s\"", status, product_id)
+            cfg_res = resources + cfg_res
         log.debug("Set the status \"%s\" to submission.", status)
-
-        return self.configure(resource=submission)
+        return self.configure(resources=cfg_res)
 
     @retry(
         wait=wait_fixed(300),
@@ -459,6 +495,7 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         Raises:
             RuntimeError: whenever a publishing is already in progress.
         """
+        log.info("Ensuring no other publishing jobs are in progress for \"%s\"", product_id)
         submission_targets = ["preview", "live"]
 
         for target in submission_targets:
@@ -491,6 +528,79 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         )
         return tconfigs[0]  # It should have only one VMIPlanTechConfig per plan.
 
+    def get_modular_resources_to_publish(
+        self, product: Product, tech_config: VMIPlanTechConfig
+    ) -> List[AzureResource]:
+        """Return the required resources for a modular publishing.
+
+        According to Microsoft docs:
+        "For a modular publish, all resources are required except for the product level details
+        (for example, listing, availability, packages, reseller) as applicable to your
+        product type."
+
+        Args:
+            product (Product): The original product to filter the resources from
+            tech_config (VMIPlanTechConfig): The updated tech config to publish
+
+        Returns:
+            List[AzureResource]: _description_
+        """
+        # The following resources shouldn't be required:
+        # -> customer-leads
+        # -> test-drive
+        # -> property
+        # -> *listing*
+        # -> reseller
+        # -> price-and-availability-*
+        # NOTE: The "submission" resource will be already added by the "submit_to_status" method
+        #
+        # With that it needs only the related "product" and "plan" resources alongisde the
+        # updated tech_config
+        product_id = tech_config.product_id
+        plan_id = tech_config.plan_id
+        prod_res = cast(
+            List[ProductSummary],
+            [
+                prd
+                for prd in self.filter_product_resources(product=product, resource="product")
+                if prd.id == product_id
+            ],
+        )[0]
+        plan_res = cast(
+            List[PlanSummary],
+            [
+                pln
+                for pln in self.filter_product_resources(product=product, resource="plan")
+                if pln.id == plan_id
+            ],
+        )[0]
+        return [prod_res, plan_res, tech_config]
+
+    def compute_targets(self, product_id: str) -> List[str]:
+        """List all the possible publishing targets order to seek data from Azure.
+
+        It also returns the ordered list of targets with the following precedence:
+        ``live`` -> ``preview`` -> ``draft``
+
+        Args:
+            product_id (str)
+                The product_id to retrieve all existing submission targets.
+
+        Returns:
+            List[Str]: The ordered list with targets to lookup.
+        """
+        all_targets = ["live", "preview", "draft"]
+        computed_targets = []
+
+        # We cannot simply return all targets above because the existing product might
+        # lack one of them. So now we need to filter out unexisting targets.
+        product_submissions = self.get_submissions(product_id)
+        product_targets = [s.target.targetType for s in product_submissions]
+        for t in all_targets:
+            if t in product_targets:
+                computed_targets.append(t)
+        return computed_targets
+
     def _is_submission_in_preview(self, current: ProductSubmission) -> bool:
         """Return True if the latest submission state is "preview", False otherwise.
 
@@ -518,42 +628,33 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         stop=stop_after_attempt(3),
         reraise=True,
     )
-    def _publish_preview(self, product: Product, product_name: str) -> None:
+    def _publish_preview(
+        self, product: Product, product_name: str, resources: Optional[List[AzureResource]] = None
+    ) -> None:
         """
-        Submit the product to 'preview'  if it's not already in this state.
+        Submit the product to 'preview' after going through Azure Marketplace Validatoin.
 
         This is required to execute the validation pipeline on Azure side.
 
         Args:
             product
-                The product with changes to publish live
+                The product with changes to publish to preview
             product_name
                 The product name to display in logs.
+            resources:
+                Additional resources for modular push.
         """
-        # We just want to set the ProductSubmission to 'preview' if it's not in this status.
-        #
-        # The `preview` stage runs the Azure pipeline which takes up to 4 days.
-        # Meanwhile the `submit_for_status` will be blocked querying the `job_status`until
-        # all the Azure verification pipeline finishes.
-        submission: ProductSubmission = cast(
-            List[ProductSubmission],
-            self.filter_product_resources(product=product, resource="submission"),
-        )[0]
-        if not self._is_submission_in_preview(submission):
-            log.info(
-                "Submitting the product \"%s (%s)\" to \"preview\"." % (product_name, product.id)
+        res = self.submit_to_status(product_id=product.id, status='preview', resources=resources)
+
+        if res.job_result != 'succeeded' or not self.get_submission_state(
+            product.id, state="preview"
+        ):
+            errors = "\n".join(res.errors)
+            failure_msg = (
+                f"Failed to submit the product {product_name} ({product.id}) to preview. "
+                f"Status: {res.job_result} Errors: {errors}"
             )
-            res = self.submit_to_status(product_id=product.id, status='preview')
-
-            if res.job_result != 'succeeded' or not self.get_submission_state(
-                product.id, state="preview"
-            ):
-                errors = "\n".join(res.errors)
-                failure_msg = (
-                    f"Failed to submit the product {product.id} to preview. "
-                    f"Status: {res.job_result} Errors: {errors}"
-                )
-                raise RuntimeError(failure_msg)
+            raise RuntimeError(failure_msg)
 
     @retry(
         wait=wait_fixed(wait=60),
@@ -572,17 +673,133 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         """
         # Note: the offer can only go `live` after successfully being changed to `preview`
         # which takes up to 4 days.
-        log.info("Submitting the product \"%s (%s)\" to \"live\"." % (product_name, product.id))
         res = self.submit_to_status(product_id=product.id, status='live')
 
         if res.job_result != 'succeeded' or not self.get_submission_state(product.id, state="live"):
             errors = "\n".join(res.errors)
             failure_msg = (
-                f"Failed to submit the product {product.id} to live. "
+                f"Failed to submit the product {product_name} ({product.id}) to live. "
                 f"Status: {res.job_result} Errors: {errors}"
             )
             raise RuntimeError(failure_msg)
 
+    def _overwrite_disk_version(
+        self,
+        metadata: AzurePublishingMetadata,
+        product_name: str,
+        plan_name: str,
+        source: VMImageSource,
+        target: str,
+    ) -> TechnicalConfigLookUpData:
+        """Private method to overwrite the technical config with a new DiskVersion.
+
+        Args:
+            metadata (AzurePublishingMetadata): the incoming publishing metadata
+            product_name (str): the product (offer) name
+            plan_name (str): the plan name
+            source (VMImageSource): the source VMI to create and overwrite the new DiskVersion
+            target (str): the submission target.
+
+        Returns:
+            TechnicalConfigLookUpData: The overwritten tech_config for the product/plan
+        """
+        product, plan = self.get_product_plan_by_name(product_name, plan_name, target)
+        log.warning(
+            "Overwriting the plan \"%s\" on \"%s\" with the given image: \"%s\".",
+            plan_name,
+            target,
+            metadata.image_path,
+        )
+        tech_config = self.get_plan_tech_config(product, plan)
+        disk_version = create_disk_version_from_scratch(metadata, source)
+        tech_config.disk_versions = [disk_version]
+        return {
+            "metadata": metadata,
+            "tech_config": tech_config,
+            "sas_found": False,
+            "product": product,
+            "plan": plan,
+            "target": target,
+        }
+
+    def _look_up_sas_on_technical_config(
+        self, metadata: AzurePublishingMetadata, product_name: str, plan_name: str, target: str
+    ) -> TechnicalConfigLookUpData:
+        """Private method to lookup for the TechnicalConfig of a given target.
+
+        Args:
+            metadata (AzurePublishingMetadata): the incoming publishing metadata.
+            product_name (str): the product (offer) name
+            plan_name (str): the plan name
+            target (str): the submission target to look up the TechnicalConfig object
+
+        Returns:
+            TechnicalConfigLookUpData: The data retrieved for the given submission target.
+        """
+        product, plan = self.get_product_plan_by_name(product_name, plan_name, target)
+        log.info(
+            "Retrieving the technical config for \"%s\" on \"%s\".",
+            metadata.destination,
+            target,
+        )
+        tech_config = self.get_plan_tech_config(product, plan)
+        sas_found = False
+
+        if is_sas_present(tech_config, metadata.image_path, metadata.check_base_sas_only):
+            log.info(
+                "The destination \"%s\" on \"%s\" already contains the SAS URI: \"%s\".",
+                metadata.destination,
+                target,
+                metadata.image_path,
+            )
+            sas_found = True
+        return {
+            "metadata": metadata,
+            "tech_config": tech_config,
+            "sas_found": sas_found,
+            "product": product,
+            "plan": plan,
+            "target": target,
+        }
+
+    def _create_or_update_disk_version(
+        self,
+        tech_config_lookup: TechnicalConfigLookUpData,
+        source: VMImageSource,
+        disk_version: Optional[DiskVersion],
+    ) -> DiskVersion:
+        """Private method to create/update the DiskVersion of a given TechnicalConfig object.
+
+        Args:
+            tech_config_lookup (TechnicalConfigLookUpData): the incoming data to process
+            source (VMImageSource): the new VMI source to attach
+            disk_version (Optional[DiskVersion]): the disk version if it exists (for updates).
+
+        Returns:
+            DiskVersion: The updated DiskVersion
+        """
+        metadata = tech_config_lookup["metadata"]
+        target = tech_config_lookup["target"]
+        tech_config = tech_config_lookup["tech_config"]
+
+        # Check the images of the selected DiskVersion if it exists
+        if disk_version:
+            log.info(
+                "DiskVersion \"%s\" exists in \"%s\" on \"%s\" for the image \"%s\".",
+                disk_version.version_number,
+                metadata.destination,
+                target,
+                metadata.image_path,
+            )
+            # Update the disk version with the new SAS
+            disk_version = set_new_sas_disk_version(disk_version, metadata, source)
+            return disk_version
+        # The disk version doesn't exist, we need to create one from scratch
+        log.info("The DiskVersion doesn't exist, creating one from scratch.")
+        disk_version = create_disk_version_from_scratch(metadata, source)
+        tech_config.disk_versions.append(disk_version)
+        return disk_version
+
     def publish(self, metadata: AzurePublishingMetadata) -> None:
         """
         Associate a VM image with a given product listing (destination) and publish it if required.
@@ -596,71 +813,102 @@ class AzureService(BaseService[AzurePublishingMetadata]):
         #   "product-name/plan-name"
         product_name = metadata.destination.split("/")[0]
         plan_name = metadata.destination.split("/")[-1]
-        product, plan = self.get_product_plan_by_name(product_name, plan_name)
+        product_id = self.get_productid(product_name)
+        sas_in_target = SasFoundStatus.missing
         log.info(
-            "Preparing to associate the image with the plan \"%s\" from product \"%s\""
-            % (plan_name, product_name)
+            "Preparing to associate the image \"%s\" with the plan \"%s\" from product \"%s\"",
+            metadata.image_path,
+            plan_name,
+            product_name,
         )
 
-        # 2. Retrieve the VM Technical configuration for the given plan
-        log.debug("Retrieving the technical config for \"%s\"." % metadata.destination)
-        tech_config = self.get_plan_tech_config(product, plan)
-
-        # 3. Prepare the Disk Version
-        log.debug("Creating the VMImageResource with SAS: \"%s\"" % metadata.image_path)
+        # 2. Prepare the Disk Version
+        log.info("Creating the VMImageResource with SAS for image: \"%s\"", metadata.image_path)
         sas = OSDiskURI(uri=metadata.image_path)
         source = VMImageSource(source_type="sasUri", os_disk=sas.to_json(), data_disks=[])
 
+        # 3. Set the new Disk Version into the product/plan if required
+        #
         # Note: If `overwrite` is True it means we can set this VM image as the only one in the
         # plan's technical config and discard all other VM images which may've been present.
-        disk_version = None  # just to make mypy happy
         if metadata.overwrite is True:
-            log.warning("Overwriting the plan %s with the given image.", plan_name)
-            disk_version = create_disk_version_from_scratch(metadata, source)
-            tech_config.disk_versions = [disk_version]
-
-        # We just want to append a new image if the SAS is not already present.
-        elif not is_sas_present(tech_config, metadata.image_path, metadata.check_base_sas_only):
-            # Here we can have the metadata.disk_version set or empty.
-            # When set we want to get the existing disk_version which matches its value.
-            log.debug("Scanning the disk versions from %s" % metadata.destination)
-            disk_version = seek_disk_version(tech_config, metadata.disk_version)
-
-            # Check the images of the selected DiskVersion if it exists
-            if disk_version:
-                log.debug(
-                    "DiskVersion \"%s\" exists in \"%s\"."
-                    % (disk_version.version_number, metadata.destination)
-                )
-                disk_version = set_new_sas_disk_version(disk_version, metadata, source)
-
-            else:  # The disk version doesn't exist, we need to create one from scratch
-                log.debug("The DiskVersion doesn't exist, creating one from scratch.")
-                disk_version = create_disk_version_from_scratch(metadata, source)
-                tech_config.disk_versions.append(disk_version)
+            target = "draft"  # It's expected to exist for whenever product.
+            res = self._overwrite_disk_version(metadata, product_name, plan_name, source, target)
+            tech_config = res["tech_config"]
         else:
-            log.info(
-                "The destination \"%s\" already contains the SAS URI: \"%s\"."
-                % (metadata.destination, metadata.image_path)
-            )
+            # Otherwise we need to check whether SAS isn't already present
+            # in any of the targets "preview", "live" or "draft" and if not attach and publish it.
+            for target in self.compute_targets(product_id):
+                res = self._look_up_sas_on_technical_config(
+                    metadata, product_name, plan_name, target
+                )
+                tech_config = res["tech_config"]
+                # We don't want to seek for SAS anymore as it was already found
+                if res["sas_found"]:
+                    sas_in_target = SasFoundStatus[target]
+                    break
+            else:
+                # At this point there's no SAS URI in any target so we can safely add it
+
+                # Here we can have the metadata.disk_version set or empty.
+                # When set we want to get the existing disk_version which matches its value.
+                log.info(
+                    "Scanning the disk versions from \"%s\" on \"%s\" for the image \"%s\"",
+                    metadata.destination,
+                    target,
+                    metadata.image_path,
+                )
+                dv = seek_disk_version(tech_config, metadata.disk_version)
+                self._create_or_update_disk_version(res, source, dv)
 
         # 4. With the updated disk_version we should adjust the SKUs and submit the changes
-        if disk_version:
-            log.debug("Updating SKUs for \"%s\"." % metadata.destination)
+        if sas_in_target == SasFoundStatus.missing:
+            log.info("Updating SKUs for \"%s\" on \"%s\".", metadata.destination, target)
             tech_config.skus = update_skus(
                 disk_versions=tech_config.disk_versions,
                 generation=metadata.generation,
                 plan_name=plan_name,
                 old_skus=tech_config.skus,
             )
-            log.debug("Updating the technical configuration for \"%s\"." % metadata.destination)
-            self.configure(resource=tech_config)
+            log.info(
+                "Updating the technical configuration for \"%s\" on \"%s\".",
+                metadata.destination,
+                target,
+            )
+            self.configure(resources=[tech_config])
 
         # 5. Proceed to publishing if it was requested.
         # Note: The publishing will only occur if it made changes in disk_version.
-        if disk_version and not metadata.keepdraft:
-            logdiff(self.diff_offer(product))
-            self.ensure_can_publish(product.id)
+        if not metadata.keepdraft:
+            product = res["product"]
+            # Get the submission state
+            submission: ProductSubmission = cast(
+                List[ProductSubmission],
+                self.filter_product_resources(product=product, resource="submission"),
+            )[0]
+
+            # We should only publish if there are new changes OR
+            # the existing offer was already in preview
+            if sas_in_target <= SasFoundStatus.draft or self._is_submission_in_preview(submission):
+                log.info(
+                    "Publishing the new changes for \"%s\" on plan \"%s\"", product_name, plan_name
+                )
+                logdiff(self.diff_offer(product, target))
+                self.ensure_can_publish(product.id)
+
+                # According to the documentation we only need to pass the
+                # required resources for modular publish on "preview"
+                # https://learn.microsoft.com/en-us/partner-center/marketplace-offers/product-ingestion-api#method-2-publish-specific-draft-resources-also-known-as-modular-publish  # noqa: E501
+                modular_resources = None
+                if metadata.modular_push:
+                    modular_resources = self.get_modular_resources_to_publish(product, tech_config)
+                if sas_in_target < SasFoundStatus.preview:
+                    self._publish_preview(product, product_name, resources=modular_resources)
+                if sas_in_target < SasFoundStatus.live:
+                    self._publish_live(product, product_name)
 
-            self._publish_preview(product, product_name)
-            self._publish_live(product, product_name)
+        log.info(
+            "Finished publishing the image \"%s\" to \"%s\"",
+            metadata.image_path,
+            metadata.destination,
+        )

cloudpub/ms_azure/session.py

@@ -24,7 +24,7 @@ class AccessToken:
         """
         self.expires_on = datetime.fromtimestamp(int(json["expires_on"]))
         self.access_token = json["access_token"]
-        log.debug(f"Obtained token with expiration date on {self.expires_on}")
+        log.debug("Obtained token with expiration date on %s", self.expires_on)
 
     def is_expired(self) -> bool:
         """Return True if the token is expired and False otherwise."""
@@ -108,7 +108,7 @@ class PartnerPortalSession:
             "AZURE_API_SECRET",
         ]
         for key in mandatory_keys:
-            log.debug(f"Validating mandatory key \"{key}\"")
+            log.debug("Validating mandatory key \"%s\"", key)
             if key not in auth_keys.keys() or not auth_keys.get(key):
                 err_msg = f'The key/value for "{key}" must be set.'
                 log.error(err_msg)
@@ -117,7 +117,7 @@ class PartnerPortalSession:
 
     def _login(self) -> AccessToken:
         """Retrieve the authentication token from Microsoft."""
-        log.info("Retrieving the bearer token from Microsoft")
+        log.debug("Retrieving the bearer token from Microsoft")
         url = self.LOGIN_URL_TMPL.format(**self.auth_keys)
 
         headers = {
@@ -156,7 +156,7 @@ class PartnerPortalSession:
                 params = {}
             params.update(self._mandatory_params)
 
-        log.info(f"Sending a {method} request to {path}")
+        log.debug("Sending a %s request to %s", method, path)
         formatted_url = self._prefix_url.format(**self.auth_keys)
         url = join_url(formatted_url, path)
         return self.session.request(method, url=url, params=params, headers=headers, **kwargs)

cloudpub/ms_azure/utils.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 import logging
 from operator import attrgetter
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Tuple, TypedDict
 
 from deepdiff import DeepDiff
 
@@ -9,6 +9,8 @@ from cloudpub.common import PublishingMetadata  # Cannot circular import AzurePu
 from cloudpub.models.ms_azure import (
     ConfigureStatus,
     DiskVersion,
+    PlanSummary,
+    Product,
     VMImageDefinition,
     VMImageSource,
     VMIPlanTechConfig,
@@ -54,6 +56,11 @@ class AzurePublishingMetadata(PublishingMetadata):
             check_base_sas_only (bool, optional):
                 Indicates to skip checking SAS parameters when set as ``True``.
                 Default to ``False``
+            modular_push (bool, optional):
+                Indicate whether to perform a modular push or not.
+                The modular push causes the effect to only publish
+                the changed plan instead of the whole offer to preview/live.
+                Default to ``False``.
             **kwargs
                 Arguments for :class:`~cloudpub.common.PublishingMetadata`.
         """
@@ -64,6 +71,7 @@ class AzurePublishingMetadata(PublishingMetadata):
         self.recommended_sizes = recommended_sizes or []
         self.legacy_sku_id = kwargs.pop("legacy_sku_id", None)
         self.check_base_sas_only = kwargs.pop("check_base_sas_only", False)
+        self.modular_push = kwargs.pop("modular_push", None) or False
 
         if generation == "V1" or not support_legacy:
             self.legacy_sku_id = None
@@ -107,6 +115,17 @@ class AzurePublishingMetadata(PublishingMetadata):
             raise ValueError(f"Invalid SAS URI \"{self.image_path}\". Expected: http/https URL.")
 
 
+class TechnicalConfigLookUpData(TypedDict):
+    """A typed dict to be used for private methods data exchange."""
+
+    metadata: AzurePublishingMetadata
+    tech_config: VMIPlanTechConfig
+    sas_found: bool
+    product: Product
+    plan: PlanSummary
+    target: str
+
+
 def get_image_type_mapping(architecture: str, generation: str) -> str:
     """Return the image type required by VMImageDefinition."""
     gen_map = {
@@ -150,22 +169,23 @@ def is_sas_eq(sas1: str, sas2: str, base_only=False) -> bool:
 
     # Base URL differs
     if base_sas1 != base_sas2:
-        log.debug("Got different base SAS: %s - Expected: %s" % (base_sas1, base_sas2))
+        log.debug("Got different base SAS: %s - Expected: %s", base_sas1, base_sas2)
         return False
 
     if not base_only:
         # Parameters lengh differs
         if len(params_sas1) != len(params_sas2):
             log.debug(
-                "Got different lengh of SAS parameters: len(%s) - Expected len(%s)"
-                % (params_sas1, params_sas2)
+                "Got different lengh of SAS parameters: len(%s) - Expected len(%s)",
+                params_sas1,
+                params_sas2,
             )
             return False
 
         # Parameters values differs
         for k, v in params_sas1.items():
             if v != params_sas2.get(k, None):
-                log.debug("The SAS parameter %s doesn't match %s." % (v, params_sas2.get(k, None)))
+                log.debug("The SAS parameter %s doesn't match %s.", v, params_sas2.get(k, None))
                 return False
 
     # Equivalent SAS
@@ -203,8 +223,8 @@ def is_azure_job_not_complete(job_details: ConfigureStatus) -> bool:
     Returns:
         bool: False if job completed, True otherwise
     """
-    log.debug(f"Checking if the job \"{job_details.job_id}\" is still running")
-    log.debug(f"job {job_details.job_id} is in {job_details.job_status} state")
+    log.debug("Checking if the job \"%s\" is still running", job_details.job_id)
+    log.debug("job %s is in %s state", job_details.job_id, job_details.job_status)
     if job_details.job_status != "completed":
         return True
     return False
@@ -556,16 +576,18 @@ def set_new_sas_disk_version(
     Returns:
         The changed disk version with the given source.
     """
+    log.info("Setting up a new SAS disk version for \"%s\"", metadata.image_path)
     # If we already have a VMImageDefinition let's use it
     if disk_version.vm_images:
-        log.debug("The DiskVersion \"%s\" contains inner images." % disk_version.version_number)
+        log.debug("The DiskVersion \"%s\" contains inner images.", disk_version.version_number)
         img, img_legacy = vm_images_by_generation(disk_version, metadata.architecture)
 
         # Now we replace the SAS URI for the vm_images
-        log.debug(
+        log.info(
             "Adjusting the VMImages from existing DiskVersion \"%s\""
-            "to fit the new image with SAS \"%s\"."
-            % (disk_version.version_number, metadata.image_path)
+            "to fit the new image with SAS \"%s\".",
+            disk_version.version_number,
+            metadata.image_path,
         )
         disk_version.vm_images = prepare_vm_images(
             metadata=metadata,
@@ -577,11 +599,12 @@ def set_new_sas_disk_version(
     # If no VMImages, we need to create them from scratch
     else:
         log.debug(
-            "The DiskVersion \"%s\" does not contain inner images." % disk_version.version_number
+            "The DiskVersion \"%s\" does not contain inner images.", disk_version.version_number
         )
-        log.debug(
-            "Setting the new image \"%s\" on DiskVersion \"%s\"."
-            % (metadata.image_path, disk_version.version_number)
+        log.info(
+            "Setting the new image \"%s\" on DiskVersion \"%s\".",
+            metadata.image_path,
+            disk_version.version_number,
         )
         disk_version.vm_images = create_vm_image_definitions(metadata, source)
 
@@ -591,4 +614,4 @@ def set_new_sas_disk_version(
 def logdiff(diff: DeepDiff) -> None:
     """Log the offer diff if it exists."""
     if diff:
-        log.warning(f"Found the following offer diff before publishing:\n{diff.pretty()}")
+        log.warning("Found the following offer diff before publishing:\n%s", diff.pretty())

{cloudpub-1.5.0.dist-info → cloudpub-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudpub
-Version: 1.5.0
+Version: 1.6.0
 Summary: Services for publishing products in cloud environments
 Home-page: https://github.com/release-engineering/cloudpub
 Author: Jonathan Gangi

{cloudpub-1.5.0.dist-info → cloudpub-1.6.0.dist-info}/RECORD

@@ -10,11 +10,11 @@ cloudpub/models/aws.py,sha256=arzFqLmFw8O9Otk_VatLR5dmQ9FsdWT3f0Ibap7EW0o,42850
 cloudpub/models/common.py,sha256=iZ503VVFL9y0P_wXiK0f3flXV32VWBs9i-9NoYfJZUg,4970
 cloudpub/models/ms_azure.py,sha256=nzTp9IvAW-WEJuN20IAc93yY6YPHCTE0j116EfQUsPg,55974
 cloudpub/ms_azure/__init__.py,sha256=eeYXPd_wzDBmh0Hmzd5o4yzocFzM6n4r8qpCDy00kYk,117
-cloudpub/ms_azure/service.py,sha256=cMgKcOfgW0UwPPSGGH6Iiyqz2JidrEeowiY-SHq1mSU,26589
-cloudpub/ms_azure/session.py,sha256=7ZjBLBX4XSzx60Bxhn96kh64RJ3oQs734Tw3ZVSnFrU,6349
-cloudpub/ms_azure/utils.py,sha256=h6bEtMrlPsbayR-SlVEzlzxEC1i4fdSqH8Fn-m_xaMQ,20730
-cloudpub-1.5.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-cloudpub-1.5.0.dist-info/METADATA,sha256=06r2pdV_DeEMDPue5D5iQ3rrmQe5fsEHF21zvlEFdFo,754
-cloudpub-1.5.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cloudpub-1.5.0.dist-info/top_level.txt,sha256=YnnJuTiWBpRI9zMkYUVcZNuvjzzJYblASj-7Q8m3Gzg,9
-cloudpub-1.5.0.dist-info/RECORD,,
+cloudpub/ms_azure/service.py,sha256=ySc3ktibNhMw-ZvTgTIB1EZjliYu0OYSBi8sRBlpslg,36250
+cloudpub/ms_azure/session.py,sha256=PXCSJ1dFkx43lQV0WFPnRxbpyOBccdtrMiWGPORT3Ro,6356
+cloudpub/ms_azure/utils.py,sha256=goADEmIZBFuIDG5sH9dAZed_EWIUWUAtjzDTw9HyNsI,21512
+cloudpub-1.6.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+cloudpub-1.6.0.dist-info/METADATA,sha256=bXsSCTG8RdWlsD5SjlqYrWgxsOQKOL5bRwk-fVVVP6Y,754
+cloudpub-1.6.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cloudpub-1.6.0.dist-info/top_level.txt,sha256=YnnJuTiWBpRI9zMkYUVcZNuvjzzJYblASj-7Q8m3Gzg,9
+cloudpub-1.6.0.dist-info/RECORD,,