/ - Diff - snf-ganeti - Greek Research and Technology Network's projects

       """
       hyper = hypervisor.GetHypervisor(instance.hypervisor)
       try:
         hyper.VerifyHotplugSupport(instance, action, dev_type)
       except errors.HotplugError, err:
         _Fail("Hotplug is not supported: %s", err)
       if action == constants.HOTPLUG_ACTION_ADD:
         fn = hyper.HotAddDevice
       elif action == constants.HOTPLUG_ACTION_REMOVE:
-...
       else:
         assert action in constants.HOTPLUG_ALL_ACTIONS
       # This will raise an exception if hotplug is no supported for this case
       hyper.HotplugSupported(instance, action, dev_type)
       return fn(instance, dev_type, device, extra, seq)
     def HotplugSupported(instance):
       """Checks if hotplug is generally supported.
       """
       hyper = hypervisor.GetHypervisor(instance.hypervisor)
       try:
         hyper.HotplugSupported(instance)
       except errors.HotplugError, err:
         _Fail("Hotplug is not supported: %s", err)
     def BlockdevCreate(disk, size, owner, on_primary, info, excl_stor):
       """Creates a block device for an instance.

         # dictionary with instance information after the modification
         ispec = {}
         if self.op.hotplug:
           result = self.rpc.call_hotplug_supported(self.instance.primary_node,
                                                    self.instance)
           result.Raise("Hotplug is not supported.")
         # Check disk modifications. This is done here and not in CheckArguments
         # (as with NICs), because we need to know the instance's disk template
         if instance.disk_template == constants.DT_EXT:

         """
         pass
       def HotplugSupported(self, instance, action, dev_type):
       # pylint: disable=R0201,W0613
       def VerifyHotplugSupport(self, instance, action, dev_type):
         """Whether hotplug is supported.
         Given the target device and hotplug action checks if hotplug is
         actually supported.
         @type instance: L{objects.Instance}
         @param instance: the instance object
         @type action: string
         @param action: one of the supported hotplug commands
         @type dev_type: string
         @param dev_type: one of the supported device types to hotplug
         @raise errors.HotplugError: if hotplugging is not supported
         Depends on instance's hvparam, the action. and the dev_type
         """
         pass
         raise errors.HotplugError("Hotplug is not supported.")
       # pylint: disable=R0201,W0613
       def HotplugSupported(self, instance):
         """Checks if hotplug is supported.
         By default is not. Currently only KVM hypervisor supports it.
         """
         raise errors.HotplugError("Hotplug is not supported by this hypervisor")

         dev.pci = int(free)
       def HotplugSupported(self, instance, action, dev_type):
       def VerifyHotplugSupport(self, instance, action, dev_type):
         """Check if hotplug is supported.
         Hotplug is *not* supported in case of:
          - qemu versions < 1.0
          - security models and chroot (disk hotplug)
          - fdsend module is missing (nic hot-add)
         @raise errors.HypervisorError: in previous cases
         """
         output = self._CallMonitorCommand(instance.name, self._INFO_VERSION_CMD)
         # TODO: search for netdev_add, drive_add, device_add.....
         match = self._INFO_VERSION_RE.search(output.stdout)
         if not match:
           raise errors.HotplugError("Try hotplug only in running instances.")
         v_major, v_min, _, _ = match.groups()
         if (v_major, v_min) <= (1, 0):
           raise errors.HotplugError("Hotplug not supported for qemu versions < 1.0")
         if dev_type == constants.HOTPLUG_TARGET_DISK:
           hvp = instance.hvparams
           security_model = hvp[constants.HV_SECURITY_MODEL]
-...
                                     " fdsend python module is missing.")
         return True
       def HotplugSupported(self, instance):
         """Checks if hotplug is generally supported.
         Hotplug is *not* supported in case of:
          - qemu versions < 1.0
          - for stopped instances
         @raise errors.HypervisorError: in one of the previous cases
         """
         output = self._CallMonitorCommand(instance.name, self._INFO_VERSION_CMD)
         # TODO: search for netdev_add, drive_add, device_add.....
         match = self._INFO_VERSION_RE.search(output.stdout)
         if not match:
           raise errors.HotplugError("Try hotplug only in running instances.")
         v_major, v_min, _, _ = match.groups()
         if (int(v_major), int(v_min)) < (1, 0):
           raise errors.HotplugError("Hotplug not supported for qemu versions < 1.0")
       def _CallHotplugCommand(self, name, cmd):
         output = self._CallMonitorCommand(name, cmd)
         # TODO: parse output and check if succeeded

         ("extra", None, "Extra info for device (dev_path for disk)"),
         ("seq", None, "Device seq"),
         ], None, None, "Hoplug a device to a running instance"),
       ("hotplug_supported", SINGLE, None, constants.RPC_TMO_NORMAL, [
         ("instance", ED_INST_DICT, "Instance object"),
         ], None, None, "Check if hotplug is supported"),
+      ]
     _IMPEXP_CALLS = [

         return backend.HotplugDevice(instance, action, dev_type, device, extra, seq)
       @staticmethod
       def perspective_hotplug_supported(params):
         """Checks if hotplug is supported.
         """
         instance = objects.Instance.FromDict(params[0])
         return backend.HotplugSupported(instance)
       @staticmethod
       def perspective_migration_info(params):
         """Gather information about an instance to be migrated.

Synnefo » snf-ganeti

Revision ad00ee21