Revision 75c7520f lib/cmdlib.py
| b/lib/cmdlib.py | ||
|---|---|---|
| 4048 | 4048 |
if query.IQ_DISKUSAGE in self.requested_data: |
| 4049 | 4049 |
disk_usage = dict((inst.name, |
| 4050 | 4050 |
_ComputeDiskSize(inst.disk_template, |
| 4051 |
[{"size": disk.size}
|
|
| 4051 |
[{constants.IDISK_SIZE: disk.size}
|
|
| 4052 | 4052 |
for disk in inst.disks])) |
| 4053 | 4053 |
for inst in instance_list) |
| 4054 | 4054 |
else: |
| ... | ... | |
| 6954 | 6954 |
for i in range(disk_count)]) |
| 6955 | 6955 |
for idx, disk in enumerate(disk_info): |
| 6956 | 6956 |
disk_index = idx + base_index |
| 6957 |
vg = disk.get("vg", vgname)
|
|
| 6957 |
vg = disk.get(constants.IDISK_VG, vgname)
|
|
| 6958 | 6958 |
feedback_fn("* disk %i, vg %s, name %s" % (idx, vg, names[idx]))
|
| 6959 |
disk_dev = objects.Disk(dev_type=constants.LD_LV, size=disk["size"], |
|
| 6959 |
disk_dev = objects.Disk(dev_type=constants.LD_LV, |
|
| 6960 |
size=disk[constants.IDISK_SIZE], |
|
| 6960 | 6961 |
logical_id=(vg, names[idx]), |
| 6961 | 6962 |
iv_name="disk/%d" % disk_index, |
| 6962 |
mode=disk["mode"])
|
|
| 6963 |
mode=disk[constants.IDISK_MODE])
|
|
| 6963 | 6964 |
disks.append(disk_dev) |
| 6964 | 6965 |
elif template_name == constants.DT_DRBD8: |
| 6965 | 6966 |
if len(secondary_nodes) != 1: |
| ... | ... | |
| 6975 | 6976 |
names.append(lv_prefix + "_meta") |
| 6976 | 6977 |
for idx, disk in enumerate(disk_info): |
| 6977 | 6978 |
disk_index = idx + base_index |
| 6978 |
vg = disk.get("vg", vgname)
|
|
| 6979 |
vg = disk.get(constants.IDISK_VG, vgname)
|
|
| 6979 | 6980 |
disk_dev = _GenerateDRBD8Branch(lu, primary_node, remote_node, |
| 6980 |
disk["size"], vg, names[idx*2:idx*2+2], |
|
| 6981 |
disk[constants.IDISK_SIZE], vg, |
|
| 6982 |
names[idx * 2:idx * 2 + 2], |
|
| 6981 | 6983 |
"disk/%d" % disk_index, |
| 6982 |
minors[idx*2], minors[idx*2+1])
|
|
| 6983 |
disk_dev.mode = disk["mode"]
|
|
| 6984 |
minors[idx * 2], minors[idx * 2 + 1])
|
|
| 6985 |
disk_dev.mode = disk[constants.IDISK_MODE]
|
|
| 6984 | 6986 |
disks.append(disk_dev) |
| 6985 | 6987 |
elif template_name == constants.DT_FILE: |
| 6986 | 6988 |
if len(secondary_nodes) != 0: |
| ... | ... | |
| 6990 | 6992 |
|
| 6991 | 6993 |
for idx, disk in enumerate(disk_info): |
| 6992 | 6994 |
disk_index = idx + base_index |
| 6993 |
disk_dev = objects.Disk(dev_type=constants.LD_FILE, size=disk["size"], |
|
| 6995 |
disk_dev = objects.Disk(dev_type=constants.LD_FILE, |
|
| 6996 |
size=disk[constants.IDISK_SIZE], |
|
| 6994 | 6997 |
iv_name="disk/%d" % disk_index, |
| 6995 | 6998 |
logical_id=(file_driver, |
| 6996 | 6999 |
"%s/disk%d" % (file_storage_dir, |
| 6997 | 7000 |
disk_index)), |
| 6998 |
mode=disk["mode"])
|
|
| 7001 |
mode=disk[constants.IDISK_MODE])
|
|
| 6999 | 7002 |
disks.append(disk_dev) |
| 7000 | 7003 |
elif template_name == constants.DT_SHARED_FILE: |
| 7001 | 7004 |
if len(secondary_nodes) != 0: |
| ... | ... | |
| 7005 | 7008 |
|
| 7006 | 7009 |
for idx, disk in enumerate(disk_info): |
| 7007 | 7010 |
disk_index = idx + base_index |
| 7008 |
disk_dev = objects.Disk(dev_type=constants.LD_FILE, size=disk["size"], |
|
| 7011 |
disk_dev = objects.Disk(dev_type=constants.LD_FILE, |
|
| 7012 |
size=disk[constants.IDISK_SIZE], |
|
| 7009 | 7013 |
iv_name="disk/%d" % disk_index, |
| 7010 | 7014 |
logical_id=(file_driver, |
| 7011 | 7015 |
"%s/disk%d" % (file_storage_dir, |
| 7012 | 7016 |
disk_index)), |
| 7013 |
mode=disk["mode"])
|
|
| 7017 |
mode=disk[constants.IDISK_MODE])
|
|
| 7014 | 7018 |
disks.append(disk_dev) |
| 7015 | 7019 |
elif template_name == constants.DT_BLOCK: |
| 7016 | 7020 |
if len(secondary_nodes) != 0: |
| ... | ... | |
| 7018 | 7022 |
|
| 7019 | 7023 |
for idx, disk in enumerate(disk_info): |
| 7020 | 7024 |
disk_index = idx + base_index |
| 7021 |
disk_dev = objects.Disk(dev_type=constants.LD_BLOCKDEV, size=disk["size"], |
|
| 7025 |
disk_dev = objects.Disk(dev_type=constants.LD_BLOCKDEV, |
|
| 7026 |
size=disk[constants.IDISK_SIZE], |
|
| 7022 | 7027 |
logical_id=(constants.BLOCKDEV_DRIVER_MANUAL, |
| 7023 |
disk["adopt"]),
|
|
| 7028 |
disk[constants.IDISK_ADOPT]),
|
|
| 7024 | 7029 |
iv_name="disk/%d" % disk_index, |
| 7025 |
mode=disk["mode"])
|
|
| 7030 |
mode=disk[constants.IDISK_MODE])
|
|
| 7026 | 7031 |
disks.append(disk_dev) |
| 7027 | 7032 |
|
| 7028 | 7033 |
else: |
| ... | ... | |
| 7213 | 7218 |
|
| 7214 | 7219 |
""" |
| 7215 | 7220 |
def _compute(disks, payload): |
| 7216 |
"""Universal algorithm |
|
| 7221 |
"""Universal algorithm.
|
|
| 7217 | 7222 |
|
| 7218 | 7223 |
""" |
| 7219 | 7224 |
vgs = {}
|
| 7220 | 7225 |
for disk in disks: |
| 7221 |
vgs[disk["vg"]] = vgs.get("vg", 0) + disk["size"] + payload
|
|
| 7226 |
vgs[disk[constants.IDISK_VG]] = \ |
|
| 7227 |
vgs.get(constants.IDISK_VG, 0) + disk[constants.IDISK_MODE] + payload |
|
| 7222 | 7228 |
|
| 7223 | 7229 |
return vgs |
| 7224 | 7230 |
|
| ... | ... | |
| 7246 | 7252 |
# Required free disk space as a function of disk and swap space |
| 7247 | 7253 |
req_size_dict = {
|
| 7248 | 7254 |
constants.DT_DISKLESS: None, |
| 7249 |
constants.DT_PLAIN: sum(d["size"] for d in disks),
|
|
| 7255 |
constants.DT_PLAIN: sum(d[constants.IDISK_SIZE] for d in disks),
|
|
| 7250 | 7256 |
# 128 MB are added for drbd metadata for each disk |
| 7251 |
constants.DT_DRBD8: sum(d["size"] + 128 for d in disks),
|
|
| 7257 |
constants.DT_DRBD8: sum(d[constants.IDISK_SIZE] + 128 for d in disks),
|
|
| 7252 | 7258 |
constants.DT_FILE: None, |
| 7253 | 7259 |
constants.DT_SHARED_FILE: 0, |
| 7254 | 7260 |
constants.DT_BLOCK: 0, |
| ... | ... | |
| 7368 | 7374 |
has_adopt = has_no_adopt = False |
| 7369 | 7375 |
for disk in self.op.disks: |
| 7370 | 7376 |
utils.ForceDictType(disk, constants.IDISK_PARAMS_TYPES) |
| 7371 |
if "adopt" in disk:
|
|
| 7377 |
if constants.IDISK_ADOPT in disk:
|
|
| 7372 | 7378 |
has_adopt = True |
| 7373 | 7379 |
else: |
| 7374 | 7380 |
has_no_adopt = True |
| ... | ... | |
| 7607 | 7613 |
vcpus=self.be_full[constants.BE_VCPUS], |
| 7608 | 7614 |
nics=_NICListToTuple(self, self.nics), |
| 7609 | 7615 |
disk_template=self.op.disk_template, |
| 7610 |
disks=[(d["size"], d["mode"]) for d in self.disks], |
|
| 7616 |
disks=[(d[constants.IDISK_SIZE], d[constants.IDISK_MODE]) |
|
| 7617 |
for d in self.disks], |
|
| 7611 | 7618 |
bep=self.be_full, |
| 7612 | 7619 |
hvp=self.hv_full, |
| 7613 | 7620 |
hypervisor_name=self.op.hypervisor, |
| ... | ... | |
| 7694 | 7701 |
# TODO: import the disk iv_name too |
| 7695 | 7702 |
for idx in range(einfo.getint(constants.INISECT_INS, "disk_count")): |
| 7696 | 7703 |
disk_sz = einfo.getint(constants.INISECT_INS, "disk%d_size" % idx) |
| 7697 |
disks.append({"size": disk_sz})
|
|
| 7704 |
disks.append({constants.IDISK_SIZE: disk_sz})
|
|
| 7698 | 7705 |
self.op.disks = disks |
| 7699 | 7706 |
else: |
| 7700 | 7707 |
raise errors.OpPrereqError("No disk info specified and the export"
|
| ... | ... | |
| 7815 | 7822 |
# NIC buildup |
| 7816 | 7823 |
self.nics = [] |
| 7817 | 7824 |
for idx, nic in enumerate(self.op.nics): |
| 7818 |
nic_mode_req = nic.get("mode", None)
|
|
| 7825 |
nic_mode_req = nic.get(constants.INIC_MODE, None)
|
|
| 7819 | 7826 |
nic_mode = nic_mode_req |
| 7820 | 7827 |
if nic_mode is None: |
| 7821 | 7828 |
nic_mode = cluster.nicparams[constants.PP_DEFAULT][constants.NIC_MODE] |
| ... | ... | |
| 7827 | 7834 |
default_ip_mode = constants.VALUE_NONE |
| 7828 | 7835 |
|
| 7829 | 7836 |
# ip validity checks |
| 7830 |
ip = nic.get("ip", default_ip_mode)
|
|
| 7837 |
ip = nic.get(constants.INIC_IP, default_ip_mode)
|
|
| 7831 | 7838 |
if ip is None or ip.lower() == constants.VALUE_NONE: |
| 7832 | 7839 |
nic_ip = None |
| 7833 | 7840 |
elif ip.lower() == constants.VALUE_AUTO: |
| ... | ... | |
| 7848 | 7855 |
errors.ECODE_INVAL) |
| 7849 | 7856 |
|
| 7850 | 7857 |
# MAC address verification |
| 7851 |
mac = nic.get("mac", constants.VALUE_AUTO)
|
|
| 7858 |
mac = nic.get(constants.INIC_MAC, constants.VALUE_AUTO)
|
|
| 7852 | 7859 |
if mac not in (constants.VALUE_AUTO, constants.VALUE_GENERATE): |
| 7853 | 7860 |
mac = utils.NormalizeAndValidateMac(mac) |
| 7854 | 7861 |
|
| ... | ... | |
| 7872 | 7879 |
self.nics.append(objects.NIC(mac=mac, ip=nic_ip, nicparams=nicparams)) |
| 7873 | 7880 |
|
| 7874 | 7881 |
# disk checks/pre-build |
| 7882 |
default_vg = self.cfg.GetVGName() |
|
| 7875 | 7883 |
self.disks = [] |
| 7876 | 7884 |
for disk in self.op.disks: |
| 7877 |
mode = disk.get("mode", constants.DISK_RDWR)
|
|
| 7885 |
mode = disk.get(constants.IDISK_MODE, constants.DISK_RDWR)
|
|
| 7878 | 7886 |
if mode not in constants.DISK_ACCESS_SET: |
| 7879 | 7887 |
raise errors.OpPrereqError("Invalid disk access mode '%s'" %
|
| 7880 | 7888 |
mode, errors.ECODE_INVAL) |
| 7881 |
size = disk.get("size", None)
|
|
| 7889 |
size = disk.get(constants.IDISK_SIZE, None)
|
|
| 7882 | 7890 |
if size is None: |
| 7883 | 7891 |
raise errors.OpPrereqError("Missing disk size", errors.ECODE_INVAL)
|
| 7884 | 7892 |
try: |
| ... | ... | |
| 7886 | 7894 |
except (TypeError, ValueError): |
| 7887 | 7895 |
raise errors.OpPrereqError("Invalid disk size '%s'" % size,
|
| 7888 | 7896 |
errors.ECODE_INVAL) |
| 7889 |
vg = disk.get("vg", self.cfg.GetVGName())
|
|
| 7890 |
new_disk = {"size": size, "mode": mode, "vg": vg}
|
|
| 7891 |
if "adopt" in disk: |
|
| 7892 |
new_disk["adopt"] = disk["adopt"] |
|
| 7897 |
new_disk = {
|
|
| 7898 |
constants.IDISK_SIZE: size, |
|
| 7899 |
constants.IDISK_MODE: mode, |
|
| 7900 |
constants.IDISK_VG: disk.get(constants.IDISK_VG, default_vg), |
|
| 7901 |
} |
|
| 7902 |
if constants.IDISK_ADOPT in disk: |
|
| 7903 |
new_disk[constants.IDISK_ADOPT] = disk[constants.IDISK_ADOPT] |
|
| 7893 | 7904 |
self.disks.append(new_disk) |
| 7894 | 7905 |
|
| 7895 | 7906 |
if self.op.mode == constants.INSTANCE_IMPORT: |
| ... | ... | |
| 7991 | 8002 |
_CheckNodesFreeDiskPerVG(self, nodenames, req_sizes) |
| 7992 | 8003 |
|
| 7993 | 8004 |
elif self.op.disk_template == constants.DT_PLAIN: # Check the adoption data |
| 7994 |
all_lvs = set([i["vg"] + "/" + i["adopt"] for i in self.disks]) |
|
| 8005 |
all_lvs = set(["%s/%s" % (disk[constants.IDISK_VG], |
|
| 8006 |
disk[constants.IDISK_ADOPT]) |
|
| 8007 |
for disk in self.disks]) |
|
| 7995 | 8008 |
if len(all_lvs) != len(self.disks): |
| 7996 | 8009 |
raise errors.OpPrereqError("Duplicate volume names given for adoption",
|
| 7997 | 8010 |
errors.ECODE_INVAL) |
| ... | ... | |
| 8024 | 8037 |
errors.ECODE_STATE) |
| 8025 | 8038 |
# update the size of disk based on what is found |
| 8026 | 8039 |
for dsk in self.disks: |
| 8027 |
dsk["size"] = int(float(node_lvs[dsk["vg"] + "/" + dsk["adopt"]][0])) |
|
| 8040 |
dsk[constants.IDISK_SIZE] = \ |
|
| 8041 |
int(float(node_lvs["%s/%s" % (dsk[constants.IDISK_VG], |
|
| 8042 |
dsk[constants.IDISK_ADOPT])][0])) |
|
| 8028 | 8043 |
|
| 8029 | 8044 |
elif self.op.disk_template == constants.DT_BLOCK: |
| 8030 | 8045 |
# Normalize and de-duplicate device paths |
| 8031 |
all_disks = set([os.path.abspath(i["adopt"]) for i in self.disks]) |
|
| 8046 |
all_disks = set([os.path.abspath(disk[constants.IDISK_ADOPT]) |
|
| 8047 |
for disk in self.disks]) |
|
| 8032 | 8048 |
if len(all_disks) != len(self.disks): |
| 8033 | 8049 |
raise errors.OpPrereqError("Duplicate disk names given for adoption",
|
| 8034 | 8050 |
errors.ECODE_INVAL) |
| ... | ... | |
| 8052 | 8068 |
utils.CommaJoin(delta), |
| 8053 | 8069 |
errors.ECODE_INVAL) |
| 8054 | 8070 |
for dsk in self.disks: |
| 8055 |
dsk["size"] = int(float(node_disks[dsk["adopt"]])) |
|
| 8071 |
dsk[constants.IDISK_SIZE] = \ |
|
| 8072 |
int(float(node_disks[dsk[constants.IDISK_ADOPT]])) |
|
| 8056 | 8073 |
|
| 8057 | 8074 |
_CheckHVParams(self, nodenames, self.op.hypervisor, self.op.hvparams) |
| 8058 | 8075 |
|
| ... | ... | |
| 8132 | 8149 |
rename_to = [] |
| 8133 | 8150 |
for t_dsk, a_dsk in zip (tmp_disks, self.disks): |
| 8134 | 8151 |
rename_to.append(t_dsk.logical_id) |
| 8135 |
t_dsk.logical_id = (t_dsk.logical_id[0], a_dsk["adopt"])
|
|
| 8152 |
t_dsk.logical_id = (t_dsk.logical_id[0], a_dsk[constants.IDISK_ADOPT])
|
|
| 8136 | 8153 |
self.cfg.SetDiskID(t_dsk, pnode_name) |
| 8137 | 8154 |
result = self.rpc.call_blockdev_rename(pnode_name, |
| 8138 | 8155 |
zip(tmp_disks, rename_to)) |
| ... | ... | |
| 9517 | 9534 |
raise errors.OpPrereqError(msg, errors.ECODE_INVAL) |
| 9518 | 9535 |
|
| 9519 | 9536 |
if disk_op == constants.DDM_ADD: |
| 9520 |
mode = disk_dict.setdefault('mode', constants.DISK_RDWR)
|
|
| 9537 |
mode = disk_dict.setdefault(constants.IDISK_MODE, constants.DISK_RDWR)
|
|
| 9521 | 9538 |
if mode not in constants.DISK_ACCESS_SET: |
| 9522 | 9539 |
raise errors.OpPrereqError("Invalid disk access mode '%s'" % mode,
|
| 9523 | 9540 |
errors.ECODE_INVAL) |
| 9524 |
size = disk_dict.get('size', None)
|
|
| 9541 |
size = disk_dict.get(constants.IDISK_SIZE, None)
|
|
| 9525 | 9542 |
if size is None: |
| 9526 | 9543 |
raise errors.OpPrereqError("Required disk parameter size missing",
|
| 9527 | 9544 |
errors.ECODE_INVAL) |
| ... | ... | |
| 9530 | 9547 |
except (TypeError, ValueError), err: |
| 9531 | 9548 |
raise errors.OpPrereqError("Invalid disk size parameter: %s" %
|
| 9532 | 9549 |
str(err), errors.ECODE_INVAL) |
| 9533 |
disk_dict['size'] = size
|
|
| 9550 |
disk_dict[constants.IDISK_SIZE] = size
|
|
| 9534 | 9551 |
else: |
| 9535 | 9552 |
# modification of disk |
| 9536 |
if 'size' in disk_dict:
|
|
| 9553 |
if constants.IDISK_SIZE in disk_dict:
|
|
| 9537 | 9554 |
raise errors.OpPrereqError("Disk size change not possible, use"
|
| 9538 | 9555 |
" grow-disk", errors.ECODE_INVAL) |
| 9539 | 9556 |
|
| ... | ... | |
| 9570 | 9587 |
raise errors.OpPrereqError(msg, errors.ECODE_INVAL) |
| 9571 | 9588 |
|
| 9572 | 9589 |
# nic_dict should be a dict |
| 9573 |
nic_ip = nic_dict.get('ip', None)
|
|
| 9590 |
nic_ip = nic_dict.get(constants.INIC_IP, None)
|
|
| 9574 | 9591 |
if nic_ip is not None: |
| 9575 | 9592 |
if nic_ip.lower() == constants.VALUE_NONE: |
| 9576 |
nic_dict['ip'] = None
|
|
| 9593 |
nic_dict[constants.INIC_IP] = None
|
|
| 9577 | 9594 |
else: |
| 9578 | 9595 |
if not netutils.IPAddress.IsValid(nic_ip): |
| 9579 | 9596 |
raise errors.OpPrereqError("Invalid IP address '%s'" % nic_ip,
|
| 9580 | 9597 |
errors.ECODE_INVAL) |
| 9581 | 9598 |
|
| 9582 | 9599 |
nic_bridge = nic_dict.get('bridge', None)
|
| 9583 |
nic_link = nic_dict.get('link', None)
|
|
| 9600 |
nic_link = nic_dict.get(constants.INIC_LINK, None)
|
|
| 9584 | 9601 |
if nic_bridge and nic_link: |
| 9585 | 9602 |
raise errors.OpPrereqError("Cannot pass 'bridge' and 'link'"
|
| 9586 | 9603 |
" at the same time", errors.ECODE_INVAL) |
| 9587 | 9604 |
elif nic_bridge and nic_bridge.lower() == constants.VALUE_NONE: |
| 9588 | 9605 |
nic_dict['bridge'] = None |
| 9589 | 9606 |
elif nic_link and nic_link.lower() == constants.VALUE_NONE: |
| 9590 |
nic_dict['link'] = None
|
|
| 9607 |
nic_dict[constants.INIC_LINK] = None
|
|
| 9591 | 9608 |
|
| 9592 | 9609 |
if nic_op == constants.DDM_ADD: |
| 9593 |
nic_mac = nic_dict.get('mac', None)
|
|
| 9610 |
nic_mac = nic_dict.get(constants.INIC_MAC, None)
|
|
| 9594 | 9611 |
if nic_mac is None: |
| 9595 |
nic_dict['mac'] = constants.VALUE_AUTO
|
|
| 9612 |
nic_dict[constants.INIC_MAC] = constants.VALUE_AUTO
|
|
| 9596 | 9613 |
|
| 9597 |
if 'mac' in nic_dict:
|
|
| 9598 |
nic_mac = nic_dict['mac']
|
|
| 9614 |
if constants.INIC_MAC in nic_dict:
|
|
| 9615 |
nic_mac = nic_dict[constants.INIC_MAC]
|
|
| 9599 | 9616 |
if nic_mac not in (constants.VALUE_AUTO, constants.VALUE_GENERATE): |
| 9600 | 9617 |
nic_mac = utils.NormalizeAndValidateMac(nic_mac) |
| 9601 | 9618 |
|
| ... | ... | |
| 9641 | 9658 |
this_nic_override = nic_override[idx] |
| 9642 | 9659 |
else: |
| 9643 | 9660 |
this_nic_override = {}
|
| 9644 |
if 'ip' in this_nic_override:
|
|
| 9645 |
ip = this_nic_override['ip']
|
|
| 9661 |
if constants.INIC_IP in this_nic_override:
|
|
| 9662 |
ip = this_nic_override[constants.INIC_IP]
|
|
| 9646 | 9663 |
else: |
| 9647 | 9664 |
ip = nic.ip |
| 9648 |
if 'mac' in this_nic_override:
|
|
| 9649 |
mac = this_nic_override['mac']
|
|
| 9665 |
if constants.INIC_MAC in this_nic_override:
|
|
| 9666 |
mac = this_nic_override[constants.INIC_MAC]
|
|
| 9650 | 9667 |
else: |
| 9651 | 9668 |
mac = nic.mac |
| 9652 | 9669 |
if idx in self.nic_pnew: |
| ... | ... | |
| 9657 | 9674 |
link = nicparams[constants.NIC_LINK] |
| 9658 | 9675 |
args['nics'].append((ip, mac, mode, link)) |
| 9659 | 9676 |
if constants.DDM_ADD in nic_override: |
| 9660 |
ip = nic_override[constants.DDM_ADD].get('ip', None)
|
|
| 9661 |
mac = nic_override[constants.DDM_ADD]['mac']
|
|
| 9677 |
ip = nic_override[constants.DDM_ADD].get(constants.INIC_IP, None)
|
|
| 9678 |
mac = nic_override[constants.DDM_ADD][constants.INIC_MAC]
|
|
| 9662 | 9679 |
nicparams = self.nic_pnew[constants.DDM_ADD] |
| 9663 | 9680 |
mode = nicparams[constants.NIC_MODE] |
| 9664 | 9681 |
link = nicparams[constants.NIC_LINK] |
| ... | ... | |
| 9723 | 9740 |
_CheckNodeNotDrained(self, self.op.remote_node) |
| 9724 | 9741 |
# FIXME: here we assume that the old instance type is DT_PLAIN |
| 9725 | 9742 |
assert instance.disk_template == constants.DT_PLAIN |
| 9726 |
disks = [{"size": d.size, "vg": d.logical_id[0]}
|
|
| 9743 |
disks = [{constants.IDISK_SIZE: d.size,
|
|
| 9744 |
constants.IDISK_VG: d.logical_id[0]} |
|
| 9727 | 9745 |
for d in instance.disks] |
| 9728 | 9746 |
required = _ComputeDiskSizePerVG(self.op.disk_template, disks) |
| 9729 | 9747 |
_CheckNodesFreeDiskPerVG(self, [self.op.remote_node], required) |
| ... | ... | |
| 9868 | 9886 |
else: |
| 9869 | 9887 |
raise errors.OpPrereqError(msg, errors.ECODE_ENVIRON) |
| 9870 | 9888 |
if new_nic_mode == constants.NIC_MODE_ROUTED: |
| 9871 |
if 'ip' in nic_dict:
|
|
| 9872 |
nic_ip = nic_dict['ip']
|
|
| 9889 |
if constants.INIC_IP in nic_dict:
|
|
| 9890 |
nic_ip = nic_dict[constants.INIC_IP]
|
|
| 9873 | 9891 |
else: |
| 9874 | 9892 |
nic_ip = old_nic_ip |
| 9875 | 9893 |
if nic_ip is None: |
| 9876 | 9894 |
raise errors.OpPrereqError('Cannot set the nic ip to None'
|
| 9877 | 9895 |
' on a routed nic', errors.ECODE_INVAL) |
| 9878 |
if 'mac' in nic_dict:
|
|
| 9879 |
nic_mac = nic_dict['mac']
|
|
| 9896 |
if constants.INIC_MAC in nic_dict:
|
|
| 9897 |
nic_mac = nic_dict[constants.INIC_MAC]
|
|
| 9880 | 9898 |
if nic_mac is None: |
| 9881 | 9899 |
raise errors.OpPrereqError('Cannot set the nic mac to None',
|
| 9882 | 9900 |
errors.ECODE_INVAL) |
| 9883 | 9901 |
elif nic_mac in (constants.VALUE_AUTO, constants.VALUE_GENERATE): |
| 9884 | 9902 |
# otherwise generate the mac |
| 9885 |
nic_dict['mac'] = self.cfg.GenerateMAC(self.proc.GetECId()) |
|
| 9903 |
nic_dict[constants.INIC_MAC] = \ |
|
| 9904 |
self.cfg.GenerateMAC(self.proc.GetECId()) |
|
| 9886 | 9905 |
else: |
| 9887 | 9906 |
# or validate/reserve the current one |
| 9888 | 9907 |
try: |
| ... | ... | |
| 9929 | 9948 |
snode = self.op.remote_node |
| 9930 | 9949 |
|
| 9931 | 9950 |
# create a fake disk info for _GenerateDiskTemplate |
| 9932 |
disk_info = [{"size": d.size, "mode": d.mode} for d in instance.disks]
|
|
| 9951 |
disk_info = [{constants.IDISK_SIZE: d.size, constants.IDISK_MODE: d.mode}
|
|
| 9952 |
for d in instance.disks] |
|
| 9933 | 9953 |
new_disks = _GenerateDiskTemplate(self, self.op.disk_template, |
| 9934 | 9954 |
instance.name, pnode, [snode], |
| 9935 | 9955 |
disk_info, None, None, 0, feedback_fn) |
| ... | ... | |
| 10071 | 10091 |
(new_disk.size, new_disk.mode))) |
| 10072 | 10092 |
else: |
| 10073 | 10093 |
# change a given disk |
| 10074 |
instance.disks[disk_op].mode = disk_dict['mode'] |
|
| 10075 |
result.append(("disk.mode/%d" % disk_op, disk_dict['mode']))
|
|
| 10094 |
instance.disks[disk_op].mode = disk_dict[constants.IDISK_MODE] |
|
| 10095 |
result.append(("disk.mode/%d" % disk_op,
|
|
| 10096 |
disk_dict[constants.IDISK_MODE])) |
|
| 10076 | 10097 |
|
| 10077 | 10098 |
if self.op.disk_template: |
| 10078 | 10099 |
r_shut = _ShutdownInstanceDisks(self, instance) |
| ... | ... | |
| 10095 | 10116 |
result.append(("nic.%d" % len(instance.nics), "remove"))
|
| 10096 | 10117 |
elif nic_op == constants.DDM_ADD: |
| 10097 | 10118 |
# mac and bridge should be set, by now |
| 10098 |
mac = nic_dict['mac']
|
|
| 10099 |
ip = nic_dict.get('ip', None)
|
|
| 10119 |
mac = nic_dict[constants.INIC_MAC]
|
|
| 10120 |
ip = nic_dict.get(constants.INIC_IP, None)
|
|
| 10100 | 10121 |
nicparams = self.nic_pinst[constants.DDM_ADD] |
| 10101 | 10122 |
new_nic = objects.NIC(mac=mac, ip=ip, nicparams=nicparams) |
| 10102 | 10123 |
instance.nics.append(new_nic) |
| ... | ... | |
| 10107 | 10128 |
self.nic_pnew[constants.DDM_ADD][constants.NIC_LINK] |
| 10108 | 10129 |
))) |
| 10109 | 10130 |
else: |
| 10110 |
for key in 'mac', 'ip':
|
|
| 10131 |
for key in (constants.INIC_MAC, constants.INIC_IP):
|
|
| 10111 | 10132 |
if key in nic_dict: |
| 10112 | 10133 |
setattr(instance.nics[nic_op], key, nic_dict[key]) |
| 10113 | 10134 |
if nic_op in self.nic_pinst: |
| ... | ... | |
| 11636 | 11657 |
"os": iinfo.os, |
| 11637 | 11658 |
"nodes": [iinfo.primary_node] + list(iinfo.secondary_nodes), |
| 11638 | 11659 |
"nics": nic_data, |
| 11639 |
"disks": [{"size": dsk.size, "mode": dsk.mode} for dsk in iinfo.disks],
|
|
| 11660 |
"disks": [{constants.IDISK_SIZE: dsk.size,
|
|
| 11661 |
constants.IDISK_MODE: dsk.mode} |
|
| 11662 |
for dsk in iinfo.disks], |
|
| 11640 | 11663 |
"disk_template": iinfo.disk_template, |
| 11641 | 11664 |
"hypervisor": iinfo.hypervisor, |
| 11642 | 11665 |
} |
| ... | ... | |
| 11701 | 11724 |
errors.ECODE_STATE) |
| 11702 | 11725 |
|
| 11703 | 11726 |
self.required_nodes = 1 |
| 11704 |
disk_sizes = [{'size': disk.size} for disk in instance.disks]
|
|
| 11727 |
disk_sizes = [{constants.IDISK_SIZE: disk.size} for disk in instance.disks]
|
|
| 11705 | 11728 |
disk_space = _ComputeDiskSize(instance.disk_template, disk_sizes) |
| 11706 | 11729 |
|
| 11707 | 11730 |
request = {
|
Also available in: Unified diff