rwcal/plugins/vala/rwcal_cloudsim/test/cloudsim_module_test.py

   1 #!/usr/bin/env python3
   2
   3 #
   4 #   Copyright 2016 RIFT.IO Inc
   5 #
   6 #   Licensed under the Apache License, Version 2.0 (the "License");
   7 #   you may not use this file except in compliance with the License.
   8 #   You may obtain a copy of the License at
   9 #
  10 #       http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 #   Unless required by applicable law or agreed to in writing, software
  13 #   distributed under the License is distributed on an "AS IS" BASIS,
  14 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 #   See the License for the specific language governing permissions and
  16 #   limitations under the License.
  17 #
  18
  19
  20 import logging
  21 import os
  22 import ipaddress
  23 import unittest
  24 import uuid
  25 import sys
  26 from gi.repository import RwcalYang
  27
  28 import rift.rwcal.cloudsim.lvm as lvm
  29 import rift.rwcal.cloudsim.lxc as lxc
  30
  31 sys.path.append('../')
  32 import rwcal_cloudsim
  33
  34
  35 logger = logging.getLogger('rwcal-cloudsim')
  36
  37
  38 class CloudsimTest(unittest.TestCase):
  39     @classmethod
  40     def cleanUp(cls):
  41         for container in lxc.containers():
  42             lxc.stop(container)
  43
  44         for container in lxc.containers():
  45             lxc.destroy(container)
  46
  47         #lvm.destroy("rift")
  48
  49     @classmethod
  50     def create_image(cls):
  51         image = RwcalYang.YangData_RwProject_Project_VimResources_ImageinfoList()
  52         image.name = "rift-lxc-image"
  53         image.location = "/net/sharedfiles/home1/common/vm/R0.4/rift-mano-devel-latest.qcow2"
  54         image.disk_format = "qcow2"
  55         image.id = cls.cal.do_create_image(cls.account, image, no_rwstatus=True)
  56
  57         cls.image = image
  58
  59     @classmethod
  60     def setUpClass(cls):
  61         cls.cleanUp()
  62
  63         lvm.create("rift")
  64         cls.account = RwcalYang.YangData_RwProject_Project_CloudAccounts_CloudAccountList()
  65         cls.cal = rwcal_cloudsim.CloudSimPlugin()
  66         cls.create_image()
  67
  68     def setUp(self):
  69         pass
  70
  71     def create_vm(self, image, index):
  72         vm = RwcalYang.VmInfo()
  73         vm.vm_name = 'rift-s{}'.format(index + 1)
  74         vm.image_id = image.id
  75         vm.user_tags.node_id = str(uuid.uuid4())
  76
  77         self.cal.do_create_vm(self.account, vm, no_rwstatus=True)
  78
  79         return vm
  80
  81     def create_virtual_link(self, index):
  82         link = RwcalYang.YangData_RwProject_Project_VirtualLinkReqParams()
  83         link.name = 'link-{}'.format(index + 1)
  84         link.subnet = '192.168.{}.0/24'.format(index + 1)
  85
  86         logger.debug("Creating virtual link: %s", link)
  87
  88         link_id = self.cal.do_create_virtual_link(self.account, link, no_rwstatus=True)
  89         return link, link_id
  90
  91     def create_vdu(self, image, index, virtual_link_ids=None):
  92         vdu_init = RwcalYang.YangData_RwProject_Project_VduInitParams()
  93         vdu_init.name = 'rift-vdu{}'.format(index + 1)
  94         vdu_init.node_id = str(uuid.uuid4())
  95         vdu_init.image_id = image.id
  96
  97         if virtual_link_ids is not None:
  98             for vl_id in virtual_link_ids:
  99                 cp = vdu_init.connection_points.add()
 100                 cp.name = "{}_{}".format(vdu_init.name, vl_id)
 101                 cp.virtual_link_id = vl_id
 102
 103         vdu_id = self.cal.do_create_vdu(self.account, vdu_init, no_rwstatus=True)
 104
 105         return vdu_init, vdu_id
 106
 107     def test_create_vm(self):
 108         self.create_vm(self.image, 0)
 109
 110     def test_create_delete_virtual_link(self):
 111         link, link_id = self.create_virtual_link(0)
 112         get_link = self.cal.do_get_virtual_link(self.account, link_id, no_rwstatus=True)
 113         assert get_link.name == link.name
 114         assert get_link.virtual_link_id == link_id
 115         assert len(get_link.connection_points) == 0
 116         assert get_link.state == "active"
 117
 118         resources = self.cal.do_get_virtual_link_list(self.account, no_rwstatus=True)
 119         assert len(resources.virtual_link_info_list) == 1
 120         assert resources.virtual_link_info_list[0] == get_link
 121
 122         self.cal.do_delete_virtual_link(self.account, link_id, no_rwstatus=True)
 123         resources = self.cal.do_get_virtual_link_list(self.account, no_rwstatus=True)
 124         assert len(resources.virtual_link_info_list) == 0
 125
 126     def test_create_delete_vdu(self):
 127         vdu, vdu_id = self.create_vdu(self.image, 0)
 128         get_vdu = self.cal.do_get_vdu(self.account, vdu_id, None, no_rwstatus=True)
 129
 130         assert get_vdu.image_id == self.image.id
 131         assert get_vdu.name == vdu.name
 132         assert get_vdu.node_id == vdu.node_id
 133
 134         assert len(get_vdu.connection_points) == 0
 135
 136         assert get_vdu.vm_flavor.vcpu_count >= 1
 137         assert get_vdu.vm_flavor.memory_mb >= 8 * 1024
 138         assert get_vdu.vm_flavor.storage_gb >= 5
 139
 140         resources = self.cal.do_get_vdu_list(self.account, no_rwstatus=True)
 141         assert len(resources.vdu_info_list) == 1
 142         assert resources.vdu_info_list[0] == get_vdu
 143
 144         resources = self.cal.do_delete_vdu(self.account, vdu_id, no_rwstatus=True)
 145
 146         resources = self.cal.do_get_vdu_list(self.account, no_rwstatus=True)
 147         assert len(resources.vdu_info_list) == 0
 148
 149     def test_create_vdu_single_connection_point(self):
 150         link, link_id = self.create_virtual_link(0)
 151         vdu, vdu_id = self.create_vdu(self.image, 0, [link_id])
 152         get_vdu = self.cal.do_get_vdu(self.account, vdu_id, None, no_rwstatus=True)
 153         assert len(get_vdu.connection_points) == 1
 154         cp = get_vdu.connection_points[0]
 155         assert (ipaddress.IPv4Address(cp.ip_address) in
 156                 ipaddress.IPv4Network(link.subnet))
 157
 158         get_link = self.cal.do_get_virtual_link(self.account, link_id, no_rwstatus=True)
 159         assert len(get_link.connection_points) == 1
 160         assert get_link.connection_points[0].vdu_id == vdu_id
 161         assert get_link.connection_points[0].virtual_link_id == link_id
 162
 163         self.cal.do_delete_vdu(self.account, vdu_id, no_rwstatus=True)
 164         get_link = self.cal.do_get_virtual_link(self.account, link_id, no_rwstatus=True)
 165         assert len(get_link.connection_points) == 0
 166
 167         self.cal.do_delete_virtual_link(self.account, link_id)
 168
 169     def test_create_vdu_multiple_connection_point(self):
 170         link1, link1_id = self.create_virtual_link(0)
 171         link2, link2_id = self.create_virtual_link(1)
 172         link3, link3_id = self.create_virtual_link(2)
 173         link_id_map = {link1_id: link1, link2_id: link2, link3_id: link3}
 174
 175         vdu, vdu_id = self.create_vdu(self.image, 0, link_id_map.keys())
 176         get_vdu = self.cal.do_get_vdu(self.account, vdu_id, None, no_rwstatus=True)
 177         assert len(get_vdu.connection_points) == 3
 178         for cp in get_vdu.connection_points:
 179             assert cp.virtual_link_id in link_id_map
 180             link = link_id_map[cp.virtual_link_id]
 181
 182             assert (ipaddress.IPv4Address(cp.ip_address) in
 183                     ipaddress.IPv4Network(link.subnet))
 184
 185         self.do_delete_vdu(self.account, vdu_id, no_rwstatus=True)
 186
 187         self.do_delete_virtual_link(self.account, link1_id, no_rwstatus=True)
 188         self.do_delete_virtual_link(self.account, link2_id, no_rwstatus=True)
 189         self.do_delete_virtual_link(self.account, link3_id, no_rwstatus=True)
 190
 191     def test_modify_vdu_add_remove_connection_point(self):
 192         vdu, vdu_id = self.create_vdu(self.image, 0)
 193         link, link_id = self.create_virtual_link(0)
 194
 195         get_vdu = self.cal.do_get_vdu(self.account, vdu_id, None, no_rwstatus=True)
 196         assert len(get_vdu.connection_points) == 0
 197
 198         modify_vdu = RwcalYang.YangData_RwProject_Project_VduModifyParams()
 199         modify_vdu.vdu_id = vdu_id
 200         cp = modify_vdu.connection_points_add.add()
 201         cp.virtual_link_id = link_id
 202         cp.name = "link_1"
 203         self.cal.do_modify_vdu(self.account, modify_vdu, no_rwstatus=True)
 204
 205         get_vdu = self.cal.do_get_vdu(self.account, vdu_id, None, no_rwstatus=True)
 206         assert len(get_vdu.connection_points) == 1
 207
 208         modify_vdu = RwcalYang.YangData_RwProject_Project_VduModifyParams()
 209         modify_vdu.vdu_id = vdu_id
 210         cp = modify_vdu.connection_points_remove.add()
 211         cp.connection_point_id = get_vdu.connection_points[0].connection_point_id
 212         self.cal.do_modify_vdu(self.account, modify_vdu, no_rwstatus=True)
 213
 214         get_vdu = self.cal.do_get_vdu(self.account, vdu_id, None, no_rwstatus=True)
 215         assert len(get_vdu.connection_points) == 0
 216
 217         self.cal.do_delete_vdu(self.account, vdu_id, no_rwstatus=True)
 218         self.cal.do_delete_virtual_link(self.account, link_id, no_rwstatus=True)
 219
 220 if __name__ == "__main__":
 221     logging.basicConfig(level=logging.DEBUG)
 222     unittest.main()