shellfoundry 1.2.25__py3-none-any.whl

shellfoundry/commands/get_templates_command.py

@@ -0,0 +1,151 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+import shutil
+from threading import Thread, currentThread
+
+import click
+import yaml
+from requests.exceptions import SSLError
+
+from shellfoundry.exceptions import VersionRequestException
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+from shellfoundry.utilities.repository_downloader import RepositoryDownloader
+from shellfoundry.utilities.temp_dir_context import TempDirContext
+from shellfoundry.utilities.template_retriever import TemplateRetriever
+
+
+class GetTemplatesCommandExecutor(object):
+    def __init__(self, repository_downloader=None, template_retriever=None):
+        """Download all templates relevant to provided CloudShell Version.
+
+        :param TemplateRetriever template_retriever:
+        :param RepositoryDownloader repository_downloader:
+        """
+        self.cloudshell_config_reader = Configuration(CloudShellConfigReader())
+        self.template_retriever = template_retriever or TemplateRetriever()
+        self.repository_downloader = repository_downloader or RepositoryDownloader()
+
+    def get_templates(self, cs_version, output_dir=None):
+        """Download all templates relevant to provided CloudShell Version.
+
+        :param str cs_version: The desired version of the CloudShell
+        :param str output_dir: Output directory to download templates
+        """
+        shellfoundry_config = self.cloudshell_config_reader.read()
+        online_mode = shellfoundry_config.online_mode.lower() == "true"
+        if online_mode:
+            try:
+                response = self.template_retriever._get_templates_from_github()
+                config = yaml.safe_load(response)
+                repos = {template["repository"] for template in config["templates"]}
+
+                if not output_dir:
+                    output_dir = os.path.abspath(os.path.curdir)
+
+                archive_name = "shellfoundry_templates_{}".format(cs_version)
+
+                archive_path = os.path.join(output_dir, "{}.zip".format(archive_name))
+                if os.path.exists(archive_path):
+                    click.confirm(
+                        text="Templates archive for CloudShell Version {cs_version} already exists in path {path}."  # noqa: E501
+                        "\nDo you wish to overwrite it?".format(
+                            cs_version=cs_version, path=archive_path
+                        ),
+                        abort=True,
+                    )
+                    os.remove(archive_path)
+
+                with TempDirContext(archive_name) as temp_dir:
+                    templates_path = temp_dir
+                    threads = []
+                    errors = []
+                    for i, repo in enumerate(repos):
+                        template_thread = Thread(
+                            name=str(i),
+                            target=self.download_template,
+                            args=(
+                                repo,
+                                cs_version,
+                                templates_path,
+                                shellfoundry_config.github_login,
+                                shellfoundry_config.github_password,
+                                errors,
+                            ),
+                        )
+                        threads.append(template_thread)
+
+                    for thread in threads:
+                        thread.start()
+                    for thread in threads:
+                        thread.join()
+
+                    if errors:
+                        raise click.ClickException(errors[0])
+
+                    os.chdir(output_dir)
+                    shutil.make_archive(archive_name, "zip", templates_path)
+
+                click.echo(
+                    "Downloaded templates for CloudShell {cs_version} to {templates}".format(  # noqa: E501
+                        cs_version=cs_version, templates=os.path.abspath(archive_path)
+                    )
+                )
+            except SSLError:
+                raise click.UsageError(
+                    "Could not retrieve the templates list to download. Are you offline?"  # noqa: E501
+                )
+        else:
+            click.echo(
+                "Please, move shellfoundry to online mode. See, shellfoundry config command"  # noqa: E501
+            )
+
+    def download_template(
+        self,
+        repository,
+        cs_version,
+        templates_path,
+        github_login,
+        github_password,
+        errors,
+    ):
+        try:
+            result_branch = self.template_retriever.get_latest_template(
+                repository, cs_version, github_login, github_password
+            )
+
+            if result_branch:
+                try:
+                    template_path = os.path.join(
+                        templates_path, currentThread().getName()
+                    )
+                    os.mkdir(template_path)
+                    res = self.repository_downloader.download_template(
+                        target_dir=template_path,
+                        repo_address=repository,
+                        branch=result_branch,
+                        is_need_construct=True,
+                    )
+
+                    shutil.copytree(
+                        res, os.path.join(templates_path, repository.split("/")[-1])
+                    )
+                    shutil.rmtree(path=template_path, ignore_errors=True)
+                except VersionRequestException:
+                    errors.append(
+                        "Failed to download template from repository {} version {}".format(  # noqa: E501
+                            repository, result_branch
+                        )
+                    )
+                except shutil.Error:
+                    errors.append(
+                        "Failed to build correct template '{}' structure".format(
+                            repository
+                        )
+                    )
+                finally:
+                    pass
+
+        except click.ClickException as err:
+            errors.append(str(err))

shellfoundry/commands/install_command.py

@@ -0,0 +1,81 @@
+# !/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+import click
+
+try:
+    # Python 2.x version
+    from urllib2 import HTTPError, URLError
+except ImportError:
+    # Python 3.x version
+    from urllib.error import HTTPError, URLError
+
+from shellfoundry.exceptions import FatalError
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+from shellfoundry.utilities.installer import ShellInstaller
+from shellfoundry.utilities.shell_config_reader import ShellConfigReader
+from shellfoundry.utilities.shell_package import ShellPackage
+from shellfoundry.utilities.shell_package_installer import ShellPackageInstaller
+
+
+class InstallCommandExecutor(object):
+    def __init__(
+        self,
+        cloudshell_config_reader=None,
+        installer=None,
+        shell_config_reader=None,
+        shell_package_installer=None,
+    ):
+        self.cloudshell_config_reader = cloudshell_config_reader or Configuration(
+            CloudShellConfigReader()
+        )
+        self.installer = installer or ShellInstaller()
+        self.shell_config_reader = shell_config_reader or ShellConfigReader()
+        self.shell_package_installer = (
+            shell_package_installer or ShellPackageInstaller()
+        )
+
+    def install(self):
+        current_path = os.getcwd()
+        shell_package = ShellPackage(current_path)
+        if shell_package.is_layer_one():
+            click.secho(
+                "Installing a L1 shell directly via shellfoundry is not supported. "
+                "Please follow the L1 shell import procedure described in help.quali.com.",  # noqa: E501
+                fg="yellow",
+            )
+        else:
+            if shell_package.is_tosca():
+                self.shell_package_installer.install(current_path)
+            else:
+                self._install_old_school_shell()
+            click.secho("Successfully installed shell", fg="green")
+
+    def _install_old_school_shell(self):
+        error = None
+        try:
+            cloudshell_config = self.cloudshell_config_reader.read()
+            shell_config = self.shell_config_reader.read()
+            self.installer.install(shell_config.name, cloudshell_config)
+        except HTTPError as e:
+            if e.code == 401:
+                raise FatalError(
+                    "Login to CloudShell failed. "
+                    "Please verify the credentials in the config"
+                )
+            error = str(e)
+        except URLError:
+            raise FatalError(
+                "Connection to CloudShell Server failed. "
+                "Please make sure it is up and running properly."
+            )
+        except Exception as e:
+            error = str(e)
+
+        if error:
+            raise FatalError(
+                "Failed to install shell. "
+                "CloudShell responded with: '{}'".format(error)
+            )

shellfoundry/commands/list_command.py

@@ -0,0 +1,110 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from os import linesep
+from textwrap import wrap
+
+import click
+from cloudshell.rest.exceptions import FeatureUnavailable
+from requests.exceptions import SSLError
+from terminaltables import AsciiTable
+
+from ..exceptions import FatalError
+
+from shellfoundry import ALTERNATIVE_TEMPLATES_PATH
+from shellfoundry.utilities.config_reader import (
+    CloudShellConfigReader,
+    Configuration,
+    ShellFoundryConfig,
+)
+from shellfoundry.utilities.standards import Standards
+from shellfoundry.utilities.template_retriever import (
+    FilteredTemplateRetriever,
+    TemplateRetriever,
+)
+
+
+class ListCommandExecutor(object):
+    def __init__(self, default_view=None, template_retriever=None, standards=None):
+        dv = default_view or Configuration(ShellFoundryConfig()).read().defaultview
+        self.template_retriever = template_retriever or FilteredTemplateRetriever(
+            dv, TemplateRetriever()
+        )
+        self.show_info_msg = default_view is None
+        self.standards = standards or Standards()
+        self.cloudshell_config_reader = Configuration(CloudShellConfigReader())
+
+    def list(self):  # noqa: A003
+        online_mode = self.cloudshell_config_reader.read().online_mode.lower() == "true"
+        template_location = self.cloudshell_config_reader.read().template_location
+
+        try:
+            standards = self.standards.fetch()
+            if online_mode:
+                try:
+                    templates = self.template_retriever.get_templates(
+                        standards=standards
+                    )
+                except SSLError:
+                    raise click.UsageError(
+                        "Could not retrieve the templates list. Are you offline?"
+                    )
+            else:
+                templates = self.template_retriever.get_templates(
+                    template_location=template_location, standards=standards
+                )
+        except FatalError as err:
+            raise click.UsageError(str(err))
+        except FeatureUnavailable:
+            if online_mode:
+                templates = self.template_retriever.get_templates(
+                    alternative=ALTERNATIVE_TEMPLATES_PATH
+                )
+            else:
+                templates = self.template_retriever.get_templates(
+                    template_location=template_location
+                )
+
+        if not templates:
+            raise click.ClickException(
+                "No templates matched the view criteria(gen1/gen2) or "
+                "available templates and standards are not compatible"
+            )
+
+        template_rows = [["Template Name", "CloudShell Ver.", "Description"]]
+        for template in list(templates.values()):
+            template = template[0]
+            cs_ver_txt = str(template.min_cs_ver) + " and up"
+            template_rows.append(
+                [template.name, cs_ver_txt, template.description]
+            )  # description is later wrapped based on the size of the console
+
+        table = AsciiTable(template_rows)
+        table.outer_border = False
+        table.inner_column_border = False
+        max_width = table.column_max_width(2)
+
+        if max_width <= 0:  # verify that the console window is not too small,
+            # and if so skip the wrapping logic
+            click.echo(table.table)
+            return
+
+        row = 1
+        for template in list(templates.values()):
+            template = template[0]
+            wrapped_string = linesep.join(wrap(template.description, max_width))
+            table.table_data[row][2] = wrapped_string
+            row += 1
+
+        output = table.table
+        click.echo(output)
+
+        if self.show_info_msg:
+            click.echo(
+                """
+As of CloudShell 8.0, CloudShell uses 2nd generation shells,
+to view the list of 1st generation shells use: shellfoundry list --gen1.
+For more information, please visit our devguide:
+https://qualisystems.github.io/devguide/
+"""
+            )