Exemplo n.º 1
0
def test_component_load_balancer_namelength(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "HealthCheckPath": "/healthcheck"
    }
    info = {'StackName': 'foobar' * 5, 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr(
        'senza.components.elastic_load_balancer.find_ssl_certificate_arn',
        mock_string_result)
    monkeypatch.setattr(
        'senza.components.elastic_load_balancer.resolve_security_groups',
        mock_string_result)

    try:
        component_elastic_load_balancer(definition, configuration, args, info,
                                        False)
    except click.UsageError:
        pass
    except:
        assert False, "check for supported protocols returns unknown Exception"
    else:
        assert False, "check for supported protocols failed"
Exemplo n.º 2
0
def test_component_load_balancer_healthcheck(monkeypatch):
    configuration = {"Name": "test_lb", "SecurityGroups": "", "HTTPPort": "9999", "HealthCheckPath": "/healthcheck"}

    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr("senza.components.elastic_load_balancer.find_ssl_certificate_arn", mock_string_result)
    monkeypatch.setattr("senza.components.elastic_load_balancer.resolve_security_groups", mock_string_result)

    result = component_elastic_load_balancer(definition, configuration, args, MagicMock(), False)
    # Defaults to HTTP
    assert "HTTP:9999/healthcheck" == result["Resources"]["test_lb"]["Properties"]["HealthCheck"]["Target"]

    # Supports other AWS protocols
    configuration["HealthCheckProtocol"] = "TCP"
    result = component_elastic_load_balancer(definition, configuration, args, MagicMock(), False)
    assert "TCP:9999/healthcheck" == result["Resources"]["test_lb"]["Properties"]["HealthCheck"]["Target"]

    # Will fail on incorrect protocol
    configuration["HealthCheckProtocol"] = "MYFANCYPROTOCOL"
    try:
        component_elastic_load_balancer(definition, configuration, args, MagicMock(), False)
    except click.UsageError:
        pass
    except:
        assert False, "check for supported protocols failed"
Exemplo n.º 3
0
def test_component_load_balancer_healthcheck(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "HealthCheckPath": "/healthcheck"
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr(
        'senza.components.elastic_load_balancer.resolve_security_groups',
        mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)

    result = component_elastic_load_balancer(definition, configuration, args,
                                             info, False, MagicMock())
    # Defaults to HTTP
    assert "HTTP:9999/healthcheck" == result["Resources"]["test_lb"][
        "Properties"]["HealthCheck"]["Target"]

    # Support own health check port
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    configuration["HealthCheckPort"] = "1234"
    result = component_elastic_load_balancer(definition, configuration, args,
                                             info, False, MagicMock())
    assert "HTTP:1234/healthcheck" == result["Resources"]["test_lb"][
        "Properties"]["HealthCheck"]["Target"]
    del (configuration["HealthCheckPort"])

    # Supports other AWS protocols
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    configuration["HealthCheckProtocol"] = "TCP"
    result = component_elastic_load_balancer(definition, configuration, args,
                                             info, False, MagicMock())
    assert "TCP:9999" == result["Resources"]["test_lb"]["Properties"][
        "HealthCheck"]["Target"]

    # Will fail on incorrect protocol
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    configuration["HealthCheckProtocol"] = "MYFANCYPROTOCOL"
    try:
        component_elastic_load_balancer(definition, configuration, args, info,
                                        False, MagicMock())
    except click.UsageError:
        pass
    except:
        assert False, "check for supported protocols returns unknown Exception"
    else:
        assert False, "check for supported protocols failed"
Exemplo n.º 4
0
def test_component_load_balancer_namelength(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "HealthCheckPath": "/healthcheck"
    }
    info = {'StackName': 'foobar'*5, 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.find_ssl_certificate_arn', mock_string_result)
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    try:
        component_elastic_load_balancer(definition, configuration, args, info, False)
    except click.UsageError:
        pass
    except:
        assert False, "check for supported protocols returns unknown Exception"
    else:
        assert False, "check for supported protocols failed"
Exemplo n.º 5
0
def test_component_load_balancer_healthcheck(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "HealthCheckPath": "/healthcheck"
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)

    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    # Defaults to HTTP
    assert "HTTP:9999/healthcheck" == result["Resources"]["test_lb"]["Properties"]["HealthCheck"]["Target"]

    # Support own health check port
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    configuration["HealthCheckPort"] = "1234"
    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert "HTTP:1234/healthcheck" == result["Resources"]["test_lb"]["Properties"]["HealthCheck"]["Target"]
    del(configuration["HealthCheckPort"])

    # Supports other AWS protocols
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    configuration["HealthCheckProtocol"] = "TCP"
    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert "TCP:9999/healthcheck" == result["Resources"]["test_lb"]["Properties"]["HealthCheck"]["Target"]

    # Will fail on incorrect protocol
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    configuration["HealthCheckProtocol"] = "MYFANCYPROTOCOL"
    try:
        component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    except click.UsageError:
        pass
    except:
        assert False, "check for supported protocols returns unknown Exception"
    else:
        assert False, "check for supported protocols failed"
Exemplo n.º 6
0
def test_component_load_balancer_idletimeout(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "ConnectionSettings": {"IdleTimeout": 300}
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)

    # issue 105: support additional ELB properties
    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert 300 == result["Resources"]["test_lb"]["Properties"]["ConnectionSettings"]["IdleTimeout"]
    assert 'HTTPPort' not in result["Resources"]["test_lb"]["Properties"]
Exemplo n.º 7
0
def component_weighted_dns_elastic_load_balancer(definition, configuration,
                                                 args, info, force,
                                                 account_info):
    if 'Domains' not in configuration:
        if 'MainDomain' in configuration:
            main_domain = configuration['MainDomain']
            main_subdomain, main_zone = main_domain.split('.', 1)
            del configuration['MainDomain']
        else:
            main_zone = account_info.Domain
            main_subdomain = info['StackName']

        if 'VersionDomain' in configuration:
            version_domain = configuration['VersionDomain']
            version_subdomain, version_zone = version_domain.split('.', 1)
            del configuration['VersionDomain']
        else:
            version_zone = account_info.Domain
            version_subdomain = '{}-{}'.format(info['StackName'],
                                               info['StackVersion'])

        configuration['Domains'] = {
            'MainDomain': {
                'Type': 'weighted',
                'Zone': '{}.'.format(main_zone.rstrip('.')),
                'Subdomain': main_subdomain
            },
            'VersionDomain': {
                'Type': 'standalone',
                'Zone': '{}.'.format(version_zone.rstrip('.')),
                'Subdomain': version_subdomain
            }
        }
    return component_elastic_load_balancer(definition, configuration, args,
                                           info, force, account_info)
def component_weighted_dns_elastic_load_balancer(definition, configuration, args, info, force, account_info):
    if 'Domains' not in configuration:
        if 'MainDomain' in configuration:
            main_domain = configuration['MainDomain']
            main_subdomain, main_zone = account_info.split_domain(main_domain)
            del configuration['MainDomain']
        else:
            main_zone = account_info.Domain
            main_subdomain = info['StackName']

        if 'VersionDomain' in configuration:
            version_domain = configuration['VersionDomain']
            version_subdomain, version_zone = account_info.split_domain(version_domain)
            del configuration['VersionDomain']
        else:
            version_zone = account_info.Domain
            version_subdomain = '{}-{}'.format(info['StackName'], info['StackVersion'])

        configuration['Domains'] = {'MainDomain': {'Type': 'weighted',
                                                   'Zone': '{}.'.format(main_zone.rstrip('.')),
                                                   'Subdomain': main_subdomain},
                                    'VersionDomain': {'Type': 'standalone',
                                                      'Zone': '{}.'.format(version_zone.rstrip('.')),
                                                      'Subdomain': version_subdomain}}
    return component_elastic_load_balancer(definition, configuration, args, info, force, account_info)
Exemplo n.º 9
0
def test_component_load_balancer_listeners_ssl(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "Listeners": [{
            "Protocol": "SSL"
        }]
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr(
        'senza.components.elastic_load_balancer.resolve_security_groups',
        mock_string_result)

    get_ssl_cert = MagicMock()
    get_ssl_cert.return_value = 'my-ssl-arn'
    monkeypatch.setattr('senza.components.elastic_load_balancer.get_ssl_cert',
                        get_ssl_cert)

    result = component_elastic_load_balancer(definition, configuration, args,
                                             info, False, MagicMock())
    assert 'my-ssl-arn' == result["Resources"]["test_lb"]["Properties"][
        "Listeners"][0]["SSLCertificateId"]
Exemplo n.º 10
0
def test_component_load_balancer_http_only(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "SSLCertificateId":
        "arn:none",  # should be ignored as we overwrite Listeners
        "Listeners": [{
            "Foo": "Bar"
        }]
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr(
        'senza.components.elastic_load_balancer.resolve_security_groups',
        mock_string_result)

    result = component_elastic_load_balancer(definition, configuration, args,
                                             info, False, MagicMock())
    assert 'Bar' == result["Resources"]["test_lb"]["Properties"]["Listeners"][
        0]["Foo"]
Exemplo n.º 11
0
def test_component_load_balancer_namelength(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "HealthCheckPath": "/healthcheck"
    }
    info = {'StackName': 'foobar' * 5, 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)

    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    lb_name = result['Resources']['test_lb']['Properties']['LoadBalancerName']
    assert lb_name == 'foobarfoobarfoobarfoobarfoob-0.1'
    assert len(lb_name) == 32
Exemplo n.º 12
0
def test_component_load_balancer_cert_arn(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "SSLCertificateId": "foo2"
    }

    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"

    m_acm.get_certificates.return_value = iter([m_acm_certificate])

    m_acm_certificate.is_arn_certificate.return_value = True
    m_acm_certificate.get_by_arn.return_value = True

    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACMCertificate', m_acm_certificate)

    # issue 105: support additional ELB properties
    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert "foo2" == result["Resources"]["test_lb"]["Properties"]["Listeners"][0]["SSLCertificateId"]
def component_weighted_dns_elastic_load_balancer(definition, configuration, args, info, force):
    if 'Domains' not in configuration:

        if 'MainDomain' in configuration:
            main_domain = configuration['MainDomain']
            main_subdomain, main_zone = main_domain.split('.', 1)
            del configuration['MainDomain']
        else:
            main_zone = get_default_zone(args.region)
            main_subdomain = info['StackName']

        if 'VersionDomain' in configuration:
            version_domain = configuration['VersionDomain']
            version_subdomain, version_zone = version_domain.split('.', 1)
            del configuration['VersionDomain']
        else:
            version_zone = get_default_zone(args.region)
            version_subdomain = '{}-{}'.format(info['StackName'], info['StackVersion'])

        configuration['Domains'] = {'MainDomain': {'Type': 'weighted',
                                                   'Zone': main_zone,
                                                   'Subdomain': main_subdomain},
                                    'VersionDomain': {'Type': 'standalone',
                                                      'Zone': version_zone,
                                                      'Subdomain': version_subdomain}}
    return component_elastic_load_balancer(definition, configuration, args, info, force)
Exemplo n.º 14
0
def test_component_load_balancer_namelength(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "HealthCheckPath": "/healthcheck"
    }
    info = {'StackName': 'foobar' * 5, 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)

    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    lb_name = result['Resources']['test_lb']['Properties']['LoadBalancerName']
    assert lb_name == 'foobarfoobarfoobarfoobarfoob-0.1'
    assert len(lb_name) == 32
Exemplo n.º 15
0
def test_component_load_balancer_cert_arn(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "SSLCertificateId": "foo2"
    }

    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"

    m_acm.get_certificates.return_value = iter([m_acm_certificate])

    m_acm_certificate.is_arn_certificate.return_value = True
    m_acm_certificate.get_by_arn.return_value = True

    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACMCertificate', m_acm_certificate)

    # issue 105: support additional ELB properties
    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert "foo2" == result["Resources"]["test_lb"]["Properties"]["Listeners"][0]["SSLCertificateId"]
Exemplo n.º 16
0
def test_component_load_balancer_idletimeout(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "ConnectionSettings": {"IdleTimeout": 300}
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    m_acm = MagicMock()
    m_acm_certificate = MagicMock()
    m_acm_certificate.arn = "foo"
    m_acm.get_certificates.return_value = iter([m_acm_certificate])
    monkeypatch.setattr('senza.components.elastic_load_balancer.ACM', m_acm)

    # issue 105: support additional ELB properties
    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert 300 == result["Resources"]["test_lb"]["Properties"]["ConnectionSettings"]["IdleTimeout"]
    assert 'HTTPPort' not in result["Resources"]["test_lb"]["Properties"]
Exemplo n.º 17
0
def test_component_load_balancer_default_internal_scheme(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999"
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert 'internal' == result["Resources"]["test_lb"]["Properties"]["Scheme"]
Exemplo n.º 18
0
def test_component_load_balancer_default_internal_scheme(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999"
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert 'internal' == result["Resources"]["test_lb"]["Properties"]["Scheme"]
Exemplo n.º 19
0
def test_component_load_balancer_http_only(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "SSLCertificateId": "arn:none",  # should be ignored as we overwrite Listeners
        "Listeners": [{"Foo": "Bar"}]
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert 'Bar' == result["Resources"]["test_lb"]["Properties"]["Listeners"][0]["Foo"]
Exemplo n.º 20
0
def test_component_load_balancer_listeners_ssl(monkeypatch):
    configuration = {
        "Name": "test_lb",
        "SecurityGroups": "",
        "HTTPPort": "9999",
        "Listeners": [{"Protocol": "SSL"}]
    }
    info = {'StackName': 'foobar', 'StackVersion': '0.1'}
    definition = {"Resources": {}}

    args = MagicMock()
    args.region = "foo"

    mock_string_result = MagicMock()
    mock_string_result.return_value = "foo"
    monkeypatch.setattr('senza.components.elastic_load_balancer.resolve_security_groups', mock_string_result)

    get_ssl_cert = MagicMock()
    get_ssl_cert.return_value = 'my-ssl-arn'
    monkeypatch.setattr('senza.components.elastic_load_balancer.get_ssl_cert', get_ssl_cert)

    result = component_elastic_load_balancer(definition, configuration, args, info, False, MagicMock())
    assert 'my-ssl-arn' == result["Resources"]["test_lb"]["Properties"]["Listeners"][0]["SSLCertificateId"]
def component_weighted_dns_elastic_load_balancer(definition, configuration, args, info, force):
    if 'Domains' not in configuration:

        if 'MainDomain' in configuration:
            main_domain = configuration['MainDomain']
            main_subdomain, main_zone = main_domain.split('.', 1)
        else:
            main_zone = get_default_zone(args.region)
            main_subdomain = info['StackName']

        if 'VersionDomain' in configuration:
            version_domain = configuration['VersionDomain']
            version_subdomain, version_zone = version_domain.split('.', 1)
        else:
            version_zone = get_default_zone(args.region)
            version_subdomain = '{}-{}'.format(info['StackName'], info['StackVersion'])

        configuration['Domains'] = {'MainDomain': {'Type': 'weighted',
                                                   'Zone': main_zone,
                                                   'Subdomain': main_subdomain},
                                    'VersionDomain': {'Type': 'standalone',
                                                      'Zone': version_zone,
                                                      'Subdomain': version_subdomain}}
    return component_elastic_load_balancer(definition, configuration, args, info, force)