4/26 release: Up with --repo/--browse, exec (ssh) command, replica commands, log streaming commands

src/containerapp/HISTORY.rst

@@ -3,6 +3,13 @@
 Release History
 ===============
 
+0.4.0
+++++++
+* Create or update a container app and all associated resources (container app environment, ACR, Github Actions, resource group, etc.) with 'az containerapp up'
+* Open an ssh-like shell in a Container App with 'az containerapp exec'
+* Support for log streaming with 'az containerapp logs show'
+* Replica show and list commands
+
 0.3.1
 ++++++
 * Update "az containerapp github-action add" parameters: replace --docker-file-path with --context-path, add --image.

src/containerapp/azext_containerapp/_acr_run_polling.py

@@ -0,0 +1,112 @@
+# --------------------------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# --------------------------------------------------------------------------------------------
+# pylint: disable=line-too-long, consider-using-f-string
+
+import time
+
+from msrest import Deserializer
+from msrestazure.azure_exceptions import CloudError
+from azure.cli.core.profiles import ResourceType
+from azure.cli.command_modules.acr._constants import get_acr_task_models
+from azure.core.polling import PollingMethod, LROPoller
+
+
+def get_run_with_polling(cmd,
+                         client,
+                         run_id,
+                         registry_name,
+                         resource_group_name):
+    deserializer = Deserializer(
+        {k: v for k, v in get_acr_task_models(cmd).__dict__.items() if isinstance(v, type)})
+
+    def deserialize_run(response):
+        return deserializer('Run', response)
+
+    return LROPoller(
+        client=client,
+        initial_response=client.get(
+            resource_group_name, registry_name, run_id, cls=lambda x, y, z: x),
+        deserialization_callback=deserialize_run,
+        polling_method=RunPolling(
+            cmd=cmd,
+            registry_name=registry_name,
+            run_id=run_id
+        ))
+
+
+class RunPolling(PollingMethod):  # pylint: disable=too-many-instance-attributes
+
+    def __init__(self, cmd, registry_name, run_id, timeout=30):
+        self._cmd = cmd
+        self._registry_name = registry_name
+        self._run_id = run_id
+        self._timeout = timeout
+        self._client = None
+        self._response = None  # Will hold latest received response
+        self._url = None  # The URL used to get the run
+        self._deserialize = None  # The deserializer for Run
+        self.operation_status = ""
+        self.operation_result = None
+
+    def initialize(self, client, initial_response, deserialization_callback):
+        self._client = client._client  # pylint: disable=protected-access
+        self._response = initial_response
+        self._url = initial_response.http_request.url
+        self._deserialize = deserialization_callback
+
+        self._set_operation_status(initial_response)
+
+    def run(self):
+        while not self.finished():
+            time.sleep(self._timeout)
+            self._update_status()
+
+        if self.operation_status not in get_succeeded_run_status(self._cmd):
+            from knack.util import CLIError
+            raise CLIError("The run with ID '{}' finished with unsuccessful status '{}'. "
+                           "Show run details by 'az acr task show-run -r {} --run-id {}'. "
+                           "Show run logs by 'az acr task logs -r {} --run-id {}'.".format(
+                               self._run_id,
+                               self.operation_status,
+                               self._registry_name,
+                               self._run_id,
+                               self._registry_name,
+                               self._run_id
+                           ))
+
+    def status(self):
+        return self.operation_status
+
+    def finished(self):
+        return self.operation_status in get_finished_run_status(self._cmd)
+
+    def resource(self):
+        return self.operation_result
+
+    def _set_operation_status(self, response):
+        if response.http_response.status_code == 200:
+            self.operation_result = self._deserialize(response)
+            self.operation_status = self.operation_result.status
+            return
+        raise CloudError(response)
+
+    def _update_status(self):
+        self._response = self._client._pipeline.run(  # pylint: disable=protected-access
+            self._client.get(self._url), stream=False)
+        self._set_operation_status(self._response)
+
+
+def get_succeeded_run_status(cmd):
+    RunStatus = cmd.get_models('RunStatus', resource_type=ResourceType.MGMT_CONTAINERREGISTRY, operation_group='task_runs')
+    return [RunStatus.succeeded.value]
+
+
+def get_finished_run_status(cmd):
+    RunStatus = cmd.get_models('RunStatus', resource_type=ResourceType.MGMT_CONTAINERREGISTRY, operation_group='task_runs')
+    return [RunStatus.succeeded.value,
+            RunStatus.failed.value,
+            RunStatus.canceled.value,
+            RunStatus.error.value,
+            RunStatus.timeout.value]

src/containerapp/azext_containerapp/_archive_utils.py

@@ -0,0 +1,242 @@
+# --------------------------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# --------------------------------------------------------------------------------------------
+
+import tarfile
+import os
+import re
+import codecs
+from io import open
+import requests
+from knack.log import get_logger
+from knack.util import CLIError
+from msrestazure.azure_exceptions import CloudError
+from azure.cli.core.profiles import ResourceType, get_sdk
+from azure.cli.command_modules.acr._azure_utils import get_blob_info
+from azure.cli.command_modules.acr._constants import TASK_VALID_VSTS_URLS
+
+logger = get_logger(__name__)
+
+
+def upload_source_code(cmd, client,
+                       registry_name,
+                       resource_group_name,
+                       source_location,
+                       tar_file_path,
+                       docker_file_path,
+                       docker_file_in_tar):
+    _pack_source_code(source_location,
+                      tar_file_path,
+                      docker_file_path,
+                      docker_file_in_tar)
+
+    size = os.path.getsize(tar_file_path)
+    unit = 'GiB'
+    for S in ['Bytes', 'KiB', 'MiB', 'GiB']:
+        if size < 1024:
+            unit = S
+            break
+        size = size / 1024.0
+
+    logger.info("Uploading archived source code from '%s'...", tar_file_path)
+    upload_url = None
+    relative_path = None
+    try:
+        source_upload_location = client.get_build_source_upload_url(
+            resource_group_name, registry_name)
+        upload_url = source_upload_location.upload_url
+        relative_path = source_upload_location.relative_path
+    except (AttributeError, CloudError) as e:
+        raise CLIError("Failed to get a SAS URL to upload context. Error: {}".format(e.message))
+
+    if not upload_url:
+        raise CLIError("Failed to get a SAS URL to upload context.")
+
+    account_name, endpoint_suffix, container_name, blob_name, sas_token = get_blob_info(upload_url)
+    BlockBlobService = get_sdk(cmd.cli_ctx, ResourceType.DATA_STORAGE, 'blob#BlockBlobService')
+    BlockBlobService(account_name=account_name,
+                     sas_token=sas_token,
+                     endpoint_suffix=endpoint_suffix,
+                     # Increase socket timeout from default of 20s for clients with slow network connection.
+                     socket_timeout=300).create_blob_from_path(
+                         container_name=container_name,
+                         blob_name=blob_name,
+                         file_path=tar_file_path)
+    logger.info("Sending context ({0:.3f} {1}) to registry: {2}...".format(
+        size, unit, registry_name))
+    return relative_path
+
+
+def _pack_source_code(source_location, tar_file_path, docker_file_path, docker_file_in_tar):
+    logger.info("Packing source code into tar to upload...")
+
+    original_docker_file_name = os.path.basename(docker_file_path.replace("\\", os.sep))
+    ignore_list, ignore_list_size = _load_dockerignore_file(source_location, original_docker_file_name)
+    common_vcs_ignore_list = {'.git', '.gitignore', '.bzr', 'bzrignore', '.hg', '.hgignore', '.svn'}
+
+    def _ignore_check(tarinfo, parent_ignored, parent_matching_rule_index):
+        # ignore common vcs dir or file
+        if tarinfo.name in common_vcs_ignore_list:
+            logger.info("Excluding '%s' based on default ignore rules", tarinfo.name)
+            return True, parent_matching_rule_index
+
+        if ignore_list is None:
+            # if .dockerignore doesn't exists, inherit from parent
+            # eg, it will ignore the files under .git folder.
+            return parent_ignored, parent_matching_rule_index
+
+        for index, item in enumerate(ignore_list):
+            # stop checking the remaining rules whose priorities are lower than the parent matching rule
+            # at this point, current item should just inherit from parent
+            if index >= parent_matching_rule_index:
+                break
+            if re.match(item.pattern, tarinfo.name):
+                logger.debug(".dockerignore: rule '%s' matches '%s'.",
+                             item.rule, tarinfo.name)
+                return item.ignore, index
+
+        logger.debug(".dockerignore: no rule for '%s'. parent ignore '%s'",
+                     tarinfo.name, parent_ignored)
+        # inherit from parent
+        return parent_ignored, parent_matching_rule_index
+
+    with tarfile.open(tar_file_path, "w:gz") as tar:
+        # need to set arcname to empty string as the archive root path
+        _archive_file_recursively(tar,
+                                  source_location,
+                                  arcname="",
+                                  parent_ignored=False,
+                                  parent_matching_rule_index=ignore_list_size,
+                                  ignore_check=_ignore_check)
+
+        # Add the Dockerfile if it's specified.
+        # In the case of run, there will be no Dockerfile.
+        if docker_file_path:
+            docker_file_tarinfo = tar.gettarinfo(
+                docker_file_path, docker_file_in_tar)
+            with open(docker_file_path, "rb") as f:
+                tar.addfile(docker_file_tarinfo, f)
+
+
+class IgnoreRule:  # pylint: disable=too-few-public-methods
+    def __init__(self, rule):
+
+        self.rule = rule
+        self.ignore = True
+        # ! makes exceptions to exclusions
+        if rule.startswith('!'):
+            self.ignore = False
+            rule = rule[1:]  # remove !
+            # load path without leading slash in linux and windows
+            # environments (interferes with dockerignore file)
+            if rule.startswith('/'):
+                rule = rule[1:]  # remove beginning '/'
+
+        self.pattern = "^"
+        tokens = rule.split('/')
+        token_length = len(tokens)
+        for index, token in enumerate(tokens, 1):
+            # ** matches any number of directories
+            if token == "**":
+                self.pattern += ".*"  # treat **/ as **
+            else:
+                # * matches any sequence of non-seperator characters
+                # ? matches any single non-seperator character
+                # . matches dot character
+                self.pattern += token.replace(
+                    "*", "[^/]*").replace("?", "[^/]").replace(".", "\\.")
+                if index < token_length:
+                    self.pattern += "/"  # add back / if it's not the last
+        self.pattern += "$"
+
+
+def _load_dockerignore_file(source_location, original_docker_file_name):
+    # reference: https://docs.docker.com/engine/reference/builder/#dockerignore-file
+    docker_ignore_file = os.path.join(source_location, ".dockerignore")
+    docker_ignore_file_override = None
+    if original_docker_file_name != "Dockerfile":
+        docker_ignore_file_override = os.path.join(
+            source_location, "{}.dockerignore".format(original_docker_file_name))
+        if os.path.exists(docker_ignore_file_override):
+            logger.info("Overriding .dockerignore with %s", docker_ignore_file_override)
+            docker_ignore_file = docker_ignore_file_override
+
+    if not os.path.exists(docker_ignore_file):
+        return None, 0
+
+    encoding = "utf-8"
+    header = open(docker_ignore_file, "rb").read(len(codecs.BOM_UTF8))
+    if header.startswith(codecs.BOM_UTF8):
+        encoding = "utf-8-sig"
+
+    ignore_list = []
+    if docker_ignore_file == docker_ignore_file_override:
+        ignore_list.append(IgnoreRule(".dockerignore"))
+
+    for line in open(docker_ignore_file, 'r', encoding=encoding).readlines():
+        rule = line.rstrip()
+
+        # skip empty line and comment
+        if not rule or rule.startswith('#'):
+            continue
+
+        # the ignore rule at the end has higher priority
+        ignore_list = [IgnoreRule(rule)] + ignore_list
+
+    return ignore_list, len(ignore_list)
+
+
+def _archive_file_recursively(tar, name, arcname, parent_ignored, parent_matching_rule_index, ignore_check):
+    # create a TarInfo object from the file
+    tarinfo = tar.gettarinfo(name, arcname)
+
+    if tarinfo is None:
+        raise CLIError("tarfile: unsupported type {}".format(name))
+
+    # check if the file/dir is ignored
+    ignored, matching_rule_index = ignore_check(
+        tarinfo, parent_ignored, parent_matching_rule_index)
+
+    if not ignored:
+        # append the tar header and data to the archive
+        if tarinfo.isreg():
+            with open(name, "rb") as f:
+                tar.addfile(tarinfo, f)
+        else:
+            tar.addfile(tarinfo)
+
+    # even the dir is ignored, its child items can still be included, so continue to scan
+    if tarinfo.isdir():
+        for f in os.listdir(name):
+            _archive_file_recursively(tar, os.path.join(name, f), os.path.join(arcname, f),
+                                      parent_ignored=ignored, parent_matching_rule_index=matching_rule_index,
+                                      ignore_check=ignore_check)
+
+
+def check_remote_source_code(source_location):
+    lower_source_location = source_location.lower()
+
+    # git
+    if lower_source_location.startswith("git@") or lower_source_location.startswith("git://"):
+        return source_location
+
+    # http
+    if lower_source_location.startswith("https://") or lower_source_location.startswith("http://") \
+       or lower_source_location.startswith("github.com/"):
+        isVSTS = any(url in lower_source_location for url in TASK_VALID_VSTS_URLS)
+        if isVSTS or re.search(r"\.git(?:#.+)?$", lower_source_location):
+            # git url must contain ".git" or be from VSTS/Azure DevOps.
+            # This is because Azure DevOps doesn't follow the standard git server convention of putting
+            # .git at the end of their URLs, so we have to special case them.
+            return source_location
+        if not lower_source_location.startswith("github.com/"):
+            # Others are tarball
+            if requests.head(source_location).status_code < 400:
+                return source_location
+            raise CLIError("'{}' doesn't exist.".format(source_location))
+
+    # oci
+    if lower_source_location.startswith("oci://"):
+        return source_location
+    raise CLIError("'{}' doesn't exist.".format(source_location))