def _create_volume(self, size, **kwargs): """Create one volume. Returns when the volume is actually created and is in the "Available" state. :param size: int be size of volume in GB, or dictionary, must contain two values: min - minimum size volumes will be created as; max - maximum size volumes will be created as. :param kwargs: Other optional parameters to initialize the volume :returns: Created volume object """ kwargs["display_name"] = kwargs.get("display_name", self._generate_random_name()) if isinstance(size, dict): size = random.randint(size["min"], size["max"]) volume = self.clients("cinder").volumes.create(size, **kwargs) # NOTE(msdubov): It is reasonable to wait 5 secs before starting to # check whether the volume is ready => less API calls. time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay) volume = bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval, ) return volume
def _create_snapshot(self, volume_id, force=False, **kwargs): """Create one snapshot. Returns when the snapshot is actually created and is in the "Available" state. :param volume_id: volume uuid for creating snapshot :param force: flag to indicate whether to snapshot a volume even if it's attached to an instance :param kwargs: Other optional parameters to initialize the volume :returns: Created snapshot object """ kwargs["display_name"] = kwargs.get("display_name", self._generate_random_name()) kwargs["force"] = force snapshot = self.clients("cinder").volume_snapshots.create(volume_id, **kwargs) time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay) snapshot = bench_utils.wait_for( snapshot, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval ) return snapshot
def _create_volume(self, size, **kwargs): """create one volume. Returns when the volume is actually created and is in the "Available" state. :param size: int be size of volume in GB :param **kwargs: Other optional parameters to initialize the volume :returns: Created volume object """ kwargs["display_name"] = kwargs.get("display_name", self._generate_random_name()) volume = self.clients("cinder").volumes.create(size, **kwargs) # NOTE(msdubov): It is reasonable to wait 5 secs before starting to # check whether the volume is ready => less API calls. time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay) volume = bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval ) return volume
def _create_share(self, share_proto, size=1, **kwargs): """Create a share. :param share_proto: share protocol for new share, available values are NFS, CIFS, GlusterFS and HDFS. :param size: size of a share in GB :param snapshot_id: ID of the snapshot :param name: name of new share :param description: description of a share :param metadata: optional metadata to set on share creation :param share_network: either instance of ShareNetwork or str with ID :param share_type: either instance of ShareType or str with ID :param is_public: defines whether to set share as public or not. :returns: instance of :class:`Share` """ if (self.context and self.context.get("tenant", {}).get("share_networks", []) and not kwargs.get("share_network")): kwargs["share_network"] = next(self.context.get("tenant", {}).get( "sn_iterator")) if not kwargs.get("name"): kwargs["name"] = self._generate_random_name() share = self.clients("manila").shares.create( share_proto, size, **kwargs) time.sleep(CONF.benchmark.manila_share_create_prepoll_delay) share = bench_utils.wait_for( share, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.manila_share_create_timeout, check_interval=CONF.benchmark.manila_share_create_poll_interval, ) return share
def _create_image(self, image_name, container_format, image_url, disk_format, **kwargs): """Create a new image. :param image_name: String used to name the image :param container_format: Container format of image. Acceptable formats: ami, ari, aki, bare, and ovf. :param image_url: URL for download image :param disk_format: Disk format of image. Acceptable formats: ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, and iso. :param **kwargs: optional parameters to create image returns: object of image """ image = self.clients("glance").images.create( name=image_name, copy_from=image_url, container_format=container_format, disk_format=disk_format, **kwargs) time.sleep(CONF.benchmark.glance_image_create_prepoll_delay) image = bench_utils.wait_for( image, is_ready=bench_utils.resource_is("active"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.glance_image_create_timeout, check_interval=CONF.benchmark.glance_image_create_poll_interval) return image
def _boot_server(cls, server_name, image_id, flavor_id, **kwargs): """Boots one server. Returns when the server is actually booted and is in the "Active" state. :param server_name: String used to name the server :param image_id: ID of the image to be used for server creation :param flavor_id: ID of the flavor to be used for server creation :param **kwargs: Other optional parameters to initialize the server :returns: Created server object """ if 'security_groups' not in kwargs: kwargs['security_groups'] = ['rally_open'] else: if 'rally_open' not in kwargs['security_groups']: kwargs['security_groups'].append('rally_open') server = cls.clients("nova").servers.create( server_name, image_id, flavor_id, **kwargs) # NOTE(msdubov): It is reasonable to wait 5 secs before starting to # check whether the server is ready => less API calls. time.sleep(5) server = utils.wait_for(server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=600, check_interval=3) return server
def _create_stack(self, template): """Create a new stack. :param template: template with stack description. :returns: object of stack """ stack_name = self._generate_random_name() kw = { "stack_name": stack_name, "disable_rollback": True, "parameters": {}, "template": template, "files": {}, "environment": {} } # heat client returns body instead manager object, so we should # get manager object using stack_id stack_id = self.clients("heat").stacks.create(**kw)["stack"]["id"] stack = self.clients("heat").stacks.get(stack_id) time.sleep(CONF.benchmark.heat_stack_create_prepoll_delay) stack = bench_utils.wait_for( stack, is_ready=bench_utils.resource_is("CREATE_COMPLETE"), update_resource=bench_utils.get_from_manager(["CREATE_FAILED"]), timeout=CONF.benchmark.heat_stack_create_timeout, check_interval=CONF.benchmark.heat_stack_create_poll_interval) return stack
def _live_migrate(self, server, target_host, block_migration=False, disk_over_commit=False, skip_host_check=False): """Run live migration of the given server. :param server: Server object :param target_host: Specifies the target compute node to migrate :param block_migration: Specifies the migration type :param disk_over_commit: Specifies whether to overcommit migrated instance or not :param skip_host_check: Specifies whether to verify the targeted host availability """ server_admin = self.admin_clients("nova").servers.get(server.id) host_pre_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host") server_admin.live_migrate(target_host, block_migration=block_migration, disk_over_commit=disk_over_commit) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_live_migrate_timeout, check_interval=( CONF.benchmark.nova_server_live_migrate_poll_interval) ) server_admin = self.admin_clients("nova").servers.get(server.id) if (host_pre_migrate == getattr(server_admin, "OS-EXT-SRV-ATTR:host") and not skip_host_check): raise exceptions.LiveMigrateException( "Migration complete but instance did not change host: %s" % host_pre_migrate)
def _migrate(self, server, skip_host_check=False): """Run migration of the given server. :param server: Server object :param skip_host_check: Specifies whether to verify the targeted host availability """ server_admin = self.admin_clients("nova").servers.get(server.id) host_pre_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host") server_admin.migrate() bench_utils.wait_for( server, is_ready=bench_utils.resource_is("VERIFY_RESIZE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_migrate_timeout, check_interval=( CONF.benchmark.nova_server_migrate_poll_interval) ) if not skip_host_check: server_admin = self.admin_clients("nova").servers.get(server.id) host_after_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host") if host_pre_migrate == host_after_migrate: raise exceptions.MigrateException( "Migration complete but instance did not change host: %s" % host_pre_migrate)
def _update_stack(self, stack, template, parameters=None, files=None, environment=None): """Update an existing stack :param stack: stack that need to be updated :param template: Updated template :param parameters: template parameters for stack update :param files: additional files used in template :param environment: stack environment definition :returns: object of updated stack """ kw = { "stack_name": stack.stack_name, "disable_rollback": True, "parameters": parameters or {}, "template": template, "files": files or {}, "environment": environment or {} } self.clients("heat").stacks.update(stack.id, **kw) time.sleep(CONF.benchmark.heat_stack_update_prepoll_delay) stack = bench_utils.wait_for( stack, is_ready=bench_utils.resource_is("UPDATE_COMPLETE"), update_resource=bench_utils.get_from_manager(["UPDATE_FAILED"]), timeout=CONF.benchmark.heat_stack_update_timeout, check_interval=CONF.benchmark.heat_stack_update_poll_interval) return stack
def _boot_server(self, server_name, image_id, flavor_id, **kwargs): """Boots one server. Returns when the server is actually booted and is in the "Active" state. :param server_name: String used to name the server :param image_id: ID of the image to be used for server creation :param flavor_id: ID of the flavor to be used for server creation :param **kwargs: Other optional parameters to initialize the server :returns: Created server object """ if 'security_groups' not in kwargs: kwargs['security_groups'] = [secgroup.SSH_GROUP_NAME] else: if secgroup.SSH_GROUP_NAME not in kwargs['security_groups']: kwargs['security_groups'].append(secgroup.SSH_GROUP_NAME) server = self.clients("nova").servers.create(server_name, image_id, flavor_id, **kwargs) time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay) server = bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_boot_timeout, check_interval=CONF.benchmark.nova_server_boot_poll_interval ) return server
def _wait_for_ping(self, server_ip): server_ip = netaddr.IPAddress(server_ip) bench_utils.wait_for( server_ip, is_ready=bench_utils.resource_is(ICMP_UP_STATUS, self._ping_ip_address), timeout=120 )
def _wait_finish_of_deploy(self, environment): bench_utils.wait_for( environment, is_ready=bench_utils.resource_is("READY"), update_resource=bench_utils.get_from_manager(), timeout=1200.0, check_interval=5.0 )
def _do_server_reboot(self, server, reboottype): server.reboot(reboot_type=reboottype) time.sleep(CONF.benchmark.nova_server_reboot_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_reboot_timeout, check_interval=CONF.benchmark.nova_server_reboot_poll_interval )
def _resize(self, server, flavor): server.resize(flavor) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("VERIFY_RESIZE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_resize_timeout, check_interval=CONF.benchmark.nova_server_resize_poll_interval )
def _resize_revert(self, server, status="ACTIVE"): server.revert_resize() bench_utils.wait_for( server, is_ready=bench_utils.resource_is(status), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_resize_revert_timeout, check_interval=( CONF.benchmark.nova_server_resize_revert_poll_interval) )
def _resize_confirm(self, server): server.confirm_resize() bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_resize_confirm_timeout, check_interval=( CONF.benchmark.nova_server_resize_confirm_poll_interval) )
def _delete_image(cls, image): """Deletes the given image. Returns when the image is actually deleted. :param image: Image object """ image.delete() utils.wait_for(image, is_ready=bench_utils.resource_is("DELETED"), update_resource=bench_utils.get_from_manager(), timeout=600, check_interval=3)
def _stop_server(cls, server): """Stop the given server. Issues a stop on the given server and waits for the server to become SHUTOFF. :param server: The server to stop. """ server.stop() utils.wait_for(server, is_ready=bench_utils.resource_is("SHUTOFF"), update_resource=bench_utils.get_from_manager(), timeout=600, check_interval=2)
def _start_server(cls, server): """Starts the given server. A start will be issued for the given server upon which time this method will wait for it to become ACTIVE. :param server: The server to start and wait to become ACTIVE. """ server.start() utils.wait_for(server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=600, check_interval=2)
def _detach_volume(self, server, volume): server_id = server.id volume_id = volume.id self.clients("nova").volumes.delete_server_volume(server_id, volume_id) bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_detach_volume_timeout, check_interval=CONF.benchmark.nova_detach_volume_poll_interval )
def _unrescue_server(cls, server): """Unrescue the given server. Returns when the server is unrescue and waits to become ACTIVE :param server: Server object """ server.unrescue() time.sleep(2) utils.wait_for(server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=600, check_interval=3)
def _suspend_server(cls, server): """Suspends the given server. Returns when the server is actually suspended and is in the "Suspended" state. :param server: Server object """ server.suspend() time.sleep(2) utils.wait_for(server, is_ready=bench_utils.resource_is("SUSPENDED"), update_resource=bench_utils.get_from_manager(), timeout=600, check_interval=3)
def _rescue_server(cls, server): """Rescue the given server. Returns when the server is actually rescue and is in the "Rescue" state. :param server: Server object """ server.rescue() time.sleep(2) utils.wait_for(server, is_ready=bench_utils.resource_is("RESCUE"), update_resource=bench_utils.get_from_manager(), timeout=600, check_interval=3)
def _boot_server(self, server_name, image_id, flavor_id, auto_assign_nic=False, **kwargs): """Boots one server. Returns when the server is actually booted and is in the "Active" state. If multiple networks are present, the first network found that isn't associated with a floating IP pool is used. :param server_name: String used to name the server :param image_id: ID of the image to be used for server creation :param flavor_id: ID of the flavor to be used for server creation :param auto_assign_nic: Boolean for whether or not to assign NICs :param **kwargs: Other optional parameters to initialize the server :returns: Created server object """ allow_ssh_secgroup = self.context().get("allow_ssh") if allow_ssh_secgroup: if 'security_groups' not in kwargs: kwargs['security_groups'] = [allow_ssh_secgroup] elif allow_ssh_secgroup not in kwargs['security_groups']: kwargs['security_groups'].append(allow_ssh_secgroup) nics = kwargs.get('nics', False) if auto_assign_nic and nics is False: nets = self.clients("nova").networks.list() fip_pool = [ pool.name for pool in self.clients("nova").floating_ip_pools.list() ] for net in nets: if net.label not in fip_pool: kwargs['nics'] = [{'net-id': net.id}] break server = self.clients("nova").servers.create(server_name, image_id, flavor_id, **kwargs) time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay) server = bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_boot_timeout, check_interval=CONF.benchmark.nova_server_boot_poll_interval ) return server
def _upload_volume_to_image(self, volume, force=False, container_format="bare", disk_format="raw"): """Upload the given volume to image. Returns created image. :param volume: volume object :param force: flag to indicate whether to snapshot a volume even if it's attached to an instance :param container_format: container format of image. Acceptable formats: ami, ari, aki, bare, and ovf :param: disk_format: disk format of image. Acceptable formats: ami, ari, aki, vhd, vmdk, raw, qcow2, vdi and iso :returns: Returns created image object """ resp, img = volume.upload_to_image(force, self._generate_random_name(), container_format, disk_format) # NOTE (e0ne): upload_to_image changes volume status to uploading so # we need to wait until it will be available. volume = bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval ) image_id = img["os-volume_upload_image"]["image_id"] image = self.clients("glance").images.get(image_id) image = bench_utils.wait_for( image, is_ready=bench_utils.resource_is("active"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.glance_image_create_prepoll_delay, check_interval=CONF.benchmark.glance_image_create_poll_interval ) return image
def _resume_stack(self, stack): """Resume given stack. :param stack: stack that needs to be resumed """ self.clients("heat").actions.resume(stack.id) bench_utils.wait_for( stack, is_ready=bench_utils.resource_is("RESUME_COMPLETE"), update_resource=bench_utils.get_from_manager( ["RESUME_FAILED"]), timeout=CONF.benchmark.heat_stack_resume_timeout, check_interval=CONF.benchmark.heat_stack_resume_poll_interval)
def _deploy_environment(self, environment, session): """Deploy environment. :param environment: Environment instance :param session: Session instance """ self.clients("murano").sessions.deploy(environment.id, session.id) bench_utils.wait_for( environment, is_ready=bench_utils.resource_is("READY"), update_resource=bench_utils.get_from_manager(["DEPLOY FAILURE"]), timeout=CONF.benchmark.deploy_environment_timeout, check_interval=CONF.benchmark.deploy_environment_check_interval )
def _create_backup(self, volume_id, **kwargs): """Create a volume backup of the given volume. :param volume_id: The ID of the volume to backup. :param kwargs: Other optional parameters """ backup = self.clients("cinder").backups.create(volume_id, **kwargs) return bench_utils.wait_for( backup, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval )
def _attach_volume(self, server, volume, device=None): server_id = server.id volume_id = volume.id self.clients("nova").volumes.create_server_volume(server_id, volume_id, device) bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("in-use"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_resize_revert_timeout, check_interval=( CONF.benchmark.nova_server_resize_revert_poll_interval) )
def _unrescue_server(self, server): """Unrescue the given server. Returns when the server is unrescue and waits to become ACTIVE :param server: Server object """ server.unrescue() time.sleep(CONF.benchmark.nova_server_unrescue_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_unrescue_timeout, check_interval=CONF.benchmark.nova_server_unrescue_poll_interval )
def _stop_server(self, server): """Stop the given server. Issues a stop on the given server and waits for the server to become SHUTOFF. :param server: The server to stop. """ server.stop() bench_utils.wait_for( server, is_ready=bench_utils.resource_is("SHUTOFF"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_stop_timeout, check_interval=CONF.benchmark.nova_server_stop_poll_interval )
def _start_server(self, server): """Start the given server. A start will be issued for the given server upon which time this method will wait for it to become ACTIVE. :param server: The server to start and wait to become ACTIVE. """ server.start() bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_start_timeout, check_interval=CONF.benchmark.nova_server_start_poll_interval )
def _extend_volume(self, volume, new_size): """Extend the given volume. Returns when the volume is actually extended. :param volume: volume object :param new_size: new volume size in GB """ volume.extend(volume, new_size) volume = bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval)
def _rebuild_server(self, server, image, **kwargs): """Rebuild a server with a new image. :param server: The server to rebuild. :param image: The new image to rebuild the server with. :param kwargs: Optional additional arguments to pass to the rebuild """ server.rebuild(image, **kwargs) time.sleep(CONF.benchmark.nova_server_rebuild_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_rebuild_timeout, check_interval=CONF.benchmark.nova_server_rebuild_poll_interval)
def _boot_server(self, image_id, flavor_id, auto_assign_nic=False, name=None, **kwargs): """Boot a server. Returns when the server is actually booted and in "ACTIVE" state. If multiple networks are present, the first network found that isn't associated with a floating IP pool is used. :param image_id: int, image ID for server creation :param flavor_id: int, flavor ID for server creation :param auto_assign_nic: bool, whether or not to auto assign NICs :param name: str, server name :param kwargs: other optional parameters to initialize the server :returns: nova Server instance """ server_name = name or self._generate_random_name() secgroup = self.context.get("user", {}).get("secgroup") if secgroup: if "security_groups" not in kwargs: kwargs["security_groups"] = [secgroup["name"]] elif secgroup["name"] not in kwargs["security_groups"]: kwargs["security_groups"].append(secgroup["name"]) if auto_assign_nic and not kwargs.get("nics", False): nets = [net["id"] for net in self.context.get("tenant", {}).get("networks", [])] if nets: # NOTE(amaretskiy): Balance servers among networks: # divmod(iteration % tenants_num, nets_num)[1] net_idx = divmod( (self.context["iteration"] % self.context["config"]["users"]["tenants"]), len(nets))[1] kwargs["nics"] = [{"net-id": nets[net_idx]}] server = self.clients("nova").servers.create( server_name, image_id, flavor_id, **kwargs) time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay) server = bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_boot_timeout, check_interval=CONF.benchmark.nova_server_boot_poll_interval ) return server
def _suspend_server(self, server): """Suspends the given server. Returns when the server is actually suspended and is in the "Suspended" state. :param server: Server object """ server.suspend() time.sleep(CONF.benchmark.nova_server_suspend_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("SUSPENDED"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_suspend_timeout, check_interval=CONF.benchmark.nova_server_suspend_poll_interval )
def _rescue_server(self, server): """Rescue the given server. Returns when the server is actually rescue and is in the "Rescue" state. :param server: Server object """ server.rescue() time.sleep(CONF.benchmark.nova_server_rescue_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("RESCUE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_rescue_timeout, check_interval=CONF.benchmark.nova_server_rescue_poll_interval )
def _set_alarm_state(self, alarm, state, timeout): """Set the state of the alarm. :param alarm: alarm instance :param state: an alarm state to be set :param timeout: The number of seconds for which to attempt a successful check of the alarm state. :returns: alarm in the set state """ self.clients("ceilometer").alarms.set_state(alarm.alarm_id, state) return bench_utils.wait_for( alarm, is_ready=bench_utils.resource_is(state), update_resource=bench_utils.get_from_manager(), timeout=timeout, check_interval=1)
def _unpause_server(self, server): """Unpause the paused server. Returns when the server is actually unpaused and is in the "ACTIVE" state. :param server: Server object """ server.unpause() time.sleep(CONF.benchmark.nova_server_unpause_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_unpause_timeout, check_interval=CONF.benchmark.nova_server_unpause_poll_interval )
def _shelve_server(self, server): """Shelve the given server. Returns when the server is actually shelved and is in the "SHELVED_OFFLOADED" state. :param server: Server object """ server.shelve() time.sleep(CONF.benchmark.nova_server_shelve_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("SHELVED_OFFLOADED"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_shelve_timeout, check_interval=CONF.benchmark.nova_server_shelve_poll_interval )
def _boot_servers(self, image_id, flavor_id, requests, name_prefix=None, instances_amount=1, **kwargs): """Boot multiple servers. Returns when all the servers are actually booted and are in the "Active" state. :param image_id: ID of the image to be used for server creation :param flavor_id: ID of the flavor to be used for server creation :param requests: Number of booting requests to perform :param name_prefix: The prefix to use while naming the created servers. The rest of the server names will be '_<number>' :param instances_amount: Number of instances to boot per each request :returns: List of created server objects """ if not name_prefix: name_prefix = self._generate_random_name() for i in range(requests): self.clients("nova").servers.create("%s_%d" % (name_prefix, i), image_id, flavor_id, min_count=instances_amount, max_count=instances_amount, **kwargs) # NOTE(msdubov): Nova python client returns only one server even when # min_count > 1, so we have to rediscover all the # created servers manually. servers = filter(lambda server: server.name.startswith(name_prefix), self.clients("nova").servers.list()) time.sleep(CONF.benchmark.nova_server_boot_prepoll_delay) servers = [ bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_boot_timeout, check_interval=CONF.benchmark.nova_server_boot_poll_interval) for server in servers ] return servers
def test_wait_for_timeout_failure(self): self.resource.name = "fake_name" self.resource.id = "fake_id" self.resource.status = "fake_stale_status" is_ready = utils.resource_is("fake_new_status") exc = self.assertRaises(exceptions.TimeoutException, utils.wait_for, self.resource, is_ready, self.fake_updater, self.load_secs, self.load_secs / 3) self.assertEqual(exc.kwargs["resource_name"], "fake_name") self.assertEqual(exc.kwargs["resource_id"], "fake_id") self.assertEqual(exc.kwargs["desired_status"], "fake_new_status") self.assertEqual(exc.kwargs["resource_status"], "FAKE_STALE_STATUS") self.assertIn("FakeResource", str(exc)) self.assertIn("fake_new_status", str(exc))
def _create_image(self, image_name, container_format, image_location, disk_format, **kwargs): """Create a new image. :param image_name: String used to name the image :param container_format: Container format of image. Acceptable formats: ami, ari, aki, bare, and ovf. :param image_location: image file location used to upload :param disk_format: Disk format of image. Acceptable formats: ami, ari, aki, vhd, vmdk, raw, qcow2, vdi, and iso. :param **kwargs: optional parameters to create image returns: object of image """ kw = { "name": image_name, "container_format": container_format, "disk_format": disk_format, } kw.update(kwargs) try: if os.path.isfile(image_location): kw["data"] = open(image_location) else: kw["copy_from"] = image_location image = self.clients("glance").images.create(**kw) time.sleep(CONF.benchmark.glance_image_create_prepoll_delay) image = bench_utils.wait_for( image, is_ready=bench_utils.resource_is("active"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.glance_image_create_timeout, check_interval=CONF.benchmark.glance_image_create_poll_interval ) finally: if "data" in kw: kw["data"].close() return image
def _reboot_server(self, server, soft=True): """Reboots the given server using hard or soft reboot. A reboot will be issued on the given server upon which time this method will wait for the server to become active. :param server: The server to reboot. :param soft: False if hard reboot should be used, otherwise soft reboot is done (default). """ server.reboot(reboot_type=("SOFT" if soft else "HARD")) time.sleep(CONF.benchmark.nova_server_reboot_prepoll_delay) bench_utils.wait_for( server, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_reboot_timeout, check_interval=CONF.benchmark.nova_server_reboot_poll_interval)
def create_servers(self): """Create VMs with chosen image.""" image_uuid = self.get_image_uuid() userdata = self.get_userdata() flavor = self.config['flavor_id'] nics = self.get_nics() keypair, public_key_path = self.create_keypair() os_servers = [] for i in range(self.config.get('amount', 1)): name = "%s-%d" % (self.config['deployment_name'], i) server = self.nova.servers.create(name, image_uuid, flavor, nics=nics, key_name=keypair.name, userdata=userdata) os_servers.append(server) self.resources.create({'id': server.id}, type=SERVER_TYPE) kwargs = { 'is_ready': benchmark_utils.resource_is("ACTIVE"), 'update_resource': benchmark_utils.get_from_manager(), 'timeout': 120, 'check_interval': 5 } for os_server in os_servers: benchmark_utils.wait_for(os_server, **kwargs) servers = [ provider.Server(host=s.addresses.values()[0][0]['addr'], user='******', key=public_key_path) for s in os_servers ] for s in servers: s.ssh.wait(timeout=120, interval=5) # NOTE(eyerediskin): usually ssh is ready much earlier then cloud-init time.sleep(8) return servers
def _create_image(self, server): """Creates an image of the given server Uses the server name to name the created image. Returns when the image is actually created and is in the "Active" state. :param server: Server object for which the image will be created :returns: Created image object """ image_uuid = self.clients("nova").servers.create_image( server, server.name) image = self.clients("nova").images.get(image_uuid) check_interval = CONF.benchmark.nova_server_image_create_poll_interval image = bench_utils.wait_for( image, is_ready=bench_utils.resource_is("ACTIVE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_image_create_timeout, check_interval=check_interval) return image
def _create_stack(self, template, parameters=None, files=None, environment=None): """Create a new stack. :param template: template with stack description. :param parameters: template parameters used during stack creation :param files: additional files used in template :param environment: stack environment definition :returns: object of stack """ stack_name = self._generate_random_name(prefix="rally_stack_") kw = { "stack_name": stack_name, "disable_rollback": True, "parameters": parameters or {}, "template": template, "files": files or {}, "environment": environment or {} } # heat client returns body instead manager object, so we should # get manager object using stack_id stack_id = self.clients("heat").stacks.create(**kw)["stack"]["id"] stack = self.clients("heat").stacks.get(stack_id) time.sleep(CONF.benchmark.heat_stack_create_prepoll_delay) stack = bench_utils.wait_for( stack, is_ready=bench_utils.resource_is("CREATE_COMPLETE"), update_resource=bench_utils.get_from_manager(["CREATE_FAILED"]), timeout=CONF.benchmark.heat_stack_create_timeout, check_interval=CONF.benchmark.heat_stack_create_poll_interval) return stack
def _extend_volume(self, volume, new_size): """Extend the given volume. Returns when the volume is actually extended. :param volume: volume object :param new_size: new volume size in GB, or dictionary, must contain two values: min - minimum size volumes will be created as; max - maximum size volumes will be created as. Notice: should be bigger volume size """ if isinstance(new_size, dict): new_size = random.randint(new_size["min"], new_size["max"]) volume.extend(volume, new_size) volume = bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval)
def _create_volume(self, size, **kwargs): """Create one volume. Returns when the volume is actually created and is in the "Available" state. :param size: int be size of volume in GB :param kwargs: Other optional parameters to initialize the volume :returns: Created volume object """ kwargs["display_name"] = kwargs.get("display_name", self._generate_random_name()) volume = self.clients("cinder").volumes.create(size, **kwargs) # NOTE(msdubov): It is reasonable to wait 5 secs before starting to # check whether the volume is ready => less API calls. time.sleep(CONF.benchmark.cinder_volume_create_prepoll_delay) volume = bench_utils.wait_for( volume, is_ready=bench_utils.resource_is("available"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.cinder_volume_create_timeout, check_interval=CONF.benchmark.cinder_volume_create_poll_interval) return volume
def _migrate(self, server, skip_host_check=False): """Run migration of the given server. :param server: Server object :param skip_host_check: Specifies whether to verify the targeted host availability """ server_admin = self.admin_clients("nova").servers.get(server.id) host_pre_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host") server_admin.migrate() bench_utils.wait_for( server, is_ready=bench_utils.resource_is("VERIFY_RESIZE"), update_resource=bench_utils.get_from_manager(), timeout=CONF.benchmark.nova_server_migrate_timeout, check_interval=(CONF.benchmark.nova_server_migrate_poll_interval)) if not skip_host_check: server_admin = self.admin_clients("nova").servers.get(server.id) host_after_migrate = getattr(server_admin, "OS-EXT-SRV-ATTR:host") if host_pre_migrate == host_after_migrate: raise exceptions.MigrateException( "Migration complete but instance did not change host: %s" % host_pre_migrate)
def test_resource_is_with_fake_status_getter(self): fake_getter = mock.MagicMock(return_value="LGTM") fake_res = mock.MagicMock() is_lgtm = utils.resource_is("LGTM", fake_getter) self.assertTrue(is_lgtm(fake_res)) fake_getter.assert_called_once_with(fake_res)
def test_resource_is(self): is_active = utils.resource_is("ACTIVE") self.assertTrue(is_active(fakes.FakeResource(status="active"))) self.assertTrue(is_active(fakes.FakeResource(status="aCtIvE"))) self.assertFalse(is_active(fakes.FakeResource(status="ERROR")))
def _wait_for_ping(self, server_ip): server_ip = netaddr.IPAddress(server_ip) bench_utils.wait_for(server_ip, is_ready=bench_utils.resource_is( ICMP_UP_STATUS, self._ping_ip_address), timeout=120)