shellfoundry 1.2.25__py3-none-any.whl

shellfoundry/utilities/shell_package_builder.py

@@ -0,0 +1,149 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+import os
+import shutil
+from io import open
+
+import click
+import yaml
+
+from shellfoundry.utilities.archive_creator import ArchiveCreator
+from shellfoundry.utilities.shell_package import ShellPackage
+from shellfoundry.utilities.temp_dir_context import TempDirContext
+
+
+class ShellPackageBuilder(object):
+    DRIVER_DIR = "src"
+    DEPLOY_DIR = "deployments"
+
+    def pack(self, path):
+        """Creates TOSCA based Shell package."""
+        self._remove_all_pyc(path)
+        shell_package = ShellPackage(path)
+        shell_name = shell_package.get_shell_name()
+        shell_real_name = shell_package.get_name_from_definition()
+        with TempDirContext(shell_name) as package_path:
+            self._copy_tosca_meta(package_path, "")
+            tosca_meta = self._read_tosca_meta(path)
+
+            shell_definition_path = tosca_meta["Entry-Definitions"]
+
+            self._copy_shell_definition(package_path, "", shell_definition_path)
+
+            with open(shell_definition_path, encoding="utf8") as shell_definition_file:
+                shell_definition = yaml.safe_load(shell_definition_file)
+
+                if "template_icon" in shell_definition["metadata"]:
+                    self._copy_artifact(
+                        shell_definition["metadata"]["template_icon"], package_path
+                    )
+
+                for node_type in list(shell_definition["node_types"].values()):
+                    if "artifacts" not in node_type:
+                        continue
+
+                    artifact_path_list = []
+                    for artifact_name, artifact in node_type["artifacts"].items():
+                        if artifact_name == "driver":
+                            artifact_path_list.append(
+                                self._create_driver(
+                                    path="",
+                                    package_path=os.curdir,
+                                    dir_path=self.DRIVER_DIR,
+                                    driver_name=os.path.basename(artifact["file"]),
+                                )
+                            )
+                        elif artifact_name == "deployment":
+                            artifact_path_list.append(
+                                self._create_driver(
+                                    path="",
+                                    package_path=os.curdir,
+                                    dir_path=self.DEPLOY_DIR,
+                                    driver_name=os.path.basename(artifact["file"]),
+                                    mandatory=False,
+                                )
+                            )
+
+                        self._copy_artifact(artifact["file"], package_path)
+
+            zip_path = self._zip_package(package_path, "", shell_real_name)
+
+            try:
+                self._remove_build_artifacts(artifact_path_list)
+            except Exception:
+                pass
+
+            click.echo("Shell package was successfully created: " + zip_path)
+
+    def _copy_artifact(self, artifact_path, package_path):
+        if os.path.exists(artifact_path):
+            click.echo("Adding artifact to shell package: " + artifact_path)
+            self._copy_file(src_file_path=artifact_path, dest_dir_path=package_path)
+        else:
+            click.echo("Missing artifact not added to shell package: " + artifact_path)
+
+    def _read_tosca_meta(self, path):
+        tosca_meta = {}
+        shell_package = ShellPackage(path)
+        with open(shell_package.get_metadata_path(), encoding="utf8") as meta_file:
+            for meta_line in meta_file:
+                (key, val) = meta_line.split(":")
+                tosca_meta[key] = val.strip()
+        return tosca_meta
+
+    def _copy_shell_icon(self, package_path, path):
+        self._copy_file(
+            src_file_path=os.path.join(path, "shell-icon.png"),
+            dest_dir_path=package_path,
+        )
+
+    def _copy_shell_definition(self, package_path, path, shell_definition):
+        self._copy_file(
+            src_file_path=os.path.join(path, shell_definition),
+            dest_dir_path=package_path,
+        )
+
+    def _copy_tosca_meta(self, package_path, path):
+        shell_package = ShellPackage(path)
+        self._copy_file(
+            src_file_path=shell_package.get_metadata_path(),
+            dest_dir_path=os.path.join(package_path, "TOSCA-Metadata"),
+        )
+
+    @staticmethod
+    def _remove_all_pyc(package_path):
+        for root, dirs, files in os.walk(package_path):
+            for file in files:
+                if file.endswith(".pyc"):
+                    os.remove(os.path.join(root, file))
+
+    @staticmethod
+    def _create_driver(path, package_path, dir_path, driver_name, mandatory=True):
+        dir_to_zip = os.path.join(path, dir_path)
+        if os.path.exists(dir_to_zip):
+            zip_file_path = os.path.join(package_path, driver_name)
+            ArchiveCreator.make_archive(zip_file_path, "zip", dir_to_zip)
+            return os.path.abspath(zip_file_path)
+        elif mandatory:
+            raise click.ClickException(
+                "Invalid driver structure. Can't find '{}' driver folder.".format(
+                    dir_path
+                )
+            )
+
+    @staticmethod
+    def _copy_file(src_file_path, dest_dir_path):
+        if not os.path.exists(dest_dir_path):
+            os.makedirs(dest_dir_path)
+        shutil.copy(src_file_path, dest_dir_path)
+
+    @staticmethod
+    def _zip_package(package_path, path, package_name):
+        zip_file_path = os.path.join(path, "dist", package_name)
+        return ArchiveCreator.make_archive(zip_file_path, "zip", package_path)
+
+    @staticmethod
+    def _remove_build_artifacts(artifacts_path_list):
+        for artifact_path in artifacts_path_list:
+            if artifact_path and os.path.exists(artifact_path):
+                os.remove(artifact_path)

shellfoundry/utilities/shell_package_installer.py

@@ -0,0 +1,231 @@
+#!/usr/bin/python
+
+import json
+import os
+import time
+
+import click
+
+try:
+    from urllib.error import HTTPError
+except ImportError:
+    from urllib2 import HTTPError
+
+from cloudshell.rest.api import PackagingRestApiClient
+
+try:
+    from cloudshell.rest.exceptions import FeatureUnavailable, ShellNotFound
+except ImportError:
+    from cloudshell.rest.exceptions import (
+        FeatureUnavailable,
+        ShellNotFoundException as ShellNotFound,
+    )
+
+from shellfoundry.exceptions import FatalError
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+from shellfoundry.utilities.constants import (
+    CLOUDSHELL_MAX_RETRIES,
+    CLOUDSHELL_RETRY_INTERVAL_SEC,
+    DEFAULT_TIME_WAIT,
+)
+from shellfoundry.utilities.shell_package import ShellPackage
+
+SHELL_IS_OFFICIAL_FLAG = "IsOfficial"
+
+
+class ShellPackageInstaller(object):
+    GLOBAL_DOMAIN = "Global"
+
+    def __init__(self):
+        self.cloudshell_config_reader = Configuration(CloudShellConfigReader())
+
+    def install(self, path):
+        """Install new or Update existed Shell."""
+        shell_package = ShellPackage(path)
+        shell_name = shell_package.get_name_from_definition()
+        shell_filename = shell_name + ".zip"
+        package_full_path = os.path.join(path, "dist", shell_filename)
+
+        cloudshell_config = self.cloudshell_config_reader.read()
+
+        if cloudshell_config.domain != self.GLOBAL_DOMAIN:
+            raise click.UsageError(
+                "Gen2 shells could not be installed into non Global domain."
+            )
+
+        cs_connection_label = "Connecting to CloudShell at {}:{}".format(
+            cloudshell_config.host, cloudshell_config.port
+        )
+        with click.progressbar(
+            length=CLOUDSHELL_MAX_RETRIES, show_eta=False, label=cs_connection_label
+        ) as pbar:
+            try:
+                client = self._open_connection_to_quali_server(
+                    cloudshell_config, pbar, retry=CLOUDSHELL_MAX_RETRIES
+                )
+            finally:
+                self._render_pbar_finish(pbar)
+
+        try:
+            is_official = client.get_shell(shell_name=shell_name).get(
+                SHELL_IS_OFFICIAL_FLAG, False
+            )
+
+            if is_official:
+                click.confirm(
+                    text="Upgrading to a custom version of the shell will limit you "
+                    "only to customized versions of this shell from now on. "
+                    "You won't be able to upgrade it to an official version of the shell in the future."  # noqa: E501
+                    "\nDo you wish to continue?",
+                    abort=True,
+                )
+
+        except FeatureUnavailable:
+            # try to update shell first
+            pass
+        except ShellNotFound:
+            # try to install shell
+            pass
+        except click.Abort:
+            raise
+        except Exception as e:
+            raise FatalError(
+                self._parse_installation_error(
+                    "Failed to get information about installed shell", e
+                )
+            )
+
+        pbar_install_shell_len = 2  # amount of possible actions (update and add)
+        installation_label = "Installing shell into CloudShell".ljust(
+            len(cs_connection_label)
+        )
+        with click.progressbar(
+            length=pbar_install_shell_len, show_eta=False, label=installation_label
+        ) as pbar:
+            try:
+                client.update_shell(package_full_path)
+            except ShellNotFound:
+                self._increase_pbar(pbar, DEFAULT_TIME_WAIT)
+                self._add_new_shell(client, package_full_path)
+            except Exception as e:
+                self._increase_pbar(pbar, DEFAULT_TIME_WAIT)
+                raise FatalError(
+                    self._parse_installation_error("Failed to update shell", e)
+                )
+            finally:
+                self._render_pbar_finish(pbar)
+
+    def delete(self, shell_name):
+        """Delete Shell."""
+        cloudshell_config = self.cloudshell_config_reader.read()
+
+        if cloudshell_config.domain != self.GLOBAL_DOMAIN:
+            raise click.UsageError(
+                "Gen2 shells could not be deleted from non Global domain."
+            )
+
+        cs_connection_label = "Connecting to CloudShell at {}:{}".format(
+            cloudshell_config.host, cloudshell_config.port
+        )
+        with click.progressbar(
+            length=CLOUDSHELL_MAX_RETRIES, show_eta=False, label=cs_connection_label
+        ) as pbar:
+            try:
+                client = self._open_connection_to_quali_server(
+                    cloudshell_config, pbar, retry=CLOUDSHELL_MAX_RETRIES
+                )
+            finally:
+                self._render_pbar_finish(pbar)
+
+        pbar_install_shell_len = 2  # amount of possible actions (update and add)
+        installation_label = "Deleting shell from CloudShell".ljust(
+            len(cs_connection_label)
+        )
+        with click.progressbar(
+            length=pbar_install_shell_len, show_eta=False, label=installation_label
+        ) as pbar:
+            try:
+                client.delete_shell(shell_name)
+            except FeatureUnavailable:
+                self._increase_pbar(pbar, DEFAULT_TIME_WAIT)
+                raise click.ClickException(
+                    "Delete shell command unavailable (probably due to CloudShell version below 9.2)"  # noqa: E501
+                )
+            except ShellNotFound:
+                self._increase_pbar(pbar, DEFAULT_TIME_WAIT)
+                raise click.ClickException(
+                    "Shell '{shell_name}' doesn't exist on CloudShell".format(
+                        shell_name=shell_name
+                    )
+                )
+            except Exception as e:
+                self._increase_pbar(pbar, DEFAULT_TIME_WAIT)
+                raise click.ClickException(
+                    self._parse_installation_error("Failed to delete shell", e)
+                )
+            finally:
+                self._render_pbar_finish(pbar)
+
+    def _open_connection_to_quali_server(self, cloudshell_config, pbar, retry):
+        if retry == 0:
+            raise FatalError(
+                "Connection to CloudShell Server failed. "
+                "Please make sure it is up and running properly."
+            )
+        try:
+            try:
+                client = PackagingRestApiClient.login(
+                    host=cloudshell_config.host,
+                    port=cloudshell_config.port,
+                    username=cloudshell_config.username,
+                    password=cloudshell_config.password,
+                    domain=cloudshell_config.domain,
+                )
+                return client
+            except AttributeError:
+                client = PackagingRestApiClient(
+                    ip=cloudshell_config.host,
+                    port=cloudshell_config.port,
+                    username=cloudshell_config.username,
+                    password=cloudshell_config.password,
+                    domain=cloudshell_config.domain,
+                )
+                return client
+        except HTTPError as e:
+            if e.code == 401:
+                raise FatalError(
+                    "Login to CloudShell failed. "
+                    "Please verify the credentials in the config"
+                )
+            raise FatalError(
+                "Connection to CloudShell Server failed. "
+                "Please make sure it is up and running properly."
+            )
+        except Exception:
+            self._increase_pbar(pbar, time_wait=CLOUDSHELL_RETRY_INTERVAL_SEC)
+            return self._open_connection_to_quali_server(
+                cloudshell_config, pbar, retry - 1
+            )
+
+    def _add_new_shell(self, client, package_full_path):
+        try:
+            client.add_shell(package_full_path)
+        except Exception as e:
+            raise FatalError(
+                self._parse_installation_error("Failed to add new shell", e)
+            )
+
+    def _parse_installation_error(self, base_message, error):
+        try:
+            cs_message = json.loads(str(error))["Message"]
+        except Exception:
+            cs_message = ""
+        return "{}. CloudShell responded with: '{}'".format(base_message, cs_message)
+
+    def _increase_pbar(self, pbar, time_wait):
+        time.sleep(time_wait)
+        pbar.make_step(1)
+
+    def _render_pbar_finish(self, pbar):
+        pbar.finish()
+        pbar.render_progress()

shellfoundry/utilities/standards/__init__.py

@@ -0,0 +1,3 @@
+from .consts import STANDARD_NAME_KEY, VERSIONS_KEY  # noqa: F401
+from .standards_retriever import Standards  # noqa: F401
+from .standards_versions import StandardVersions, StandardVersionsFactory  # noqa: F401

shellfoundry/utilities/standards/consts.py

@@ -0,0 +1,2 @@
+STANDARD_NAME_KEY = "StandardName"
+VERSIONS_KEY = "Versions"

shellfoundry/utilities/standards/standards_retriever.py

@@ -0,0 +1,32 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import json
+from io import open
+
+from ..cloudshell_api import create_cloudshell_client
+
+from shellfoundry.decorators.standards import standard_transformation
+
+
+class Standards(object):
+    @standard_transformation
+    def fetch(self, **kwargs):
+        alternative = kwargs.get("alternative", None)
+        if not alternative:
+            return self._fetch_from_cloudshell()
+        return self._fetch_from_alternative_path(alternative)
+
+    @staticmethod
+    def _fetch_from_cloudshell():
+        cs_client = create_cloudshell_client()
+        try:
+            return cs_client.get_installed_standards()
+        except Exception:
+            raise
+
+    @staticmethod
+    def _fetch_from_alternative_path(alternative_path):
+        with open(alternative_path, mode="r", encoding="utf8") as stream:
+            response = stream.read()
+        return json.loads(response)

shellfoundry/utilities/standards/standards_versions.py

@@ -0,0 +1,34 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from pkg_resources import parse_version
+
+
+class StandardVersionsFactory(object):
+    def create(self, standards):
+        return StandardVersions(standards)
+
+
+class StandardVersions(object):
+    def __init__(self, standards):
+        if not standards:
+            import os
+
+            from shellfoundry import __file__ as sf_file
+
+            raise Exception(
+                "Standards list is empty. Please verify that {} exists".format(
+                    os.path.join(os.path.dirname(sf_file), "data", "standards.json")
+                )
+            )
+
+        self.standards = standards
+
+    def get_latest_version(self, standard):
+        standards = self.standards.get(standard, None)
+        if standards is None:
+            raise Exception("Failed to find latest version")
+
+        latest_version = str(max(list(map(parse_version, standards))))
+        if latest_version:
+            return latest_version

shellfoundry/utilities/temp_dir_context.py

@@ -0,0 +1,17 @@
+import shutil
+import tempfile
+
+
+class TempDirContext:
+    def __init__(self, remove_dir_on_error=True, prefix=""):
+        self.temp_dir = None
+        self.prefix = prefix
+        self._remove_dir_on_error = remove_dir_on_error
+
+    def __enter__(self):
+        self.temp_dir = tempfile.mkdtemp(prefix=self.prefix)
+        return self.temp_dir
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if not exc_val or (exc_val and self._remove_dir_on_error):
+            shutil.rmtree(self.temp_dir, ignore_errors=True)