def create_multicontroller_mininet_topology(mininet_blockname):
mininet_ip = vtn_testconfig.ReadValues(MININETDATA,
mininet_blockname)['mininet_ipaddr']
mininet_user = vtn_testconfig.ReadValues(
MININETDATA, mininet_blockname)['mininet_username']
ssh = vtn_testconfig.ReadValues(MININETDATA, mininet_blockname)['ssh']
file_name = vtn_testconfig.ReadValues(MININETDATA,
mininet_blockname)['file_name']
topology = ssh + ' ' + mininet_user + ' ' + mininet_ip + ' ' + file_name
ssh_newkey = 'Are you sure you want to continue connecting'
print topology
child = pexpect.spawn(topology)
child.logfile = open("/tmp/mylog", "w")
index = child.expect(
[ssh_newkey, 'password:'******'yes')
index = child.expect(
[ssh_newkey, 'password:'******'mininet')
print "connection OK"
return child
elif index == 2:
print "2:connection timeout"
return child
elif index == 3:
print "3:connection timeout"
return child
def split_blockname(blockname, url):
count = blockname.count('|')
vbr_bn = ""
vbrif_bn = ""
vtermif_bn = ""
if count == 3:
vtermif_bn = blockname.split('|')[3]
vterm_bn = blockname.split('|')[1]
if count == 2:
vbrif_bn = blockname.split('|')[2]
count = count - 1
if count == 1:
vbr_bn = blockname.split('|')[1]
count = count - 1
if(vbr_bn):
vbr_url = vtn_testconfig.ReadValues(VTNVBRDATA, vbr_bn)['vbr_url']
url = url + vbr_url
if(vbrif_bn):
vbr_url = vtn_testconfig.ReadValues(VBRIFDATA, vbrif_bn)['vbrif_url']
url = url + vbr_url
if(vtermif_bn):
vterm_url = vtn_testconfig.ReadValues(VTNVTERMDATA, vterm_bn)['vterm_url']
vtermif_url = vtn_testconfig.ReadValues(VTERMIFDATA, vtermif_bn)['vtermif_url']
url = url + vterm_url + vtermif_url
return url
def validate_boundary(blockname, presence="yes", position=0):
boundary_name = vtn_testconfig.ReadValues(MININETDATA,
blockname)['boundary_id']
boundary_url = vtn_testconfig.ReadValues(MININETDATA, 'URL')['url']
url = coordinator_url + boundary_url
print url
r = requests.get(url, headers=def_header)
print r.status_code
if presence == "no":
if r.status_code == resp_code.RESP_NOT_FOUND:
return 0
if r.status_code != resp_code.RESP_GET_SUCCESS:
return 1
data = json.loads(r.content)
if presence == "no":
print data['boundaries']
if data['boundaries'] == []:
return 0
vtn_content = data['boundaries'][position]
if vtn_content['boundary_id'] != boundary_name:
if presence == "yes":
return 1
else:
return 0
else:
if presence == "yes":
return 0
else:
return 1
def validate_vtn_at_controller(vtn_blockname,
controller_blockname,
presence="yes",
position=0):
test_vtn_name = vtn_testconfig.ReadValues(VTNVTERMDATA,
vtn_blockname)['vtn_name']
test_controller_ipaddr = vtn_testconfig.ReadValues(
CONTROLLERDATA, controller_blockname)['ipaddr']
test_controller_port = vtn_testconfig.ReadValues(
CONTROLLERDATA, controller_blockname)['restconf_port']
test_vtn_url = vtn_testconfig.ReadValues(VTNVTERMDATA, 'VTNURL')['ctr_url']
url = 'http://' + test_controller_ipaddr + ':' + test_controller_port + controller_url_part + test_vtn_url + '/' + test_vtn_name
print url
r = requests.get(url, headers=controller_headers, auth=('admin', 'admin'))
print r.status_code
if presence == "no":
if r.status_code == resp_code.RESP_NOT_FOUND:
print 'vtenant name : ' + test_vtn_name + ' is removed'
return 0
if r.status_code != resp_code.RESP_GET_SUCCESS:
return 1
data = json.loads(r.content)
if presence == "no":
print data['vtn']
if data['vtn'] == []:
return 0
vtn_content = data['vtn'][position]
print vtn_content
if vtn_content == None:
if presence == "yes":
return 0
else:
return 1
if vtn_content['name'] != test_vtn_name:
if presence == "yes":
return 1
else:
return 0
else:
if presence == "yes":
print 'vtn name : ' + vtn_content['name'] + ' is present'
return 0
else:
return 1
def validate_flowlist_at_controller(flowlist_blockname,
controller_blockname,
presence="yes",
position=0):
test_vtn_name = vtn_testconfig.ReadValues(
FLOWLISTDATA, flowlist_blockname)['flowlist_name']
test_controller_ipaddr = vtn_testconfig.ReadValues(
CONTROLLERDATA, controller_blockname)['ipaddr']
test_controller_port = vtn_testconfig.ReadValues(
CONTROLLERDATA, controller_blockname)['restconf_port']
test_vtn_url = vtn_testconfig.ReadValues(FLOWLISTDATA,
'FLOWLISTURL')['ctr_url']
url = 'http://' + test_controller_ipaddr + ':' + test_controller_port + controller_url_part + test_vtn_url
print url
r = requests.get(url, headers=controller_headers, auth=('admin', 'admin'))
print r.status_code
if presence == "no":
if r.status_code == resp_code.RESP_NOT_FOUND:
return 0
if r.status_code != resp_code.RESP_GET_SUCCESS:
return 1
data = json.loads(r.content)
print data
return 0
# if presence == "no":
# print data['flowlist']
# if data['flowlist'] == []:
# return 0
vtn_content = data['vtn-flow-condition'][position]
if vtn_content == None:
if presence == "yes":
return 0
else:
return 1
if vtn_content['name'] != test_vtn_name:
if presence == "yes":
return 1
else:
return 0
else:
if presence == "yes":
return 0
else:
return 1
def delete_boundary(blockname):
boundary_name = vtn_testconfig.ReadValues(MININETDATA,
blockname)['boundary_id']
boundary_url = vtn_testconfig.ReadValues(MININETDATA, blockname)['url']
url = coordinator_url + boundary_url
print url
r = requests.delete(url, headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_DELETE_SUCCESS:
return 1
else:
return 0
def delete_vtn(blockname):
test_vtn_name=vtn_testconfig.ReadValues(VTNVBRDATA,blockname)['vtn_name']
test_vtn_description=vtn_testconfig.ReadValues(VTNVBRDATA,blockname)['description']
vtn_url=vtn_testconfig.ReadValues(VTNVBRDATA,blockname)['vtn_url']
url= coordinator_url + vtn_url + '.json'
print url
r = requests.delete(url,headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_DELETE_SUCCESS and r.status_code != resp_code.RESP_DELETE_SUCCESS_U14:
return 1
else:
return 0
def delete_flowlistentry(flowlist_blockname,flowlistentry_blockname):
test_vtn_name=vtn_testconfig.ReadValues(FLOWLISTDATA,flowlist_blockname)['flowlist_name']
test_flentry_seqnum=vtn_testconfig.ReadValues(FLOWLISTENTRYDATA,flowlistentry_blockname)['seqnum']
url= coordinator_url + '/flowlists/' + test_vtn_name + '/flowlistentries/' + test_flentry_seqnum + '.json'
print url
r = requests.delete(url,headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_DELETE_SUCCESS and r.status_code != resp_code.RESP_DELETE_SUCCESS_U14:
return 1
else:
return 0
def delete_vlink(vlink_blockname, vtn_blockname):
vlink_name = vtn_testconfig.ReadValues(MININETDATA,
vlink_blockname)['link_name']
vlink_url = vtn_testconfig.ReadValues(MININETDATA, vlink_blockname)['url']
vtn_name = vtn_testconfig.ReadValues(VTNVBRDATA, vtn_blockname)['vtn_name']
vtn_url = vtn_testconfig.ReadValues(VTNVBRDATA, 'VTNURL')['ctr_url']
url = coordinator_url + vtn_url + '/' + vtn_name + vlink_url
print url
r = requests.delete(url, headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_DELETE_SUCCESS:
return 1
else:
return 0
def create_flowlist(blockname):
test_vtn_name=vtn_testconfig.ReadValues(FLOWLISTDATA,blockname)['flowlist_name']
vtn_url=vtn_testconfig.ReadValues(FLOWLISTDATA,'FLOWLISTURL')['url']
url= coordinator_url + vtn_url
print url
vtn_add = collections.defaultdict(dict)
vtn_add['flowlist']['fl_name']=test_vtn_name
r = requests.post(url,data=json.dumps(vtn_add),headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_CREATE_SUCCESS and r.status_code != resp_code.RESP_CREATE_SUCCESS_U14:
return 1
else:
return 0
def delete_vtermif(vtn_blockname,vterm_blockname,vtermif_blockname):
test_vtn_name = vtn_testconfig.ReadValues(VTNVTERMDATA,vtn_blockname)['vtn_name']
test_vterminal_name = vtn_testconfig.ReadValues(VTNVTERMDATA,vterm_blockname)['vterminal_name']
vtn_url = vtn_testconfig.ReadValues(VTNVTERMDATA,vtn_blockname)['vtn_url']
vterm_url = vtn_testconfig.ReadValues(VTNVTERMDATA,vterm_blockname)['vterm_url']
vtermif_url = vtn_testconfig.ReadValues(VTERMIFDATA,vtermif_blockname)['vtermif_url']
url= coordinator_url + vtn_url + vterm_url + vtermif_url + '.json'
print url
r = requests.delete(url,headers = def_header)
print r.status_code
if r.status_code != resp_code.RESP_DELETE_SUCCESS and r.status_code != resp_code.RESP_DELETE_SUCCESS_U14:
return 1
else:
return 0
def wait_until_state(blockname, state):
#print "Wait until the controler state is",state
i = 1
retval = 1
test_controller_id = vtn_testconfig.ReadValues(CONTROLLERDATA,
blockname)['controller_id']
test_url = vtn_testconfig.ReadValues(CONTROLLERDATA, blockname)['url']
while (retval == 1):
sys.stdout.write("\rWaiting..%ds.." % i)
sys.stdout.flush()
time.sleep(4)
i += 4
if i == 45:
return 1
retval = check_controller_state(blockname, state)
return 0
def create_vtn(blockname):
test_vtn_name=vtn_testconfig.ReadValues(VTNVBRDATA,blockname)['vtn_name']
test_vtn_description=vtn_testconfig.ReadValues(VTNVBRDATA,blockname)['description']
vtn_url=vtn_testconfig.ReadValues(VTNVBRDATA,'VTNURL')['url']
url= coordinator_url + vtn_url
print url
vtn_add = collections.defaultdict(dict)
vtn_add['vtn']['vtn_name']=test_vtn_name
vtn_add['vtn']['description']=test_vtn_description
r = requests.post(url,data=json.dumps(vtn_add),headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_CREATE_SUCCESS and r.status_code != resp_code.RESP_CREATE_SUCCESS_U14:
return 1
else:
return 0
def validate_dlsrc(json_array, ff_blockname):
print "validate_dlsrc"
dlsrc = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['dlsrc']
if json_arrary['dlsrc']['address'] == int(locale.atof(dlsrc)):
print "dlsrc"
return 0
else:
return 1
def validate_dscp(json_array, ff_blockname):
print "validate_dscp"
dscp = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['dscp']
if json_array['dscp']['dscp'] == int(locale.atof(dscp)):
print "dscp"
return 0
else:
return 1
def delete_flowfilter(blockname, ff_blockname):
vtn_bn = blockname.split('|')[0]
vtn_url = vtn_testconfig.ReadValues(VTNVBRDATA, vtn_bn)['vtn_url']
ff_type = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['type']
url = coordinator_url + vtn_url
url = split_blockname(blockname, url)
url = url + '/flowfilters/' + ff_type + '.json'
print url
r = requests.delete(url, headers = def_header)
print r.status_code
if r.status_code != resp_code.RESP_DELETE_SUCCESS and r.status_code != resp_code.RESP_DELETE_SUCCESS_U14:
return 1
else:
return 0
def validate_dlsrc(json_array, ff_blockname):
print "validate_dlsrc"
dlsrc = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['srcaddress']
print dlsrc
print json_array['vtn-set-dl-src-action']['address']
if (json_array['vtn-set-dl-src-action']['address']) == dlsrc:
print "dlsrc"
return 0
def validate_dldst(json_array, ff_blockname):
print "validate_dldst"
macdstaddr = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['dstaddress']
print macdstaddr
print json_array['vtn-set-dl-dst-action']['address']
if (json_array['vtn-set-dl-dst-action']['address']) == macdstaddr:
print "dldst"
return 0
def validate_priority(json_array, ff_blockname):
print "validate_priority"
vlanpcp = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['priority']
if int(json_array['vtn-set-vlan-pcp-action']['vlan-pcp']) == int(locale.atof(vlanpcp)):
print "vlan-pcp"
return 0
else:
return 1
def create_vtermif(vtn_blockname, vterm_blockname, vtermif_blockname):
test_vtn_name = vtn_testconfig.ReadValues(VTNVTERMDATA,
vtn_blockname)['vtn_name']
vtn_url = vtn_testconfig.ReadValues(VTNVTERMDATA, vtn_blockname)['vtn_url']
vterm_url = vtn_testconfig.ReadValues(VTNVTERMDATA,
vterm_blockname)['vterm_url']
vtermif_create_url = vtn_testconfig.ReadValues(VTERMIFDATA,
'VTERMIFURL')['url']
vtermif_name = vtn_testconfig.ReadValues(VTERMIFDATA,
vtermif_blockname)['vtermif_name']
description = vtn_testconfig.ReadValues(VTERMIFDATA,
vtermif_blockname)['description']
admin_status = vtn_testconfig.ReadValues(VTERMIFDATA,
vtermif_blockname)['admin_status']
url = coordinator_url + vtn_url + vterm_url + vtermif_create_url
print url
vtermif_add = collections.defaultdict(dict)
vtermif_add['interface']['if_name'] = vtermif_name
vtermif_add['interface']['description'] = description
vtermif_add['interface']['admin_status'] = admin_status
r = requests.post(url, data=json.dumps(vtermif_add), headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_CREATE_SUCCESS and r.status_code != resp_code.RESP_CREATE_SUCCESS_U14:
return 1
else:
return 0
def delete_vlanmap(vtn_blockname, vbr_blockname, vlanmap_blockname, no_vlan=0):
test_vtn_name = vtn_testconfig.ReadValues(VTNVBRDATA,
vtn_blockname)['vtn_name']
test_vbr_name = vtn_testconfig.ReadValues(VTNVBRDATA,
vbr_blockname)['vbr_name']
vtn_url = vtn_testconfig.ReadValues(VTNVBRDATA, vtn_blockname)['vtn_url']
vbr_url = vtn_testconfig.ReadValues(VTNVBRDATA, vbr_blockname)['vbr_url']
vlanmap_create_url = vtn_testconfig.ReadValues(VLANMAPDATA,
'VLANMAPURL')['ctr_url']
vlan_map_id = vtn_testconfig.ReadValues(VLANMAPDATA,
vlanmap_blockname)['vlanmap_id']
no_vlanmap_id = vtn_testconfig.ReadValues(VLANMAPDATA,
'VLANMAPURL')['no_vlanmap_id']
if no_vlan == 1:
url = coordinator_url + vtn_url + vbr_url + vlanmap_create_url + '/' + vlan_map_id + '.json'
else:
url = coordinator_url + vtn_url + vbr_url + vlanmap_create_url + '/' + no_vlanmap_id + '.json'
print url
r = requests.delete(url, headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_DELETE_SUCCESS and r.status_code != resp_code.RESP_DELETE_SUCCESS_U14:
return 1
else:
return 0
def create_vterm(vtn_blockname, vterm_blockname, controller_blockname):
test_vtn_name = vtn_testconfig.ReadValues(VTNVTERMDATA,
vtn_blockname)['vtn_name']
test_vterminal_name = vtn_testconfig.ReadValues(
VTNVTERMDATA, vterm_blockname)['vterminal_name']
test_vterm_controller_id = vtn_testconfig.ReadValues(
CONTROLLERDATA, controller_blockname)['controller_id']
test_vterm_description = vtn_testconfig.ReadValues(
VTNVTERMDATA, vterm_blockname)['description']
test_vterm_domain_id = vtn_testconfig.ReadValues(
VTNVTERMDATA, vterm_blockname)['domain_id']
test_vtn_url = vtn_testconfig.ReadValues(VTNVTERMDATA,
vtn_blockname)['vtn_url']
vterm_url = vtn_testconfig.ReadValues(VTNVTERMDATA, 'VTERMURL')['url']
url = coordinator_url + test_vtn_url + vterm_url
print "url is ", url
vterm_add = collections.defaultdict(dict)
vterm_add['vterminal']['vterminal_name'] = test_vterminal_name
vterm_add['vterminal']['controller_id'] = test_vterm_controller_id
vterm_add['vterminal']['domain_id'] = test_vterm_domain_id
vterm_add['vterminal']['description'] = test_vterm_description
r = requests.post(url, data=json.dumps(vterm_add), headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_CREATE_SUCCESS and r.status_code != resp_code.RESP_CREATE_SUCCESS_U14:
return 1
else:
return 0
def update_controller_ex(blockname,
ipaddr="",
version="",
auditstatus="",
description="",
username="",
password=""):
test_controller_id = vtn_testconfig.ReadValues(CONTROLLERDATA,
blockname)['controller_id']
test_url = vtn_testconfig.ReadValues(CONTROLLERDATA, blockname)['url']
return update_controller(test_controller_id,
ipaddr=ipaddr,
version=version,
auditstatus=auditstatus,
description=description,
username=username,
password=password,
controller_url=test_url)
def validate_dscp(json_array, ff_blockname):
print "validate_dscp"
dscp = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['dscp']
if int(json_array['vtn-set-inet-dscp-action']['dscp']) == int(locale.atof(dscp)):
print "dscp"
return 0
else:
print 'fails dscp'
return 1
def validate_priority(json_array, ff_blockname):
print "validate_priority"
priority = vtn_testconfig.ReadValues(FLOWFILTERDATA,
ff_blockname)['priority']
if json_array['vlanpcp']['priority'] == int(locale.atof(priority)):
print "priority"
return 0
else:
return 1
def update_vlanmap(vtn_blockname,
vbr_blockname,
vlanmap_blockname,
update_id=0):
test_vtn_name = vtn_testconfig.ReadValues(VTNVBRDATA,
vtn_blockname)['vtn_name']
vtn_url = vtn_testconfig.ReadValues(VTNVBRDATA, vtn_blockname)['vtn_url']
vbr_url = vtn_testconfig.ReadValues(VTNVBRDATA, vbr_blockname)['vbr_url']
vlanmap_create_url = vtn_testconfig.ReadValues(VLANMAPDATA,
'VLANMAPURL')['ctr_url']
vlan_map_id = vtn_testconfig.ReadValues(VLANMAPDATA,
vlanmap_blockname)['vlanmap_id']
vlan_id = vtn_testconfig.ReadValues(VLANMAPDATA, vlanmap_blockname)['u_id']
vlan_id = vtn_testconfig.ReadValues(VLANMAPDATA, vlanmap_blockname)['u_id']
no_vlan_id = vtn_testconfig.ReadValues(VLANMAPDATA,
vlanmap_blockname)['no_vlan_id']
no_vlanmap_id = vtn_testconfig.ReadValues(VLANMAPDATA,
'VLANMAPURL')['no_vlanmap_id']
any_id = vtn_testconfig.ReadValues(VLANMAPDATA, 'VLANMAPURL')['any_id']
if update_id == 1 or update_id == 2:
url = coordinator_url + vtn_url + vbr_url + vlanmap_create_url + '/' + vlan_map_id + '.json'
else:
url = coordinator_url + vtn_url + vbr_url + vlanmap_create_url + '/' + no_vlanmap_id + '.json'
print url
vlan_map_add = collections.defaultdict(dict)
if update_id == 1:
vlan_map_add['vlanmap']['vlan_id'] = vlan_id
elif update_id == 2:
vlan_map_add['vlanmap']['no_vlan_id'] = no_vlan_id
else:
vlan_map_add['vlanmap']['vlan_id'] = 50
print json.dumps(vlan_map_add)
r = requests.put(url, data=json.dumps(vlan_map_add), headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_UPDATE_SUCCESS and r.status_code != resp_code.RESP_UPDATE_SUCCESS_U14:
return 1
else:
return 0
def create_vlink(vlink_blockname, boundary_blockname, vtn_blockname):
vlk_name = vtn_testconfig.ReadValues(MININETDATA,
vlink_blockname)['link_name']
vnode1 = vtn_testconfig.ReadValues(MININETDATA,
vlink_blockname)['vnode1_name']
vnode2 = vtn_testconfig.ReadValues(MININETDATA,
vlink_blockname)['vnode2_name']
if1_name = vtn_testconfig.ReadValues(MININETDATA,
vlink_blockname)['if1_name']
if2_name = vtn_testconfig.ReadValues(MININETDATA,
vlink_blockname)['if2_name']
vlan_id = vtn_testconfig.ReadValues(MININETDATA,
vlink_blockname)['vlan_id']
vlink_url = vtn_testconfig.ReadValues(MININETDATA, 'URL')['link_url']
boundary_name = vtn_testconfig.ReadValues(
MININETDATA, boundary_blockname)['boundary_id']
vtn_name = vtn_testconfig.ReadValues(VTNVBRDATA, vtn_blockname)['vtn_name']
vtn_url = vtn_testconfig.ReadValues(VTNVBRDATA, 'VTNURL')['ctr_url']
url = coordinator_url + vtn_url + '/' + vtn_name + vlink_url
print url
vlink_add = collections.defaultdict(dict)
boundarymap = collections.defaultdict(dict)
vlink_add['vlink']['vlk_name'] = vlk_name
vlink_add['vlink']['vnode1_name'] = vnode1
vlink_add['vlink']['if1_name'] = if1_name
vlink_add['vlink']['vnode2_name'] = vnode2
vlink_add['vlink']['if2_name'] = if2_name
vlink_add['vlink']['boundary_map'] = boundarymap
boundarymap['boundary_id'] = boundary_name
boundarymap['vlan_id'] = vlan_id
print json.dumps(vlink_add)
r = requests.post(url, data=json.dumps(vlink_add), headers=def_header)
print r.status_code
if r.status_code != resp_code.RESP_CREATE_SUCCESS:
return 1
else:
return 0
def create_mininet_topology(mininet_blockname, controller_blockname, topology_depth_str):
mininet_ip = vtn_testconfig.ReadValues(MININETDATA, mininet_blockname)['mininet_ipaddr']
mininet_user = vtn_testconfig.ReadValues(MININETDATA, mininet_blockname)['mininet_username']
ssh = vtn_testconfig.ReadValues(MININETDATA, mininet_blockname)['ssh']
ctr_remote = vtn_testconfig.ReadValues(MININETDATA, mininet_blockname)['ctr_remote']
topo_tree = vtn_testconfig.ReadValues(MININETDATA, mininet_blockname)['topo_tree']
controller_ipaddr = vtn_testconfig.ReadValues(CONTROLLERDATA, controller_blockname)['ipaddr']
topology = ssh +' ' + mininet_user +' '+ mininet_ip +' '+ ctr_remote +controller_ipaddr +' '+ topo_tree +topology_depth_str
ssh_newkey = 'Are you sure you want to continue connecting'
print topology
child = pexpect.spawn(topology)
index = child.expect([ssh_newkey, 'password:'******'yes')
index = child.expect([ssh_newkey, 'password:'******'mininet')
print "connection OK"
return child
elif index == 2:
print "2:connection timeout"
return child
elif index == 3:
print "3:connection timeout"
return child
def create_flowfilter(blockname, ff_blockname):
vtn_bn = blockname.split('|')[0]
vtn_url=vtn_testconfig.ReadValues(VTNVBRDATA, vtn_bn)['vtn_url']
flowfilter_url = vtn_testconfig.ReadValues(FLOWFILTERDATA, 'FlowfilterURL')['url']
ff_type = vtn_testconfig.ReadValues(FLOWFILTERDATA, ff_blockname)['type']
url = coordinator_url + vtn_url
url = split_blockname(blockname, url)
url = url + flowfilter_url
print url
flowfilter_add = collections.defaultdict(dict)
print ff_type
flowfilter_add['flowfilter']['ff_type'] = ff_type
print flowfilter_add
r = requests.post(url, data = json.dumps(flowfilter_add), headers = def_header)
print r.status_code
if r.status_code != resp_code.RESP_CREATE_SUCCESS and r.status_code != resp_code.RESP_CREATE_SUCCESS_U14:
return 1
else:
return 0
def validate_flowlistentry_at_controller(flowlist_blockname, flowlistentry_blockname,controller_blockname, presence="yes",position=0):
test_vtn_name=vtn_testconfig.ReadValues(FLOWLISTDATA,blockname)['flowlist_name']
test_flentry_seqnum=vtn_testconfig.ReadValues(FLOWLISTENTRYDATA,blockname)['seqnum']
test_controller_ipaddr=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['ipaddr']
test_controller_id=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['controller_id']
test_controller_port=vtn_testconfig.ReadValues(CONTROLLERDATA,controller_blockname)['port']
test_flowlist_url=vtn_testconfig.ReadValues(FLOWLISTDATA,'FLOWLISTURL')['ctr_url']
test_flowlistentry_url=vtn_testconfig.ReadValues(FLOWLISTENTRYDATA,'FLOWLISTENTRY')['ctr_url']
url='http://'+test_controller_ipaddr+':'+test_controller_port+controller_url_part+test_flowlist_url+'/'+test_vtn_name+test_vbr_url
print url
r = requests.get(url,headers=controller_headers,auth=('admin','admin'))
print r.status_code
if presence == "no":
if r.status_code == resp_code.RESP_NOT_FOUND:
return 0
if r.status_code != resp_code.RESP_GET_SUCCESS:
return 1
data=json.loads(r.content)
vtn_content=data['flowlistentries'][position]
print vtn_content
if vtn_content == None:
if presence == "yes":
return 0
else:
return 1
if vtn_content['flowlist_name'] != test_vtn_name:
if presence == "yes":
return 1
else:
return 0
else:
if presence == "yes":
return 0
if vtn_content['seqnum'] != test_flentry_seqnum:
if presence == "yes":
return 1
else:
return 0
else:
if presence == "yes":
return 0
