testcases/Controllers/ONOS/Sfc/Sfc_fun.py

   1 """SFC functions."""
   2 import json
   3 from multiprocessing import Process
   4 from multiprocessing import Queue
   5 import os
   6 import re
   7 import time
   8
   9 import functest.utils.functest_logger as ft_logger
  10 from pexpect import pxssh
  11 import requests
  12
  13
  14 class Sfc_fun:
  15     """Defines all the def function of SFC."""
  16
  17     def __init__(self):
  18         """Initialization of variables."""
  19         self.logger = ft_logger.Logger("sfc_fun").getLogger()
  20         self.osver = "v2.0"
  21         self.token_id = 0
  22         self.net_id = 0
  23         self.image_id = 0
  24         self.keystone_hostname = 'keystone_ip'
  25         self.neutron_hostname = 'neutron_ip'
  26         self.nova_hostname = 'nova_ip'
  27         self.glance_hostname = 'glance_ip'
  28         self.onos_hostname = 'onos_ip'
  29         # Network variables #######
  30         self.netname = "test_nw"
  31         self.admin_state_up = True
  32         self.tenant_id = 0
  33         self.subnetId = 0
  34         # #########################
  35         # SubNet variables#########
  36         self.ip_version = 4
  37         self.cidr = "20.20.20.0/24"
  38         self.subnetname = "test_nw_subnets"
  39         # ###############################
  40         # Port variable
  41         self.port = "port"
  42         self.port_num = []
  43         self.vm_id = 0
  44         self.port_ip = []
  45         self.count = 0
  46         self.i = 0
  47         self.numTerms = 3
  48         self.security_groups = []
  49         self.port_security_enabled = False
  50         # ###############################
  51         # VM creation variable
  52         self.container_format = "bare"
  53         self.disk_format = "qcow2"
  54         self.imagename = "TestSfcVm"
  55         self.createImage = "/home/root1/devstack/files/images/\
  56                             firewall_block_image.img"
  57
  58         self.vm_name = "vm"
  59         self.imageRef = "test"
  60         self.flavorRef = "1"
  61         self.max_count = "1"
  62         self.min_count = "1"
  63         self.org_nw_port = []
  64         self.image_id = 0
  65         self.routername = "router1"
  66         self.router_id = 0
  67         # #####################################
  68         # Port pair
  69         self.port_pair_ingress = 0
  70         self.port_pair_egress = 0
  71         self.port_pair_name = "PP"
  72         self.port_pair_id = []
  73         # ####################################
  74         # Port Group
  75         self.port_group_name = "PG"
  76         self.port_grp_id = []
  77         # ####################################
  78         # FlowClassifier
  79         self.source_ip_prefix = "20.20.20.0/24"
  80         self.destination_ip_prefix = "20.20.20.0/24"
  81         self.logical_source_port = 0
  82         self.fcname = "FC"
  83         self.ethertype = "IPv4"
  84         # #####################################
  85         self.flow_class_if = 0
  86         # #####################################
  87         # Port Chain variables
  88         self.pcname = 'PC'
  89         self.PC_id = 0
  90         # #####################################
  91         # Port Chain variables
  92         self.flowadd = ''
  93         # #####################################
  94         self.ip_pool = 0
  95         self.vm_public_ip = []
  96         self.vm_public_id = []
  97         self.net_id1 = 0
  98         self.vm = []
  99         self.address = 0
 100         self.value = 0
 101         self.pub_net_id = 0
 102
 103     def getToken(self):
 104         """Get the keystone token value from Openstack ."""
 105         url = 'http://' + self.keystone_hostname + \
 106             ':5000/' + self.osver + '/tokens'
 107         data = '{"auth": {"tenantName": "admin",  "passwordCredentials":\
 108                 { "username": "admin", "password": "console"}}}'
 109         headers = {"Accept": "application/json"}
 110         response = requests.post(url, headers=headers,  data=data)
 111         if (response.status_code == 200):
 112             json1_data = json.loads(response.content)
 113             self.logger.debug(response.status_code)
 114             self.logger.debug(response.content)
 115             self.logger.debug(json1_data)
 116             self.token_id = json1_data['access']['token']['id']
 117             self.tenant_id = json1_data['access']['token']['tenant']['id']
 118             return(response.status_code)
 119         else:
 120             return(response.status_code)
 121
 122     def createNetworks(self):
 123         """Creation of networks."""
 124         Dicdata = {}
 125         if self.netname != '':
 126             Dicdata['name'] = self.netname
 127         if self.admin_state_up != '':
 128             Dicdata['admin_state_up'] = self.admin_state_up
 129         Dicdata = {'network': Dicdata}
 130         data = json.dumps(Dicdata,  indent=4)
 131         url = 'http://' + self.neutron_hostname + \
 132             ':9696/' + self.osver + '/networks'
 133         headers = {"Accept": "application/json",
 134                    "X-Auth-Token": self.token_id}
 135         response = requests.post(url, headers=headers,  data=data)
 136         if (response.status_code == 201):
 137             self.logger.debug(response.status_code)
 138             self.logger.debug(response.content)
 139
 140             json1_data = json.loads(response.content)
 141             self.logger.debug(json1_data)
 142             self.net_id = json1_data['network']['id']
 143             return(response.status_code)
 144         else:
 145             return(response.status_code)
 146
 147     def createSubnets(self):
 148         """Creation of SubNets."""
 149         Dicdata = {}
 150         if self.net_id != 0:
 151             Dicdata['network_id'] = self.net_id
 152         if self.ip_version != '':
 153             Dicdata['ip_version'] = self.ip_version
 154         if self.cidr != '':
 155             Dicdata['cidr'] = self.cidr
 156         if self.subnetname != '':
 157             Dicdata['name'] = self.subnetname
 158
 159         Dicdata = {'subnet': Dicdata}
 160         data = json.dumps(Dicdata, indent=4)
 161         url = 'http://' + self.neutron_hostname + \
 162             ':9696/' + self.osver + '/subnets'
 163         headers = {"Accept": "application/json",
 164                    "X-Auth-Token": self.token_id}
 165         response = requests.post(url, headers=headers,  data=data)
 166
 167         if (response.status_code == 201):
 168             self.logger.debug(response.status_code)
 169             self.logger.debug(response.content)
 170             json1_data = json.loads(response.content)
 171             self.logger.debug(json1_data)
 172             self.subnetId = json1_data['subnet']['id']
 173             return(response.status_code)
 174         else:
 175             return(response.status_code)
 176
 177     def createPorts(self):
 178         """Creation of Ports."""
 179         for x in range(self.i, self.numTerms):
 180             Dicdata = {}
 181             if self.net_id != '':
 182                 Dicdata['network_id'] = self.net_id
 183             if self.port != '':
 184                 Dicdata['name'] = "port" + str(x)
 185             if self.admin_state_up != '':
 186                 Dicdata['admin_state_up'] = self.admin_state_up
 187             if self.security_groups != '':
 188                 Dicdata['security_groups'] = self.security_groups
 189             # if self.port_security_enabled != '':
 190             #    Dicdata['port_security_enabled'] = self.port_security_enabled
 191
 192             Dicdata = {'port': Dicdata}
 193             data = json.dumps(Dicdata, indent=4)
 194             url = 'http://' + self.neutron_hostname + \
 195                 ':9696/' + self.osver + '/ports'
 196             headers = {"Accept": "application/json",
 197                        "X-Auth-Token": self.token_id}
 198             response = requests.post(url, headers=headers,  data=data)
 199
 200             if (response.status_code == 201):
 201                 self.logger.debug(response.status_code)
 202                 self.logger.debug(response.content)
 203
 204                 json1_data = json.loads(response.content)
 205                 self.logger.debug(json1_data)
 206                 self.port_num.append(json1_data['port']['id'])
 207                 self.port_ip.append(json1_data['port']['fixed_ips'][0]
 208                                     ['ip_address'])
 209             else:
 210                 return(response.status_code)
 211         return(response.status_code)
 212
 213     def createVm(self):
 214         """Creation of Instance, using  firewall image."""
 215         url = 'http://' + self.glance_hostname + \
 216             ':9292/v2/images?name=TestSfcVm'
 217         headers = {"Accept": "application/json", "Content-Type": "application/\
 218                     octet-stream",  "X-Auth-Token": self.token_id}
 219         response = requests.get(url, headers=headers)
 220         if (response.status_code == 200):
 221             self.logger.debug(response.status_code)
 222             self.logger.debug(response.content)
 223             self.logger.info("\tFireWall Image is available")
 224             json1_data = json.loads(response.content)
 225             self.logger.debug(json1_data)
 226             self.image_id = json1_data['images'][0]['id']
 227         else:
 228             return(response.status_code)
 229
 230         url = 'http://' + self.nova_hostname + \
 231             ':8774/v2.1/' + self.tenant_id + '/flavors?name=m1.tiny'
 232         headers = {"Accept": "application/json", "Content-Type":
 233                    "application/json", "X-Auth-Token": self.token_id}
 234         response = requests.get(url, headers=headers)
 235
 236         if (response.status_code == 200):
 237             self.logger.debug(response.status_code)
 238             self.logger.debug(response.content)
 239             self.logger.info("\tFlavor is available")
 240             json1_data = json.loads(response.content)
 241             self.logger.debug(json1_data)
 242             self.flavorRef = json1_data['flavors'][0]['id']
 243         else:
 244             return(response.status_code)
 245
 246         for y in range(0, 3):
 247             Dicdata = {}
 248             org_nw_port = []
 249             org_nw_port.append({'port': self.port_num[y]})
 250             if self.vm_name != '':
 251                 Dicdata['name'] = "vm" + str(y)
 252             if self.imageRef != '':
 253                 Dicdata['imageRef'] = self.image_id
 254             if self.flavorRef != '':
 255                 Dicdata['flavorRef'] = self.flavorRef
 256             if self.max_count != '':
 257                 Dicdata['max_count'] = self.max_count
 258             if self.min_count != '':
 259                 Dicdata['min_count'] = self.min_count
 260             if self.org_nw_port != '':
 261                 Dicdata['networks'] = org_nw_port
 262             Dicdata = {'server': Dicdata}
 263             data = json.dumps(Dicdata, indent=4)
 264
 265             url = ('http://' + self.nova_hostname + ':8774/v2.1/' +
 266                    self.tenant_id + '/servers')
 267             headers = {"Accept": "application/json", "Content-Type":
 268                        "application/json", "X-Auth-Token": self.token_id}
 269             response = requests.post(url, headers=headers,  data=data)
 270             if (response.status_code == 202):
 271                 self.logger.debug(response.status_code)
 272                 self.logger.debug(response.content)
 273                 self.logger.info("\tCreation of VM is successfull")
 274
 275                 json1_data = json.loads(response.content)
 276                 self.logger.debug(json1_data)
 277                 self.vm_id = json1_data['server']['id']
 278                 self.vm.append(json1_data['server']['id'])
 279             else:
 280                 return(response.status_code)
 281
 282         return(response.status_code)
 283
 284     def checkVmState(self):
 285         """Checking the Status of the Instance."""
 286         time.sleep(10)
 287         for y in range(0, 3):
 288             url = 'http://' + \
 289                   self.nova_hostname + \
 290                 ':8774/v2.1/servers/detail?name=vm' + str(y)
 291             headers = {"Accept": "application/json",  "X-Auth-Token":
 292                        self.token_id}
 293             response = requests.get(url, headers=headers)
 294             if (response.status_code == 200):
 295                 self.logger.debug(response.status_code)
 296                 self.logger.debug(response.content)
 297                 json1_data = json.loads(response.content)
 298                 self.logger.debug(json1_data)
 299                 self.vm_active = json1_data['servers'][0]['status']
 300                 if (self.vm_active == "ACTIVE"):
 301                     print ("\t\t\t\t\t\tVM" + str(y) + " is Active : " +
 302                            self.vm_active)
 303                 else:
 304                     print ("\t\t\t\t\t\tVM" + str(y) + " is NOT Active : " +
 305                            self.vm_active)
 306             else:
 307                 return(response.status_code)
 308         return(response.status_code)
 309         time.sleep(10)
 310
 311     def createPortPair(self):
 312         """Creation of Port Pair."""
 313         for p in range(1, 2):
 314             Dicdata = {}
 315             if self.port_pair_ingress != '':
 316                 Dicdata['ingress'] = self.port_num[p]
 317             if self.port_pair_egress != '':
 318                 egress = p
 319                 Dicdata['egress'] = self.port_num[egress]
 320             if self.port_pair_name != '':
 321                 Dicdata['name'] = "PP" + str(p)
 322
 323             Dicdata = {'port_pair': Dicdata}
 324             data = json.dumps(Dicdata, indent=4)
 325
 326             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 327                 '/sfc/port_pairs'
 328             headers = {"Accept": "application/json", "X-Auth-Token":
 329                        self.token_id}
 330             response = requests.post(url, headers=headers,  data=data)
 331             if (response.status_code == 201):
 332                 print ("\t\t\t\tCreation of Port Pair PP" + str(p) +
 333                        " is successful")
 334             else:
 335                 return(response.status_code)
 336
 337         return(response.status_code)
 338
 339     def getPortPair(self):
 340         """Query the Portpair id value."""
 341         for p in range(0, 1):
 342             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 343                   '/sfc/port_pairs?name=PP1'
 344             headers = {"Accept": "application/json", "X-Auth-Token":
 345                        self.token_id}
 346             response = requests.get(url, headers=headers)
 347
 348             if (response.status_code == 200):
 349                 self.logger.debug(response.status_code)
 350                 self.logger.debug(response.content)
 351                 json1_data = json.loads(response.content)
 352                 self.logger.debug(json1_data)
 353                 self.port_pair_id.append(json1_data['port_pairs'][0]['id'])
 354             else:
 355                 return(response.status_code)
 356         return(response.status_code)
 357
 358     def createPortGroup(self):
 359         """Creation of PortGroup."""
 360         for p in range(0, 1):
 361             Dicdata = {}
 362             port_pair_list = []
 363             port_pair_list.append(self.port_pair_id[p])
 364             if self.port_group_name != '':
 365                 Dicdata['name'] = "PG" + str(p)
 366             if self.port_pair_id != '':
 367                 Dicdata['port_pairs'] = port_pair_list
 368
 369             Dicdata = {'port_pair_group': Dicdata}
 370             data = json.dumps(Dicdata, indent=4)
 371             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 372                   '/sfc/port_pair_groups'
 373             headers = {"Accept": "application/json", "X-Auth-Token":
 374                        self.token_id}
 375             response = requests.post(url, headers=headers,  data=data)
 376             if (response.status_code == 201):
 377                 print ("\t\t\t\tCreation of Port Group PG" + str(p) +
 378                        "is successful")
 379             else:
 380                 return(response.status_code)
 381
 382         return(response.status_code)
 383
 384     def getPortGroup(self):
 385         """Query the PortGroup id."""
 386         for p in range(0, 1):
 387             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 388                   '/sfc/port_pair_groups?name=PG' + str(p)
 389             headers = {"Accept": "application/json", "X-Auth-Token":
 390                        self.token_id}
 391             response = requests.get(url, headers=headers)
 392
 393             if (response.status_code == 200):
 394                 self.logger.debug(response.status_code)
 395                 self.logger.debug(response.content)
 396                 json1_data = json.loads(response.content)
 397                 self.port_grp_id.append(json1_data['port_pair_groups']
 398                                         [0]['id'])
 399             else:
 400                 return(response.status_code)
 401         return(response.status_code)
 402
 403     def createFlowClassifier(self):
 404         """Creation of Flow Classifier."""
 405         Dicdata = {}
 406         if self.source_ip_prefix != '':
 407             Dicdata['source_ip_prefix'] = self.source_ip_prefix
 408         if self.destination_ip_prefix != '':
 409             Dicdata['destination_ip_prefix'] = self.destination_ip_prefix
 410         if self.logical_source_port != '':
 411             Dicdata['logical_source_port'] = self.port_num[0]
 412         if self.fcname != '':
 413             Dicdata['name'] = "FC1"
 414         if self.ethertype != '':
 415             Dicdata['ethertype'] = self.ethertype
 416
 417         Dicdata = {'flow_classifier': Dicdata}
 418         data = json.dumps(Dicdata, indent=4)
 419         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 420               '/sfc/flow_classifiers'
 421         headers = {"Accept": "application/json",
 422                    "X-Auth-Token": self.token_id}
 423         response = requests.post(url, headers=headers,  data=data)
 424         if (response.status_code == 201):
 425             json1_data = json.loads(response.content)
 426             self.flow_class_if = json1_data['flow_classifier']['id']
 427             self.logger.info("\tCreation of Flow Classifier is successful")
 428             return(response.status_code)
 429         else:
 430             return(response.status_code)
 431
 432     def createPortChain(self):
 433         """Creation of PortChain."""
 434         Dicdata = {}
 435         flow_class_list = []
 436         flow_class_list.append(self.flow_class_if)
 437         port_pair_groups_list = []
 438         port_pair_groups_list.append(self.port_grp_id[0])
 439
 440         if flow_class_list != '':
 441             Dicdata['flow_classifiers'] = flow_class_list
 442         if self.pcname != '':
 443             Dicdata['name'] = "PC1"
 444         if port_pair_groups_list != '':
 445             Dicdata['port_pair_groups'] = port_pair_groups_list
 446
 447         Dicdata = {'port_chain': Dicdata}
 448         data = json.dumps(Dicdata, indent=4)
 449         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 450               '/sfc/port_chains'
 451         headers = {"Accept": "application/json",
 452                    "Content-Type": "application/json",
 453                    "X-Auth-Token": self.token_id}
 454         response = requests.post(url, headers=headers,  data=data)
 455         if (response.status_code == 201):
 456             self.logger.info("\tCreation of PORT CHAIN is successful")
 457             json1_data = json.loads(response.content)
 458             self.PC_id = json1_data['port_chain']['id']
 459             return(response.status_code)
 460         else:
 461             return(response.status_code)
 462
 463     def checkFlowAdded(self):
 464         """Check whether the Flows are downloaded successfully."""
 465         time.sleep(5)
 466         response = requests.get('http://' + self.onos_hostname +
 467                                 ':8181/onos/v1/flows',
 468                                 auth=("karaf",  "karaf"))
 469         if (response.status_code == 200):
 470             self.logger.info("\tFlow is successfully Queries")
 471             json1_data = json.loads(response.content)
 472             self.flowadd = json1_data['flows'][0]['state']
 473
 474             if (self.flowadd == "ADDED"):
 475                 self.logger.info("\tFlow is successfully added to OVS")
 476                 return(response.status_code)
 477             else:
 478                 return(404)
 479         else:
 480             return(response.status_code)
 481 ####################################################################
 482
 483     def createRouter(self):
 484         """Creation of Router."""
 485         Dicdata = {}
 486         if self.routername != '':
 487             Dicdata['name'] = "router1"
 488         if self.admin_state_up != '':
 489             Dicdata['admin_state_up'] = self.admin_state_up
 490
 491         Dicdata = {'router': Dicdata}
 492         data = json.dumps(Dicdata, indent=4)
 493         url = 'http://' + self.neutron_hostname + ':9696/' + \
 494             self.osver + '/routers.json'
 495         headers = {"Accept": "application/json",
 496                    "X-Auth-Token": self.token_id}
 497         response = requests.post(url, headers=headers,  data=data)
 498         if (response.status_code == 201):
 499             self.logger.debug(response.status_code)
 500             self.logger.debug(response.content)
 501             self.logger.info("\tCreation of Router is successfull")
 502             json1_data = json.loads(response.content)
 503             self.logger.debug(json1_data)
 504             self.router_id = json1_data['router']['id']
 505             return(response.status_code)
 506         else:
 507             return(response.status_code)
 508
 509     def attachInterface(self):
 510         """Attachment of instance ports to the Router."""
 511         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 512               '/networks?name=admin_floating_net'
 513         headers = {"Accept": "application/json",
 514                    "X-Auth-Token": self.token_id}
 515         response = requests.get(url, headers=headers)
 516         if (response.status_code == 200):
 517             self.logger.debug(response.status_code)
 518             self.logger.debug(response.content)
 519             json1_data = json.loads(response.content)
 520             self.logger.debug(json1_data)
 521             self.net_name = json1_data['networks'][0]['name']
 522             if (self.net_name == "admin_floating_net"):
 523                 self.pub_net_id = json1_data['networks'][0]['id']
 524             else:
 525                 return(response.status_code)
 526         ############################################################
 527
 528         self.logger.info("\tAttachment of Instance interface to Router")
 529         Dicdata = {}
 530         if self.subnetId != '':
 531             Dicdata['subnet_id'] = self.subnetId
 532
 533         data = json.dumps(Dicdata, indent=4)
 534         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 535               '/routers/' + self.router_id + '/add_router_interface'
 536         headers = {"Accept": "application/json",
 537                    "X-Auth-Token": self.token_id}
 538         response = requests.put(url, headers=headers,  data=data)
 539         if (response.status_code == 200):
 540             self.logger.debug(response.status_code)
 541             self.logger.debug(response.content)
 542             self.logger.info("\tInterface attached successfull")
 543         else:
 544             return(response.status_code)
 545         ############################################################
 546         self.logger.info("\tAttachment of Gateway to Router")
 547
 548         Dicdata1 = {}
 549         if self.pub_net_id != 0:
 550             Dicdata1['network_id'] = self.pub_net_id
 551
 552         Dicdata1 = {'external_gateway_info': Dicdata1}
 553         Dicdata1 = {'router': Dicdata1}
 554         data = json.dumps(Dicdata1, indent=4)
 555         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 556               '/routers/' + self.router_id
 557         headers = {"Accept": "application/json",
 558                    "X-Auth-Token": self.token_id}
 559         response = requests.put(url, headers=headers,  data=data)
 560         if (response.status_code == 200):
 561             self.logger.debug(response.status_code)
 562             self.logger.debug(response.content)
 563             self.logger.info("\tGateway Interface attached successfull")
 564             return(response.status_code)
 565         else:
 566             return(response.status_code)
 567
 568     def addFloatingIp(self):
 569         """Attachment of Floating Ip to the Router."""
 570         for ip_num in range(0, 2):
 571             Dicdata = {}
 572             Dicdata['pool'] = "admin_floating_net"
 573
 574             data = json.dumps(Dicdata, indent=4)
 575             url = 'http://' + self.nova_hostname + ':8774/v2.1/os-floating-ips'
 576             headers = {"Accept": "application/json",
 577                        "X-Auth-Token": self.token_id}
 578             response = requests.post(url, headers=headers,  data=data)
 579             if (response.status_code == 200):
 580                 self.logger.debug(response.status_code)
 581                 self.logger.debug(response.content)
 582                 self.logger.info("\tFloating ip created successfully")
 583                 json1_data = json.loads(response.content)
 584                 self.logger.debug(json1_data)
 585                 self.vm_public_ip.append(json1_data['floating_ip']['ip'])
 586                 self.vm_public_id.append(json1_data['floating_ip']['id'])
 587             else:
 588                 self.logger.error("\tFloating ip NOT created successfully")
 589
 590             Dicdata1 = {}
 591             if self.address != '':
 592                 Dicdata1['address'] = self.vm_public_ip[ip_num]
 593
 594             Dicdata1 = {'addFloatingIp': Dicdata1}
 595             data = json.dumps(Dicdata1, indent=4)
 596             url = 'http://' + self.nova_hostname + ':8774/v2.1/servers/' + \
 597                   self.vm[ip_num] + '/action'
 598             headers = {"Accept": "application/json",
 599                        "X-Auth-Token": self.token_id}
 600             response = requests.post(url, headers=headers,  data=data)
 601             if(response.status_code == 202):
 602                 self.logger.debug(response.status_code)
 603                 self.logger.debug(response.content)
 604                 self.logger.info("\tPublic Ip successfully added to VM")
 605             else:
 606                 return(response.status_code)
 607         return(response.status_code)
 608
 609     def loginToVM(self):
 610         """Login to the VM to check NSH packets are received."""
 611         queue1 = "0"
 612
 613         def vm0():
 614
 615             s = pxssh.pxssh()
 616             hostname = self.vm_public_ip[0]
 617             username = "cirros"
 618             password = "cubswin:)"
 619             s.login(hostname,  username,  password)
 620             s.sendline("ping -c 5 " + str(self.port_ip[2]))
 621             s.prompt()             # match the prompt
 622
 623             ping_re = re.search("transmitted.*received",  s.before).group()
 624             x = re.split('\s+',  ping_re)
 625             if (x[1] >= "1"):
 626                 self.logger.info("\tPing is Successfull")
 627             else:
 628                 self.logger.info("\tPing is NOT Successfull")
 629
 630         def vm1(queue1):
 631             s = pxssh.pxssh()
 632             hostname = self.vm_public_ip[1]
 633             username = "cirros"
 634             password = "cubswin:)"
 635             s.login(hostname,  username,  password)
 636             s.sendline('sudo ./firewall')
 637             s.prompt()
 638             output_pack = s.before
 639
 640             if(output_pack.find("nshc") != -1):
 641                 self.logger.info("\tThe packet has reached VM2 Instance")
 642                 queue1.put("1")
 643             else:
 644                 self.logger.info("\tPacket not received in Instance")
 645                 queue1.put("0")
 646
 647         def ping(ip, timeout=300):
 648             while True:
 649                 time.sleep(1)
 650                 self.logger.debug("Pinging %s. Waiting for response..." % ip)
 651                 response = os.system("ping -c 1 " + ip + " >/dev/null 2>&1")
 652                 if response == 0:
 653                     self.logger.info("Ping " + ip + " detected!")
 654                     return 0
 655
 656                 elif timeout == 0:
 657                     self.logger.info("Ping " + ip + " timeout reached.")
 658                     return 1
 659                 timeout -= 1
 660
 661         result0 = ping(self.vm_public_ip[0])
 662         result1 = ping(self.vm_public_ip[1])
 663         if result0 == 0 and result1 == 0:
 664             time.sleep(300)
 665             queue1 = Queue()
 666             p1 = Process(target=vm1,  args=(queue1, ))
 667             p1.start()
 668             p2 = Process(target=vm0)
 669             p2.start()
 670             p1.join(10)
 671             return (queue1.get())
 672         else:
 673             print("Thread didnt run")
 674
 675     """##################################################################"""
 676     """ ########################  Stats Functions ################# #####"""
 677
 678     def portChainDeviceMap(self):
 679         """Check the PC Device Stats in the ONOS."""
 680         response = requests.get('http://' + self.onos_hostname +
 681                                 ':8181/onos/vtn/portChainDeviceMap/' +
 682                                 self.PC_id, auth=("karaf", "karaf"))
 683         if (response.status_code == 200):
 684             self.logger.info("\tPortChainDeviceMap is successfully Queries")
 685             return(response.status_code)
 686         else:
 687             return(response.status_code)
 688
 689     def portChainSfMap(self):
 690         """Check the PC SF Map Stats in the ONOS."""
 691         response = requests.get('http://' + self.onos_hostname +
 692                                 ':8181/onos/vtn/portChainSfMap/' +
 693                                 self.PC_id, auth=("karaf",  "karaf"))
 694         if (response.status_code == 200):
 695             self.logger.info("\tportChainSfMap is successfully Queries")
 696             return(response.status_code)
 697         else:
 698             return(response.status_code)
 699
 700     """###################################################################"""
 701
 702     def deletePortChain(self):
 703         """Deletion of PortChain."""
 704         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 705               '/sfc/port_chains/' + self.PC_id
 706         headers = {"Accept": "application/json", "Content-Type":
 707                    "application/json", "X-Auth-Token": self.token_id}
 708         response = requests.delete(url, headers=headers)
 709         if (response.status_code == 200):
 710             self.logger.debug(response.status_code)
 711             self.logger.debug(response.content)
 712             return(response.status_code)
 713         else:
 714             return(response.status_code)
 715
 716     def deleteFlowClassifier(self):
 717         """Deletion of Flow Classifier."""
 718         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 719               '/sfc/flow_classifiers/' + self.flow_class_if
 720         headers = {"Accept": "application/json",
 721                    "X-Auth-Token": self.token_id}
 722         response = requests.delete(url, headers=headers)
 723         if (response.status_code == 200):
 724             self.logger.debug(response.status_code)
 725             self.logger.debug(response.content)
 726             return(response.status_code)
 727         else:
 728             return(response.status_code)
 729
 730     def deletePortGroup(self):
 731         """Deletion of PortGroup."""
 732         for p in range(0, 1):
 733             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 734                   '/sfc/port_pair_groups/' + self.port_grp_id[p]
 735             headers = {"Accept": "application/json", "X-Auth-Token":
 736                        self.token_id}
 737             response = requests.delete(url, headers=headers)
 738             if (response.status_code == 204):
 739                 self.logger.debug(response.status_code)
 740                 self.logger.debug(response.content)
 741                 print ("\n\t\tPort " + self.port_grp_id[p] + "Deleted")
 742             else:
 743                 return(response.status_code)
 744         return(response.status_code)
 745
 746     def deletePortPair(self):
 747         """Deletion of Portpair."""
 748         for p in range(1,  2):
 749             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 750                   '/sfc/port_pairs/' + self.port_pair_id[0]
 751             headers = {"Accept": "application/json",
 752                        "X-Auth-Token": self.token_id}
 753             response = requests.delete(url, headers=headers)
 754             if (response.status_code == 204):
 755                 self.logger.debug(response.status_code)
 756                 self.logger.debug(response.content)
 757             else:
 758                 return(response.status_code)
 759         return(response.status_code)
 760
 761     def cleanup(self):
 762         """Cleanup."""
 763         print ("\n\t\tDeleting the VMs")
 764         for y in range(0, 3):
 765             url = 'http://' + self.nova_hostname + \
 766                 ':8774/v2.1/servers/' + self.vm[y]
 767             headers = {"Accept": "application/json",
 768                        "X-Auth-Token": self.token_id}
 769             response = requests.delete(url, headers=headers)
 770             if (response.status_code == 204):
 771                 self.logger.debug(response.status_code)
 772                 self.logger.debug(response.content)
 773                 print ("\n\t\tVM" + str(y) + " is Deleted : ")
 774                 time.sleep(10)
 775             else:
 776                 return(response.status_code)
 777         print ("\n\t\tDeletion of Ports")
 778         for x in range(self.i, self.numTerms):
 779             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 780                   '/ports/' + self.port_num[x]
 781             headers = {"Accept": "application/json", "X-Auth-Token":
 782                        self.token_id}
 783             response = requests.delete(url, headers=headers)
 784
 785             if (response.status_code == 204):
 786                 self.logger.debug(response.status_code)
 787                 self.logger.debug(response.content)
 788                 print ("\n\t\tPort" + str(x) + "  Deleted")
 789             else:
 790                 return(response.status_code)
 791         print ("\n\t\tDeleting Router")
 792
 793         Dicdata = {}
 794         Dicdata['external_gateway_info'] = {}
 795         Dicdata = {'router': Dicdata}
 796         data = json.dumps(Dicdata, indent=4)
 797         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 798               '/routers/' + self.router_id
 799         headers = {"Accept": "application/json",
 800                    "X-Auth-Token": self.token_id}
 801         response = requests.put(url, headers=headers,  data=data)
 802         if (response.status_code == 200):
 803             self.logger.debug(response.status_code)
 804             self.logger.debug(response.content)
 805             Dicdata1 = {}
 806             if self.subnetId != '':
 807                 Dicdata1['subnet_id'] = self.subnetId
 808             data = json.dumps(Dicdata1, indent=4)
 809             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 810                   '/routers/' + self.router_id + \
 811                   '/remove_router_interface.json'
 812             headers = {"Accept": "application/json",
 813                        "X-Auth-Token": self.token_id}
 814             response = requests.put(url, headers=headers,  data=data)
 815             if (response.status_code == 200):
 816                 url = ('http://' + self.neutron_hostname + ':9696/' +
 817                        self.osver + '/routers/' + self.router_id)
 818                 headers = {"Accept": "application/json",  "X-Auth-Token":
 819                            self.token_id}
 820                 response = requests.delete(url, headers=headers)
 821                 if (response.status_code == 204):
 822                     self.logger.debug(response.status_code)
 823                     self.logger.debug(response.content)
 824                     print ("\n\t\tDeletion of Router is successfull")
 825                 else:
 826                     return(response.status_code)
 827             else:
 828                 return(response.status_code)
 829         else:
 830             return(response.status_code)
 831
 832         print ("\n\t\tDeletion of Network")
 833         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 834               '/networks/' + self.net_id
 835         headers = {"Accept": "application/json",
 836                    "X-Auth-Token": self.token_id}
 837         response = requests.delete(url, headers=headers)
 838         if (response.status_code == 204):
 839             self.logger.debug(response.status_code)
 840             self.logger.debug(response.content)
 841             print ("\n\t\tNetwork deleted Successfully")
 842         else:
 843             return(response.status_code)
 844
 845         print ("\n\t\tDeletion of Floating ip")
 846         for ip_num in range(0, 2):
 847             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 848                   '/floatingips/' + self.vm_public_id[ip_num]
 849             headers = {"Accept": "application/json", "X-Auth-Token":
 850                        self.token_id}
 851             response = requests.delete(url, headers=headers)
 852             if (response.status_code == 204):
 853                 self.logger.debug(response.status_code)
 854                 self.logger.debug(response.content)
 855             else:
 856                 return(response.status_code)
 857         return(response.status_code)