rwlaunchpad/ra/pytest/ns/ha/conftest.py

#!/usr/bin/env python3
"""
# 
#   Copyright 2017 RIFT.IO Inc
#
#   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.
#
"""

import pytest
import subprocess
import os
import time

import rift.vcs.vcs
import rift.auto.mano as mano

from gi.repository import (
    RwConmanYang,
    RwUserYang,
    RwProjectYang,
    RwRbacInternalYang,
    RwRbacPlatformYang,
    RwCloudYang,
)

@pytest.fixture(scope='session')
def ha_mgmt_sessions(sut_host_addrs, session_type):
    """Fixture that returns mgmt sessions for active, standby LPs"""
    sessions = {}
    for name,addr in sut_host_addrs.items():
        if session_type == 'netconf':
            mgmt_session = rift.auto.session.NetconfSession(host=addr)
        elif session_type == 'restconf':
            mgmt_session = rift.auto.session.RestconfSession(host=addr)

        if 'standby' in name:
            sessions['standby'] = mgmt_session
        elif 'active' in name:
            sessions['active'] = mgmt_session
            mgmt_session.connect()
            rift.vcs.vcs.wait_until_system_started(mgmt_session)

    return sessions

@pytest.fixture(scope='session')
def active_mgmt_session(ha_mgmt_sessions):
    """Fixture that returns mgmt sessions for active LP"""
    return ha_mgmt_sessions['active']

@pytest.fixture(scope='session')
def standby_mgmt_session(ha_mgmt_sessions):
    """Fixture that returns mgmt sessions for standby LP"""
    return ha_mgmt_sessions['standby']

@pytest.fixture(scope='session')
def active_confd_host(active_mgmt_session):
    """Fixture that returns mgmt sessions for active LP"""
    return active_mgmt_session.host

@pytest.fixture(scope='session')
def standby_confd_host(standby_mgmt_session):
    """Fixture that returns mgmt sessions for standby LP"""
    return standby_mgmt_session.host

@pytest.fixture(scope='session')
def revertive_pref_host(active_mgmt_session):
    """Fixture that returns mgmt sessions for active LP"""
    return active_mgmt_session.host

@pytest.fixture(scope='session')
def active_site_name(active_mgmt_session):
    """Fixture that returns mgmt sessions for active LP"""
    return 'site-a'

@pytest.fixture(scope='session')
def standby_site_name(standby_mgmt_session):
    """Fixture that returns mgmt sessions for standby LP"""
    return 'site-b'

@pytest.fixture(scope='session', autouse=True)
def redundancy_config_setup(logger, active_confd_host, standby_confd_host, active_mgmt_session):
    """Fixture that prepares the rw-redundancy-config.xml file and copies it to RVR of active, standby systems;
    starts the mock dns script in the revertive-preference host.
    It assumes system-tests are running containers where launchpad runs in production mode"""

    # Starts the mock dns script in revertive-preference host which is the active system.
    ssh_mock_dns_cmd = 'ssh -n -o BatchMode=yes -o StrictHostKeyChecking=no {revertive_pref_host} -- "python3 /usr/rift/usr/rift/systemtest/util/test_mock_dns.py --active-site site-a {active_host} --standby-site site-b {standby_host}"'.format(
        revertive_pref_host=active_confd_host, active_host=active_confd_host, standby_host=standby_confd_host)
    logger.debug('Running mock dns script in host {host}; cmd: {ssh_cmd}'.format(host=active_confd_host,
                                                                                 ssh_cmd=ssh_mock_dns_cmd))
    subprocess.Popen(ssh_mock_dns_cmd, shell=True)
    # Have to check if the script ran fine

    # Prepares the rw-redundancy-config.xml file
    redundancy_cfg_file_path = os.path.join(os.getenv('RIFT_INSTALL'),
                                            'usr/rift/systemtest/config/rw-redundancy-config.xml')
    with open(redundancy_cfg_file_path) as f:
        file_content = f.read()

    with open(redundancy_cfg_file_path+'.auto', 'w') as f:
        new_content = file_content.replace('1.1.1.1', active_confd_host).replace('2.2.2.2', standby_confd_host)
        logger.debug('redundancy config file content: {}'.format(new_content))
        f.write(new_content)

    # Copies the redundancy config file to active, standby systems
    for host_addr in (active_confd_host, standby_confd_host):
        scp_cmd = 'scp -o StrictHostkeyChecking=no {file_path} {host}:/usr/rift/var/rift/rw-redundancy-config.xml'.format(
            file_path=redundancy_cfg_file_path+'.auto', host=host_addr)
        logger.debug(
            'Copying redundancy config xml to host {host}; scp cmd: {scp_cmd}'.format(host=host_addr, scp_cmd=scp_cmd))
        assert os.system(scp_cmd) == 0

    # Restart the launchpad service in active, standby systems
    for host_addr in (active_confd_host, standby_confd_host):
        ssh_launchpad_restart_cmd = 'ssh -n -o BatchMode=yes -o StrictHostKeyChecking=no {host} -- "sudo pkill rwmain"'.format(
            host=host_addr)
        logger.debug('Restarting launchpad service in host {host}. cmd: {ssh_cmd}'.format(host=host_addr,
                                                                                          ssh_cmd=ssh_launchpad_restart_cmd))
        assert os.system(ssh_launchpad_restart_cmd.format(host=host_addr)) == 0
        time.sleep(30)

    active_mgmt_session.connect()
    rift.vcs.vcs.wait_until_system_started(active_mgmt_session)
    mano.verify_ha_redundancy_state(active_mgmt_session)

@pytest.fixture(scope='session')
def ha_lp_nodes(sut_host_addrs, session_type):
    """Fixture that returns rift.auto.mano.LpNode objects for active, standby LPs"""
    lp_nodes = {}
    for name,addr in sut_host_addrs.items():
        lp_node = mano.LpNode(host=addr, session_type=session_type, connect=False)
        if 'standby' in name:
            lp_nodes['standby'] = lp_node
        elif 'active' in name:
            lp_nodes['active'] = lp_node

    return lp_nodes

@pytest.fixture(scope='session')
def active_lp_node_obj(ha_lp_nodes):
    """Fixture that returns rift.auto.mano.LpNode object for active LP"""
    return ha_lp_nodes['active']

@pytest.fixture(scope='session')
def standby_lp_node_obj(ha_lp_nodes):
    """Fixture that returns rift.auto.mano.LpNode object for standby LP"""
    return ha_lp_nodes['standby']

@pytest.fixture(scope='session')
def rw_active_user_proxy(active_mgmt_session):
    return active_mgmt_session.proxy(RwUserYang)

@pytest.fixture(scope='session')
def rw_active_project_proxy(active_mgmt_session):
    return active_mgmt_session.proxy(RwProjectYang)

@pytest.fixture(scope='session')
def rw_active_rbac_int_proxy(active_mgmt_session):
    return active_mgmt_session.proxy(RwRbacInternalYang)

@pytest.fixture(scope='session')
def rw_active_conman_proxy(active_mgmt_session):
    return active_mgmt_session.proxy(RwConmanYang)

@pytest.fixture(scope='session')
def rbac_active_platform_proxy(active_mgmt_session):
    return active_mgmt_session.proxy(RwRbacPlatformYang)

@pytest.fixture(scope='session')
def rw_active_cloud_pxy(active_mgmt_session):
    return active_mgmt_session.proxy(RwCloudYang)