shellfoundry 1.2.25__py3-none-any.whl

shellfoundry/__init__.py

@@ -0,0 +1,8 @@
+from os.path import dirname, join
+
+ALTERNATIVE_TEMPLATES_PATH = join(dirname(__file__), "data", "templates.yml")
+ALTERNATIVE_STANDARDS_PATH = join(dirname(__file__), "data", "standards.json")
+
+MASTER_BRANCH_NAME = "master"
+
+PACKAGE_NAME = __package__.split(".")[0]

shellfoundry/__main__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+
+"""bootstrap.cli: executed when bootstrap directory is called as script."""
+from .bootstrap import cli
+
+cli()

shellfoundry/bootstrap.py

@@ -0,0 +1,169 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import click
+import pkg_resources
+
+from shellfoundry.commands.config_command import ConfigCommandExecutor
+from shellfoundry.commands.delete_command import DeleteCommandExecutor
+from shellfoundry.commands.dist_command import DistCommandExecutor
+from shellfoundry.commands.extend_command import ExtendCommandExecutor
+from shellfoundry.commands.generate_command import GenerateCommandExecutor
+from shellfoundry.commands.get_templates_command import GetTemplatesCommandExecutor
+from shellfoundry.commands.install_command import InstallCommandExecutor
+from shellfoundry.commands.list_command import ListCommandExecutor
+from shellfoundry.commands.new_command import NewCommandExecutor
+from shellfoundry.commands.pack_command import PackCommandExecutor
+from shellfoundry.commands.show_command import ShowCommandExecutor
+from shellfoundry.decorators import shellfoundry_version_check
+from shellfoundry.utilities import GEN_ONE, GEN_TWO, LAYER_ONE, NO_FILTER
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+def version():
+    """Displays the shellfoundry version."""
+    click.echo(
+        "shellfoundry version " + pkg_resources.get_distribution("shellfoundry").version
+    )
+
+
+@cli.command()  # noqa: A001
+@click.option(
+    "--gen2",
+    "default_view",
+    flag_value=GEN_TWO,
+    help="Show 2nd generation shell templates",
+)
+@click.option(
+    "--gen1",
+    "default_view",
+    flag_value=GEN_ONE,
+    help="Show 1st generation shell templates",
+)
+@click.option(
+    "--layer1", "default_view", flag_value=LAYER_ONE, help="Show layer1 shell templates"
+)
+@click.option("--all", "default_view", flag_value=NO_FILTER, help="Show all templates")
+@shellfoundry_version_check(abort_if_major=True)
+def list(default_view):  # noqa: A001
+    """Lists the available shell templates."""
+    ListCommandExecutor(default_view).list()
+
+
+@cli.command()
+@click.argument("name")
+@click.option(
+    "--template",
+    default="gen2/resource",
+    help="Specify a Shell template. Use 'shellfoundry list' to see the list of available templates. "  # noqa: E501
+    "You can use 'local://<folder>' to specify a locally saved template",
+)
+@click.option("--version", default=None)
+@click.option(
+    "--python",
+    type=click.Choice(["2", "3"]),
+    default="3",
+    required=False,
+    help="Specify Python version which will be used",
+)
+@shellfoundry_version_check(abort_if_major=True)
+def new(name, template, version, python):
+    """Creates a new shell based on a template."""
+    NewCommandExecutor().new(name, template, version, python)
+
+
+@cli.command()
+def pack():
+    """Creates a shell package."""
+    PackCommandExecutor().pack()
+
+
+@cli.command()
+def install():
+    """Installs the shell package into CloudShell."""
+    PackCommandExecutor().pack()
+    InstallCommandExecutor().install()
+
+
+@cli.command()
+@click.option(
+    "--enable_cs_repo",
+    is_flag=True,
+    help="Includes shell dependencies " "that are stored in the local pypi repository",
+)
+def dist(enable_cs_repo):
+    """Creates a deployable Shell which can be distributed to a production environment."""  # noqa: E501
+    PackCommandExecutor().pack()
+    DistCommandExecutor().dist(enable_cs_repo)
+
+
+@cli.command()
+def generate():
+    """Generates Python driver data model to be used in driver code."""
+    PackCommandExecutor().pack()
+    GenerateCommandExecutor().generate()
+
+
+@cli.command()
+@click.argument("kv", type=(str, str), default=(None, None), required=False)
+@click.option("--global/--local", "global_cfg", default=True)
+@click.option("--remove", "key_to_remove", default=None)
+def config(kv, global_cfg, key_to_remove):
+    """Configures global/local config values used by shellfoundry."""
+    ConfigCommandExecutor(global_cfg).config(kv, key_to_remove)
+
+
+@cli.command()
+@click.argument("template_name")
+def show(template_name):
+    """Shows all versions of TEMPLATE NAME."""
+    ShowCommandExecutor().show(template_name)
+
+
+@cli.command()
+@click.argument("source")
+@click.option(
+    "--attribute",
+    "add_attribute",
+    multiple=True,
+    default=None,
+    help="Creates a commented out attribute in the shell definition",
+)
+def extend(source, add_attribute):
+    r"""Creates a new shell based on an existing shell.
+
+    SOURCE - Specify the original Shell location.\n
+    \tYou can use 'local://<folder>' to specify a locally saved Shell folder
+    """
+    ExtendCommandExecutor().extend(source, add_attribute)
+
+
+@cli.command()
+@click.argument("cs_version")
+@click.option(
+    "--output_dir",
+    "output_dir",
+    default=None,
+    help="Folder where templates will be saved",
+)
+def get_templates(cs_version, output_dir):
+    """Download all templates which are compatible with provided CloudShell Version.
+
+    CS_VERSION - CloudShell Version
+    """
+    GetTemplatesCommandExecutor().get_templates(cs_version, output_dir)
+
+
+@cli.command()
+@click.argument("name")
+def delete(name):
+    """Deletes the shell from CloudShell.
+
+    NAME - Shell name installed on CloudShell
+    """
+    DeleteCommandExecutor().delete(name)

shellfoundry/commands/config_command.py

@@ -0,0 +1,87 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import click
+
+from shellfoundry.utilities.config.config_context import ConfigContext
+from shellfoundry.utilities.config.config_file_creation import ConfigFileCreation
+from shellfoundry.utilities.config.config_providers import (
+    GlobalConfigProvider,
+    LocalConfigProvider,
+)
+from shellfoundry.utilities.config.config_record import ConfigRecord
+from shellfoundry.utilities.config_reader import INSTALL, Configuration
+
+DEFAULTS_CHAR = "*"
+
+
+class ConfigCommandExecutor(object):
+    def __init__(self, global_cfg, cfg_creation=None):
+        self.global_cfg = global_cfg
+        self.cfg_creation = cfg_creation or ConfigFileCreation()
+
+    def config(self, kv=(None, None), key_to_remove=None):
+        config_file_path = self._get_config_file_path(self.global_cfg)
+        if self._should_remove_key(key_to_remove):
+            context = ConfigContext(config_file_path)
+            ConfigRecord(key_to_remove).delete(context)
+        elif self._should_append_key(kv):
+            field, name = kv
+            if not name:
+                raise click.BadArgumentUsage(
+                    "Field '{}' can not be empty".format(field)
+                )
+            else:
+                self.cfg_creation.create(config_file_path)
+                context = ConfigContext(config_file_path)
+                ConfigRecord(*kv).save(context)
+        else:
+            self._echo_config(config_file_path)
+
+    def _should_append_key(self, kv):
+        return None not in kv
+
+    def _should_remove_key(self, key_to_remove):
+        return key_to_remove is not None
+
+    def _echo_config(self, config_file_path):
+
+        config_data = Configuration.readall(
+            config_file_path, mark_defaults=DEFAULTS_CHAR
+        )
+        table = self._format_config_as_table(config_data, DEFAULTS_CHAR)
+        click.echo(table)
+        click.echo("")
+        click.echo(
+            "* Value marked with '{}' is actually the default value and has not been override by the user.".format(  # noqa: E501
+                DEFAULTS_CHAR
+            )
+        )
+
+    def _format_config_as_table(self, config_data, defaults_char):
+        from shellfoundry.utilities.modifiers.configuration.password_modification import (  # noqa: E501
+            PasswordModification,
+        )
+
+        table_data = [["Key", "Value", ""]]
+        for key, value in config_data[INSTALL].items():
+            default_val = ""
+            if defaults_char in value:
+                default_val = defaults_char
+                value = value.strip(defaults_char).lstrip()
+            if key in PasswordModification.HANDLING_KEYS:
+                value = "[encrypted]"
+            table_data.append([key, value, default_val])
+        import terminaltables
+
+        table = terminaltables.AsciiTable(table_data)
+        table.outer_border = False
+        table.inner_column_border = False
+        return table.table
+
+    @staticmethod
+    def _get_config_file_path(is_global_flag):
+        if is_global_flag:
+            cfg_provider = GlobalConfigProvider()
+            return cfg_provider.get_config_path()
+        return LocalConfigProvider().get_config_path()

shellfoundry/commands/delete_command.py

@@ -0,0 +1,24 @@
+# !/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import click
+
+from shellfoundry.exceptions import FatalError
+from shellfoundry.utilities.shell_package_installer import ShellPackageInstaller
+
+
+class DeleteCommandExecutor(object):
+    def __init__(self, shell_package_installer=None):
+        self.shell_package_installer = (
+            shell_package_installer or ShellPackageInstaller()
+        )
+
+    def delete(self, shell_name):
+        try:
+            self.shell_package_installer.delete(shell_name=shell_name)
+        except FatalError as err:
+
+            msg = err.message if hasattr(err, "message") else err.args[0]
+            click.ClickException(msg)
+
+        click.secho("Successfully deleted shell", fg="green")

shellfoundry/commands/dist_command.py

@@ -0,0 +1,34 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+from shellfoundry.utilities.python_dependencies_packager import (
+    PythonDependenciesPackager,
+)
+
+
+class DistCommandExecutor(object):
+    def __init__(self, cloudshell_config_reader=None, dependencies_packager=None):
+        self.cloudshell_config_reader = cloudshell_config_reader or Configuration(
+            CloudShellConfigReader()
+        )
+        self.dependencies_packager = (
+            dependencies_packager or PythonDependenciesPackager()
+        )
+
+    def dist(self, enable_cs_repo):
+        """Creates offline dependencies archive."""
+        current_path = os.getcwd()
+        requirements_path = os.path.join(current_path, "src", "requirements.txt")
+        dest_path = os.path.join(current_path, "dist", "offline_requirements")
+
+        if enable_cs_repo:
+            cs_server_address = self.cloudshell_config_reader.read().host
+        else:
+            cs_server_address = None
+
+        self.dependencies_packager.save_offline_dependencies(
+            requirements_path, dest_path, cs_server_address
+        )

shellfoundry/commands/extend_command.py

@@ -0,0 +1,182 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+import re
+import shutil
+
+import click
+
+from shellfoundry.exceptions import VersionRequestException
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+from shellfoundry.utilities.constants import (
+    METADATA_AUTHOR_FIELD,
+    TEMPLATE_AUTHOR_FIELD,
+    TEMPLATE_BASED_ON,
+)
+from shellfoundry.utilities.modifiers.definition.definition_modification import (
+    DefinitionModification,
+)
+from shellfoundry.utilities.repository_downloader import RepositoryDownloader
+from shellfoundry.utilities.temp_dir_context import TempDirContext
+from shellfoundry.utilities.validations import (
+    ShellGenerationValidations,
+    ShellNameValidations,
+)
+
+
+class ExtendCommandExecutor(object):
+    LOCAL_TEMPLATE_URL_PREFIX = "local:"
+    SIGN_FILENAME = "signed"
+    ARTIFACTS = {"driver": "src", "deployment": "deployments"}
+
+    def __init__(
+        self,
+        repository_downloader=None,
+        shell_name_validations=None,
+        shell_gen_validations=None,
+    ):
+        """Creates a new shell based on an already existing shell.
+
+        :param RepositoryDownloader repository_downloader:
+        :param ShellNameValidations shell_name_validations:
+        """
+        self.repository_downloader = repository_downloader or RepositoryDownloader()
+        self.shell_name_validations = shell_name_validations or ShellNameValidations()
+        self.shell_gen_validations = (
+            shell_gen_validations or ShellGenerationValidations()
+        )
+        self.cloudshell_config_reader = Configuration(CloudShellConfigReader())
+
+    def extend(self, source, attribute_names):
+        """Create a new shell based on an already existing shell.
+
+        :param str source: The path to the existing shell. Can be a url or local path
+        :param tuple attribute_names: Sequence of attribute names that should be added
+        """
+        with TempDirContext("Extended_Shell_Temp_Dir") as temp_dir:
+            try:
+                if self._is_local(source):
+                    temp_shell_path = self._copy_local_shell(
+                        self._remove_prefix(
+                            source, ExtendCommandExecutor.LOCAL_TEMPLATE_URL_PREFIX
+                        ),
+                        temp_dir,
+                    )
+                else:
+                    temp_shell_path = self._copy_online_shell(source, temp_dir)
+            except VersionRequestException as err:
+                raise click.ClickException(str(err))
+            except Exception:
+                raise click.BadParameter("Check correctness of entered attributes")
+
+            # Remove shell version from folder name
+            shell_path = re.sub(r"-\d+(\.\d+)*/?$", "", temp_shell_path)
+            os.rename(temp_shell_path, shell_path)
+
+            if not self.shell_gen_validations.validate_2nd_gen(shell_path):
+                raise click.ClickException("Invalid second generation Shell.")
+
+            modificator = DefinitionModification(shell_path)
+            self._unpack_driver_archive(shell_path, modificator)
+            self._remove_quali_signature(shell_path)
+            self._change_author(shell_path, modificator)
+            self._add_based_on(shell_path, modificator)
+            self._add_attributes(shell_path, attribute_names)
+
+            try:
+                shutil.move(shell_path, os.path.curdir)
+            except shutil.Error as err:
+                raise click.BadParameter(str(err))
+
+        click.echo("Created shell based on source {}".format(source))
+
+    def _copy_local_shell(self, source, destination):
+        """Copy shell and extract if needed."""
+        if os.path.isdir(source):
+            source = source.rstrip(os.sep)
+            name = os.path.basename(source)
+            ext_shell_path = os.path.join(destination, name)
+            shutil.copytree(source, ext_shell_path)
+        else:
+            raise
+
+        return ext_shell_path
+
+    def _copy_online_shell(self, source, destination):
+        """Download shell and extract it."""
+        archive_path = None
+        try:
+            archive_path = self.repository_downloader.download_file(source, destination)
+            ext_shell_path = (
+                self.repository_downloader.repo_extractor.extract_to_folder(
+                    archive_path, destination
+                )
+            )
+            ext_shell_path = ext_shell_path[0]
+        finally:
+            if archive_path and os.path.exists(archive_path):
+                os.remove(archive_path)
+
+        return os.path.join(destination, ext_shell_path)
+
+    @staticmethod
+    def _is_local(source):
+        return source.startswith(ExtendCommandExecutor.LOCAL_TEMPLATE_URL_PREFIX)
+
+    @staticmethod
+    def _remove_prefix(string, prefix):
+        return string.rpartition(prefix)[-1]
+
+    def _unpack_driver_archive(self, shell_path, modificator=None):
+        """Unpack driver files from ZIP-archive."""
+        if not modificator:
+            modificator = DefinitionModification(shell_path)
+
+        artifacts = modificator.get_artifacts_files(
+            artifact_name_list=list(self.ARTIFACTS.keys())
+        )
+
+        for artifact_name, artifact_path in artifacts.items():
+
+            artifact_path = os.path.join(shell_path, artifact_path)
+
+            if os.path.exists(artifact_path):
+                self.repository_downloader.repo_extractor.extract_to_folder(
+                    artifact_path,
+                    os.path.join(shell_path, self.ARTIFACTS[artifact_name]),
+                )
+                os.remove(artifact_path)
+
+    @staticmethod
+    def _remove_quali_signature(shell_path):
+        """Remove Quali signature from shell."""
+        signature_file_path = os.path.join(
+            shell_path, ExtendCommandExecutor.SIGN_FILENAME
+        )
+        if os.path.exists(signature_file_path):
+            os.remove(signature_file_path)
+
+    def _change_author(self, shell_path, modificator=None):
+        """Change shell authoring."""
+        author = self.cloudshell_config_reader.read().author
+
+        if not modificator:
+            modificator = DefinitionModification(shell_path)
+
+        modificator.edit_definition(field=TEMPLATE_AUTHOR_FIELD, value=author)
+        modificator.edit_tosca_meta(field=METADATA_AUTHOR_FIELD, value=author)
+
+    def _add_based_on(self, shell_path, modificator=None):
+        """Add Based_ON field to shell-definition.yaml file."""
+        if not modificator:
+            modificator = DefinitionModification(shell_path)
+
+        modificator.add_field_to_definition(field=TEMPLATE_BASED_ON)
+
+    def _add_attributes(self, shell_path, attribute_names, modificator=None):
+        """Add a commented out attributes to the shell definition."""
+        if not modificator:
+            modificator = DefinitionModification(shell_path)
+
+        modificator.add_properties(attribute_names=attribute_names)

shellfoundry/commands/generate_command.py

@@ -0,0 +1,44 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+from os import path
+
+import click
+
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+from shellfoundry.utilities.driver_generator import DriverGenerator
+from shellfoundry.utilities.shell_package import ShellPackage
+
+
+class GenerateCommandExecutor(object):
+    def __init__(self, cloudshell_config_reader=None, driver_generator=None):
+        self.cloudshell_config_reader = cloudshell_config_reader or Configuration(
+            CloudShellConfigReader()
+        )
+        self.driver_generator = driver_generator or DriverGenerator()
+
+    def generate(self):
+        """Generates Python driver by connecting to CloudShell server."""
+        current_path = os.getcwd()
+        shell_package = ShellPackage(current_path)
+        if not shell_package.is_tosca():
+            click.echo("Code generation supported in TOSCA based shells only", err=True)
+            return
+
+        shell_name = shell_package.get_name_from_definition()
+        shell_filename = shell_name + ".zip"
+        package_full_path = path.join(current_path, "dist", shell_filename)
+        destination_path = path.join(current_path, "src")
+
+        cloudshell_config = self.cloudshell_config_reader.read()
+
+        click.echo("Connecting to Cloudshell server ...")
+
+        self.driver_generator.generate_driver(
+            cloudshell_config=cloudshell_config,
+            destination_path=destination_path,
+            package_full_path=package_full_path,
+            shell_filename=shell_filename,
+            shell_name=shell_name,
+        )