cleanup after the recent refactoring, removing dead code, fixing comments
ran unit tests, ran through cli operations
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | testCloud/cli.py (49 lines) | |||
| M | testCloud/image.py (44 lines) | |||
| M | testCloud/instance.py (43 lines) | |||
| M | testCloud/util.py (28 lines) |
| Commit | Tree | Parents | Author | Summary | Date |
|---|---|---|---|---|---|
| b3b4a0cf0f16 | bbce4d21d003 | 05eb0cdd7f0e | Tim Flink | cleaning out unused code and fixing comments after refactor. Fixes T508 (Show More…) | Jun 17 2015, 3:57 PM |
| 1 | #!/usr/bin/env python | 1 | #!/usr/bin/env python | ||
|---|---|---|---|---|---|
| 2 | # -*- coding: utf-8 -*- | 2 | # -*- coding: utf-8 -*- | ||
| 3 | # Copyright 2015, Red Hat, Inc. | 3 | # Copyright 2015, Red Hat, Inc. | ||
| 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | ||
| 5 | # See the LICENSE file for more details on Licensing | 5 | # See the LICENSE file for more details on Licensing | ||
| 6 | 6 | | |||
| 7 | """ | 7 | """ | ||
| 8 | This is the primary user entry point for testCloud | 8 | This is the primary user entry point for testCloud | ||
| 9 | """ | 9 | """ | ||
| 10 | 10 | | |||
| 11 | import argparse | 11 | import argparse | ||
| 12 | import logging | 12 | import logging | ||
| 13 | import sys | 13 | from time import sleep | ||
| 14 | from pprint import pprint | | |||
| 15 | 14 | | |||
| 16 | from . import config | 15 | from . import config | ||
| 17 | from . import image | 16 | from . import image | ||
| 18 | from . import instance | 17 | from . import instance | ||
| 19 | | ||||
| 20 | # these are used in commented out code, may be reactivated | | |||
| 21 | | ||||
| 22 | from time import sleep | | |||
| 23 | from . import util | 18 | from . import util | ||
| 24 | from .exceptions import DomainNotFoundError, TestCloudCliError | 19 | from .exceptions import DomainNotFoundError, TestCloudCliError | ||
| 25 | 20 | | |||
| 26 | config_data = config.get_config() | 21 | config_data = config.get_config() | ||
| 27 | 22 | | |||
| 28 | log = logging.getLogger('libtestcloud') | 23 | log = logging.getLogger('libtestcloud') | ||
| 29 | logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG) | 24 | logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.DEBUG) | ||
| 30 | 25 | | |||
| Show All 25 Lines | |||||
| 56 | def _create_instance(args): | 51 | def _create_instance(args): | ||
| 57 | """Handler for 'instance create' command. Expects the following elements in args: | 52 | """Handler for 'instance create' command. Expects the following elements in args: | ||
| 58 | * name(str) | 53 | * name(str) | ||
| 59 | 54 | | |||
| 60 | :param args: args from argparser | 55 | :param args: args from argparser | ||
| 61 | """ | 56 | """ | ||
| 62 | 57 | | |||
| 63 | log.debug("create instance") | 58 | log.debug("create instance") | ||
| 64 | pprint(args) | | |||
| 65 | 59 | | |||
| 66 | tc_image = image.Image(args.url) | 60 | tc_image = image.Image(args.url) | ||
| 67 | tc_image.prepare() | 61 | tc_image.prepare() | ||
| 68 | 62 | | |||
| 69 | existing_instance = instance.find_instance(args.name, tc_image) | 63 | existing_instance = instance.find_instance(args.name, tc_image) | ||
| 70 | 64 | | |||
| 71 | # can't create existing instances | 65 | # can't create existing instances | ||
| 72 | if existing_instance is not None: | 66 | if existing_instance is not None: | ||
| ▲ Show 20 Lines • Show All 183 Lines • ▼ Show 20 Line(s) | 171 | def get_argparser(): | |||
| 256 | return parser | 250 | return parser | ||
| 257 | 251 | | |||
| 258 | 252 | | |||
| 259 | def main(): | 253 | def main(): | ||
| 260 | parser = get_argparser() | 254 | parser = get_argparser() | ||
| 261 | args = parser.parse_args() | 255 | args = parser.parse_args() | ||
| 262 | 256 | | |||
| 263 | args.func(args) | 257 | args.func(args) | ||
| 264 | sys.exit(1) | | |||
| 265 | | ||||
| 266 | # get/find image | | |||
| 267 | # look for existing instance | | |||
| 268 | # if not exist: | | |||
| 269 | # prepare metadata | | |||
| 270 | # boot vm | | |||
| 271 | | ||||
| 272 | tc_image = image.Image(args.url) | | |||
| 273 | tc_image.prepare() | | |||
| 274 | | ||||
| 275 | instance_path = instance.find_instance(args.name, tc_image.name) | | |||
| 276 | | ||||
| 277 | # for the moment, rebooting existing instances is noworky, so blow up early | | |||
| 278 | if instance_path is not None: | | |||
| 279 | raise NotImplementedError("testCloud does not yet support booting " | | |||
| 280 | "existing instances. Please remove {} before" | | |||
| 281 | " continuing".format(instance_path)) | | |||
| 282 | | ||||
| 283 | else: | | |||
| 284 | tc_instance = instance.Instance(args.name, tc_image) | | |||
| 285 | | ||||
| 286 | # prepare instance | | |||
| 287 | tc_instance.prepare() | | |||
| 288 | | ||||
| 289 | # boot instance | | |||
| 290 | tc_instance.spawn_vm() | | |||
| 291 | | ||||
| 292 | # look for data about instance (mac, IP, etc.) | | |||
| 293 | | ||||
| 294 | # install(args.url, | | |||
| 295 | # args.name, | | |||
| 296 | # args.ram, | | |||
| 297 | # graphics=args.no_graphic, | | |||
| 298 | # vnc=args.vnc, | | |||
| 299 | # atomic=args.atomic, | | |||
| 300 | # pristine=args.pristine) | | |||
| 301 | # | | |||
| 302 | # It takes a bit for the instance to get registered in virsh, | | |||
| 303 | # so here we keep asking for the domain we created until virsh | | |||
| 304 | # finally decides to cough up the information. | | |||
| 305 | 258 | | |||
| 306 | 259 | | |||
| 307 | def find_vm_ip(name): | 260 | def find_vm_ip(name): | ||
| 308 | """Finds the ip of a local vm given it's name used by libvirt. | 261 | """Finds the ip of a local vm given it's name used by libvirt. | ||
| 309 | 262 | | |||
| 310 | :param name: name of the VM (as used by libvirt) | 263 | :param name: name of the VM (as used by libvirt) | ||
| 311 | :returns: ip address of VM | 264 | :returns: ip address of VM | ||
| 312 | :rtype: str | 265 | :rtype: str | ||
| Show All 34 Lines | |||||
| 1 | #!/usr/bin/env python | 1 | #!/usr/bin/env python | ||
|---|---|---|---|---|---|
| 2 | # -*- coding: utf-8 -*- | 2 | # -*- coding: utf-8 -*- | ||
| 3 | # Copyright 2015, Red Hat, Inc. | 3 | # Copyright 2015, Red Hat, Inc. | ||
| 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | ||
| 5 | # See the LICENSE file for more details on Licensing | 5 | # See the LICENSE file for more details on Licensing | ||
| 6 | 6 | | |||
| 7 | """ | 7 | """ | ||
| 8 | This is a module for downloading fedora cloud images (and probably any other | 8 | Representation of a cloud image which can be used to boot instances | ||
| 9 | qcow2) and then booting them locally with qemu. | | |||
| 10 | """ | 9 | """ | ||
| 11 | 10 | | |||
| 12 | import sys | 11 | import sys | ||
| 13 | import os | 12 | import os | ||
| 14 | import subprocess | 13 | import subprocess | ||
| 15 | import re | 14 | import re | ||
| 16 | import shutil | 15 | import shutil | ||
| 17 | import logging | 16 | import logging | ||
| 18 | 17 | | |||
| 19 | import requests | 18 | import requests | ||
| 20 | 19 | | |||
| 21 | from . import config | 20 | from . import config | ||
| 22 | from .exceptions import TestCloudImageError | 21 | from .exceptions import TestCloudImageError | ||
| 23 | 22 | | |||
| 24 | config_data = config.get_config() | 23 | config_data = config.get_config() | ||
| 25 | 24 | | |||
| 26 | log = logging.getLogger('testCloud.image') | 25 | log = logging.getLogger('testCloud.image') | ||
| 27 | 26 | | |||
| 28 | 27 | | |||
| 29 | def list_images(): | 28 | def list_images(): | ||
| 29 | """List the images currently downloaded and available on the system | ||||
| 30 | | ||||
| 31 | :returns: list of images currently available | ||||
| 32 | """ | ||||
| 33 | | ||||
| 30 | image_dir = '{}/cache'.format(config_data.DATA_DIR) | 34 | image_dir = '{}/cache'.format(config_data.DATA_DIR) | ||
| 31 | images = os.listdir(image_dir) | 35 | images = os.listdir(image_dir) | ||
| 32 | 36 | | |||
| 33 | return images | 37 | return images | ||
| 34 | 38 | | |||
| 35 | 39 | | |||
| 36 | def find_image(name, uri=None): | 40 | def find_image(name, uri=None): | ||
| 41 | """Find an image matching a given name and optionally, a uri | ||||
| 42 | | ||||
| 43 | :param name: name of the image to look for | ||||
| 44 | :param uri: source uri to use if the image is found | ||||
| 45 | | ||||
| 46 | :returns: :py:class:`Image` if an image is found, otherwise None | ||||
| 47 | """ | ||||
| 37 | images = list_images() | 48 | images = list_images() | ||
| 38 | 49 | | |||
| 39 | if name in images: | 50 | if name in images: | ||
| 40 | if uri is None: | 51 | if uri is None: | ||
| 41 | uri = 'file://{}/cache/{}'.format(config_data.DATA_DIR, name) | 52 | uri = 'file://{}/cache/{}'.format(config_data.DATA_DIR, name) | ||
| 42 | return Image(uri) | 53 | return Image(uri) | ||
| 43 | else: | 54 | else: | ||
| 44 | return None | 55 | return None | ||
| ▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Line(s) | 183 | else: | |||
| 173 | log.error('Error while changing SELinux context on ' | 184 | log.error('Error while changing SELinux context on ' | ||
| 174 | 'image {}'.format(image_path)) | 185 | 'image {}'.format(image_path)) | ||
| 175 | 186 | | |||
| 176 | def prepare(self): | 187 | def prepare(self): | ||
| 177 | """Prepare the image for local use by either downloading the image from | 188 | """Prepare the image for local use by either downloading the image from | ||
| 178 | a remote location or copying it into the image cache from a locally | 189 | a remote location or copying it into the image cache from a locally | ||
| 179 | mounted filesystem""" | 190 | mounted filesystem""" | ||
| 180 | 191 | | |||
| 181 | # # Create the proper local upload directory if it doesn't exist. | | |||
| 182 | # if not os.path.exists(config_data.PRISTINE): | | |||
| 183 | # os.makedirs(config_data.PRISTINE) | | |||
| 184 | | ||||
| 185 | log.debug("Local downloads will be stored in {}.".format( | 192 | log.debug("Local downloads will be stored in {}.".format( | ||
| 186 | config_data.CACHE_DIR)) | 193 | config_data.CACHE_DIR)) | ||
| 187 | 194 | | |||
| 188 | if self.uri_type == 'file': | 195 | if self.uri_type == 'file': | ||
| 189 | self._handle_file_url(self.remote_path, self.local_path) | 196 | self._handle_file_url(self.remote_path, self.local_path) | ||
| 190 | else: | 197 | else: | ||
| 191 | if not os.path.exists(self.local_path): | 198 | if not os.path.exists(self.local_path): | ||
| 192 | self._download_remote_image(self.remote_path, self.local_path) | 199 | self._download_remote_image(self.remote_path, self.local_path) | ||
| 193 | 200 | | |||
| 194 | self._adjust_image_selinux(self.local_path) | 201 | self._adjust_image_selinux(self.local_path) | ||
| 195 | 202 | | |||
| 196 | return self.local_path | 203 | return self.local_path | ||
| 197 | 204 | | |||
| 198 | def destroy(self): | 205 | def destroy(self): | ||
| 206 | """Destroy the image, removing it from disk. This operation cannot be | ||||
| 207 | undone. | ||||
| 208 | """ | ||||
| 209 | | ||||
| 199 | log.debug("destroying image {}".format(self.local_path)) | 210 | log.debug("destroying image {}".format(self.local_path)) | ||
| 200 | 211 | | |||
| 201 | os.remove(self.local_path) | 212 | os.remove(self.local_path) | ||
| 202 | | ||||
| 203 | # def save_pristine(self): | | |||
| 204 | # """Save a copy of the downloaded image to the config_dataured PRISTINE dir. | | |||
| 205 | # Only call this after an image has been downloaded. | | |||
| 206 | # """ | | |||
| 207 | # | | |||
| 208 | # subprocess.call(['cp', | | |||
| 209 | # self.local_path, | | |||
| 210 | # config_data.PRISTINE]) | | |||
| 211 | # | | |||
| 212 | # log.debug('Copied fresh image to {0}...'.format(config_data.PRISTINE)) | | |||
| 213 | # | | |||
| 214 | # def load_pristine(self): | | |||
| 215 | # """Load a pristine image to /tmp instead of downloading. | | |||
| 216 | # """ | | |||
| 217 | # subprocess.call(['cp', | | |||
| 218 | # config_data.PRISTINE + self.name, | | |||
| 219 | # config_data.LOCAL_DOWNLOAD_DIR]) | | |||
| 220 | # | | |||
| 221 | # log.debug('Copied fresh image to {} ...'.format(config_data.LOCAL_DOWNLOAD_DIR)) | | |||
| 222 | # | | |||
| 1 | #!/usr/bin/env python | 1 | #!/usr/bin/env python | ||
|---|---|---|---|---|---|
| 2 | # -*- coding: utf-8 -*- | 2 | # -*- coding: utf-8 -*- | ||
| 3 | # Copyright 2015, Red Hat, Inc. | 3 | # Copyright 2015, Red Hat, Inc. | ||
| 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | ||
| 5 | # See the LICENSE file for more details on Licensing | 5 | # See the LICENSE file for more details on Licensing | ||
| 6 | 6 | | |||
| 7 | """ | 7 | """ | ||
| 8 | This is a module for downloading fedora cloud images (and probably any other | 8 | Representation of a TestCloud spawned (or to-be-spawned) virtual machine | ||
| 9 | qcow2) and then booting them locally with qemu. | | |||
| 10 | """ | 9 | """ | ||
| 11 | 10 | | |||
| 12 | import os | 11 | import os | ||
| 13 | import sys | 12 | import sys | ||
| 14 | import subprocess | 13 | import subprocess | ||
| 15 | import glob | 14 | import glob | ||
| 16 | import logging | 15 | import logging | ||
| 17 | 16 | | |||
| ▲ Show 20 Lines • Show All 80 Lines • ▼ Show 20 Line(s) | 96 | raise TestCloudInstanceError("instance {} exists in instances/ " | |||
| 98 | "but is not a libvirt domain on " | 97 | "but is not a libvirt domain on " | ||
| 99 | "{}".format(instance, connection)) | 98 | "{}".format(instance, connection)) | ||
| 100 | instances[instance] = system_domains[instance] | 99 | instances[instance] = system_domains[instance] | ||
| 101 | 100 | | |||
| 102 | return instances | 101 | return instances | ||
| 103 | 102 | | |||
| 104 | 103 | | |||
| 105 | class Instance(object): | 104 | class Instance(object): | ||
| 106 | """The Instance class handles the creation, location and customization | 105 | """Handles creating, starting, stopping and destroying virtual machines | ||
| 107 | of existing testCloud instances (which are qcow2 backed from an Image)""" | 106 | defined on the local system, using an existing :py:class:`Image`. | ||
| 107 | """ | ||||
| 108 | 108 | | |||
| 109 | def __init__(self, name, image=None): | 109 | def __init__(self, name, image=None): | ||
| 110 | self.name = name | 110 | self.name = name | ||
| 111 | self.image = image | 111 | self.image = image | ||
| 112 | self.path = "{}/instances/{}".format(config_data.DATA_DIR, self.name) | 112 | self.path = "{}/instances/{}".format(config_data.DATA_DIR, self.name) | ||
| 113 | self.seed_path = "{}/{}-seed.img".format(self.path, self.name) | 113 | self.seed_path = "{}/{}-seed.img".format(self.path, self.name) | ||
| 114 | self.meta_path = "{}/meta".format(self.path) | 114 | self.meta_path = "{}/meta".format(self.path) | ||
| 115 | self.local_disk = "{}/{}-local.qcow2".format(self.path, self.name) | 115 | self.local_disk = "{}/{}-local.qcow2".format(self.path, self.name) | ||
| 116 | 116 | | |||
| 117 | self.ram = 512 | 117 | self.ram = 512 | ||
| 118 | self.vnc = False | 118 | self.vnc = False | ||
| 119 | self.graphics = False | 119 | self.graphics = False | ||
| 120 | self.atomic = False | 120 | self.atomic = False | ||
| 121 | self.seed = None | 121 | self.seed = None | ||
| 122 | self.kernel = None | 122 | self.kernel = None | ||
| 123 | self.initrd = None | 123 | self.initrd = None | ||
| 124 | 124 | | |||
| 125 | # get rid of | 125 | # get rid of | ||
| 126 | self.backing_store = image.local_path if image else None | 126 | self.backing_store = image.local_path if image else None | ||
| 127 | self.image_path = config_data.CACHE_DIR + self.name + ".qcow2" | 127 | self.image_path = config_data.CACHE_DIR + self.name + ".qcow2" | ||
| 128 | 128 | | |||
| 129 | def prepare(self): | 129 | def prepare(self): | ||
| 130 | """Create local directories and metadata needed to spawn the instance | ||||
| 131 | """ | ||||
| 130 | # create the dirs needed for this instance | 132 | # create the dirs needed for this instance | ||
| 131 | self._create_dirs() | 133 | self._create_dirs() | ||
| 132 | 134 | | |||
| 133 | # generate metadata | 135 | # generate metadata | ||
| 134 | self._create_user_data(config_data.PASSWORD) | 136 | self._create_user_data(config_data.PASSWORD) | ||
| 135 | self._create_meta_data(config_data.HOSTNAME) | 137 | self._create_meta_data(config_data.HOSTNAME) | ||
| 136 | 138 | | |||
| 137 | # generate seed image | 139 | # generate seed image | ||
| ▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Line(s) | 197 | def _generate_seed_image(self): | |||
| 210 | else: | 212 | else: | ||
| 211 | log.error("Seed image generation failed. Exiting") | 213 | log.error("Seed image generation failed. Exiting") | ||
| 212 | raise TestCloudInstanceError("Failure during seed image generation") | 214 | raise TestCloudInstanceError("Failure during seed image generation") | ||
| 213 | 215 | | |||
| 214 | def _extract_initrd_and_kernel(self): | 216 | def _extract_initrd_and_kernel(self): | ||
| 215 | """Download the necessary kernel and initrd for booting a specified | 217 | """Download the necessary kernel and initrd for booting a specified | ||
| 216 | cloud image.""" | 218 | cloud image.""" | ||
| 217 | 219 | | |||
| 218 | # still need to figure out if the image needs to be copied from | | |||
| 219 | # cache for each instance | | |||
| 220 | # for now, assuming that it doesn't | | |||
| 221 | | ||||
| 222 | if self.image is None: | 220 | if self.image is None: | ||
| 223 | raise TestCloudInstanceError("attempted to access image " | 221 | raise TestCloudInstanceError("attempted to access image " | ||
| 224 | "information for instance {} but " | 222 | "information for instance {} but " | ||
| 225 | "that information was not supplied " | 223 | "that information was not supplied " | ||
| 226 | "at creation time".format(self.name)) | 224 | "at creation time".format(self.name)) | ||
| 227 | 225 | | |||
| 228 | log.info("extracting kernel and initrd from {}".format(self.image.local_path)) | 226 | log.info("extracting kernel and initrd from {}".format(self.image.local_path)) | ||
| 229 | subprocess.call(['virt-builder', '--get-kernel', | 227 | subprocess.call(['virt-builder', '--get-kernel', | ||
| Show All 21 Lines | 248 | subprocess.call(['qemu-img', | |||
| 251 | 'create', | 249 | 'create', | ||
| 252 | '-f', | 250 | '-f', | ||
| 253 | 'qcow2', | 251 | 'qcow2', | ||
| 254 | '-b', | 252 | '-b', | ||
| 255 | self.image.local_path, | 253 | self.image.local_path, | ||
| 256 | self.local_disk | 254 | self.local_disk | ||
| 257 | ]) | 255 | ]) | ||
| 258 | 256 | | |||
| 259 | def spawn_vm(self, expand_disk=False): | 257 | def spawn_vm(self): | ||
| 260 | """Boot the cloud image redirecting local port 8888 to 80 on the vm as | 258 | """Create and boot the instance, using prepared data.""" | ||
| 261 | well as local port 2222 to 22 on the vm so http and ssh can be | | |||
| 262 | accessed. | | |||
| 263 | | ||||
| 264 | Pass True to expand_disk if booting a fresh atomic image or you want to | | |||
| 265 | grow the disk size for some other reason at boot. | | |||
| 266 | | ||||
| 267 | """ | | |||
| 268 | 259 | | |||
| 269 | boot_args = ['/usr/bin/virt-install', | 260 | boot_args = ['/usr/bin/virt-install', | ||
| 270 | '--connect', | 261 | '--connect', | ||
| 271 | 'qemu:///system', | 262 | 'qemu:///system', | ||
| 272 | '--import', | 263 | '--import', | ||
| 273 | '-n', | 264 | '-n', | ||
| 274 | self.name, | 265 | self.name, | ||
| 275 | '-r', | 266 | '-r', | ||
| 276 | str(self.ram), | 267 | str(self.ram), | ||
| 277 | '--os-type=linux', # This should be configurable later | 268 | '--os-type=linux', # This should be configurable later | ||
| 278 | '--disk', | 269 | '--disk', | ||
| 279 | '{},device=disk,bus=virtio,format=qcow2'.format( | 270 | '{},device=disk,bus=virtio,format=qcow2'.format( | ||
| 280 | self.local_disk), | 271 | self.local_disk), | ||
| 281 | '--disk', | 272 | '--disk', | ||
| 282 | '{},device=disk,bus=virtio'.format(self.seed_path), | 273 | '{},device=disk,bus=virtio'.format(self.seed_path), | ||
| 283 | ] | 274 | ] | ||
| 284 | 275 | | |||
| 285 | # Extend with the customizations from the config_data file | 276 | # Extend with the customizations from the config_data file | ||
| 286 | boot_args.extend(config_data.CMD_LINE_ARGS) | 277 | boot_args.extend(config_data.CMD_LINE_ARGS) | ||
| 287 | 278 | | |||
| 288 | # if expand_disk: | | |||
| 289 | # self.expand_qcow() | | |||
| 290 | # | | |||
| 291 | # if not self.atomic: | | |||
| 292 | # self.download_initrd_and_kernel() | | |||
| 293 | # | | |||
| 294 | # boot_args.extend(['--boot', | | |||
| 295 | # 'kernel={0},initrd={1},kernel_args={2}'.format( | | |||
| 296 | # self.kernel, | | |||
| 297 | # self.initrd, | | |||
| 298 | # '"root=/dev/vda1 ro ds=nocloud-net"'), | | |||
| 299 | # ]) | | |||
| 300 | # | | |||
| 301 | if self.graphics: | 279 | if self.graphics: | ||
| 302 | boot_args.extend(['--noautoconsole']) | 280 | boot_args.extend(['--noautoconsole']) | ||
| 303 | 281 | | |||
| 304 | if self.vnc: | 282 | if self.vnc: | ||
| 305 | boot_args.extend(['-vnc', '0.0.0.0:1']) | 283 | boot_args.extend(['-vnc', '0.0.0.0:1']) | ||
| 306 | 284 | | |||
| 307 | vm = subprocess.Popen(boot_args) | 285 | vm = subprocess.Popen(boot_args) | ||
| 308 | 286 | | |||
| 309 | log.info("Successfully booted your local cloud image!") | 287 | log.info("Successfully booted your local cloud image!") | ||
| 310 | log.info("PID: %d" % vm.pid) | 288 | log.info("PID: %d" % vm.pid) | ||
| 311 | 289 | | |||
| 312 | return vm | 290 | return vm | ||
| 313 | 291 | | |||
| 314 | def exists(self): | | |||
| 315 | """Check to see if this instance already exists.""" | | |||
| 316 | | ||||
| 317 | pass | | |||
| 318 | | ||||
| 319 | def expand_qcow(self, size="+10G"): | 292 | def expand_qcow(self, size="+10G"): | ||
| 320 | """Expand the storage for a qcow image. Currently only used for Atomic | 293 | """Expand the storage for a qcow image. Currently only used for Atomic | ||
| 321 | Hosts.""" | 294 | Hosts.""" | ||
| 322 | 295 | | |||
| 323 | log.info("expanding qcow2 image {}".format(self.image_path)) | 296 | log.info("expanding qcow2 image {}".format(self.image_path)) | ||
| 324 | subprocess.call(['qemu-img', | 297 | subprocess.call(['qemu-img', | ||
| 325 | 'resize', | 298 | 'resize', | ||
| 326 | self.image_path, | 299 | self.image_path, | ||
| ▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines | |||||
| 1 | #!/usr/bin/env python | 1 | #!/usr/bin/env python | ||
|---|---|---|---|---|---|
| 2 | # -*- coding: utf-8 -*- | 2 | # -*- coding: utf-8 -*- | ||
| 3 | # Copyright 2015, Red Hat, Inc. | 3 | # Copyright 2015, Red Hat, Inc. | ||
| 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | 4 | # License: GPL-2.0+ <http://spdx.org/licenses/GPL-2.0+> | ||
| 5 | # See the LICENSE file for more details on Licensing | 5 | # See the LICENSE file for more details on Licensing | ||
| 6 | 6 | | |||
| 7 | """ | 7 | """ | ||
| 8 | This module contains helper functions for the housekeeping tasks of testCloud. | 8 | This module contains helper functions for testCloud. | ||
| 9 | """ | 9 | """ | ||
| 10 | 10 | | |||
| 11 | import os | | |||
| 12 | import shutil | | |||
| 13 | import glob | | |||
| 14 | import subprocess | 11 | import subprocess | ||
| 15 | import logging | 12 | import logging | ||
| 16 | 13 | | |||
| 17 | import libvirt | 14 | import libvirt | ||
| 18 | import xml.etree.ElementTree as ET | 15 | import xml.etree.ElementTree as ET | ||
| 19 | 16 | | |||
| 20 | from . import config | 17 | from . import config | ||
| 21 | 18 | | |||
| 22 | log = logging.getLogger('testCloud.util') | 19 | log = logging.getLogger('testCloud.util') | ||
| 23 | config_data = config.get_config() | 20 | config_data = config.get_config() | ||
| 24 | 21 | | |||
| 25 | 22 | | |||
| 26 | def create_dirs(): | | |||
| 27 | """Create the dirs in the download dir we need to store things.""" | | |||
| 28 | os.makedirs(config_data.LOCAL_DOWNLOAD_DIR + 'testCloud/meta') | | |||
| 29 | if not os.path.exists(config_data.PRISTINE): | | |||
| 30 | os.makedirs(config_data.PRISTINE) | | |||
| 31 | log.debug("Created image store: {0}".format(config_data.PRISTINE)) | | |||
| 32 | return "Created tmp directories." | | |||
| 33 | | ||||
| 34 | | ||||
| 35 | def clean_dirs(): | | |||
| 36 | """Remove dirs after a test run.""" | | |||
| 37 | if os.path.exists(config_data.LOCAL_DOWNLOAD_DIR + 'testCloud'): | | |||
| 38 | shutil.rmtree(config_data.LOCAL_DOWNLOAD_DIR + 'testCloud') | | |||
| 39 | return "All cleaned up!" | | |||
| 40 | | ||||
| 41 | | ||||
| 42 | def list_pristine(): | | |||
| 43 | """List the pristine images currently saved.""" | | |||
| 44 | images = glob.glob(config_data.PRISTINE + '/*') | | |||
| 45 | for image in images: | | |||
| 46 | print('\t- {0}'.format(image.split('/')[-1])) | | |||
| 47 | | ||||
| 48 | | ||||
| 49 | def get_vm_xml(instance_name): | 23 | def get_vm_xml(instance_name): | ||
| 50 | """Query virsh for the xml of an instance by name.""" | 24 | """Query virsh for the xml of an instance by name.""" | ||
| 51 | 25 | | |||
| 52 | con = libvirt.openReadOnly('qemu:///system') | 26 | con = libvirt.openReadOnly('qemu:///system') | ||
| 53 | try: | 27 | try: | ||
| 54 | domain = con.lookupByName(instance_name) | 28 | domain = con.lookupByName(instance_name) | ||
| 55 | 29 | | |||
| 56 | except libvirt.libvirtError: | 30 | except libvirt.libvirtError: | ||
| Show All 27 Lines | |||||