rwlaunchpad/ra/pytest/ns/haproxy/test_scaling.py

   1
   2 #
   3 #   Copyright 2016 RIFT.IO Inc
   4 #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");
   6 #   you may not use this file except in compliance with the License.
   7 #   You may obtain a copy of the License at
   8 #
   9 #       http://www.apache.org/licenses/LICENSE-2.0
  10 #
  11 #   Unless required by applicable law or agreed to in writing, software
  12 #   distributed under the License is distributed on an "AS IS" BASIS,
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 #   See the License for the specific language governing permissions and
  15 #   limitations under the License.
  16 #
  17
  18 import pytest
  19
  20 from gi.repository import (
  21     NsrYang,
  22     RwNsrYang,
  23     RwVnfrYang,
  24     ProjectNsdYang as NsdYang,
  25     RwProjectNsdYang as RwNsdYang
  26     )
  27 import rift.auto.session
  28
  29 @pytest.fixture(scope='module')
  30 def proxy(request, mgmt_session):
  31     return mgmt_session.proxy
  32
  33
  34 ScalingGroupInstance = NsrYang.YangData_RwProject_Project_NsInstanceConfig_Nsr_ScalingGroup_Instance
  35 ScalingGroup = NsrYang.YangData_RwProject_Project_NsInstanceConfig_Nsr_ScalingGroup
  36
  37 INSTANCE_ID = 1
  38
  39
  40 @pytest.mark.depends('nsr')
  41 @pytest.mark.incremental
  42 class TestScaling:
  43     def wait_for_nsr_state(self, proxy, state):
  44         """Wait till the NSR reaches a desired state.
  45
  46         Args:
  47             proxy (Callable): Proxy for launchpad session.
  48             state (str): Expected state
  49         """
  50         nsr_opdata = proxy(RwNsrYang).get('/ns-instance-opdata')
  51         nsr = nsr_opdata.nsr[0]
  52         xpath = "/ns-instance-opdata/nsr[ns-instance-config-ref='{}']/operational-status".format(nsr.ns_instance_config_ref)
  53         proxy(RwNsrYang).wait_for(xpath, state, timeout=240)
  54
  55     def verify_scaling_group(self, proxy, group_name, expected_records_count, scale_out=True):
  56         """
  57         Args:
  58             proxy (Callable): LP session
  59             group_name (str): Group name which is being scaled up.
  60             scale_out (bool, optional): To identify scale-out/scale-in mode.
  61
  62         Asserts:
  63             1. Additional records are added to the opdata
  64             2. Status of the scaling group
  65             3. New vnfr record has been created.
  66         """
  67         nsr_opdata = proxy(RwNsrYang).get('/ns-instance-opdata')
  68         nsr_id = nsr_opdata.nsr[0].ns_instance_config_ref
  69
  70         xpath = ('/ns-instance-opdata/nsr[ns-instance-config-ref="{}"]'
  71                  '/scaling-group-record[scaling-group-name-ref="{}"]').format(
  72                         nsr_id, group_name)
  73
  74         scaling_record = proxy(NsrYang).get(xpath)
  75
  76         assert len(scaling_record.instance) == expected_records_count
  77
  78         for instance in scaling_record.instance:
  79             assert instance.op_status == 'running'
  80
  81             for vnfr in instance.vnfrs:
  82                 vnfr_record = proxy(RwVnfrYang).get(
  83                         "/vnfr-catalog/vnfr[id='{}']".format(vnfr))
  84                 assert vnfr_record is not None
  85
  86     def verify_scale_up(self, proxy, group_name, expected):
  87         """Verifies the scaling up steps for the group
  88         NSR moves from running -> scaling-up -> running
  89
  90         Args:
  91             proxy (callable): LP proxy
  92             group_name (str): Name of the group to verify.
  93         """
  94         self.wait_for_nsr_state(proxy, "scaling-out")
  95         self.wait_for_nsr_state(proxy, "running")
  96         self.verify_scaling_group(proxy, group_name, expected)
  97
  98     def verify_scale_in(self, proxy, group_name, expected):
  99         """Verifies the scaling in streps for the group.
 100         NSR moves from running -> scaling-down -> running
 101
 102         Args:
 103             proxy (callable): LP proxy
 104             group_name (str): group name.
 105         """
 106         self.wait_for_nsr_state(proxy, "scaling-in")
 107         self.wait_for_nsr_state(proxy, "running")
 108         self.verify_scaling_group(proxy, group_name, expected, scale_out=False)
 109
 110     def test_wait_for_nsr_configured(self, proxy):
 111         """Wait till the NSR state moves to configured before starting scaling
 112         tests.
 113         """
 114         nsr_opdata = proxy(RwNsrYang).get('/ns-instance-opdata')
 115         nsrs = nsr_opdata.nsr
 116
 117         assert len(nsrs) == 1
 118         current_nsr = nsrs[0]
 119
 120         xpath = "/ns-instance-opdata/nsr[ns-instance-config-ref='{}']/config-status".format(current_nsr.ns_instance_config_ref)
 121         proxy(RwNsrYang).wait_for(xpath, "configured", timeout=240)
 122
 123
 124     def test_min_max_scaling(self, proxy):
 125         nsr_opdata = proxy(RwNsrYang).get('/ns-instance-opdata')
 126         nsrs = nsr_opdata.nsr
 127         nsd_id = nsrs[0].nsd_ref
 128         nsr_id = nsrs[0].ns_instance_config_ref
 129
 130         # group_name = "http_client_group"
 131
 132         xpath = "/ns-instance-opdata/nsr[ns-instance-config-ref='{}']/scaling-group-record".format(nsr_id)
 133         scaling_records = proxy(RwNsrYang).get(xpath, list_obj=True)
 134
 135         for scaling_record in scaling_records.scaling_group_record:
 136             group_name = scaling_record.scaling_group_name_ref
 137             xpath = "/nsd-catalog/nsd[id='{}']/scaling-group-descriptor[name='{}']".format(
 138                     nsd_id, group_name)
 139             scaling_group_desc = proxy(NsdYang).get(xpath)
 140
 141             # Add + 1 to go beyond the threshold
 142             for instance_id in range(1, scaling_group_desc.max_instance_count + 1):
 143                 xpath = '/ns-instance-config/nsr[id="{}"]/scaling-group[scaling-group-name-ref="{}"]'.format(
 144                             nsr_id,
 145                             group_name)
 146
 147                 instance = ScalingGroupInstance.from_dict({"id": instance_id})
 148                 scaling_group = proxy(NsrYang).get(xpath)
 149
 150                 if scaling_group is None:
 151                     scaling_group = ScalingGroup.from_dict({
 152                         'scaling_group_name_ref': group_name,
 153                         })
 154
 155                 scaling_group.instance.append(instance)
 156
 157                 try:
 158                     proxy(NsrYang).merge_config(xpath, scaling_group)
 159                     self.verify_scale_up(proxy, group_name, instance_id + 1)
 160                 except rift.auto.session.ProxyRequestError:
 161                     assert instance_id == scaling_group_desc.max_instance_count
 162
 163             for instance_id in range(1, scaling_group_desc.max_instance_count):
 164                 xpath = ('/ns-instance-config/nsr[id="{}"]/scaling-group'
 165                          '[scaling-group-name-ref="{}"]/'
 166                          'instance[id="{}"]').format(
 167                          nsr_id, group_name, instance_id)
 168                 proxy(NsrYang).delete_config(xpath)
 169                 self.verify_scale_in(proxy, group_name, instance_id)
 170
 171
 172
 173
 174
 175
 176