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

Revision 3ecf6786

     from optparse import OptionParser
     from ganeti import logger
     from ganeti import constants
     from ganeti import errors
     from ganeti import ssconf
-...
       result = utils.RunCmd(["fping", "-q", master_ip])
       if not result.failed:
         r2 = utils.RunCmd(["fping", "-q", "-S127.0.0.1", master_ip])
         if not result.failed:
         if not r2.failed:
           # we already have the ip:
           if debug:
             sys.stderr.write("Notice: already started.\n")
-...
       else:
         fn = StopMaster
       return fn(master_netdev, master_ip, debug)
       result = fn(master_netdev, master_ip, debug)
       sys.exit(result)
     if __name__=='__main__':
       exit_code = main()
       sys.exit(exit_code)
     if __name__ == '__main__':
       main()

     """Ganeti node daemon"""
     # functions in this module need to have a given name structure, so:
     # pylint: disable-msg=C0103
     import os
     import sys
     import resource
-...
     class ServerContextFactory:
       def getContext(self):
       """SSL context factory class that uses a given certificate.
       """
       @staticmethod
       def getContext():
         """Return a customized context.
         The context will be set to use our certificate.
         """
         ctx = SSL.Context(SSL.TLSv1_METHOD)
         ctx.use_certificate_file(constants.SSL_CERT_FILE)
         ctx.use_privatekey_file(constants.SSL_CERT_FILE)
         return ctx
     class ServerObject(pb.Avatar):
       """The server implementation.
       This class holds all methods exposed over the RPC interface.
       """
       def __init__(self, name):
         self.name = name
       def perspectiveMessageReceived(self, broker, message, args, kw):
         """This method is called when a network message is received.
         I will call::
         """Custom message dispatching function.
           |  self.perspective_%(message)s(*broker.unserialize(args),
           |                               **broker.unserialize(kw))
         to handle the method; subclasses of Avatar are expected to
         implement methods of this naming convention.
         This function overrides the pb.Avatar function in order to provide
         a simple form of exception passing (as text only).
         """
         args = broker.unserialize(args, self)
-...
       # the new block devices  --------------------------
       def perspective_blockdev_create(self, params):
       @staticmethod
       def perspective_blockdev_create(params):
         """Create a block device.
         """
         bdev_s, size, on_primary, info = params
         bdev = objects.ConfigObject.Loads(bdev_s)
         if bdev is None:
           raise ValueError("can't unserialize data!")
         return backend.CreateBlockDevice(bdev, size, on_primary, info)
       def perspective_blockdev_remove(self, params):
       @staticmethod
       def perspective_blockdev_remove(params):
         """Remove a block device.
         """
         bdev_s = params[0]
         bdev = objects.ConfigObject.Loads(bdev_s)
         return backend.RemoveBlockDevice(bdev)
       def perspective_blockdev_assemble(self, params):
       @staticmethod
       def perspective_blockdev_assemble(params):
         """Assemble a block device.
         """
         bdev_s, on_primary = params
         bdev = objects.ConfigObject.Loads(bdev_s)
         if bdev is None:
           raise ValueError("can't unserialize data!")
         return backend.AssembleBlockDevice(bdev, on_primary)
       def perspective_blockdev_shutdown(self, params):
       @staticmethod
       def perspective_blockdev_shutdown(params):
         """Shutdown a block device.
         """
         bdev_s = params[0]
         bdev = objects.ConfigObject.Loads(bdev_s)
         if bdev is None:
           raise ValueError("can't unserialize data!")
         return backend.ShutdownBlockDevice(bdev)
       def perspective_blockdev_addchild(self, params):
       @staticmethod
       def perspective_blockdev_addchild(params):
         """Add a child to a mirror device.
         Note: this is only valid for mirror devices. It's the caller's duty
         to send a correct disk, otherwise we raise an error.
         """
         bdev_s, ndev_s = params
         bdev = objects.ConfigObject.Loads(bdev_s)
         ndev = objects.ConfigObject.Loads(ndev_s)
-...
           raise ValueError("can't unserialize data!")
         return backend.MirrorAddChild(bdev, ndev)
       def perspective_blockdev_removechild(self, params):
       @staticmethod
       def perspective_blockdev_removechild(params):
         """Remove a child from a mirror device.
         This is only valid for mirror devices, of course. It's the callers
         duty to send a correct disk, otherwise we raise an error.
         """
         bdev_s, ndev_s = params
         bdev = objects.ConfigObject.Loads(bdev_s)
         ndev = objects.ConfigObject.Loads(ndev_s)
-...
           raise ValueError("can't unserialize data!")
         return backend.MirrorRemoveChild(bdev, ndev)
       def perspective_blockdev_getmirrorstatus(self, params):
       @staticmethod
       def perspective_blockdev_getmirrorstatus(params):
         """Return the mirror status for a list of disks.
         """
         disks = [objects.ConfigObject.Loads(dsk_s)
                 for dsk_s in params]
         return backend.GetMirrorStatus(disks)
       def perspective_blockdev_find(self, params):
       @staticmethod
       def perspective_blockdev_find(params):
         """Expose the FindBlockDevice functionality for a disk.
         This will try to find but not activate a disk.
         """
         disk = objects.ConfigObject.Loads(params[0])
         return backend.FindBlockDevice(disk)
       def perspective_blockdev_snapshot(self, params):
       @staticmethod
       def perspective_blockdev_snapshot(params):
         """Create a snapshot device.
         Note that this is only valid for LVM disks, if we get passed
         something else we raise an exception. The snapshot device can be
         remove by calling the generic block device remove call.
         """
         cfbd = objects.ConfigObject.Loads(params[0])
         return backend.SnapshotBlockDevice(cfbd)
       # export/import  --------------------------
       def perspective_snapshot_export(self, params):
       @staticmethod
       def perspective_snapshot_export(params):
         """Export a given snapshot.
         """
         disk = objects.ConfigObject.Loads(params[0])
         dest_node = params[1]
         instance = objects.ConfigObject.Loads(params[2])
         return backend.ExportSnapshot(disk,dest_node,instance)
         return backend.ExportSnapshot(disk, dest_node, instance)
       @staticmethod
       def perspective_finalize_export(params):
         """Expose the finalize export functionality.
       def perspective_finalize_export(self, params):
         """
         instance = objects.ConfigObject.Loads(params[0])
         snap_disks = [objects.ConfigObject.Loads(str_data)
                       for str_data in params[1]]
         return backend.FinalizeExport(instance, snap_disks)
       def perspective_export_info(self, params):
         dir = params[0]
         einfo = backend.ExportInfo(dir)
       @staticmethod
       def perspective_export_info(params):
         """Query information about an existing export on this node.
         The given path may not contain an export, in which case we return
         None.
         """
         path = params[0]
         einfo = backend.ExportInfo(path)
         if einfo is None:
           return einfo
         return einfo.Dumps()
       def perspective_export_list(self, params):
       @staticmethod
       def perspective_export_list(params):
         """List the available exports on this node.
         Note that as opposed to export_info, which may query data about an
         export in any path, this only queries the standard Ganeti path
         (constants.EXPORT_DIR).
         """
         return backend.ListExports()
       def perspective_export_remove(self, params):
       @staticmethod
       def perspective_export_remove(params):
         """Remove an export.
         """
         export = params[0]
         return backend.RemoveExport(export)
       # volume  --------------------------
       def perspective_volume_list(self, params):
       @staticmethod
       def perspective_volume_list(params):
         """Query the list of logical volumes in a given volume group.
         """
         vgname = params[0]
         return backend.GetVolumeList(vgname)
       def perspective_vg_list(self, params):
       @staticmethod
       def perspective_vg_list(params):
         """Query the list of volume groups.
         """
         return backend.ListVolumeGroups()
       # bridge  --------------------------
       def perspective_bridges_exist(self, params):
       @staticmethod
       def perspective_bridges_exist(params):
         """Check if all bridges given exist on this node.
         """
         bridges_list = params[0]
         return backend.BridgesExist(bridges_list)
       # instance  --------------------------
       def perspective_instance_os_add(self, params):
       @staticmethod
       def perspective_instance_os_add(params):
         """Install an OS on a given instance.
         """
         inst_s, os_disk, swap_disk = params
         inst = objects.ConfigObject.Loads(inst_s)
         return backend.AddOSToInstance(inst, os_disk, swap_disk)
       def perspective_instance_os_import(self, params):
       @staticmethod
       def perspective_instance_os_import(params):
         """Run the import function of an OS onto a given instance.
         """
         inst_s, os_disk, swap_disk, src_node, src_image = params
         inst = objects.ConfigObject.Loads(inst_s)
         return backend.ImportOSIntoInstance(inst, os_disk, swap_disk,
                                             src_node, src_image)
       def perspective_instance_shutdown(self, params):
       @staticmethod
       def perspective_instance_shutdown(params):
         """Shutdown an instance.
         """
         instance = objects.ConfigObject.Loads(params[0])
         return backend.ShutdownInstance(instance)
       def perspective_instance_start(self, params):
       @staticmethod
       def perspective_instance_start(params):
         """Start an instance.
         """
         instance = objects.ConfigObject.Loads(params[0])
         extra_args = params[1]
         return backend.StartInstance(instance, extra_args)
       def perspective_instance_info(self, params):
       @staticmethod
       def perspective_instance_info(params):
         """Query instance information.
         """
         return backend.GetInstanceInfo(params[0])
       def perspective_all_instances_info(self, params):
       @staticmethod
       def perspective_all_instances_info(params):
         """Query information about all instances.
         """
         return backend.GetAllInstancesInfo()
       def perspective_instance_list(self, params):
       @staticmethod
       def perspective_instance_list(params):
         """Query the list of running instances.
         """
         return backend.GetInstanceList()
       # node --------------------------
       def perspective_node_info(self, params):
       @staticmethod
       def perspective_node_info(params):
         """Query node information.
         """
         vgname = params[0]
         return backend.GetNodeInfo(vgname)
       def perspective_node_add(self, params):
       @staticmethod
       def perspective_node_add(params):
         """Complete the registration of this node in the cluster.
         """
         return backend.AddNode(params[0], params[1], params[2],
                                params[3], params[4], params[5])
       def perspective_node_verify(self, params):
       @staticmethod
       def perspective_node_verify(params):
         """Run a verify sequence on this node.
         """
         return backend.VerifyNode(params[0])
       def perspective_node_start_master(self, params):
       @staticmethod
       def perspective_node_start_master(params):
         """Promote this node to master status.
         """
         return backend.StartMaster()
       def perspective_node_stop_master(self, params):
       @staticmethod
       def perspective_node_stop_master(params):
         """Demote this node from master status.
         """
         return backend.StopMaster()
       def perspective_node_leave_cluster(self, params):
       @staticmethod
       def perspective_node_leave_cluster(params):
         """Cleanup after leaving a cluster.
         """
         return backend.LeaveCluster()
       def perspective_node_volumes(self, params):
       @staticmethod
       def perspective_node_volumes(params):
         """Query the list of all logical volume groups.
         """
         return backend.NodeVolumes()
       # cluster --------------------------
       def perspective_version(self, params):
       @staticmethod
       def perspective_version(params):
         """Query version information.
         """
         return constants.PROTOCOL_VERSION
       def perspective_upload_file(self, params):
       @staticmethod
       def perspective_upload_file(params):
         """Upload a file.
         Note that the backend implementation imposes strict rules on which
         files are accepted.
         """
         return backend.UploadFile(*params)
       # os -----------------------
       def perspective_os_diagnose(self, params):
       @staticmethod
       def perspective_os_diagnose(params):
         """Query detailed information about existing OSes.
         """
         os_list = backend.DiagnoseOS()
         if not os_list:
           # this catches also return values of 'False',
-...
           elif isinstance(data, errors.InvalidOS):
             result.append(data.args)
           else:
             raise errors.ProgrammerError, ("Invalid result from backend.DiagnoseOS"
                                            " (class %s, %s)" %
                                            (str(data.__class__), data))
             raise errors.ProgrammerError("Invalid result from backend.DiagnoseOS"
                                          " (class %s, %s)" %
                                          (str(data.__class__), data))
         return result
       def perspective_os_get(self, params):
       @staticmethod
       def perspective_os_get(params):
         """Query information about a given OS.
         """
         name = params[0]
         try:
           os = backend.OSFromDisk(name).Dumps()
           os_obj = backend.OSFromDisk(name).Dumps()
         except errors.InvalidOS, err:
           os = err.args
         return os
           os_obj = err.args
         return os_obj
       # hooks -----------------------
       def perspective_hooks_runner(self, params):
       @staticmethod
       def perspective_hooks_runner(params):
         """Run hook scripts.
         """
         hpath, phase, env = params
         hr = backend.HooksRunner()
         return hr.RunHooks(hpath, phase, env)
     class MyRealm:
       """Simple realm that forwards all requests to a ServerObject.
       """
       __implements__ = portal.IRealm
       def requestAvatar(self, avatarId, mind, *interfaces):
         """Return an avatar based on our ServerObject class.
         """
         if pb.IPerspective not in interfaces:
           raise NotImplementedError
         return pb.IPerspective, ServerObject(avatarId), lambda:None
-...
     def main():
       """Main function for the node daemon.
       """
       options, args = ParseOptions()
       for fname in (constants.SSL_CERT_FILE,):
         if not os.path.isfile(fname):
-...
       try:
         pid = os.fork()
       except OSError, e:
         raise Exception, "%s [%d]" % (e.strerror, e.errno)
         raise Exception("%s [%d]" % (e.strerror, e.errno))
       if (pid == 0):  # The first child.
         os.setsid()
         try:
           pid = os.fork() # Fork a second child.
         except OSError, e:
           raise Exception, "%s [%d]" % (e.strerror, e.errno)
           raise Exception("%s [%d]" % (e.strerror, e.errno))
         if (pid == 0):  # The second child.
           os.chdir(WORKDIR)
           os.umask(UMASK)
-...
       return(0)
     if __name__=='__main__':
     if __name__ == '__main__':
       main()

           fcntl.flock(f.fileno(), fcntl.LOCK_EX|fcntl.LOCK_NB)
         except IOError, x:
           if x.errno == errno.EAGAIN:
             raise StandardError('State file already locked')
             raise StandardError("State file already locked")
           raise
         self.statefile = f
-...
         self.state = state
       def Restart(self):
         """Encapsulates the start of an instance.
         This is currently done using the command line interface and not
         the Ganeti modules.
         """
         DoCmd(['gnt-instance', 'startup', '--lock-retries=15', self.name])
-...
         sstore = ssconf.SimpleStore()
         master = sstore.GetMasterNode()
         if master != socket.gethostname():
           raise NotMasterError, ("This is not the master node")
           raise NotMasterError("This is not the master node")
         self.instances = InstanceList()
         self.messages = []

       iinfo = hypervisor.GetHypervisor().GetAllInstancesInfo()
       if iinfo:
         for name, id, memory, vcpus, state, times in iinfo:
         for name, inst_id, memory, vcpus, state, times in iinfo:
           output[name] = {
             'memory': memory,
             'vcpus': vcpus,
-...
       for dsk in disks:
         rbd = _RecursiveFindBD(dsk)
         if rbd is None:
           raise errors.BlockDeviceError, "Can't find device %s" % str(dsk)
           raise errors.BlockDeviceError("Can't find device %s" % str(dsk))
         stats.append(rbd.CombinedSyncStatus())
       return stats
-...
       try:
         st = os.stat(api_file)
       except EnvironmentError, err:
         raise errors.InvalidOS, (name, "'ganeti_api_version' file not"
                                  " found (%s)" % _ErrnoOrStr(err))
         raise errors.InvalidOS(name, "'ganeti_api_version' file not"
                                " found (%s)" % _ErrnoOrStr(err))
       if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):
         raise errors.InvalidOS, (name, "'ganeti_api_version' file is not"
                                  " a regular file")
         raise errors.InvalidOS(name, "'ganeti_api_version' file is not"
                                " a regular file")
       try:
         f = open(api_file)
-...
         finally:
           f.close()
       except EnvironmentError, err:
         raise errors.InvalidOS, (name, "error while reading the"
                                  " API version (%s)" % _ErrnoOrStr(err))
         raise errors.InvalidOS(name, "error while reading the"
                                " API version (%s)" % _ErrnoOrStr(err))
       api_version = api_version.strip()
       try:
         api_version = int(api_version)
       except (TypeError, ValueError), err:
         raise errors.InvalidOS, (name, "API version is not integer (%s)" %
                                  str(err))
         raise errors.InvalidOS(name, "API version is not integer (%s)" % str(err))
       return api_version
-...
       api_version = _OSOndiskVersion(name, os_dir)
       if api_version != constants.OS_API_VERSION:
         raise errors.InvalidOS, (name, "API version mismatch (found %s want %s)"
                                  % (api_version, constants.OS_API_VERSION))
         raise errors.InvalidOS(name, "API version mismatch (found %s want %s)"
                                % (api_version, constants.OS_API_VERSION))
       # OS Scripts dictionary, we will populate it with the actual script names
       os_scripts = {'create': '', 'export': '', 'import': ''}
-...
         try:
           st = os.stat(os_scripts[script])
         except EnvironmentError, err:
           raise errors.InvalidOS, (name, "'%s' script missing (%s)" %
                                    (script, _ErrnoOrStr(err)))
           raise errors.InvalidOS(name, "'%s' script missing (%s)" %
                                  (script, _ErrnoOrStr(err)))
         if stat.S_IMODE(st.st_mode) & stat.S_IXUSR != stat.S_IXUSR:
           raise errors.InvalidOS, (name, "'%s' script not executable" % script)
           raise errors.InvalidOS(name, "'%s' script not executable" % script)
         if not stat.S_ISREG(stat.S_IFMT(st.st_mode)):
           raise errors.InvalidOS, (name, "'%s' is not a regular file" % script)
           raise errors.InvalidOS(name, "'%s' is not a regular file" % script)
       return objects.OS(name=name, path=os_dir,
-...
         else:
           return None
       else:
         raise errors.ProgrammerError, ("Cannot snapshot non-lvm block device"
                                        "'%s' of type '%s'" %
                                        (disk.unique_id, disk.dev_type))
         raise errors.ProgrammerError("Cannot snapshot non-lvm block device"
                                      "'%s' of type '%s'" %
                                      (disk.unique_id, disk.dev_type))
     def ExportSnapshot(disk, dest_node, instance):
-...
       real_os_dev = _RecursiveFindBD(os_device)
       if real_os_dev is None:
         raise errors.BlockDeviceError, ("Block device '%s' is not set up" %
                                         str(os_device))
         raise errors.BlockDeviceError("Block device '%s' is not set up" %
                                       str(os_device))
       real_os_dev.Open()
       real_swap_dev = _RecursiveFindBD(swap_device)
       if real_swap_dev is None:
         raise errors.BlockDeviceError, ("Block device '%s' is not set up" %
                                         str(swap_device))
         raise errors.BlockDeviceError("Block device '%s' is not set up" %
                                       str(swap_device))
       real_swap_dev.Open()
       logfile = "%s/import-%s-%s-%s.log" % (constants.LOG_OS_DIR, instance.os,
-...
         elif phase == constants.HOOKS_PHASE_POST:
           suffix = "post"
         else:
           raise errors.ProgrammerError, ("Unknown hooks phase: '%s'" % phase)
           raise errors.ProgrammerError("Unknown hooks phase: '%s'" % phase)
         rr = []
         subdir = "%s-%s.d" % (hpath, suffix)

         vg_name, lv_name = unique_id
         pvs_info = cls.GetPVInfo(vg_name)
         if not pvs_info:
           raise errors.BlockDeviceError, ("Can't compute PV info for vg %s" %
                                           vg_name)
           raise errors.BlockDeviceError("Can't compute PV info for vg %s" %
                                         vg_name)
         pvs_info.sort()
         pvs_info.reverse()
-...
         # The size constraint should have been checked from the master before
         # calling the create function.
         if free_size < size:
           raise errors.BlockDeviceError, ("Not enough free space: required %s,"
                                           " available %s" % (size, free_size))
           raise errors.BlockDeviceError("Not enough free space: required %s,"
                                         " available %s" % (size, free_size))
         result = utils.RunCmd(["lvcreate", "-L%dm" % size, "-n%s" % lv_name,
                                vg_name] + pvlist)
         if result.failed:
-...
         pvs_info = self.GetPVInfo(self._vg_name)
         if not pvs_info:
           raise errors.BlockDeviceError, ("Can't compute PV info for vg %s" %
                                           self._vg_name)
           raise errors.BlockDeviceError("Can't compute PV info for vg %s" %
                                         self._vg_name)
         pvs_info.sort()
         pvs_info.reverse()
         free_size, pv_name = pvs_info[0]
         if free_size < size:
           raise errors.BlockDeviceError, ("Not enough free space: required %s,"
                                           " available %s" % (size, free_size))
           raise errors.BlockDeviceError("Not enough free space: required %s,"
                                         " available %s" % (size, free_size))
         result = utils.RunCmd(["lvcreate", "-L%dm" % size, "-s",
                                "-n%s" % snap_name, self.dev_path])
         if result.failed:
           raise errors.BlockDeviceError, ("command: %s error: %s" %
                                           (result.cmd, result.fail_reason))
           raise errors.BlockDeviceError("command: %s error: %s" %
                                         (result.cmd, result.fail_reason))
         return snap_name
-...
         result = utils.RunCmd(["lvchange", "--addtag", text,
                                self.dev_path])
         if result.failed:
           raise errors.BlockDeviceError, ("Command: %s error: %s" %
                                           (result.cmd, result.fail_reason))
           raise errors.BlockDeviceError("Command: %s error: %s" %
                                         (result.cmd, result.fail_reason))
     class MDRaid1(BlockDev):
-...
         """
         if self.minor is None and not self.Attach():
           raise errors.BlockDeviceError, "Can't attach to device"
           raise errors.BlockDeviceError("Can't attach to device")
         if device.dev_path is None:
           raise errors.BlockDeviceError, "New child is not initialised"
           raise errors.BlockDeviceError("New child is not initialised")
         result = utils.RunCmd(["mdadm", "-a", self.dev_path, device.dev_path])
         if result.failed:
           raise errors.BlockDeviceError, ("Failed to add new device to array: %s" %
                                           result.output)
           raise errors.BlockDeviceError("Failed to add new device to array: %s" %
                                         result.output)
         new_len = len(self._children) + 1
         result = utils.RunCmd(["mdadm", "--grow", self.dev_path, "-n", new_len])
         if result.failed:
           raise errors.BlockDeviceError, ("Can't grow md array: %s" %
                                           result.output)
           raise errors.BlockDeviceError("Can't grow md array: %s" %
                                         result.output)
         self._children.append(device)
-...
         """
         if self.minor is None and not self.Attach():
           raise errors.BlockDeviceError, "Can't attach to device"
           raise errors.BlockDeviceError("Can't attach to device")
         if len(self._children) == 1:
           raise errors.BlockDeviceError, ("Can't reduce member when only one"
                                           " child left")
           raise errors.BlockDeviceError("Can't reduce member when only one"
                                         " child left")
         for device in self._children:
           if device.dev_path == dev_path:
             break
         else:
           raise errors.BlockDeviceError, "Can't find child with this path"
           raise errors.BlockDeviceError("Can't find child with this path")
         new_len = len(self._children) - 1
         result = utils.RunCmd(["mdadm", "-f", self.dev_path, dev_path])
         if result.failed:
           raise errors.BlockDeviceError, ("Failed to mark device as failed: %s" %
                                           result.output)
           raise errors.BlockDeviceError("Failed to mark device as failed: %s" %
                                         result.output)
         # it seems here we need a short delay for MD to update its
         # superblocks
         time.sleep(0.5)
         result = utils.RunCmd(["mdadm", "-r", self.dev_path, dev_path])
         if result.failed:
           raise errors.BlockDeviceError, ("Failed to remove device from array:"
                                           " %s" % result.output)
           raise errors.BlockDeviceError("Failed to remove device from array:"
                                             " %s" % result.output)
         result = utils.RunCmd(["mdadm", "--grow", "--force", self.dev_path,
                                "-n", new_len])
         if result.failed:
           raise errors.BlockDeviceError, ("Can't shrink md array: %s" %
                                           result.output)
           raise errors.BlockDeviceError("Can't shrink md array: %s" %
                                         result.output)
         self._children.remove(device)
-...
         minor = self._FindUnusedMinor()
         if minor is None:
           raise errors.BlockDeviceError, "Not enough free minors for DRBD!"
           raise errors.BlockDeviceError("Not enough free minors for DRBD!")
         need_localdev_teardown = False
         if self._children[0]:
           result = self._AssembleLocal(minor, self._children[0].dev_path,

       try:
         return utils.ParseUnit(value)
       except errors.UnitParseError, err:
         raise OptionValueError, ("option %s: %s" % (opt, err))
         raise OptionValueError("option %s: %s" % (opt, err))
     class CliOption(Option):

         for attr_name in self._OP_REQP:
           attr_val = getattr(op, attr_name, None)
           if attr_val is None:
             raise errors.OpPrereqError, ("Required parameter '%s' missing" %
                                          attr_name)
             raise errors.OpPrereqError("Required parameter '%s' missing" %
                                        attr_name)
         if self.REQ_CLUSTER:
           if not cfg.IsCluster():
             raise errors.OpPrereqError, ("Cluster not initialized yet,"
                                          " use 'gnt-cluster init' first.")
             raise errors.OpPrereqError("Cluster not initialized yet,"
                                        " use 'gnt-cluster init' first.")
           if self.REQ_MASTER:
             master = sstore.GetMasterNode()
             if master != socket.gethostname():
               raise errors.OpPrereqError, ("Commands must be run on the master"
                                            " node %s" % master)
               raise errors.OpPrereqError("Commands must be run on the master"
                                          " node %s" % master)
       def CheckPrereq(self):
         """Check prerequisites for this LU.
-...
       """
       if nodes is not None and not isinstance(nodes, list):
         raise errors.OpPrereqError, "Invalid argument type 'nodes'"
         raise errors.OpPrereqError("Invalid argument type 'nodes'")
       if nodes:
         wanted_nodes = []
-...
         for name in nodes:
           node = lu.cfg.GetNodeInfo(lu.cfg.ExpandNodeName(name))
           if node is None:
             raise errors.OpPrereqError, ("No such node name '%s'" % name)
             raise errors.OpPrereqError("No such node name '%s'" % name)
         wanted_nodes.append(node)
         return wanted_nodes
-...
       all_fields = static_fields | dynamic_fields
       if not all_fields.issuperset(selected):
         raise errors.OpPrereqError, ("Unknown output fields selected: %s"
                                      % ",".join(frozenset(selected).
                                                 difference(all_fields)))
         raise errors.OpPrereqError("Unknown output fields selected: %s"
                                    % ",".join(frozenset(selected).
                                               difference(all_fields)))
     def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
-...
                              "-f", "/root/.ssh/id_dsa",
                              "-q", "-N", ""])
       if result.failed:
         raise errors.OpExecError, ("could not generate ssh keypair, error %s" %
                                    result.output)
         raise errors.OpExecError("Could not generate ssh keypair, error %s" %
                                  result.output)
       f = open('/root/.ssh/id_dsa.pub', 'r')
       try:
-...
                              "-keyout", constants.SSL_CERT_FILE,
                              "-out", constants.SSL_CERT_FILE, "-batch"])
       if result.failed:
         raise errors.OpExecError, ("could not generate server ssl cert, command"
                                    " %s had exitcode %s and error message %s" %
                                    (result.cmd, result.exit_code, result.output))
         raise errors.OpExecError("could not generate server ssl cert, command"
                                  " %s had exitcode %s and error message %s" %
                                  (result.cmd, result.exit_code, result.output))
       os.chmod(constants.SSL_CERT_FILE, 0400)
       result = utils.RunCmd([constants.NODE_INITD_SCRIPT, "restart"])
       if result.failed:
         raise errors.OpExecError, ("could not start the node daemon, command %s"
                                    " had exitcode %s and error %s" %
                                    (result.cmd, result.exit_code, result.output))
         raise errors.OpExecError("Could not start the node daemon, command %s"
                                  " had exitcode %s and error %s" %
                                  (result.cmd, result.exit_code, result.output))
     class LUInitCluster(LogicalUnit):
-...
         """
         if config.ConfigWriter.IsCluster():
           raise errors.OpPrereqError, ("Cluster is already initialised")
           raise errors.OpPrereqError("Cluster is already initialised")
         hostname_local = socket.gethostname()
         self.hostname = hostname = utils.LookupHostname(hostname_local)
         if not hostname:
           raise errors.OpPrereqError, ("Cannot resolve my own hostname ('%s')" %
                                        hostname_local)
           raise errors.OpPrereqError("Cannot resolve my own hostname ('%s')" %
                                      hostname_local)
         self.clustername = clustername = utils.LookupHostname(self.op.cluster_name)
         if not clustername:
           raise errors.OpPrereqError, ("Cannot resolve given cluster name ('%s')"
                                        % self.op.cluster_name)
           raise errors.OpPrereqError("Cannot resolve given cluster name ('%s')"
                                      % self.op.cluster_name)
         result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", hostname['ip']])
         if result.failed:
           raise errors.OpPrereqError, ("Inconsistency: this host's name resolves"
                                        " to %s,\nbut this ip address does not"
                                        " belong to this host."
                                        " Aborting." % hostname['ip'])
           raise errors.OpPrereqError("Inconsistency: this host's name resolves"
                                      " to %s,\nbut this ip address does not"
                                      " belong to this host."
                                      " Aborting." % hostname['ip'])
         secondary_ip = getattr(self.op, "secondary_ip", None)
         if secondary_ip and not utils.IsValidIP(secondary_ip):
           raise errors.OpPrereqError, ("Invalid secondary ip given")
           raise errors.OpPrereqError("Invalid secondary ip given")
         if secondary_ip and secondary_ip != hostname['ip']:
           result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", secondary_ip])
           if result.failed:
             raise errors.OpPrereqError, ("You gave %s as secondary IP,\n"
                                          "but it does not belong to this host." %
                                          secondary_ip)
             raise errors.OpPrereqError("You gave %s as secondary IP,\n"
                                        "but it does not belong to this host." %
                                        secondary_ip)
         self.secondary_ip = secondary_ip
         # checks presence of the volume group given
         vgstatus = _HasValidVG(utils.ListVolumeGroups(), self.op.vg_name)
         if vgstatus:
           raise errors.OpPrereqError, ("Error: %s" % vgstatus)
           raise errors.OpPrereqError("Error: %s" % vgstatus)
         if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$",
                         self.op.mac_prefix):
           raise errors.OpPrereqError, ("Invalid mac prefix given '%s'" %
                                        self.op.mac_prefix)
           raise errors.OpPrereqError("Invalid mac prefix given '%s'" %
                                      self.op.mac_prefix)
         if self.op.hypervisor_type not in hypervisor.VALID_HTYPES:
           raise errors.OpPrereqError, ("Invalid hypervisor type given '%s'" %
                                        self.op.hypervisor_type)
           raise errors.OpPrereqError("Invalid hypervisor type given '%s'" %
                                      self.op.hypervisor_type)
         result = utils.RunCmd(["ip", "link", "show", "dev", self.op.master_netdev])
         if result.failed:
           raise errors.OpPrereqError, ("Invalid master netdev given (%s): '%s'" %
                                        (self.op.master_netdev, result.output))
           raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %
                                      (self.op.master_netdev, result.output))
       def Exec(self, feedback_fn):
         """Initialize the cluster.
-...
         nodelist = self.cfg.GetNodeList()
         if len(nodelist) != 1 or nodelist[0] != master:
           raise errors.OpPrereqError, ("There are still %d node(s) in "
                                        "this cluster." % (len(nodelist) - 1))
           raise errors.OpPrereqError("There are still %d node(s) in"
                                      " this cluster." % (len(nodelist) - 1))
         instancelist = self.cfg.GetInstanceList()
         if instancelist:
           raise errors.OpPrereqError, ("There are still %d instance(s) in "
                                        "this cluster." % len(instancelist))
           raise errors.OpPrereqError("There are still %d instance(s) in"
                                      " this cluster." % len(instancelist))
       def Exec(self, feedback_fn):
         """Destroys the cluster.
-...
           logger.ToStderr("Can't get any data from node %s" % node)
           retries += 1
           if retries >= 10:
             raise errors.RemoteError, ("Can't contact node %s for mirror data,"
                                        " aborting." % node)
             raise errors.RemoteError("Can't contact node %s for mirror data,"
                                      " aborting." % node)
           time.sleep(6)
           continue
         retries = 0
-...
         node_list = self.cfg.GetNodeList()
         node_data = rpc.call_os_diagnose(node_list)
         if node_data == False:
           raise errors.OpExecError, "Can't gather the list of OSes"
           raise errors.OpExecError("Can't gather the list of OSes")
         return node_data
-...
         masternode = self.sstore.GetMasterNode()
         if node.name == masternode:
           raise errors.OpPrereqError, ("Node is the master node,"
                                        " you need to failover first.")
           raise errors.OpPrereqError("Node is the master node,"
                                      " you need to failover first.")
         for instance_name in instance_list:
           instance = self.cfg.GetInstanceInfo(instance_name)
           if node.name == instance.primary_node:
             raise errors.OpPrereqError, ("Instance %s still running on the node,"
                                          " please remove first." % instance_name)
             raise errors.OpPrereqError("Instance %s still running on the node,"
                                        " please remove first." % instance_name)
           if node.name in instance.secondary_nodes:
             raise errors.OpPrereqError, ("Instance %s has node as a secondary,"
                                          " please remove first." % instance_name)
             raise errors.OpPrereqError("Instance %s has node as a secondary,"
                                        " please remove first." % instance_name)
         self.op.node_name = node.name
         self.node = node
-...
             elif field in self.dynamic_fields:
               val = live_data[node.name].get(field, "?")
             else:
               raise errors.ParameterError, field
               raise errors.ParameterError(field)
             val = str(val)
             node_output.append(val)
           output.append(node_output)
-...
                 else:
                   val = '-'
               else:
                 raise errors.ParameterError, field
                 raise errors.ParameterError(field)
               node_output.append(str(val))
             output.append(node_output)
-...
         dns_data = utils.LookupHostname(node_name)
         if not dns_data:
           raise errors.OpPrereqError, ("Node %s is not resolvable" % node_name)
           raise errors.OpPrereqError("Node %s is not resolvable" % node_name)
         node = dns_data['hostname']
         primary_ip = self.op.primary_ip = dns_data['ip']
-...
         if secondary_ip is None:
           secondary_ip = primary_ip
         if not utils.IsValidIP(secondary_ip):
           raise errors.OpPrereqError, ("Invalid secondary IP given")
           raise errors.OpPrereqError("Invalid secondary IP given")
         self.op.secondary_ip = secondary_ip
         node_list = cfg.GetNodeList()
         if node in node_list:
           raise errors.OpPrereqError, ("Node %s is already in the configuration"
                                        % node)
           raise errors.OpPrereqError("Node %s is already in the configuration"
                                      % node)
         for existing_node_name in node_list:
           existing_node = cfg.GetNodeInfo(existing_node_name)
-...
               existing_node.secondary_ip == primary_ip or
               existing_node.primary_ip == secondary_ip or
               existing_node.secondary_ip == secondary_ip):
             raise errors.OpPrereqError, ("New node ip address(es) conflict with"
                                          " existing node %s" % existing_node.name)
             raise errors.OpPrereqError("New node ip address(es) conflict with"
                                        " existing node %s" % existing_node.name)
         # check that the type of the node (single versus dual homed) is the
         # same as for the master
-...
         newbie_singlehomed = secondary_ip == primary_ip
         if master_singlehomed != newbie_singlehomed:
           if master_singlehomed:
             raise errors.OpPrereqError, ("The master has no private ip but the"
                                          " new node has one")
             raise errors.OpPrereqError("The master has no private ip but the"
                                        " new node has one")
           else:
             raise errors.OpPrereqError ("The master has a private ip but the"
                                         " new node doesn't have one")
             raise errors.OpPrereqError("The master has a private ip but the"
                                        " new node doesn't have one")
         # checks reachablity
         command = ["fping", "-q", primary_ip]
         result = utils.RunCmd(command)
         if result.failed:
           raise errors.OpPrereqError, ("Node not reachable by ping")
           raise errors.OpPrereqError("Node not reachable by ping")
         if not newbie_singlehomed:
           # check reachability from my secondary ip to newbie's secondary ip
           command = ["fping", "-S%s" % myself.secondary_ip, "-q", secondary_ip]
           result = utils.RunCmd(command)
           if result.failed:
             raise errors.OpPrereqError, ("Node secondary ip not reachable by ping")
             raise errors.OpPrereqError("Node secondary ip not reachable by ping")
         self.new_node = objects.Node(name=node,
                                      primary_ip=primary_ip,
-...
         # set up inter-node password and certificate and restarts the node daemon
         gntpass = self.sstore.GetNodeDaemonPassword()
         if not re.match('^[a-zA-Z0-9.]{1,64}$', gntpass):
           raise errors.OpExecError, ("ganeti password corruption detected")
           raise errors.OpExecError("ganeti password corruption detected")
         f = open(constants.SSL_CERT_FILE)
         try:
           gntpem = f.read(8192)
-...
         # cert doesn't contain this, the here-document will be correctly
         # parsed by the shell sequence below
         if re.search('^!EOF\.', gntpem, re.MULTILINE):
           raise errors.OpExecError, ("invalid PEM encoding in the SSL certificate")
           raise errors.OpExecError("invalid PEM encoding in the SSL certificate")
         if not gntpem.endswith("\n"):
           raise errors.OpExecError, ("PEM must end with newline")
           raise errors.OpExecError("PEM must end with newline")
         logger.Info("copy cluster pass to %s and starting the node daemon" % node)
         # remove first the root's known_hosts file
-...
         result = ssh.SSHCall(node, 'root', mycommand, batch=False, ask_key=True)
         if result.failed:
           raise errors.OpExecError, ("Remote command on node %s, error: %s,"
                                      " output: %s" %
                                      (node, result.fail_reason, result.output))
           raise errors.OpExecError("Remote command on node %s, error: %s,"
                                    " output: %s" %
                                    (node, result.fail_reason, result.output))
         # check connectivity
         time.sleep(4)
-...
             logger.Info("communication to node %s fine, sw version %s match" %
                         (node, result))
           else:
             raise errors.OpExecError, ("Version mismatch master version %s,"
                                        " node version %s" %
                                        (constants.PROTOCOL_VERSION, result))
             raise errors.OpExecError("Version mismatch master version %s,"
                                      " node version %s" %
                                      (constants.PROTOCOL_VERSION, result))
         else:
           raise errors.OpExecError, ("Cannot get version from the new node")
           raise errors.OpExecError("Cannot get version from the new node")
         # setup ssh on node
         logger.Info("copy ssh key to node %s" % node)
-...
                                    keyarray[3], keyarray[4], keyarray[5])
         if not result:
           raise errors.OpExecError, ("Cannot transfer ssh keys to the new node")
           raise errors.OpExecError("Cannot transfer ssh keys to the new node")
         # Add node to our /etc/hosts, and add key to known_hosts
         _UpdateEtcHosts(new_node.name, new_node.primary_ip)
-...
           result = ssh.SSHCall(node, "root",
                                "fping -S 127.0.0.1 -q %s" % new_node.secondary_ip)
           if result.failed:
             raise errors.OpExecError, ("Node claims it doesn't have the"
                                        " secondary ip you gave (%s).\n"
                                        "Please fix and re-run this command." %
                                        new_node.secondary_ip)
             raise errors.OpExecError("Node claims it doesn't have the"
                                      " secondary ip you gave (%s).\n"
                                      "Please fix and re-run this command." %
                                      new_node.secondary_ip)
         # Distribute updated /etc/hosts and known_hosts to all nodes,
         # including the node just added
-...
         self.old_master = self.sstore.GetMasterNode()
         if self.old_master == self.new_master:
           raise errors.OpPrereqError, ("This commands must be run on the node"
                                        " where you want the new master to be.\n"
                                        "%s is already the master" %
                                        self.old_master)
           raise errors.OpPrereqError("This commands must be run on the node"
                                      " where you want the new master to be.\n"
                                      "%s is already the master" %
                                      self.old_master)
       def Exec(self, feedback_fn):
         """Failover the master node.
-...
         instance = self.cfg.GetInstanceInfo(
           self.cfg.ExpandInstanceName(self.op.instance_name))
         if instance is None:
           raise errors.OpPrereqError, ("Instance '%s' not known" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' not known" %
                                      self.op.instance_name)
         self.instance = instance
-...
         """
         disks_ok, disks_info = _AssembleInstanceDisks(self.instance, self.cfg)
         if not disks_ok:
           raise errors.OpExecError, ("Cannot activate block devices")
           raise errors.OpExecError("Cannot activate block devices")
         return disks_info
-...
     def _StartInstanceDisks(cfg, instance, force):
       """Start the disks of an instance.
       """
       disks_ok, dummy = _AssembleInstanceDisks(instance, cfg,
                                                ignore_secondaries=force)
       if not disks_ok:
-...
         if force is not None and not force:
           logger.Error("If the message above refers to a secondary node,"
                        " you can retry the operation using '--force'.")
         raise errors.OpExecError, ("Disk consistency error")
         raise errors.OpExecError("Disk consistency error")
     class LUDeactivateInstanceDisks(NoHooksLU):
-...
         instance = self.cfg.GetInstanceInfo(
           self.cfg.ExpandInstanceName(self.op.instance_name))
         if instance is None:
           raise errors.OpPrereqError, ("Instance '%s' not known" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' not known" %
                                      self.op.instance_name)
         self.instance = instance
       def Exec(self, feedback_fn):
-...
         ins_l = rpc.call_instance_list([instance.primary_node])
         ins_l = ins_l[instance.primary_node]
         if not type(ins_l) is list:
           raise errors.OpExecError, ("Can't contact node '%s'" %
                                      instance.primary_node)
           raise errors.OpExecError("Can't contact node '%s'" %
                                    instance.primary_node)
         if self.instance.name in ins_l:
           raise errors.OpExecError, ("Instance is running, can't shutdown"
                                      " block devices.")
           raise errors.OpExecError("Instance is running, can't shutdown"
                                    " block devices.")
         _ShutdownInstanceDisks(instance, self.cfg)
-...
         instance = self.cfg.GetInstanceInfo(
           self.cfg.ExpandInstanceName(self.op.instance_name))
         if instance is None:
           raise errors.OpPrereqError, ("Instance '%s' not known" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' not known" %
                                      self.op.instance_name)
         # check bridges existance
         brlist = [nic.bridge for nic in instance.nics]
         if not rpc.call_bridges_exist(instance.primary_node, brlist):
           raise errors.OpPrereqError, ("one or more target bridges %s does not"
                                        " exist on destination node '%s'" %
                                        (brlist, instance.primary_node))
           raise errors.OpPrereqError("one or more target bridges %s does not"
                                      " exist on destination node '%s'" %
                                      (brlist, instance.primary_node))
         self.instance = instance
         self.op.instance_name = instance.name
-...
         nodeinfo = rpc.call_node_info([node_current], self.cfg.GetVGName())
         if not nodeinfo:
           raise errors.OpExecError, ("Could not contact node %s for infos" %
                                      (node_current))
           raise errors.OpExecError("Could not contact node %s for infos" %
                                    (node_current))
         freememory = nodeinfo[node_current]['memory_free']
         memory = instance.memory
         if memory > freememory:
           raise errors.OpExecError, ("Not enough memory to start instance"
                                      " %s on node %s"
                                      " needed %s MiB, available %s MiB" %
                                      (instance.name, node_current, memory,
                                       freememory))
           raise errors.OpExecError("Not enough memory to start instance"
                                    " %s on node %s"
                                    " needed %s MiB, available %s MiB" %
                                    (instance.name, node_current, memory,
                                     freememory))
         _StartInstanceDisks(self.cfg, instance, force)
         if not rpc.call_instance_start(node_current, instance, extra_args):
           _ShutdownInstanceDisks(instance, self.cfg)
           raise errors.OpExecError, ("Could not start instance")
           raise errors.OpExecError("Could not start instance")
         self.cfg.MarkInstanceUp(instance.name)
-...
         instance = self.cfg.GetInstanceInfo(
           self.cfg.ExpandInstanceName(self.op.instance_name))
         if instance is None:
           raise errors.OpPrereqError, ("Instance '%s' not known" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' not known" %
                                      self.op.instance_name)
         self.instance = instance
       def Exec(self, feedback_fn):
-...
         instance = self.cfg.GetInstanceInfo(
           self.cfg.ExpandInstanceName(self.op.instance_name))
         if instance is None:
           raise errors.OpPrereqError, ("Instance '%s' not known" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' not known" %
                                      self.op.instance_name)
         if instance.disk_template == constants.DT_DISKLESS:
           raise errors.OpPrereqError, ("Instance '%s' has no disks" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' has no disks" %
                                      self.op.instance_name)
         if instance.status != "down":
           raise errors.OpPrereqError, ("Instance '%s' is marked to be up" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' is marked to be up" %
                                      self.op.instance_name)
         remote_info = rpc.call_instance_info(instance.primary_node, instance.name)
         if remote_info:
           raise errors.OpPrereqError, ("Instance '%s' is running on the node %s" %
                                        (self.op.instance_name,
                                         instance.primary_node))
           raise errors.OpPrereqError("Instance '%s' is running on the node %s" %
                                      (self.op.instance_name,
                                       instance.primary_node))
         self.op.os_type = getattr(self.op, "os_type", None)
         if self.op.os_type is not None:
-...
           pnode = self.cfg.GetNodeInfo(
             self.cfg.ExpandNodeName(instance.primary_node))
           if pnode is None:
             raise errors.OpPrereqError, ("Primary node '%s' is unknown" %
                                          self.op.pnode)
             raise errors.OpPrereqError("Primary node '%s' is unknown" %
                                        self.op.pnode)
           os_obj = rpc.call_os_get([pnode.name], self.op.os_type)[pnode.name]
           if not isinstance(os_obj, objects.OS):
             raise errors.OpPrereqError, ("OS '%s' not in supported OS list for"
                                          " primary node"  % self.op.os_type)
             raise errors.OpPrereqError("OS '%s' not in supported OS list for"
                                        " primary node"  % self.op.os_type)
         self.instance = instance
-...
         try:
           feedback_fn("Running the instance OS create scripts...")
           if not rpc.call_instance_os_add(inst.primary_node, inst, "sda", "sdb"):
             raise errors.OpExecError, ("Could not install OS for instance %s "
                                        "on node %s" %
                                        (inst.name, inst.primary_node))
             raise errors.OpExecError("Could not install OS for instance %s "
                                      "on node %s" %
                                      (inst.name, inst.primary_node))
         finally:
           _ShutdownInstanceDisks(inst, self.cfg)
-...
         instance = self.cfg.GetInstanceInfo(
           self.cfg.ExpandInstanceName(self.op.instance_name))
         if instance is None:
           raise errors.OpPrereqError, ("Instance '%s' not known" %
                                        self.op.instance_name)
           raise errors.OpPrereqError("Instance '%s' not known" %
                                      self.op.instance_name)
         self.instance = instance
       def Exec(self, feedback_fn):
-...
                     (instance.name, instance.primary_node))

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff

Synnefo » snf-ganeti

Revision 3ecf6786