ebcli/operations/solution_stack_ops.py

# Copyright 2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"). You
# may not use this file except in compliance with the License. A copy of
# the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "license" file accompanying this file. This file is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
# ANY KIND, either express or implied. See the License for the specific
# language governing permissions and limitations under the License.
from cement.utils.misc import minimal_logger

from ebcli.core import io
from ebcli.lib import elasticbeanstalk, heuristics, utils
from ebcli.objects.exceptions import NotFoundError
from ebcli.objects.platform import PlatformVersion
from ebcli.objects.solutionstack import SolutionStack
from ebcli.operations import commonops, platform_version_ops
from ebcli.resources.strings import alerts, prompts

CUSTOM_PLATFORM_OPTION = 'Custom Platform'

LOG = minimal_logger(__name__)


def get_default_solution_stack():
    return commonops.get_config_setting_from_branch_or_default('default_platform')


def get_all_solution_stacks():
    return elasticbeanstalk.get_available_solution_stacks()


def find_solution_stack_from_string(solution_string, find_newer=False):
    """
    Method returns a SolutionStack object representing the given `solution_string`.

    If the `solution_string` matches ARNs and complete names of solution stacks, the exact
    match is returned. In the event when there are multiple matches, the latest version is
    returned.

    :param solution_string: A string in one of the following (case-insensitive) forms:
        - PlatformArn:
            - EB-managed: 'arn:aws:elasticbeanstalk:us-west-2::platform/Multi-container
                            Docker running on 64bit Amazon Linux/2.8.0'
            - Custom: arn:aws:elasticbeanstalk:us-west-2:123412341234:platform/
                        custom_platform/1.0.0
        - complete name: '64bit Amazon Linux 2017.03 v2.7.5 running Multi-container Docker
                            17.03.2-ce (Generic)'
        - shorthand: 'Multi-container Docker 17.03.2-ce (Generic)'
        - language name: 'Multi-container Docker'
        - pythonified shorthand: 'multi-container-docker-17.03.2-ce-(generic)'
    :param find_newer: If solution_string is a complete name or a PlatformArn that uniquely
                        matches a solution stack or platform, find the newest version of the
                        solution stack.

    :return: A SolutionStack object representing the latest version of the `solution_string`.
            In case of a custom platform, the return value is a PlatformVersion object.
    """

    # Compare input with PlatformARNs
    match = None
    if PlatformVersion.is_eb_managed_platform_arn(solution_string):
        if find_newer:
            match = platform_version_ops.get_latest_eb_managed_platform(solution_string)
        else:
            match = platform_arn_to_solution_stack(solution_string)
    elif PlatformVersion.is_custom_platform_arn(solution_string):
        if find_newer:
            match = platform_version_ops.get_latest_custom_platform_version(solution_string)
        else:
            match = platform_version_ops.find_custom_platform_version_from_string(solution_string)

    # Compare input with complete SolutionStack name and retrieve latest SolutionStack
    # in the series if `find_newer` is set to True
    if not match:
        available_solution_stacks = elasticbeanstalk.get_available_solution_stacks()

        match = SolutionStack.match_with_complete_solution_string(available_solution_stacks, solution_string)
        if match and find_newer:
            language_name = SolutionStack(solution_string).language_name
            match = SolutionStack.match_with_solution_string_language_name(
                available_solution_stacks,
                language_name
            )

    # Compare input with other forms
    for solution_string_matcher in [
        SolutionStack.match_with_solution_string_shorthand,
        SolutionStack.match_with_solution_string_language_name,
        SolutionStack.match_with_pythonified_solution_string,
        SolutionStack.match_with_windows_server_version_string,
    ]:
        if not match:
            match = solution_string_matcher(available_solution_stacks, solution_string)

    # Compare input with custom platform names
    if not match:
        match = platform_version_ops.find_custom_platform_version_from_string(solution_string)

    if not match:
        raise NotFoundError(alerts['platform.invalidstring'].format(solution_string))

    return match


def platform_arn_to_solution_stack(platform_arn):
    """
    Method determines the EB-managed solution stack represented by a PlatformArn

    :param platform_arn: PlatformArn of a solution stack
    :return: SolutionStack representing the PlatformArn if it an EB-managed platform, otherwise None
    """
    if not PlatformVersion.is_eb_managed_platform_arn(platform_arn):
        return

    platform_description = elasticbeanstalk.describe_platform_version(platform_arn)

    return SolutionStack(platform_description['SolutionStackName'])


def prompt_for_solution_stack_version(matching_language_versions):
    """
    Method prompts customer to pick a solution stack version, given a set of platform
    versions of a language

    :param matching_language_versions: A list of platform versions of a language to allow
            the customer to choose from.

                e.g. Given Platform, Ruby, the following options will be presented
                    1. Ruby 2.4 (Passenger standalone)
                    2. Ruby 2.4 (Puma)
                    3. ...

    :return: A string representing te platform version the customer would like to use.
    """
    io.echo()
    io.echo(prompts['sstack.version'])
    language_versions_to_display = [version['PlatformShorthand'] for version in matching_language_versions]

    return utils.prompt_for_item_in_list(language_versions_to_display)


def resolve_language_version(chosen_language_name, solution_stacks):
    """
    Method determines the list of platform versions matching a platform name and
    returns a SolutionStack object representing the platform version the customer
    would like to use.

    :param chosen_language_name: Name of language the customer would like to use
    :param solution_stacks: A list of SolutionStack objects to assemble the list
    of related platform versions from.

    :return: A SolutionStack object representing customer's choice of language
    version.
    """
    matching_language_versions = SolutionStack.group_solution_stacks_by_platform_shorthand(
        solution_stacks,
        language_name=chosen_language_name
    )

    if len(matching_language_versions) > 1:
        version = prompt_for_solution_stack_version(matching_language_versions)
    else:
        version = matching_language_versions[0]['PlatformShorthand']

    for language_version in matching_language_versions:
        if language_version['PlatformShorthand'] == version:
            return language_version['SolutionStack']