shellfoundry 1.2.25__py3-none-any.whl

shellfoundry/decorators/version_check.py

@@ -0,0 +1,52 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+from functools import update_wrapper
+
+import click
+
+from shellfoundry.exceptions import ShellFoundryVersionException
+from shellfoundry.utilities import is_index_version_greater_than_current
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+
+
+class shellfoundry_version_check(object):
+    def __init__(self, abort_if_major=False):
+        self.abort_if_major = abort_if_major
+        self.cloudshell_config_reader = Configuration(CloudShellConfigReader())
+
+    def __call__(self, f):
+        def decorator(*args, **kwargs):
+            output = ""
+            if self.cloudshell_config_reader.read().online_mode.lower() == "true":
+                try:
+                    (
+                        is_greater_version,
+                        is_major_release,
+                    ) = is_index_version_greater_than_current()
+                except ShellFoundryVersionException as err:
+                    click.secho(str(err), fg="red")
+                    raise click.Abort()
+                if is_greater_version:
+                    if is_major_release:
+                        output = (
+                            "This version of shellfoundry is not supported anymore, "
+                            "please upgrade by running: pip install shellfoundry --upgrade"  # noqa: E501
+                        )
+
+                        if self.abort_if_major:
+                            click.secho(output, fg="yellow")
+                            print("")  # noqa: T001
+                            raise click.Abort()
+                    else:
+                        output = (
+                            "There is a new version of shellfoundry available, "
+                            "please upgrade by running: pip install shellfoundry --upgrade"  # noqa: E501
+                        )
+
+            f(**kwargs)
+
+            if output:
+                print("")  # noqa: T001
+                click.secho(output, fg="yellow")
+
+        return update_wrapper(decorator, f)

shellfoundry/exceptions.py

@@ -0,0 +1,52 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import click
+
+
+class ShellFoundryBaseException(Exception):
+    def __init__(self, message):
+        super(ShellFoundryBaseException, self).__init__(message)
+
+
+class ShellYmlMissingException(ShellFoundryBaseException):
+    def __init__(self, message):
+        super(ShellYmlMissingException, self).__init__(message)
+
+
+class WrongShellYmlException(ShellFoundryBaseException):
+    def __init__(self, message):
+        super(WrongShellYmlException, self).__init__(message)
+
+
+class NoVersionsHaveBeenFoundException(ShellFoundryBaseException):
+    def __init__(self, message):
+        super(NoVersionsHaveBeenFoundException, self).__init__(message)
+
+
+class VersionRequestException(ShellFoundryBaseException):
+    def __init__(self, message):
+        super(VersionRequestException, self).__init__(message)
+
+
+class PlatformNameIsEmptyException(ShellFoundryBaseException):
+    def __init__(self, message="Machine name is empty"):
+        super(PlatformNameIsEmptyException, self).__init__(message)
+
+
+class FatalError(click.ClickException):
+    def __init__(self, message):
+        super(FatalError, self).__init__(message)
+
+    def show(self, file=None):
+        click.secho("Error: {}".format(self.format_message()), err=True, fg="red")
+
+
+class YmlFieldMissingException(Exception):
+    def __init__(self, message):
+        super(YmlFieldMissingException, self).__init__(message)
+
+
+class ShellFoundryVersionException(Exception):
+    def __init__(self, message):
+        super(ShellFoundryVersionException, self).__init__(message)

shellfoundry/models/install_config.py

@@ -0,0 +1,82 @@
+#!/usr/bin/python
+
+from shellfoundry.utilities.modifiers.configuration.password_modification import (
+    PasswordModification,
+)
+
+DEFAULT_HOST = "localhost"
+DEFAULT_PORT = 9000
+DEFAULT_USERNAME = "admin"
+DEFAULT_PASSWORD = "admin"
+DEFAULT_DOMAIN = "Global"
+DEFAULT_AUTHOR = "Anonymous"
+DEFAULT_ONLINE_MODE = "True"
+DEFAULT_TEMPLATE_LOCATION = "Empty"
+DEFAULT_GITHUB_LOGIN = ""
+DEFAULT_GITHUB_PASSWORD = "gh_pass"
+
+
+class InstallConfig(object):
+    def __init__(
+        self,
+        host,
+        port,
+        username,
+        password,
+        domain,
+        author,
+        online_mode,
+        template_location,
+        github_login,
+        github_password,
+    ):
+        self.domain = domain
+        self.password = self._decode_password(password)
+        self.username = username
+        self.port = port
+        self.host = host
+        self.author = author
+        self.online_mode = online_mode
+        self.template_location = template_location
+        self.github_login = github_login
+        self.github_password = self._decode_password(github_password)
+
+    def __eq__(self, other):
+        """Comparison.
+
+        :param other: An instance of InstallConfig to compare
+        :type other InstallConfig
+        :return: True of same value, False otherwise
+        :rtype bool
+        """
+        return (
+            self.domain == other.domain
+            and self.host == other.host
+            and self.password == other.password
+            and self.port == other.port
+            and self.username == other.username
+            and self.author == other.author
+            and self.online_mode == other.online_mode
+            and self.template_location == other.template_location
+            and self.github_login == other.github_login
+            and self.github_password == other.github_password
+        )
+
+    @staticmethod
+    def get_default():
+        return InstallConfig(
+            DEFAULT_HOST,
+            DEFAULT_PORT,
+            DEFAULT_USERNAME,
+            DEFAULT_PASSWORD,
+            DEFAULT_DOMAIN,
+            DEFAULT_AUTHOR,
+            DEFAULT_ONLINE_MODE,
+            DEFAULT_TEMPLATE_LOCATION,
+            DEFAULT_GITHUB_LOGIN,
+            DEFAULT_GITHUB_PASSWORD,
+        )
+
+    def _decode_password(self, password):
+        pass_mod = PasswordModification()
+        return pass_mod.normalize(password)

shellfoundry/models/shell_template.py

@@ -0,0 +1,22 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+
+class ShellTemplate(object):
+    def __init__(
+        self,
+        name,
+        description,
+        repository,
+        min_cs_ver,
+        standard=None,
+        standard_version=None,
+        params=None,
+    ):
+        self.name = name
+        self.description = description
+        self.repository = repository
+        self.min_cs_ver = min_cs_ver
+        self.standard = standard
+        self.standard_version = standard_version or {}
+        self.params = params or {}

shellfoundry/models/shellfoundry_settings.py

@@ -0,0 +1,13 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+DEFAULT_DEFAULT_VIEW = "gen2"
+
+
+class ShellFoundrySettings(object):
+    def __init__(self, defaultview):
+        self.defaultview = defaultview
+
+    @staticmethod
+    def get_default():
+        return ShellFoundrySettings(DEFAULT_DEFAULT_VIEW)

shellfoundry/utilities/__init__.py

@@ -0,0 +1,114 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import json
+import ssl
+
+import pkg_resources
+
+try:
+    # Python 2.x version
+    from xmlrpclib import ProtocolError, ServerProxy
+except ImportError:
+    # Python 3.x version
+    from xmlrpc.client import ProtocolError, ServerProxy
+
+try:
+    from urllib import urlopen
+except ImportError:
+    from urllib.request import urlopen
+
+try:
+    from urllib.error import HTTPError, URLError
+except ImportError:
+    from urllib2 import HTTPError, URLError
+
+from distutils.version import StrictVersion
+
+from shellfoundry import PACKAGE_NAME
+from shellfoundry.exceptions import ShellFoundryVersionException
+
+GEN_ONE = "gen1"
+GEN_TWO = "gen2"
+LAYER_ONE = "layer1"
+NO_FILTER = "all"
+GEN_ONE_FILTER = "gen1"
+GEN_TWO_FILTER = "gen2"
+LAYER_ONE_FILTER = "layer-1"
+SEPARATOR = "/"
+
+
+class Index(object):
+    def __init__(self, url):
+        self.url = url
+
+
+PyPI = Index("https://pypi.python.org/pypi/")
+
+
+def get_installed_version(package_name):
+    return pkg_resources.get_distribution(package_name).version
+
+
+def is_index_version_greater_than_current():
+    MAJOR_INDEX = 0
+
+    installed, index = (
+        StrictVersion(get_installed_version(PACKAGE_NAME)),
+        StrictVersion(max_version_from_index()),
+    )
+    is_major_release = False
+
+    is_greater_version = index > installed
+    if (
+        is_greater_version
+        and get_index_of_biggest_component_between_two_versions(
+            index.version, installed.version
+        )
+        == MAJOR_INDEX
+    ):
+        is_major_release = True
+
+    return is_greater_version, is_major_release
+
+
+def max_version_from_index():
+    try:
+        ctx = ssl.SSLContext(protocol=ssl.PROTOCOL_SSLv23)
+        proxy = ServerProxy(PyPI.url, context=ctx)
+        releases = proxy.package_releases(PACKAGE_NAME)
+        max_version = max(releases)
+        return max_version
+    except ProtocolError as err:
+        raise ShellFoundryVersionException(
+            "Cannot retrieve latest shellfoundry version, "
+            "are you offline? Error: {}".format(err)
+        )
+    except Exception as err:
+        raise ShellFoundryVersionException(
+            "Unexpected error during shellfoundry version check. "
+            "Error: {}.".format(err)
+        )
+
+
+def latest_released_version():
+    url = "https://pypi.org/pypi/{package_name}/json"
+    try:
+        package_info = json.load(urlopen(url.format(package_name=PACKAGE_NAME)))
+        return package_info["info"]["version"]
+    except (HTTPError, URLError) as err:
+        raise ShellFoundryVersionException(
+            "Cannot retrieve latest shellfoundry version, "
+            "are you offline? Error: {}".format(err)
+        )
+    except Exception as err:
+        raise ShellFoundryVersionException(
+            "Unexpected error during shellfoundry version check. "
+            "Error: {}.".format(err)
+        )
+
+
+def get_index_of_biggest_component_between_two_versions(v1, v2):
+    for i in range(0, len(v1)):
+        if v1[i] > v2[i]:
+            return i

shellfoundry/utilities/archive_creator.py

@@ -0,0 +1,35 @@
+import os
+import zipfile
+
+
+class ArchiveCreator(object):
+    @staticmethod
+    def make_archive(output_filename, archive_format, source_dir):
+        """Creates archive in specified format recursively of source_dir.
+
+        Replaces shutil.make_archive in order to be able to test with pyfakefs
+        :param output_filename: Output archive file name.
+        If directory does not exist, it will be created
+        :param archive_format: Archive format to be used.
+        Currently only zip is supported
+        :param source_dir: Directory to scan for archiving
+        :return:
+        """
+        if os.path.exists(source_dir):
+            if os.path.splitext(output_filename)[1] == "":
+                output_filename += ".zip"
+            output_dir = os.path.dirname(output_filename)
+            if output_dir and not os.path.exists(output_dir):
+                os.makedirs(output_dir)
+            relroot = source_dir
+            with zipfile.ZipFile(output_filename, "w", zipfile.ZIP_DEFLATED) as zip_f:
+                for root, dirs, files in os.walk(source_dir):
+                    # add directory (needed for empty dirs)
+                    zip_f.write(root, os.path.relpath(root, relroot))
+                    for file in files:
+                        filename = os.path.join(root, file)
+                        if os.path.isfile(filename):  # regular files only
+                            arcname = os.path.join(os.path.relpath(root, relroot), file)
+                            zip_f.write(filename, arcname)
+
+            return output_filename

shellfoundry/utilities/cloudshell_api/__init__.py

@@ -0,0 +1 @@
+from .client_wrapper import CloudShellClient, create_cloudshell_client  # noqa: F401

shellfoundry/utilities/cloudshell_api/client_wrapper.py

@@ -0,0 +1,71 @@
+#!/usr/bin/python
+
+from cloudshell.rest.api import PackagingRestApiClient
+
+from shellfoundry.exceptions import FatalError
+from shellfoundry.utilities.config_reader import CloudShellConfigReader, Configuration
+
+try:
+    from urllib.error import HTTPError
+except Exception:
+    from urllib2 import HTTPError
+
+
+def create_cloudshell_client(retries=1):
+    try:
+        cs_client = CloudShellClient().create_client(retries=retries)
+    except FatalError:
+        raise
+    return cs_client
+
+
+class CloudShellClient(object):
+    ConnectionFailureMessage = "Connection to CloudShell Server failed. Please make sure it is up and running properly."  # noqa: E501
+
+    def __init__(self, cs_config=None):
+        """Creates cloudshell client.
+
+        :type cs_config shellfoundry.models.install_config.InstallConfig
+        """
+        self._cs_config = cs_config or Configuration(CloudShellConfigReader()).read()
+
+    def create_client(self, **kwargs):
+        retries = kwargs.get("retries", 1)
+        if retries == 0:
+            raise FatalError(self.ConnectionFailureMessage)
+        try:
+            return self._create_client()
+        except FatalError as e:
+            retry = retries - 1
+            if retry == 0:
+                raise e
+            return self.create_client(retries=retry)
+
+    def _create_client(self):
+        try:
+            try:
+                client = PackagingRestApiClient.login(
+                    host=self._cs_config.host,
+                    port=self._cs_config.port,
+                    username=self._cs_config.username,
+                    password=self._cs_config.password,
+                    domain=self._cs_config.domain,
+                )
+                return client
+            except AttributeError:
+                client = PackagingRestApiClient(
+                    ip=self._cs_config.host,
+                    port=self._cs_config.port,
+                    username=self._cs_config.username,
+                    password=self._cs_config.password,
+                    domain=self._cs_config.domain,
+                )
+                return client
+        except (HTTPError, Exception) as e:
+            if hasattr(e, "code") and e.code == 401:
+                if hasattr(e, "msg") and e.msg:
+                    msg = e.msg
+                else:
+                    msg = "Please verify the credentials in the config"
+                raise FatalError("Login to CloudShell failed. {}".format(msg))
+            raise FatalError(self.ConnectionFailureMessage)

shellfoundry/utilities/config/config_context.py

@@ -0,0 +1,44 @@
+# !/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from io import open
+
+import yaml
+
+from shellfoundry.utilities.config_reader import INSTALL
+from shellfoundry.utilities.modifiers.configuration.aggregated_modifiers import (
+    AggregatedModifiers,
+)
+
+
+class ConfigContext(object):
+    def __init__(self, config_file_path):
+        self.config_file_path = config_file_path
+        self.modifier = AggregatedModifiers()
+
+    def try_save(self, key, value):
+        try:
+            with open(self.config_file_path, mode="r+", encoding="utf8") as stream:
+                data = yaml.safe_load(stream) or {INSTALL: {}}
+                data[INSTALL][key] = self._modify(key, value)
+                stream.seek(0)
+                stream.truncate()
+                yaml.safe_dump(data, stream=stream, default_flow_style=False)
+            return True
+        except Exception:
+            return False
+
+    def try_delete(self, key):
+        try:
+            with open(self.config_file_path, mode="r+", encoding="utf8") as stream:
+                data = yaml.safe_load(stream)
+                del data[INSTALL][key]  # handle cases that INSTALL does not exists
+                stream.seek(0)
+                stream.truncate()
+                yaml.safe_dump(data, stream=stream, default_flow_style=False)
+            return True
+        except Exception:
+            return False
+
+    def _modify(self, key, value):
+        return self.modifier.modify(key, value)

shellfoundry/utilities/config/config_file_creation.py

@@ -0,0 +1,32 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+import errno
+import os
+from io import open
+
+import click
+
+
+class ConfigFileCreation(object):
+    def create(self, config_file_path):
+        if os.path.exists(config_file_path):
+            return
+        if not os.path.exists(os.path.dirname(config_file_path)):
+            try:
+                dirname = os.path.dirname(config_file_path)
+                os.makedirs(dirname)
+            except OSError as exc:
+                if exc.errno != errno.EEXIST:
+                    click.echo("Failed to create config file")
+                    click.echo(str(exc))
+                    raise
+        try:
+            click.echo("Creating config file...")
+            open(config_file_path, mode="w", encoding="utf8").close()
+        except Exception:
+            if not os.path.exists(config_file_path):
+                click.echo("Failed to create config file")
+                import sys
+
+                click.echo(str(sys.exc_info()[1]))
+                raise

shellfoundry/utilities/config/config_providers.py

@@ -0,0 +1,50 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+
+import click
+
+GLOBAL_CONFIG_NAME = "global_config.yml"
+LOCAL_CONFIG_NAME = "cloudshell_config.yml"
+
+
+class LocalConfigProvider(object):
+    def get_config_path(self):
+        path = os.path.join(os.getcwd(), LOCAL_CONFIG_NAME)
+        if os.path.exists(path):
+            click.echo("Using local configuration...")
+        return path
+
+
+class GlobalConfigProvider(object):
+    QUALI = "Quali"
+    PRODUCT = "shellfoundry"
+
+    def get_config_path(self):
+        sf_name = os.path.join(GlobalConfigProvider.QUALI, GlobalConfigProvider.PRODUCT)
+        app_dir_path = click.get_app_dir(sf_name)
+        return os.path.join(app_dir_path, GLOBAL_CONFIG_NAME)
+
+
+class ConfigProvider(object):
+    def __init__(self, *args):
+        self.config_providers = args
+
+    def get_config_path(self):
+        for provider in self.config_providers:
+            config_path = provider.get_config_path()
+            if os.path.exists(config_path):
+                return config_path
+
+
+class DefaultConfigProvider(ConfigProvider):
+    def __init__(self):
+        ConfigProvider.__init__(self, (GlobalConfigProvider()))  # The order do matters
+        self.default_provider = LocalConfigProvider()
+
+    def get_config_path(self):
+        config_path = self.default_provider.get_config_path()
+        if not os.path.exists(config_path):
+            config_path = ConfigProvider.get_config_path(self)
+        return config_path  # or self.fallback_provider.get_config_path()

shellfoundry/utilities/config/config_record.py

@@ -0,0 +1,24 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import click
+
+
+class ConfigRecord(object):
+    def __init__(self, key, value=None):
+        self.key = key
+        self.value = value
+
+    def save(self, config_context):
+        if config_context.try_save(self.key, self.value):
+            click.echo("{}: {} was saved successfully".format(self.key, self.value))
+        else:
+            click.echo("Failed to save key value")
+
+    def delete(self, config_context):
+        if config_context.try_delete(self.key):
+            click.echo("{} was deleted successfully".format(self.key))
+        else:
+            # add support for typed exceptions
+            # in order to have the ability to differentiate between failures
+            click.echo("Failed to delete key")