self.process_element(state, event, element)
element.clear()
# debugging code to stop after the named test case is processed
- if "s1-t1" in self.pdata:
- break
+ # if "s1-t1" in self.pdata:
+ # break
root.clear()
def write_pdata(self):
--- /dev/null
+from model import Model
+
+
+NAME = "elan"
+
+
+def elan_instances(store, ip=None, port=None, path=None):
+ return ElanInstances(NAME, ElanInstances.CONTAINER, store, ip, port, path)
+
+
+def elan_interfaces(store, ip=None, port=None, path=None):
+ return ElanInstances(NAME, ElanInstances.CONTAINER, store, ip, port, path)
+
+
+class ElanInstances(Model):
+ CONTAINER = "elan-instances"
+ ELAN_INSTANCE = "elan-instance"
+
+ def get_elan_instances(self):
+ return self.data[self.CONTAINER][self.ELAN_INSTANCE]
+
+ def get_elan_instances_by_key(self, key="elan-instance-name"):
+ d = {}
+ instances = self.get_elan_instances()
+ for instance in instances:
+ d[instance[key]] = instance
+ return d
+
+
+class ElanInterfaces(Model):
+ CONTAINER = "elan-interfaces"
+ ELAN_INSTANCE = "elan-instance"
+
+ def get_elan_interfaces(self):
+ return self.data[self.CONTAINER][self.ELAN_INSTANCE]
+
+ def get_elan_interfaces_by_key(self, key="name"):
+ d = {}
+ ifaces = self.get_elan_ifaces()
+ for iface in ifaces:
+ d[iface[key]] = iface
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "id-manager"
+
+
+def id_pools(store, ip=None, port=None, path=None):
+ return IdPools(NAME, IdPools.CONTAINER, store, ip, port, path)
+
+
+class IdPools(Model):
+ CONTAINER = "id-pools"
+ ID_POOL = "id-pool"
+
+ def get_id_pools(self):
+ return self.data[self.CONTAINER][self.ID_POOL]
+
+ def get_id_pools_by_key(self, key="pool-name"):
+ d = {}
+ idpools = self.get_id_pools()
+ for idpool in idpools:
+ d[idpool[key]] = idpool
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "ietf-interfaces"
+
+
+def interfaces(store, ip=None, port=None, path=None):
+ return Interfaces(NAME, Interfaces.CONTAINER, store, ip, port, path)
+
+
+def interfaces_state(store, ip=None, port=None, path=None):
+ return Interfaces(NAME, InterfacesState.CONTAINER, store, ip, port, path)
+
+
+class Interfaces(Model):
+ CONTAINER = "interfaces"
+ INTERFACE = "interface"
+
+ def get_interfaces(self):
+ return self.data[self.CONTAINER][self.INTERFACE]
+
+ def get_interfaces_by_key(self, key="name"):
+ d = {}
+ ifaces = self.get_interfaces()
+ for iface in ifaces:
+ d[iface[key]] = iface
+ return d
+
+
+class InterfacesState(Model):
+ ROOT = NAME
+ CONTAINER = "interfaces-state"
+ INTERFACE = "interface"
+
+ def get_interfaces(self):
+ return self.data[self.CONTAINER][self.INTERFACE]
+
+ def get_interfaces_by_key(self, key="name"):
+ d = {}
+ ifaces = self.get_interfaces()
+ for iface in ifaces:
+ d[iface[key]] = iface
+ return d
+
+
+class InterfacesState(Model):
+ ROOT = NAME
+ CONTAINER = "interfaces-state"
+ INTERFACE = "interface"
+
+ def get_interfaces(self):
+ return self.data[self.CONTAINER][self.INTERFACE]
+
+ def get_interfaces_by_key(self, key="name"):
+ d = {}
+ ifaces = self.get_interfaces()
+ for iface in ifaces:
+ d[iface[key]] = iface
+ return d
--- /dev/null
+import collections
+from model import Model
+
+
+NAME = "interface-service-bindings"
+
+
+def service_bindings(store, ip=None, port=None, path=None):
+ return ServiceBindings(NAME, ServiceBindings.CONTAINER, store, ip, port, path)
+
+
+class ServiceBindings(Model):
+ CONTAINER = "service-bindings"
+ SERVICES_INFO = "services-info"
+
+ def get_services_infos(self):
+ return self.data[self.CONTAINER][self.SERVICES_INFO]
+
+ def get_service_bindings(self):
+ sb_dict = collections.defaultdict(dict)
+ orphans_dict = collections.defaultdict(dict)
+ sb_infos = self.get_services_infos()
+ for sb_info in sb_infos:
+ service_mode = sb_info['service-mode'][len('interface-service-bindings:'):]
+ if sb_info.get('bound-services'):
+ sb_dict[sb_info['interface-name']][service_mode] = sb_info
+ else:
+ orphans_dict[sb_info['interface-name']][service_mode] = sb_info
+ return dict(sb_dict), dict(orphans_dict)
-from models import Model
+from model import Model
NAME = "itm-state"
+def dpn_endpoints(store, ip, port, path):
+ return DpnEndpoints(NAME, DpnEndpoints.CONTAINER, store, ip, port, path)
+
+
+def interfaces(store, ip=None, port=None, path=None):
+ return DpnTepsState(NAME, DpnTepsState.CONTAINER, store, ip, port, path)
+
+
+def tunnels_state(store, ip=None, port=None, path=None):
+ return TunnelsState(NAME, TunnelsState.CONTAINER, store, ip, port, path)
+
+
class DpnEndpoints(Model):
CONTAINER = "dpn-endpoints"
DPN_TEPS_INFO = "DPN-TEPs-info"
TUNNEL_END_POINTS = "tunnel-end-points"
IP_ADDRESS = "ip-address"
- # not currently used, backup method to get_kv
- def item_generator(self, json_input, lookup_key):
- if isinstance(json_input, dict):
- for k, v in json_input.iteritems():
- if k == lookup_key:
- yield v
- else:
- for child_val in self.item_generator(v, lookup_key):
- yield child_val
- elif isinstance(json_input, list):
- for item in json_input:
- for item_val in self.item_generator(item, lookup_key):
- yield item_val
-
def get_dpn_teps_infos(self):
return self.data[self.CONTAINER][self.DPN_TEPS_INFO]
return tunnel_endpoints[0][self.IP_ADDRESS]
-def dpn_endpoints(store, ip, port):
- return DpnEndpoints(NAME, DpnEndpoints.CONTAINER, store, ip, port)
+class DpnTepsState(Model):
+ CONTAINER = "dpn-teps-state"
+ DPN_TEPS = "dpns-teps"
+
+ def get_dpn_teps(self):
+ return self.data[self.CONTAINER][self.DPN_TEPS]
+
+ def get_tuninterfaces_by_name(self):
+ d = {}
+ tunifaces = self.get_dpn_teps()
+ for sourcedpn in tunifaces:
+ for remotedpn in sourcedpn['remote-dpns']:
+ d[remotedpn['tunnel-name']] = remotedpn
+ return d
+
+
+class TunnelsState(Model):
+ CONTAINER = "tunnels_state"
+ STATE_TUNNEL_LIST = "state-tunnel-list"
+
+ def get_state_tunnel_list(self):
+ return self.data[self.CONTAINER][self.STATE_TUNNEL_LIST]
+
+ def get_tunnels_by_key(self, key="tunnel-interface-name"):
+ d = {}
+ tunnels = self.get_state_tunnel_list()
+ for tunnel in tunnels:
+ d[tunnel[key]] = tunnel
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "l3vpn"
+
+
+def vpn_instance_to_vpn_id(store, ip=None, port=None, path=None):
+ return VpnInterfaces(NAME, VpnInterfaces.CONTAINER, store, ip, port, path)
+
+
+class VpnInterfaces(Model):
+ CONTAINER = "vpn-interfaces"
+ VPN_INTERFACE = "vpn-interface"
+
+ def get_vpn_interfaces(self):
+ return self.data[self.CONTAINER][self.VPN_INTERFACE]
+
+ def get_vpn_ids_by_key(self, key="name"):
+ d = {}
+ ifaces = self.get_vpn_interfaces()
+ for iface in ifaces:
+ d[iface[key]] = iface
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "mip"
+
+
+def mac(store, ip=None, port=None, path=None):
+ return Mac(NAME, Mac.CONTAINER, store, ip, port, path)
+
+
+class Mac(Model):
+ CONTAINER = "mac"
+ ENTRY = "entry"
+
+ def get_entries(self):
+ return self.data[self.CONTAINER][self.ENTRY]
+
+ def get_entries_by_key(self, key="name"):
+ d = {}
+ entries = self.get_entries()
+ for entry in entries:
+ entry['mac'] = entry['mac'].lower()
+ d[entry.get('mac')][entry.get('network-id')] = entry
+ return d
--- /dev/null
+import json
+import request
+
+
+class Model:
+ CONFIG = "config"
+ OPERATIONAL = "operational"
+ USER = "admin"
+ PW = "admin"
+
+ def __init__(self, name, container, store, ip=None, port=None, path="/tmp", mid=None):
+ self.name = name
+ self.container = container
+ self.store = store
+ self.ip = ip
+ self.port = port
+ self.url = self.make_url()
+ self.path = path
+ self.filename = self.make_filename()
+ if mid is not None:
+ self.url = self.make_url_type(mid)
+ self.filename = self.make_filename_type(mid)
+ self.data = None
+ self.data = self.get_model_data()
+
+ def make_filename(self):
+ return "{}/{}_{}:{}.json".format(self.path, self.store, self.name, self.container)
+
+ def make_filename_type(self, mid):
+ return "{}/{}_{}:{}_topology_{}.json".format(self.path, self.store, self.name, self.container, mid)
+
+ def make_url(self):
+ return "http://{}:{}/restconf/{}/{}:{}".format(self.ip, self.port, self.store,
+ self.name, self.container)
+
+ def make_url_type(self, mid):
+ return "http://{}:{}/restconf/{}/{}:{}/topology/{}".format(self.ip, self.port, self.store,
+ self.name, self.container, mid)
+
+ def get_from_odl(self):
+ return request.get(self.url, self.USER, self.PW)
+
+ def read_file(self, filename):
+ return request.read_file(filename)
+
+ def get_model_data(self):
+ if self.data is not None:
+ return self.data
+
+ self.data = self.read_file(self.filename)
+ if self.data is not None:
+ return self.data
+
+ self.data = self.get_from_odl()
+ if self.data is not None:
+ request.write_file(self.filename, self.data)
+ return self.data
+
+ def pretty_format(self, data=None):
+ if data is None:
+ data = self.data
+ return json.dumps(data, indent=4, separators=(',', ': '))
+
+ def get_kv(self, k, v, values):
+ """
+ Return a list of values for the given key
+ :param k:
+ :param v:
+ :param values:
+ :return:
+ """
+ if type(v) is dict:
+ for jsonkey in v:
+ if jsonkey == k:
+ values.append(v[jsonkey])
+ elif type(v[jsonkey]) in (list, dict):
+ self.get_kv(k, v[jsonkey], values)
+ elif type(v) is list:
+ for item in v:
+ if type(item) in (list, dict):
+ self.get_kv(k, item, values)
+ return values
-import json
-import request
+from mdsal.model import Model
+from mdsal import elan
+from mdsal import id_manager
+from mdsal import ietf_interfaces
+from mdsal import interface_service_bindings
+from mdsal import itm_state
+from mdsal import l3vpn
+from mdsal import mip
+from mdsal import network_topology
+from mdsal import neutron
+from mdsal import odl_fib
+from mdsal import odl_interface_meta
+from mdsal import odl_l3vpn
+from mdsal import opendaylight_inventory
-class Model:
- CONFIG = "config"
- OPERATIONAL = "operational"
- USER = "admin"
- PW = "admin"
+modelpath = "/tmp/robotjob/s1-t1_Create_VLAN_Network_net_1/models"
+elan_elan_instances = None
+elan_elan_interfaces = None
+id_manager_id_pools = None
+ietf_interfaces_interfaces = None
+ietf_interfaces_interfaces_state = None
+interface_service_bindings_service_bindings = None
+itm_state_tunnels_state = None
+l3vpn_vpn_interfaces = None
+mip_mac = None
+network_topology_network_topology_config = None
+network_topology_network_topology_operational = None
+neutron_neutron = None
+odl_fib_fib_entries = None
+odl_interface_meta_if_index_interface_map = None
+odl_inventory_nodes_config = None
+odl_inventory_nodes_operational = None
+odl_l3vpn_vpn_instance_to_vpn_id = None
- def __init__(self, name, container, store, ip, port):
- self.name = name
- self.CONTAINER = container
- self.store = store
- self.ip = ip
- self.port = port
- self.data = None
- self.url = self.make_url()
- def set_odl_address(self, ip, port):
- self.ip = ip
- self.port = port
+def get_all_dumps():
+ global elan_elan_instances
+ global elan_elan_interfaces
+ global id_manager_id_pools
+ global ietf_interfaces_interfaces
+ global ietf_interfaces_interfaces_state
+ global interface_service_bindings_service_bindings
+ global itm_state_tunnels_state
+ global l3vpn_vpn_interfaces
+ global mip_mac
+ global network_topology_network_topology_config
+ global network_topology_network_topology_operational
+ global neutron_neutron
+ global odl_fib_fib_entries
+ global odl_interface_meta_if_index_interface_map
+ global odl_inventory_nodes_config
+ global odl_inventory_nodes_operational
+ global odl_l3vpn_vpn_instance_to_vpn_id
- def make_url(self):
- url = "http://{}:{}/restconf/{}/{}:{}".format(self.ip, self.port, self.store,
- self.name, self.CONTAINER)
- return url
-
- def get_from_odl(self):
- self.data = request.get(self.url, self.USER, self.PW)
- return self.data
-
- def read_file(self, filename):
- self.data = request.read_file(filename)
- return self.data
-
- def pretty_format(self, data=None):
- if data is None:
- data = self.data
- return json.dumps(data, indent=4, separators=(',', ': '))
-
- def get_kv(self, k, v, values):
- """
- Return a list of values for the given key
- :param k:
- :param v:
- :param values:
- :return:
- """
- if type(v) is dict:
- for jsonkey in v:
- if jsonkey == k:
- values.append(v[jsonkey])
- elif type(v[jsonkey]) in (list, dict):
- self.get_kv(k, v[jsonkey], values)
- elif type(v) is list:
- for item in v:
- if type(item) in (list, dict):
- self.get_kv(k, item, values)
- return values
+ elan_elan_instances = elan.elan_instances(Model.CONFIG, modelpath)
+ elan_elan_interfaces = elan.elan_interfaces(Model.CONFIG, modelpath)
+ id_manager_id_pools = id_manager.id_pools(Model.CONFIG, modelpath)
+ ietf_interfaces_interfaces = ietf_interfaces.interfaces(Model.CONFIG, modelpath)
+ ietf_interfaces_interfaces_state = ietf_interfaces.interfaces_state(Model.OPERATIONAL, modelpath)
+ interface_service_bindings_service_bindings = interface_service_bindings.service_bindings(Model.CONFIG, modelpath)
+ itm_state_tunnels_state = itm_state.tunnels_state(Model.OPERATIONAL, modelpath)
+ l3vpn_vpn_interfaces = l3vpn.vpn_instance_to_vpn_id(Model.CONFIG, modelpath)
+ mip_mac = mip.mac(Model.CONFIG, modelpath)
+ neutron_neutron = neutron.neutron(Model.CONFIG, modelpath)
+ network_topology_network_topology_config = network_topology.network_topology(Model.CONFIG, modelpath)
+ network_topology_network_topology_operational = network_topology.network_topology(Model.CONFIG, modelpath)
+ neutron_neutron = neutron.neutron(Model.CONFIG, modelpath)
+ odl_fib_fib_entries = odl_fib.fib_entries(Model.CONFIG, modelpath)
+ odl_interface_meta_if_index_interface_map = odl_interface_meta.if_indexes_interface_map(Model.OPERATIONAL, modelpath)
+ odl_inventory_nodes_config = opendaylight_inventory.nodes(Model.CONFIG, modelpath)
+ odl_inventory_nodes_operational = opendaylight_inventory.nodes(Model.OPERATIONAL, modelpath)
+ odl_l3vpn_vpn_instance_to_vpn_id = odl_l3vpn.vpn_instance_to_vpn_id(Model.CONFIG, modelpath)
--- /dev/null
+from model import Model
+
+
+NAME = "network-topology"
+
+
+def network_topology(store, ip=None, port=None, path=None, mid="ovsdb:1"):
+ return NetworkTopology(NAME, NetworkTopology.CONTAINER, store, ip, port, path, mid)
+
+
+class NetworkTopology(Model):
+ # TODO: class currently assumes the ovsdb:1 has been used so need to fix that to take a topology-id
+ CONTAINER = "network-topology"
+ TOPOLOGY = "topology"
+ NODE = "node"
+ OVSDB1 = "ovsdb:1"
+
+ def get_topologies(self):
+ return self.data[self.TOPOLOGY]
+
+ def get_topology_by_tid(self, tid="ovsdb:1"):
+ topologies = self.get_topologies()
+ for topology in topologies:
+ if topology['topology-id'] == tid:
+ return topology
+
+ def get_nodes_by_tid(self, tid="ovsdb:1"):
+ topology = self.get_topology_by_tid(tid)
+ return topology[self.NODE]
+
+ def get_nodes_by_tid_and_key(self, tid="ovsdb:1", key='node-id'):
+ nodes = self.get_nodes_by_tid_and_key(tid, key)
+ d = {}
+ for node in nodes:
+ d[node[key]] = node
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "neutron"
+
+
+def neutron(store, ip=None, port=None, path=None):
+ return Neutron(NAME, Neutron.CONTAINER, store, ip, port, path)
+
+
+class Neutron(Model):
+ CONTAINER = "neutron"
+ NETWORKS = "networks"
+ NETWORK = "network"
+ PORTS = "ports"
+ PORT = "port"
+ ROUTERS = "routers"
+ ROUTER = "router"
+ TRUNKS = "trunks"
+ TRUNK = "trunk"
+ NAME = "name"
+ UUID = "uuid"
+
+ def get_ports(self):
+ return self.data[self.CONTAINER][self.PORTS][self.PORT]
+
+ def get_ports_by_key(self, key="uuid"):
+ d = {}
+ ports = self.get_ports()
+ for port in ports:
+ d[port[key]] = port
+ return d
+
+ def get_trunks(self):
+ return self.data[self.CONTAINER][self.TRUNKS][self.TRUNK]
+
+ def get_trunks_by_key(self, key="uuid"):
+ d = {}
+ trunks = self.get_trunks()
+ for trunk in trunks:
+ d[trunk[key]] = trunk
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "odl-fib"
+
+
+def fib_entries(store, ip=None, port=None, path=None):
+ return FibEntries(NAME, FibEntries.CONTAINER, store, ip, port, path)
+
+
+class FibEntries(Model):
+ CONTAINER = "fibEntries"
+ VRFTABLES = "vrfTables"
+ VRFENTRY = "vrfEntry"
+ ROUTEDISTINGUISHER = "routeDistinguisher"
+ RD = "rd"
+
+ def get_vrf_tables(self):
+ return self.data[self.CONTAINER][self.VRFTABLES]
+
+ def get_vrf_entries_by_key(self, key="label"):
+ d = {}
+ vrf_tables = self.get_vrf_tables()
+ for vrf_table in vrf_tables:
+ for vrf_entry in vrf_table.get(self.VRFENTRY, []):
+ if vrf_entry.get('label'):
+ vrf_entry[self.RD] = vrf_table[self.ROUTEDISTINGUISHER]
+ d[vrf_entry[key]] = vrf_entry
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "odl-interface-meta"
+
+
+def if_indexes_interface_map(store, ip=None, port=None, path=None):
+ return IfIndexesInterfaceMap(NAME, IfIndexesInterfaceMap.CONTAINER, store, ip, port, path)
+
+
+class IfIndexesInterfaceMap(Model):
+ CONTAINER = "if-indexes-interface-map"
+ IF_INDEX_INTERFACE = "if-index-interface"
+
+ def get_if_index_interfaces(self):
+ return self.data[self.CONTAINER][self.IF_INDEX_INTERFACE]
+
+ def get_if_index_interfaces_by_key(self, key="if-index"):
+ d = {}
+ ifaces = self.get_if_index_interfaces()
+ for iface in ifaces:
+ d[iface[key]] = iface
+ return d
+
+
+class ElanInterfaces(Model):
+ CONTAINER = "elan-interfaces"
+ ELAN_INSTANCE = "elan-instance"
+
+ def get_elan_interfaces(self):
+ return self.data[self.CONTAINER][self.ELAN_INSTANCE]
+
+ def get_elan_interfaces_by_key(self, key="name"):
+ d = {}
+ ifaces = self.get_elan_ifaces()
+ for iface in ifaces:
+ d[iface[key]] = iface
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "odl-l3vpn"
+
+
+def vpn_id_to_vpn_instance(store, ip=None, port=None, path=None):
+ return VpnIdToVpnInstance(NAME, VpnIdToVpnInstance.CONTAINER, store, ip, port, path)
+
+
+def vpn_instance_to_vpn_id(store, ip=None, port=None, path=None):
+ return VpnInstanceToVpnId(NAME, VpnInstanceToVpnId.CONTAINER, store, ip, port, path)
+
+
+class VpnIdToVpnInstance(Model):
+ CONTAINER = "vpn-id-to-vpn-instance"
+ VPN_IDS = "vpn-ids"
+
+ def get_vpn_ids(self):
+ return self.data[self.CONTAINER][self.VPN_IDS]
+
+ def get_vpn_ids_by_key(self, key="vpn-id"):
+ d = {}
+ vpnids = self.get_vpn_ids()
+ for vpnid in vpnids:
+ d[vpnid[key]] = vpnid
+ return d
+
+
+class VpnInstanceToVpnId(Model):
+ CONTAINER = "vpn-instance-to-vpn-id"
+ VPN_INSTANCE = "vpn-instance"
+
+ def get_vpn_instances(self):
+ return self.data[self.CONTAINER][self.VPN_INSTANCE]
+
+ def get_vpn_instances_by_key(self, key="vpn-id"):
+ d = {}
+ instances = self.get_vpn_instances()
+ for instance in instances:
+ d[instance[key]] = instance
+ return d
--- /dev/null
+from model import Model
+
+
+NAME = "opendaylight-inventory"
+
+
+def nodes(store, ip=None, port=None, path=None):
+ return Nodes(NAME, Nodes.CONTAINER, store, ip, port, path)
+
+
+class Nodes(Model):
+ CONTAINER = "nodes"
+ NODE = "node"
+
+ def get_nodes(self):
+ return self.data[self.CONTAINER][self.NODE]
+
+ def get_nodes_by_key(self, key="id"):
+ d = {}
+ nodez = self.get_nodes()
+ for node in nodez:
+ d[node[key]] = node
+ return d
def debug_print(text1, data):
- logger.info("request: %s: processed %d lines", text1, len(data))
+ logger.debug("request: %s: processed %d lines", text1, len(data))
logger.debug("request: %s", text1)
logger.debug("%s", json.dumps(data))
logger.debug("%s", json.dumps(data, indent=4, separators=(',', ': ')))
data = json.load(json_file)
debug_print(filename, data)
return data
+
+
+def write_file(filename, data):
+ with open(filename, 'w') as fp:
+ json.dump(data, fp)
+ logger.debug("write_file: File: %s", filename)
--- /dev/null
+{
+ "interfaces": {
+ "interface": [
+ {
+ "description": "VXLAN Trunk Interface",
+ "enabled": true,
+ "name": "tun95fee4d7132",
+ "odl-interface:datapath-node-identifier": 132319289050514,
+ "odl-interface:internal": true,
+ "odl-interface:monitor-enabled": true,
+ "odl-interface:monitor-interval": 10000,
+ "odl-interface:monitor-protocol": "odl-interface:tunnel-monitoring-type-bfd",
+ "odl-interface:tunnel-destination": "10.30.170.90",
+ "odl-interface:tunnel-gateway": "0.0.0.0",
+ "odl-interface:tunnel-interface-type": "odl-interface:tunnel-type-vxlan",
+ "odl-interface:tunnel-remote-ip-flow": false,
+ "odl-interface:tunnel-source": "10.30.170.17",
+ "type": "iana-if-type:tunnel"
+ },
+ {
+ "description": "VXLAN Trunk Interface",
+ "enabled": true,
+ "name": "tundb1d8b295c1",
+ "odl-interface:datapath-node-identifier": 234018835196237,
+ "odl-interface:internal": true,
+ "odl-interface:monitor-enabled": true,
+ "odl-interface:monitor-interval": 10000,
+ "odl-interface:monitor-protocol": "odl-interface:tunnel-monitoring-type-bfd",
+ "odl-interface:tunnel-destination": "10.30.170.17",
+ "odl-interface:tunnel-gateway": "0.0.0.0",
+ "odl-interface:tunnel-interface-type": "odl-interface:tunnel-type-vxlan",
+ "odl-interface:tunnel-remote-ip-flow": false,
+ "odl-interface:tunnel-source": "10.30.170.92",
+ "type": "iana-if-type:tunnel"
+ },
+ {
+ "description": "VXLAN Trunk Interface",
+ "enabled": true,
+ "name": "tun94ecbe1efd8",
+ "odl-interface:datapath-node-identifier": 132319289050514,
+ "odl-interface:internal": true,
+ "odl-interface:monitor-enabled": true,
+ "odl-interface:monitor-interval": 10000,
+ "odl-interface:monitor-protocol": "odl-interface:tunnel-monitoring-type-bfd",
+ "odl-interface:tunnel-destination": "10.30.170.92",
+ "odl-interface:tunnel-gateway": "0.0.0.0",
+ "odl-interface:tunnel-interface-type": "odl-interface:tunnel-type-vxlan",
+ "odl-interface:tunnel-remote-ip-flow": false,
+ "odl-interface:tunnel-source": "10.30.170.17",
+ "type": "iana-if-type:tunnel"
+ },
+ {
+ "description": "VXLAN Trunk Interface",
+ "enabled": true,
+ "name": "tunf68aef23130",
+ "odl-interface:datapath-node-identifier": 74851789353527,
+ "odl-interface:internal": true,
+ "odl-interface:monitor-enabled": true,
+ "odl-interface:monitor-interval": 10000,
+ "odl-interface:monitor-protocol": "odl-interface:tunnel-monitoring-type-bfd",
+ "odl-interface:tunnel-destination": "10.30.170.92",
+ "odl-interface:tunnel-gateway": "0.0.0.0",
+ "odl-interface:tunnel-interface-type": "odl-interface:tunnel-type-vxlan",
+ "odl-interface:tunnel-remote-ip-flow": false,
+ "odl-interface:tunnel-source": "10.30.170.90",
+ "type": "iana-if-type:tunnel"
+ },
+ {
+ "description": "VXLAN Trunk Interface",
+ "enabled": true,
+ "name": "tun999632b8289",
+ "odl-interface:datapath-node-identifier": 234018835196237,
+ "odl-interface:internal": true,
+ "odl-interface:monitor-enabled": true,
+ "odl-interface:monitor-interval": 10000,
+ "odl-interface:monitor-protocol": "odl-interface:tunnel-monitoring-type-bfd",
+ "odl-interface:tunnel-destination": "10.30.170.90",
+ "odl-interface:tunnel-gateway": "0.0.0.0",
+ "odl-interface:tunnel-interface-type": "odl-interface:tunnel-type-vxlan",
+ "odl-interface:tunnel-remote-ip-flow": false,
+ "odl-interface:tunnel-source": "10.30.170.92",
+ "type": "iana-if-type:tunnel"
+ },
+ {
+ "description": "VXLAN Trunk Interface",
+ "enabled": true,
+ "name": "tun03a2b920986",
+ "odl-interface:datapath-node-identifier": 74851789353527,
+ "odl-interface:internal": true,
+ "odl-interface:monitor-enabled": true,
+ "odl-interface:monitor-interval": 10000,
+ "odl-interface:monitor-protocol": "odl-interface:tunnel-monitoring-type-bfd",
+ "odl-interface:tunnel-destination": "10.30.170.17",
+ "odl-interface:tunnel-gateway": "0.0.0.0",
+ "odl-interface:tunnel-interface-type": "odl-interface:tunnel-type-vxlan",
+ "odl-interface:tunnel-remote-ip-flow": false,
+ "odl-interface:tunnel-source": "10.30.170.90",
+ "type": "iana-if-type:tunnel"
+ }
+ ]
+ }
+}
\ No newline at end of file
--- /dev/null
+{
+ "topology": [
+ {
+ "node": [
+ {
+ "node-id": "ovsdb://uuid/8eabb815-5570-42fc-9635-89c880ebc4ac/bridge/br-int",
+ "ovsdb:bridge-name": "br-int",
+ "ovsdb:bridge-other-configs": [
+ {
+ "bridge-other-config-key": "hwaddr",
+ "bridge-other-config-value": "44:13:ca:50:b2:37"
+ },
+ {
+ "bridge-other-config-key": "disable-in-band",
+ "bridge-other-config-value": "true"
+ }
+ ],
+ "ovsdb:controller-entry": [
+ {
+ "target": "tcp:10.30.170.5:6653"
+ }
+ ],
+ "ovsdb:fail-mode": "ovsdb:ovsdb-fail-mode-secure",
+ "ovsdb:managed-by": "/network-topology:network-topology/network-topology:topology[network-topology:topology-id='ovsdb:1']/network-topology:node[network-topology:node-id='ovsdb://uuid/8eabb815-5570-42fc-9635-89c880ebc4ac']",
+ "ovsdb:protocol-entry": [
+ {
+ "protocol": "ovsdb:ovsdb-bridge-protocol-openflow-13"
+ }
+ ],
+ "termination-point": [
+ {
+ "ovsdb:interface-type": "ovsdb:interface-type-patch",
+ "ovsdb:name": "br-physnet1-pa",
+ "ovsdb:options": [
+ {
+ "option": "peer",
+ "value": "br-physnet1-int-patch"
+ }
+ ],
+ "tp-id": "br-physnet1-pa"
+ },
+ {
+ "ovsdb:interface-bfd": [
+ {
+ "bfd-key": "forwarding_if_rx",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "enable",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "min_tx",
+ "bfd-value": "10000"
+ }
+ ],
+ "ovsdb:interface-type": "ovsdb:interface-type-vxlan",
+ "ovsdb:name": "tun03a2b920986",
+ "ovsdb:options": [
+ {
+ "option": "key",
+ "value": "flow"
+ },
+ {
+ "option": "local_ip",
+ "value": "10.30.170.90"
+ },
+ {
+ "option": "remote_ip",
+ "value": "10.30.170.17"
+ }
+ ],
+ "tp-id": "tun03a2b920986"
+ },
+ {
+ "ovsdb:interface-bfd": [
+ {
+ "bfd-key": "forwarding_if_rx",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "enable",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "min_tx",
+ "bfd-value": "10000"
+ }
+ ],
+ "ovsdb:interface-type": "ovsdb:interface-type-vxlan",
+ "ovsdb:name": "tunf68aef23130",
+ "ovsdb:options": [
+ {
+ "option": "key",
+ "value": "flow"
+ },
+ {
+ "option": "local_ip",
+ "value": "10.30.170.90"
+ },
+ {
+ "option": "remote_ip",
+ "value": "10.30.170.92"
+ }
+ ],
+ "tp-id": "tunf68aef23130"
+ }
+ ]
+ },
+ {
+ "node-id": "ovsdb://uuid/52910ce2-e429-4417-b638-142a32dbe56b/bridge/br-physnet1",
+ "termination-point": [
+ {
+ "ovsdb:interface-type": "ovsdb:interface-type-patch",
+ "ovsdb:name": "br-physnet1-int-patch",
+ "ovsdb:options": [
+ {
+ "option": "peer",
+ "value": "br-physnet1-pa"
+ }
+ ],
+ "tp-id": "br-physnet1-int-patch"
+ }
+ ]
+ },
+ {
+ "node-id": "ovsdb://uuid/52910ce2-e429-4417-b638-142a32dbe56b/bridge/br-int",
+ "ovsdb:bridge-name": "br-int",
+ "ovsdb:bridge-other-configs": [
+ {
+ "bridge-other-config-key": "hwaddr",
+ "bridge-other-config-value": "d4:d6:c1:8a:e9:4d"
+ },
+ {
+ "bridge-other-config-key": "disable-in-band",
+ "bridge-other-config-value": "true"
+ }
+ ],
+ "ovsdb:controller-entry": [
+ {
+ "target": "tcp:10.30.170.5:6653"
+ }
+ ],
+ "ovsdb:fail-mode": "ovsdb:ovsdb-fail-mode-secure",
+ "ovsdb:managed-by": "/network-topology:network-topology/network-topology:topology[network-topology:topology-id='ovsdb:1']/network-topology:node[network-topology:node-id='ovsdb://uuid/52910ce2-e429-4417-b638-142a32dbe56b']",
+ "ovsdb:protocol-entry": [
+ {
+ "protocol": "ovsdb:ovsdb-bridge-protocol-openflow-13"
+ }
+ ],
+ "termination-point": [
+ {
+ "ovsdb:interface-type": "ovsdb:interface-type-patch",
+ "ovsdb:name": "br-physnet1-pa",
+ "ovsdb:options": [
+ {
+ "option": "peer",
+ "value": "br-physnet1-int-patch"
+ }
+ ],
+ "tp-id": "br-physnet1-pa"
+ },
+ {
+ "ovsdb:interface-bfd": [
+ {
+ "bfd-key": "forwarding_if_rx",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "enable",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "min_tx",
+ "bfd-value": "10000"
+ }
+ ],
+ "ovsdb:interface-type": "ovsdb:interface-type-vxlan",
+ "ovsdb:name": "tundb1d8b295c1",
+ "ovsdb:options": [
+ {
+ "option": "key",
+ "value": "flow"
+ },
+ {
+ "option": "local_ip",
+ "value": "10.30.170.92"
+ },
+ {
+ "option": "remote_ip",
+ "value": "10.30.170.17"
+ }
+ ],
+ "tp-id": "tundb1d8b295c1"
+ },
+ {
+ "ovsdb:interface-bfd": [
+ {
+ "bfd-key": "forwarding_if_rx",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "enable",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "min_tx",
+ "bfd-value": "10000"
+ }
+ ],
+ "ovsdb:interface-type": "ovsdb:interface-type-vxlan",
+ "ovsdb:name": "tun999632b8289",
+ "ovsdb:options": [
+ {
+ "option": "key",
+ "value": "flow"
+ },
+ {
+ "option": "local_ip",
+ "value": "10.30.170.92"
+ },
+ {
+ "option": "remote_ip",
+ "value": "10.30.170.90"
+ }
+ ],
+ "tp-id": "tun999632b8289"
+ }
+ ]
+ },
+ {
+ "node-id": "ovsdb://uuid/719e0692-b96a-4109-b1b3-f6370546be5b/bridge/br-int",
+ "ovsdb:bridge-name": "br-int",
+ "ovsdb:bridge-other-configs": [
+ {
+ "bridge-other-config-key": "hwaddr",
+ "bridge-other-config-value": "78:57:fc:38:85:92"
+ },
+ {
+ "bridge-other-config-key": "disable-in-band",
+ "bridge-other-config-value": "true"
+ }
+ ],
+ "ovsdb:controller-entry": [
+ {
+ "target": "tcp:10.30.170.5:6653"
+ }
+ ],
+ "ovsdb:fail-mode": "ovsdb:ovsdb-fail-mode-secure",
+ "ovsdb:managed-by": "/network-topology:network-topology/network-topology:topology[network-topology:topology-id='ovsdb:1']/network-topology:node[network-topology:node-id='ovsdb://uuid/719e0692-b96a-4109-b1b3-f6370546be5b']",
+ "ovsdb:protocol-entry": [
+ {
+ "protocol": "ovsdb:ovsdb-bridge-protocol-openflow-13"
+ }
+ ],
+ "termination-point": [
+ {
+ "ovsdb:interface-type": "ovsdb:interface-type-patch",
+ "ovsdb:name": "br-physnet1-pa",
+ "ovsdb:options": [
+ {
+ "option": "peer",
+ "value": "br-physnet1-int-patch"
+ }
+ ],
+ "tp-id": "br-physnet1-pa"
+ },
+ {
+ "ovsdb:interface-bfd": [
+ {
+ "bfd-key": "forwarding_if_rx",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "enable",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "min_tx",
+ "bfd-value": "10000"
+ }
+ ],
+ "ovsdb:interface-type": "ovsdb:interface-type-vxlan",
+ "ovsdb:name": "tun95fee4d7132",
+ "ovsdb:options": [
+ {
+ "option": "key",
+ "value": "flow"
+ },
+ {
+ "option": "local_ip",
+ "value": "10.30.170.17"
+ },
+ {
+ "option": "remote_ip",
+ "value": "10.30.170.90"
+ }
+ ],
+ "tp-id": "tun95fee4d7132"
+ },
+ {
+ "ovsdb:interface-bfd": [
+ {
+ "bfd-key": "forwarding_if_rx",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "enable",
+ "bfd-value": "true"
+ },
+ {
+ "bfd-key": "min_tx",
+ "bfd-value": "10000"
+ }
+ ],
+ "ovsdb:interface-type": "ovsdb:interface-type-vxlan",
+ "ovsdb:name": "tun94ecbe1efd8",
+ "ovsdb:options": [
+ {
+ "option": "key",
+ "value": "flow"
+ },
+ {
+ "option": "local_ip",
+ "value": "10.30.170.17"
+ },
+ {
+ "option": "remote_ip",
+ "value": "10.30.170.92"
+ }
+ ],
+ "tp-id": "tun94ecbe1efd8"
+ }
+ ]
+ },
+ {
+ "node-id": "ovsdb://uuid/719e0692-b96a-4109-b1b3-f6370546be5b/bridge/br-physnet1",
+ "termination-point": [
+ {
+ "ovsdb:interface-type": "ovsdb:interface-type-patch",
+ "ovsdb:name": "br-physnet1-int-patch",
+ "ovsdb:options": [
+ {
+ "option": "peer",
+ "value": "br-physnet1-pa"
+ }
+ ],
+ "tp-id": "br-physnet1-int-patch"
+ }
+ ]
+ },
+ {
+ "node-id": "ovsdb://uuid/8eabb815-5570-42fc-9635-89c880ebc4ac/bridge/br-physnet1",
+ "termination-point": [
+ {
+ "ovsdb:interface-type": "ovsdb:interface-type-patch",
+ "ovsdb:name": "br-physnet1-int-patch",
+ "ovsdb:options": [
+ {
+ "option": "peer",
+ "value": "br-physnet1-pa"
+ }
+ ],
+ "tp-id": "br-physnet1-int-patch"
+ }
+ ]
+ }
+ ],
+ "topology-id": "ovsdb:1"
+ }
+ ]
+}
\ No newline at end of file
--- /dev/null
+import unittest
+from mdsal.model import Model
+from mdsal.ietf_interfaces import interfaces
+from odltools import logg
+
+ip = "127.0.0.1"
+port = "8080"
+path = "./resources"
+# path = "/tmp/robotjob/s1-t1_Create_VLAN_Network_net_1/models"
+
+
+class TestIetfInterfaces(unittest.TestCase):
+ def setUp(self):
+ logg.Logger()
+ self.interfaces = interfaces(Model.CONFIG, ip, port, path)
+
+ def test_get_interfaces_by_key(self):
+ d = self.interfaces.get_interfaces_by_key()
+ self.assertIsNotNone(d['tun95fee4d7132'])
+
+if __name__ == '__main__':
+ unittest.main()
import unittest
from mdsal import itm_state
-from mdsal.models import Model
+from mdsal.model import Model
from mdsal.itm_state import DpnEndpoints
from odltools import logg
ip = "127.0.0.1"
port = "8080"
+path = "./resources"
+# path = "/tmp/robotjob/s1-t1_Create_VLAN_Network_net_1/models"
class TestItmState(unittest.TestCase):
def setUp(self):
logg.Logger()
- self.dpn_endpoints = itm_state.dpn_endpoints(Model.CONFIG, ip, port)
- self.data = self.dpn_endpoints.read_file("./resources/itm-state_dpn-endpoints.json")
+ self.dpn_endpoints = itm_state.dpn_endpoints(Model.CONFIG, ip, port, path)
+ # self.data = self.dpn_endpoints.read_file("./resources/config_itm-state:dpn-endpoints.json")
def test_read_file(self):
- print "dpn-endpoints: {}".format(self.data)
- print "dpn-endpoints: \n{}".format(self.dpn_endpoints.pretty_format(self.data))
+ print "dpn-endpoints: {}".format(self.dpn_endpoints.data)
+ print "dpn-endpoints: \n{}".format(self.dpn_endpoints.pretty_format(self.dpn_endpoints.data))
def test_get_ip_address(self):
dpn_ids = self.dpn_endpoints.get_dpn_ids()
dpn_id = dpn_ids[0]
ip_address = self.dpn_endpoints.get_ip_address(dpn_id)
print "dpn_id: {}, ip_address: {}".format(dpn_id, ip_address)
- self.assertEqual(dpn_id, "13878168265586")
+ self.assertEqual(dpn_id, 13878168265586)
self.assertEqual(ip_address, "10.29.13.165")
def test_get_all(self):
- print "dpn-endpoints: {}".format(self.data)
- print "dpn-endpoints: \n{}".format(self.dpn_endpoints.pretty_format(self.data))
+ print "dpn-endpoints: {}".format(self.dpn_endpoints.data)
+ print "dpn-endpoints: \n{}".format(self.dpn_endpoints.pretty_format(self.dpn_endpoints.data))
dpn_ids = self.dpn_endpoints.get_dpn_ids()
dpn_id = dpn_ids[0]
self.get_info(DpnEndpoints.DPN_ID)
def get_info(self, key):
- info = self.dpn_endpoints.get_kv(key, self.data, values=[])
+ info = self.dpn_endpoints.get_kv(key, self.dpn_endpoints.data, values=[])
print "dpn info for {}: {}".format(key, info)
return info
--- /dev/null
+import unittest
+from mdsal.model import Model
+from mdsal.network_topology import network_topology
+from mdsal.network_topology import NetworkTopology
+from odltools import logg
+
+ip = "127.0.0.1"
+port = "8080"
+path = "./resources"
+# path = "/tmp/robotjob/s1-t1_Create_VLAN_Network_net_1/models"
+
+
+class TestNetworkTopology(unittest.TestCase):
+ def setUp(self):
+ logg.Logger()
+ self.network_topology = network_topology(Model.CONFIG, ip, port, path, NetworkTopology.OVSDB1)
+
+ def test_get_topologies(self):
+ self.assertIsNotNone(self.network_topology.get_topologies())
+
+ def test_get_nodes_by_key(self):
+ d = self.network_topology.get_nodes_by_tid_and_key()
+ self.assertIsNotNone(d['ovsdb://uuid/8eabb815-5570-42fc-9635-89c880ebc4ac/bridge/br-int'])
+
+if __name__ == '__main__':
+ unittest.main()
class TestRequest(unittest.TestCase):
def setUp(self):
logg.Logger()
- self.filename = "./resources/itm-state_dpn-endpoints.json"
+ self.filename = "./resources/config_itm-state:dpn-endpoints.json"
def test_read_file(self):
data = request.read_file(self.filename)
import constants as const
-import ds_get_data as dsg
import flow_parser as fp
import json
import netvirt_utils as utils
from collections import defaultdict
+from mdsal.model import Model
+from mdsal import elan
+from mdsal import id_manager
+from mdsal import ietf_interfaces
+from mdsal import interface_service_bindings
+from mdsal import itm_state
+from mdsal import l3vpn
+from mdsal import mip
+from mdsal import network_topology
+from mdsal import neutron
+from mdsal import odl_fib
+from mdsal import odl_interface_meta
+from mdsal import odl_l3vpn
+from mdsal import opendaylight_inventory
# Required
operNodes = {}
+modelpath = "/tmp/robotjob/s1-t1_Create_VLAN_Network_net_1/models"
+elan_elan_instances = None
+elan_elan_interfaces = None
+id_manager_id_pools = None
+ietf_interfaces_interfaces = None
+ietf_interfaces_interfaces_state = None
+interface_service_bindings_service_bindings = None
+itm_state_tunnels_state = None
+l3vpn_vpn_interfaces = None
+mip_mac = None
+network_topology_network_topology_config = None
+network_topology_network_topology_operational = None
+neutron_neutron = None
+odl_fib_fib_entries = None
+odl_interface_meta_if_index_interface_map = None
+odl_inventory_nodes_config = None
+odl_inventory_nodes_operational = None
+odl_l3vpn_vpn_instance_to_vpn_id = None
+
+
def by_ifname(ifname):
ifstate = ifstates.get(ifname)
iface = ifaces.get(ifname)
tunnel = None
tunState = None
if iface and iface.get('type') == const.IFTYPE_VLAN:
- ports = dsg.get_neutron_ports()
+ ports = neutron_neutron.get_ports_by_key()
port = ports.get(ifname)
elif iface and iface.get('type') == const.IFTYPE_TUNNEL:
- tunnels = dsg.get_config_tunnels()
+ tunnels = itm_state_tunnels_state.get_tunnels_by_key()
tunnel = tunnels.get(ifname)
tunStates = dsg.get_tunnel_states()
tunState = tunStates.get(ifname)
print_keys()
exit(1)
ifname = ifname[0]
- ifaces = dsg.get_config_interfaces()
- ifstates = dsg.get_interface_states()
+ ifaces = ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifstates = ietf_interfaces_interfaces_state.get_interfaces_by_key()
iface,ifstate,port,tunnel,tunState = by_ifname(ifname)
print "InterfaceConfig: "
json.dumps(iface, indent=2)
def analyze_inventory(nodeId, isConfig=True, ncId=None, ifName=None):
if isConfig:
- nodes = dsg.get_inventory_config()
+ nodes = odl_inventory_nodes_config.get_nodes_by_key()
print "Inventory Config:"
else:
print "Inventory Operational:"
- nodes = dsg.get_inventory_oper()
+ nodes = odl_inventory_nodes_operational.get_nodes_by_key()
node = nodes.get(nodeId)
tables = node.get(const.NODE_TABLE)
groups = node.get(const.NODE_GROUP)
def get_dpn_host_mapping(oper_nodes=None):
nodes_dict = {}
- nodes = oper_nodes or dsg.get_inventory_oper()
+ nodes = oper_nodes or odl_inventory_nodes_operational.get_nodes_by_key()
for node in nodes.itervalues():
dpnid = utils.get_dpn_from_ofnodeid(node['id'])
nodes_dict[dpnid] = node.get('flow-node-inventory:description', '')
def get_groups(ofnodes=None):
- of_nodes = ofnodes or dsg.get_inventory_config()
+ of_nodes = ofnodes or odl_inventory_nodes_config.get_nodes_by_key()
key ='group-id'
group_dict = defaultdict(dict)
for node in of_nodes.itervalues():
groups = {}
table_list = list(set([table for module in modules for table in const.TABLE_MAP[module]]))
##table_list = [214, 244]
- of_nodes = dsg.get_inventory_config()
+ of_nodes = odl_inventory_nodes_config.get_nodes_by_key()
if 'ifm' in modules:
- ifaces = dsg.get_config_interfaces()
- ifstates = dsg.get_interface_states()
+ ifaces = ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifstates = ietf_interfaces_interfaces_state.get_interfaces_by_key()
if 'l3vpn' in modules:
- ifaces = ifaces or dsg.get_config_interfaces()
- ifindexes = ifindexes or dsg.get_ifindexes()
- fibentries = fibentries or dsg.get_fibentries_by_label()
- vpnids = vpnids or dsg.get_vpnids()
- vpninterfaces = vpninterfaces or dsg.get_vpninterfaces()
+ ifaces = ifaces or ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifindexes = ifindexes or odl_interface_meta_if_index_interface_map.get_if_index_interfaces_by_key()
+ fibentries = fibentries or odl_fib_fib_entries.get_vrf_entries_by_key()
+ vpnids = vpnids or odl_l3vpn_vpn_instance_to_vpn_id.get_vpn_ids_by_key()
+ vpninterfaces = vpninterfaces or l3vpn_vpn_interfaces.get_vpn_ids_by_key()
groups = groups or get_groups(of_nodes)
if 'acl' in modules:
- ifaces = ifaces or dsg.get_config_interfaces()
- ifindexes = ifindexes or dsg.get_ifindexes()
- einsts = einsts or dsg.get_elan_instances()
- eifaces = eifaces or dsg.get_elan_interfaces()
+ ifaces = ifaces or ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifindexes = ifindexes or odl_interface_meta_if_index_interface_map.get_if_index_interfaces_by_key()
+ einsts = einsts or elan_elan_instances.get_elan_instances_by_key()
+ eifaces = eifaces or elan_elan_interfaces.get_elan_interfaces()
if 'elan' in modules:
- ifaces = ifaces or dsg.get_config_interfaces()
- einsts = einsts or dsg.get_elan_instances()
- eifaces = eifaces or dsg.get_elan_interfaces()
- ifindexes = ifindexes or dsg.get_ifindexes()
+ ifaces = ifaces or ietf_interfaces_interfaces.get_interfaces_by_key()
+ einsts = einsts or elan_elan_instances.get_elan_instances_by_key()
+ eifaces = eifaces or elan_elan_interfaces.get_elan_interfaces()
+ ifindexes = ifindexes or odl_interface_meta_if_index_interface_map.get_if_index_interfaces_by_key()
stale_flows = []
for node in of_nodes.itervalues():
tables = [x for x in node[const.NODE_TABLE] if x['id'] in table_list]
def get_stale_bindings():
- ifaces = dsg.get_config_interfaces()
- bindings, orphans = dsg.get_service_bindings()
+ ifaces = ietf_interfaces_interfaces.get_interfaces_by_key()
+ bindings, orphans = interface_service_bindings_service_bindings.get_service_bindings()
return set(bindings.keys()) - set(ifaces.keys()), bindings
def show_stale_flows(sort_by='table'):
compute_map = get_dpn_host_mapping()
- nports = dsg.get_neutron_ports()
+ nports = neutron_neutron.get_ports_by_key()
for flow in utils.sort(get_stale_flows(['ifm', 'acl', 'elan', 'l3vpn']), sort_by):
host = compute_map.get(flow.get('dpnid'), flow.get('dpnid'))
ip_list = get_ips_for_iface(nports, flow.get('ifname'))
else:
table_list = list(set([table for module in modules for table in const.TABLE_MAP[module]]))
##table_list = [214, 244]
- of_nodes = dsg.get_inventory_config()
+ of_nodes = odl_inventory_nodes_config.get_nodes_by_key()
if 'ifm' in modules:
- ifaces = dsg.get_config_interfaces()
- ifstates = dsg.get_interface_states()
+ ifaces = ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifstates = ietf_interfaces_interfaces_state.get_interfaces_by_key()
if 'l3vpn' in modules:
- ifaces = ifaces or dsg.get_config_interfaces()
- ifindexes = ifindexes or dsg.get_ifindexes()
+ ifaces = ifaces or ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifindexes = ifindexes or odl_interface_meta_if_index_interface_map.get_if_index_interfaces_by_key()
fibentries = fibentries or dsg.get_fibentries_by_label()
- vpnids = vpnids or dsg.get_vpnids()
- vpninterfaces = vpninterfaces or dsg.get_vpninterfaces()
+ vpnids = vpnids or odl_l3vpn_vpn_instance_to_vpn_id.get_vpn_ids_by_key()
+ vpninterfaces = vpninterfaces or l3vpn_vpn_interfaces.get_vpn_ids_by_key()
groups = groups or get_groups(of_nodes)
if 'acl' in modules:
- ifaces = ifaces or dsg.get_config_interfaces()
- ifindexes = ifindexes or dsg.get_ifindexes()
- einsts = einsts or dsg.get_elan_instances()
- eifaces = eifaces or dsg.get_elan_interfaces()
+ ifaces = ifaces or ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifindexes = ifindexes or odl_interface_meta_if_index_interface_map.get_if_index_interfaces_by_key()
+ einsts = einsts or elan_elan_instances.get_elan_instances_by_key()
+ eifaces = eifaces or elan_elan_interfaces.get_elan_interfaces()
if 'elan' in modules:
- ifaces = ifaces or dsg.get_config_interfaces()
- einsts = einsts or dsg.get_elan_instances()
- eifaces = eifaces or dsg.get_elan_interfaces()
- ifindexes = ifindexes or dsg.get_ifindexes()
+ ifaces = ifaces or ietf_interfaces_interfaces.get_interfaces_by_key()
+ einsts = einsts or elan_elan_instances.get_elan_instances_by_key()
+ eifaces = eifaces or elan_elan_interfaces.get_elan_interfaces()
+ ifindexes = ifindexes or odl_interface_meta_if_index_interface_map.get_if_index_interfaces_by_key()
if 'all' in modules:
groups = groups or get_groups(of_nodes)
- ifaces = ifaces or dsg.get_config_interfaces()
- ifstates = ifstates or dsg.get_interface_states()
- ifindexes = ifindexes or dsg.get_ifindexes()
+ ifaces = ifaces or ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifstates = ifstates or ietf_interfaces_interfaces_state.get_interfaces_by_key()
+ ifindexes = ifindexes or odl_interface_meta_if_index_interface_map.get_if_index_interfaces_by_key()
fibentries = fibentries or dsg.get_fibentries_by_label()
- vpnids = vpnids or dsg.get_vpnids()
- vpninterfaces = vpninterfaces or dsg.get_vpninterfaces()
- einsts = einsts or dsg.get_elan_instances()
- eifaces = eifaces or dsg.get_elan_interfaces()
+ vpnids = vpnids or odl_l3vpn_vpn_instance_to_vpn_id.get_vpn_ids_by_key()
+ vpninterfaces = vpninterfaces or l3vpn_vpn_interfaces.get_vpn_ids_by_key()
+ einsts = einsts or elan_elan_instances.get_elan_instances_by_key()
+ eifaces = eifaces or elan_elan_interfaces.get_elan_interfaces()
flows = []
for node in of_nodes.itervalues():
tables = [x for x in node[const.NODE_TABLE] if x['id'] in table_list]
def show_flows(modules=['ifm'], sort_by='table', filter_by=[]):
compute_map = get_dpn_host_mapping()
- nports = dsg.get_neutron_ports()
+ nports = neutron_neutron.get_ports_by_key()
for flow in utils.sort(get_all_flows(modules, filter_by), sort_by):
host = compute_map.get(flow.get('dpnid'), flow.get('dpnid'))
ip_list = get_ips_for_iface(nports, flow.get('ifname'))
def show_dup_flows():
- mmac = dsg.get_mip_mac()
- einsts = dsg.get_elan_instances()
+ mmac = mip_mac.get_entries_by_key()
+ einsts = elan_elan_instances.get_elan_instances_by_key()
flows = utils.sort(get_all_flows(['elan']), 'table')
matches = defaultdict(list)
compute_map = get_dpn_host_mapping()
def show_learned_mac_flows():
- nports = dsg.get_neutron_ports(key_field='mac-address')
+ nports = neutron_neutron.get_ports_by_key(key_field='mac-address')
flows = utils.sort(get_all_flows(['elan']), 'table')
compute_map = get_dpn_host_mapping()
for flow_info in flows:
def show_elan_instances():
- insts = dsg.get_elan_instances()
+ insts = elan_elan_instances.get_elan_instances_by_key()
json.dumps(insts)
def get_duplicate_ids():
duplicate_ids= {}
- for pool in dsg.get_idpools().itervalues():
+ for pool in id_manager_id_pools.get_id_pools_by_key().itervalues():
id_values = {}
for id_entry in pool.get('id-entries', []):
id_info = {}
def show_idpools():
- ports = dsg.get_neutron_ports()
+ ports = neutron_neutron.get_ports_by_key()
iface_ids = []
for k,v in get_duplicate_ids().iteritems():
result = "Id:{},Keys:{}".format(k, json.dumps(v.get('id-keys')))
# Sample method that shows how to use
def show_all_tables():
- of_nodes = dsg.get_inventory_config()
+ of_nodes = odl_inventory_nodes_config.get_nodes_by_key()
tables = set()
for node in of_nodes.itervalues():
for table in node[const.NODE_TABLE]:
def show_all_groups():
- of_nodes = dsg.get_inventory_config()
+ of_nodes = odl_inventory_nodes_config.get_nodes_by_key()
groups = get_groups(of_nodes)
for dpn in groups:
for group_key in groups[dpn]:
def analyze_trunks():
- nports = dsg.get_neutron_ports()
- ntrunks = dsg.get_neutron_trunks()
- vpninterfaces = dsg.get_vpninterfaces()
- ifaces = dsg.get_config_interfaces()
- ifstates = dsg.get_interface_states()
+ nports = neutron_neutron.get_ports_by_key()
+ ntrunks = neutron_neutron.get_trunks_by_key()
+ vpninterfaces = l3vpn_vpn_interfaces.get_vpn_ids_by_key()
+ ifaces = ietf_interfaces_interfaces.get_interfaces_by_key()
+ ifstates = ietf_interfaces_interfaces_state.get_interfaces_by_key()
subport_dict = {}
for v in ntrunks.itervalues():
nport = nports.get(v.get('port-id'))
def main(args=None):
+ global elan_elan_instances
+ global elan_elan_interfaces
+ global id_manager_id_pools
+ global ietf_interfaces_interfaces
+ global ietf_interfaces_interfaces_state
+ global interface_service_bindings_service_bindings
+ global itm_state_tunnels_state
+ global l3vpn_vpn_interfaces
+ global mip_mac
+ global network_topology_network_topology_config
+ global network_topology_network_topology_operational
+ global neutron_neutron
+ global odl_fib_fib_entries
+ global odl_interface_meta_if_index_interface_map
+ global odl_inventory_nodes_config
+ global odl_inventory_nodes_operational
+ global odl_l3vpn_vpn_instance_to_vpn_id
options, args = utils.parse_args()
+
+ elan_elan_instances = elan.elan_instances(Model.CONFIG, modelpath)
+ elan_elan_interfaces = elan.elan_interfaces(Model.CONFIG, modelpath)
+ id_manager_id_pools = id_manager.id_pools(Model.CONFIG, modelpath)
+ ietf_interfaces_interfaces = ietf_interfaces.interfaces(Model.CONFIG, modelpath)
+ ietf_interfaces_interfaces_state = ietf_interfaces.interfaces_state(Model.OPERATIONAL, modelpath)
+ interface_service_bindings_service_bindings = interface_service_bindings.service_bindings(Model.CONFIG, modelpath)
+ itm_state_tunnels_state = itm_state.tunnels_state(Model.OPERATIONAL, modelpath)
+ l3vpn_vpn_interfaces = l3vpn.vpn_instance_to_vpn_id(Model.CONFIG, modelpath)
+ mip_mac = mip.mac(Model.CONFIG, modelpath)
+ neutron_neutron = neutron.neutron(Model.CONFIG, modelpath)
+ network_topology_network_topology_config = network_topology.network_topology(Model.CONFIG, modelpath)
+ network_topology_network_topology_operational = network_topology.network_topology(Model.CONFIG, modelpath)
+ neutron_neutron = neutron.neutron(Model.CONFIG, modelpath)
+ odl_fib_fib_entries = odl_fib.fib_entries(Model.CONFIG, modelpath)
+ odl_interface_meta_if_index_interface_map = odl_interface_meta.if_indexes_interface_map(Model.OPERATIONAL, modelpath)
+ odl_inventory_nodes_config = opendaylight_inventory.nodes(Model.CONFIG, modelpath)
+ odl_inventory_nodes_operational = opendaylight_inventory.nodes(Model.OPERATIONAL, modelpath)
+ odl_l3vpn_vpn_instance_to_vpn_id = odl_l3vpn.vpn_instance_to_vpn_id(Model.CONFIG, modelpath)
+
if options.callMethod:
if args[1:]:
eval(options.callMethod)(args[1:])
else:
eval(options.callMethod)()
return
- #print json.dumps(dsg.get_vpninterfaces())
+ #print json.dumps(l3vpn_vpn_interfaces.get_vpn_ids_by_key())
#show_all_tables()
#analyze_inventory('openflow:165862438671169',ifName='tunf94333cc491')
#show_stale_flows()
+++ /dev/null
-import collections
-import json
-import netvirt_utils as utils
-import constants as const
-
-
-def get_ds_data(name, file_name=None, ds_type=None):
- res = const.DSMAP[name]
- filename = '{}/{}'.format(utils.get_temp_path(), res[const.DSM_FILE])
- dstype = ds_type or res[const.DSM_DSTYPE]
- path = res[const.DSM_PATH]
- root1 = res[const.DSM_ROOT1]
- root2 = res[const.DSM_ROOT2]
- data = {}
- try:
- with open(filename) as data_file:
- data = json.load(data_file)[root1][root2]
- except IOError:
- url = utils.create_url(dstype, path)
- result = utils.grabJson(url)
- if result:
- data = result[root1][root2]
- return data
-
-
-def get_all_dumps():
- for res in const.DSMAP.itervalues():
- filename = '{}/{}'.format(utils.get_temp_path(), res[const.DSM_FILE])
- dstype = res[const.DSM_DSTYPE]
- path = res[const.DSM_PATH]
- root1 = res[const.DSM_ROOT1]
- root2 = res[const.DSM_ROOT2]
- data = {}
- url = utils.create_url(dstype, path)
- result = utils.grabJson(url)
- with open(filename, 'w+') as data_file:
- json.dump(result, data_file)
-
-
-def get_config_interfaces(file_name=None):
- # Returns dict of ifaces, key is iface name
- if_dict = {}
- ifaces = get_ds_data('ifconfig',file_name)
- for iface in ifaces:
- if_dict[iface['name']] = iface
- return if_dict
-
-
-def get_itm_config_interfaces(file_name=None):
- tun_dict = {}
- tunifaces = get_ds_data('itmconfig',file_name)
- for sourcedpn in tunifaces:
- for remotedpn in sourcedpn['remote-dpns']:
- tun_dict[remotedpn['tunnel-name']] = remotedpn
- return tun_dict
-
-
-def get_neutron_ports(file_name=None, key_field='uuid'):
- port_dict = {}
- ports = get_ds_data('neutronports',file_name)
- for port in ports:
- port_dict[port[key_field]] = port
- return port_dict
-
-
-def get_neutron_trunks(file_name=None):
- trunk_dict = {}
- trunks = get_ds_data('neutrontrunks',file_name)
- for trunk in trunks:
- trunk_dict[trunk['uuid']] = trunk
- return trunk_dict
-
-
-def get_interface_states(file_name=None):
- ifs_dict = {}
- ifstates = get_ds_data('ifstate',file_name)
- for ifstate in ifstates:
- ifs_dict[ifstate['name']] = ifstate
- return ifs_dict
-
-
-def get_config_tunnels(file_name='tunnel-config.log'):
- tun_dict = {}
- tunnels = {}
- try:
- with open(file_name) as tunconfig_file:
- tunnels = json.load(tunconfig_file)['tunnel-list']['internal-tunnel']
- except Exception:
- pass
- for tunnel in tunnels:
- for tun_name in tunnel['tunnel-interface-name']:
- tun_dict[tun_name] = tunnel
- return tun_dict
-
-
-def get_tunnel_states(file_name=None):
- tun_dict = {}
- tunnels = get_ds_data('tunstate',file_name)
- for tunnel in tunnels:
- tun_dict[tunnel['tunnel-interface-name']] = tunnel
- return tun_dict
-
-
-def get_topology_nodes(file_name, type = 'ovsdb:1', dsType = 'config'):
- nodes_dict = {}
- topologies = {}
- nodes = {}
- try:
- with open(file_name) as topology_file:
- topologies = json.load(topology_file)['topology']
- nodes = [topology['node'] for topology in topologies if topology['topology-id'] == type][0]
- except IOError:
- url = utils.create_url(dsType, "network-topology:network-topology/{}".format(type))
- result = utils.grabJson(url)
- if result:
- nodes = result['node']
- for node in nodes:
- nodes_dict[node['node-id']] = node
- return nodes_dict
-
-
-def get_topology_config(file_name='topology-config.log', type = 'ovsdb:1'):
- return get_topology_nodes(file_name)
-
-
-def get_topology_oper(file_name='topology-oper.log', type = 'ovsdb:1', dsType = 'operational'):
- return get_topology_nodes(file_name, type)
-
-
-def get_inventory_nodes(file_name, dsType = 'config'):
- nodes_dict = {}
- nodes = get_ds_data('inventory', file_name, dsType)
- for node in nodes:
- nodes_dict[node['id']] = node
- return nodes_dict
-
-
-
-def get_inventory_config(file_name=None):
- return get_inventory_nodes(file_name)
-
-
-def get_inventory_oper(file_name='inventory-oper.log'):
- return get_inventory_nodes(file_name, 'operational')
-
-
-def get_service_bindings(file_name=None):
- sb_dict = collections.defaultdict(dict)
- orphans_dict = collections.defaultdict(dict)
- sb_infos = get_ds_data('bindings')
- for sb_info in sb_infos:
- service_mode = sb_info['service-mode'][len('interface-service-bindings:'):]
- if sb_info.get('bound-services'):
- sb_dict[sb_info['interface-name']][service_mode] = sb_info
- else:
- orphans_dict[sb_info['interface-name']][service_mode] = sb_info
- return dict(sb_dict), dict(orphans_dict)
-
-
-def get_elan_instances(file_name=None):
- einstances_dict = {}
- einstances = get_ds_data('elaninstances')
- for einstance in einstances:
- einstances_dict[einstance['elan-instance-name']] = einstance
- return einstances_dict
-
-
-def get_elan_interfaces(file_name=None):
- eifaces_dict = {}
- eifaces = get_ds_data('elaninterfaces')
- for eiface in eifaces:
- eifaces_dict[eiface['name']] = eiface
- return eifaces_dict
-
-
-def get_ifindexes(file_name=None):
- ifindexes_dict = {}
- ifindexes = get_ds_data('ifindexes')
- for ifindex in ifindexes:
- ifindexes_dict[ifindex['if-index']] = ifindex
- return ifindexes_dict
-
-
-def get_fibentries_by_label(file_name=None):
- fibs_dict = {}
- fibs = get_ds_data('fibentries')
- for vrftable in fibs:
- for vrfEntry in vrftable.get('vrfentry', []):
- if vrfEntry.get('label'):
- vrfEntry['rd'] = vrftable['routeDistinguisher']
- fibs_dict[vrfEntry['label']] = vrfEntry
- return fibs_dict
-
-
-def get_vpnids(filename=None):
- vpnids_dict = {}
- vpninstances = get_ds_data('vpninstance-to-vpnid')
- for vpninstance in vpninstances:
- vpnids_dict[vpninstance['vpn-id']] = vpninstance
- return vpnids_dict
-
-
-def get_vpninterfaces(filename=None):
- vpninterfaces_dict = {}
- vpninterfaces = get_ds_data('vpninterfaces')
- for vpninterface in vpninterfaces:
- vpninterfaces_dict[vpninterface['name']] = vpninterface
- return vpninterfaces_dict
-
-
-def get_idpools(filename=None):
- idpools_dict = {}
- idpools = get_ds_data('idpools')
- for idpool in idpools:
- idpools_dict[idpool['pool-name']] = idpool
- return idpools_dict
-
-
-def get_mip_mac(filename='mip-mac.log'):
- mmac_dict = collections.defaultdict(dict)
- try:
- with open(filename) as data_file:
- data = json.load(data_file)
- except IOError:
- data = []
- for entry in data:
- entry['mac'] = entry['mac'].lower()
- mmac_dict[entry.get('mac')][entry.get('network-id')] = entry
- return mmac_dict
lines = []
with open(filename, 'r') as fp:
for line in fp:
- # strip leading spaces; by default every flow line has a leading space: " cookie=..."
+ # strip leading spaces. by default every flow line has a leading space: " cookie=..."
lines.append(line.lstrip())
- logger.info("read_file: File: %s: processed %d lines", filename, len(lines))
- # logger.debug("read_file: lines:\n%s", "".join(lines))
+ logger.debug("read_file: File: %s: processed %d lines", filename, len(lines))
return lines
def write_file(filename, lines):
with open(filename, 'w') as fp:
fp.writelines(lines)
- logger.info("write_file: File: %s: wrote %d lines", filename, len(lines))
+ logger.debug("write_file: File: %s: wrote %d lines", filename, len(lines))
Code Review / netvirt.git / commitdiff