예제 #1
0
 def _set_machine_id(self, client_factory, instance):
     """
     Set the machine id of the VM for guest tools to pick up and change
     the IP.
     """
     vm_ref = self._get_vm_ref_from_the_name(instance.name)
     if vm_ref is None:
         raise exception.InstanceNotFound(instance_id=instance.id)
     network = db.network_get_by_instance(context.get_admin_context(),
                                         instance['id'])
     mac_addr = instance.mac_address
     net_mask = network["netmask"]
     gateway = network["gateway"]
     ip_addr = db.instance_get_fixed_address(context.get_admin_context(),
                                         instance['id'])
     machine_id_chanfge_spec = \
         vm_util.get_machine_id_change_spec(client_factory, mac_addr,
                                     ip_addr, net_mask, gateway)
     LOG.debug(_("Reconfiguring VM instance %(name)s to set the machine id "
               "with ip - %(ip_addr)s") %
               ({'name': instance.name,
                'ip_addr': ip_addr}))
     reconfig_task = self._session._call_method(self._session._get_vim(),
                        "ReconfigVM_Task", vm_ref,
                        spec=machine_id_chanfge_spec)
     self._session._wait_for_task(instance.id, reconfig_task)
     LOG.debug(_("Reconfigured VM instance %(name)s to set the machine id "
               "with ip - %(ip_addr)s") %
               ({'name': instance.name,
                'ip_addr': ip_addr}))
예제 #2
0
파일: vmops.py 프로젝트: cp16net/reddwarf
    def _set_machine_id(self, client_factory, instance):
        """
        Set the machine id of the VM for guest tools to pick up and change
        the IP.
        """
        admin_context = context.get_admin_context()
        vm_ref = self._get_vm_ref_from_the_name(instance.name)
        if vm_ref is None:
            raise exception.InstanceNotFound(instance_id=instance.id)
        network = db.network_get_by_instance(context.get_admin_context(),
                                             instance['id'])
        mac_address = None
        if instance['mac_addresses']:
            mac_address = instance['mac_addresses'][0]['address']

        net_mask = network["netmask"]
        gateway = network["gateway"]
        broadcast = network["broadcast"]
        # TODO(vish): add support for dns2
        dns = network["dns1"]

        addresses = db.instance_get_fixed_addresses(admin_context,
                                                    instance['id'])
        ip_addr = addresses[0] if addresses else None

        machine_id_change_spec = \
            vm_util.get_machine_id_change_spec(client_factory, mac_address,
                                               ip_addr, net_mask, gateway,
                                               broadcast, dns)
        LOG.debug(
            _("Reconfiguring VM instance %(name)s to set the machine id "
              "with ip - %(ip_addr)s") % ({
                  'name': instance.name,
                  'ip_addr': ip_addr
              }))
        reconfig_task = self._session._call_method(self._session._get_vim(),
                                                   "ReconfigVM_Task",
                                                   vm_ref,
                                                   spec=machine_id_change_spec)
        self._session._wait_for_task(instance.id, reconfig_task)
        LOG.debug(
            _("Reconfigured VM instance %(name)s to set the machine id "
              "with ip - %(ip_addr)s") % ({
                  'name': instance.name,
                  'ip_addr': ip_addr
              }))
예제 #3
0
파일: vmops.py 프로젝트: YouthSun/nova
    def _set_machine_id(self, client_factory, instance):
        """
        Set the machine id of the VM for guest tools to pick up and change
        the IP.
        """
        admin_context = nova_context.get_admin_context()
        vm_ref = self._get_vm_ref_from_the_name(instance.name)
        if vm_ref is None:
            raise exception.InstanceNotFound(instance_id=instance.id)
        network = db.network_get_by_instance(nova_context.get_admin_context(),
                                            instance['id'])
        mac_address = None
        if instance['mac_addresses']:
            mac_address = instance['mac_addresses'][0]['address']

        net_mask = network["netmask"]
        gateway = network["gateway"]
        broadcast = network["broadcast"]
        # TODO(vish): add support for dns2
        dns = network["dns1"]

        addresses = db.instance_get_fixed_addresses(admin_context,
                                                    instance['id'])
        ip_addr = addresses[0] if addresses else None

        machine_id_change_spec = \
            vm_util.get_machine_id_change_spec(client_factory, mac_address,
                                               ip_addr, net_mask, gateway,
                                               broadcast, dns)
        LOG.debug(_("Reconfiguring VM instance %(name)s to set the machine id "
                  "with ip - %(ip_addr)s") %
                  ({'name': instance.name,
                   'ip_addr': ip_addr}))
        reconfig_task = self._session._call_method(self._session._get_vim(),
                           "ReconfigVM_Task", vm_ref,
                           spec=machine_id_change_spec)
        self._session._wait_for_task(instance.id, reconfig_task)
        LOG.debug(_("Reconfigured VM instance %(name)s to set the machine id "
                  "with ip - %(ip_addr)s") %
                  ({'name': instance.name,
                   'ip_addr': ip_addr}))
예제 #4
0
 def setup_compute_network(self, context, instance_id):
     """Sets up matching network for compute hosts."""
     network_ref = db.network_get_by_instance(context, instance_id)
     self.driver.ensure_vlan_bridge(network_ref['vlan'],
                                    network_ref['bridge'])
예제 #5
0
파일: vmops.py 프로젝트: cp16net/reddwarf
    def spawn(self, instance, network_info):
        """
        Creates a VM instance.

        Steps followed are:
        1. Create a VM with no disk and the specifics in the instance object
            like RAM size.
        2. Create a dummy vmdk of the size of the disk file that is to be
            uploaded. This is required just to create the metadata file.
        3. Delete the -flat.vmdk file created in the above step and retain
            the metadata .vmdk file.
        4. Upload the disk file.
        5. Attach the disk to the VM by reconfiguring the same.
        6. Power on the VM.
        """
        vm_ref = self._get_vm_ref_from_the_name(instance.name)
        if vm_ref:
            raise exception.InstanceExists(name=instance.name)

        client_factory = self._session._get_vim().client.factory
        service_content = self._session._get_vim().get_service_content()

        network = db.network_get_by_instance(context.get_admin_context(),
                                             instance['id'])

        net_name = network['bridge']

        def _check_if_network_bridge_exists():
            network_ref = \
                network_utils.get_network_with_the_name(self._session,
                                                        net_name)
            if network_ref is None:
                raise exception.NetworkNotFoundForBridge(bridge=net_name)
            return network_ref

        self.plug_vifs(instance, network_info)
        network_obj = _check_if_network_bridge_exists()

        def _get_datastore_ref():
            """Get the datastore list and choose the first local storage."""
            data_stores = self._session._call_method(
                vim_util, "get_objects", "Datastore",
                ["summary.type", "summary.name"])
            for elem in data_stores:
                ds_name = None
                ds_type = None
                for prop in elem.propSet:
                    if prop.name == "summary.type":
                        ds_type = prop.val
                    elif prop.name == "summary.name":
                        ds_name = prop.val
                # Local storage identifier
                if ds_type == "VMFS":
                    data_store_name = ds_name
                    return data_store_name

            if data_store_name is None:
                msg = _("Couldn't get a local Datastore reference")
                LOG.exception(msg)
                raise exception.Error(msg)

        data_store_name = _get_datastore_ref()

        def _get_image_properties():
            """
            Get the Size of the flat vmdk file that is there on the storage
            repository.
            """
            image_size, image_properties = \
                    vmware_images.get_vmdk_size_and_properties(
                                       instance.image_ref, instance)
            vmdk_file_size_in_kb = int(image_size) / 1024
            os_type = image_properties.get("vmware_ostype", "otherGuest")
            adapter_type = image_properties.get("vmware_adaptertype",
                                                "lsiLogic")
            return vmdk_file_size_in_kb, os_type, adapter_type

        vmdk_file_size_in_kb, os_type, adapter_type = _get_image_properties()

        def _get_vmfolder_and_res_pool_mors():
            """Get the Vm folder ref from the datacenter."""
            dc_objs = self._session._call_method(vim_util, "get_objects",
                                                 "Datacenter", ["vmFolder"])
            # There is only one default datacenter in a standalone ESX host
            vm_folder_mor = dc_objs[0].propSet[0].val

            # Get the resource pool. Taking the first resource pool coming our
            # way. Assuming that is the default resource pool.
            res_pool_mor = self._session._call_method(vim_util, "get_objects",
                                                      "ResourcePool")[0].obj
            return vm_folder_mor, res_pool_mor

        vm_folder_mor, res_pool_mor = _get_vmfolder_and_res_pool_mors()

        # Get the create vm config spec
        config_spec = vm_util.get_vm_create_spec(client_factory, instance,
                                                 data_store_name, net_name,
                                                 os_type, network_obj)

        def _execute_create_vm():
            """Create VM on ESX host."""
            LOG.debug(
                _("Creating VM with the name %s on the ESX  host") %
                instance.name)
            # Create the VM on the ESX host
            vm_create_task = self._session._call_method(
                self._session._get_vim(),
                "CreateVM_Task",
                vm_folder_mor,
                config=config_spec,
                pool=res_pool_mor)
            self._session._wait_for_task(instance.id, vm_create_task)

            LOG.debug(
                _("Created VM with the name %s on the ESX  host") %
                instance.name)

        _execute_create_vm()

        # Set the machine id for the VM for setting the IP
        self._set_machine_id(client_factory, instance)

        # Naming the VM files in correspondence with the VM instance name
        # The flat vmdk file name
        flat_uploaded_vmdk_name = "%s/%s-flat.vmdk" % (instance.name,
                                                       instance.name)
        # The vmdk meta-data file
        uploaded_vmdk_name = "%s/%s.vmdk" % (instance.name, instance.name)
        flat_uploaded_vmdk_path = vm_util.build_datastore_path(
            data_store_name, flat_uploaded_vmdk_name)
        uploaded_vmdk_path = vm_util.build_datastore_path(
            data_store_name, uploaded_vmdk_name)

        def _create_virtual_disk():
            """Create a virtual disk of the size of flat vmdk file."""
            # Create a Virtual Disk of the size of the flat vmdk file. This is
            # done just to generate the meta-data file whose specifics
            # depend on the size of the disk, thin/thick provisioning and the
            # storage adapter type.
            # Here we assume thick provisioning and lsiLogic for the adapter
            # type
            LOG.debug(
                _("Creating Virtual Disk of size  "
                  "%(vmdk_file_size_in_kb)s KB and adapter type  "
                  "%(adapter_type)s on the ESX host local store"
                  " %(data_store_name)s") % {
                      "vmdk_file_size_in_kb": vmdk_file_size_in_kb,
                      "adapter_type": adapter_type,
                      "data_store_name": data_store_name
                  })
            vmdk_create_spec = vm_util.get_vmdk_create_spec(
                client_factory, vmdk_file_size_in_kb, adapter_type)
            vmdk_create_task = self._session._call_method(
                self._session._get_vim(),
                "CreateVirtualDisk_Task",
                service_content.virtualDiskManager,
                name=uploaded_vmdk_path,
                datacenter=self._get_datacenter_name_and_ref()[0],
                spec=vmdk_create_spec)
            self._session._wait_for_task(instance.id, vmdk_create_task)
            LOG.debug(
                _("Created Virtual Disk of size %(vmdk_file_size_in_kb)s"
                  " KB on the ESX host local store "
                  "%(data_store_name)s") % {
                      "vmdk_file_size_in_kb": vmdk_file_size_in_kb,
                      "data_store_name": data_store_name
                  })

        _create_virtual_disk()

        def _delete_disk_file():
            LOG.debug(
                _("Deleting the file %(flat_uploaded_vmdk_path)s "
                  "on the ESX host local"
                  "store %(data_store_name)s") % {
                      "flat_uploaded_vmdk_path": flat_uploaded_vmdk_path,
                      "data_store_name": data_store_name
                  })
            # Delete the -flat.vmdk file created. .vmdk file is retained.
            vmdk_delete_task = self._session._call_method(
                self._session._get_vim(),
                "DeleteDatastoreFile_Task",
                service_content.fileManager,
                name=flat_uploaded_vmdk_path)
            self._session._wait_for_task(instance.id, vmdk_delete_task)
            LOG.debug(
                _("Deleted the file %(flat_uploaded_vmdk_path)s on the "
                  "ESX host local store %(data_store_name)s") % {
                      "flat_uploaded_vmdk_path": flat_uploaded_vmdk_path,
                      "data_store_name": data_store_name
                  })

        _delete_disk_file()

        cookies = self._session._get_vim().client.options.transport.cookiejar

        def _fetch_image_on_esx_datastore():
            """Fetch image from Glance to ESX datastore."""
            LOG.debug(
                _("Downloading image file data %(image_ref)s to the ESX "
                  "data store %(data_store_name)s") %
                ({
                    'image_ref': instance.image_ref,
                    'data_store_name': data_store_name
                }))
            # Upload the -flat.vmdk file whose meta-data file we just created
            # above
            vmware_images.fetch_image(
                instance.image_ref,
                instance,
                host=self._session._host_ip,
                data_center_name=self._get_datacenter_name_and_ref()[1],
                datastore_name=data_store_name,
                cookies=cookies,
                file_path=flat_uploaded_vmdk_name)
            LOG.debug(
                _("Downloaded image file data %(image_ref)s to the ESX "
                  "data store %(data_store_name)s") %
                ({
                    'image_ref': instance.image_ref,
                    'data_store_name': data_store_name
                }))

        _fetch_image_on_esx_datastore()

        vm_ref = self._get_vm_ref_from_the_name(instance.name)

        def _attach_vmdk_to_the_vm():
            """
            Attach the vmdk uploaded to the VM. VM reconfigure is done
            to do so.
            """
            vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_spec(
                client_factory, vmdk_file_size_in_kb, uploaded_vmdk_path,
                adapter_type)
            LOG.debug(
                _("Reconfiguring VM instance %s to attach the image "
                  "disk") % instance.name)
            reconfig_task = self._session._call_method(
                self._session._get_vim(),
                "ReconfigVM_Task",
                vm_ref,
                spec=vmdk_attach_config_spec)
            self._session._wait_for_task(instance.id, reconfig_task)
            LOG.debug(
                _("Reconfigured VM instance %s to attach the image "
                  "disk") % instance.name)

        _attach_vmdk_to_the_vm()

        def _power_on_vm():
            """Power on the VM."""
            LOG.debug(_("Powering on the VM instance %s") % instance.name)
            # Power On the VM
            power_on_task = self._session._call_method(
                self._session._get_vim(), "PowerOnVM_Task", vm_ref)
            self._session._wait_for_task(instance.id, power_on_task)
            LOG.debug(_("Powered on the VM instance %s") % instance.name)

        _power_on_vm()
예제 #6
0
파일: manager.py 프로젝트: superstack/nova
 def setup_compute_network(self, context, instance_id):
     """Sets up matching network for compute hosts."""
     network_ref = db.network_get_by_instance(context, instance_id)
     self.driver.ensure_vlan_bridge(network_ref['vlan'],
                                    network_ref['bridge'])
예제 #7
0
파일: vmops.py 프로젝트: superstack/nova
    def spawn(self, instance):
        """
        Creates a VM instance.

        Steps followed are:
        1. Create a VM with no disk and the specifics in the instance object
            like RAM size.
        2. Create a dummy vmdk of the size of the disk file that is to be
            uploaded. This is required just to create the metadata file.
        3. Delete the -flat.vmdk file created in the above step and retain
            the metadata .vmdk file.
        4. Upload the disk file.
        5. Attach the disk to the VM by reconfiguring the same.
        6. Power on the VM.
        """
        vm_ref = self._get_vm_ref_from_the_name(instance.name)
        if vm_ref:
            raise exception.InstanceExists(name=instance.name)

        client_factory = self._session._get_vim().client.factory
        service_content = self._session._get_vim().get_service_content()

        network = db.network_get_by_instance(context.get_admin_context(),
                                            instance['id'])

        net_name = network['bridge']

        def _check_if_network_bridge_exists():
            network_ref = \
                network_utils.get_network_with_the_name(self._session,
                                                        net_name)
            if network_ref is None:
                raise exception.NetworkNotFoundForBridge(bridge=net_name)

        _check_if_network_bridge_exists()

        def _get_datastore_ref():
            """Get the datastore list and choose the first local storage."""
            data_stores = self._session._call_method(vim_util, "get_objects",
                        "Datastore", ["summary.type", "summary.name"])
            for elem in data_stores:
                ds_name = None
                ds_type = None
                for prop in elem.propSet:
                    if prop.name == "summary.type":
                        ds_type = prop.val
                    elif prop.name == "summary.name":
                        ds_name = prop.val
                # Local storage identifier
                if ds_type == "VMFS":
                    data_store_name = ds_name
                    return data_store_name

            if data_store_name is None:
                msg = _("Couldn't get a local Datastore reference")
                LOG.exception(msg)
                raise exception.Error(msg)

        data_store_name = _get_datastore_ref()

        def _get_image_properties():
            """
            Get the Size of the flat vmdk file that is there on the storage
            repository.
            """
            image_size, image_properties = \
                    vmware_images.get_vmdk_size_and_properties(
                                       instance.image_id, instance)
            vmdk_file_size_in_kb = int(image_size) / 1024
            os_type = image_properties.get("vmware_ostype", "otherGuest")
            adapter_type = image_properties.get("vmware_adaptertype",
                                                "lsiLogic")
            return vmdk_file_size_in_kb, os_type, adapter_type

        vmdk_file_size_in_kb, os_type, adapter_type = _get_image_properties()

        def _get_vmfolder_and_res_pool_mors():
            """Get the Vm folder ref from the datacenter."""
            dc_objs = self._session._call_method(vim_util, "get_objects",
                                    "Datacenter", ["vmFolder"])
            # There is only one default datacenter in a standalone ESX host
            vm_folder_mor = dc_objs[0].propSet[0].val

            # Get the resource pool. Taking the first resource pool coming our
            # way. Assuming that is the default resource pool.
            res_pool_mor = self._session._call_method(vim_util, "get_objects",
                                    "ResourcePool")[0].obj
            return vm_folder_mor, res_pool_mor

        vm_folder_mor, res_pool_mor = _get_vmfolder_and_res_pool_mors()

        # Get the create vm config spec
        config_spec = vm_util.get_vm_create_spec(client_factory, instance,
                                data_store_name, net_name, os_type)

        def _execute_create_vm():
            """Create VM on ESX host."""
            LOG.debug(_("Creating VM with the name %s on the ESX  host") %
                      instance.name)
            # Create the VM on the ESX host
            vm_create_task = self._session._call_method(
                                    self._session._get_vim(),
                                    "CreateVM_Task", vm_folder_mor,
                                    config=config_spec, pool=res_pool_mor)
            self._session._wait_for_task(instance.id, vm_create_task)

            LOG.debug(_("Created VM with the name %s on the ESX  host") %
                      instance.name)

        _execute_create_vm()

        # Set the machine id for the VM for setting the IP
        self._set_machine_id(client_factory, instance)

        # Naming the VM files in correspondence with the VM instance name
        # The flat vmdk file name
        flat_uploaded_vmdk_name = "%s/%s-flat.vmdk" % (instance.name,
                                                       instance.name)
        # The vmdk meta-data file
        uploaded_vmdk_name = "%s/%s.vmdk" % (instance.name, instance.name)
        flat_uploaded_vmdk_path = vm_util.build_datastore_path(data_store_name,
                                            flat_uploaded_vmdk_name)
        uploaded_vmdk_path = vm_util.build_datastore_path(data_store_name,
                                            uploaded_vmdk_name)

        def _create_virtual_disk():
            """Create a virtual disk of the size of flat vmdk file."""
            # Create a Virtual Disk of the size of the flat vmdk file. This is
            # done just to generate the meta-data file whose specifics
            # depend on the size of the disk, thin/thick provisioning and the
            # storage adapter type.
            # Here we assume thick provisioning and lsiLogic for the adapter
            # type
            LOG.debug(_("Creating Virtual Disk of size  "
                      "%(vmdk_file_size_in_kb)s KB and adapter type  "
                      "%(adapter_type)s on the ESX host local store"
                      " %(data_store_name)s") %
                       {"vmdk_file_size_in_kb": vmdk_file_size_in_kb,
                        "adapter_type": adapter_type,
                        "data_store_name": data_store_name})
            vmdk_create_spec = vm_util.get_vmdk_create_spec(client_factory,
                                    vmdk_file_size_in_kb, adapter_type)
            vmdk_create_task = self._session._call_method(
                self._session._get_vim(),
                "CreateVirtualDisk_Task",
                service_content.virtualDiskManager,
                name=uploaded_vmdk_path,
                datacenter=self._get_datacenter_name_and_ref()[0],
                spec=vmdk_create_spec)
            self._session._wait_for_task(instance.id, vmdk_create_task)
            LOG.debug(_("Created Virtual Disk of size %(vmdk_file_size_in_kb)s"
                        " KB on the ESX host local store "
                        "%(data_store_name)s") %
                        {"vmdk_file_size_in_kb": vmdk_file_size_in_kb,
                         "data_store_name": data_store_name})

        _create_virtual_disk()

        def _delete_disk_file():
            LOG.debug(_("Deleting the file %(flat_uploaded_vmdk_path)s "
                        "on the ESX host local"
                        "store %(data_store_name)s") %
                        {"flat_uploaded_vmdk_path": flat_uploaded_vmdk_path,
                         "data_store_name": data_store_name})
            # Delete the -flat.vmdk file created. .vmdk file is retained.
            vmdk_delete_task = self._session._call_method(
                        self._session._get_vim(),
                        "DeleteDatastoreFile_Task",
                        service_content.fileManager,
                        name=flat_uploaded_vmdk_path)
            self._session._wait_for_task(instance.id, vmdk_delete_task)
            LOG.debug(_("Deleted the file %(flat_uploaded_vmdk_path)s on the "
                        "ESX host local store %(data_store_name)s") %
                        {"flat_uploaded_vmdk_path": flat_uploaded_vmdk_path,
                         "data_store_name": data_store_name})

        _delete_disk_file()

        cookies = self._session._get_vim().client.options.transport.cookiejar

        def _fetch_image_on_esx_datastore():
            """Fetch image from Glance to ESX datastore."""
            LOG.debug(_("Downloading image file data %(image_id)s to the ESX "
                        "data store %(data_store_name)s") %
                        ({'image_id': instance.image_id,
                          'data_store_name': data_store_name}))
            # Upload the -flat.vmdk file whose meta-data file we just created
            # above
            vmware_images.fetch_image(
                instance.image_id,
                instance,
                host=self._session._host_ip,
                data_center_name=self._get_datacenter_name_and_ref()[1],
                datastore_name=data_store_name,
                cookies=cookies,
                file_path=flat_uploaded_vmdk_name)
            LOG.debug(_("Downloaded image file data %(image_id)s to the ESX "
                        "data store %(data_store_name)s") %
                        ({'image_id': instance.image_id,
                         'data_store_name': data_store_name}))
        _fetch_image_on_esx_datastore()

        vm_ref = self._get_vm_ref_from_the_name(instance.name)

        def _attach_vmdk_to_the_vm():
            """
            Attach the vmdk uploaded to the VM. VM reconfigure is done
            to do so.
            """
            vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_spec(
                                client_factory,
                                vmdk_file_size_in_kb, uploaded_vmdk_path,
                                adapter_type)
            LOG.debug(_("Reconfiguring VM instance %s to attach the image "
                      "disk") % instance.name)
            reconfig_task = self._session._call_method(
                               self._session._get_vim(),
                               "ReconfigVM_Task", vm_ref,
                               spec=vmdk_attach_config_spec)
            self._session._wait_for_task(instance.id, reconfig_task)
            LOG.debug(_("Reconfigured VM instance %s to attach the image "
                      "disk") % instance.name)

        _attach_vmdk_to_the_vm()

        def _power_on_vm():
            """Power on the VM."""
            LOG.debug(_("Powering on the VM instance %s") % instance.name)
            # Power On the VM
            power_on_task = self._session._call_method(
                               self._session._get_vim(),
                               "PowerOnVM_Task", vm_ref)
            self._session._wait_for_task(instance.id, power_on_task)
            LOG.debug(_("Powered on the VM instance %s") % instance.name)
        _power_on_vm()