shellfoundry 1.2.25__py3-none-any.whl

shellfoundry/utilities/config_reader.py

@@ -0,0 +1,154 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+from io import open
+
+import yaml
+
+from shellfoundry.models.install_config import (
+    DEFAULT_AUTHOR,
+    DEFAULT_DOMAIN,
+    DEFAULT_GITHUB_LOGIN,
+    DEFAULT_GITHUB_PASSWORD,
+    DEFAULT_HOST,
+    DEFAULT_ONLINE_MODE,
+    DEFAULT_PASSWORD,
+    DEFAULT_PORT,
+    DEFAULT_TEMPLATE_LOCATION,
+    DEFAULT_USERNAME,
+    InstallConfig,
+)
+from shellfoundry.models.shellfoundry_settings import (
+    DEFAULT_DEFAULT_VIEW,
+    ShellFoundrySettings,
+)
+from shellfoundry.utilities.config.config_providers import DefaultConfigProvider
+
+INSTALL = "install"
+
+HOST = "host"
+PORT = "port"
+USERNAME = "username"
+PASSWORD = "password"
+DOMAIN = "domain"
+AUTHOR = "author"
+ONLINE_MODE = "online_mode"
+TEMPLATE_LOCATION = "template_location"
+GITHUB_LOGIN = "github_login"
+GITHUB_PASSWORD = "github_password"
+
+DEFAULT_VIEW = "defaultview"
+
+
+def get_with_default(install_config, parameter_name, default_value):
+    """Get configuration with default values.
+
+    :param install_config: A dict represents the install section inside the configuration file  # noqa: E501
+    :param parameter_name: Specific key inside the install section
+    :param default_value: Default value in cases that the key cannot be found
+    :return: The value of the key in the configuration file or default value if key cannot be found  # noqa: E501
+    """
+    return (
+        install_config[parameter_name]
+        if install_config and parameter_name in install_config
+        else default_value
+    )
+
+
+class Configuration(object):
+    def __init__(self, reader, config_provider=None):
+        self.reader = reader
+        self.config_provider = config_provider or DefaultConfigProvider()
+
+    def read(self):
+        config_path = self.config_provider.get_config_path()
+
+        if config_path is None or not os.path.isfile(config_path):
+            return self.reader.get_defaults()
+
+        with open(config_path) as stream:
+            config = yaml.safe_load(stream.read())
+
+        if not config or INSTALL not in config:
+            return self.reader.get_defaults()
+
+        return self.reader.read_from_config(config[INSTALL])
+
+    @staticmethod
+    def readall(config_path, mark_defaults=None):
+        """Reads configuration from given file.
+
+        Missing keys will be filled with their defaults.
+        """
+        config_data = None
+        if os.path.exists(config_path):
+            with open(config_path, mode="r", encoding="utf8") as conf_file:
+                config_data = yaml.safe_load(conf_file)
+
+        if not config_data or INSTALL not in config_data:
+            config_data = {INSTALL: {}}
+
+        mark_defaults_f = Configuration._mark_defaults
+        install_cfg_def = {
+            (k, mark_defaults_f(v, mark_defaults))
+            for k, v in InstallConfig.get_default().__dict__.items()
+        }
+        sf_cfg_def = {
+            (k, mark_defaults_f(v, mark_defaults))
+            for k, v in ShellFoundrySettings.get_default().__dict__.items()
+        }
+        all_cfg = dict(install_cfg_def)
+        all_cfg.update(sf_cfg_def)
+        all_cfg.update(config_data[INSTALL])
+        return {INSTALL: all_cfg}
+
+    @staticmethod
+    def _mark_defaults(value, mark_defaults_char):
+        if not mark_defaults_char:
+            return str(value)
+        return "{value} {default_char}".format(
+            value=str(value), default_char=mark_defaults_char
+        )
+
+
+class CloudShellConfigReader(object):
+    def get_defaults(self):
+        return InstallConfig.get_default()
+
+    def read_from_config(self, config):
+        host = get_with_default(config, HOST, DEFAULT_HOST)
+        port = get_with_default(config, PORT, DEFAULT_PORT)
+        username = get_with_default(config, USERNAME, DEFAULT_USERNAME)
+        password = get_with_default(config, PASSWORD, DEFAULT_PASSWORD)
+        domain = get_with_default(config, DOMAIN, DEFAULT_DOMAIN)
+        author = get_with_default(config, AUTHOR, DEFAULT_AUTHOR)
+        online_mode = get_with_default(config, ONLINE_MODE, DEFAULT_ONLINE_MODE)
+        template_location = get_with_default(
+            config, TEMPLATE_LOCATION, DEFAULT_TEMPLATE_LOCATION
+        )
+        github_login = get_with_default(config, GITHUB_LOGIN, DEFAULT_GITHUB_LOGIN)
+        github_password = get_with_default(
+            config, GITHUB_PASSWORD, DEFAULT_GITHUB_PASSWORD
+        )
+        return InstallConfig(
+            host,
+            port,
+            username,
+            password,
+            domain,
+            author,
+            online_mode,
+            template_location,
+            github_login,
+            github_password,
+        )
+
+
+class ShellFoundryConfig(object):
+    def get_defaults(self):
+        return ShellFoundrySettings.get_default()
+
+    def read_from_config(self, config):
+        defaultview = get_with_default(config, DEFAULT_VIEW, DEFAULT_DEFAULT_VIEW)
+        return ShellFoundrySettings(defaultview)

shellfoundry/utilities/constants.py

@@ -0,0 +1,37 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+__all__ = [
+    "TOSCA_META_LOCATION",
+    "TEMPLATE_AUTHOR_FIELD",
+    "TEMPLATE_VERSION",
+    "TEMPLATE_BASED_ON",
+    "CLOUDSHELL_MAX_RETRIES",
+    "CLOUDSHELL_RETRY_INTERVAL_SEC",
+    "DEFAULT_TIME_WAIT",
+    "TEMPLATE_PROPERTY",
+    "TEMPLATES_YML",
+    "SERVER_VERSION_KEY",
+]
+
+CLOUDSHELL_MAX_RETRIES = 5
+CLOUDSHELL_RETRY_INTERVAL_SEC = 0.5
+DEFAULT_TIME_WAIT = 1.0
+METADATA_AUTHOR_FIELD = "Created-By"
+TEMPLATE_AUTHOR_FIELD = "metadata/template_author"
+TEMPLATE_VERSION = "metadata/template_version"
+TEMPLATE_BASED_ON = "metadata/template_based_on"
+TEMPLATE_INFO_FILE = "cookiecutter.json"
+TEMPLATE_PROPERTY = {
+    "type": "string",
+    "default": "fast",
+    "description": "Some attribute description",
+    "constraints": [{"valid_values": ["fast", "slow"]}],
+}
+TEMPLATES_YML = (
+    "https://raw.github.com/QualiSystems/shellfoundry/master/templates_v1.yml"
+)
+TOSCA_META_LOCATION = os.path.join("TOSCA-Metadata", "TOSCA.meta")
+SERVER_VERSION_KEY = "server_version"

shellfoundry/utilities/cookiecutter_integration.py

@@ -0,0 +1,67 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import datetime
+import os
+
+from click import ClickException
+from cookiecutter.exceptions import OutputDirExistsException
+from cookiecutter.main import cookiecutter
+
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+from shellfoundry.utilities.constants import TEMPLATE_INFO_FILE
+
+
+class CookiecutterTemplateCompiler(object):
+    def __init__(self):
+        self.cloudshell_config_reader = Configuration(CloudShellConfigReader())
+
+    def compile_template(
+        self,
+        shell_name,
+        template_path,
+        extra_context,
+        running_on_same_folder,
+        python_version=None,
+    ):
+
+        if python_version is None:
+            python_version = ""
+        else:
+            python_version = ' PythonVersion="{}"'.format(str(python_version))
+
+        extra_context.update(
+            {
+                "project_name": shell_name,
+                "full_name": self.cloudshell_config_reader.read().author,
+                "release_date": datetime.datetime.now().strftime("%B %Y"),
+                "python_version": str(python_version),
+            }
+        )
+
+        if running_on_same_folder:
+            output_dir = os.path.pardir
+        else:
+            output_dir = os.path.curdir
+
+        try:
+            cookiecutter(
+                template_path,
+                no_input=True,
+                extra_context=extra_context,
+                overwrite_if_exists=False,
+                output_dir=output_dir,
+            )
+        except OutputDirExistsException as err:
+            if str(err).startswith("Error: "):
+                msg = str(err)[6:].strip()
+            else:
+                msg = str(err)
+            raise ClickException(msg)
+
+    @staticmethod
+    def _remove_template_info_file(shell_path):
+        """Remove template info file from shell structure."""
+        template_info_file_path = os.path.join(shell_path, TEMPLATE_INFO_FILE)
+        if os.path.exists(template_info_file_path):
+            os.remove(template_info_file_path)

shellfoundry/utilities/driver_generator.py

@@ -0,0 +1,121 @@
+#!/usr/bin/python
+try:
+    from urllib.error import URLError
+except ImportError:
+    from urllib2 import URLError
+
+import zipfile
+from io import open
+from os import path
+
+import click
+from cloudshell.rest.api import PackagingRestApiClient
+from requests import post
+
+from shellfoundry.utilities.temp_dir_context import TempDirContext
+
+
+class DriverGenerator(object):
+    def generate_driver(
+        self,
+        cloudshell_config,
+        destination_path,
+        package_full_path,
+        shell_filename,
+        shell_name,
+    ):
+        """Generates Python data model by connecting to Cloudshell server.
+
+        :param cloudshell_config:
+        :type cloudshell_config: InstallConfig
+        :param destination_path:
+        :param package_full_path:
+        :param shell_filename:
+        :param shell_name:
+        :return:
+        """
+        client = self._connect_to_cloudshell(cloudshell_config)
+        self._generate_driver_data_model(
+            client=client,
+            cloudshell_config=cloudshell_config,
+            destination_path=destination_path,
+            package_full_path=package_full_path,
+            shell_filename=shell_filename,
+            shell_name=shell_name,
+        )
+
+    @staticmethod
+    def _generate_driver_data_model(
+        client,
+        cloudshell_config,
+        destination_path,
+        package_full_path,
+        shell_filename,
+        shell_name,
+    ):
+        """Generates driver data model.
+
+        :param client:
+        :param cloudshell_config:
+        :type cloudshell_config: InstallConfig
+        :param destination_path:
+        :param package_full_path:
+        :param shell_filename:
+        :param shell_name:
+        :return:
+        """
+        url = "http://{}:{}/API/ShellDrivers/Generate".format(
+            cloudshell_config.host, cloudshell_config.port
+        )
+        token = client.token
+        response = post(
+            url,
+            files={path.basename(shell_filename): open(package_full_path, "rb")},
+            headers={"Authorization": "Basic " + token},
+        )
+
+        if response.status_code != 200:
+            error_message = "Code generation failed with code {} and error {}".format(
+                response.status_code, response.text
+            )
+            click.echo(message=error_message, err=True)
+            return
+
+        click.echo("Extracting data model ...")
+        with TempDirContext(remove_dir_on_error=False, prefix=shell_name) as temp_dir:
+            generated_zip = path.join(temp_dir, shell_filename)
+            click.echo("Writing temporary file {}".format(generated_zip))
+            with open(generated_zip, "wb") as driver_file:
+                driver_file.write(response.content)
+
+            click.echo("Extracting generated code at {}".format(destination_path))
+            with zipfile.ZipFile(generated_zip) as zf:
+                zf.extractall(destination_path)
+
+    @staticmethod
+    def _connect_to_cloudshell(cloudshell_config):
+        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 URLError:
+            click.echo(
+                "Login to CloudShell failed. Please verify the credentials in cloudshell_config.yml",  # noqa: E501
+                err=True,
+            )
+            raise

shellfoundry/utilities/filters.py

@@ -0,0 +1,45 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+from . import (
+    GEN_ONE,
+    GEN_ONE_FILTER,
+    GEN_TWO,
+    GEN_TWO_FILTER,
+    LAYER_ONE,
+    LAYER_ONE_FILTER,
+    NO_FILTER,
+)
+
+
+class CompositeFilter(object):
+    def __init__(self, template_type=None):
+        self.template_type = template_type or NO_FILTER
+        self.filters = {
+            GEN_ONE: GenOneFilter,
+            GEN_TWO: GenTwoFilter,
+            LAYER_ONE: LayerOneFilter,
+            NO_FILTER: NoFilter,
+        }
+
+    def filter(self, template_name):  # noqa: A003
+        return self.filters.get(self.template_type, NoFilter)().filter(template_name)
+
+
+class GenOneFilter(object):
+    def filter(self, template_name):  # noqa: A003
+        return GEN_ONE_FILTER in template_name
+
+
+class GenTwoFilter(object):
+    def filter(self, template_name):  # noqa: A003
+        return GEN_TWO_FILTER in template_name
+
+
+class LayerOneFilter(object):
+    def filter(self, template_name):  # noqa: A003
+        return LAYER_ONE_FILTER in template_name
+
+
+class NoFilter(object):
+    def filter(self, template_name):  # noqa: A003
+        return True

shellfoundry/utilities/installer.py

@@ -0,0 +1,44 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+import click
+from cloudshell.rest.api import PackagingRestApiClient
+
+
+class ShellInstaller(object):
+    def install(self, package_name, config):
+        """Installs package according to cloudshell.
+
+        :param package_name: Package name to install
+        :type package_name str
+        :param config: Configuration to be used for
+        :type config shellfoundry.models.install_config.InstallConfig
+        :return:
+        """
+        package_full_path = os.path.join(os.getcwd(), "dist", package_name + ".zip")
+        click.echo(
+            "Installing package {} into CloudShell at http://{}:{}".format(
+                package_full_path, config.host, config.port
+            )
+        )
+
+        try:
+            client = PackagingRestApiClient.login(
+                host=config.host,
+                port=config.port,
+                username=config.username,
+                password=config.password,
+                domain=config.domain,
+            )
+        except AttributeError:
+            client = PackagingRestApiClient(
+                ip=config.host,
+                port=config.port,
+                username=config.username,
+                password=config.password,
+                domain=config.domain,
+            )
+
+        client.import_package(package_full_path)

shellfoundry/utilities/modifiers/configuration/aggregated_modifiers.py

@@ -0,0 +1,26 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from .password_modification import PasswordModification
+
+DEFAULT_MODIFIER = (
+    lambda x: x
+)  # Default modifier returns the passed value unchanged  # noqa: E731
+
+
+class AggregatedModifiers(object):
+    def __init__(self, modifiers=None, default=None):
+        self.modifiers = modifiers or {
+            key: PasswordModification().modify
+            for key in PasswordModification.HANDLING_KEYS
+        }
+        self.default_modifier = default or AggregatedModifiers._default_modifier
+
+    def modify(self, key, value):
+        if key in self.modifiers:
+            return self.modifiers[key](value)
+        return self.default_modifier(value)
+
+    @staticmethod
+    def _default_modifier(value):  # Default modifier returns the passed value unchanged
+        return value

shellfoundry/utilities/modifiers/configuration/password_modification.py

@@ -0,0 +1,48 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import base64
+import binascii
+import sys
+
+import shellfoundry.exceptions as exceptions
+
+
+class PasswordModification(object):
+    HANDLING_KEYS = ["password", "github_password"]
+
+    def modify(self, value):
+        encryption_key = self._get_encryption_key()
+        encoded = self._decode_encode(value, encryption_key)
+        if sys.version_info[0] < 3:
+            return base64.b64encode(encoded)
+        else:
+            return base64.b64encode(encoded.encode()).decode()
+
+    def normalize(self, value):
+        try:
+            encryption_key = self._get_encryption_key()
+            if sys.version_info[0] < 3:
+                decoded = self._decode_encode(
+                    base64.decodestring(value), encryption_key
+                )
+            else:
+                decoded = self._decode_encode(
+                    base64.decodebytes(value.encode()).decode(), encryption_key
+                )
+            return decoded
+        except binascii.Error:
+            return value
+
+    def _get_encryption_key(self):
+        from platform import node
+
+        machine_name = node()
+        if not machine_name:
+            raise exceptions.PlatformNameIsEmptyException()
+        return machine_name
+
+    def _decode_encode(self, value, key):
+        return "".join(
+            chr(ord(source) ^ ord(key)) for source, key in zip(value, key * 100)
+        )