#!/usr/bin/python2.6
#
# Copyright (c) 2015, Oracle and/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. You may obtain
# a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License 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.

#
# This script migrates the network, subnet and port information from EVS DB to
# neutron-server DB. It also re-creates routers and floatingips tables with
# Neutron's l3 schema. This script needs to be run for the proper upgrade of
# Neutron from Havana to Juno release.
#

import ConfigParser
import rad.connect as radcon
import rad.bindings.com.oracle.solaris.rad.evscntl as evsc

from neutron import context as ctx
from neutron.db import common_db_mixin
from neutron.db import api as db
from neutron.db import model_base
from neutron.plugins.evs.migrate import havana_api

import sqlalchemy as sa
from sqlalchemy import MetaData
from sqlalchemy.orm import sessionmaker
from sqlalchemy.schema import DropConstraint
from sqlalchemy import sql

from oslo.config import cfg
from oslo.db import options as db_options
from oslo.db import exception as excp


def create_db_network(nw, engine, ext_ro):
    ''' Method for creating networks table in the neutron-server DB
        Input params:
        @nw - Dictionary with values from EVS DB
        @engine - SQL engine
        @ext_ro - External router
    '''
    # Importing locally because these modules end up importing neutron.wsgi
    # which causes RAD to hang
    from neutron.db import db_base_plugin_v2
    from neutron.db import external_net_db as ext_net
    model_base.BASEV2.metadata.bind = engine
    model_base.BASEV2.metadata.create_all(engine)
    ctxt = ctx.get_admin_context()
    inst = db_base_plugin_v2.NeutronDbPluginV2()
    dup = False
    try:
        db_base_plugin_v2.NeutronDbPluginV2.create_network(inst, ctxt, nw)
        print "\nnetwork=%s added" % nw['network']['name']
        if ext_ro:
            ext_nw = ext_net.ExternalNetwork(network_id=nw['network']['id'])
            session = sessionmaker()
            session.configure(bind=engine)
            s = session()
            s.add(ext_nw)
            s.commit()
    except excp.DBDuplicateEntry:
        print "\nnetwork '%s' already exists" % nw['network']['name']
        dup = True
    return dup


def create_db_subnet(sub):
    ''' Method for creating subnets table in the neutron-server DB
        Input params:
        @sub - Dictionary with values from EVS DB
    '''
    # Importing locally because this module ends up importing neutron.wsgi
    # which causes RAD to hang
    from neutron.db import db_base_plugin_v2
    ctxt = ctx.get_admin_context()
    inst = db_base_plugin_v2.NeutronDbPluginV2()
    try:
        db_base_plugin_v2.NeutronDbPluginV2.create_subnet(inst, ctxt, sub)
        print "\nsubnet=%s added" % sub['subnet']['id']
    except excp.DBDuplicateEntry:
        print "\nsubnet '%s' already exists" % sub['subnet']['id']


def create_db_port(port):
    ''' Method for creating ports table in the neutron-server DB
        Input params:
        @port - Dictionary with values from EVS DB
    '''
    # Importing locally because this module ends up importing neutron.wsgi
    # which causes RAD to hang
    from neutron.db import db_base_plugin_v2
    ctxt = ctx.get_admin_context()
    inst = db_base_plugin_v2.NeutronDbPluginV2()
    try:
        db_base_plugin_v2.NeutronDbPluginV2.create_port(inst, ctxt, port)
        print "\nport=%s added" % port['port']['id']
    except excp.DBDuplicateEntry:
        print "\nport '%s' already exists" % port['port']['id']


def main():
    print "Start Migration."

    # Connect to EVS controller
    config = ConfigParser.RawConfigParser()
    config.readfp(open("/etc/neutron/plugins/evs/evs_plugin.ini"))
    if config.has_option("EVS", 'evs_controller'):
        config_suh = config.get("EVS", 'evs_controller')
    else:
        config_suh = 'ssh://evsuser@localhost'
    suh = config_suh.split('://')
    if len(suh) != 2 or suh[0] != 'ssh' or not suh[1].strip():
        raise SystemExit(_("Specified evs_controller is invalid"))
    uh = suh[1].split('@')
    if len(uh) != 2 or not uh[0].strip() or not uh[1].strip():
        raise SystemExit(_("'user' and 'hostname' need to be specified "
                           "for evs_controller"))
    try:
        rc = radcon.connect_ssh(uh[1], user=uh[0])
    except:
        raise SystemExit(_("Cannot connect to EVS Controller"))
    try:
        evs_contr = rc.get_object(evsc.EVSController())
    except:
        raise SystemExit(_("Could not retrieve EVS info from EVS Controller"))
    evsinfo = evs_contr.getEVSInfo()
    if not evsinfo:
        raise SystemExit(_("No data to migrate"))

    config.readfp(open("/etc/neutron/neutron.conf"))
    if config.has_option("database", 'connection'):
        SQL_CONNECTION = config.get("database", 'connection')
    else:
        SQL_CONNECTION = 'sqlite:////var/lib/neutron/neutron.sqlite'

    conf = cfg.CONF
    db_options.set_defaults(cfg.CONF,
                            connection=SQL_CONNECTION,
                            sqlite_db='', max_pool_size=10,
                            max_overflow=20, pool_timeout=10)

    neutron_engine = sa.create_engine(SQL_CONNECTION)
    router_port_ids = {}

    for e in evsinfo:
        ext_ro = False
        for p in e.props:
            if p.name == 'OpenStack:router:external' and p.value == 'True':
                ext_ro = True
        # Populate networks table
        n = {
            'tenant_id': e.tenantname,
            'id': e.uuid,
            'name': e.name,
            'status': 'ACTIVE',
            'admin_state_up': True,
            'shared': False
            }
        nw = {'network': n}
        dup = create_db_network(nw, neutron_engine, ext_ro)
        if dup:
            continue  # No need to iterate over subnets and ports

        # Populate subnets table
        for i in e.ipnets:
            cidr = None
            gateway_ip = None
            enable_dhcp = None
            dns = []
            host = []
            start = []
            for p in i.props:
                if p.name == 'subnet':
                    cidr = p.value
                elif p.name == 'defrouter':
                    gateway_ip = p.value
                elif p.name == 'OpenStack:enable_dhcp':
                    enable_dhcp = p.value == 'True'
                elif p.name == 'OpenStack:dns_nameservers':
                    dns = p.value.split(',')
                elif p.name == 'OpenStack:host_routes':
                    hh = p.value.split(',')
                    for h in range(0, len(hh), 2):
                        d = {hh[h]: hh[h+1]}
                        host.append(d)
                elif p.name == 'pool':
                    ss = p.value.split(',')
                    for s in ss:
                        if '-' in s:
                            d = {'start': s.split('-')[0],
                                 'end': s.split('-')[1]}
                            start.append(d)
                        else:
                            d = {'start': s, 'end': s}
                            start.append(d)
            ip_version = 4 if i.ipvers == evsc.IPVersion.IPV4 else 6

            if i.name.startswith(i.uuid[:8]):
                # Skip autogenerated names
                name = None
            else:
                name = i.name
            s = {
                'tenant_id': i.tenantname,
                'id': i.uuid,
                'name': name,
                'network_id': e.uuid,
                'ip_version': ip_version,
                'cidr': cidr,
                'gateway_ip': gateway_ip,
                'enable_dhcp': enable_dhcp,
                'shared': False,
                'allocation_pools': start,
                'dns_nameservers': dns,
                'host_routes': host
                }

            sub = {'subnet': s}
            create_db_subnet(sub)

        # Populate ports table
        for j in e.vports:
            device_owner = ''
            device_id = ''
            mac_address = None
            ipaddr = None
            for v in j.props:
                if v.name == 'OpenStack:device_owner':
                    device_owner = v.value
                    if v.value in ('network:router_interface',
                                   'network:router_gateway'):
                        router_port_ids[j.uuid] = v.value
                elif v.name == 'OpenStack:device_id':
                    device_id = v.value
                elif v.name == 'macaddr':
                    mac_address = v.value
                elif v.name == 'ipaddr':
                    ipaddr = v.value.split('/')[0]
            if j.name.startswith(j.uuid[:8]):
                # Skip autogenerated names
                name = None
            else:
                name = j.name

            p = {
                'tenant_id': j.tenantname,
                'id': j.uuid,
                'name': name,
                'network_id': e.uuid,
                'mac_address': mac_address,
                'admin_state_up': True,
                'status': 'ACTIVE',
                'device_id': device_id,
                'device_owner': device_owner,
                'fixed_ips': [{'subnet_id': e.ipnets[0].uuid,
                               'ip_address': ipaddr}]
                }
            port = {'port': p}
            create_db_port(port)

    # Change the schema of the floatingips and routers tables by doing
    # the following:
    #     Fetch the floatingip, router entry using EVS API,
    #     Temporarily store the information,
    #     Delete floatingip, router entry,
    #     Remove floatingip, router as a constraint from existing tables,
    #     Drop the routers, floatingips table,
    #     Add router, floatingip entry using Neutron API

    # Importing locally because this module ends up importing neutron.wsgi
    # which causes RAD to hang
    from neutron.db import l3_db
    havana_api.configure_db()
    session = havana_api.get_session()

    # Fetch the floatingip entry using EVS API
    query = session.query(havana_api.FloatingIP)
    floatingips = query.all()
    fl = []
    if floatingips:
        for f in floatingips:
            fi = {
                'id': f['id'],
                'floating_ip_address': f['floating_ip_address'],
                'floating_network_id': f['floating_network_id'],
                'floating_port_id': f['floating_port_id'],
                'fixed_port_id': f['fixed_port_id'],
                'fixed_ip_address': f['fixed_ip_address'],
                'tenant_id': f['tenant_id'],
                'router_id': f['router_id'],
                }
            fl.append(fi)

        # Delete floatingip entry
        ctxt = ctx.get_admin_context()
        ctxt = havana_api.get_evs_context(ctxt)
        with ctxt.session.begin(subtransactions=True):
            cm_db_inst = common_db_mixin.CommonDbMixin()
            query = common_db_mixin.CommonDbMixin._model_query(cm_db_inst,
                                                               ctxt,
                                                               havana_api.
                                                               FloatingIP)
            for fip in query:
                ctxt.session.delete(fip)

    # Fetch the router entry using EVS API
    query = session.query(havana_api.Router)
    routers = []
    try:
        routers = query.all()
    except sa.exc.OperationalError:
        pass
    if routers:
        for r in routers:
            router_id = r['id']
            rt = {
                'tenant_id': r['tenant_id'],
                'id': r['id'],
                'name': r['name'],
                'admin_state_up': r['admin_state_up'],
                'gw_port_id': r['gw_port_id'],
                'status': 'ACTIVE'
                }

        # Delete router entry
        ctxt = ctx.get_admin_context()
        ctxt = havana_api.get_evs_context(ctxt)
        with ctxt.session.begin(subtransactions=True):
            cm_db_inst = common_db_mixin.CommonDbMixin()
            query = common_db_mixin.CommonDbMixin._model_query(cm_db_inst,
                                                               ctxt,
                                                               havana_api.
                                                               Router)
            router = query.filter(havana_api.Router.id == router_id).one()
            ctxt.session.delete(router)

    engine = sa.create_engine(SQL_CONNECTION)
    meta = MetaData()
    conn = engine.connect()
    trans = conn.begin()
    meta.reflect(engine)

    # Remove router as a constraint from existing tables,
    # Drop the routers table to remove old schema
    for t in meta.tables.values():
        for fk in t.foreign_keys:
            if fk.column.table.name == "routers":
                engine.execute(DropConstraint(fk.constraint))
    for t in meta.tables.values():
        if t.name == "routers":
            t.drop(bind=conn)

    # Remove floatingip as a constraint from existing tables,
    # Drop the floatingip table to remove old schema
    for t in meta.tables.values():
        for fk in t.foreign_keys:
            if fk.column.table.name == "floatingips":
                engine.execute(DropConstraint(fk.constraint))
    for t in meta.tables.values():
        if t.name == "floatingips":
            t.drop(bind=conn)
    conn.close()

    # Add the routers and floatingips using the schema in l3_db.py

    setattr(l3_db.Router, 'enable_snat', sa.Column(sa.Boolean,
            default=True, server_default=sql.true(), nullable=False))
    neutron_engine = sa.create_engine(SQL_CONNECTION)
    model_base.BASEV2.metadata.bind = neutron_engine
    model_base.BASEV2.metadata.create_all(neutron_engine)
    if routers:
        ctxt = ctx.get_admin_context()
        with ctxt.session.begin(subtransactions=True):
            router_db = l3_db.Router(id=router_id,
                                     tenant_id=r['tenant_id'],
                                     name=rt['name'],
                                     admin_state_up=rt['admin_state_up'],
                                     gw_port_id=rt['gw_port_id'],
                                     status="ACTIVE")
            ctxt.session.add(router_db)
            print "\nrouter=%s updated" % rt['name']
        with ctxt.session.begin(subtransactions=True):
            for i, j in router_port_ids.iteritems():
                router_port = l3_db.RouterPort(
                    port_id=i,
                    router_id=router_id,
                    port_type=j)
                ctxt.session.add(router_port)

    if floatingips:
        ctxt = ctx.get_admin_context()
        with ctxt.session.begin(subtransactions=True):
            for i in fl:
                fl_db = l3_db.FloatingIP(
                    id=i['id'],
                    floating_ip_address=i['floating_ip_address'],
                    floating_network_id=i['floating_network_id'],
                    floating_port_id=i['floating_port_id'],
                    fixed_port_id=i['fixed_port_id'],
                    fixed_ip_address=i['fixed_ip_address'],
                    router_id=i['router_id'],
                    tenant_id=i['tenant_id'])
                ctxt.session.add(fl_db)
                print "\nfloatingip=%s updated" % i['floating_ip_address']

    print "\nEnd Migration."


if __name__ == '__main__':
    main()