Python compute.create_test_server函数代码示例

 def create_server(cls):
     tenant_network = cls.get_tenant_network()
     body, server = compute.create_test_server(
         cls.os, tenant_network=tenant_network, name=data_utils.rand_name("ceilometer-instance"), wait_until="ACTIVE"
     )
     cls.server_ids.append(body["id"])
     return body

    def test_reassign_port_between_servers(self):
        """Tests the following:

        1. Create a port in Neutron.
        2. Create two servers in Nova.
        3. Attach the port to the first server.
        4. Detach the port from the first server.
        5. Attach the port to the second server.
        6. Detach the port from the second server.
        """
        network = self.get_tenant_network()
        network_id = network['id']
        port = self.ports_client.create_port(network_id=network_id)
        port_id = port['port']['id']
        self.addCleanup(self.ports_client.delete_port, port_id)

        # create two servers
        _, servers = compute.create_test_server(
            self.os_primary, tenant_network=network,
            wait_until='ACTIVE', min_count=2)
        # add our cleanups for the servers since we bypassed the base class
        for server in servers:
            self.addCleanup(self.delete_server, server['id'])

        for server in servers:
            # attach the port to the server
            iface = self.interfaces_client.create_interface(
                server['id'], port_id=port_id)['interfaceAttachment']
            self._check_interface(iface, server_id=server['id'],
                                  port_id=port_id)

            # detach the port from the server; this is a cast in the compute
            # API so we have to poll the port until the device_id is unset.
            self.interfaces_client.delete_interface(server['id'], port_id)
            self.wait_for_port_detach(port_id)

    def create_test_server(cls, validatable=False, volume_backed=False,
                           **kwargs):
        """Wrapper utility that returns a test server.

        This wrapper utility calls the common create test server and
        returns a test server. The purpose of this wrapper is to minimize
        the impact on the code of the tests already using this
        function.

        :param validatable: Whether the server will be pingable or sshable.
        :param volume_backed: Whether the instance is volume backed or not.
        """
        if 'name' not in kwargs:
            kwargs['name'] = data_utils.rand_name(cls.__name__ + "-server")
        tenant_network = cls.get_tenant_network()
        body, servers = compute.create_test_server(
            cls.os,
            validatable,
            validation_resources=cls.validation_resources,
            tenant_network=tenant_network,
            volume_backed=volume_backed,
            **kwargs)

        cls.servers.extend(servers)

        return body

    def create_test_server(cls, validatable=False, volume_backed=False,
                           **kwargs):
        """Wrapper utility that returns a test server.

        This wrapper utility calls the common create test server and
        returns a test server. The purpose of this wrapper is to minimize
        the impact on the code of the tests already using this
        function.

        :param validatable: Whether the server will be pingable or sshable.
        :param volume_backed: Whether the instance is volume backed or not.
        """
        if 'name' not in kwargs:
            kwargs['name'] = data_utils.rand_name(cls.__name__ + "-server")

        request_version = api_version_request.APIVersionRequest(
            cls.request_microversion)
        v2_37_version = api_version_request.APIVersionRequest('2.37')

        # NOTE(snikitin): since microversion v2.37 'networks' field is required
        if request_version >= v2_37_version and 'networks' not in kwargs:
            kwargs['networks'] = 'none'

        tenant_network = cls.get_tenant_network()
        body, servers = compute.create_test_server(
            cls.os_primary,
            validatable,
            validation_resources=cls.validation_resources,
            tenant_network=tenant_network,
            volume_backed=volume_backed,
            **kwargs)

        cls.servers.extend(servers)

        return body

 def create_server(cls, name, **kwargs):
     tenant_network = cls.get_tenant_network()
     body, _ = compute.create_test_server(
         cls.os,
         tenant_network=tenant_network,
         name=name,
         **kwargs)
     return body

 def test_server_create_no_allocate(self):
     """Tests that no networking is allocated for the server."""
     # create the server with no networking
     server, _ = compute.create_test_server(self.os, networks="none", wait_until="ACTIVE")
     self.addCleanup(self.delete_server, server["id"])
     # get the server ips
     addresses = self.servers_client.list_addresses(server["id"])["addresses"]
     # assert that there is no networking
     self.assertEqual({}, addresses)

 def create_server(cls, validatable=False, volume_backed=False, **kwargs):
     tenant_network = cls.get_tenant_network()
     body, servers = compute.create_test_server(
         cls.os,
         validatable,
         validation_resources=cls.validation_resources,
         tenant_network=tenant_network,
         **kwargs)
     return body

 def create_server(cls):
     tenant_network = cls.get_tenant_network()
     body, server = compute.create_test_server(
         cls.os_primary,
         tenant_network=tenant_network,
         name=data_utils.rand_name('ceilometer-instance'),
         wait_until='ACTIVE')
     cls.server_ids.append(body['id'])
     return body

 def create_server(cls, name, **kwargs):
     tenant_network = cls.get_tenant_network()
     kwargs['availability_zone'] = CONF.volume.get('availability_zone')
     body, _ = compute.create_test_server(
         cls.os,
         tenant_network=tenant_network,
         name=name,
         **kwargs)
     return body

 def test_server_create_no_allocate(self):
     """Tests that no networking is allocated for the server."""
     # create the server with no networking
     server, _ = compute.create_test_server(
         self.os_primary, networks='none', wait_until='ACTIVE')
     self.addCleanup(self.delete_server, server['id'])
     # get the server ips
     addresses = self.servers_client.list_addresses(
         server['id'])['addresses']
     # assert that there is no networking
     self.assertEqual({}, addresses)

    def create_test_server(self, wait_until=None):
        flavors = self.flavors_client.list_flavors()['flavors']
        images = self.image_client.list_images()['images']
        tenant_network = self.get_tenant_network()
        body, servers = compute.create_test_server(
            self.os,
            wait_until=wait_until,
            image_id=images[0]['id'],
            flavor=flavors[0]['id'],
            tenant_network=tenant_network)

        server = self.os_primary.servers_client.show_server(body['id'])[
            'server']
        return server, flavors[0]

    def create_server(self, **kwargs):
        name = kwargs.get("name", data_utils.rand_name(self.__class__.__name__ + "-instance"))

        tenant_network = self.get_tenant_network()
        body, _ = compute.create_test_server(self.os, tenant_network=tenant_network, name=name, **kwargs)

        self.addCleanup(
            test_utils.call_and_ignore_notfound_exc,
            waiters.wait_for_server_termination,
            self.servers_client,
            body["id"],
        )
        self.addCleanup(test_utils.call_and_ignore_notfound_exc, self.servers_client.delete_server, body["id"])
        return body

 def test_multiple_create(self):
     tenant_network = self.get_tenant_network()
     body, servers = compute.create_test_server(
         self.os_primary,
         wait_until='ACTIVE',
         min_count=2,
         tenant_network=tenant_network)
     for server in servers:
         self.addCleanup(self.servers_client.delete_server, server['id'])
     # NOTE(maurosr): do status response check and also make sure that
     # reservation_id is not in the response body when the request send
     # contains return_reservation_id=False
     self.assertNotIn('reservation_id', body)
     self.assertEqual(2, len(servers))

    def create_test_server(cls, validatable=False, volume_backed=False,
                           validation_resources=None, **kwargs):
        """Wrapper utility that returns a test server.

        This wrapper utility calls the common create test server and
        returns a test server. The purpose of this wrapper is to minimize
        the impact on the code of the tests already using this
        function.

        :param validatable: Whether the server will be pingable or sshable.
        :param volume_backed: Whether the instance is volume backed or not.
        :param validation_resources: Dictionary of validation resources as
            returned by `get_class_validation_resources`.
        :param kwargs: Extra arguments are passed down to the
            `compute.create_test_server` call.
        """
        if 'name' not in kwargs:
            kwargs['name'] = data_utils.rand_name(cls.__name__ + "-server")

        request_version = api_version_request.APIVersionRequest(
            cls.request_microversion)
        v2_37_version = api_version_request.APIVersionRequest('2.37')

        tenant_network = cls.get_tenant_network()
        # NOTE(snikitin): since microversion v2.37 'networks' field is required
        if (request_version >= v2_37_version and 'networks' not in kwargs and
            not tenant_network):
            kwargs['networks'] = 'none'

        body, servers = compute.create_test_server(
            cls.os_primary,
            validatable,
            validation_resources=validation_resources,
            tenant_network=tenant_network,
            volume_backed=volume_backed,
            **kwargs)

        # For each server schedule wait and delete, so we first delete all
        # and then wait for all
        for server in servers:
            cls.addClassResourceCleanup(waiters.wait_for_server_termination,
                                        cls.servers_client, server['id'])
        for server in servers:
            cls.addClassResourceCleanup(
                test_utils.call_and_ignore_notfound_exc,
                cls.servers_client.delete_server, server['id'])

        return body

    def create_test_server(cls, validatable=False, **kwargs):
        """Wrapper utility that returns a test server.

        This wrapper utility calls the common create test server and
        returns a test server. The purpose of this wrapper is to minimize
        the impact on the code of the tests already using this
        function.
        """
        tenant_network = cls.get_tenant_network()
        body, servers = compute.create_test_server(
            cls.os, validatable, validation_resources=cls.validation_resources, tenant_network=tenant_network, **kwargs
        )

        cls.servers.extend(servers)

        return body