functest/opnfv_tests/sdn/onos/sfc/sfc_onos.py

   1 import os
   2 import re
   3 import time
   4 import json
   5 import requests
   6
   7 from multiprocessing import Process
   8 from multiprocessing import Queue
   9 from pexpect import pxssh
  10
  11 import functest.utils.functest_logger as ft_logger
  12
  13 OK = 200
  14 CREATED = 201
  15 ACCEPTED = 202
  16 NO_CONTENT = 204
  17
  18
  19 class SfcOnos:
  20     """Defines all the def function of SFC."""
  21
  22     def __init__(self):
  23         """Initialization of variables."""
  24         self.logger = ft_logger.Logger("sfc_fun").getLogger()
  25         self.osver = "v2.0"
  26         self.token_id = 0
  27         self.net_id = 0
  28         self.image_id = 0
  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
  37         self.tenant_id = 0
  38         self.subnetId = 0
  39         # #########################
  40         # SubNet variables#########
  41         self.ip_version = 4
  42         self.cidr = "20.20.20.0/24"
  43         self.subnetname = "test_nw_subnets"
  44         # ###############################
  45         # Port variable
  46         self.port = "port"
  47         self.port_num = []
  48         self.vm_id = 0
  49         self.port_ip = []
  50         self.count = 0
  51         self.i = 0
  52         self.numTerms = 3
  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"
  62
  63         self.vm_name = "vm"
  64         self.imageRef = "test"
  65         self.flavorRef = "1"
  66         self.max_count = "1"
  67         self.min_count = "1"
  68         self.org_nw_port = []
  69         self.image_id = 0
  70         self.routername = "router1"
  71         self.router_id = 0
  72         # #####################################
  73         # Port pair
  74         self.port_pair_ingress = 0
  75         self.port_pair_egress = 0
  76         self.port_pair_name = "PP"
  77         self.port_pair_id = []
  78         # ####################################
  79         # Port Group
  80         self.port_group_name = "PG"
  81         self.port_grp_id = []
  82         # ####################################
  83         # FlowClassifier
  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
  87         self.fcname = "FC"
  88         self.ethertype = "IPv4"
  89         # #####################################
  90         self.flow_class_if = 0
  91         # #####################################
  92         # Port Chain variables
  93         self.pcname = 'PC'
  94         self.PC_id = 0
  95         # #####################################
  96         # Port Chain variables
  97         self.flowadd = ''
  98         # #####################################
  99         self.ip_pool = 0
 100         self.vm_public_ip = []
 101         self.vm_public_id = []
 102         self.net_id1 = 0
 103         self.vm = []
 104         self.address = 0
 105         self.value = 0
 106         self.pub_net_id = 0
 107
 108     def getToken(self):
 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)
 124         else:
 125             return(response.status_code)
 126
 127     def createNetworks(self):
 128         """Creation of networks."""
 129         Dicdata = {}
 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)
 144
 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)
 149         else:
 150             return(response.status_code)
 151
 152     def createSubnets(self):
 153         """Creation of SubNets."""
 154         Dicdata = {}
 155         if self.net_id != 0:
 156             Dicdata['network_id'] = self.net_id
 157         if self.ip_version != '':
 158             Dicdata['ip_version'] = self.ip_version
 159         if self.cidr != '':
 160             Dicdata['cidr'] = self.cidr
 161         if self.subnetname != '':
 162             Dicdata['name'] = self.subnetname
 163
 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)
 171
 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)
 179         else:
 180             return(response.status_code)
 181
 182     def createPorts(self):
 183         """Creation of Ports."""
 184         for x in range(self.i, self.numTerms):
 185             Dicdata = {}
 186             if self.net_id != '':
 187                 Dicdata['network_id'] = self.net_id
 188             if self.port != '':
 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
 196
 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)
 204
 205             if (response.status_code == CREATED):
 206                 self.logger.debug(response.status_code)
 207                 self.logger.debug(response.content)
 208
 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]
 213                                     ['ip_address'])
 214             else:
 215                 return(response.status_code)
 216         return(response.status_code)
 217
 218     def createVm(self):
 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']
 232         else:
 233             return(response.status_code)
 234
 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)
 240
 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']
 248         else:
 249             return(response.status_code)
 250
 251         for y in range(0, 3):
 252             Dicdata = {}
 253             org_nw_port = []
 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)
 269
 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)
 280
 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'])
 285             else:
 286                 return(response.status_code)
 287
 288         return(response.status_code)
 289
 290     def checkVmState(self):
 291         """Checking the Status of the Instance."""
 292         time.sleep(10)
 293         for y in range(0, 3):
 294             url = 'http://' + \
 295                   self.nova_hostname + \
 296                 ':8774/v2.1/servers/detail?name=vm' + str(y)
 297             headers = {"Accept": "application/json",  "X-Auth-Token":
 298                        self.token_id}
 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
 309                 else:
 310                     info = "VM" + str(y) + " is NOT Active : " + \
 311                         self.vm_active
 312                 self.logger.debug(info)
 313             else:
 314                 return(response.status_code)
 315         return(response.status_code)
 316         time.sleep(10)
 317
 318     def createPortPair(self):
 319         """Creation of Port Pair."""
 320         for p in range(1, 2):
 321             Dicdata = {}
 322             if self.port_pair_ingress != '':
 323                 Dicdata['ingress'] = self.port_num[p]
 324             if self.port_pair_egress != '':
 325                 egress = p
 326                 Dicdata['egress'] = self.port_num[egress]
 327             if self.port_pair_name != '':
 328                 Dicdata['name'] = "PP" + str(p)
 329
 330             Dicdata = {'port_pair': Dicdata}
 331             data = json.dumps(Dicdata, indent=4)
 332
 333             url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 334                 '/sfc/port_pairs'
 335             headers = {"Accept": "application/json", "X-Auth-Token":
 336                        self.token_id}
 337             response = requests.post(url, headers=headers,  data=data)
 338             if (response.status_code == CREATED):
 339                 info = "Creation of Port Pair PP" + str(p) + \
 340                        " is successful"
 341                 self.logger.debug(info)
 342             else:
 343                 return(response.status_code)
 344
 345         return(response.status_code)
 346
 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":
 353                        self.token_id}
 354             response = requests.get(url, headers=headers)
 355
 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'])
 362             else:
 363                 return(response.status_code)
 364         return(response.status_code)
 365
 366     def createPortGroup(self):
 367         """Creation of PortGroup."""
 368         for p in range(0, 1):
 369             Dicdata = {}
 370             port_pair_list = []
 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
 376
 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":
 382                        self.token_id}
 383             response = requests.post(url, headers=headers,  data=data)
 384             if (response.status_code == CREATED):
 385                 info = "Creation of Port Group PG" + str(p) + \
 386                     "is successful"
 387                 self.logger.debug(info)
 388             else:
 389                 return(response.status_code)
 390
 391         return(response.status_code)
 392
 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":
 399                        self.token_id}
 400             response = requests.get(url, headers=headers)
 401
 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']
 407                                         [0]['id'])
 408             else:
 409                 return(response.status_code)
 410         return(response.status_code)
 411
 412     def createFlowClassifier(self):
 413         """Creation of Flow Classifier."""
 414         Dicdata = {}
 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
 425
 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)
 438         else:
 439             return(response.status_code)
 440
 441     def createPortChain(self):
 442         """Creation of PortChain."""
 443         Dicdata = {}
 444         flow_class_list = []
 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])
 448
 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
 455
 456         Dicdata = {'port_chain': Dicdata}
 457         data = json.dumps(Dicdata, indent=4)
 458         url = 'http://' + self.neutron_hostname + ':9696/' + self.osver + \
 459               '/sfc/port_chains'
 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)
 469         else:
 470             return(response.status_code)
 471
 472     def checkFlowAdded(self):
 473         """Check whether the Flows are downloaded successfully."""
 474         time.sleep(5)
 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']
 482
 483             if (self.flowadd == "ADDED"):
 484                 self.logger.info("Flow is successfully added to OVS")
 485                 return(response.status_code)
 486             else:
 487                 return(404)
 488         else:
 489             return(response.status_code)
 490 ####################################################################
 491
 492     def createRouter(self):
 493         """Creation of Router."""
 494         Dicdata = {}
 495         if self.routername != '':
 496             Dicdata['name'] = "router1"
 497         if self.admin_state_up != '':
 498             Dicdata['admin_state_up'] = self.admin_state_up
 499
 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)
 515         else:
 516             return(response.status_code)
 517
 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']
 533             else:
 534                 return(response.status_code)
 535         ############################################################
 536
 537         self.logger.info("Attachment of Instance interface to Router")
 538         Dicdata = {}
 539         if self.subnetId != '':
 540             Dicdata['subnet_id'] = self.subnetId
 541
 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")
 552         else:
 553             return(response.status_code)
 554         ############################################################
 555         self.logger.info("Attachment of Gateway to Router")
 556
 557         Dicdata1 = {}
 558         if self.pub_net_id != 0:
 559             Dicdata1['network_id'] = self.pub_net_id
 560
 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)
 574         else:
 575             return(response.status_code)
 576
 577     def addFloatingIp(self):
 578         """Attachment of Floating Ip to the Router."""
 579         for ip_num in range(0, 2):
 580             Dicdata = {}
 581             Dicdata['pool'] = "admin_floating_net"
 582
 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'])
 596             else:
 597                 self.logger.error("Floating ip NOT created successfully")
 598
 599             Dicdata1 = {}
 600             if self.address != '':
 601                 Dicdata1['address'] = self.vm_public_ip[ip_num]
 602
 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")
 614             else:
 615                 return(response.status_code)
 616         return(response.status_code)
 617
 618     def loginToVM(self):
 619         """Login to the VM to check NSH packets are received."""
 620         queue1 = "0"
 621
 622         def vm0():
 623
 624             s = pxssh.pxssh()
 625             hostname = self.vm_public_ip[0]
 626             username = "cirros"
 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
 631
 632             ping_re = re.search("transmitted.*received",  s.before).group()
 633             x = re.split('\s+',  ping_re)
 634             if (x[1] >= "1"):
 635                 self.logger.info("Ping is Successfull")
 636             else:
 637                 self.logger.info("Ping is NOT Successfull")
 638
 639         def vm1(queue1):
 640             s = pxssh.pxssh()
 641             hostname = self.vm_public_ip[1]
 642             username = "cirros"
 643             password = "cubswin:)"
 644             s.login(hostname,  username,  password)
 645             s.sendline('sudo ./firewall')
 646             s.prompt()
 647             output_pack = s.before
 648
 649             if(output_pack.find("nshc") != -1):
 650                 self.logger.info("The packet has reached VM2 Instance")
 651                 queue1.put("1")
 652             else:
 653                 self.logger.info("Packet not received in Instance")
 654                 queue1.put("0")
 655
 656         def ping(ip, timeout=300):
 657             while True:
 658                 time.sleep(1)
 659                 self.logger.debug("Pinging %s. Waiting for response..." % ip)
 660                 response = os.system("ping -c 1 " + ip + " >/dev/null 2>&1")
 661                 if response == 0:
 662                     self.logger.info("Ping " + ip + " detected!")
 663                     return 0
 664
 665                 elif timeout == 0:
 666                     self.logger.info("Ping " + ip + " timeout reached.")
 667                     return 1
 668                 timeout -= 1
 669
 670         result0 = ping(self.vm_public_ip[0])
 671         result1 = ping(self.vm_public_ip[1])
 672         if result0 == 0 and result1 == 0:
 673             time.sleep(300)
 674             queue1 = Queue()
 675             p1 = Process(target=vm1,  args=(queue1, ))
 676             p1.start()
 677             p2 = Process(target=vm0)
 678             p2.start()
 679             p1.join(10)
 680             return (queue1.get())
 681         else:
 682             self.logger.error("Thread didnt run")
 683
 684     """##################################################################"""
 685     """ ########################  Stats Functions ################# #####"""
 686
 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)
 695         else:
 696             return(response.status_code)
 697
 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)
 706         else:
 707             return(response.status_code)
 708
 709     """###################################################################"""
 710
 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)
 722         else:
 723             return(response.status_code)
 724
 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)
 736         else:
 737             return(response.status_code)
 738
 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":
 745                        self.token_id}
 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)
 750             else:
 751                 return(response.status_code)
 752         return(response.status_code)
 753
 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)
 765             else:
 766                 return(response.status_code)
 767         return(response.status_code)
 768
 769     def cleanup(self):
 770         """Cleanup."""
 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 : ")
 782                 time.sleep(10)
 783             else:
 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":
 790                        self.token_id}
 791             response = requests.delete(url, headers=headers)
 792
 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")
 797             else:
 798                 return(response.status_code)
 799         self.logger.info("Deleting Router")
 800
 801         Dicdata = {}
 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)
 813             Dicdata1 = {}
 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":
 827                            self.token_id}
 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)
 832                 else:
 833                     return(response.status_code)
 834             else:
 835                 return(response.status_code)
 836         else:
 837             return(response.status_code)
 838
 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)
 848         else:
 849             return(response.status_code)
 850
 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":
 856                        self.token_id}
 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)
 861             else:
 862                 return(response.status_code)
 863         return(response.status_code)