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