| #!/usr/bin/env python3 |
| |
| # |
| # Copyright 2016 RIFT.IO Inc |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| from gi import require_version |
| require_version('RwCal', '1.0') |
| |
| from gi.repository import RwcalYang |
| from gi.repository.RwTypes import RwStatus |
| import logging |
| import rw_peas |
| import rwlogger |
| import time |
| import argparse |
| import os |
| import sys |
| import uuid |
| from os.path import basename |
| |
| FLAVOR_NAME = 'm1.medium' |
| DEFAULT_IMAGE='/net/sharedfiles/home1/common/vm/rift-root-latest.qcow2' |
| |
| persistent_resources = { |
| 'vms' : ['mission_control','launchpad',], |
| 'networks' : ['public', 'private', 'multisite'], |
| 'flavors' : ['m1.tiny', 'm1.small', 'm1.medium', 'm1.large', 'm1.xlarge'], |
| 'images' : ['rwimage','rift-root-latest.qcow2','rift-root-latest-trafgen.qcow2', 'rift-root-latest-trafgen-f.qcow2'] |
| } |
| |
| # |
| # Important information about openstack installation. This needs to be manually verified |
| # |
| openstack_info = { |
| 'username' : 'pluto', |
| 'password' : 'mypasswd', |
| 'project_name' : 'demo', |
| 'mgmt_network' : 'private', |
| 'physical_network' : 'physnet1', |
| 'network_type' : 'VLAN', |
| 'segmentation_id' : 42, ### What else? |
| 'subnets' : ["11.0.0.0/24", "12.0.0.0/24", "13.0.0.0/24", "14.0.0.0/24"], |
| 'subnet_index' : 0, |
| } |
| |
| |
| logging.basicConfig(level=logging.INFO) |
| |
| USERDATA_FILENAME = os.path.join(os.environ['RIFT_INSTALL'], |
| 'etc/userdata-template') |
| |
| |
| RIFT_BASE_USERDATA = ''' |
| #cloud-config |
| runcmd: |
| - sleep 5 |
| - /usr/rift/scripts/cloud/enable_lab |
| - /usr/rift/etc/fix_this_vm |
| ''' |
| |
| try: |
| fd = open(USERDATA_FILENAME, 'r') |
| except Exception as e: |
| #logger.error("Received exception during opening of userdata (%s) file. Exception: %s" %(USERDATA_FILENAME, str(e))) |
| sys.exit(-1) |
| else: |
| LP_USERDATA_FILE = fd.read() |
| # Run the enable lab script when the openstack vm comes up |
| LP_USERDATA_FILE += "runcmd:\n" |
| LP_USERDATA_FILE += " - /usr/rift/scripts/cloud/enable_lab\n" |
| LP_USERDATA_FILE += " - /usr/rift/etc/fix_this_vm\n" |
| |
| |
| |
| def get_cal_plugin(): |
| """ |
| Loads rw.cal plugin via libpeas |
| """ |
| plugin = rw_peas.PeasPlugin('rwcal_openstack', 'RwCal-1.0') |
| engine, info, extension = plugin() |
| cal = plugin.get_interface("Cloud") |
| # Get the RwLogger context |
| rwloggerctx = rwlogger.RwLog.Ctx.new("Cal-Log") |
| try: |
| rc = cal.init(rwloggerctx) |
| assert rc == RwStatus.SUCCESS |
| except: |
| logger.error("ERROR:Cal plugin instantiation failed. Aborting tests") |
| else: |
| logger.info("Openstack Cal plugin successfully instantiated") |
| return cal |
| |
| def get_cal_account(auth_url): |
| """ |
| Returns cal account |
| """ |
| account = RwcalYang.CloudAccount() |
| account.account_type = "openstack" |
| account.openstack.key = openstack_info['username'] |
| account.openstack.secret = openstack_info['password'] |
| account.openstack.auth_url = auth_url |
| account.openstack.tenant = openstack_info['project_name'] |
| account.openstack.mgmt_network = openstack_info['mgmt_network'] |
| return account |
| |
| |
| logger = logging.getLogger('rift.cal.openstackresources') |
| |
| class OpenstackResources(object): |
| """ |
| A stupid class to manage bunch of openstack resources |
| """ |
| def __init__(self, controller): |
| self._cal = get_cal_plugin() |
| self._acct = get_cal_account('http://'+controller+':5000/v3/') |
| self._id = 0 |
| self._image_id = None |
| self._flavor_id = None |
| |
| def _destroy_vms(self): |
| """ |
| Destroy VMs |
| """ |
| logger.info("Initiating VM cleanup") |
| rc, rsp = self._cal.get_vdu_list(self._acct) |
| vdu_list = [vm for vm in rsp.vdu_info_list if vm.name not in persistent_resources['vms']] |
| logger.info("Deleting VMs : %s" %([x.name for x in vdu_list])) |
| |
| for vdu in vdu_list: |
| self._cal.delete_vdu(self._acct, vdu.vdu_id) |
| |
| logger.info("VM cleanup complete") |
| |
| def _destroy_networks(self): |
| """ |
| Destroy Networks |
| """ |
| logger.info("Initiating Network cleanup") |
| rc, rsp = self._cal.get_virtual_link_list(self._acct) |
| vlink_list = [vlink for vlink in rsp.virtual_link_info_list if vlink.name not in persistent_resources['networks']] |
| |
| logger.info("Deleting Networks : %s" %([x.name for x in vlink_list])) |
| for vlink in vlink_list: |
| self._cal.delete_virtual_link(self._acct, vlink.virtual_link_id) |
| logger.info("Network cleanup complete") |
| |
| def _destroy_flavors(self): |
| """ |
| Destroy Flavors |
| """ |
| logger.info("Initiating flavor cleanup") |
| rc, rsp = self._cal.get_flavor_list(self._acct) |
| flavor_list = [flavor for flavor in rsp.flavorinfo_list if flavor.name not in persistent_resources['flavors']] |
| |
| logger.info("Deleting flavors : %s" %([x.name for x in flavor_list])) |
| |
| for flavor in flavor_list: |
| self._cal.delete_flavor(self._acct, flavor.id) |
| |
| logger.info("Flavor cleanup complete") |
| |
| def _destroy_images(self): |
| logger.info("Initiating image cleanup") |
| rc, rsp = self._cal.get_image_list(self._acct) |
| image_list = [image for image in rsp.imageinfo_list if image.name not in persistent_resources['images']] |
| |
| logger.info("Deleting images : %s" %([x.name for x in image_list])) |
| |
| for image in image_list: |
| self._cal.delete_image(self._acct, image.id) |
| |
| logger.info("Image cleanup complete") |
| |
| def destroy_resource(self): |
| """ |
| Destroy resources |
| """ |
| logger.info("Cleaning up openstack resources") |
| self._destroy_vms() |
| self._destroy_networks() |
| self._destroy_flavors() |
| self._destroy_images() |
| logger.info("Cleaning up openstack resources.......[Done]") |
| |
| def create_mission_control(self): |
| vm_id = self.create_vm('mission_control', |
| userdata = RIFT_BASE_USERDATA) |
| return vm_id |
| |
| |
| def create_launchpad_vm(self, salt_master=None): |
| node_id = str(uuid.uuid4()) |
| if salt_master is not None: |
| userdata = LP_USERDATA_FILE.format(master_ip = salt_master, |
| lxcname = node_id) |
| else: |
| userdata = RIFT_BASE_USERDATA |
| |
| vm_id = self.create_vm('launchpad', |
| userdata = userdata, |
| node_id = node_id) |
| # vm_id = self.create_vm('launchpad2', |
| # userdata = userdata, |
| # node_id = node_id) |
| return vm_id |
| |
| def create_vm(self, name, userdata, node_id = None): |
| """ |
| Creates a VM. The VM name is derived from username |
| |
| """ |
| vm = RwcalYang.VDUInitParams() |
| vm.name = name |
| vm.flavor_id = self._flavor_id |
| vm.image_id = self._image_id |
| if node_id is not None: |
| vm.node_id = node_id |
| vm.vdu_init.userdata = userdata |
| vm.allocate_public_address = True |
| logger.info("Starting a VM with parameter: %s" %(vm)) |
| |
| rc, vm_id = self._cal.create_vdu(self._acct, vm) |
| assert rc == RwStatus.SUCCESS |
| logger.info('Created vm: %s with id: %s', name, vm_id) |
| return vm_id |
| |
| def create_network(self, name): |
| logger.info("Creating network with name: %s" %name) |
| network = RwcalYang.NetworkInfoItem() |
| network.network_name = name |
| network.subnet = openstack_info['subnets'][openstack_info['subnet_index']] |
| |
| if openstack_info['subnet_index'] == len(openstack_info['subnets']): |
| openstack_info['subnet_index'] = 0 |
| else: |
| openstack_info['subnet_index'] += 1 |
| |
| if openstack_info['physical_network']: |
| network.provider_network.physical_network = openstack_info['physical_network'] |
| if openstack_info['network_type']: |
| network.provider_network.overlay_type = openstack_info['network_type'] |
| if openstack_info['segmentation_id']: |
| network.provider_network.segmentation_id = openstack_info['segmentation_id'] |
| openstack_info['segmentation_id'] += 1 |
| |
| rc, net_id = self._cal.create_network(self._acct, network) |
| assert rc == RwStatus.SUCCESS |
| |
| logger.info("Successfully created network with id: %s" %net_id) |
| return net_id |
| |
| |
| |
| def create_image(self, location): |
| img = RwcalYang.ImageInfoItem() |
| img.name = basename(location) |
| img.location = location |
| img.disk_format = "qcow2" |
| img.container_format = "bare" |
| |
| logger.info("Uploading image : %s" %img.name) |
| rc, img_id = self._cal.create_image(self._acct, img) |
| assert rc == RwStatus.SUCCESS |
| |
| rs = None |
| rc = None |
| image = None |
| for i in range(100): |
| rc, rs = self._cal.get_image(self._acct, img_id) |
| assert rc == RwStatus.SUCCESS |
| logger.info("Image (image_id: %s) reached status : %s" %(img_id, rs.state)) |
| if rs.state == 'active': |
| image = rs |
| break |
| else: |
| time.sleep(2) # Sleep for a second |
| |
| if image is None: |
| logger.error("Failed to upload openstack image: %s", img) |
| sys.exit(1) |
| |
| self._image_id = img_id |
| logger.info("Uploading image.......[Done]") |
| |
| def create_flavor(self): |
| """ |
| Create Flavor suitable for rift_ping_pong VNF |
| """ |
| flavor = RwcalYang.FlavorInfoItem() |
| flavor.name = FLAVOR_NAME |
| flavor.vm_flavor.memory_mb = 16384 # 16GB |
| flavor.vm_flavor.vcpu_count = 4 |
| flavor.vm_flavor.storage_gb = 20 # 20 GB |
| |
| logger.info("Creating new flavor. Flavor Info: %s" %str(flavor.vm_flavor)) |
| |
| rc, flavor_id = self._cal.create_flavor(self._acct, flavor) |
| assert rc == RwStatus.SUCCESS |
| logger.info("Creating new flavor.......[Done]") |
| return flavor_id |
| |
| def find_image(self, name): |
| logger.info("Searching for uploaded image: %s" %name) |
| rc, rsp = self._cal.get_image_list(self._acct) |
| image_list = [image for image in rsp.imageinfo_list if image.name == name] |
| |
| if not image_list: |
| logger.error("Image %s not found" %name) |
| return None |
| |
| self._image_id = image_list[0].id |
| logger.info("Searching for uploaded image.......[Done]") |
| return self._image_id |
| |
| def find_flavor(self, name=FLAVOR_NAME): |
| logger.info("Searching for required flavor: %s" %name) |
| rc, rsp = self._cal.get_flavor_list(self._acct) |
| flavor_list = [flavor for flavor in rsp.flavorinfo_list if flavor.name == name] |
| |
| if not flavor_list: |
| logger.error("Flavor %s not found" %name) |
| self._flavor_id = self.create_flavor() |
| else: |
| self._flavor_id = flavor_list[0].id |
| |
| logger.info("Searching for required flavor.......[Done]") |
| return self._flavor_id |
| |
| |
| |
| |
| def main(): |
| """ |
| Main routine |
| """ |
| parser = argparse.ArgumentParser(description='Script to manage openstack resources') |
| |
| parser.add_argument('--controller', |
| action = 'store', |
| dest = 'controller', |
| type = str, |
| help='IP Address of openstack controller. This is mandatory parameter') |
| |
| parser.add_argument('--cleanup', |
| action = 'store', |
| dest = 'cleanup', |
| nargs = '+', |
| type = str, |
| help = 'Perform resource cleanup for openstack installation. \n Possible options are {all, flavors, vms, networks, images}') |
| |
| parser.add_argument('--persist-vms', |
| action = 'store', |
| dest = 'persist_vms', |
| help = 'VM instance name to persist') |
| |
| parser.add_argument('--salt-master', |
| action = 'store', |
| dest = 'salt_master', |
| type = str, |
| help='IP Address of salt controller. Required, if VMs are being created.') |
| |
| parser.add_argument('--upload-image', |
| action = 'store', |
| dest = 'upload_image', |
| help='Openstack image location to upload and use when creating vms.x') |
| |
| parser.add_argument('--use-image', |
| action = 'store', |
| dest = 'use_image', |
| help='Image name to be used for VM creation') |
| |
| parser.add_argument('--use-flavor', |
| action = 'store', |
| dest = 'use_flavor', |
| help='Flavor name to be used for VM creation') |
| |
| parser.add_argument('--mission-control', |
| action = 'store_true', |
| dest = 'mission_control', |
| help='Create Mission Control VM') |
| |
| |
| parser.add_argument('--launchpad', |
| action = 'store_true', |
| dest = 'launchpad', |
| help='Create LaunchPad VM') |
| |
| parser.add_argument('--use-project', |
| action = 'store', |
| dest = 'use_project', |
| help='Project name to be used for VM creation') |
| |
| parser.add_argument('--clean-mclp', |
| action='store_true', |
| dest='clean_mclp', |
| help='Remove Mission Control and Launchpad VMs') |
| |
| argument = parser.parse_args() |
| |
| if argument.persist_vms is not None: |
| global persistent_resources |
| vm_name_list = argument.persist_vms.split(',') |
| for single_vm in vm_name_list: |
| persistent_resources['vms'].append(single_vm) |
| logger.info("persist-vms: %s" % persistent_resources['vms']) |
| |
| if argument.clean_mclp: |
| persistent_resources['vms'] = [] |
| |
| if argument.controller is None: |
| logger.error('Need openstack controller IP address') |
| sys.exit(-1) |
| |
| |
| if argument.use_project is not None: |
| openstack_info['project_name'] = argument.use_project |
| |
| ### Start processing |
| logger.info("Instantiating cloud-abstraction-layer") |
| drv = OpenstackResources(argument.controller) |
| logger.info("Instantiating cloud-abstraction-layer.......[Done]") |
| |
| |
| if argument.cleanup is not None: |
| for r_type in argument.cleanup: |
| if r_type == 'all': |
| drv.destroy_resource() |
| break |
| if r_type == 'images': |
| drv._destroy_images() |
| if r_type == 'flavors': |
| drv._destroy_flavors() |
| if r_type == 'vms': |
| drv._destroy_vms() |
| if r_type == 'networks': |
| drv._destroy_networks() |
| |
| if argument.upload_image is not None: |
| image_name_list = argument.upload_image.split(',') |
| logger.info("Will upload %d image(s): %s" % (len(image_name_list), image_name_list)) |
| for image_name in image_name_list: |
| drv.create_image(image_name) |
| #print("Uploaded :", image_name) |
| |
| elif argument.use_image is not None: |
| img = drv.find_image(argument.use_image) |
| if img == None: |
| logger.error("Image: %s not found" %(argument.use_image)) |
| sys.exit(-4) |
| else: |
| if argument.mission_control or argument.launchpad: |
| img = drv.find_image(basename(DEFAULT_IMAGE)) |
| if img == None: |
| drv.create_image(DEFAULT_IMAGE) |
| |
| if argument.use_flavor is not None: |
| drv.find_flavor(argument.use_flavor) |
| else: |
| drv.find_flavor() |
| |
| if argument.mission_control == True: |
| drv.create_mission_control() |
| |
| if argument.launchpad == True: |
| drv.create_launchpad_vm(salt_master = argument.salt_master) |
| |
| |
| if __name__ == '__main__': |
| main() |
| |