Merge pull request #146 from release-engineering/draft_to_preview

Azure: ensure draft is published when SAS found

Author: JAVGan

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
@@ -71,6 +72,15 @@
 ]
 
 
+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."""
 
@@ -570,7 +580,7 @@ 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:
-            ``preview`` -> ``live`` -> ``draft``
+        ``live`` -> ``preview`` -> ``draft``
 
         Args:
             product_id (str)
@@ -579,7 +589,7 @@ def compute_targets(self, product_id: str) -> List[str]:
         Returns:
             List[Str]: The ordered list with targets to lookup.
         """
-        all_targets = ["preview", "live", "draft"]
+        all_targets = ["live", "preview", "draft"]
         computed_targets = []
 
         # We cannot simply return all targets above because the existing product might
@@ -622,7 +632,7 @@ 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.
 
@@ -634,19 +644,6 @@ def _publish_preview(
             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 self._is_submission_in_preview(submission):
-            log.info("The product \"%s\" is already set to preview", product_name)
-            return
-
         res = self.submit_to_status(product_id=product.id, status='preview', resources=resources)
 
         if res.job_result != 'succeeded' or not self.get_submission_state(
@@ -817,7 +814,7 @@ def publish(self, metadata: AzurePublishingMetadata) -> None:
         product_name = metadata.destination.split("/")[0]
         plan_name = metadata.destination.split("/")[-1]
         product_id = self.get_productid(product_name)
-        disk_version = None
+        sas_in_target = SasFoundStatus.missing
         log.info(
             "Preparing to associate the image \"%s\" with the plan \"%s\" from product \"%s\"",
             metadata.image_path,
@@ -838,7 +835,6 @@ def publish(self, metadata: AzurePublishingMetadata) -> None:
             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"]
-            disk_version = tech_config.disk_versions[0]  # only 1 as it was overwritten
         else:
             # 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.
@@ -849,6 +845,7 @@ def publish(self, metadata: AzurePublishingMetadata) -> None:
                 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
@@ -862,10 +859,10 @@ def publish(self, metadata: AzurePublishingMetadata) -> None:
                     metadata.image_path,
                 )
                 dv = seek_disk_version(tech_config, metadata.disk_version)
-                disk_version = self._create_or_update_disk_version(res, source, dv)
+                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:
+        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,
@@ -892,7 +889,7 @@ def publish(self, metadata: AzurePublishingMetadata) -> None:
 
             # We should only publish if there are new changes OR
             # the existing offer was already in preview
-            if disk_version or self._is_submission_in_preview(submission):
+            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
                 )
@@ -905,8 +902,10 @@ def publish(self, metadata: AzurePublishingMetadata) -> None:
                 modular_resources = None
                 if metadata.modular_push:
                     modular_resources = self.get_modular_resources_to_publish(product, tech_config)
-                self._publish_preview(product, product_name, resources=modular_resources)
-                self._publish_live(product, product_name)
+                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)
 
         log.info(
             "Finished publishing the image \"%s\" to \"%s\"",

tests/ms_azure/test_service.py

@@ -161,7 +161,7 @@ def test_get_product_id_not_found(
     @pytest.mark.parametrize(
         "targets_list",
         [
-            ["preview", "live", "draft"],
+            ["live", "preview", "draft"],
             ["live", "draft"],
             ["preview", "draft"],
             ["draft"],
@@ -1651,6 +1651,86 @@ def test_publish_live_arm64_only(
         mock_submit.assert_has_calls(submit_calls)
         mock_ensure_publish.assert_called_once_with(product_obj.id)
 
+    @mock.patch("cloudpub.ms_azure.AzureService._publish_live")
+    @mock.patch("cloudpub.ms_azure.AzureService._publish_preview")
+    @mock.patch("cloudpub.ms_azure.AzureService.ensure_can_publish")
+    @mock.patch("cloudpub.ms_azure.AzureService._create_or_update_disk_version")
+    @mock.patch("cloudpub.ms_azure.AzureService._overwrite_disk_version")
+    @mock.patch("cloudpub.ms_azure.AzureService.compute_targets")
+    @mock.patch("cloudpub.ms_azure.AzureService.get_productid")
+    @mock.patch("cloudpub.ms_azure.AzureService.configure")
+    def test_publish_live_when_sas_is_present_in_draft(
+        self,
+        mock_configure: mock.MagicMock,
+        mock_get_productid: mock.MagicMock,
+        mock_compute_targets: mock.MagicMock,
+        mock_create_diskversion: mock.MagicMock,
+        mock_overwrite: mock.MagicMock,
+        mock_ensure_can_publish: mock.MagicMock,
+        mock_publish_preview: mock.MagicMock,
+        mock_publish_live: mock.MagicMock,
+        token: Dict[str, Any],
+        auth_dict: Dict[str, Any],
+        configure_success_response: Dict[str, Any],
+        product: Dict[str, Any],
+        products_list: Dict[str, Any],
+        product_summary: Dict[str, Any],
+        metadata_azure_obj: mock.MagicMock,
+        vmimage_source: Dict[str, Any],
+        caplog: pytest.LogCaptureFixture,
+    ) -> None:
+        """Ensure live publish works as expected when the SAS is already present as draft."""
+        # Prepare testing data
+        metadata_azure_obj.keepdraft = False
+        metadata_azure_obj.destination = "example-product/plan-1"
+        # SAS URI will be already present during draft
+        metadata_azure_obj.image_path = vmimage_source["osDisk"]["uri"]
+
+        # targets
+        mock_get_productid.return_value = "fake-id"
+        targets = ["draft"]
+        mock_compute_targets.return_value = targets
+
+        # Constants
+        login_url = "https://login.microsoftonline.com/foo/oauth2/token"
+        base_url = "https://graph.microsoft.com/rp/product-ingestion"
+        product_id = str(product_summary['id']).split("/")[-1]
+
+        mock_configure.return_value = ConfigureStatus.from_json(configure_success_response)
+
+        # Constants
+        login_url = "https://login.microsoftonline.com/foo/oauth2/token"
+        base_url = "https://graph.microsoft.com/rp/product-ingestion"
+        product_id = str(product_summary['id']).split("/")[-1]
+
+        # Test
+        with caplog.at_level(logging.INFO):
+            with requests_mock.Mocker() as m:
+                m.post(login_url, json=token)
+                m.get(f"{base_url}/product", json=products_list)
+                m.get(f"{base_url}/resource-tree/product/{product_id}", json=product)
+                azure_svc = AzureService(auth_dict)
+                azure_svc.publish(metadata=metadata_azure_obj)
+
+        # Present messages
+        assert (
+            "Requesting the product ID \"ffffffff-ffff-ffff-ffff-ffffffffffff\""
+            " with state \"draft\"."
+        ) in caplog.messages
+        assert (
+            "Retrieving the technical config for \"example-product/plan-1\" on \"draft\"."
+            in caplog.messages
+        )
+        assert (
+            "The destination \"example-product/plan-1\" on \"draft\" "
+            "already contains the SAS URI: \"https://uri.test.com\"."
+        ) in caplog.messages
+        mock_publish_preview.assert_called_once()
+        mock_publish_live.assert_called_once()
+        mock_ensure_can_publish.assert_called_once()
+        mock_create_diskversion.assert_not_called()
+        mock_overwrite.assert_not_called()
+
     @mock.patch("cloudpub.ms_azure.AzureService.compute_targets")
     @mock.patch("cloudpub.ms_azure.AzureService.get_productid")
     def test_publish_live_when_state_is_preview(
@@ -1761,7 +1841,6 @@ def test_publish_live_when_state_is_preview(
             'Looking up for submission in state "live" for "ffffffff-ffff-ffff-ffff-ffffffffffff"'
             in caplog.text
         )
-        assert 'The product "example-product" is already set to preview' in caplog.text
         assert (
             'Submitting the status of "ffffffff-ffff-ffff-ffff-ffffffffffff" to "live"'
             in caplog.text