util/testOfOverlay/odl_gbp.py

   1
   2 import requests,json
   3 from requests.auth import HTTPBasicAuth
   4
   5 USERNAME='admin'
   6 PASSWORD='admin'
   7 REGISTER_EP_URL="http://%s:8181/restconf/operations/endpoint:register-endpoint"
   8 REGISTER_TENANTS_URL="http://%s:8181/restconf/config/policy:tenants"
   9 REGISTER_NODES_URL="http://%s:8181/restconf/config/opendaylight-inventory:nodes"
  10
  11 endpointGroups = {}
  12
  13 def get_epg(tenantId, epgId):
  14     k = "{}|{}".format(tenantId,epgId)
  15     if k in endpointGroups:
  16         return endpointGroups[k]
  17     tenant = get_tenant(tenantId);
  18     data = {
  19         "id": epgId,
  20         "consumer-named-selector": [],
  21         "provider-named-selector": []
  22     }
  23     tenant["endpoint-group"].append(data)
  24     endpointGroups[k] = data
  25     return data
  26
  27 tenants = {}
  28
  29 def get_tenant(tenantId):
  30     if tenantId in tenants:
  31         return tenants[tenantId]
  32     data = {
  33         "id": tenantId,
  34         "l3-context": [],
  35         "l2-bridge-domain": [],
  36         "l2-flood-domain": [],
  37         "subnet": [],
  38         "endpoint-group": [],
  39         "contract": [],
  40         "subject-feature-instances": {
  41             "classifier-instance": [
  42                 {"name": "http-dest",
  43                 "classifier-definition-id": "4250ab32-e8b8-445a-aebb-e1bd2cdd291f",
  44                 "parameter-value": [
  45                     {"name": "type",
  46                      "string-value": "TCP"},
  47                     {"name": "destport",
  48                      "int-value": "80"}
  49                 ]},
  50                 {"name": "http-src",
  51                 "classifier-definition-id": "4250ab32-e8b8-445a-aebb-e1bd2cdd291f",
  52                 "parameter-value": [
  53                     {"name": "type",
  54                      "string-value": "TCP"},
  55                     {"name": "sourceport",
  56                      "int-value": "80"}
  57                 ]},
  58                 {"name": "icmp",
  59                 "classifier-definition-id": "79c6fdb2-1e1a-4832-af57-c65baf5c2335",
  60                 "parameter-value": [
  61                     {"name": "proto",
  62                      "int-value": "1"}
  63                 ]},
  64             ]
  65         }
  66     }
  67     tenants[tenantId] = data
  68     return data
  69
  70 subnets = {}
  71
  72 def get_fd(tenantId, fdId, parent):
  73     tenant = get_tenant(tenantId)
  74     data = {"id": fdId,
  75             "parent": parent}
  76     tenant["l2-flood-domain"].append(data)
  77     return data
  78
  79 def get_bd(tenantId, bdId, parent):
  80     tenant = get_tenant(tenantId)
  81     data = {"id": bdId,
  82             "parent": parent}
  83     tenant["l2-bridge-domain"].append(data)
  84     return data
  85
  86 def get_l3c(tenantId, l3cId):
  87     tenant = get_tenant(tenantId)
  88     data = {"id": l3cId}
  89     tenant["l3-context"].append(data)
  90     return data
  91
  92 def get_subnet(tenantId, subnetId, parent, prefix, router):
  93     k = "{}|{}".format(tenantId, subnetId)
  94     if k in subnets:
  95         return subnets[k]
  96     tenant = get_tenant(tenantId)
  97     data = {"id": subnetId,
  98             "parent": parent,
  99             "ip-prefix": prefix,
 100             "virtual-router-ip": router}
 101     tenant["subnet"].append(data)
 102     return data
 103
 104 endpoints = []
 105
 106 def get_ep(tenantId, groupId, l3ctx, ip, l2ctx, mac, sw, port):
 107     group = get_epg(tenantId, groupId)
 108     data = {"tenant": tenantId,
 109             "endpoint-group": groupId,
 110             "l2-context": l2ctx,
 111             "mac-address": mac,
 112             "l3-address": [{"l3-context": l3ctx,
 113                             "ip-address": ip}],
 114             "ofoverlay:node-id": "openflow:{}".format(sw),
 115             "ofoverlay:node-connector-id": "openflow:{}:{}".format(sw, port)
 116         }
 117     endpoints.append(data)
 118     return data
 119
 120 nodes = []
 121
 122 def get_node_config(sw, tun_ip):
 123     data = {
 124         "id": "openflow:{}".format(sw),
 125         "ofoverlay:tunnel-ip": tun_ip
 126     }
 127     nodes.append(data)
 128     return data
 129
 130 def get_contract(tenantId, pgroupId, cgroupId, contractId):
 131     tenant = get_tenant(tenantId)
 132     pgroup = get_epg(tenantId, pgroupId)
 133     cgroup = get_epg(tenantId, cgroupId)
 134     data = {
 135         "id": contractId,
 136         "subject": [{"name": "allow-http-subject",
 137                      "rule": [
 138                          {"name": "allow-http-rule",
 139                           "classifier-ref": [
 140                               {"name": "http-dest",
 141                                "direction": "in"},
 142                               {"name": "http-src",
 143                                "direction": "out"}
 144                           ]}
 145                      ]},
 146                     {"name": "allow-icmp-subject",
 147                      "rule": [
 148                          {"name": "allow-icmp-rule",
 149                           "classifier-ref": [
 150                               {"name": "icmp"}
 151                           ]}
 152                      ]}],
 153         "clause": [{"name": "allow-http-clause",
 154                     "subject-refs": ["allow-http-subject",
 155                                      "allow-icmp-subject"]}]
 156     }
 157     tenant["contract"].append(data)
 158     cgroup["consumer-named-selector"].append({
 159         "name": "{}-{}-{}".format(pgroupId, cgroupId, contractId),
 160         "contract": [contractId]
 161     })
 162     pgroup["provider-named-selector"].append({
 163         "name": "{}-{}-{}".format(pgroupId, cgroupId, contractId),
 164         "contract": [contractId]
 165     })
 166
 167     return data
 168
 169 def post(url, data):
 170     headers = {'Content-type': 'application/yang.data+json',
 171                'Accept': 'application/yang.data+json'}
 172     print "POST %s" % url
 173     print json.dumps(data, indent=4, sort_keys=True)
 174     r = requests.post(url, data=json.dumps(data), headers=headers, auth=HTTPBasicAuth(USERNAME, PASSWORD))
 175     print r.text
 176     r.raise_for_status()
 177
 178 def put(url, data):
 179     headers = {'Content-type': 'application/yang.data+json',
 180                'Accept': 'application/yang.data+json'}
 181     print "PUT %s" % url
 182     print json.dumps(data, indent=4, sort_keys=True)
 183     r = requests.put(url, data=json.dumps(data), headers=headers, auth=HTTPBasicAuth(USERNAME, PASSWORD))
 184     print r.text
 185     r.raise_for_status()
 186
 187 def register_tenants(contHost):
 188     data = {"policy:tenants": {"tenant": tenants.values()}}
 189     put(REGISTER_TENANTS_URL % contHost, data)
 190
 191 def register_eps(contHost):
 192     for ep in endpoints:
 193        data = {"input": ep}
 194        post(REGISTER_EP_URL % contHost, data)
 195
 196 def register_nodes(contHost):
 197     data = {"opendaylight-inventory:nodes": {"node": nodes}}
 198     put(REGISTER_NODES_URL % contHost, data)