# 02110-1301, USA.
-"""Module implementing the commands used by gnt-* programs."""
+"""Module implementing the master-side code."""
# pylint: disable-msg=W0613,W0201
from ganeti import ssconf
class LogicalUnit(object):
- """Logical Unit base class..
+ """Logical Unit base class.
Subclasses must follow these rules:
- implement CheckPrereq which also fills in the opcode instance
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 = cfg.GetMaster()
+ 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.
return
+def _GetWantedNodes(lu, nodes):
+ """Returns list of checked and expanded node names.
+
+ Args:
+ nodes: List of nodes (strings) or None for all
+
+ """
+ if not isinstance(nodes, list):
+ raise errors.OpPrereqError("Invalid argument type 'nodes'")
+
+ if nodes:
+ wanted = []
+
+ for name in nodes:
+ node = lu.cfg.ExpandNodeName(name)
+ if node is None:
+ raise errors.OpPrereqError("No such node name '%s'" % name)
+ wanted.append(node)
+
+ else:
+ wanted = lu.cfg.GetNodeList()
+ return utils.NiceSort(wanted)
+
+
+def _GetWantedInstances(lu, instances):
+ """Returns list of checked and expanded instance names.
+
+ Args:
+ instances: List of instances (strings) or None for all
+
+ """
+ if not isinstance(instances, list):
+ raise errors.OpPrereqError("Invalid argument type 'instances'")
+
+ if instances:
+ wanted = []
+
+ for name in instances:
+ instance = lu.cfg.ExpandInstanceName(name)
+ if instance is None:
+ raise errors.OpPrereqError("No such instance name '%s'" % name)
+ wanted.append(instance)
+
+ else:
+ wanted = lu.cfg.GetInstanceList()
+ return utils.NiceSort(wanted)
+
+
+def _CheckOutputFields(static, dynamic, selected):
+ """Checks whether all selected fields are valid.
+
+ Args:
+ static: Static fields
+ dynamic: Dynamic fields
+
+ """
+ static_fields = frozenset(static)
+ dynamic_fields = frozenset(dynamic)
+
+ 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)))
+
+
+def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,
+ memory, vcpus, nics):
+ """Builds instance related env variables for hooks from single variables.
+
+ Args:
+ secondary_nodes: List of secondary nodes as strings
+ """
+ env = {
+ "INSTANCE_NAME": name,
+ "INSTANCE_PRIMARY": primary_node,
+ "INSTANCE_SECONDARIES": " ".join(secondary_nodes),
+ "INSTANCE_OS_TYPE": os_type,
+ "INSTANCE_STATUS": status,
+ "INSTANCE_MEMORY": memory,
+ "INSTANCE_VCPUS": vcpus,
+ }
+
+ if nics:
+ nic_count = len(nics)
+ for idx, (ip, bridge) in enumerate(nics):
+ if ip is None:
+ ip = ""
+ env["INSTANCE_NIC%d_IP" % idx] = ip
+ env["INSTANCE_NIC%d_BRIDGE" % idx] = bridge
+ else:
+ nic_count = 0
+
+ env["INSTANCE_NIC_COUNT"] = nic_count
+
+ return env
+
+
+def _BuildInstanceHookEnvByObject(instance, override=None):
+ """Builds instance related env variables for hooks from an object.
+
+ Args:
+ instance: objects.Instance object of instance
+ override: dict of values to override
+ """
+ args = {
+ 'name': instance.name,
+ 'primary_node': instance.primary_node,
+ 'secondary_nodes': instance.secondary_nodes,
+ 'os_type': instance.os,
+ 'status': instance.os,
+ 'memory': instance.memory,
+ 'vcpus': instance.vcpus,
+ 'nics': [(nic.ip, nic.bridge) for nic in instance.nics],
+ }
+ if override:
+ args.update(override)
+ return _BuildInstanceHookEnv(**args)
+
+
def _UpdateEtcHosts(fullnode, ip):
"""Ensure a node has a correct entry in /etc/hosts.
pubkey - the public key of the cluster
"""
- if os.path.exists('/etc/ssh/ssh_known_hosts'):
- f = open('/etc/ssh/ssh_known_hosts', 'r+')
+ if os.path.exists(constants.SSH_KNOWN_HOSTS_FILE):
+ f = open(constants.SSH_KNOWN_HOSTS_FILE, 'r+')
else:
- f = open('/etc/ssh/ssh_known_hosts', 'w+')
+ f = open(constants.SSH_KNOWN_HOSTS_FILE, 'w+')
inthere = False
save_lines = save_lines + add_lines
# Write a new file and replace old.
- fd, tmpname = tempfile.mkstemp('tmp', 'ssh_known_hosts_', '/etc/ssh')
+ fd, tmpname = tempfile.mkstemp('.tmp', 'known_hosts.',
+ constants.DATA_DIR)
newfile = os.fdopen(fd, 'w')
- newfile.write(''.join(save_lines))
- newfile.close()
+ try:
+ newfile.write(''.join(save_lines))
+ finally:
+ newfile.close()
logger.Debug("Wrote new known_hosts.")
- os.rename(tmpname, '/etc/ssh/ssh_known_hosts')
+ os.rename(tmpname, constants.SSH_KNOWN_HOSTS_FILE)
elif add_lines:
# Simply appending a new line will do the trick.
if vgsize is None:
return "volume group '%s' missing" % vgname
elif vgsize < 20480:
- return ("volume group '%s' too small (20480MiB required, %dMib found" %
- vgname, vgsize)
+ return ("volume group '%s' too small (20480MiB required, %dMib found)" %
+ (vgname, vgsize))
return None
node: the name of this host as a fqdn
"""
- utils.RemoveFile('/root/.ssh/known_hosts')
-
if os.path.exists('/root/.ssh/id_dsa'):
utils.CreateBackup('/root/.ssh/id_dsa')
if os.path.exists('/root/.ssh/id_dsa.pub'):
"-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))
-
-
-def _InitClusterInterface(fullname, name, ip):
- """Initialize the master startup script.
-
- """
- f = file(constants.CLUSTER_NAME_FILE, 'w')
- f.write("%s\n" % fullname)
- f.close()
-
- f = file(constants.MASTER_INITD_SCRIPT, 'w')
- f.write ("#!/bin/sh\n")
- f.write ("\n")
- f.write ("# Start Ganeti Master Virtual Address\n")
- f.write ("\n")
- f.write ("DESC=\"Ganeti Master IP\"\n")
- f.write ("MASTERNAME=\"%s\"\n" % name)
- f.write ("MASTERIP=\"%s\"\n" % ip)
- f.write ("case \"$1\" in\n")
- f.write (" start)\n")
- f.write (" if fping -q -c 3 ${MASTERIP} &>/dev/null; then\n")
- f.write (" echo \"$MASTERNAME no-go - there is already a master.\"\n")
- f.write (" rm -f %s\n" % constants.MASTER_CRON_LINK)
- f.write (" scp ${MASTERNAME}:%s %s\n" %
- (constants.CLUSTER_CONF_FILE, constants.CLUSTER_CONF_FILE))
- f.write (" else\n")
- f.write (" echo -n \"Starting $DESC: \"\n")
- f.write (" ip address add ${MASTERIP}/32 dev xen-br0"
- " label xen-br0:0\n")
- f.write (" arping -q -U -c 3 -I xen-br0 -s ${MASTERIP} ${MASTERIP}\n")
- f.write (" echo \"$MASTERNAME.\"\n")
- f.write (" fi\n")
- f.write (" ;;\n")
- f.write (" stop)\n")
- f.write (" echo -n \"Stopping $DESC: \"\n")
- f.write (" ip address del ${MASTERIP}/32 dev xen-br0\n")
- f.write (" echo \"$MASTERNAME.\"\n")
- f.write (" ;;\n")
- f.write (" *)\n")
- f.write (" echo \"Usage: $0 {start|stop}\" >&2\n")
- f.write (" exit 1\n")
- f.write (" ;;\n")
- f.write ("esac\n")
- f.write ("\n")
- f.write ("exit 0\n")
- f.flush()
- os.fsync(f.fileno())
- f.close()
- os.chmod(constants.MASTER_INITD_SCRIPT, 0755)
+ 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):
HPATH = "cluster-init"
HTYPE = constants.HTYPE_CLUSTER
_OP_REQP = ["cluster_name", "hypervisor_type", "vg_name", "mac_prefix",
- "def_bridge"]
+ "def_bridge", "master_netdev"]
REQ_CLUSTER = False
def BuildHooksEnv(self):
ourselves in the post-run node list.
"""
-
- env = {"CLUSTER": self.op.cluster_name,
- "MASTER": self.hostname}
- return env, [], [self.hostname['hostname_full']]
+ env = {
+ "CLUSTER": self.op.cluster_name,
+ "MASTER": self.hostname.name,
+ }
+ return env, [], [self.hostname.name]
def CheckPrereq(self):
"""Verify that the passed name is a valid one.
"""
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)
+
+ if hostname.name != hostname_local:
+ raise errors.OpPrereqError("My own hostname (%s) does not match the"
+ " resolver (%s): probably not using FQDN"
+ " for hostname." %
+ (hostname_local, hostname.name))
+
+ if hostname.ip.startswith("127."):
+ raise errors.OpPrereqError("This host's IP resolves to the private"
+ " range (%s). Please fix DNS or /etc/hosts." %
+ (hostname.ip,))
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']])
+ 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")
- if secondary_ip and secondary_ip != hostname['ip']:
+ 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.strip()))
def Exec(self, feedback_fn):
"""Initialize the cluster.
clustername = self.clustername
hostname = self.hostname
- # adds the cluste name file and master startup script
- _InitClusterInterface(clustername['hostname_full'],
- clustername['hostname'],
- clustername['ip'])
-
# set up the simple store
ss = ssconf.SimpleStore()
ss.SetKey(ss.SS_HYPERVISOR, self.op.hypervisor_type)
+ ss.SetKey(ss.SS_MASTER_NODE, hostname.name)
+ ss.SetKey(ss.SS_MASTER_IP, clustername.ip)
+ ss.SetKey(ss.SS_MASTER_NETDEV, self.op.master_netdev)
+ ss.SetKey(ss.SS_CLUSTER_NAME, clustername.name)
# set up the inter-node password and certificate
_InitGanetiServerSetup(ss)
# start the master ip
- rpc.call_node_start_master(hostname['hostname_full'])
+ rpc.call_node_start_master(hostname.name)
# set up ssh config and /etc/hosts
f = open('/etc/ssh/ssh_host_rsa_key.pub', 'r')
f.close()
sshkey = sshline.split(" ")[1]
- _UpdateEtcHosts(hostname['hostname_full'],
- hostname['ip'],
- )
+ _UpdateEtcHosts(hostname.name, hostname.ip)
- _UpdateKnownHosts(hostname['hostname_full'],
- hostname['ip'],
- sshkey,
- )
+ _UpdateKnownHosts(hostname.name, hostname.ip, sshkey)
- _InitSSHSetup(hostname['hostname'])
+ _InitSSHSetup(hostname.name)
# init of cluster config file
cfgw = config.ConfigWriter()
- cfgw.InitConfig(hostname['hostname'], hostname['ip'], self.secondary_ip,
- clustername['hostname'], sshkey, self.op.mac_prefix,
+ cfgw.InitConfig(hostname.name, hostname.ip, self.secondary_ip,
+ sshkey, self.op.mac_prefix,
self.op.vg_name, self.op.def_bridge)
Any errors are signalled by raising errors.OpPrereqError.
"""
- master = self.cfg.GetMaster()
+ master = self.sstore.GetMasterNode()
nodelist = self.cfg.GetNodeList()
- if len(nodelist) > 0 and nodelist != [master]:
- raise errors.OpPrereqError, ("There are still %d node(s) in "
- "this cluster." % (len(nodelist) - 1))
+ if len(nodelist) != 1 or nodelist[0] != master:
+ 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))
def Exec(self, feedback_fn):
"""Destroys the cluster.
"""
utils.CreateBackup('/root/.ssh/id_dsa')
utils.CreateBackup('/root/.ssh/id_dsa.pub')
- rpc.call_node_leave_cluster(self.cfg.GetMaster())
+ rpc.call_node_leave_cluster(self.sstore.GetMasterNode())
class LUVerifyCluster(NoHooksLU):
node: name of the node to check
file_list: required list of files
local_cksum: dictionary of local files and their checksums
+
"""
# compares ganeti version
local_version = constants.PROTOCOL_VERSION
bad = True
return bad
-
def _VerifyOrphanInstances(self, instancelist, node_instance, feedback_fn):
"""Verify the list of running instances.
bad = True
return bad
- def _VerifyNodeConfigFiles(self, ismaster, node, file_list, feedback_fn):
- """Verify the list of node config files"""
-
- bad = False
- for file_name in constants.MASTER_CONFIGFILES:
- if ismaster and file_name not in file_list:
- feedback_fn(" - ERROR: master config file %s missing from master"
- " node %s" % (file_name, node))
- bad = True
- elif not ismaster and file_name in file_list:
- feedback_fn(" - ERROR: master config file %s should not exist"
- " on non-master node %s" % (file_name, node))
- bad = True
-
- for file_name in constants.NODE_CONFIGFILES:
- if file_name not in file_list:
- feedback_fn(" - ERROR: config file %s missing from node %s" %
- (file_name, node))
- bad = True
-
- return bad
-
def CheckPrereq(self):
"""Check prerequisites.
feedback_fn("* Verifying global settings")
self.cfg.VerifyConfig()
- master = self.cfg.GetMaster()
+ master = self.sstore.GetMasterNode()
vg_name = self.cfg.GetVGName()
nodelist = utils.NiceSort(self.cfg.GetNodeList())
instancelist = utils.NiceSort(self.cfg.GetInstanceList())
# FIXME: verify OS list
# do local checksums
- file_names = constants.CLUSTER_CONF_FILES
+ file_names = list(self.sstore.GetFileList())
+ file_names.append(constants.SSL_CERT_FILE)
+ file_names.append(constants.CLUSTER_CONF_FILE)
local_checksums = utils.FingerprintFiles(file_names)
feedback_fn("* Gathering data (%d nodes)" % len(nodelist))
- all_configfile = rpc.call_configfile_list(nodelist)
all_volumeinfo = rpc.call_volume_list(nodelist, vg_name)
all_instanceinfo = rpc.call_instance_list(nodelist)
all_vglist = rpc.call_vg_list(nodelist)
all_vglist[node], all_nvinfo[node],
all_rversion[node], feedback_fn)
bad = bad or result
- # node_configfile
- nodeconfigfile = all_configfile[node]
-
- if not nodeconfigfile:
- feedback_fn(" - ERROR: connection to %s failed" % (node))
- bad = True
- continue
-
- bad = bad or self._VerifyNodeConfigFiles(node==master, node,
- nodeconfigfile, feedback_fn)
# node_volume
volumeinfo = all_volumeinfo[node]
return int(bad)
+class LURenameCluster(LogicalUnit):
+ """Rename the cluster.
+
+ """
+ HPATH = "cluster-rename"
+ HTYPE = constants.HTYPE_CLUSTER
+ _OP_REQP = ["name"]
+
+ def BuildHooksEnv(self):
+ """Build hooks env.
+
+ """
+ env = {
+ "NEW_NAME": self.op.name,
+ }
+ mn = self.sstore.GetMasterNode()
+ return env, [mn], [mn]
+
+ def CheckPrereq(self):
+ """Verify that the passed name is a valid one.
+
+ """
+ hostname = utils.LookupHostname(self.op.name)
+ if not hostname:
+ raise errors.OpPrereqError("Cannot resolve the new cluster name ('%s')" %
+ self.op.name)
+
+ new_name = hostname.name
+ self.ip = new_ip = hostname.ip
+ old_name = self.sstore.GetClusterName()
+ old_ip = self.sstore.GetMasterIP()
+ if new_name == old_name and new_ip == old_ip:
+ raise errors.OpPrereqError("Neither the name nor the IP address of the"
+ " cluster has changed")
+ if new_ip != old_ip:
+ result = utils.RunCmd(["fping", "-q", new_ip])
+ if not result.failed:
+ raise errors.OpPrereqError("The given cluster IP address (%s) is"
+ " reachable on the network. Aborting." %
+ new_ip)
+
+ self.op.name = new_name
+
+ def Exec(self, feedback_fn):
+ """Rename the cluster.
+
+ """
+ clustername = self.op.name
+ ip = self.ip
+ ss = self.sstore
+
+ # shutdown the master IP
+ master = ss.GetMasterNode()
+ if not rpc.call_node_stop_master(master):
+ raise errors.OpExecError("Could not disable the master role")
+
+ try:
+ # modify the sstore
+ ss.SetKey(ss.SS_MASTER_IP, ip)
+ ss.SetKey(ss.SS_CLUSTER_NAME, clustername)
+
+ # Distribute updated ss config to all nodes
+ myself = self.cfg.GetNodeInfo(master)
+ dist_nodes = self.cfg.GetNodeList()
+ if myself.name in dist_nodes:
+ dist_nodes.remove(myself.name)
+
+ logger.Debug("Copying updated ssconf data to all nodes")
+ for keyname in [ss.SS_CLUSTER_NAME, ss.SS_MASTER_IP]:
+ fname = ss.KeyToFilename(keyname)
+ result = rpc.call_upload_file(dist_nodes, fname)
+ for to_node in dist_nodes:
+ if not result[to_node]:
+ logger.Error("copy of file %s to node %s failed" %
+ (fname, to_node))
+ finally:
+ if not rpc.call_node_start_master(master):
+ logger.Error("Could not re-enable the master role on the master,\n"
+ "please restart manually.")
+
+
def _WaitForSync(cfgw, instance, oneshot=False, unlock=False):
"""Sleep and poll for an instance's disk to sync.
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
"""Check that mirrors are not degraded.
"""
-
cfgw.SetDiskID(dev, node)
result = True
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
node would not allows itself to run.
"""
+ env = {
+ "NODE_NAME": self.op.node_name,
+ }
all_nodes = self.cfg.GetNodeList()
all_nodes.remove(self.op.node_name)
- return {"NODE_NAME": self.op.node_name}, all_nodes, all_nodes
+ return env, all_nodes, all_nodes
def CheckPrereq(self):
"""Check prerequisites.
Any errors are signalled by raising errors.OpPrereqError.
"""
-
node = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(self.op.node_name))
if node is None:
- logger.Error("Error: Node '%s' is unknown." % self.op.node_name)
- return 1
+ raise errors.OpPrereqError, ("Node '%s' is unknown." % self.op.node_name)
instance_list = self.cfg.GetInstanceList()
- masternode = self.cfg.GetMaster()
+ 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
"""Logical unit for querying nodes.
"""
- _OP_REQP = ["output_fields"]
+ _OP_REQP = ["output_fields", "names"]
def CheckPrereq(self):
"""Check prerequisites.
This checks that the fields required are valid output fields.
"""
- self.static_fields = frozenset(["name", "pinst", "sinst", "pip", "sip"])
self.dynamic_fields = frozenset(["dtotal", "dfree",
"mtotal", "mnode", "mfree"])
- self.all_fields = self.static_fields | self.dynamic_fields
- if not self.all_fields.issuperset(self.op.output_fields):
- raise errors.OpPrereqError, ("Unknown output fields selected: %s"
- % ",".join(frozenset(self.op.output_fields).
- difference(self.all_fields)))
+ _CheckOutputFields(static=["name", "pinst_cnt", "sinst_cnt",
+ "pinst_list", "sinst_list",
+ "pip", "sip"],
+ dynamic=self.dynamic_fields,
+ selected=self.op.output_fields)
+ self.wanted = _GetWantedNodes(self, self.op.names)
def Exec(self, feedback_fn):
"""Computes the list of nodes and their attributes.
"""
- nodenames = utils.NiceSort(self.cfg.GetNodeList())
+ nodenames = self.wanted
nodelist = [self.cfg.GetNodeInfo(name) for name in nodenames]
-
# begin data gathering
if self.dynamic_fields.intersection(self.op.output_fields):
else:
live_data = dict.fromkeys(nodenames, {})
- node_to_primary = dict.fromkeys(nodenames, 0)
- node_to_secondary = dict.fromkeys(nodenames, 0)
+ node_to_primary = dict([(name, set()) for name in nodenames])
+ node_to_secondary = dict([(name, set()) for name in nodenames])
- if "pinst" in self.op.output_fields or "sinst" in self.op.output_fields:
+ inst_fields = frozenset(("pinst_cnt", "pinst_list",
+ "sinst_cnt", "sinst_list"))
+ if inst_fields & frozenset(self.op.output_fields):
instancelist = self.cfg.GetInstanceList()
- for instance in instancelist:
- instanceinfo = self.cfg.GetInstanceInfo(instance)
- node_to_primary[instanceinfo.primary_node] += 1
- for secnode in instanceinfo.secondary_nodes:
- node_to_secondary[secnode] += 1
+ for instance_name in instancelist:
+ inst = self.cfg.GetInstanceInfo(instance_name)
+ if inst.primary_node in node_to_primary:
+ node_to_primary[inst.primary_node].add(inst.name)
+ for secnode in inst.secondary_nodes:
+ if secnode in node_to_secondary:
+ node_to_secondary[secnode].add(inst.name)
# end data gathering
for field in self.op.output_fields:
if field == "name":
val = node.name
- elif field == "pinst":
- val = node_to_primary[node.name]
- elif field == "sinst":
- val = node_to_secondary[node.name]
+ elif field == "pinst_list":
+ val = list(node_to_primary[node.name])
+ elif field == "sinst_list":
+ val = list(node_to_secondary[node.name])
+ elif field == "pinst_cnt":
+ val = len(node_to_primary[node.name])
+ elif field == "sinst_cnt":
+ val = len(node_to_secondary[node.name])
elif field == "pip":
val = node.primary_ip
elif field == "sip":
val = node.secondary_ip
elif field in self.dynamic_fields:
- val = live_data[node.name].get(field, "?")
+ val = live_data[node.name].get(field, None)
else:
- raise errors.ParameterError, field
- val = str(val)
+ raise errors.ParameterError(field)
node_output.append(val)
output.append(node_output)
return output
-def _CheckNodesDirs(node_list, paths):
- """Verify if the given nodes have the same files.
+class LUQueryNodeVolumes(NoHooksLU):
+ """Logical unit for getting volumes on node(s).
- Args:
- node_list: the list of node names to check
- paths: the list of directories to checksum and compare
+ """
+ _OP_REQP = ["nodes", "output_fields"]
- Returns:
- list of (node, different_file, message); if empty, the files are in sync
+ def CheckPrereq(self):
+ """Check prerequisites.
- """
- file_names = []
- for dir_name in paths:
- flist = [os.path.join(dir_name, name) for name in os.listdir(dir_name)]
- flist = [name for name in flist if os.path.isfile(name)]
- file_names.extend(flist)
+ This checks that the fields required are valid output fields.
- local_checksums = utils.FingerprintFiles(file_names)
+ """
+ self.nodes = _GetWantedNodes(self, self.op.nodes)
- results = []
- verify_params = {'filelist': file_names}
- all_node_results = rpc.call_node_verify(node_list, verify_params)
- for node_name in node_list:
- node_result = all_node_results.get(node_name, False)
- if not node_result or 'filelist' not in node_result:
- results.append((node_name, "'all files'", "node communication error"))
- continue
- remote_checksums = node_result['filelist']
- for fname in local_checksums:
- if fname not in remote_checksums:
- results.append((node_name, fname, "missing file"))
- elif remote_checksums[fname] != local_checksums[fname]:
- results.append((node_name, fname, "wrong checksum"))
- return results
+ _CheckOutputFields(static=["node"],
+ dynamic=["phys", "vg", "name", "size", "instance"],
+ selected=self.op.output_fields)
+
+
+ def Exec(self, feedback_fn):
+ """Computes the list of nodes and their attributes.
+
+ """
+ nodenames = self.nodes
+ volumes = rpc.call_node_volumes(nodenames)
+
+ ilist = [self.cfg.GetInstanceInfo(iname) for iname
+ in self.cfg.GetInstanceList()]
+
+ lv_by_node = dict([(inst, inst.MapLVsByNode()) for inst in ilist])
+
+ output = []
+ for node in nodenames:
+ if node not in volumes or not volumes[node]:
+ continue
+
+ node_vols = volumes[node][:]
+ node_vols.sort(key=lambda vol: vol['dev'])
+
+ for vol in node_vols:
+ node_output = []
+ for field in self.op.output_fields:
+ if field == "node":
+ val = node
+ elif field == "phys":
+ val = vol['dev']
+ elif field == "vg":
+ val = vol['vg']
+ elif field == "name":
+ val = vol['name']
+ elif field == "size":
+ val = int(float(vol['size']))
+ elif field == "instance":
+ for inst in ilist:
+ if node not in lv_by_node[inst]:
+ continue
+ if vol['name'] in lv_by_node[inst][node]:
+ val = inst.name
+ break
+ else:
+ val = '-'
+ else:
+ raise errors.ParameterError(field)
+ node_output.append(str(val))
+
+ output.append(node_output)
+
+ return output
class LUAddNode(LogicalUnit):
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']
+ node = dns_data.name
+ primary_ip = self.op.primary_ip = dns_data.ip
secondary_ip = getattr(self.op, "secondary_ip", None)
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
- myself = cfg.GetNodeInfo(cfg.GetMaster())
+ myself = cfg.GetNodeInfo(self.sstore.GetMasterNode())
master_singlehomed = myself.secondary_ip == myself.primary_ip
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
- utils.RemoveFile("/root/.ssh/known_hosts")
# and then connect with ssh to set password and start ganeti-noded
# note that all the below variables are sanitized at this point,
# either by being constants or by the checks above
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)
+
+ success, msg = ssh.VerifyNodeHostname(node)
+ if not success:
+ raise errors.OpExecError("Node '%s' claims it has a different hostname"
+ " than the one the resolver gives: %s.\n"
+ "Please fix and re-run this command." %
+ (node, msg))
# Distribute updated /etc/hosts and known_hosts to all nodes,
# including the node just added
- myself = self.cfg.GetNodeInfo(self.cfg.GetMaster())
+ myself = self.cfg.GetNodeInfo(self.sstore.GetMasterNode())
dist_nodes = self.cfg.GetNodeList() + [node]
if myself.name in dist_nodes:
dist_nodes.remove(myself.name)
logger.Debug("Copying hosts and known_hosts to all nodes")
- for fname in ("/etc/hosts", "/etc/ssh/ssh_known_hosts"):
+ for fname in ("/etc/hosts", constants.SSH_KNOWN_HOSTS_FILE):
result = rpc.call_upload_file(dist_nodes, fname)
for to_node in dist_nodes:
if not result[to_node]:
logger.Error("copy of file %s to node %s failed" %
(fname, to_node))
- to_copy = [constants.MASTER_CRON_FILE,
- constants.MASTER_INITD_SCRIPT,
- constants.CLUSTER_NAME_FILE]
- to_copy.extend(ss.GetFileList())
+ to_copy = ss.GetFileList()
for fname in to_copy:
if not ssh.CopyFileToNode(node, fname):
logger.Error("could not copy file %s to node %s" % (fname, node))
"""
self.new_master = socket.gethostname()
- self.old_master = self.cfg.GetMaster()
+ 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.
master.
"""
-
#TODO: do not rely on gethostname returning the FQDN
logger.Info("setting master to %s, old master: %s" %
(self.new_master, self.old_master))
logger.Error("could disable the master role on the old master"
" %s, please disable manually" % self.old_master)
+ ss = self.sstore
+ ss.SetKey(ss.SS_MASTER_NODE, self.new_master)
+ if not rpc.call_upload_file(self.cfg.GetNodeList(),
+ ss.KeyToFilename(ss.SS_MASTER_NODE)):
+ logger.Error("could not distribute the new simple store master file"
+ " to the other nodes, please check.")
+
if not rpc.call_node_start_master(self.new_master):
logger.Error("could not start the master role on the new master"
" %s, please check" % self.new_master)
+ feedback_fn("Error in activating the master IP on the new master,\n"
+ "please fix manually.")
- self.cfg.SetMaster(self.new_master)
class LUQueryClusterInfo(NoHooksLU):
"""
_OP_REQP = []
+ REQ_MASTER = False
def CheckPrereq(self):
"""No prerequsites needed for this LU.
"""Return cluster config.
"""
- instances = [self.cfg.GetInstanceInfo(name)
- for name in self.cfg.GetInstanceList()]
result = {
- "name": self.cfg.GetClusterName(),
+ "name": self.sstore.GetClusterName(),
"software_version": constants.RELEASE_VERSION,
"protocol_version": constants.PROTOCOL_VERSION,
"config_version": constants.CONFIG_VERSION,
"os_api_version": constants.OS_API_VERSION,
"export_version": constants.EXPORT_VERSION,
- "master": self.cfg.GetMaster(),
+ "master": self.sstore.GetMasterNode(),
"architecture": (platform.architecture()[0], platform.machine()),
- "instances": [(instance.name, instance.primary_node)
- for instance in instances],
- "nodes": self.cfg.GetNodeList(),
}
return result
"""
if not os.path.exists(self.op.filename):
raise errors.OpPrereqError("No such filename '%s'" % self.op.filename)
- if self.op.nodes:
- nodes = self.op.nodes
- else:
- nodes = self.cfg.GetNodeList()
- self.nodes = []
- for node in nodes:
- nname = self.cfg.ExpandNodeName(node)
- if nname is None:
- raise errors.OpPrereqError, ("Node '%s' is unknown." % node)
- self.nodes.append(nname)
+
+ self.nodes = _GetWantedNodes(self, self.op.nodes)
def Exec(self, feedback_fn):
"""Copy a file from master to some nodes.
It checks that the given list of nodes is valid.
"""
- if self.op.nodes:
- nodes = self.op.nodes
- else:
- nodes = self.cfg.GetNodeList()
- self.nodes = []
- for node in nodes:
- nname = self.cfg.ExpandNodeName(node)
- if nname is None:
- raise errors.OpPrereqError, ("Node '%s' is unknown." % node)
- self.nodes.append(nname)
+ self.nodes = _GetWantedNodes(self, self.op.nodes)
def Exec(self, feedback_fn):
"""Run a command on some nodes.
"""
data = []
for node in self.nodes:
- result = utils.RunCmd(["ssh", node, self.op.command])
- data.append((node, result.cmd, result.output, result.exit_code))
+ result = ssh.SSHCall(node, "root", self.op.command)
+ data.append((node, result.output, result.exit_code))
return data
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
return disks_ok, device_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:
+ _ShutdownInstanceDisks(instance, cfg)
+ 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")
+
+
class LUDeactivateInstanceDisks(NoHooksLU):
"""Shutdown an instance's disks.
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)
"""
env = {
- "INSTANCE_NAME": self.op.instance_name,
- "INSTANCE_PRIMARY": self.instance.primary_node,
- "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),
"FORCE": self.op.force,
}
- nl = ([self.cfg.GetMaster(), self.instance.primary_node] +
+ env.update(_BuildInstanceHookEnvByObject(self.instance))
+ nl = ([self.sstore.GetMasterNode(), self.instance.primary_node] +
list(self.instance.secondary_nodes))
return env, nl, nl
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))
- disks_ok, dummy = _AssembleInstanceDisks(instance, self.cfg,
- ignore_secondaries=force)
- if not disks_ok:
- _ShutdownInstanceDisks(instance, self.cfg)
- if 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")
+ _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)
This runs on master, primary and secondary nodes of the instance.
"""
- env = {
- "INSTANCE_NAME": self.op.instance_name,
- "INSTANCE_PRIMARY": self.instance.primary_node,
- "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),
- }
- nl = ([self.cfg.GetMaster(), self.instance.primary_node] +
+ env = _BuildInstanceHookEnvByObject(self.instance)
+ nl = ([self.sstore.GetMasterNode(), self.instance.primary_node] +
list(self.instance.secondary_nodes))
return env, nl, nl
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):
_ShutdownInstanceDisks(instance, self.cfg)
+class LUReinstallInstance(LogicalUnit):
+ """Reinstall an instance.
+
+ """
+ HPATH = "instance-reinstall"
+ HTYPE = constants.HTYPE_INSTANCE
+ _OP_REQP = ["instance_name"]
+
+ def BuildHooksEnv(self):
+ """Build hooks env.
+
+ This runs on master, primary and secondary nodes of the instance.
+
+ """
+ env = _BuildInstanceHookEnvByObject(self.instance)
+ nl = ([self.sstore.GetMasterNode(), self.instance.primary_node] +
+ list(self.instance.secondary_nodes))
+ return env, nl, nl
+
+ def CheckPrereq(self):
+ """Check prerequisites.
+
+ This checks that the instance is in the cluster and is not running.
+
+ """
+ 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)
+ if instance.disk_template == constants.DT_DISKLESS:
+ 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)
+ 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))
+
+ self.op.os_type = getattr(self.op, "os_type", None)
+ if self.op.os_type is not None:
+ # OS verification
+ 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)
+ 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)
+
+ self.instance = instance
+
+ def Exec(self, feedback_fn):
+ """Reinstall the instance.
+
+ """
+ inst = self.instance
+
+ if self.op.os_type is not None:
+ feedback_fn("Changing OS to '%s'..." % self.op.os_type)
+ inst.os = self.op.os_type
+ self.cfg.AddInstance(inst)
+
+ _StartInstanceDisks(self.cfg, inst, None)
+ 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))
+ finally:
+ _ShutdownInstanceDisks(inst, self.cfg)
+
+
+class LURenameInstance(LogicalUnit):
+ """Rename an instance.
+
+ """
+ HPATH = "instance-rename"
+ HTYPE = constants.HTYPE_INSTANCE
+ _OP_REQP = ["instance_name", "new_name"]
+
+ def BuildHooksEnv(self):
+ """Build hooks env.
+
+ This runs on master, primary and secondary nodes of the instance.
+
+ """
+ env = _BuildInstanceHookEnvByObject(self.instance)
+ env["INSTANCE_NEW_NAME"] = self.op.new_name
+ nl = ([self.sstore.GetMasterNode(), self.instance.primary_node] +
+ list(self.instance.secondary_nodes))
+ return env, nl, nl
+
+ def CheckPrereq(self):
+ """Check prerequisites.
+
+ This checks that the instance is in the cluster and is not running.
+
+ """
+ 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)
+ if instance.status != "down":
+ 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))
+ self.instance = instance
+
+ # new name verification
+ hostname1 = utils.LookupHostname(self.op.new_name)
+ if not hostname1:
+ raise errors.OpPrereqError("New instance name '%s' not found in dns" %
+ self.op.new_name)
+
+ self.op.new_name = new_name = hostname1.name
+ if not getattr(self.op, "ignore_ip", False):
+ command = ["fping", "-q", hostname1.ip]
+ result = utils.RunCmd(command)
+ if not result.failed:
+ raise errors.OpPrereqError("IP %s of instance %s already in use" %
+ (hostname1.ip, new_name))
+
+
+ def Exec(self, feedback_fn):
+ """Reinstall the instance.
+
+ """
+ inst = self.instance
+ old_name = inst.name
+
+ self.cfg.RenameInstance(inst.name, self.op.new_name)
+
+ # re-read the instance from the configuration after rename
+ inst = self.cfg.GetInstanceInfo(self.op.new_name)
+
+ _StartInstanceDisks(self.cfg, inst, None)
+ try:
+ if not rpc.call_instance_run_rename(inst.primary_node, inst, old_name,
+ "sda", "sdb"):
+ msg = ("Could run OS rename script for instance %s\n"
+ "on node %s\n"
+ "(but the instance has been renamed in Ganeti)" %
+ (inst.name, inst.primary_node))
+ logger.Error(msg)
+ finally:
+ _ShutdownInstanceDisks(inst, self.cfg)
+
+
class LURemoveInstance(LogicalUnit):
"""Remove an instance.
This runs on master, primary and secondary nodes of the instance.
"""
- env = {
- "INSTANCE_NAME": self.op.instance_name,
- "INSTANCE_PRIMARY": self.instance.primary_node,
- "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),
- }
- nl = ([self.cfg.GetMaster(), self.instance.primary_node] +
+ env = _BuildInstanceHookEnvByObject(self.instance)
+ nl = ([self.sstore.GetMasterNode(), self.instance.primary_node] +
list(self.instance.secondary_nodes))
return env, nl, nl
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))
if not rpc.call_instance_shutdown(instance.primary_node, instance):
- raise errors.OpExecError, ("Could not shutdown instance %s on node %s" %
- (instance.name, instance.primary_node))
+ raise errors.OpExecError("Could not shutdown instance %s on node %s" %
+ (instance.name, instance.primary_node))
logger.Info("removing block devices for instance %s" % instance.name)
"""Logical unit for querying instances.
"""
- OP_REQP = ["output_fields"]
+ _OP_REQP = ["output_fields", "names"]
def CheckPrereq(self):
"""Check prerequisites.
This checks that the fields required are valid output fields.
"""
-
- self.static_fields = frozenset(["name", "os", "pnode", "snodes",
- "admin_state", "admin_ram",
- "disk_template", "ip", "mac", "bridge"])
self.dynamic_fields = frozenset(["oper_state", "oper_ram"])
- self.all_fields = self.static_fields | self.dynamic_fields
+ _CheckOutputFields(static=["name", "os", "pnode", "snodes",
+ "admin_state", "admin_ram",
+ "disk_template", "ip", "mac", "bridge",
+ "sda_size", "sdb_size"],
+ dynamic=self.dynamic_fields,
+ selected=self.op.output_fields)
- if not self.all_fields.issuperset(self.op.output_fields):
- raise errors.OpPrereqError, ("Unknown output fields selected: %s"
- % ",".join(frozenset(self.op.output_fields).
- difference(self.all_fields)))
+ self.wanted = _GetWantedInstances(self, self.op.names)
def Exec(self, feedback_fn):
"""Computes the list of nodes and their attributes.
"""
-
- instance_names = utils.NiceSort(self.cfg.GetInstanceList())
+ instance_names = self.wanted
instance_list = [self.cfg.GetInstanceInfo(iname) for iname
in instance_names]
elif field == "pnode":
val = instance.primary_node
elif field == "snodes":
- val = ",".join(instance.secondary_nodes) or "-"
+ val = list(instance.secondary_nodes)
elif field == "admin_state":
- if instance.status == "down":
- val = "no"
- else:
- val = "yes"
+ val = (instance.status != "down")
elif field == "oper_state":
if instance.primary_node in bad_nodes:
- val = "(node down)"
+ val = None
else:
- if live_data.get(instance.name):
- val = "running"
- else:
- val = "stopped"
+ val = bool(live_data.get(instance.name))
elif field == "admin_ram":
val = instance.memory
elif field == "oper_ram":
if instance.primary_node in bad_nodes:
- val = "(node down)"
+ val = None
elif instance.name in live_data:
val = live_data[instance.name].get("memory", "?")
else:
val = instance.nics[0].bridge
elif field == "mac":
val = instance.nics[0].mac
+ elif field == "sda_size" or field == "sdb_size":
+ disk = instance.FindDisk(field[:3])
+ if disk is None:
+ val = None
+ else:
+ val = disk.size
else:
- raise errors.ParameterError, field
- val = str(val)
+ raise errors.ParameterError(field)
iout.append(val)
output.append(iout)
"""
env = {
- "INSTANCE_NAME": self.op.instance_name,
- "INSTANCE_PRIMARY": self.instance.primary_node,
- "INSTANCE_SECONDARIES": " ".join(self.instance.secondary_nodes),
"IGNORE_CONSISTENCY": self.op.ignore_consistency,
}
- nl = [self.cfg.GetMaster()] + list(self.instance.secondary_nodes)
+ env.update(_BuildInstanceHookEnvByObject(self.instance))
+ nl = [self.sstore.GetMasterNode()] + list(self.instance.secondary_nodes)
return env, nl, nl
def CheckPrereq(self):
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_REMOTE_RAID1:
+ raise errors.OpPrereqError("Instance's disk layout is not"
+ " remote_raid1.")
+
+ secondary_nodes = instance.secondary_nodes
+ if not secondary_nodes:
+ raise errors.ProgrammerError("no secondary node but using "
+ "DT_REMOTE_RAID1 template")
# check memory requirements on the secondary node
- target_node = instance.secondary_nodes[0]
+ target_node = secondary_nodes[0]
nodeinfo = rpc.call_node_info([target_node], self.cfg.GetVGName())
info = nodeinfo.get(target_node, None)
if not info:
- raise errors.OpPrereqError, ("Cannot get current information"
- " from node '%s'" % nodeinfo)
+ raise errors.OpPrereqError("Cannot get current information"
+ " from node '%s'" % nodeinfo)
if instance.memory > info['memory_free']:
- raise errors.OpPrereqError, ("Not enough memory on target node %s."
- " %d MB available, %d MB required" %
- (target_node, info['memory_free'],
- instance.memory))
+ raise errors.OpPrereqError("Not enough memory on target node %s."
+ " %d MB available, %d MB required" %
+ (target_node, info['memory_free'],
+ instance.memory))
# check bridge 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
# for remote_raid1, these are md over drbd
if not _CheckDiskConsistency(self.cfg, dev, target_node, False):
if not self.op.ignore_consistency:
- raise errors.OpExecError, ("Disk %s is degraded on target node,"
- " aborting failover." % dev.iv_name)
+ raise errors.OpExecError("Disk %s is degraded on target node,"
+ " aborting failover." % dev.iv_name)
feedback_fn("* checking target node resource availability")
nodeinfo = rpc.call_node_info([target_node], self.cfg.GetVGName())
if not nodeinfo:
- raise errors.OpExecError, ("Could not contact target node %s." %
- target_node)
+ raise errors.OpExecError("Could not contact target node %s." %
+ target_node)
free_memory = int(nodeinfo[target_node]['memory_free'])
memory = instance.memory
if memory > free_memory:
- raise errors.OpExecError, ("Not enough memory to create instance %s on"
- " node %s. needed %s MiB, available %s MiB" %
- (instance.name, target_node, memory,
- free_memory))
+ raise errors.OpExecError("Not enough memory to create instance %s on"
+ " node %s. needed %s MiB, available %s MiB" %
+ (instance.name, target_node, memory,
+ free_memory))
feedback_fn("* shutting down instance on source node")
logger.Info("Shutting down instance %s on node %s" %
feedback_fn("* deactivating the instance's disks on source node")
if not _ShutdownInstanceDisks(instance, self.cfg, ignore_primary=True):
- raise errors.OpExecError, ("Can't shut down the instance's disks.")
+ raise errors.OpExecError("Can't shut down the instance's disks.")
instance.primary_node = target_node
# distribute new instance config to the other nodes
ignore_secondaries=True)
if not disks_ok:
_ShutdownInstanceDisks(instance, self.cfg)
- raise errors.OpExecError, ("Can't activate the instance's disks")
+ raise errors.OpExecError("Can't activate the instance's disks")
feedback_fn("* starting the instance on the target node")
if not rpc.call_instance_start(target_node, instance, None):
_ShutdownInstanceDisks(instance, self.cfg)
raise errors.OpExecError("Could not start instance %s on node %s." %
- (instance, target_node))
+ (instance.name, target_node))
-def _CreateBlockDevOnPrimary(cfg, node, device):
+def _CreateBlockDevOnPrimary(cfg, node, device, info):
"""Create a tree of block devices on the primary node.
This always creates all devices.
"""
-
if device.children:
for child in device.children:
- if not _CreateBlockDevOnPrimary(cfg, node, child):
+ if not _CreateBlockDevOnPrimary(cfg, node, child, info):
return False
cfg.SetDiskID(device, node)
- new_id = rpc.call_blockdev_create(node, device, device.size, True)
+ new_id = rpc.call_blockdev_create(node, device, device.size, True, info)
if not new_id:
return False
if device.physical_id is None:
return True
-def _CreateBlockDevOnSecondary(cfg, node, device, force):
+def _CreateBlockDevOnSecondary(cfg, node, device, force, info):
"""Create a tree of block devices on a secondary node.
If this device type has to be created on secondaries, create it and
force = True
if device.children:
for child in device.children:
- if not _CreateBlockDevOnSecondary(cfg, node, child, force):
+ if not _CreateBlockDevOnSecondary(cfg, node, child, force, info):
return False
if not force:
return True
cfg.SetDiskID(device, node)
- new_id = rpc.call_blockdev_create(node, device, device.size, False)
+ new_id = rpc.call_blockdev_create(node, device, device.size, False, info)
if not new_id:
return False
if device.physical_id is None:
return True
-def _GenerateMDDRBDBranch(cfg, vgname, primary, secondary, size, base):
+def _GenerateUniqueNames(cfg, exts):
+ """Generate a suitable LV name.
+
+ This will generate a logical volume name for the given instance.
+
+ """
+ results = []
+ for val in exts:
+ new_id = cfg.GenerateUniqueID()
+ results.append("%s%s" % (new_id, val))
+ return results
+
+
+def _GenerateMDDRBDBranch(cfg, primary, secondary, size, names):
"""Generate a drbd device complete with its children.
"""
port = cfg.AllocatePort()
- base = "%s_%s" % (base, port)
+ vgname = cfg.GetVGName()
dev_data = objects.Disk(dev_type="lvm", size=size,
- logical_id=(vgname, "%s.data" % base))
+ logical_id=(vgname, names[0]))
dev_meta = objects.Disk(dev_type="lvm", size=128,
- logical_id=(vgname, "%s.meta" % base))
+ logical_id=(vgname, names[1]))
drbd_dev = objects.Disk(dev_type="drbd", size=size,
logical_id = (primary, secondary, port),
children = [dev_data, dev_meta])
return drbd_dev
-def _GenerateDiskTemplate(cfg, vgname, template_name,
+def _GenerateDiskTemplate(cfg, template_name,
instance_name, primary_node,
secondary_nodes, disk_sz, swap_sz):
"""Generate the entire disk layout for a given template type.
"""
#TODO: compute space requirements
+ vgname = cfg.GetVGName()
if template_name == "diskless":
disks = []
elif template_name == "plain":
if len(secondary_nodes) != 0:
raise errors.ProgrammerError("Wrong template configuration")
+
+ names = _GenerateUniqueNames(cfg, [".sda", ".sdb"])
sda_dev = objects.Disk(dev_type="lvm", size=disk_sz,
- logical_id=(vgname, "%s.os" % instance_name),
+ logical_id=(vgname, names[0]),
iv_name = "sda")
sdb_dev = objects.Disk(dev_type="lvm", size=swap_sz,
- logical_id=(vgname, "%s.swap" % instance_name),
+ logical_id=(vgname, names[1]),
iv_name = "sdb")
disks = [sda_dev, sdb_dev]
elif template_name == "local_raid1":
if len(secondary_nodes) != 0:
raise errors.ProgrammerError("Wrong template configuration")
+
+
+ names = _GenerateUniqueNames(cfg, [".sda_m1", ".sda_m2",
+ ".sdb_m1", ".sdb_m2"])
sda_dev_m1 = objects.Disk(dev_type="lvm", size=disk_sz,
- logical_id=(vgname, "%s.os_m1" % instance_name))
+ logical_id=(vgname, names[0]))
sda_dev_m2 = objects.Disk(dev_type="lvm", size=disk_sz,
- logical_id=(vgname, "%s.os_m2" % instance_name))
+ logical_id=(vgname, names[1]))
md_sda_dev = objects.Disk(dev_type="md_raid1", iv_name = "sda",
size=disk_sz,
children = [sda_dev_m1, sda_dev_m2])
sdb_dev_m1 = objects.Disk(dev_type="lvm", size=swap_sz,
- logical_id=(vgname, "%s.swap_m1" %
- instance_name))
+ logical_id=(vgname, names[2]))
sdb_dev_m2 = objects.Disk(dev_type="lvm", size=swap_sz,
- logical_id=(vgname, "%s.swap_m2" %
- instance_name))
+ logical_id=(vgname, names[3]))
md_sdb_dev = objects.Disk(dev_type="md_raid1", iv_name = "sdb",
size=swap_sz,
children = [sdb_dev_m1, sdb_dev_m2])
disks = [md_sda_dev, md_sdb_dev]
- elif template_name == "remote_raid1":
+ elif template_name == constants.DT_REMOTE_RAID1:
if len(secondary_nodes) != 1:
raise errors.ProgrammerError("Wrong template configuration")
remote_node = secondary_nodes[0]
- drbd_sda_dev = _GenerateMDDRBDBranch(cfg, vgname,
- primary_node, remote_node, disk_sz,
- "%s-sda" % instance_name)
+ names = _GenerateUniqueNames(cfg, [".sda_data", ".sda_meta",
+ ".sdb_data", ".sdb_meta"])
+ drbd_sda_dev = _GenerateMDDRBDBranch(cfg, primary_node, remote_node,
+ disk_sz, names[0:2])
md_sda_dev = objects.Disk(dev_type="md_raid1", iv_name="sda",
children = [drbd_sda_dev], size=disk_sz)
- drbd_sdb_dev = _GenerateMDDRBDBranch(cfg, vgname,
- primary_node, remote_node, swap_sz,
- "%s-sdb" % instance_name)
+ drbd_sdb_dev = _GenerateMDDRBDBranch(cfg, primary_node, remote_node,
+ swap_sz, names[2:4])
md_sdb_dev = objects.Disk(dev_type="md_raid1", iv_name="sdb",
children = [drbd_sdb_dev], size=swap_sz)
disks = [md_sda_dev, md_sdb_dev]
return disks
+def _GetInstanceInfoText(instance):
+ """Compute that text that should be added to the disk's metadata.
+
+ """
+ return "originstname+%s" % instance.name
+
+
def _CreateDisks(cfg, instance):
"""Create all disks for an instance.
True or False showing the success of the creation process
"""
+ info = _GetInstanceInfoText(instance)
+
for device in instance.disks:
logger.Info("creating volume %s for instance %s" %
(device.iv_name, instance.name))
#HARDCODE
for secondary_node in instance.secondary_nodes:
- if not _CreateBlockDevOnSecondary(cfg, secondary_node, device, False):
+ if not _CreateBlockDevOnSecondary(cfg, secondary_node, device, False,
+ info):
logger.Error("failed to create volume %s (%s) on secondary node %s!" %
(device.iv_name, device, secondary_node))
return False
#HARDCODE
- if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, device):
+ if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, device, info):
logger.Error("failed to create volume %s on primary!" %
device.iv_name)
return False
HTYPE = constants.HTYPE_INSTANCE
_OP_REQP = ["instance_name", "mem_size", "disk_size", "pnode",
"disk_template", "swap_size", "mode", "start", "vcpus",
- "wait_for_sync"]
+ "wait_for_sync", "ip_check"]
def BuildHooksEnv(self):
"""Build hooks env.
"""
env = {
- "INSTANCE_NAME": self.op.instance_name,
- "INSTANCE_PRIMARY": self.op.pnode,
- "INSTANCE_SECONDARIES": " ".join(self.secondaries),
- "DISK_TEMPLATE": self.op.disk_template,
- "MEM_SIZE": self.op.mem_size,
- "DISK_SIZE": self.op.disk_size,
- "SWAP_SIZE": self.op.swap_size,
- "VCPUS": self.op.vcpus,
- "BRIDGE": self.op.bridge,
+ "INSTANCE_DISK_TEMPLATE": self.op.disk_template,
+ "INSTANCE_DISK_SIZE": self.op.disk_size,
+ "INSTANCE_SWAP_SIZE": self.op.swap_size,
"INSTANCE_ADD_MODE": self.op.mode,
}
if self.op.mode == constants.INSTANCE_IMPORT:
- env["SRC_NODE"] = self.op.src_node
- env["SRC_PATH"] = self.op.src_path
- env["SRC_IMAGE"] = self.src_image
- if self.inst_ip:
- env["INSTANCE_IP"] = self.inst_ip
-
- nl = ([self.cfg.GetMaster(), self.op.pnode] +
+ env["INSTANCE_SRC_NODE"] = self.op.src_node
+ env["INSTANCE_SRC_PATH"] = self.op.src_path
+ env["INSTANCE_SRC_IMAGE"] = self.src_image
+
+ env.update(_BuildInstanceHookEnv(name=self.op.instance_name,
+ primary_node=self.op.pnode,
+ secondary_nodes=self.secondaries,
+ status=self.instance_status,
+ os_type=self.op.os_type,
+ memory=self.op.mem_size,
+ vcpus=self.op.vcpus,
+ nics=[(self.inst_ip, self.op.bridge)],
+ ))
+
+ nl = ([self.sstore.GetMasterNode(), self.op.pnode] +
self.secondaries)
return env, nl, nl
"""
if self.op.mode not in (constants.INSTANCE_CREATE,
constants.INSTANCE_IMPORT):
- raise errors.OpPrereqError, ("Invalid instance creation mode '%s'" %
- self.op.mode)
+ raise errors.OpPrereqError("Invalid instance creation mode '%s'" %
+ self.op.mode)
if self.op.mode == constants.INSTANCE_IMPORT:
src_node = getattr(self.op, "src_node", None)
src_path = getattr(self.op, "src_path", None)
if src_node is None or src_path is None:
- raise errors.OpPrereqError, ("Importing an instance requires source"
- " node and path options")
+ raise errors.OpPrereqError("Importing an instance requires source"
+ " node and path options")
src_node_full = self.cfg.ExpandNodeName(src_node)
if src_node_full is None:
- raise errors.OpPrereqError, ("Unknown source node '%s'" % src_node)
+ raise errors.OpPrereqError("Unknown source node '%s'" % src_node)
self.op.src_node = src_node = src_node_full
if not os.path.isabs(src_path):
- raise errors.OpPrereqError, ("The source path must be absolute")
+ raise errors.OpPrereqError("The source path must be absolute")
export_info = rpc.call_export_info(src_node, src_path)
if not export_info:
- raise errors.OpPrereqError, ("No export found in dir %s" % src_path)
+ raise errors.OpPrereqError("No export found in dir %s" % src_path)
if not export_info.has_section(constants.INISECT_EXP):
- raise errors.ProgrammerError, ("Corrupted export config")
+ raise errors.ProgrammerError("Corrupted export config")
ei_version = export_info.get(constants.INISECT_EXP, 'version')
if (int(ei_version) != constants.EXPORT_VERSION):
- raise errors.OpPrereqError, ("Wrong export version %s (wanted %d)" %
- (ei_version, constants.EXPORT_VERSION))
+ raise errors.OpPrereqError("Wrong export version %s (wanted %d)" %
+ (ei_version, constants.EXPORT_VERSION))
if int(export_info.get(constants.INISECT_INS, 'disk_count')) > 1:
- raise errors.OpPrereqError, ("Can't import instance with more than"
- " one data disk")
+ raise errors.OpPrereqError("Can't import instance with more than"
+ " one data disk")
# FIXME: are the old os-es, disk sizes, etc. useful?
self.op.os_type = export_info.get(constants.INISECT_EXP, 'os')
self.src_image = diskimage
else: # INSTANCE_CREATE
if getattr(self.op, "os_type", None) is None:
- raise errors.OpPrereqError, ("No guest OS specified")
+ raise errors.OpPrereqError("No guest OS specified")
# check primary node
pnode = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(self.op.pnode))
if pnode is None:
- raise errors.OpPrereqError, ("Primary node '%s' is uknown" %
- self.op.pnode)
+ raise errors.OpPrereqError("Primary node '%s' is unknown" %
+ self.op.pnode)
self.op.pnode = pnode.name
self.pnode = pnode
self.secondaries = []
# disk template and mirror node verification
if self.op.disk_template not in constants.DISK_TEMPLATES:
- raise errors.OpPrereqError, ("Invalid disk template name")
+ raise errors.OpPrereqError("Invalid disk template name")
if self.op.disk_template == constants.DT_REMOTE_RAID1:
if getattr(self.op, "snode", None) is None:
- raise errors.OpPrereqError, ("The 'remote_raid1' disk template needs"
- " a mirror node")
+ raise errors.OpPrereqError("The 'remote_raid1' disk template needs"
+ " a mirror node")
snode_name = self.cfg.ExpandNodeName(self.op.snode)
if snode_name is None:
- raise errors.OpPrereqError, ("Unknown secondary node '%s'" %
- self.op.snode)
+ raise errors.OpPrereqError("Unknown secondary node '%s'" %
+ self.op.snode)
elif snode_name == pnode.name:
- raise errors.OpPrereqError, ("The secondary node cannot be"
- " the primary node.")
+ raise errors.OpPrereqError("The secondary node cannot be"
+ " the primary node.")
self.secondaries.append(snode_name)
# Check lv size requirements
}
if self.op.disk_template not in req_size_dict:
- raise errors.ProgrammerError, ("Disk template '%s' size requirement"
- " is unknown" % self.op.disk_template)
+ raise errors.ProgrammerError("Disk template '%s' size requirement"
+ " is unknown" % self.op.disk_template)
req_size = req_size_dict[self.op.disk_template]
for node in nodenames:
info = nodeinfo.get(node, None)
if not info:
- raise errors.OpPrereqError, ("Cannot get current information"
- " from node '%s'" % nodeinfo)
+ raise errors.OpPrereqError("Cannot get current information"
+ " from node '%s'" % nodeinfo)
if req_size > info['vg_free']:
- raise errors.OpPrereqError, ("Not enough disk space on target node %s."
- " %d MB available, %d MB required" %
- (node, info['vg_free'], req_size))
+ raise errors.OpPrereqError("Not enough disk space on target node %s."
+ " %d MB available, %d MB required" %
+ (node, info['vg_free'], req_size))
# os verification
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)
# instance verification
hostname1 = utils.LookupHostname(self.op.instance_name)
if not hostname1:
- raise errors.OpPrereqError, ("Instance name '%s' not found in dns" %
- self.op.instance_name)
+ raise errors.OpPrereqError("Instance name '%s' not found in dns" %
+ self.op.instance_name)
- self.op.instance_name = instance_name = hostname1['hostname']
+ self.op.instance_name = instance_name = hostname1.name
instance_list = self.cfg.GetInstanceList()
if instance_name in instance_list:
- raise errors.OpPrereqError, ("Instance '%s' is already in the cluster" %
- instance_name)
+ raise errors.OpPrereqError("Instance '%s' is already in the cluster" %
+ instance_name)
ip = getattr(self.op, "ip", None)
if ip is None or ip.lower() == "none":
inst_ip = None
elif ip.lower() == "auto":
- inst_ip = hostname1['ip']
+ inst_ip = hostname1.ip
else:
if not utils.IsValidIP(ip):
- raise errors.OpPrereqError, ("given IP address '%s' doesn't look"
- " like a valid IP" % ip)
+ raise errors.OpPrereqError("given IP address '%s' doesn't look"
+ " like a valid IP" % ip)
inst_ip = ip
self.inst_ip = inst_ip
- command = ["fping", "-q", hostname1['ip']]
- result = utils.RunCmd(command)
- if not result.failed:
- raise errors.OpPrereqError, ("IP %s of instance %s already in use" %
- (hostname1['ip'], instance_name))
+ if self.op.start and not self.op.ip_check:
+ raise errors.OpPrereqError("Cannot ignore IP address conflicts when"
+ " adding an instance in start mode")
+
+ if self.op.ip_check:
+ command = ["fping", "-q", hostname1.ip]
+ result = utils.RunCmd(command)
+ if not result.failed:
+ raise errors.OpPrereqError("IP address %s of instance %s already"
+ " in use" % (hostname1.ip, instance_name))
# bridge verification
bridge = getattr(self.op, "bridge", None)
self.op.bridge = bridge
if not rpc.call_bridges_exist(self.pnode.name, [self.op.bridge]):
- raise errors.OpPrereqError, ("target bridge '%s' does not exist on"
- " destination node '%s'" %
- (self.op.bridge, pnode.name))
+ raise errors.OpPrereqError("target bridge '%s' does not exist on"
+ " destination node '%s'" %
+ (self.op.bridge, pnode.name))
if self.op.start:
self.instance_status = 'up'
if self.inst_ip is not None:
nic.ip = self.inst_ip
- disks = _GenerateDiskTemplate(self.cfg, self.cfg.GetVGName(),
+ disks = _GenerateDiskTemplate(self.cfg,
self.op.disk_template,
instance, pnode_name,
self.secondaries, self.op.disk_size,
feedback_fn("* creating instance disks...")
if not _CreateDisks(self.cfg, iobj):
_RemoveDisks(iobj, self.cfg)
- raise errors.OpExecError, ("Device creation failed, reverting...")
+ raise errors.OpExecError("Device creation failed, reverting...")
feedback_fn("adding instance %s to cluster config" % instance)
if self.op.wait_for_sync:
disk_abort = not _WaitForSync(self.cfg, iobj)
- elif iobj.disk_template == "remote_raid1":
+ elif iobj.disk_template == constants.DT_REMOTE_RAID1:
# make sure the disks are not degraded (still sync-ing is ok)
time.sleep(15)
feedback_fn("* checking mirrors status")
if disk_abort:
_RemoveDisks(iobj, self.cfg)
self.cfg.RemoveInstance(iobj.name)
- raise errors.OpExecError, ("There are some degraded disks for"
- " this instance")
+ raise errors.OpExecError("There are some degraded disks for"
+ " this instance")
feedback_fn("creating os for instance %s on node %s" %
(instance, pnode_name))
if self.op.mode == constants.INSTANCE_CREATE:
feedback_fn("* running the instance OS create scripts...")
if not rpc.call_instance_os_add(pnode_name, iobj, "sda", "sdb"):
- raise errors.OpExecError, ("could not add os for instance %s"
- " on node %s" %
- (instance, pnode_name))
+ raise errors.OpExecError("could not add os for instance %s"
+ " on node %s" %
+ (instance, pnode_name))
elif self.op.mode == constants.INSTANCE_IMPORT:
feedback_fn("* running the instance OS import scripts...")
src_image = self.src_image
if not rpc.call_instance_os_import(pnode_name, iobj, "sda", "sdb",
src_node, src_image):
- raise errors.OpExecError, ("Could not import os for instance"
- " %s on node %s" %
- (instance, pnode_name))
+ raise errors.OpExecError("Could not import os for instance"
+ " %s on node %s" %
+ (instance, pnode_name))
else:
# also checked in the prereq part
- raise errors.ProgrammerError, ("Unknown OS initialization mode '%s'"
- % self.op.mode)
+ raise errors.ProgrammerError("Unknown OS initialization mode '%s'"
+ % self.op.mode)
if self.op.start:
logger.Info("starting instance %s on node %s" % (instance, pnode_name))
feedback_fn("* starting instance...")
if not rpc.call_instance_start(pnode_name, iobj, None):
- raise errors.OpExecError, ("Could not start instance")
+ raise errors.OpExecError("Could not start instance")
class LUConnectConsole(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):
node_insts = rpc.call_instance_list([node])[node]
if node_insts is False:
- raise errors.OpExecError, ("Can't connect to node %s." % node)
+ raise errors.OpExecError("Can't connect to node %s." % node)
if instance.name not in node_insts:
- raise errors.OpExecError, ("Instance %s is not running." % instance.name)
+ raise errors.OpExecError("Instance %s is not running." % instance.name)
logger.Debug("connecting to console of %s on %s" % (instance.name, node))
hyper = hypervisor.GetHypervisor()
console_cmd = hyper.GetShellCommandForConsole(instance.name)
- return node, console_cmd
+ # build ssh cmdline
+ argv = ["ssh", "-q", "-t"]
+ argv.extend(ssh.KNOWN_HOSTS_OPTS)
+ argv.extend(ssh.BATCH_MODE_OPTS)
+ argv.append(node)
+ argv.append(console_cmd)
+ return "ssh", argv
class LUAddMDDRBDComponent(LogicalUnit):
"""
env = {
- "INSTANCE_NAME": self.op.instance_name,
"NEW_SECONDARY": self.op.remote_node,
"DISK_NAME": self.op.disk_name,
}
- nl = [self.cfg.GetMaster(), self.instance.primary_node,
+ env.update(_BuildInstanceHookEnvByObject(self.instance))
+ nl = [self.sstore.GetMasterNode(), self.instance.primary_node,
self.op.remote_node,] + list(self.instance.secondary_nodes)
return env, nl, nl
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
remote_node = self.cfg.ExpandNodeName(self.op.remote_node)
if remote_node is None:
- raise errors.OpPrereqError, ("Node '%s' not known" % self.op.remote_node)
+ raise errors.OpPrereqError("Node '%s' not known" % self.op.remote_node)
self.remote_node = remote_node
if remote_node == instance.primary_node:
- raise errors.OpPrereqError, ("The specified node is the primary node of"
- " the instance.")
+ raise errors.OpPrereqError("The specified node is the primary node of"
+ " the instance.")
if instance.disk_template != constants.DT_REMOTE_RAID1:
- raise errors.OpPrereqError, ("Instance's disk layout is not"
- " remote_raid1.")
+ raise errors.OpPrereqError("Instance's disk layout is not"
+ " remote_raid1.")
for disk in instance.disks:
if disk.iv_name == self.op.disk_name:
break
else:
- raise errors.OpPrereqError, ("Can't find this device ('%s') in the"
- " instance." % self.op.disk_name)
+ raise errors.OpPrereqError("Can't find this device ('%s') in the"
+ " instance." % self.op.disk_name)
if len(disk.children) > 1:
- raise errors.OpPrereqError, ("The device already has two slave"
- " devices.\n"
- "This would create a 3-disk raid1"
- " which we don't allow.")
+ raise errors.OpPrereqError("The device already has two slave"
+ " devices.\n"
+ "This would create a 3-disk raid1"
+ " which we don't allow.")
self.disk = disk
def Exec(self, feedback_fn):
instance = self.instance
remote_node = self.remote_node
+ lv_names = [".%s_%s" % (disk.iv_name, suf) for suf in ["data", "meta"]]
+ names = _GenerateUniqueNames(self.cfg, lv_names)
new_drbd = _GenerateMDDRBDBranch(self.cfg, instance.primary_node,
- remote_node, disk.size, "%s-%s" %
- (instance.name, self.op.disk_name))
+ remote_node, disk.size, names)
logger.Info("adding new mirror component on secondary")
#HARDCODE
- if not _CreateBlockDevOnSecondary(self.cfg, remote_node, new_drbd, False):
- raise errors.OpExecError, ("Failed to create new component on secondary"
- " node %s" % remote_node)
+ if not _CreateBlockDevOnSecondary(self.cfg, remote_node, new_drbd, False,
+ _GetInstanceInfoText(instance)):
+ raise errors.OpExecError("Failed to create new component on secondary"
+ " node %s" % remote_node)
logger.Info("adding new mirror component on primary")
#HARDCODE
- if not _CreateBlockDevOnPrimary(self.cfg, instance.primary_node, new_drbd):
+ if not _CreateBlockDevOnPrimary(self.cfg, instance.primary_node, new_drbd,
+ _GetInstanceInfoText(instance)):
# remove secondary dev
self.cfg.SetDiskID(new_drbd, remote_node)
rpc.call_blockdev_remove(remote_node, new_drbd)
- raise errors.OpExecError, ("Failed to create volume on primary")
+ raise errors.OpExecError("Failed to create volume on primary")
# the device exists now
# call the primary node to add the mirror to md
self.cfg.SetDiskID(new_drbd, instance.primary_node)
if not rpc.call_blockdev_remove(instance.primary_node, new_drbd):
logger.Error("Can't rollback on primary")
- raise errors.OpExecError, "Can't add mirror component to md array"
+ raise errors.OpExecError("Can't add mirror component to md array")
disk.children.append(new_drbd)
"""
env = {
- "INSTANCE_NAME": self.op.instance_name,
"DISK_NAME": self.op.disk_name,
"DISK_ID": self.op.disk_id,
"OLD_SECONDARY": self.old_secondary,
}
- nl = [self.cfg.GetMaster(),
+ env.update(_BuildInstanceHookEnvByObject(self.instance))
+ nl = [self.sstore.GetMasterNode(),
self.instance.primary_node] + list(self.instance.secondary_nodes)
return env, nl, nl
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
if instance.disk_template != constants.DT_REMOTE_RAID1:
- raise errors.OpPrereqError, ("Instance's disk layout is not"
- " remote_raid1.")
+ raise errors.OpPrereqError("Instance's disk layout is not"
+ " remote_raid1.")
for disk in instance.disks:
if disk.iv_name == self.op.disk_name:
break
else:
- raise errors.OpPrereqError, ("Can't find this device ('%s') in the"
- " instance." % self.op.disk_name)
+ raise errors.OpPrereqError("Can't find this device ('%s') in the"
+ " instance." % self.op.disk_name)
for child in disk.children:
if child.dev_type == "drbd" and child.logical_id[2] == self.op.disk_id:
break
else:
- raise errors.OpPrereqError, ("Can't find the device with this port.")
+ raise errors.OpPrereqError("Can't find the device with this port.")
if len(disk.children) < 2:
- raise errors.OpPrereqError, ("Cannot remove the last component from"
- " a mirror.")
+ raise errors.OpPrereqError("Cannot remove the last component from"
+ " a mirror.")
self.disk = disk
self.child = child
if self.child.logical_id[0] == instance.primary_node:
self.cfg.SetDiskID(disk, instance.primary_node)
if not rpc.call_blockdev_removechild(instance.primary_node,
disk, child):
- raise errors.OpExecError, ("Can't remove child from mirror.")
+ raise errors.OpExecError("Can't remove child from mirror.")
for node in child.logical_id[:2]:
self.cfg.SetDiskID(child, node)
"""
env = {
- "INSTANCE_NAME": self.op.instance_name,
"NEW_SECONDARY": self.op.remote_node,
"OLD_SECONDARY": self.instance.secondary_nodes[0],
}
- nl = [self.cfg.GetMaster(),
+ env.update(_BuildInstanceHookEnvByObject(self.instance))
+ nl = [self.sstore.GetMasterNode(),
self.instance.primary_node] + list(self.instance.secondary_nodes)
return env, nl, nl
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
if instance.disk_template != constants.DT_REMOTE_RAID1:
- raise errors.OpPrereqError, ("Instance's disk layout is not"
- " remote_raid1.")
+ raise errors.OpPrereqError("Instance's disk layout is not"
+ " remote_raid1.")
if len(instance.secondary_nodes) != 1:
- raise errors.OpPrereqError, ("The instance has a strange layout,"
- " expected one secondary but found %d" %
- len(instance.secondary_nodes))
+ raise errors.OpPrereqError("The instance has a strange layout,"
+ " expected one secondary but found %d" %
+ len(instance.secondary_nodes))
remote_node = getattr(self.op, "remote_node", None)
if remote_node is None:
else:
remote_node = self.cfg.ExpandNodeName(remote_node)
if remote_node is None:
- raise errors.OpPrereqError, ("Node '%s' not known" %
- self.op.remote_node)
+ raise errors.OpPrereqError("Node '%s' not known" %
+ self.op.remote_node)
if remote_node == instance.primary_node:
- raise errors.OpPrereqError, ("The specified node is the primary node of"
- " the instance.")
+ raise errors.OpPrereqError("The specified node is the primary node of"
+ " the instance.")
self.op.remote_node = remote_node
def Exec(self, feedback_fn):
cfg = self.cfg
for dev in instance.disks:
size = dev.size
+ lv_names = [".%s_%s" % (dev.iv_name, suf) for suf in ["data", "meta"]]
+ names = _GenerateUniqueNames(cfg, lv_names)
new_drbd = _GenerateMDDRBDBranch(cfg, instance.primary_node,
- remote_node, size,
- "%s-%s" % (instance.name, dev.iv_name))
+ remote_node, size, names)
iv_names[dev.iv_name] = (dev, dev.children[0], new_drbd)
logger.Info("adding new mirror component on secondary for %s" %
dev.iv_name)
#HARDCODE
- if not _CreateBlockDevOnSecondary(cfg, remote_node, new_drbd, False):
- raise errors.OpExecError, ("Failed to create new component on"
- " secondary node %s\n"
- "Full abort, cleanup manually!" %
- remote_node)
+ if not _CreateBlockDevOnSecondary(cfg, remote_node, new_drbd, False,
+ _GetInstanceInfoText(instance)):
+ raise errors.OpExecError("Failed to create new component on"
+ " secondary node %s\n"
+ "Full abort, cleanup manually!" %
+ remote_node)
logger.Info("adding new mirror component on primary")
#HARDCODE
- if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, new_drbd):
+ if not _CreateBlockDevOnPrimary(cfg, instance.primary_node, new_drbd,
+ _GetInstanceInfoText(instance)):
# remove secondary dev
cfg.SetDiskID(new_drbd, remote_node)
rpc.call_blockdev_remove(remote_node, new_drbd)
# call the primary node to add the mirror to md
logger.Info("adding new mirror component to md")
if not rpc.call_blockdev_addchild(instance.primary_node, dev,
- new_drbd):
+ new_drbd):
logger.Error("Can't add mirror compoment to md!")
cfg.SetDiskID(new_drbd, remote_node)
if not rpc.call_blockdev_remove(remote_node, new_drbd):
cfg.SetDiskID(new_drbd, instance.primary_node)
if not rpc.call_blockdev_remove(instance.primary_node, new_drbd):
logger.Error("Can't rollback on primary")
- raise errors.OpExecError, ("Full abort, cleanup manually!!")
+ raise errors.OpExecError("Full abort, cleanup manually!!")
dev.children.append(new_drbd)
cfg.AddInstance(instance)
cfg.SetDiskID(dev, instance.primary_node)
is_degr = rpc.call_blockdev_find(instance.primary_node, dev)[5]
if is_degr:
- raise errors.OpExecError, ("MD device %s is degraded!" % name)
+ raise errors.OpExecError("MD device %s is degraded!" % name)
cfg.SetDiskID(new_drbd, instance.primary_node)
is_degr = rpc.call_blockdev_find(instance.primary_node, new_drbd)[5]
if is_degr:
- raise errors.OpExecError, ("New drbd device %s is degraded!" % name)
+ raise errors.OpExecError("New drbd device %s is degraded!" % name)
for name in iv_names:
dev, child, new_drbd = iv_names[name]
"""
if not isinstance(self.op.instances, list):
- raise errors.OpPrereqError, "Invalid argument type 'instances'"
+ raise errors.OpPrereqError("Invalid argument type 'instances'")
if self.op.instances:
self.wanted_instances = []
names = self.op.instances
for name in names:
instance = self.cfg.GetInstanceInfo(self.cfg.ExpandInstanceName(name))
if instance is None:
- raise errors.OpPrereqError, ("No such instance name '%s'" % name)
+ raise errors.OpPrereqError("No such instance name '%s'" % name)
self.wanted_instances.append(instance)
else:
self.wanted_instances = [self.cfg.GetInstanceInfo(name) for name
def Exec(self, feedback_fn):
"""Gather and return data"""
-
result = {}
for instance in self.wanted_instances:
remote_info = rpc.call_instance_info(instance.primary_node,
return result
-class LUQueryNodeData(NoHooksLU):
- """Logical unit for querying node data.
-
- """
- _OP_REQP = ["nodes"]
-
- def CheckPrereq(self):
- """Check prerequisites.
-
- This only checks the optional node list against the existing names.
-
- """
- if not isinstance(self.op.nodes, list):
- raise errors.OpPrereqError, "Invalid argument type 'nodes'"
- if self.op.nodes:
- self.wanted_nodes = []
- names = self.op.nodes
- for name in names:
- node = self.cfg.GetNodeInfo(self.cfg.ExpandNodeName(name))
- if node is None:
- raise errors.OpPrereqError, ("No such node name '%s'" % name)
- self.wanted_nodes.append(node)
- else:
- self.wanted_nodes = [self.cfg.GetNodeInfo(name) for name
- in self.cfg.GetNodeList()]
- return
-
- def Exec(self, feedback_fn):
- """Compute and return the list of nodes.
-
- """
-
- ilist = [self.cfg.GetInstanceInfo(iname) for iname
- in self.cfg.GetInstanceList()]
- result = []
- for node in self.wanted_nodes:
- result.append((node.name, node.primary_ip, node.secondary_ip,
- [inst.name for inst in ilist
- if inst.primary_node == node.name],
- [inst.name for inst in ilist
- if node.name in inst.secondary_nodes],
- ))
- return result
-
-
class LUSetInstanceParms(LogicalUnit):
"""Modifies an instances's parameters.
This runs on the master, primary and secondaries.
"""
- env = {
- "INSTANCE_NAME": self.op.instance_name,
- }
+ args = dict()
if self.mem:
- env["MEM_SIZE"] = self.mem
+ args['memory'] = self.mem
if self.vcpus:
- env["VCPUS"] = self.vcpus
- if self.do_ip:
- env["INSTANCE_IP"] = self.ip
- if self.bridge:
- env["BRIDGE"] = self.bridge
-
- nl = [self.cfg.GetMaster(),
+ args['vcpus'] = self.vcpus
+ if self.do_ip or self.do_bridge:
+ if self.do_ip:
+ ip = self.ip
+ else:
+ ip = self.instance.nics[0].ip
+ if self.bridge:
+ bridge = self.bridge
+ else:
+ bridge = self.instance.nics[0].bridge
+ args['nics'] = [(ip, bridge)]
+ env = _BuildInstanceHookEnvByObject(self.instance, override=args)
+ nl = [self.sstore.GetMasterNode(),
self.instance.primary_node] + list(self.instance.secondary_nodes)
-
return env, nl, nl
def CheckPrereq(self):
self.ip = getattr(self.op, "ip", None)
self.bridge = getattr(self.op, "bridge", None)
if [self.mem, self.vcpus, self.ip, self.bridge].count(None) == 4:
- raise errors.OpPrereqError, ("No changes submitted")
+ raise errors.OpPrereqError("No changes submitted")
if self.mem is not None:
try:
self.mem = int(self.mem)
except ValueError, err:
- raise errors.OpPrereqError, ("Invalid memory size: %s" % str(err))
+ raise errors.OpPrereqError("Invalid memory size: %s" % str(err))
if self.vcpus is not None:
try:
self.vcpus = int(self.vcpus)
except ValueError, err:
- raise errors.OpPrereqError, ("Invalid vcpus number: %s" % str(err))
+ raise errors.OpPrereqError("Invalid vcpus number: %s" % str(err))
if self.ip is not None:
self.do_ip = True
if self.ip.lower() == "none":
self.ip = None
else:
if not utils.IsValidIP(self.ip):
- raise errors.OpPrereqError, ("Invalid IP address '%s'." % self.ip)
+ raise errors.OpPrereqError("Invalid IP address '%s'." % self.ip)
else:
self.do_ip = False
+ self.do_bridge = (self.bridge is not None)
instance = self.cfg.GetInstanceInfo(
self.cfg.ExpandInstanceName(self.op.instance_name))
if instance is None:
- raise errors.OpPrereqError, ("No such instance name '%s'" %
- self.op.instance_name)
+ raise errors.OpPrereqError("No such instance name '%s'" %
+ self.op.instance_name)
self.op.instance_name = instance.name
self.instance = instance
return
"""Check that the nodelist contains only existing nodes.
"""
- nodes = getattr(self.op, "nodes", None)
- if not nodes:
- self.op.nodes = self.cfg.GetNodeList()
- else:
- expnodes = [self.cfg.ExpandNodeName(node) for node in nodes]
- if expnodes.count(None) > 0:
- raise errors.OpPrereqError, ("At least one of the given nodes %s"
- " is unknown" % self.op.nodes)
- self.op.nodes = expnodes
+ self.nodes = _GetWantedNodes(self, getattr(self.op, "nodes", None))
def Exec(self, feedback_fn):
-
"""Compute the list of all the exported system images.
Returns:
that node.
"""
- return rpc.call_export_list(self.op.nodes)
+ return rpc.call_export_list(self.nodes)
class LUExportInstance(LogicalUnit):
"""
env = {
- "INSTANCE_NAME": self.op.instance_name,
"EXPORT_NODE": self.op.target_node,
"EXPORT_DO_SHUTDOWN": self.op.shutdown,
}
- nl = [self.cfg.GetMaster(), self.instance.primary_node,
+ env.update(_BuildInstanceHookEnvByObject(self.instance))
+ nl = [self.sstore.GetMasterNode(), self.instance.primary_node,
self.op.target_node]
return env, nl, nl
instance_name = self.cfg.ExpandInstanceName(self.op.instance_name)
self.instance = self.cfg.GetInstanceInfo(instance_name)
if self.instance is None:
- raise errors.OpPrereqError, ("Instance '%s' not found" %
- self.op.instance_name)
+ raise errors.OpPrereqError("Instance '%s' not found" %
+ self.op.instance_name)
# node verification
dst_node_short = self.cfg.ExpandNodeName(self.op.target_node)
self.dst_node = self.cfg.GetNodeInfo(dst_node_short)
if self.dst_node is None:
- raise errors.OpPrereqError, ("Destination node '%s' is uknown." %
- self.op.target_node)
+ raise errors.OpPrereqError("Destination node '%s' is unknown." %
+ self.op.target_node)
self.op.target_node = self.dst_node.name
def Exec(self, feedback_fn):
if not rpc.call_export_remove(node, instance.name):
logger.Error("could not remove older export for instance %s"
" on node %s" % (instance.name, node))
+
+
+class TagsLU(NoHooksLU):
+ """Generic tags LU.
+
+ This is an abstract class which is the parent of all the other tags LUs.
+
+ """
+ def CheckPrereq(self):
+ """Check prerequisites.
+
+ """
+ if self.op.kind == constants.TAG_CLUSTER:
+ self.target = self.cfg.GetClusterInfo()
+ elif self.op.kind == constants.TAG_NODE:
+ name = self.cfg.ExpandNodeName(self.op.name)
+ if name is None:
+ raise errors.OpPrereqError("Invalid node name (%s)" %
+ (self.op.name,))
+ self.op.name = name
+ self.target = self.cfg.GetNodeInfo(name)
+ elif self.op.kind == constants.TAG_INSTANCE:
+ name = self.cfg.ExpandInstanceName(name)
+ if name is None:
+ raise errors.OpPrereqError("Invalid instance name (%s)" %
+ (self.op.name,))
+ self.op.name = name
+ self.target = self.cfg.GetInstanceInfo(name)
+ else:
+ raise errors.OpPrereqError("Wrong tag type requested (%s)" %
+ str(self.op.kind))
+
+
+class LUGetTags(TagsLU):
+ """Returns the tags of a given object.
+
+ """
+ _OP_REQP = ["kind", "name"]
+
+ def Exec(self, feedback_fn):
+ """Returns the tag list.
+
+ """
+ return self.target.GetTags()
+
+
+class LUAddTag(TagsLU):
+ """Sets a tag on a given object.
+
+ """
+ _OP_REQP = ["kind", "name", "tag"]
+
+ def CheckPrereq(self):
+ """Check prerequisites.
+
+ This checks the type and length of the tag name and value.
+
+ """
+ TagsLU.CheckPrereq(self)
+ objects.TaggableObject.ValidateTag(self.op.tag)
+
+ def Exec(self, feedback_fn):
+ """Sets the tag.
+
+ """
+ try:
+ self.target.AddTag(self.op.tag)
+ except errors.TagError, err:
+ raise errors.OpExecError("Error while setting tag: %s" % str(err))
+ try:
+ self.cfg.Update(self.target)
+ except errors.ConfigurationError:
+ raise errors.OpRetryError("There has been a modification to the"
+ " config file and the operation has been"
+ " aborted. Please retry.")
+
+
+class LUDelTag(TagsLU):
+ """Delete a tag from a given object.
+
+ """
+ _OP_REQP = ["kind", "name", "tag"]
+
+ def CheckPrereq(self):
+ """Check prerequisites.
+
+ This checks that we have the given tag.
+
+ """
+ TagsLU.CheckPrereq(self)
+ objects.TaggableObject.ValidateTag(self.op.tag)
+ if self.op.tag not in self.target.GetTags():
+ raise errors.OpPrereqError("Tag not found")
+
+ def Exec(self, feedback_fn):
+ """Remove the tag from the object.
+
+ """
+ self.target.RemoveTag(self.op.tag)
+ try:
+ self.cfg.Update(self.target)
+ except errors.ConfigurationError:
+ raise errors.OpRetryError("There has been a modification to the"
+ " config file and the operation has been"
+ " aborted. Please retry.")
projects / ganeti-local / blobdiff