octavia-resource-list

#!/usr/bin/env python

from __future__ import print_function
import sys
import os
import time
import collections
import yaml
import openstack


verbose = False

def dict_representer(dumper, data):
    return dumper.represent_dict(data.items())
yaml.add_representer(collections.OrderedDict, dict_representer)

if type(u'string') != str:
    def unicode_representer(dumper, data):
        return dumper.represent_str(str(data))
    yaml.add_representer(unicode, unicode_representer)

def config_from_env():
    config = {}
    for k in ('auth_url', 'project_name', 'username',
              'password', 'region_name'):
        v = os.environ.get('OS_%s' % (k.upper()))
        config[k] = v
    return config


def lbaasv2_print_status(conn):
    subnet_names = {}
    for subnet in conn.network.subnets():
        if subnet.name != '':
            subnet_names[subnet.id] = subnet.name

    status = collections.OrderedDict()

    if verbose:
        print('Get flavor_profile list')
    for fp in conn.load_balancer.flavor_profiles():
        if 'flavorprofiles' not in status:
            status['flavorprofiles'] = collections.OrderedDict()
        status['flavorprofiles'][fp['id']] = collections.OrderedDict([
            ('name', fp['name']),
            ('provider_name', fp['provider_name']),
            ('flavor_data', fp['flavor_data'].strip()),
        ])
    if verbose:
        print('Get flavor list')
    for f in conn.load_balancer.flavors():
        if 'flavors' not in status:
            status['flavors'] = collections.OrderedDict()
        fp_name = status['flavorprofiles'][f['flavor_profile_id']].get('name')
        if fp_name:
            fp_status = " ({})".format(fp_name)
        else:
            fp_status = ""
        status['flavors'][f['id']] = collections.OrderedDict([
            ('name', f['name']),
            ('enabled', f['is_enabled']),
            ('flavor_profile_id', "%s%s" % (f['flavor_profile_id'], fp_status)),
        ])

    try:
        if verbose:
            print('Get amphora list')
        for a in conn.load_balancer.amphorae():
            a_status = collections.OrderedDict([
                ('id', a.id),
                ('role', a.role),
                ('status', a.status),
                ('vrrp_ip', a.vrrp_ip),
                ('ha_ip', a.ha_ip),
                ('lb_network_ip', a.lb_network_ip),
                ('vrrp_port_id', a.vrrp_port_id),
                ('ha_port_id', a.ha_port_id),
            ])
            if 'amphorae' not in status:
                status['amphorae'] = collections.OrderedDict()
            status['amphorae'][a.name if a.name else a.id] = a_status
    except openstack.exceptions.HttpException as e:
        pass

    if verbose:
        print('Get load balancer list')
    for lb in conn.load_balancer.load_balancers():
        subnet_name = subnet_names.get(lb.vip_subnet_id, None)
        if subnet_name:
            subnet_id = "%s (%s)" % (lb.vip_subnet_id,
                                     subnet_name)
        else:
            subnet_id = "%s" % (lb.vip_subnet_id)

        lb_status = collections.OrderedDict([
            ('name', lb.name),
            ('operating_status', lb.operating_status),
            ('provisioning_status', lb.provisioning_status),
            ('vip_address', lb.vip_address),
            ('vip_port_id', lb.vip_port_id),
            ('vip_subnet_id', subnet_id),
            ('listeners', {}),
            ('pools', {}),
            ('statistics', {}),
        ])
        #stats = conn.load_balancer.get_load_balancer_statistics(lb.id)
        #lb_status['statistics'] = {
        #    'total_connections': stats.total_connections,
        #    'active_connections': stats.active_connections,
        #    'request_errors': stats.request_errors,
        #    'bytes_in': stats.bytes_in,
        #    'bytes_out': stats.bytes_out,
        #}
        for l in lb.listeners:
            if verbose:
                print('Get listener')
            listener = conn.load_balancer.get_listener(l['id'])
            d = collections.OrderedDict([
                ('id', listener.id),
                ('operating_status', listener.operating_status),
                ('provisioning_status', listener.provisioning_status),
                ('protocol_port', listener.protocol_port),
                ('protocol', listener.protocol),
                ('connection_limit', listener.connection_limit),
                ('allowed_cidrs', listener.allowed_cidrs),
                ('tls_ciphers', listener.tls_ciphers),
                ('tls_versions', listener.tls_versions),
                ('statistics', {}),
            ])
            #stats = conn.load_balancer.get_listener_statistics(listener.id)
            #d['statistics'] = {
            #    'total_connections': stats.total_connections,
            #    'active_connections': stats.active_connections,
            #    'request_errors': stats.request_errors,
            #    'bytes_in': stats.bytes_in,
            #    'bytes_out': stats.bytes_out,
            #}
            key = listener.name if listener.name else listener.id
            lb_status['listeners'][key] = d

        for p in lb.pools:
            if verbose:
                print('Get pool')
            pool = conn.load_balancer.get_pool(p['id'])
            d = collections.OrderedDict([
                ('id', pool.id),
                ('operating_status', pool.operating_status),
                ('provisioning_status', pool.provisioning_status),
                ('protocol', pool.protocol),
                ('lb_algorithm', pool.lb_algorithm),
                ('tls_enabled', pool.tls_enabled),
                ('tls_ciphers', pool.tls_ciphers),
                ('tls_versions', pool.tls_versions),
                #('session_persistence', pool.session_persistence),
                ('members', {}),
                #('health_monitor', None),
            ])

            if pool.health_monitor_id is not None:
                hm = conn.load_balancer.get_health_monitor(pool.health_monitor_id)
                dh = collections.OrderedDict([
                    ('id', hm.id),
                    ('name', hm.name),
                    ('operating_status', hm.operating_status),
                    ('provisioning_status', hm.provisioning_status),
                    ('type', hm.type),
                ])
                d['health_monitor'] = dh

            for m in pool.members:
                member = conn.load_balancer.get_member(m['id'], pool)
                subnet_name = subnet_names.get(member.subnet_id, None)
                if subnet_name:
                    subnet_id = "%s (%s)" % (member.subnet_id,
                                             subnet_name)
                else:
                    subnet_id = "%s" % (member.subnet_id)
                dm = collections.OrderedDict([
                    ('id', member.id),
                    ('operating_status', member.operating_status),
                    ('provisioning_status', member.provisioning_status),
                    ('address', member.address),
                    ('protocol_port', member.protocol_port),
                    #('monitor_address', member.monitor_address),
                    ('subnet', subnet_id),
                ])
                key = member.name if member.name else member.id
                d['members'][key] = dm

            key = pool.name if pool.name else pool.id
            lb_status['pools'][key] = d

        for ip in conn.network.ips(port_id=lb['vip_port_id']):
            lb_status['floating_ip'] = ip.floating_ip_address

        if 'loadbalancer' not in status:
            status['loadbalancer'] = collections.OrderedDict()

        status['loadbalancer'][lb.id] = lb_status

    print(yaml.dump(status, default_flow_style=False))

def wait_for_lb(lb):
    print("Waiting for %s (%s) to be active" % (lb.name, lb.id), end='')
    sys.stdout.flush()
    while range(0, 120):
        lb = conn.load_balancer.get_load_balancer(lb)
        print(".", end='')
        sys.stdout.flush()
        if lb.provisioning_status == 'ACTIVE':
            print("")
            break
        time.sleep(1)
    else:
        print(lb)
        raise Exception("")

if '-v' in sys.argv[1:]:
    verbose = True

openstack.enable_logging()

conn = openstack.connect(**config_from_env())

lbaasv2_print_status(conn)