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()
        utils.wait_for_status(
            server,
            ready_statuses=["VERIFY_RESIZE"],
            update_resource=utils.get_from_manager(),
            timeout=CONF.openstack.nova_server_migrate_timeout,
            check_interval=(
                CONF.openstack.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.RallyException(
                    "Migration failed: Migration complete but instance"
                    " did not change host: %s" % host_pre_migrate)

    def _allow_access_share(self, share, access_type, access, access_level):
        """Allow access to a share

        :param share: :class:`Share`
        :param access_type: represents the access type (e.g: 'ip', 'domain'...)
        :param access: represents the object (e.g: '127.0.0.1'...)
        :param access_level: access level to the share (e.g: 'rw', 'ro')
        """
        access_result = share.allow(access_type, access, access_level)
        # Get access from the list of accesses of the share
        access = next(access for access in share.access_list()
                      if access.id == access_result["id"])

        fn = self._update_resource_in_allow_access_share(share,
                                                         access_result["id"])

        # We check if the access in that access_list has the active state
        utils.wait_for_status(
            access,
            ready_statuses=["active"],
            update_resource=fn,
            check_interval=CONF.openstack.manila_access_create_poll_interval,
            timeout=CONF.openstack.manila_access_create_timeout)

        return access_result

    def _live_migrate(self, server, block_migration=False,
                      disk_over_commit=False, skip_host_check=False):
        """Run live migration of the given server.

        :param server: Server object
        :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(block_migration=block_migration,
                                  disk_over_commit=disk_over_commit)
        utils.wait_for_status(
            server,
            ready_statuses=["ACTIVE"],
            update_resource=utils.get_from_manager(),
            timeout=CONF.openstack.nova_server_live_migrate_timeout,
            check_interval=(
                CONF.openstack.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.RallyException(
                "Live Migration failed: Migration complete "
                "but instance did not change host: %s" % host_pre_migrate)

 def delete_image(self, image):
     image.delete()
     utils.wait_for_status(
         image, ["deleted"],
         check_deletion=True,
         update_resource=utils.get_from_manager(),
         timeout=CONF.benchmark.glance_image_delete_timeout,
         check_interval=CONF.benchmark.glance_image_delete_poll_interval)

 def _wait_for_ping(self, server_ip):
     server = Host(server_ip)
     utils.wait_for_status(
         server,
         ready_statuses=[Host.ICMP_UP_STATUS],
         update_resource=Host.update_status,
         timeout=CONF.benchmark.vm_ping_timeout,
         check_interval=CONF.benchmark.vm_ping_poll_interval
     )

 def _resize(self, server, flavor):
     server.resize(flavor)
     utils.wait_for_status(
         server,
         ready_statuses=["VERIFY_RESIZE"],
         update_resource=utils.get_from_manager(),
         timeout=CONF.openstack.nova_server_resize_timeout,
         check_interval=CONF.openstack.nova_server_resize_poll_interval
     )

 def delete(self):
     client = self._client()
     client().images.delete(self.raw_resource.id)
     task_utils.wait_for_status(
         self.raw_resource, ["deleted"],
         check_deletion=True,
         update_resource=self._wrapper().get_image,
         timeout=CONF.benchmark.glance_image_delete_timeout,
         check_interval=CONF.benchmark.glance_image_delete_poll_interval)

 def _do_server_reboot(self, server, reboottype):
     server.reboot(reboot_type=reboottype)
     self.sleep_between(CONF.openstack.nova_server_pause_prepoll_delay)
     utils.wait_for_status(
         server,
         ready_statuses=["ACTIVE"],
         update_resource=utils.get_from_manager(),
         timeout=CONF.openstack.nova_server_reboot_timeout,
         check_interval=CONF.openstack.nova_server_reboot_poll_interval
     )

 def _resize_revert(self, server, status="ACTIVE"):
     server.revert_resize()
     utils.wait_for_status(
         server,
         ready_statuses=[status],
         update_resource=utils.get_from_manager(),
         timeout=CONF.openstack.nova_server_resize_revert_timeout,
         check_interval=(
             CONF.openstack.nova_server_resize_revert_poll_interval)
     )

 def delete(self):
     client = self._client()
     if self.raw_resource.status == "deactivated":
         glancev2 = glance_v2.GlanceV2Service(self.admin or self.user)
         glancev2.reactivate_image(self.raw_resource.id)
     client.delete_image(self.raw_resource.id)
     task_utils.wait_for_status(
         self.raw_resource, ["deleted"],
         check_deletion=True,
         update_resource=self._client().get_image,
         timeout=CONF.openstack.glance_image_delete_timeout,
         check_interval=CONF.openstack.glance_image_delete_poll_interval)

    def _delete_share_network(self, share_network):
        """Delete share network.

        :param share_network: instance of :class:`ShareNetwork`.
        """
        share_network.delete()
        utils.wait_for_status(
            share_network,
            ready_statuses=["deleted"],
            check_deletion=True,
            update_resource=utils.get_from_manager(),
            timeout=CONF.openstack.manila_share_delete_timeout,
            check_interval=CONF.openstack.manila_share_delete_poll_interval)

    def _shrink_share(self, share, new_size):
        """Shrink the given share

        :param share: :class:`Share`
        :param new_size: new size of the share
        """
        share.shrink(new_size)
        utils.wait_for_status(
            share,
            ready_statuses=["available"],
            update_resource=utils.get_from_manager(),
            timeout=CONF.openstack.manila_share_create_timeout,
            check_interval=CONF.openstack.manila_share_create_poll_interval)

 def _cleanup_images(self):
     glance_wrapper = glance.wrap(self.clients.glance, self)
     for image in self._created_images:
         LOG.debug("Deleting image '%s'" % image.name)
         self.clients.glance().images.delete(image.id)
         task_utils.wait_for_status(
             image, ["deleted", "pending_delete"],
             check_deletion=True,
             update_resource=glance_wrapper.get_image,
             timeout=CONF.benchmark.glance_image_delete_timeout,
             check_interval=CONF.benchmark.
             glance_image_delete_poll_interval)
         self._remove_opt_value_from_config("compute", image.id)

    def _delete_security_service(self, security_service):
        """Delete security service.

        :param security_service: instance of :class:`SecurityService`.
        """
        security_service.delete()
        utils.wait_for_status(
            security_service,
            ready_statuses=["deleted"],
            check_deletion=True,
            update_resource=utils.get_from_manager(),
            timeout=CONF.openstack.manila_share_delete_timeout,
            check_interval=CONF.openstack.manila_share_delete_poll_interval)

    def create_image(self, container_format, image_location,
                     disk_format, **kwargs):
        kw = {
            "container_format": container_format,
            "disk_format": disk_format,
        }
        kw.update(kwargs)
        if "name" not in kw:
            kw["name"] = self.owner.generate_random_name()
        if "is_public" in kw:
            LOG.warning("is_public is not supported by Glance v2, and is "
                        "deprecated in Rally v0.8.0")
            kw["visibility"] = "public" if kw.pop("is_public") else "private"

        image_location = os.path.expanduser(image_location)

        image = self.client.images.create(**kw)

        rutils.interruptable_sleep(CONF.openstack.
                                   glance_image_create_prepoll_delay)

        start = time.time()
        image = utils.wait_for_status(
            image, ["queued"],
            update_resource=self.get_image,
            timeout=CONF.openstack.glance_image_create_timeout,
            check_interval=CONF.openstack.
            glance_image_create_poll_interval)
        timeout = time.time() - start

        image_data = None
        response = None
        try:
            if os.path.isfile(image_location):
                image_data = open(image_location)
            else:
                response = requests.get(image_location, stream=True)
                image_data = response.raw
            self.client.images.upload(image.id, image_data)
        finally:
            if image_data is not None:
                image_data.close()
            if response is not None:
                response.close()

        return utils.wait_for_status(
            image, ["active"],
            update_resource=self.get_image,
            timeout=timeout,
            check_interval=CONF.openstack.
            glance_image_create_poll_interval)

    def _resume_stack(self, stack):
        """Resume given stack.

        :param stack: stack that needs to be resumed
        """

        self.clients("heat").actions.resume(stack.id)
        utils.wait_for_status(
            stack,
            ready_statuses=["RESUME_COMPLETE"],
            failure_statuses=["RESUME_FAILED", "ERROR"],
            update_resource=utils.get_from_manager(),
            timeout=CONF.openstack.heat_stack_resume_timeout,
            check_interval=CONF.openstack.heat_stack_resume_poll_interval)

 def _attach_volume(self, server, volume, device=None):
     server_id = server.id
     volume_id = volume.id
     attachment = self.clients("nova").volumes.create_server_volume(
         server_id, volume_id, device)
     utils.wait_for_status(
         volume,
         ready_statuses=["in-use"],
         update_resource=self._update_volume_resource,
         timeout=CONF.openstack.nova_server_resize_revert_timeout,
         check_interval=(
             CONF.openstack.nova_server_resize_revert_poll_interval)
     )
     return attachment

    def _delete_share(self, share):
        """Delete the given share.

        :param share: :class:`Share`
        """
        share.delete()
        error_statuses = ("error_deleting", )
        utils.wait_for_status(
            share,
            ready_statuses=["deleted"],
            check_deletion=True,
            update_resource=utils.get_from_manager(error_statuses),
            timeout=CONF.openstack.manila_share_delete_timeout,
            check_interval=CONF.openstack.manila_share_delete_poll_interval)

    def _suspend_stack(self, stack):
        """Suspend given stack.

        :param stack: stack that needs to be suspended
        """

        self.clients("heat").actions.suspend(stack.id)
        utils.wait_for_status(
            stack,
            ready_statuses=["SUSPEND_COMPLETE"],
            failure_statuses=["SUSPEND_FAILED", "ERROR"],
            update_resource=utils.get_from_manager(),
            timeout=CONF.openstack.heat_stack_suspend_timeout,
            check_interval=CONF.openstack.heat_stack_suspend_poll_interval)

 def _cleanup_images(self):
     image_service = image.Image(self.clients)
     for image_obj in self._created_images:
         LOG.debug("Deleting image '%s'." % image_obj.name)
         self.clients.glance().images.delete(image_obj.id)
         task_utils.wait_for_status(
             image_obj, ["deleted", "pending_delete"],
             check_deletion=True,
             update_resource=image_service.get_image,
             timeout=conf.CONF.openstack.glance_image_delete_timeout,
             check_interval=conf.CONF.openstack.
             glance_image_delete_poll_interval)
         LOG.debug("Image '%s' has been deleted." % image_obj.name)
         self._remove_opt_value_from_config("compute", image_obj.id)