def test_lbaas_l7(cmgr, subnet_id, http_server_list, l7_server_list,
                  security_group_id, lb_name=None, lb_timeout=900,
                  protocol='HTTP', protocol_port=80, ip_version=4,
                  delay=4, max_retries=3, monitor_type="PING",
                  monitor_timeout=10, public_network_id=None, **kwargs):
    public_network_id = kwargs.pop('public_network_id', None)
    lb_name = lb_name if lb_name else lbaas2.data_utils.rand_name('lb2')
    load_balancer = cmgr.lbaas('loadbalancer-create', subnet_id,
                               name=lb_name)
    loadbalancer_id = load_balancer['id']
    cmgr.lbaas('loadbalancer_waitfor_active', loadbalancer_id,
               timeout=lb_timeout)
    fip = lbaas2.assign_floatingip_to_vip(cmgr, lb_name,
                                          public_network_id=public_network_id,
                                          security_group_id=security_group_id)
    lb_vip_address = fip.get('floating_ip_address')
    # create pool/listern/http_server_list for all http traffic
    listener1 = cmgr.lbaas('listener-create', name='listener1',
                           loadbalancer_id=loadbalancer_id,
                           protocol=protocol,
                           protocol_port=protocol_port)
    cmgr.lbaas('loadbalancer_waitfor_active', loadbalancer_id,
               timeout=lb_timeout)
    pool1 = cmgr.lbaas('pool-create', name='pool1',
                       lb_algorithm='ROUND_ROBIN',
                       listener_id=listener1.get('id'), protocol=protocol)
    cmgr.lbaas('loadbalancer_waitfor_active', loadbalancer_id,
               timeout=lb_timeout)
    member1_list = []
    for sv_id in http_server_list:
        server = cmgr.nova('server-show', sv_id)
        fixed_ip_address = lbaas2.LB_NET.get_server_ip_address(server,
                                                               'fixed')
        member = cmgr.lbaas('member-create', pool1.get('id'),
                            subnet_id=subnet_id,
                            address=fixed_ip_address,
                            protocol_port=protocol_port)
        member1_list.append(member)
        cmgr.lbaas('loadbalancer_waitfor_active', loadbalancer_id,
                   timeout=lb_timeout)
    run_cnt = 10
    cnt_dict = lbaas2.count_http_servers(lb_vip_address, run_cnt)
    tot_cnt = 0
    for sn, cnt in cnt_dict.items():
        tot_cnt += cnt
    if (not tot_cnt == run_cnt):
        raise Exception("Expect %d responses, got %d" % (run_cnt, tot_cnt))

    build_l7_switching(cmgr, subnet_id, loadbalancer_id,
                       listener1.get('id'),
                       l7_server_list, protocol=protocol,
                       protocol_port=protocol_port, lb_timeout=lb_timeout)

    # test l7 forwarding depending on URL prefix
    run_l7_switching(http_server_list, lb_vip_address, '')
    run_l7_switching(http_server_list, lb_vip_address, 'xapi')
    run_l7_switching(l7_server_list, lb_vip_address, 'api')
def poke_http_stats_change(nsxt_client, cmgr, lb2_name,
                           interval=5.0, poke_count=100,
                           no_http_traffic=False):
    lb2_fip = lbaas2.get_loadbalancer_floatingip(cmgr, lb2_name)
    lb2_web_ip = lb2_fip[1]['floating_ip_address']
    lb = cmgr.lbaas('loadbalancer-show', lb2_name)
    lb_port = cmgr.qsvc('port-show', lb['vip_port_id'])
    os_security_group_id = lb_port['security_groups'][0]
    _sgroup = cmgr.qsvc('security-group-show', os_security_group_id)
    msg = "os-security-group-id = %s" % (os_security_group_id)
    utils.log_msg(msg, 'CHK-Stats')

    sg_rules = _sgroup['security_group_rules']
    http_rule = [x for x in sg_rules if x['port_range_min'] >= 80][0]

    filters = {'os-neutron-secgr-id': os_security_group_id}
    fw_list = nsxt_client.list_firewall_sections(**filters)
    sect_id = fw_list[0].get('id')

    fw_rules = nsxt_client.get_firewall_section_rules(sect_id)
    rule = [x for x in fw_rules if x['display_name'] == http_rule.get('id')]
    rule_id = rule[0].get('id')

    msg = "NSX STATS is at section[%s] rule_id[%s]" % (sect_id, rule_id)
    utils.log_msg(msg, 'CHK-Stats')
    nsx_stats = nsxt_client.get_firewall_section_rule_stats(sect_id, rule_id)
    os_stats1 = log_lb2_stats(cmgr, lb2_name)

    if  no_http_traffic:
        utils.log_msg("No http traffic initiated", 'CHK-Stats')
    else:
        lbaas2.count_http_servers(lb2_web_ip)

    m_stats_change(nsxt_client, sect_id, rule_id, nsx_stats,
                   cmgr, lb2_name,
                   interval=interval, poke_count=poke_count)

    os_stats2 = log_lb2_stats(cmgr, lb2_name)

    dd = {}
    for k in os_stats2.keys():
        dd[k] = int(os_stats2[k]) - int(os_stats1[k])
    utils.log_msg("%s" % str(dd), "OS-STATS-DIFF")
def run_l7_switching(on_server_name_list, lb_vip_address, url_path='',
                     count=4):
    resp_urls = lbaas2.count_http_servers(lb_vip_address,
                                          count=count,
                                          url_path=url_path)
    if not url_responses_are_OK(resp_urls, on_server_name_list):
        utils.log_msg("http://%s/%s redirected to wrong pool" % (
            lb_vip_address, url_path), "LBaaS-L7 ERROR")
        return False
    return True