Matteo Scandolo | 48d3d2d | 2017-08-08 13:05:27 -0700 | [diff] [blame] | 1 | |
| 2 | # Copyright 2017-present Open Networking Foundation |
| 3 | # |
| 4 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | # you may not use this file except in compliance with the License. |
| 6 | # You may obtain a copy of the License at |
| 7 | # |
| 8 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | # |
| 10 | # Unless required by applicable law or agreed to in writing, software |
| 11 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | # See the License for the specific language governing permissions and |
| 14 | # limitations under the License. |
| 15 | |
| 16 | |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 17 | import os |
| 18 | import sys |
| 19 | import time |
| 20 | from nose.tools import * |
| 21 | from CordTestUtils import log_test as log |
| 22 | from OnosCtrl import OnosCtrl |
| 23 | |
| 24 | class XosUtils(object): |
| 25 | |
A R Karthick | 705a5bf | 2017-10-27 11:17:04 -0700 | [diff] [blame] | 26 | head_node = os.getenv('HEAD_NODE', 'head1') |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 27 | HEAD_NODE = head_node + '.cord.lab' if len(head_node.split('.')) == 1 else head_node |
| 28 | CONTROLLER_PORT = '9000' |
| 29 | our_path = os.path.dirname(os.path.realpath(__file__)) |
| 30 | cord_api_path = os.path.join(our_path, '..', 'cord-api') |
| 31 | framework_path = os.path.join(cord_api_path, 'Framework') |
| 32 | utils_path = os.path.join(framework_path, 'utils') |
| 33 | sys.path.append(utils_path) |
| 34 | sys.path.append(framework_path) |
| 35 | |
| 36 | @classmethod |
| 37 | def getCredentials(cls): |
| 38 | onos_cfg = OnosCtrl.get_config() |
| 39 | if onos_cfg is None: |
| 40 | return None |
| 41 | if 'apps' in onos_cfg and \ |
| 42 | 'org.opencord.vtn' in onos_cfg['apps'] and \ |
| 43 | 'cordvtn' in onos_cfg['apps']['org.opencord.vtn'] and \ |
| 44 | 'xos' in onos_cfg['apps']['org.opencord.vtn']['cordvtn']: |
| 45 | xos_cfg = onos_cfg['apps']['org.opencord.vtn']['cordvtn']['xos'] |
| 46 | endpoint = xos_cfg['endpoint'] |
| 47 | user = xos_cfg['user'] |
| 48 | password = xos_cfg['password'] |
| 49 | xos_endpoints = endpoint.split(':') |
| 50 | xos_host = xos_endpoints[1][len('//'):] |
| 51 | xos_port = xos_endpoints[2][:-1] |
| 52 | #log.info('xos_host: %s, port: %s, user: %s, password: %s' %(xos_host, xos_port, user, password)) |
| 53 | return dict(host = xos_host, port = xos_port, user = user, password = password) |
| 54 | |
| 55 | return None |
| 56 | |
| 57 | @classmethod |
| 58 | def getRestApi(cls): |
| 59 | try: |
| 60 | from restApi import restApi |
| 61 | restApiXos = restApi() |
| 62 | xos_credentials = cls.getCredentials() |
| 63 | if xos_credentials is None: |
| 64 | restApiXos.controllerIP = cls.HEAD_NODE |
| 65 | restApiXos.controllerPort = cls.CONTROLLER_PORT |
| 66 | else: |
| 67 | restApiXos.controllerIP = xos_credentials['host'] |
| 68 | restApiXos.controllerPort = xos_credentials['port'] |
| 69 | restApiXos.user = xos_credentials['user'] |
| 70 | restApiXos.password = xos_credentials['password'] |
| 71 | |
| 72 | return restApiXos |
| 73 | except: |
| 74 | return None |
| 75 | |
| 76 | def __init__(self): |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 77 | from utils import utils |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 78 | self.restApi = self.getRestApi() |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 79 | self.utils = utils() |
| 80 | |
| 81 | def getSubscriberId(self, subscriberList, account_num): |
| 82 | subscriberId = 0 |
| 83 | subscriberInfo = None |
| 84 | for subscriber in subscriberList: |
| 85 | if str(subscriber['service_specific_id']) == str(account_num): |
| 86 | subscriberId = self.utils.getFieldValueFromDict(subscriber, 'id') |
| 87 | subscriberInfo = subscriber |
| 88 | break |
| 89 | return subscriberInfo, subscriberId |
| 90 | |
| 91 | def getVoltId(self, result, subInfo): |
| 92 | subscribed_link_ids_list = self.utils.getFieldValueFromDict(subInfo, |
| 93 | 'subscribed_link_ids') |
| 94 | assert_not_equal( len(subscribed_link_ids_list), 0) |
| 95 | subscribed_link_ids = subscribed_link_ids_list[0] |
| 96 | service_link = self.restApi.ApiChameleonGet('CH_CORE_SERVICELINK', |
| 97 | subscribed_link_ids) |
| 98 | assert_not_equal(service_link, None) |
| 99 | provider_service_instance_id = service_link.get('provider_service_instance_id', |
| 100 | None) |
| 101 | assert_not_equal(provider_service_instance_id, None) |
| 102 | return provider_service_instance_id |
| 103 | |
| 104 | def getProviderInstance(self, info): |
| 105 | provided_link_ids_list = self.utils.getFieldValueFromDict(info, |
| 106 | 'provided_link_ids') |
| 107 | assert_not_equal(provided_link_ids_list, None) |
| 108 | assert_not_equal(len(provided_link_ids_list), 0) |
| 109 | provided_link_ids = provided_link_ids_list[0] |
| 110 | service_link = self.restApi.ApiChameleonGet('CH_CORE_SERVICELINK', |
| 111 | provided_link_ids) |
| 112 | if service_link is None: |
| 113 | return None |
| 114 | provider_service_instance_id = service_link.get('provider_service_instance_id', |
| 115 | None) |
| 116 | assert_not_equal(provider_service_instance_id, None) |
| 117 | return provider_service_instance_id |
| 118 | |
| 119 | def linkTenant(self, subId, tenant_info): |
| 120 | result = self.restApi.ApiGet('VOLT_TENANT') |
| 121 | tenant = None |
| 122 | for volt in result: |
| 123 | if str(volt['c_tag']) == str(tenant_info['c_tag']): |
| 124 | tenant = volt |
| 125 | break |
| 126 | assert_not_equal(tenant, None) |
| 127 | volt_id = self.utils.getFieldValueFromDict(tenant, 'id') |
| 128 | provided_links_ids_list = self.utils.getFieldValueFromDict(tenant, |
| 129 | 'provided_link_ids') |
| 130 | assert_not_equal( len(provided_link_ids_list), 0) |
| 131 | provided_link_ids = provided_link_ids_list[0] |
| 132 | subscribed_link_ids_list = self.utils.getFieldValueFromDict(tenant, |
| 133 | 'subscribed_link_ids') |
| 134 | assert_not_equal(len(subscribed_link_ids_list), 0) |
| 135 | subscribed_link_ids = subscribed_link_ids_list[0] |
| 136 | service_link = self.restApi.ApiChameleonGet('CH_CORE_SERVICELINK', |
| 137 | provided_link_ids) |
| 138 | assert_not_equal(service_link, None) |
| 139 | provider_service_instance_id = service_link.get('provider_service_instance_id', |
| 140 | None) |
| 141 | assert_not_equal(provider_service_instance_id, None) |
| 142 | service_dict = dict(subscriber_service_instance_id = subId) |
| 143 | result = self.restApi.ApiChameleonPut('CH_CORE_SERVICELINK', |
| 144 | service_dict, |
| 145 | provided_link_ids) |
| 146 | assert_equal(result, True) |
| 147 | return provider_service_instance_id |
| 148 | # service_link_dict = self.restApi.ApiChameleonGet('CH_CORE_SERVICELINK', |
| 149 | # subscribed_link_ids) |
| 150 | # assert_not_equal(service_link_dict, None) |
| 151 | # vsg_tenant = service_link_dict.get('provider_service_instance_id', None) |
| 152 | # assert_not_equal(vsg_tenant, None) |
| 153 | # vsg_result = self.restApi.ApiChameleonGet('VSG_TENANT', |
| 154 | # vsg_tenant) |
| 155 | # assert_not_equal(vsg_result, None) |
| 156 | # vsg_instance = vsg_result.get('instance_id', None) |
| 157 | # assert_not_equal(vsg_instance, None) |
| 158 | # instance_result = self.restApi.ApiChameleonGet('CH_CORE_INSTANCES', |
| 159 | # vsg_instance) |
| 160 | # assert_equal(instance_result, True) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 161 | |
| 162 | def subscriberCreate(self, subscriber_info, volt_subscriber_info): |
| 163 | subId = '' |
| 164 | try: |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 165 | result = self.restApi.ApiPost('VOLT_SUBSCRIBER', subscriber_info) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 166 | assert_equal(result, True) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 167 | result = self.restApi.ApiGet('VOLT_SUBSCRIBER') |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 168 | assert_not_equal(result, None) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 169 | _, subId = self.getSubscriberId(result, |
| 170 | volt_subscriber_info['service_specific_id']) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 171 | assert_not_equal(subId, '0') |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 172 | log.info('Subscriber ID for account num %s = %s' %(str(volt_subscriber_info['service_specific_id']), subId)) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 173 | volt_tenant = volt_subscriber_info['voltTenant'] |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 174 | result = self.restApi.ApiPost('VOLT_TENANT', volt_tenant) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 175 | assert_equal(result, True) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 176 | volt_id = self.linkTenant(subId, volt_tenant) |
| 177 | log.info('Subscriber create with ctag %s, stag %s, volt id %s' %(str(volt_tenant['c_tag']), |
| 178 | str(volt_tenant['s_tag']), |
| 179 | str(volt_id))) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 180 | finally: |
| 181 | return subId |
| 182 | |
| 183 | def subscriberDelete(self, account_num, subId = '', voltId = ''): |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 184 | result = self.restApi.ApiGet('VOLT_SUBSCRIBER') |
| 185 | assert_not_equal(result, None) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 186 | if not subId: |
| 187 | #get the subscriber id first |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 188 | subInfo, subId = self.getSubscriberId(result, account_num) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 189 | assert_not_equal(subId, '0') |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 190 | else: |
| 191 | subInfo, currentSubId = self.getSubscriberId(result, account_num) |
| 192 | assert_not_equal(currentSubId, '0') |
| 193 | #assert_equal(subId, currentSubId) |
| 194 | subId = self.utils.getFieldValueFromDict(subInfo, 'id') |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 195 | if not voltId: |
| 196 | #get the volt id for the subscriber |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 197 | result = self.restApi.ApiGet('VOLT_TENANT') |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 198 | assert_not_equal(result, None) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 199 | voltId = self.getVoltId(result, subInfo) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 200 | assert_not_equal(voltId, None) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 201 | log.info('Deleting VOLT Tenant ID %s for subscriber %s' %(voltId, subId)) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 202 | status = self.restApi.ApiChameleonDelete('VOLT_TENANT', voltId) |
| 203 | assert_equal(status, True) |
| 204 | log.info('Deleting subscriber ID %s for account num %s' %(subId, str(account_num))) |
| 205 | status = self.restApi.ApiChameleonDelete('VOLT_SUBSCRIBER', subId) |
| 206 | assert_equal(status, True) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 207 | |
| 208 | def subscriberId(self, account_num): |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 209 | result = self.restApi.ApiGet('VOLT_SUBSCRIBER') |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 210 | assert_not_equal(result, None) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 211 | _, subId = self.getSubscriberId(result, account_num) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 212 | return subId |
| 213 | |
| 214 | class CordSubscriberUtils(object): |
| 215 | |
| 216 | SUBSCRIBER_ACCOUNT_NUM = 100 |
| 217 | SUBSCRIBER_S_TAG = 500 |
| 218 | SUBSCRIBER_C_TAG = 500 |
| 219 | SUBSCRIBERS_PER_S_TAG = 8 |
| 220 | |
| 221 | def __init__(self, |
| 222 | num_subscribers, |
| 223 | account_num = SUBSCRIBER_ACCOUNT_NUM, |
| 224 | s_tag = SUBSCRIBER_S_TAG, |
| 225 | c_tag = SUBSCRIBER_C_TAG, |
| 226 | subscribers_per_s_tag = SUBSCRIBERS_PER_S_TAG): |
| 227 | self.num_subscribers = num_subscribers |
| 228 | self.account_num = account_num |
| 229 | self.s_tag = s_tag |
| 230 | self.c_tag = c_tag |
| 231 | self.subscribers_per_s_tag = subscribers_per_s_tag |
| 232 | self.subscriber_map = {} |
| 233 | self.subscriber_info = self.getConfig() |
| 234 | self.volt_subscriber_info = self.getVoltConfig() |
| 235 | self.xos = XosUtils() |
| 236 | |
| 237 | def getCredentials(self, subId): |
| 238 | """Generate our own account num, s_tag and c_tags""" |
| 239 | if subId in self.subscriber_map: |
| 240 | return self.subscriber_map[subId] |
| 241 | account_num = self.account_num |
| 242 | self.account_num += 1 |
| 243 | s_tag, c_tag = self.s_tag, self.c_tag |
| 244 | self.c_tag += 1 |
| 245 | if self.c_tag % self.subscribers_per_s_tag == 0: |
| 246 | self.s_tag += 1 |
| 247 | self.subscriber_map[subId] = account_num, s_tag, c_tag |
| 248 | return self.subscriber_map[subId] |
| 249 | |
| 250 | def getConfig(self): |
| 251 | features = { |
| 252 | 'cdn': True, |
| 253 | 'uplink_speed': 1000000000, |
| 254 | 'downlink_speed': 1000000000, |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 255 | 'enable_uverse': True, |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 256 | 'status': 'enabled' |
| 257 | } |
| 258 | subscriber_map = [] |
| 259 | for i in xrange(self.num_subscribers): |
| 260 | subId = 'sub{}'.format(i) |
| 261 | account_num, _, _ = self.getCredentials(subId) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 262 | identity = { 'service_specific_id' : str(account_num), |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 263 | 'name' : 'My House {}'.format(i) |
| 264 | } |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 265 | sub_data = [ (k, v) for d in (features, identity) \ |
| 266 | for k, v in d.iteritems() ] |
| 267 | sub_info = dict(sub_data) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 268 | subscriber_map.append(sub_info) |
| 269 | |
| 270 | return subscriber_map |
| 271 | |
| 272 | def getVoltConfig(self): |
| 273 | voltSubscriberMap = [] |
| 274 | for i in xrange(self.num_subscribers): |
| 275 | subId = 'sub{}'.format(i) |
| 276 | account_num, s_tag, c_tag = self.getCredentials(subId) |
| 277 | voltSubscriberInfo = {} |
| 278 | voltSubscriberInfo['voltTenant'] = dict(s_tag = str(s_tag), |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 279 | c_tag = str(c_tag)) |
| 280 | voltSubscriberInfo['service_specific_id'] = account_num |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 281 | voltSubscriberMap.append(voltSubscriberInfo) |
| 282 | |
| 283 | return voltSubscriberMap |
| 284 | |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 285 | def getVoltId(self, subInfo): |
| 286 | return self.xos.getVoltId(None, subInfo) |
| 287 | |
| 288 | def getProviderInstance(self, tenant_info): |
| 289 | return self.xos.getProviderInstance(tenant_info) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 290 | |
| 291 | def subscriberCreate(self, index, subscriber_info = None, volt_subscriber_info = None): |
| 292 | if subscriber_info is None: |
| 293 | subscriber_info = self.subscriber_info[index] |
| 294 | if volt_subscriber_info is None: |
| 295 | volt_subscriber_info = self.volt_subscriber_info[index] |
| 296 | s_tag = int(volt_subscriber_info['voltTenant']['s_tag']) |
| 297 | c_tag = int(volt_subscriber_info['voltTenant']['c_tag']) |
| 298 | log.info('Creating tenant with s_tag: %d, c_tag: %d' %(s_tag, c_tag)) |
| 299 | subId = self.xos.subscriberCreate(subscriber_info, volt_subscriber_info) |
| 300 | return subId |
| 301 | |
| 302 | def subscriberDelete(self, index, subId = '', voltId = '', subscriber_info = None, volt_subscriber_info = None): |
| 303 | if subscriber_info is None: |
| 304 | subscriber_info = self.subscriber_info[index] |
| 305 | if volt_subscriber_info is None: |
| 306 | volt_subscriber_info = self.volt_subscriber_info[index] |
| 307 | s_tag = int(volt_subscriber_info['voltTenant']['s_tag']) |
| 308 | c_tag = int(volt_subscriber_info['voltTenant']['c_tag']) |
| 309 | log.info('Deleting tenant with s_tag: %d, c_tag: %d' %(s_tag, c_tag)) |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 310 | self.xos.subscriberDelete(volt_subscriber_info['service_specific_id'], subId = subId, voltId = voltId) |
A R Karthick | ed3a2ca | 2017-07-06 15:50:03 -0700 | [diff] [blame] | 311 | |
| 312 | def subscriberId(self, index): |
| 313 | volt_subscriber_info = self.volt_subscriber_info[index] |
A R Karthick | 028edaf | 2017-11-06 16:34:57 -0800 | [diff] [blame^] | 314 | return self.xos.subscriberId(volt_subscriber_info['service_specific_id']) |