tools/test/scenarios/bin/tapiHelper.py

#!/usr/bin/python

import requests
import json
import random
from sets import Set


#
# Creates client-side connectivity json
#
def tapi_client_input(sip_uuids):
    create_input = {
              "tapi-connectivity:input": {
                "end-point" : [
                  {
                    "local-id": sip_uuids[0],
                    "service-interface-point": {
                        "service-interface-point-uuid" : sip_uuids[0]
                    }
                  },
                  {
                    "local-id": sip_uuids[1],
                    "service-interface-point": {
                        "service-interface-point-uuid" : sip_uuids[1]
                    }
                  }
                ]
              }
            }
    return create_input


#
# Creates line-side connectivity json
#
def tapi_line_input(sip_uuids):
    create_input = {
      "tapi-connectivity:input" : {
         "end-point": [
            {
               "layer-protocol-qualifier": "tapi-photonic-media:PHOTONIC_LAYER_QUALIFIER_NMC",
               "role": "UNKNOWN",
               "local-id": "Src_end_point",
               "direction": "BIDIRECTIONAL",
               "service-interface-point": {
                  "service-interface-point-uuid" : sip_uuids[0]
               },
               "protection-role": "WORK",
               "layer-protocol-name": "PHOTONIC_MEDIA"
            },
            {
               "direction": "BIDIRECTIONAL",
               "service-interface-point": {
                  "service-interface-point-uuid": sip_uuids[1]
               },
               "protection-role": "WORK",
               "layer-protocol-name": "PHOTONIC_MEDIA",
               "layer-protocol-qualifier": "tapi-photonic-media:PHOTONIC_LAYER_QUALIFIER_NMC",
               "role": "UNKNOWN",
               "local-id": "Dst_end_point"
            }
         ]
      }
    }
    return create_input


#
# Obtains TAPI context through restconf
#
def get_context(url_context):
    resp = requests.get(url_context, auth=('onos', 'rocks'))
    if resp.status_code != 200:
        raise Exception('GET {}'.format(resp.status_code))
    return resp.json()


#
# Check if the node is transponder.
# True  - transponder
# False - OLS
#
def is_transponder_node(node):
    if len(node["owned-node-edge-point"]) > 0 and "mapped-service-interface-point" in node["owned-node-edge-point"][0]:
        return True
    else:
        return False


#
# Parse src and dst sip-uuids of specific link from topo.
# The ports should be line side but not client side.
#
def parse_src_dst(topo, link_index=-1):
    if link_index == -1:
        # select a link randomly from all links of topo
        link_index = random.randint(0, len(topo["link"]) - 1)
    nep_pair = topo["link"][link_index]["node-edge-point"]
    assert topo["uuid"] == nep_pair[0]["topology-uuid"]
    assert topo["uuid"] == nep_pair[1]["topology-uuid"]
    src_onep, dst_onep = (find_line_onep(nep_pair[0], topo["node"]),
                          find_line_onep(nep_pair[1], topo["node"]))
    if src_onep is not None and dst_onep is not None:
        # If the link is between two transponders directly
        pass
    elif src_onep is None and dst_onep is None:
        raise AssertionError("Impossible for that both two ports are OLS port")
    else:
        # If one of src_onep and dst_onep is None, then make src_onep not None,
        # and find a new dst_onep with same connection id.
        if src_onep is None:
            src_onep = dst_onep
            dst_onep = None
        conn_id = parse_value(src_onep["name"])["odtn-connection-id"]
        for node in topo["node"]:
            cep = src_onep["tapi-connectivity:cep-list"]["connection-end-point"]
            assert len(cep) == 1
            if cep[0]["parent-node-edge-point"]["node-uuid"] != node["uuid"] and is_transponder_node(node):
                # If this node is not the node that includes src_onep, and not a OLS node
                for onep in node["owned-node-edge-point"]:
                    if parse_value(onep["name"])["odtn-connection-id"] == conn_id\
                            and parse_value(onep["name"])["odtn-port-type"] == "line":
                        dst_onep = onep
                        break
            if dst_onep is not None:
                break

    src_sip_uuid, dst_sip_uuid = \
        (src_onep["mapped-service-interface-point"][0]["service-interface-point-uuid"],
         dst_onep["mapped-service-interface-point"][0]["service-interface-point-uuid"])

    return src_onep, dst_onep, src_sip_uuid, dst_sip_uuid


#
# Check whether the sip uuid is used in other existed services.
#
def is_port_used(sip_uuid, conn_context):
    try:
        for service in conn_context["connectivity-service"]:
            for id in [0, 1]:
                if service["end-point"][id]["service-interface-point"]["service-interface-point-uuid"] == sip_uuid:
                    return True
    except KeyError:
        print "There is no line-side service in ONOS now."
    return False


#
# Requests a connectivity service
#
def request_connection(url_connectivity, context):
    # All Context SIPs
    sips = context["tapi-common:context"]["service-interface-point"]

    # Sorted Photonic Media SIPs. filter is an iterable
    esips = list(filter(is_dsr_media, sorted(sips, key=lambda sip: sip["name"][0]["value"])))
    endpoints = [esips[0], esips[-1]]
    sip_uuids = []
    for sip in endpoints:
        sip_uuids.append(sip["uuid"])
    for uuid in sip_uuids:
        print(uuid)

    create_input_json = json.dumps(tapi_client_input(sip_uuids))
    print (create_input_json)
    headers = {'Content-type': 'application/json'}
    resp = requests.post(url_connectivity, data=create_input_json, headers=headers,  auth=('onos', 'rocks'))
    if resp.status_code != 200:
        raise Exception('POST {}'.format(resp.status_code))
    return resp


#
# Filter method used to keep only SIPs that are photonic_media
#
def is_photonic_media(sip):
    return sip["layer-protocol-name"] == "PHOTONIC_MEDIA"


#
# Filter method used to keep only SIPs that are DSR
#
def is_dsr_media(sip):
    return sip["layer-protocol-name"] == "DSR"


#
# Processes the topology to verify the correctness
#
def process_topology():
   # TODO use method to parse topology
   # Getting the Topology
   # topology = context["tapi-common:context"]["tapi-topology:topology-context"]["topology"][0]
   # nodes = topology["node"];
   # links = topology["link"];
   noop


#
# Find mapped client-side sip_uuid according to a line-side sip_uuid.
# connection-ids of these two owned-node-edge-point should be the same.
#
def find_mapped_client_sip_uuid(line_sip_uuid, nodes):
    line_node = None
    line_onep = None
    for node in nodes:
        if is_transponder_node(node):
            for onep in node["owned-node-edge-point"]:
                if onep["mapped-service-interface-point"][0]["service-interface-point-uuid"] == line_sip_uuid:
                    line_node = node
                    line_onep = onep
                    break
    if line_node is None:
        raise AssertionError("Cannot match line-side sip uuid in topology.")
    conn_id = parse_value(line_onep["name"])["odtn-connection-id"]
    for onep in line_node["owned-node-edge-point"]:
        vals = parse_value(onep["name"])
        if vals["odtn-connection-id"] == conn_id and vals["odtn-port-type"] == "client":
            return onep["mapped-service-interface-point"][0]["service-interface-point-uuid"], vals
    return None


#
# Create a client-side connection. Firstly, get the context, parsing for SIPs that connect
# with each other in line-side; Secondly, issue the request
#
def create_client_connection(url_context, url_connectivity):
    headers = {'Content-type': 'application/json'}
    context = get_context(url_context)
    # select the first topo from all topologies
    topo = context["tapi-common:context"]["tapi-topology:topology-context"]["topology"][0]
    # Gather all current used sip_uuids
    used_sip_uuids = Set()
    try:
        services = context["tapi-common:context"]["tapi-connectivity:connectivity-context"]["connectivity-service"]
        for service in services:
            used_sip_uuids.add(service["end-point"][0]["service-interface-point"]["service-interface-point-uuid"])
            used_sip_uuids.add(service["end-point"][1]["service-interface-point"]["service-interface-point-uuid"])
    except KeyError:
        print "There is no existed connectivity service inside ONOS."

    # select the first available line-side service as bridge. If there is no available line-side service,
    # then only create a client-to-client service for src and dst node.
    empty_client_src_sip_uuid, empty_client_dst_sip_uuid = None, None
    empty_src_name, empty_dst_name, empty_client_src_name, empty_client_dst_name = None, None, None, None
    for link_index in range(0, len(topo["link"])):
        src_onep, dst_onep, src_sip_uuid, dst_sip_uuid = parse_src_dst(topo, link_index)
        client_src_sip_uuid, client_src_name = find_mapped_client_sip_uuid(src_sip_uuid, topo["node"])
        client_dst_sip_uuid, client_dst_name = find_mapped_client_sip_uuid(dst_sip_uuid, topo["node"])
        # firstly, check if line-side service exists
        # If line-side service exists
        if src_sip_uuid in used_sip_uuids and dst_sip_uuid in used_sip_uuids:
            # secondly, check if mapped client-side service exists
            if (client_src_sip_uuid not in used_sip_uuids) and (client_dst_sip_uuid not in used_sip_uuids):
                # If there is no such client-side connection exists
                # Create new client-side connection directly
                print "Create client-side connection between %s and %s." % \
                      (client_src_name["onos-cp"], client_dst_name["onos-cp"])
                create_input_json = json.dumps(tapi_client_input((client_src_sip_uuid, client_dst_sip_uuid)))
                resp = requests.post(url_connectivity, data=create_input_json, headers=headers,
                                     auth=('onos', 'rocks'))
                if resp.status_code != 200:
                    raise Exception('POST {}'.format(resp.status_code))
                return resp
            else:
                # If there exists such client-side connection
                # Do nothing, just continue
                pass
        else:
            # If line-side service doesn't exist
            # save 4 sip uuids, and continue
            empty_client_src_sip_uuid = client_src_sip_uuid
            empty_client_dst_sip_uuid = client_dst_sip_uuid
            empty_client_src_name = client_src_name
            empty_client_dst_name = client_dst_name
            empty_src_name = parse_value(src_onep["name"])
            empty_dst_name = parse_value(dst_onep["name"])
            pass

    # After FOR loop, if this method doesn't return, there is no available line-side
    # service for mapped client-side service creation.
    # So, we need to create two client-side services.
    if empty_client_src_sip_uuid is None:
        # None case means all client-side services exist.
        raise AssertionError("There is no available client-side service could be created.")
    else:
        print "Create client-side services:"
        print "\t- from %s to %s." % (empty_client_src_name["onos-cp"], empty_client_dst_name["onos-cp"])
        print "This service should go through:"
        print "\t- %s and %s." % (empty_src_name["onos-cp"], empty_dst_name["onos-cp"])
        create_input_json = json.dumps(tapi_client_input((empty_client_src_sip_uuid, empty_client_dst_sip_uuid)))
        resp = requests.post(url_connectivity, data=create_input_json, headers=headers,
                             auth=('onos', 'rocks'))
        if resp.status_code != 200:
            raise Exception('POST {}'.format(resp.status_code))
        return resp


#
# Parse array structure "name" under structure "owned node edge point"
#
def parse_value(arr):
    rtn = {}
    for item in arr:
        rtn[item["value-name"]] = item["value"]
    return rtn


#
# Find node edge point of node structure in topology with client-side port, by using nep with line-side port.
# The odtn-connection-id should be the same in both line-side nep and client-side nep
#
def find_client_onep(line_nep_in_link, nodes):
    for node in nodes:
        if node["uuid"] == line_nep_in_link["node-uuid"]:
            conn_id = None
            for onep in node["owned-node-edge-point"]:
                if onep["uuid"] == line_nep_in_link["node-edge-point-uuid"]:
                    name = parse_value(onep["name"])
                    if name["odtn-port-type"] == "line":
                        conn_id = name["odtn-connection-id"]
                        break
            if conn_id is None:
                raise AssertionError("Cannot find owned node edge point with node id %s and nep id %s."
                                     % (line_nep_in_link["node-uuid"], line_nep_in_link["node-edge-point-uuid"], ))
            for onep in node["owned-node-edge-point"]:
                name = parse_value(onep["name"])
                if name["odtn-port-type"] == "client" and name["odtn-connection-id"] == conn_id:
                    return onep

    return None


#
# Create a line-side connection. Firstly, get the context, parsing for SIPs with photonic_media type,
# and select one pair of them; Secondly, issue the request
#
def create_line_connection(url_context, url_connectivity):
    context = get_context(url_context)
    # select the first topo from all topologies
    topo = context["tapi-common:context"]["tapi-topology:topology-context"]["topology"][0]
    # select randomly the src_sip_uuid and dst_sip_uuid with same connection id.
    src_onep, dst_onep, src_sip_uuid, dst_sip_uuid = parse_src_dst(topo)
    while is_port_used(src_sip_uuid, context["tapi-common:context"]["tapi-connectivity:connectivity-context"]):
        print "Conflict occurs between randomly selected line-side link and existed ones."
        src_onep, dst_onep, src_sip_uuid, dst_sip_uuid = parse_src_dst(topo)

    print "\nBuild line-side connectivity:\n|Item|SRC|DST|\n|:--|:--|:--|\n|onos-cp|%s|%s|\n|connection id|%s|%s|\n|sip uuid|%s|%s|" % \
          (src_onep["name"][2]["value"], dst_onep["name"][2]["value"],
           src_onep["name"][1]["value"], dst_onep["name"][1]["value"],
           src_sip_uuid, dst_sip_uuid)
    create_input_json = json.dumps(tapi_line_input((src_sip_uuid, dst_sip_uuid)))
    print "\nThe json content of creation operation for line-side connectivity service is \n\t\t%s." % \
          create_input_json
    headers = {'Content-type': 'application/json'}
    resp = requests.post(url_connectivity, data=create_input_json, headers=headers, auth=('onos', 'rocks'))
    if resp.status_code != 200:
        raise Exception('POST {}'.format(resp.status_code))
    return resp


#
# find owned-node-edge-point from all nodes according to line_nep_in_links
#
def find_line_onep(line_nep_in_link, nodes):
    for node in nodes:
        if node["uuid"] == line_nep_in_link["node-uuid"]:
            if not is_transponder_node(node):
                break
            for onep in node["owned-node-edge-point"]:
                if onep["uuid"] == line_nep_in_link["node-edge-point-uuid"]:
                    # check the length equals 1 to verify the 1-to-1 mapping relationship
                    assert len(onep["mapped-service-interface-point"]) == 1
                    return onep
    # When node is OLS, this method will return None
    return None


#
# Obtains existing connectivity services
#
def get_connection(url_connectivity, uuid):
    # uuid is useless for this method
    json = '{}'
    headers = {'Content-type': 'application/json'}
    resp = requests.post(url_connectivity, data=json, headers=headers,  auth=('onos', 'rocks'))
    if resp.status_code != 200:
            raise Exception('POST {}'.format(resp.status_code))
    return resp