X-Git-Url: https://code.grnet.gr/git/ganeti-local/blobdiff_plain/83d4ba5eab52d512d25f64cbbcdf8daf69f09978..7cfe1eb620722322a602b24a3a57ad7abeaf65ae:/lib/client/gnt_instance.py diff --git a/lib/client/gnt_instance.py b/lib/client/gnt_instance.py index c6dfd69..e71c0da 100644 --- a/lib/client/gnt_instance.py +++ b/lib/client/gnt_instance.py @@ -29,7 +29,6 @@ import copy import itertools import simplejson import logging -from cStringIO import StringIO from ganeti.cli import * from ganeti import opcodes @@ -53,21 +52,21 @@ _EXPAND_NODES_SEC_BY_TAGS = "nodes-sec-by-tags" _EXPAND_INSTANCES = "instances" _EXPAND_INSTANCES_BY_TAGS = "instances-by-tags" -_EXPAND_NODES_TAGS_MODES = frozenset([ +_EXPAND_NODES_TAGS_MODES = compat.UniqueFrozenset([ _EXPAND_NODES_BOTH_BY_TAGS, _EXPAND_NODES_PRI_BY_TAGS, _EXPAND_NODES_SEC_BY_TAGS, ]) - #: default list of options for L{ListInstances} _LIST_DEF_FIELDS = [ "name", "hypervisor", "os", "pnode", "status", "oper_ram", ] - _MISSING = object() -_ENV_OVERRIDE = frozenset(["list"]) +_ENV_OVERRIDE = compat.UniqueFrozenset(["list"]) + +_INST_DATA_VAL = ht.TListOf(ht.TDict) def _ExpandMultiNames(mode, names, client=None): @@ -116,7 +115,7 @@ def _ExpandMultiNames(mode, names, client=None): if not names: raise errors.OpPrereqError("No node names passed", errors.ECODE_INVAL) ndata = client.QueryNodes(names, ["name", "pinst_list", "sinst_list"], - False) + False) ipri = [row[1] for row in ndata] pri_names = list(itertools.chain(*ipri)) @@ -218,6 +217,7 @@ def ListInstances(opts, args): fmtoverride = dict.fromkeys(["tags", "disk.sizes", "nic.macs", "nic.ips", "nic.modes", "nic.links", "nic.bridges", + "nic.networks", "snodes", "snodes.group", "snodes.group.uuid"], (lambda value: ",".join(str(item) for item in value), @@ -255,23 +255,8 @@ def AddInstance(opts, args): def BatchCreate(opts, args): """Create instances using a definition file. - This function reads a json file with instances defined - in the form:: - - {"instance-name":{ - "disk_size": [20480], - "template": "drbd", - "backend": { - "memory": 512, - "vcpus": 1 }, - "os": "debootstrap", - "primary_node": "firstnode", - "secondary_node": "secondnode", - "iallocator": "dumb"} - } - - Note that I{primary_node} and I{secondary_node} have precedence over - I{iallocator}. + This function reads a json file with L{opcodes.OpInstanceCreate} + serialisations. @param opts: the command line options selected by the user @type args: list @@ -280,130 +265,54 @@ def BatchCreate(opts, args): @return: the desired exit code """ - _DEFAULT_SPECS = {"disk_size": [20 * 1024], - "backend": {}, - "iallocator": None, - "primary_node": None, - "secondary_node": None, - "nics": None, - "start": True, - "ip_check": True, - "name_check": True, - "hypervisor": None, - "hvparams": {}, - "file_storage_dir": None, - "force_variant": False, - "file_driver": "loop"} - - def _PopulateWithDefaults(spec): - """Returns a new hash combined with default values.""" - mydict = _DEFAULT_SPECS.copy() - mydict.update(spec) - return mydict - - def _Validate(spec): - """Validate the instance specs.""" - # Validate fields required under any circumstances - for required_field in ("os", "template"): - if required_field not in spec: - raise errors.OpPrereqError('Required field "%s" is missing.' % - required_field, errors.ECODE_INVAL) - # Validate special fields - if spec["primary_node"] is not None: - if (spec["template"] in constants.DTS_INT_MIRROR and - spec["secondary_node"] is None): - raise errors.OpPrereqError("Template requires secondary node, but" - " there was no secondary provided.", - errors.ECODE_INVAL) - elif spec["iallocator"] is None: - raise errors.OpPrereqError("You have to provide at least a primary_node" - " or an iallocator.", - errors.ECODE_INVAL) - - if (spec["hvparams"] and - not isinstance(spec["hvparams"], dict)): - raise errors.OpPrereqError("Hypervisor parameters must be a dict.", - errors.ECODE_INVAL) + (json_filename,) = args + cl = GetClient() - json_filename = args[0] try: instance_data = simplejson.loads(utils.ReadFile(json_filename)) except Exception, err: # pylint: disable=W0703 ToStderr("Can't parse the instance definition file: %s" % str(err)) return 1 - if not isinstance(instance_data, dict): - ToStderr("The instance definition file is not in dict format.") + if not _INST_DATA_VAL(instance_data): + ToStderr("The instance definition file is not %s" % _INST_DATA_VAL) return 1 - jex = JobExecutor(opts=opts) + instances = [] + possible_params = set(opcodes.OpInstanceCreate.GetAllSlots()) + for (idx, inst) in enumerate(instance_data): + unknown = set(inst.keys()) - possible_params - # Iterate over the instances and do: - # * Populate the specs with default value - # * Validate the instance specs - i_names = utils.NiceSort(instance_data.keys()) # pylint: disable=E1103 - for name in i_names: - specs = instance_data[name] - specs = _PopulateWithDefaults(specs) - _Validate(specs) + if unknown: + # TODO: Suggest closest match for more user friendly experience + raise errors.OpPrereqError("Unknown fields in definition %s: %s" % + (idx, utils.CommaJoin(unknown)), + errors.ECODE_INVAL) - hypervisor = specs["hypervisor"] - hvparams = specs["hvparams"] + op = opcodes.OpInstanceCreate(**inst) # pylint: disable=W0142 + op.Validate(False) + instances.append(op) - disks = [] - for elem in specs["disk_size"]: - try: - size = utils.ParseUnit(elem) - except (TypeError, ValueError), err: - raise errors.OpPrereqError("Invalid disk size '%s' for" - " instance %s: %s" % - (elem, name, err), errors.ECODE_INVAL) - disks.append({"size": size}) - - utils.ForceDictType(specs["backend"], constants.BES_PARAMETER_COMPAT) - utils.ForceDictType(hvparams, constants.HVS_PARAMETER_TYPES) - - tmp_nics = [] - for field in constants.INIC_PARAMS: - if field in specs: - if not tmp_nics: - tmp_nics.append({}) - tmp_nics[0][field] = specs[field] - - if specs["nics"] is not None and tmp_nics: - raise errors.OpPrereqError("'nics' list incompatible with using" - " individual nic fields as well", - errors.ECODE_INVAL) - elif specs["nics"] is not None: - tmp_nics = specs["nics"] - elif not tmp_nics: - tmp_nics = [{}] - - op = opcodes.OpInstanceCreate(instance_name=name, - disks=disks, - disk_template=specs["template"], - mode=constants.INSTANCE_CREATE, - os_type=specs["os"], - force_variant=specs["force_variant"], - pnode=specs["primary_node"], - snode=specs["secondary_node"], - nics=tmp_nics, - start=specs["start"], - ip_check=specs["ip_check"], - name_check=specs["name_check"], - wait_for_sync=True, - iallocator=specs["iallocator"], - hypervisor=hypervisor, - hvparams=hvparams, - beparams=specs["backend"], - file_storage_dir=specs["file_storage_dir"], - file_driver=specs["file_driver"]) - - jex.QueueJob(name, op) - # we never want to wait, just show the submitted job IDs - jex.WaitOrShow(False) + op = opcodes.OpInstanceMultiAlloc(iallocator=opts.iallocator, + instances=instances) + result = SubmitOrSend(op, opts, cl=cl) - return 0 + # Keep track of submitted jobs + jex = JobExecutor(cl=cl, opts=opts) + + for (status, job_id) in result[constants.JOB_IDS_KEY]: + jex.AddJobId(None, status, job_id) + + results = jex.GetResults() + bad_cnt = len([row for row in results if not row[0]]) + if bad_cnt == 0: + ToStdout("All instances created successfully.") + rcode = constants.EXIT_SUCCESS + else: + ToStdout("There were %s errors during the creation.", bad_cnt) + rcode = constants.EXIT_FAILURE + + return rcode def ReinstallInstance(opts, args): @@ -486,10 +395,44 @@ def ReinstallInstance(opts, args): osparams=opts.osparams) jex.QueueJob(instance_name, op) - jex.WaitOrShow(not opts.submit_only) - return 0 + results = jex.WaitOrShow(not opts.submit_only) + + if compat.all(map(compat.fst, results)): + return constants.EXIT_SUCCESS + else: + return constants.EXIT_FAILURE +def SnapshotInstance(opts, args): + """Snapshot an instance. + + @param opts: the command line options selected by the user + @type args: list + @param args: should contain only one element, the name of the + instance to be reinstalled + @rtype: int + @return: the desired exit code + + """ + instance_name = args[0] + inames = _ExpandMultiNames(_EXPAND_INSTANCES, [instance_name]) + if not inames: + raise errors.OpPrereqError("Selection filter does not match any instances", + errors.ECODE_INVAL) + multi_on = len(inames) > 1 + jex = JobExecutor(verbose=multi_on, opts=opts) + for instance_name in inames: + op = opcodes.OpInstanceSnapshot(instance_name=instance_name, + disks=opts.disks) + jex.QueueJob(instance_name, op) + + results = jex.WaitOrShow(not opts.submit_only) + + if compat.all(map(compat.fst, results)): + return constants.EXIT_SUCCESS + else: + return constants.EXIT_FAILURE + def RemoveInstance(opts, args): """Remove an instance. @@ -516,7 +459,8 @@ def RemoveInstance(opts, args): op = opcodes.OpInstanceRemove(instance_name=instance_name, ignore_failures=opts.ignore_failures, - shutdown_timeout=opts.shutdown_timeout) + shutdown_timeout=opts.shutdown_timeout, + keep_disks=opts.keep_disks) SubmitOrSend(op, opts, cl=cl) return 0 @@ -566,7 +510,8 @@ def ActivateDisks(opts, args): """ instance_name = args[0] op = opcodes.OpInstanceActivateDisks(instance_name=instance_name, - ignore_size=opts.ignore_size) + ignore_size=opts.ignore_size, + wait_for_sync=opts.wait_for_sync) disks_info = SubmitOrSend(op, opts) for host, iname, nname in disks_info: ToStdout("%s:%s:%s", host, iname, nname) @@ -613,7 +558,7 @@ def RecreateDisks(opts, args): if not ht.TDict(ddict): msg = "Invalid disk/%d value: expected dict, got %s" % (didx, ddict) - raise errors.OpPrereqError(msg) + raise errors.OpPrereqError(msg, errors.ECODE_INVAL) if constants.IDISK_SIZE in ddict: try: @@ -621,7 +566,7 @@ def RecreateDisks(opts, args): utils.ParseUnit(ddict[constants.IDISK_SIZE]) except ValueError, err: raise errors.OpPrereqError("Invalid disk size for disk %d: %s" % - (didx, err)) + (didx, err), errors.ECODE_INVAL) disks.append((didx, ddict)) @@ -629,6 +574,9 @@ def RecreateDisks(opts, args): # LUInstanceRecreateDisks, but it'd be nice to have in the client) if opts.node: + if opts.iallocator: + msg = "At most one of either --nodes or --iallocator can be passed" + raise errors.OpPrereqError(msg, errors.ECODE_INVAL) pnode, snode = SplitNodeOption(opts.node) nodes = [pnode] if snode is not None: @@ -637,7 +585,8 @@ def RecreateDisks(opts, args): nodes = [] op = opcodes.OpInstanceRecreateDisks(instance_name=instance_name, - disks=disks, nodes=nodes) + disks=disks, nodes=nodes, + iallocator=opts.iallocator) SubmitOrSend(op, opts) return 0 @@ -727,6 +676,7 @@ def _ShutdownInstance(name, opts): """ return opcodes.OpInstanceShutdown(instance_name=name, + force=opts.force, timeout=opts.timeout, ignore_offline_nodes=opts.ignore_offline, no_remember=opts.no_remember) @@ -1007,8 +957,8 @@ def _FormatLogicalID(dev_type, logical_id, roman): convert=roman))), ("nodeB", "%s, minor=%s" % (node_b, compat.TryToRoman(minor_b, convert=roman))), - ("port", compat.TryToRoman(port, convert=roman)), - ("auth key", key), + ("port", str(compat.TryToRoman(port, convert=roman))), + ("auth key", str(key)), ] elif dev_type == constants.LD_LV: vg_name, lv_name = logical_id @@ -1019,6 +969,10 @@ def _FormatLogicalID(dev_type, logical_id, roman): return data +def _FormatListInfo(data): + return list(str(i) for i in data) + + def _FormatBlockDevInfo(idx, top_level, dev, roman): """Show block device information. @@ -1101,9 +1055,8 @@ def _FormatBlockDevInfo(idx, top_level, dev, roman): if isinstance(dev["size"], int): nice_size = utils.FormatUnit(dev["size"], "h") else: - nice_size = dev["size"] - d1 = ["- %s: %s, size %s" % (txt, dev["dev_type"], nice_size)] - data = [] + nice_size = str(dev["size"]) + data = [(txt, "%s, size %s" % (dev["dev_type"], nice_size))] if top_level: data.append(("access mode", dev["mode"])) if dev["logical_id"] is not None: @@ -1116,8 +1069,7 @@ def _FormatBlockDevInfo(idx, top_level, dev, roman): else: data.extend(l_id) elif dev["physical_id"] is not None: - data.append("physical_id:") - data.append([dev["physical_id"]]) + data.append(("physical_id:", _FormatListInfo(dev["physical_id"]))) if dev["pstatus"]: data.append(("on primary", helper(dev["dev_type"], dev["pstatus"]))) @@ -1125,41 +1077,126 @@ def _FormatBlockDevInfo(idx, top_level, dev, roman): if dev["sstatus"]: data.append(("on secondary", helper(dev["dev_type"], dev["sstatus"]))) - if dev["children"]: - data.append("child devices:") - for c_idx, child in enumerate(dev["children"]): - data.append(_FormatBlockDevInfo(c_idx, False, child, roman)) - d1.append(data) - return d1 - - -def _FormatList(buf, data, indent_level): - """Formats a list of data at a given indent level. + data.append(("name", dev["name"])) + data.append(("UUID", dev["uuid"])) - If the element of the list is: - - a string, it is simply formatted as is - - a tuple, it will be split into key, value and the all the - values in a list will be aligned all at the same start column - - a list, will be recursively formatted + if dev["children"]: + data.append(("child devices", [ + _FormatBlockDevInfo(c_idx, False, child, roman) + for c_idx, child in enumerate(dev["children"]) + ])) + return data - @type buf: StringIO - @param buf: the buffer into which we write the output - @param data: the list to format - @type indent_level: int - @param indent_level: the indent level to format at - """ - max_tlen = max([len(elem[0]) for elem in data - if isinstance(elem, tuple)] or [0]) - for elem in data: - if isinstance(elem, basestring): - buf.write("%*s%s\n" % (2 * indent_level, "", elem)) - elif isinstance(elem, tuple): - key, value = elem - spacer = "%*s" % (max_tlen - len(key), "") - buf.write("%*s%s:%s %s\n" % (2 * indent_level, "", key, spacer, value)) - elif isinstance(elem, list): - _FormatList(buf, elem, indent_level + 1) +def _FormatInstanceNicInfo(idx, nic): + """Helper function for L{_FormatInstanceInfo()}""" + (name, uuid, ip, mac, mode, link, _, netinfo) = nic + network_name = None + if netinfo: + network_name = netinfo["name"] + return [ + ("nic/%d" % idx, ""), + ("MAC", str(mac)), + ("IP", str(ip)), + ("mode", str(mode)), + ("link", str(link)), + ("network", str(network_name)), + ("UUID", str(uuid)), + ("name", str(name)), + ] + + +def _FormatInstanceNodesInfo(instance): + """Helper function for L{_FormatInstanceInfo()}""" + pgroup = ("%s (UUID %s)" % + (instance["pnode_group_name"], instance["pnode_group_uuid"])) + secs = utils.CommaJoin(("%s (group %s, group UUID %s)" % + (name, group_name, group_uuid)) + for (name, group_name, group_uuid) in + zip(instance["snodes"], + instance["snodes_group_names"], + instance["snodes_group_uuids"])) + return [ + [ + ("primary", instance["pnode"]), + ("group", pgroup), + ], + [("secondaries", secs)], + ] + + +def _GetVncConsoleInfo(instance): + """Helper function for L{_FormatInstanceInfo()}""" + vnc_bind_address = instance["hv_actual"].get(constants.HV_VNC_BIND_ADDRESS, + None) + if vnc_bind_address: + port = instance["network_port"] + display = int(port) - constants.VNC_BASE_PORT + if display > 0 and vnc_bind_address == constants.IP4_ADDRESS_ANY: + vnc_console_port = "%s:%s (display %s)" % (instance["pnode"], + port, + display) + elif display > 0 and netutils.IP4Address.IsValid(vnc_bind_address): + vnc_console_port = ("%s:%s (node %s) (display %s)" % + (vnc_bind_address, port, + instance["pnode"], display)) + else: + # vnc bind address is a file + vnc_console_port = "%s:%s" % (instance["pnode"], + vnc_bind_address) + ret = "vnc to %s" % vnc_console_port + else: + ret = None + return ret + + +def _FormatInstanceInfo(instance, roman_integers): + """Format instance information for L{cli.PrintGenericInfo()}""" + istate = "configured to be %s" % instance["config_state"] + if instance["run_state"]: + istate += ", actual state is %s" % instance["run_state"] + info = [ + ("Instance name", instance["name"]), + ("UUID", instance["uuid"]), + ("Serial number", + str(compat.TryToRoman(instance["serial_no"], convert=roman_integers))), + ("Creation time", utils.FormatTime(instance["ctime"])), + ("Modification time", utils.FormatTime(instance["mtime"])), + ("State", istate), + ("Nodes", _FormatInstanceNodesInfo(instance)), + ("Operating system", instance["os"]), + ("Operating system parameters", + FormatParamsDictInfo(instance["os_instance"], instance["os_actual"])), + ] + + if "network_port" in instance: + info.append(("Allocated network port", + str(compat.TryToRoman(instance["network_port"], + convert=roman_integers)))) + info.append(("Hypervisor", instance["hypervisor"])) + console = _GetVncConsoleInfo(instance) + if console: + info.append(("console connection", console)) + # deprecated "memory" value, kept for one version for compatibility + # TODO(ganeti 2.7) remove. + be_actual = copy.deepcopy(instance["be_actual"]) + be_actual["memory"] = be_actual[constants.BE_MAXMEM] + info.extend([ + ("Hypervisor parameters", + FormatParamsDictInfo(instance["hv_instance"], instance["hv_actual"])), + ("Back-end parameters", + FormatParamsDictInfo(instance["be_instance"], be_actual)), + ("NICs", [ + _FormatInstanceNicInfo(idx, nic) + for (idx, nic) in enumerate(instance["nics"]) + ]), + ("Disk template", instance["disk_template"]), + ("Disks", [ + _FormatBlockDevInfo(idx, True, device, roman_integers) + for (idx, device) in enumerate(instance["disks"]) + ]), + ]) + return info def ShowInstanceConfig(opts, args): @@ -1190,84 +1227,10 @@ def ShowInstanceConfig(opts, args): ToStdout("No instances.") return 1 - buf = StringIO() - retcode = 0 - for instance_name in result: - instance = result[instance_name] - buf.write("Instance name: %s\n" % instance["name"]) - buf.write("UUID: %s\n" % instance["uuid"]) - buf.write("Serial number: %s\n" % - compat.TryToRoman(instance["serial_no"], - convert=opts.roman_integers)) - buf.write("Creation time: %s\n" % utils.FormatTime(instance["ctime"])) - buf.write("Modification time: %s\n" % utils.FormatTime(instance["mtime"])) - buf.write("State: configured to be %s" % instance["config_state"]) - if instance["run_state"]: - buf.write(", actual state is %s" % instance["run_state"]) - buf.write("\n") - ##buf.write("Considered for memory checks in cluster verify: %s\n" % - ## instance["auto_balance"]) - buf.write(" Nodes:\n") - buf.write(" - primary: %s\n" % instance["pnode"]) - buf.write(" group: %s (UUID %s)\n" % - (instance["pnode_group_name"], instance["pnode_group_uuid"])) - buf.write(" - secondaries: %s\n" % - utils.CommaJoin("%s (group %s, group UUID %s)" % - (name, group_name, group_uuid) - for (name, group_name, group_uuid) in - zip(instance["snodes"], - instance["snodes_group_names"], - instance["snodes_group_uuids"]))) - buf.write(" Operating system: %s\n" % instance["os"]) - FormatParameterDict(buf, instance["os_instance"], instance["os_actual"], - level=2) - if "network_port" in instance: - buf.write(" Allocated network port: %s\n" % - compat.TryToRoman(instance["network_port"], - convert=opts.roman_integers)) - buf.write(" Hypervisor: %s\n" % instance["hypervisor"]) - - # custom VNC console information - vnc_bind_address = instance["hv_actual"].get(constants.HV_VNC_BIND_ADDRESS, - None) - if vnc_bind_address: - port = instance["network_port"] - display = int(port) - constants.VNC_BASE_PORT - if display > 0 and vnc_bind_address == constants.IP4_ADDRESS_ANY: - vnc_console_port = "%s:%s (display %s)" % (instance["pnode"], - port, - display) - elif display > 0 and netutils.IP4Address.IsValid(vnc_bind_address): - vnc_console_port = ("%s:%s (node %s) (display %s)" % - (vnc_bind_address, port, - instance["pnode"], display)) - else: - # vnc bind address is a file - vnc_console_port = "%s:%s" % (instance["pnode"], - vnc_bind_address) - buf.write(" - console connection: vnc to %s\n" % vnc_console_port) - - FormatParameterDict(buf, instance["hv_instance"], instance["hv_actual"], - level=2) - buf.write(" Hardware:\n") - # deprecated "memory" value, kept for one version for compatibility - # TODO(ganeti 2.7) remove. - be_actual = copy.deepcopy(instance["be_actual"]) - be_actual["memory"] = be_actual[constants.BE_MAXMEM] - FormatParameterDict(buf, instance["be_instance"], be_actual, level=2) - # TODO(ganeti 2.7) rework the NICs as well - buf.write(" - NICs:\n") - for idx, (ip, mac, mode, link) in enumerate(instance["nics"]): - buf.write(" - nic/%d: MAC: %s, IP: %s, mode: %s, link: %s\n" % - (idx, mac, ip, mode, link)) - buf.write(" Disk template: %s\n" % instance["disk_template"]) - buf.write(" Disks:\n") - - for idx, device in enumerate(instance["disks"]): - _FormatList(buf, _FormatBlockDevInfo(idx, True, device, - opts.roman_integers), 2) - - ToStdout(buf.getvalue().rstrip("\n")) + PrintGenericInfo([ + _FormatInstanceInfo(instance, opts.roman_integers) + for instance in result.values() + ]) return retcode @@ -1287,35 +1250,37 @@ def _ConvertNicDiskModifications(mods): """ result = [] - for (idx, params) in mods: - if idx == constants.DDM_ADD: + for (identifier, params) in mods: + if identifier == constants.DDM_ADD: # Add item as last item (legacy interface) action = constants.DDM_ADD - idxno = -1 - elif idx == constants.DDM_REMOVE: + identifier = -1 + elif identifier == constants.DDM_REMOVE: # Remove last item (legacy interface) action = constants.DDM_REMOVE - idxno = -1 + identifier = -1 else: # Modifications and adding/removing at arbitrary indices - try: - idxno = int(idx) - except (TypeError, ValueError): - raise errors.OpPrereqError("Non-numeric index '%s'" % idx, - errors.ECODE_INVAL) - add = params.pop(constants.DDM_ADD, _MISSING) remove = params.pop(constants.DDM_REMOVE, _MISSING) + modify = params.pop(constants.DDM_MODIFY, _MISSING) + + if modify is _MISSING: + if not (add is _MISSING or remove is _MISSING): + raise errors.OpPrereqError("Cannot add and remove at the same time", + errors.ECODE_INVAL) + elif add is not _MISSING: + action = constants.DDM_ADD + elif remove is not _MISSING: + action = constants.DDM_REMOVE + else: + action = constants.DDM_MODIFY - if not (add is _MISSING or remove is _MISSING): - raise errors.OpPrereqError("Cannot add and remove at the same time", - errors.ECODE_INVAL) - elif add is not _MISSING: - action = constants.DDM_ADD - elif remove is not _MISSING: - action = constants.DDM_REMOVE - else: + elif add is _MISSING and remove is _MISSING: action = constants.DDM_MODIFY + else: + raise errors.OpPrereqError("Cannot modify and add/remove at the" + " same time", errors.ECODE_INVAL) assert not (constants.DDMS_VALUES_WITH_MODIFY & set(params.keys())) @@ -1323,7 +1288,7 @@ def _ConvertNicDiskModifications(mods): raise errors.OpPrereqError("Not accepting parameters on removal", errors.ECODE_INVAL) - result.append((action, idxno, params)) + result.append((action, identifier, params)) return result @@ -1357,7 +1322,8 @@ def SetInstanceParams(opts, args): """ if not (opts.nics or opts.disks or opts.disk_template or opts.hvparams or opts.beparams or opts.os or opts.osparams or - opts.offline_inst or opts.online_inst or opts.runtime_mem): + opts.offline_inst or opts.online_inst or opts.runtime_mem or + opts.new_primary_node): ToStderr("Please give at least one of the parameters.") return 1 @@ -1378,6 +1344,14 @@ def SetInstanceParams(opts, args): allowed_values=[constants.VALUE_DEFAULT]) nics = _ConvertNicDiskModifications(opts.nics) + for action, _, __ in nics: + if action == constants.DDM_MODIFY and opts.hotplug: + usertext = ("You are about to hot-modify a NIC. This will be done" + " by removing the exisiting and then adding a new one." + " Network connection might be lost. Continue?") + if not AskUser(usertext): + return 1 + disks = _ParseDiskSizes(_ConvertNicDiskModifications(opts.disks)) if (opts.disk_template and @@ -1397,8 +1371,12 @@ def SetInstanceParams(opts, args): op = opcodes.OpInstanceSetParams(instance_name=args[0], nics=nics, disks=disks, + hotplug=opts.hotplug, + hotplug_if_possible=opts.hotplug_if_possible, + keep_disks=opts.keep_disks, disk_template=opts.disk_template, remote_node=opts.node, + pnode=opts.new_primary_node, hvparams=opts.hvparams, beparams=opts.beparams, runtime_mem=opts.runtime_mem, @@ -1408,6 +1386,7 @@ def SetInstanceParams(opts, args): force=opts.force, wait_for_sync=opts.wait_for_sync, offline=offline, + conflicts_check=opts.conflicts_check, ignore_ipolicy=opts.ignore_ipolicy) # even if here we process the result, we allow submit only @@ -1417,8 +1396,11 @@ def SetInstanceParams(opts, args): ToStdout("Modified instance %s", args[0]) for param, data in result: ToStdout(" - %-5s -> %s", param, data) - ToStdout("Please don't forget that most parameters take effect" - " only at the next start of the instance.") + if not opts.hotplug: + ToStdout("Please don't forget that most parameters take effect" + " only at the next (re)start of the instance initiated by" + " ganeti; restarting from within the instance will" + " not be enough.") return 0 @@ -1516,7 +1498,8 @@ commands = { "[...] -t disk-type -n node[:secondary-node] -o os-type ", "Creates and adds a new instance to the cluster"), "batch-create": ( - BatchCreate, [ArgFile(min=1, max=1)], [DRY_RUN_OPT, PRIORITY_OPT], + BatchCreate, [ArgFile(min=1, max=1)], + [DRY_RUN_OPT, PRIORITY_OPT, IALLOCATOR_OPT, SUBMIT_OPT], "", "Create a bunch of instances based on specs in the file."), "console": ( @@ -1527,7 +1510,7 @@ commands = { FailoverInstance, ARGS_ONE_INSTANCE, [FORCE_OPT, IGNORE_CONSIST_OPT, SUBMIT_OPT, SHUTDOWN_TIMEOUT_OPT, DRY_RUN_OPT, PRIORITY_OPT, DST_NODE_OPT, IALLOCATOR_OPT, - IGNORE_IPOLICY_OPT], + IGNORE_IPOLICY_OPT, CLEANUP_OPT], "[-f] ", "Stops the instance, changes its primary node and" " (if it was originally running) starts it on the new node" " (the secondary for mirrored instances or any node" @@ -1572,10 +1555,14 @@ commands = { m_pri_node_tags_opt, m_sec_node_tags_opt, m_inst_tags_opt, SELECT_OS_OPT, SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT, OSPARAMS_OPT], "[-f] ", "Reinstall a stopped instance"), + "snapshot": ( + SnapshotInstance, [ArgInstance(min=1,max=1)], + [DISK_OPT, SUBMIT_OPT, DRY_RUN_OPT], + "", "Snapshot an instance's disk(s)"), "remove": ( RemoveInstance, ARGS_ONE_INSTANCE, [FORCE_OPT, SHUTDOWN_TIMEOUT_OPT, IGNORE_FAILURES_OPT, SUBMIT_OPT, - DRY_RUN_OPT, PRIORITY_OPT], + DRY_RUN_OPT, PRIORITY_OPT, KEEPDISKS_OPT], "[-f] ", "Shuts down the instance and removes it"), "rename": ( RenameInstance, @@ -1587,18 +1574,20 @@ commands = { [AUTO_REPLACE_OPT, DISKIDX_OPT, IALLOCATOR_OPT, EARLY_RELEASE_OPT, NEW_SECONDARY_OPT, ON_PRIMARY_OPT, ON_SECONDARY_OPT, SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT, IGNORE_IPOLICY_OPT], - "[-s|-p|-n NODE|-I NAME] ", - "Replaces all disks for the instance"), + "[-s|-p|-a|-n NODE|-I NAME] ", + "Replaces disks for the instance"), "modify": ( SetInstanceParams, ARGS_ONE_INSTANCE, [BACKEND_OPT, DISK_OPT, FORCE_OPT, HVOPTS_OPT, NET_OPT, SUBMIT_OPT, DISK_TEMPLATE_OPT, SINGLE_NODE_OPT, OS_OPT, FORCE_VARIANT_OPT, OSPARAMS_OPT, DRY_RUN_OPT, PRIORITY_OPT, NWSYNC_OPT, OFFLINE_INST_OPT, - ONLINE_INST_OPT, IGNORE_IPOLICY_OPT, RUNTIME_MEM_OPT], + ONLINE_INST_OPT, IGNORE_IPOLICY_OPT, RUNTIME_MEM_OPT, + NOCONFLICTSCHECK_OPT, NEW_PRIMARY_OPT, HOTPLUG_OPT, KEEPDISKS_OPT, + HOTPLUG_IF_POSSIBLE_OPT], "", "Alters the parameters of an instance"), "shutdown": ( GenericManyOps("shutdown", _ShutdownInstance), [ArgInstance()], - [m_node_opt, m_pri_node_opt, m_sec_node_opt, m_clust_opt, + [FORCE_OPT, m_node_opt, m_pri_node_opt, m_sec_node_opt, m_clust_opt, m_node_tags_opt, m_pri_node_tags_opt, m_sec_node_tags_opt, m_inst_tags_opt, m_inst_opt, m_force_multi, TIMEOUT_OPT, SUBMIT_OPT, DRY_RUN_OPT, PRIORITY_OPT, IGNORE_OFFLINE_OPT, NO_REMEMBER_OPT], @@ -1620,7 +1609,7 @@ commands = { "", "Reboots an instance"), "activate-disks": ( ActivateDisks, ARGS_ONE_INSTANCE, - [SUBMIT_OPT, IGNORE_SIZE_OPT, PRIORITY_OPT], + [SUBMIT_OPT, IGNORE_SIZE_OPT, PRIORITY_OPT, WFSYNC_OPT], "", "Activate an instance's disks"), "deactivate-disks": ( DeactivateDisks, ARGS_ONE_INSTANCE, @@ -1628,7 +1617,8 @@ commands = { "[-f] ", "Deactivate an instance's disks"), "recreate-disks": ( RecreateDisks, ARGS_ONE_INSTANCE, - [SUBMIT_OPT, DISK_OPT, NODE_PLACEMENT_OPT, DRY_RUN_OPT, PRIORITY_OPT], + [SUBMIT_OPT, DISK_OPT, NODE_PLACEMENT_OPT, DRY_RUN_OPT, PRIORITY_OPT, + IALLOCATOR_OPT], "", "Recreate an instance's disks"), "grow-disk": ( GrowDisk,