7 from multiprocessing import Process
8 from multiprocessing import Queue
9 from pexpect import pxssh
11 import functest.utils.functest_logger as ft_logger
20 """Defines all the def function of SFC."""
23 """Initialization of variables."""
24 self.logger = ft_logger.Logger("sfc_fun").getLogger()
29 self.keystone_hostname = 'keystone_ip'
30 self.neutron_hostname = 'neutron_ip'
31 self.nova_hostname = 'nova_ip'
32 self.glance_hostname = 'glance_ip'
33 self.onos_hostname = 'onos_ip'
34 # Network variables #######
35 self.netname = "test_nw"
36 self.admin_state_up = True
39 # #########################
40 # SubNet variables#########
42 self.cidr = "20.20.20.0/24"
43 self.subnetname = "test_nw_subnets"
44 # ###############################
53 self.security_groups = []
54 self.port_security_enabled = False
55 # ###############################
56 # VM creation variable
57 self.container_format = "bare"
58 self.disk_format = "qcow2"
59 self.imagename = "TestSfcVm"
60 self.createImage = "/home/root1/devstack/files/images/\
61 firewall_block_image.img"
64 self.imageRef = "test"
70 self.routername = "router1"
72 # #####################################
74 self.port_pair_ingress = 0
75 self.port_pair_egress = 0
76 self.port_pair_name = "PP"
77 self.port_pair_id = []
78 # ####################################
80 self.port_group_name = "PG"
82 # ####################################
84 self.source_ip_prefix = "20.20.20.0/24"
85 self.destination_ip_prefix = "20.20.20.0/24"
86 self.logical_source_port = 0
88 self.ethertype = "IPv4"
89 # #####################################
90 self.flow_class_if = 0
91 # #####################################
92 # Port Chain variables
95 # #####################################
96 # Port Chain variables
98 # #####################################
100 self.vm_public_ip = []
101 self.vm_public_id = []
109 """Get the keystone token value from Openstack ."""
110 url = 'http://' + self.keystone_hostname + \
111 ':5000/' + self.osver + '/tokens'
112 data = '{"auth": {"tenantName": "admin", "passwordCredentials":\
113 { "username": "admin", "password": "console"}}}'
114 headers = {"Accept": "application/json"}
115 response = requests.post(url, headers=headers, data=data)
116 if (response.status_code == OK):
117 json1_data = json.loads(response.content)
118 self.logger.debug(response.status_code)
119 self.logger.debug(response.content)
120 self.logger.debug(json1_data)
121 self.token_id = json1_data['access']['token']['id']
122 self.tenant_id = json1_data['access']['token']['tenant']['id']
123 return(response.status_code)
125 return(response.status_code)
127 def createNetworks(self):
128 """Creation of networks."""
130 if self.netname != '':
131 Dicdata['name'] = self.netname
132 if self.admin_state_up != '':
133 Dicdata['admin_state_up'] = self.admin_state_up
134 Dicdata = {'network': Dicdata}
135 data = json.dumps(Dicdata, indent=4)
136 url = 'http://' + self.neutron_hostname + \
137 ':9696/' + self.osver + '/networks'
138 headers = {"Accept": "application/json",
139 "X-Auth-Token": self.token_id}
140 response = requests.post(url, headers=headers, data=data)
141 if (response.status_code == CREATED):
142 self.logger.debug(response.status_code)
143 self.logger.debug(response.content)
145 json1_data = json.loads(response.content)
146 self.logger.debug(json1_data)
147 self.net_id = json1_data['network']['id']
148 return(response.status_code)
150 return(response.status_code)
152 def createSubnets(self):
153 """Creation of SubNets."""
156 Dicdata['network_id'] = self.net_id
157 if self.ip_version != '':
158 Dicdata['ip_version'] = self.ip_version
160 Dicdata['cidr'] = self.cidr
161 if self.subnetname != '':
162 Dicdata['name'] = self.subnetname
164 Dicdata = {'subnet': Dicdata}
165 data = json.dumps(Dicdata, indent=4)
166 url = 'http://' + self.neutron_hostname + \
167 ':9696/' + self.osver + '/subnets'
168 headers = {"Accept": "application/json",
169 "X-Auth-Token": self.token_id}
170 response = requests.post(url, headers=headers, data=data)
172 if (response.status_code == CREATED):
173 self.logger.debug(response.status_code)
174 self.logger.debug(response.content)
175 json1_data = json.loads(response.content)
176 self.logger.debug(json1_data)
177 self.subnetId = json1_data['subnet']['id']
178 return(response.status_code)
180 return(response.status_code)
182 def createPorts(self):
183 """Creation of Ports."""
184 for x in range(self.i, self.numTerms):
186 if self.net_id != '':
187 Dicdata['network_id'] = self.net_id
189 Dicdata['name'] = "port" + str(x)
190 if self.admin_state_up != '':
191 Dicdata['admin_state_up'] = self.admin_state_up
192 if self.security_groups != '':
193 Dicdata['security_groups'] = self.security_groups
194 # if self.port_security_enabled != '':
195 # Dicdata['port_security_enabled'] = self.port_security_enabled
197 Dicdata = {'port': Dicdata}
198 data = json.dumps(Dicdata, indent=4)
199 url = 'http://' + self.neutron_hostname + \
200 ':9696/' + self.osver + '/ports'
201 headers = {"Accept": "application/json",
202 "X-Auth-Token": self.token_id}
203 response = requests.post(url, headers=headers, data=data)
205 if (response.status_code == CREATED):
206 self.logger.debug(response.status_code)
207 self.logger.debug(response.content)
209 json1_data = json.loads(response.content)
210 self.logger.debug(json1_data)
211 self.port_num.append(json1_data['port']['id'])
212 self.port_ip.append(json1_data['port']['fixed_ips'][0]
215 return(response.status_code)
216 return(response.status_code)
219 """Creation of Instance, using firewall image."""
220 url = 'http://' + self.glance_hostname + \
221 ':9292/v2/images?name=TestSfcVm'
222 headers = {"Accept": "application/json", "Content-Type": "application/\
223 octet-stream", "X-Auth-Token": self.token_id}
224 response = requests.get(url, headers=headers)
225 if (response.status_code == OK):
226 self.logger.debug(response.status_code)
227 self.logger.debug(response.content)
228 self.logger.info("FireWall Image is available")
229 json1_data = json.loads(response.content)
230 self.logger.debug(json1_data)
231 self.image_id = json1_data['images'][0]['id']
233 return(response.status_code)
235 url = 'http://' + self.nova_hostname + \
236 ':8774/v2.1/' + self.tenant_id + '/flavors?name=m1.tiny'
237 headers = {"Accept": "application/json", "Content-Type":
238 "application/json", "X-Auth-Token": self.token_id}
239 response = requests.get(url, headers=headers)
241 if (response.status_code == OK):
242 self.logger.debug(response.status_code)
243 self.logger.debug(response.content)
244 self.logger.info("Flavor is available")
245 json1_data = json.loads(response.content)
246 self.logger.debug(json1_data)
247 self.flavorRef = json1_data['flavors'][0]['id']
249 return(response.status_code)
251 for y in range(0, 3):
254 org_nw_port.append({'port': self.port_num[y]})
255 if self.vm_name != '':
256 Dicdata['name'] = "vm" + str(y)
257 if self.imageRef != '':
258 Dicdata['imageRef'] = self.image_id
259 if self.flavorRef != '':
260 Dicdata['flavorRef'] = self.flavorRef
261 if self.max_count != '':
262 Dicdata['max_count'] = self.max_count
263 if self.min_count != '':
264 Dicdata['min_count'] = self.min_count
265 if self.org_nw_port != '':
266 Dicdata['networks'] = org_nw_port
267 Dicdata = {'server': Dicdata}
268 data = json.dumps(Dicdata, indent=4)
270 url = ('http://' + self.nova_hostname + ':8774/v2.1/' +
271 self.tenant_id + '/servers')
272 headers = {"Accept": "application/json", "Content-Type":
273 "application/json", "X-Auth-Token": self.token_id}
274 response = requests.post(url, headers=headers, data=data)
275 if (response.status_code == ACCEPTED):
276 self.logger.debug(response.status_code)
277 self.logger.debug(response.content)
278 info = "Creation of VM" + str(y) + " is successfull"
279 self.logger.debug(info)
281 json1_data = json.loads(response.content)
282 self.logger.debug(json1_data)
283 self.vm_id = json1_data['server']['id']
284 self.vm.append(json1_data['server']['id'])
286 return(response.status_code)
288 return(response.status_code)
290 def checkVmState(self):
291 """Checking the Status of the Instance."""
293 for y in range(0, 3):
295 self.nova_hostname + \
296 ':8774/v2.1/servers/detail?name=vm' + str(y)
297 headers = {"Accept": "application/json", "X-Auth-Token":
299 response = requests.get(url, headers=headers)
300 if (response.status_code == OK):
301 self.logger.debug(response.status_code)
302 self.logger.debug(response.content)
303 json1_data = json.loads(response.content)
304 self.logger.debug(json1_data)
305 self.vm_active = json1_data['servers'][0]['status']
306 if (self.vm_active == "ACTIVE"):
307 info = "VM" + str(y) + \
308 " is Active : " + self.vm_active
310 info = "VM" + str(y) + " is NOT Active : " + \
312 self.logger.debug(info)
314 return(response.status_code)
315 return(response.status_code)
318 def createPortPair(self):
319 """Creation of Port Pair."""
320 for p in range(1, 2):
322 if self.port_pair_ingress != '':
323 Dicdata['ingress'] = self.port_num[p]
324 if self.port_pair_egress != '':
326 Dicdata['egress'] = self.port_num[egress]
327 if self.port_pair_name != '':
328 Dicdata['name'] = "PP" + str(p)
330 Dicdata = {'port_pair': Dicdata}
331 data = json.dumps(Dicdata, indent=4)
333 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
335 headers = {"Accept": "application/json", "X-Auth-Token":
337 response = requests.post(url, headers=headers, data=data)
338 if (response.status_code == CREATED):
339 info = "Creation of Port Pair PP" + str(p) + \
341 self.logger.debug(info)
343 return(response.status_code)
345 return(response.status_code)
347 def getPortPair(self):
348 """Query the Portpair id value."""
349 for p in range(0, 1):
350 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
351 '/sfc/port_pairs?name=PP1'
352 headers = {"Accept": "application/json", "X-Auth-Token":
354 response = requests.get(url, headers=headers)
356 if (response.status_code == OK):
357 self.logger.debug(response.status_code)
358 self.logger.debug(response.content)
359 json1_data = json.loads(response.content)
360 self.logger.debug(json1_data)
361 self.port_pair_id.append(json1_data['port_pairs'][0]['id'])
363 return(response.status_code)
364 return(response.status_code)
366 def createPortGroup(self):
367 """Creation of PortGroup."""
368 for p in range(0, 1):
371 port_pair_list.append(self.port_pair_id[p])
372 if self.port_group_name != '':
373 Dicdata['name'] = "PG" + str(p)
374 if self.port_pair_id != '':
375 Dicdata['port_pairs'] = port_pair_list
377 Dicdata = {'port_pair_group': Dicdata}
378 data = json.dumps(Dicdata, indent=4)
379 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
380 '/sfc/port_pair_groups'
381 headers = {"Accept": "application/json", "X-Auth-Token":
383 response = requests.post(url, headers=headers, data=data)
384 if (response.status_code == CREATED):
385 info = "Creation of Port Group PG" + str(p) + \
387 self.logger.debug(info)
389 return(response.status_code)
391 return(response.status_code)
393 def getPortGroup(self):
394 """Query the PortGroup id."""
395 for p in range(0, 1):
396 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
397 '/sfc/port_pair_groups?name=PG' + str(p)
398 headers = {"Accept": "application/json", "X-Auth-Token":
400 response = requests.get(url, headers=headers)
402 if (response.status_code == OK):
403 self.logger.debug(response.status_code)
404 self.logger.debug(response.content)
405 json1_data = json.loads(response.content)
406 self.port_grp_id.append(json1_data['port_pair_groups']
409 return(response.status_code)
410 return(response.status_code)
412 def createFlowClassifier(self):
413 """Creation of Flow Classifier."""
415 if self.source_ip_prefix != '':
416 Dicdata['source_ip_prefix'] = self.source_ip_prefix
417 if self.destination_ip_prefix != '':
418 Dicdata['destination_ip_prefix'] = self.destination_ip_prefix
419 if self.logical_source_port != '':
420 Dicdata['logical_source_port'] = self.port_num[0]
421 if self.fcname != '':
422 Dicdata['name'] = "FC1"
423 if self.ethertype != '':
424 Dicdata['ethertype'] = self.ethertype
426 Dicdata = {'flow_classifier': Dicdata}
427 data = json.dumps(Dicdata, indent=4)
428 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
429 '/sfc/flow_classifiers'
430 headers = {"Accept": "application/json",
431 "X-Auth-Token": self.token_id}
432 response = requests.post(url, headers=headers, data=data)
433 if (response.status_code == CREATED):
434 json1_data = json.loads(response.content)
435 self.flow_class_if = json1_data['flow_classifier']['id']
436 self.logger.debug("Creation of Flow Classifier is successful")
437 return(response.status_code)
439 return(response.status_code)
441 def createPortChain(self):
442 """Creation of PortChain."""
445 flow_class_list.append(self.flow_class_if)
446 port_pair_groups_list = []
447 port_pair_groups_list.append(self.port_grp_id[0])
449 if flow_class_list != '':
450 Dicdata['flow_classifiers'] = flow_class_list
451 if self.pcname != '':
452 Dicdata['name'] = "PC1"
453 if port_pair_groups_list != '':
454 Dicdata['port_pair_groups'] = port_pair_groups_list
456 Dicdata = {'port_chain': Dicdata}
457 data = json.dumps(Dicdata, indent=4)
458 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
460 headers = {"Accept": "application/json",
461 "Content-Type": "application/json",
462 "X-Auth-Token": self.token_id}
463 response = requests.post(url, headers=headers, data=data)
464 if (response.status_code == CREATED):
465 self.logger.debug("Creation of PORT CHAIN is successful")
466 json1_data = json.loads(response.content)
467 self.PC_id = json1_data['port_chain']['id']
468 return(response.status_code)
470 return(response.status_code)
472 def checkFlowAdded(self):
473 """Check whether the Flows are downloaded successfully."""
475 response = requests.get('http://' + self.onos_hostname +
476 ':8181/onos/v1/flows',
477 auth=("karaf", "karaf"))
478 if (response.status_code == OK):
479 self.logger.debug("Flow is successfully Queries")
480 json1_data = json.loads(response.content)
481 self.flowadd = json1_data['flows'][0]['state']
483 if (self.flowadd == "ADDED"):
484 self.logger.info("Flow is successfully added to OVS")
485 return(response.status_code)
489 return(response.status_code)
490 ####################################################################
492 def createRouter(self):
493 """Creation of Router."""
495 if self.routername != '':
496 Dicdata['name'] = "router1"
497 if self.admin_state_up != '':
498 Dicdata['admin_state_up'] = self.admin_state_up
500 Dicdata = {'router': Dicdata}
501 data = json.dumps(Dicdata, indent=4)
502 url = 'http://' + self.neutron_hostname + ':9696/' + \
503 self.osver + '/routers.json'
504 headers = {"Accept": "application/json",
505 "X-Auth-Token": self.token_id}
506 response = requests.post(url, headers=headers, data=data)
507 if (response.status_code == CREATED):
508 self.logger.debug(response.status_code)
509 self.logger.debug(response.content)
510 self.logger.debug("Creation of Router is successfull")
511 json1_data = json.loads(response.content)
512 self.logger.debug(json1_data)
513 self.router_id = json1_data['router']['id']
514 return(response.status_code)
516 return(response.status_code)
518 def attachInterface(self):
519 """Attachment of instance ports to the Router."""
520 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
521 '/networks?name=admin_floating_net'
522 headers = {"Accept": "application/json",
523 "X-Auth-Token": self.token_id}
524 response = requests.get(url, headers=headers)
525 if (response.status_code == OK):
526 self.logger.debug(response.status_code)
527 self.logger.debug(response.content)
528 json1_data = json.loads(response.content)
529 self.logger.debug(json1_data)
530 self.net_name = json1_data['networks'][0]['name']
531 if (self.net_name == "admin_floating_net"):
532 self.pub_net_id = json1_data['networks'][0]['id']
534 return(response.status_code)
535 ############################################################
537 self.logger.info("Attachment of Instance interface to Router")
539 if self.subnetId != '':
540 Dicdata['subnet_id'] = self.subnetId
542 data = json.dumps(Dicdata, indent=4)
543 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
544 '/routers/' + self.router_id + '/add_router_interface'
545 headers = {"Accept": "application/json",
546 "X-Auth-Token": self.token_id}
547 response = requests.put(url, headers=headers, data=data)
548 if (response.status_code == OK):
549 self.logger.debug(response.status_code)
550 self.logger.debug(response.content)
551 self.logger.info("Interface attached successfull")
553 return(response.status_code)
554 ############################################################
555 self.logger.info("Attachment of Gateway to Router")
558 if self.pub_net_id != 0:
559 Dicdata1['network_id'] = self.pub_net_id
561 Dicdata1 = {'external_gateway_info': Dicdata1}
562 Dicdata1 = {'router': Dicdata1}
563 data = json.dumps(Dicdata1, indent=4)
564 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
565 '/routers/' + self.router_id
566 headers = {"Accept": "application/json",
567 "X-Auth-Token": self.token_id}
568 response = requests.put(url, headers=headers, data=data)
569 if (response.status_code == OK):
570 self.logger.debug(response.status_code)
571 self.logger.debug(response.content)
572 self.logger.info("Gateway Interface attached successfull")
573 return(response.status_code)
575 return(response.status_code)
577 def addFloatingIp(self):
578 """Attachment of Floating Ip to the Router."""
579 for ip_num in range(0, 2):
581 Dicdata['pool'] = "admin_floating_net"
583 data = json.dumps(Dicdata, indent=4)
584 url = 'http://' + self.nova_hostname + ':8774/v2.1/os-floating-ips'
585 headers = {"Accept": "application/json",
586 "X-Auth-Token": self.token_id}
587 response = requests.post(url, headers=headers, data=data)
588 if (response.status_code == OK):
589 self.logger.debug(response.status_code)
590 self.logger.debug(response.content)
591 self.logger.info("Floating ip created successfully")
592 json1_data = json.loads(response.content)
593 self.logger.debug(json1_data)
594 self.vm_public_ip.append(json1_data['floating_ip']['ip'])
595 self.vm_public_id.append(json1_data['floating_ip']['id'])
597 self.logger.error("Floating ip NOT created successfully")
600 if self.address != '':
601 Dicdata1['address'] = self.vm_public_ip[ip_num]
603 Dicdata1 = {'addFloatingIp': Dicdata1}
604 data = json.dumps(Dicdata1, indent=4)
605 url = 'http://' + self.nova_hostname + ':8774/v2.1/servers/' + \
606 self.vm[ip_num] + '/action'
607 headers = {"Accept": "application/json",
608 "X-Auth-Token": self.token_id}
609 response = requests.post(url, headers=headers, data=data)
610 if(response.status_code == ACCEPTED):
611 self.logger.debug(response.status_code)
612 self.logger.debug(response.content)
613 self.logger.info("Public Ip successfully added to VM")
615 return(response.status_code)
616 return(response.status_code)
619 """Login to the VM to check NSH packets are received."""
625 hostname = self.vm_public_ip[0]
627 password = "cubswin:)"
628 s.login(hostname, username, password)
629 s.sendline("ping -c 5 " + str(self.port_ip[2]))
630 s.prompt() # match the prompt
632 ping_re = re.search("transmitted.*received", s.before).group()
633 x = re.split('\s+', ping_re)
635 self.logger.info("Ping is Successfull")
637 self.logger.info("Ping is NOT Successfull")
641 hostname = self.vm_public_ip[1]
643 password = "cubswin:)"
644 s.login(hostname, username, password)
645 s.sendline('sudo ./firewall')
647 output_pack = s.before
649 if(output_pack.find("nshc") != -1):
650 self.logger.info("The packet has reached VM2 Instance")
653 self.logger.info("Packet not received in Instance")
656 def ping(ip, timeout=300):
659 self.logger.debug("Pinging %s. Waiting for response..." % ip)
660 response = os.system("ping -c 1 " + ip + " >/dev/null 2>&1")
662 self.logger.info("Ping " + ip + " detected!")
666 self.logger.info("Ping " + ip + " timeout reached.")
670 result0 = ping(self.vm_public_ip[0])
671 result1 = ping(self.vm_public_ip[1])
672 if result0 == 0 and result1 == 0:
675 p1 = Process(target=vm1, args=(queue1, ))
677 p2 = Process(target=vm0)
680 return (queue1.get())
682 self.logger.error("Thread didnt run")
684 """##################################################################"""
685 """ ######################## Stats Functions ################# #####"""
687 def portChainDeviceMap(self):
688 """Check the PC Device Stats in the ONOS."""
689 response = requests.get('http://' + self.onos_hostname +
690 ':8181/onos/vtn/portChainDeviceMap/' +
691 self.PC_id, auth=("karaf", "karaf"))
692 if (response.status_code == OK):
693 self.logger.info("PortChainDeviceMap is successfully Queries")
694 return(response.status_code)
696 return(response.status_code)
698 def portChainSfMap(self):
699 """Check the PC SF Map Stats in the ONOS."""
700 response = requests.get('http://' + self.onos_hostname +
701 ':8181/onos/vtn/portChainSfMap/' +
702 self.PC_id, auth=("karaf", "karaf"))
703 if (response.status_code == OK):
704 self.logger.info("portChainSfMap is successfully Queries")
705 return(response.status_code)
707 return(response.status_code)
709 """###################################################################"""
711 def deletePortChain(self):
712 """Deletion of PortChain."""
713 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
714 '/sfc/port_chains/' + self.PC_id
715 headers = {"Accept": "application/json", "Content-Type":
716 "application/json", "X-Auth-Token": self.token_id}
717 response = requests.delete(url, headers=headers)
718 if (response.status_code == OK):
719 self.logger.debug(response.status_code)
720 self.logger.debug(response.content)
721 return(response.status_code)
723 return(response.status_code)
725 def deleteFlowClassifier(self):
726 """Deletion of Flow Classifier."""
727 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
728 '/sfc/flow_classifiers/' + self.flow_class_if
729 headers = {"Accept": "application/json",
730 "X-Auth-Token": self.token_id}
731 response = requests.delete(url, headers=headers)
732 if (response.status_code == OK):
733 self.logger.debug(response.status_code)
734 self.logger.debug(response.content)
735 return(response.status_code)
737 return(response.status_code)
739 def deletePortGroup(self):
740 """Deletion of PortGroup."""
741 for p in range(0, 1):
742 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
743 '/sfc/port_pair_groups/' + self.port_grp_id[p]
744 headers = {"Accept": "application/json", "X-Auth-Token":
746 response = requests.delete(url, headers=headers)
747 if (response.status_code == NO_CONTENT):
748 self.logger.debug(response.status_code)
749 self.logger.debug(response.content)
751 return(response.status_code)
752 return(response.status_code)
754 def deletePortPair(self):
755 """Deletion of Portpair."""
756 for p in range(1, 2):
757 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
758 '/sfc/port_pairs/' + self.port_pair_id[0]
759 headers = {"Accept": "application/json",
760 "X-Auth-Token": self.token_id}
761 response = requests.delete(url, headers=headers)
762 if (response.status_code == NO_CONTENT):
763 self.logger.debug(response.status_code)
764 self.logger.debug(response.content)
766 return(response.status_code)
767 return(response.status_code)
771 self.logger.info("Deleting VMs")
772 for y in range(0, 3):
773 url = 'http://' + self.nova_hostname + \
774 ':8774/v2.1/servers/' + self.vm[y]
775 headers = {"Accept": "application/json",
776 "X-Auth-Token": self.token_id}
777 response = requests.delete(url, headers=headers)
778 if (response.status_code == NO_CONTENT):
779 self.logger.debug(response.status_code)
780 self.logger.debug(response.content)
781 self.logger.debug("VM" + str(y) + " is Deleted : ")
784 return(response.status_code)
785 self.logger.info("Deleting Ports")
786 for x in range(self.i, self.numTerms):
787 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
788 '/ports/' + self.port_num[x]
789 headers = {"Accept": "application/json", "X-Auth-Token":
791 response = requests.delete(url, headers=headers)
793 if (response.status_code == NO_CONTENT):
794 self.logger.debug(response.status_code)
795 self.logger.debug(response.content)
796 self.logger.debug("Port" + str(x) + " Deleted")
798 return(response.status_code)
799 self.logger.info("Deleting Router")
802 Dicdata['external_gateway_info'] = {}
803 Dicdata = {'router': Dicdata}
804 data = json.dumps(Dicdata, indent=4)
805 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
806 '/routers/' + self.router_id
807 headers = {"Accept": "application/json",
808 "X-Auth-Token": self.token_id}
809 response = requests.put(url, headers=headers, data=data)
810 if (response.status_code == OK):
811 self.logger.debug(response.status_code)
812 self.logger.debug(response.content)
814 if self.subnetId != '':
815 Dicdata1['subnet_id'] = self.subnetId
816 data = json.dumps(Dicdata1, indent=4)
817 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
818 '/routers/' + self.router_id + \
819 '/remove_router_interface.json'
820 headers = {"Accept": "application/json",
821 "X-Auth-Token": self.token_id}
822 response = requests.put(url, headers=headers, data=data)
823 if (response.status_code == OK):
824 url = ('http://' + self.neutron_hostname + ':9696/' +
825 self.osver + '/routers/' + self.router_id)
826 headers = {"Accept": "application/json", "X-Auth-Token":
828 response = requests.delete(url, headers=headers)
829 if (response.status_code == NO_CONTENT):
830 self.logger.debug(response.status_code)
831 self.logger.debug(response.content)
833 return(response.status_code)
835 return(response.status_code)
837 return(response.status_code)
839 self.logger.info("Deleting Network")
840 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
841 '/networks/' + self.net_id
842 headers = {"Accept": "application/json",
843 "X-Auth-Token": self.token_id}
844 response = requests.delete(url, headers=headers)
845 if (response.status_code == NO_CONTENT):
846 self.logger.debug(response.status_code)
847 self.logger.debug(response.content)
849 return(response.status_code)
851 self.logger.info("Deleting Floating ip")
852 for ip_num in range(0, 2):
853 url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
854 '/floatingips/' + self.vm_public_id[ip_num]
855 headers = {"Accept": "application/json", "X-Auth-Token":
857 response = requests.delete(url, headers=headers)
858 if (response.status_code == NO_CONTENT):
859 self.logger.debug(response.status_code)
860 self.logger.debug(response.content)
862 return(response.status_code)
863 return(response.status_code)