← Back to branch summary

~ajkavanagh/+junk/useful-things

« back to all changes in this revision

Viewing changes to manual-openstack-testing/neutron-ext-net.py

  • Committer: Alex Kavanagh
  • Date: 2018-06-13 15:19:26 UTC
  • Revision ID: alex.kavanagh@canonical.com-20180613151926-6l76h23eu3vsh127
Add the rest of the bastion interesting files

Show diffs side-by-side

added added

removed removed

Lines of Context:
manual-openstack-testing/neutron-ext-net.py
 
1
#!/usr/bin/env python3
 
2
 
 
3
# from charm-openstack-testing!
 
4
 
 
5
from neutronclient.v2_0 import client
 
6
 
 
7
from keystoneclient.v2_0 import client as ks_client
 
8
from keystoneclient.auth import identity
 
9
from keystoneclient import session
 
10
import optparse
 
11
import os
 
12
import sys
 
13
import logging
 
14
 
 
15
 
 
16
usage = """Usage: %prog [options] ext_net_name
 
17
 
 
18
For example:
 
19
 
 
20
  %prog -g 192.168.21.1 -c 192.168.21.0/25 \\
 
21
      -f 192.168.21.100:192.168.21.200 ext_net
 
22
"""
 
23
 
 
24
if __name__ == '__main__':
 
25
    parser = optparse.OptionParser(usage)
 
26
    parser.add_option('-t', '--tenant',
 
27
                      help='Tenant name to create network for',
 
28
                      dest='tenant', action='store',
 
29
                      default=None)
 
30
    parser.add_option("-d", "--debug",
 
31
                      help="Enable debug logging",
 
32
                      dest="debug", action="store_true", default=False)
 
33
    parser.add_option("-g", "--gateway",
 
34
                      help="Default gateway to use.",
 
35
                      dest="default_gateway", action="store", default=None)
 
36
    parser.add_option("-c", "--cidr",
 
37
                      help="CIDR of external network.",
 
38
                      dest="cidr", action="store", default=None)
 
39
    parser.add_option("-f", "--floating-range",
 
40
                      help="Range of floating IP's to use (separated by :).",
 
41
                      dest="floating_range", action="store", default=None)
 
42
    parser.add_option("--network-type",
 
43
                      help="Network type.",
 
44
                      dest="network_type", action="store", default='gre')
 
45
    (opts, args) = parser.parse_args()
 
46
 
 
47
    if len(args) != 1:
 
48
        parser.print_help()
 
49
        sys.exit(1)
 
50
 
 
51
    if opts.debug:
 
52
        logging.basicConfig(level=logging.DEBUG)
 
53
    else:
 
54
        logging.basicConfig(level=logging.INFO)
 
55
 
 
56
    net_name = args[0]
 
57
    subnet_name = '{}_subnet'.format(net_name)
 
58
 
 
59
    if (opts.floating_range):
 
60
        (start_floating_ip, end_floating_ip) = opts.floating_range.split(':')
 
61
    else:
 
62
        start_floating_ip = None
 
63
        end_floating_ip = None
 
64
 
 
65
    # use session based authentication
 
66
    ep = os.environ['OS_AUTH_URL']
 
67
    if not ep.endswith('v2.0'):
 
68
        ep = "{}/v2.0".format(ep)
 
69
    print("ep: {}".format(ep))
 
70
    auth = identity.v2.Password(username=os.environ['OS_USERNAME'],
 
71
                                password=os.environ['OS_PASSWORD'],
 
72
                                tenant_name=os.environ['OS_TENANT_NAME'],
 
73
                                auth_url=ep)
 
74
    sess = session.Session(auth=auth)
 
75
    print("Session: {}".format(sess))
 
76
    keystone = ks_client.Client(session=sess)
 
77
    keystone.auth_ref = auth.get_access(sess)
 
78
    print("Keystone: {}".format(keystone))
 
79
    neutron_ep = keystone.service_catalog.url_for(
 
80
            service_type='network', endpoint_type='publicURL')
 
81
    print("neutron_ep: {}".format(neutron_ep))
 
82
    neutron = client.Client(session=sess)
 
83
    print("neutron: {}".format(neutron))
 
84
 
 
85
    # Resolve tenant id
 
86
    tenant_id = None
 
87
    print("about to do tenants list")
 
88
    print(keystone.tenants.list())
 
89
    for tenant in [t._info for t in keystone.tenants.list()]:
 
90
        if (tenant['name'] == (opts.tenant or os.environ['OS_TENANT_NAME'])):
 
91
            tenant_id = tenant['id']
 
92
            break  # Tenant ID found - stop looking
 
93
    if not tenant_id:
 
94
        logging.error("Unable to locate tenant id for %s.", opts.tenant)
 
95
        sys.exit(1)
 
96
    print("tenant_id: {}".format(tenant_id))
 
97
 
 
98
    networks = neutron.list_networks(name=net_name)
 
99
    if len(networks['networks']) == 0:
 
100
        logging.info("Configuring external network '%s'", net_name)
 
101
        network_msg = {
 
102
            'network': {
 
103
                'name': net_name,
 
104
                'router:external': True,
 
105
                'tenant_id': tenant_id,
 
106
                'provider:network_type': opts.network_type,
 
107
            }
 
108
        }
 
109
 
 
110
        if opts.network_type == 'vxlan':
 
111
            network_msg['network']['provider:segmentation_id'] = 1234
 
112
        elif opts.network_type == 'vlan':
 
113
            network_msg['network']['provider:segmentation_id'] = 2
 
114
            network_msg['network']['provider:physical_network'] = 'physnet1'
 
115
        elif opts.network_type == 'flat':
 
116
            network_msg['network']['provider:physical_network'] = 'physnet1'
 
117
        else:
 
118
            network_msg['network']['provider:segmentation_id'] = 2
 
119
 
 
120
        logging.info('Creating new external network definition: %s', net_name)
 
121
        network = neutron.create_network(network_msg)['network']
 
122
        logging.info('New external network created: %s', network['id'])
 
123
    else:
 
124
        logging.warning('Network %s already exists.', net_name)
 
125
        network = networks['networks'][0]
 
126
 
 
127
    subnets = neutron.list_subnets(name=subnet_name)
 
128
    if len(subnets['subnets']) == 0:
 
129
        subnet_msg = {
 
130
            'name': subnet_name,
 
131
            'network_id': network['id'],
 
132
            'enable_dhcp': False,
 
133
            'ip_version': 4,
 
134
            'tenant_id': tenant_id
 
135
        }
 
136
 
 
137
        if opts.default_gateway:
 
138
            subnet_msg['gateway_ip'] = opts.default_gateway
 
139
        if opts.cidr:
 
140
            subnet_msg['cidr'] = opts.cidr
 
141
        if (start_floating_ip and end_floating_ip):
 
142
            subnet_msg['allocation_pools'] = [{
 
143
                'start': start_floating_ip,
 
144
                'end': end_floating_ip
 
145
            }]
 
146
 
 
147
        logging.info('Creating new subnet for %s', net_name)
 
148
        subnet = neutron.create_subnet({'subnet': subnet_msg})['subnet']
 
149
        logging.info('New subnet created: %s', subnet['id'])
 
150
    else:
 
151
        logging.warning('Subnet %s already exists.', subnet_name)
 
152
        subnet = subnets['subnets'][0]
 
153
 
 
154
    routers = neutron.list_routers(name='provider-router')
 
155
    if len(routers['routers']) == 0:
 
156
        logging.info('Creating provider router for external network access')
 
157
        router = neutron.create_router(
 
158
            {'router': {'name': 'provider-router', 'tenant_id': tenant_id}}
 
159
        )['router']
 
160
        logging.info('New router created: %s', (router['id']))
 
161
    else:
 
162
        logging.warning('Router provider-router already exists.')
 
163
        router = routers['routers'][0]
 
164
 
 
165
    ports = neutron.list_ports(device_owner='network:router_gateway',
 
166
                               network_id=network['id'])
 
167
    if len(ports['ports']) == 0:
 
168
        logging.info('Plugging router into ext_net')
 
169
        router = (
 
170
            neutron.add_gateway_router(
 
171
                            router=router['id'],
 
172
                            body={'network_id': network['id']}))
 
173
        logging.info('Router connected to %s', net_name)
 
174
    else:
 
175
        logging.warning('Router already connect to %s', net_name)