示例#1
0
 def test_write_structured_data_with_no_device(self):
     with patch('uniconfig_worker.requests.put') as mock:
         mock.return_value = mock.return_value = MockResponse(
             bytes(json.dumps({}), encoding='utf-8'), 404, "")
         request = uniconfig_worker.write_structured_data({
             "inputData": {
                 "device_id":
                 "",
                 "uri":
                 "/frinx-openconfig-interfaces:interfaces/interface=Loopback01",
                 "template":
                 "{\"interface\":[{\"name\":\"Loopback01\","
                 "\"config\":{"
                 "\"type\":\"iana-if-type:softwareLoopback\","
                 "\"enabled\":false,"
                 "\"name\":\"Loopback01\","
                 "\"prefix\": \"aaa\"}}]}",
                 "params": {}
             }
         })
         self.assertEqual(request["status"], "FAILED")
         self.assertEqual(
             request["output"]["url"], odl_url_base +
             "/data/network-topology:network-topology/topology=uniconfig/node=/"
             "frinx-uniconfig-topology:configuration/"
             "frinx-openconfig-interfaces:interfaces/interface=Loopback01")
         self.assertEqual(request["output"]["response_code"], 404)
def put_interface_policy(device):
    if device.in_policy is None and device.out_policy is None:
        return

    url = Template(odl_url_uniconfig_ifc_policy_config).substitute({'ifc': device.interface})
    ifc_config = {
        "frinx-openconfig-network-instance:interface": [
            {
                "interface-id": device.interface,
                "config": {
                    "interface-id": device.interface
                }
            }
        ]
    }

    if device.in_policy is not None:
        ifc_config['frinx-openconfig-network-instance:interface'][0]['config']['frinx-brocade-pf-interfaces-extension:input-service-policy'] = device.in_policy
    if device.out_policy is not None:
        ifc_config['frinx-openconfig-network-instance:interface'][0]['config']['frinx-brocade-pf-interfaces-extension:output-service-policy'] = device.out_policy

    ifc_response = uniconfig_worker.write_structured_data({'inputData': {
        'device_id': device.id,
        'uri': url,
        "template": ifc_config,
        'params': {}
    }})
    ifc_response.update({'ifc_data': ifc_config})
    return ifc_response
示例#3
0
def put_ve_interface(service, device):
    url = Template(vll_service_worker.odl_url_uniconfig_ifc_config).substitute(
        {'ifc': device.ve_interface})
    ifc_config = {
        "frinx-openconfig-interfaces:interface": [{
            "name": device.ve_interface,
            "config": {
                "type": "iana-if-type:l3ipvlan",
                "enabled": True,
                "name": device.ve_interface,
                "description": "IUP-" + service.id,
            }
        }]
    }

    if device.ip is not None:
        x = device.ip.split('/')
        ifc_config["frinx-openconfig-interfaces:interface"][0].update({
            "subinterfaces": {
                "subinterface": [{
                    "index": 0,
                    "config": {
                        "index": 0
                    },
                    "frinx-openconfig-if-ip:ipv4": {
                        "addresses": {
                            "address": [{
                                "ip": x[0],
                                "config": {
                                    "prefix-length": x[1],
                                    "ip": x[0]
                                }
                            }]
                        }
                    }
                }]
            }
        })

    if device.vlan is not None:
        ifc_config['frinx-openconfig-interfaces:interface'][0].update({
            "frinx-openconfig-vlan:routed-vlan": {
                "config": {
                    "vlan": device.vlan
                }
            }
        })

    ifc_response = uniconfig_worker.write_structured_data({
        'inputData': {
            'device_id': device.id,
            'uri': url,
            "template": ifc_config,
            'params': {}
        }
    })
    ifc_response.update({'ifc_data': ifc_config})
    return ifc_response
示例#4
0
def device_create_vpls(task):
    vpls_config = create_vpls_request(task)
    response = uniconfig_worker.write_structured_data({
        'inputData': {
            'device_id':
            task['inputData']['id'],
            'uri':
            (Template(odl_url_uniconfig_network_instance_config).substitute(
                {'vpls': (task['inputData']['service_id'])})),
            'template':
            vpls_config,
            'params': {}
        }
    })
    response.update({'vpls_data': vpls_config})
    return response
示例#5
0
 def test_write_structured_data_with_bad_template(self):
     with patch('uniconfig_worker.requests.put') as mock:
         mock.return_value = MockResponse(
             bytes(json.dumps(bad_input_response), encoding='utf-8'), 400,
             "")
         request = uniconfig_worker.write_structured_data({
             "inputData": {
                 "device_id":
                 "xr5",
                 "uri":
                 "/frinx-openconfig-interfaces:interfaces/interface=Loopback01",
                 "template":
                 "{\"interface\":[{\"name\":\"Loopback01\","
                 "\"config\":{"
                 "\"type\":\"iana-if-type:softwareLoopback\","
                 "\"enabled\":false,"
                 "\"name\":\"Loopback01\","
                 "\"prefix\": \"aaa\"}}]}",
                 "params": {}
             }
         })
         self.assertEqual(request["status"], "FAILED")
         self.assertEqual(
             request["output"]["url"], odl_url_base +
             "/data/network-topology:network-topology/topology=uniconfig/node=xr5/"
             "frinx-uniconfig-topology:configuration/"
             "frinx-openconfig-interfaces:interfaces/interface=Loopback01")
         self.assertEqual(request["output"]["response_code"], 400)
         self.assertEqual(
             request["output"]["response_body"]['errors']['error'][0]
             ["error-type"], "protocol")
         self.assertEqual(
             request["output"]["response_body"]['errors']['error'][0]
             ["error-message"],
             "Error parsing input: com.google.common.util.concurrent.UncheckedExecutionException: "
             "java.lang.IllegalStateException: Schema node with name prefix was not found under "
             "(http://frinx.openconfig.net/yang/interfaces?revision=2016-12-22)config."
         )
         self.assertEqual(
             request["output"]["response_body"]['errors']['error'][0]
             ["error-tag"], "malformed-message")
def put_minimal_interface(device):
    url = Template(odl_url_uniconfig_ifc_config).substitute({'ifc': device.interface})
    ifc_config = {
        "frinx-openconfig-interfaces:interface": [
            {
                "name": device.interface,
                "config": {
                    "type": "iana-if-type:ethernetCsmacd",
                    "enabled": True,
                    "name": device.interface
                }
            }
        ]
    }

    ifc_response = uniconfig_worker.write_structured_data({'inputData': {
        'device_id': device.id,
        'uri': url,
        "template": ifc_config,
        'params': {}
    }})
    ifc_response.update({'ifc_data': ifc_config})
    return ifc_response
示例#7
0
def put_vlan(service, device):
    url = Template(odl_url_uniconfig_vlan_config).substitute(
        {'vlan': device.vlan})
    vlan_config = {
        "frinx-openconfig-network-instance:vlan": [{
            "vlan-id": device.vlan,
            "config": {
                "vlan-id": device.vlan,
                "status": "ACTIVE",
                "name": service.id
            }
        }]
    }

    vlan_response = uniconfig_worker.write_structured_data({
        'inputData': {
            'device_id': device.id,
            'uri': url,
            "template": vlan_config,
            'params': {}
        }
    })
    vlan_response.update({'vlan_data': vlan_config})
    return vlan_response
示例#8
0
def put_isis(device):
    url = Template(odl_url_uniconfig_isis_config).substitute(
        {'ifc': device.ve_interface})
    isis_config = {
        "frinx-openconfig-network-instance:interface": [{
            "interface-id":
            device.ve_interface,
            "config": {
                "interface-id": device.ve_interface,
                "passive": True
            }
        }]
    }

    isis_response = uniconfig_worker.write_structured_data({
        'inputData': {
            'device_id': device.id,
            'uri': url,
            "template": isis_config,
            'params': {}
        }
    })
    isis_response.update({'isis_data': isis_config})
    return isis_response
def put_interface(service, device):
    url = Template(odl_url_uniconfig_ifc_config).substitute({'ifc': device.interface})
    ifc_config = {
        "frinx-openconfig-interfaces:interface": [
            {
                "name": device.interface,
                "config": {
                    "type": "iana-if-type:ethernetCsmacd",
                    "enabled": True,
                    "name": device.interface,
                    "description": device.description if device.description else service.id,
                    "frinx-brocade-if-extension:priority": 3,
                    "frinx-brocade-if-extension:priority-force": True
                }
            }
        ]
    }

    if device.auto_negotiate is not None:
        ifc_config['frinx-openconfig-interfaces:interface'][0].update({"frinx-openconfig-if-ethernet:ethernet": {
            "config": {
                "auto-negotiate": device.auto_negotiate
            }
        }})

    if device.tpid is not None:
        ifc_config['frinx-openconfig-interfaces:interface'][0]['config']["frinx-openconfig-vlan:tpid"] = Device.switch_tpid.get(device.tpid)

    ifc_response = uniconfig_worker.write_structured_data({'inputData': {
        'device_id': device.id,
        'uri': url,
        "template": ifc_config,
        'params': {}
    }})
    ifc_response.update({'ifc_data': ifc_config})
    return ifc_response
示例#10
0
def put_interface(service, device):
    url = Template(vll_service_worker.odl_url_uniconfig_ifc_config).substitute(
        {'ifc': device.interface})
    ifc_config = {
        "frinx-openconfig-interfaces:interface": [{
            "name": device.interface,
            "config": {
                "type":
                "iana-if-type:ethernetCsmacd",
                "enabled":
                True,
                "name":
                device.interface,
                "description":
                "IUP-" +
                device.description if device.description else "IUP-phys-" +
                service.id,
                "frinx-brocade-if-extension:priority":
                3,
                "frinx-brocade-if-extension:priority-force":
                True
            },
            "frinx-openconfig-if-ethernet:ethernet": {
                "frinx-openconfig-vlan:switched-vlan": {
                    "config": {
                        "interface-mode":
                        "ACCESS" if device.untagged else "TRUNK"
                    }
                }
            }
        }]
    }

    if device.untagged:
        ifc_config["frinx-openconfig-interfaces:interface"][0][
            'frinx-openconfig-if-ethernet:ethernet'][
                'frinx-openconfig-vlan:switched-vlan']['config'][
                    "access-vlan"] = device.vlan
    else:
        ifc_config["frinx-openconfig-interfaces:interface"][0][
            'frinx-openconfig-if-ethernet:ethernet'][
                'frinx-openconfig-vlan:switched-vlan']['config'][
                    "trunk-vlans"] = [device.vlan]

    if device.auto_negotiate is not None:
        ifc_config['frinx-openconfig-interfaces:interface'][0].update({
            "frinx-openconfig-if-ethernet:ethernet": {
                "config": {
                    "auto-negotiate": device.auto_negotiate
                }
            }
        })

    if device.tpid is not None:
        ifc_config['frinx-openconfig-interfaces:interface'][0]['config'][
            "frinx-openconfig-vlan:tpid"] = Device.switch_tpid.get(device.tpid)

    ifc_response = uniconfig_worker.write_structured_data({
        'inputData': {
            'device_id': device.id,
            'uri': url,
            "template": ifc_config,
            'params': {}
        }
    })
    ifc_response.update({'ifc_data': ifc_config})
    return ifc_response