from ganeti import serializer
from ganeti import netutils
from ganeti import runtime
+from ganeti import mcpu
+from ganeti import compat
_BOOT_ID_PATH = "/proc/sys/kernel/random/boot_id"
#: Valid LVS output line regex
_LVSLINE_REGEX = re.compile("^ *([^|]+)\|([^|]+)\|([0-9.]+)\|([^|]{6})\|?$")
+# Actions for the master setup script
+_MASTER_START = "start"
+_MASTER_STOP = "stop"
+
class RPCFail(Exception):
"""Class denoting RPC failure.
master_netmask)
-def ActivateMasterIp():
- """Activate the IP address of the master daemon.
+def RunLocalHooks(hook_opcode, hooks_path, env_builder_fn):
+ """Decorator that runs hooks before and after the decorated function.
+
+ @type hook_opcode: string
+ @param hook_opcode: opcode of the hook
+ @type hooks_path: string
+ @param hooks_path: path of the hooks
+ @type env_builder_fn: function
+ @param env_builder_fn: function that returns a dictionary containing the
+ environment variables for the hooks. Will get all the parameters of the
+ decorated function.
+ @raise RPCFail: in case of pre-hook failure
"""
- # GetMasterInfo will raise an exception if not able to return data
- master_netdev, master_ip, _, family, master_netmask = GetMasterInfo()
+ def decorator(fn):
+ def wrapper(*args, **kwargs):
+ _, myself = ssconf.GetMasterAndMyself()
+ nodes = ([myself], [myself]) # these hooks run locally
- err_msg = None
- if netutils.TcpPing(master_ip, constants.DEFAULT_NODED_PORT):
- if netutils.IPAddress.Own(master_ip):
- # we already have the ip:
- logging.debug("Master IP already configured, doing nothing")
- else:
- err_msg = "Someone else has the master ip, not activating"
- logging.error(err_msg)
+ env_fn = compat.partial(env_builder_fn, *args, **kwargs)
+
+ cfg = _GetConfig()
+ hr = HooksRunner()
+ hm = mcpu.HooksMaster(hook_opcode, hooks_path, nodes, hr.RunLocalHooks,
+ None, env_fn, logging.warning, cfg.GetClusterName(),
+ cfg.GetMasterNode())
+
+ hm.RunPhase(constants.HOOKS_PHASE_PRE)
+ result = fn(*args, **kwargs)
+ hm.RunPhase(constants.HOOKS_PHASE_POST)
+
+ return result
+ return wrapper
+ return decorator
+
+
+def _BuildMasterIpEnv(master_params, use_external_mip_script=None):
+ """Builds environment variables for master IP hooks.
+
+ @type master_params: L{objects.MasterNetworkParameters}
+ @param master_params: network parameters of the master
+ @type use_external_mip_script: boolean
+ @param use_external_mip_script: whether to use an external master IP
+ address setup script (unused, but necessary per the implementation of the
+ _RunLocalHooks decorator)
+
+ """
+ # pylint: disable=W0613
+ ver = netutils.IPAddress.GetVersionFromAddressFamily(master_params.ip_family)
+ env = {
+ "MASTER_NETDEV": master_params.netdev,
+ "MASTER_IP": master_params.ip,
+ "MASTER_NETMASK": str(master_params.netmask),
+ "CLUSTER_IP_VERSION": str(ver),
+ }
+
+ return env
+
+
+def _RunMasterSetupScript(master_params, action, use_external_mip_script):
+ """Execute the master IP address setup script.
+
+ @type master_params: L{objects.MasterNetworkParameters}
+ @param master_params: network parameters of the master
+ @type action: string
+ @param action: action to pass to the script. Must be one of
+ L{backend._MASTER_START} or L{backend._MASTER_STOP}
+ @type use_external_mip_script: boolean
+ @param use_external_mip_script: whether to use an external master IP
+ address setup script
+ @raise backend.RPCFail: if there are errors during the execution of the
+ script
+
+ """
+ env = _BuildMasterIpEnv(master_params)
+
+ if use_external_mip_script:
+ setup_script = constants.EXTERNAL_MASTER_SETUP_SCRIPT
else:
- ipcls = netutils.IPAddress.GetClassFromIpFamily(family)
+ setup_script = constants.DEFAULT_MASTER_SETUP_SCRIPT
- result = utils.RunCmd([constants.IP_COMMAND_PATH, "address", "add",
- "%s/%s" % (master_ip, master_netmask),
- "dev", master_netdev, "label",
- "%s:0" % master_netdev])
- if result.failed:
- err_msg = "Can't activate master IP: %s" % result.output
- logging.error(err_msg)
+ result = utils.RunCmd([setup_script, action], env=env, reset_env=True)
+
+ if result.failed:
+ _Fail("Failed to %s the master IP. Script return value: %s" %
+ (action, result.exit_code), log=True)
- else:
- # we ignore the exit code of the following cmds
- if ipcls == netutils.IP4Address:
- utils.RunCmd(["arping", "-q", "-U", "-c 3", "-I", master_netdev, "-s",
- master_ip, master_ip])
- elif ipcls == netutils.IP6Address:
- try:
- utils.RunCmd(["ndisc6", "-q", "-r 3", master_ip, master_netdev])
- except errors.OpExecError:
- # TODO: Better error reporting
- logging.warning("Can't execute ndisc6, please install if missing")
- if err_msg:
- _Fail(err_msg)
+@RunLocalHooks(constants.FAKE_OP_MASTER_TURNUP, "master-ip-turnup",
+ _BuildMasterIpEnv)
+def ActivateMasterIp(master_params, use_external_mip_script):
+ """Activate the IP address of the master daemon.
+
+ @type master_params: L{objects.MasterNetworkParameters}
+ @param master_params: network parameters of the master
+ @type use_external_mip_script: boolean
+ @param use_external_mip_script: whether to use an external master IP
+ address setup script
+ @raise RPCFail: in case of errors during the IP startup
+
+ """
+ _RunMasterSetupScript(master_params, _MASTER_START,
+ use_external_mip_script)
def StartMasterDaemons(no_voting):
_Fail(msg)
-def DeactivateMasterIp():
+@RunLocalHooks(constants.FAKE_OP_MASTER_TURNDOWN, "master-ip-turndown",
+ _BuildMasterIpEnv)
+def DeactivateMasterIp(master_params, use_external_mip_script):
"""Deactivate the master IP on this node.
- """
- # TODO: log and report back to the caller the error failures; we
- # need to decide in which case we fail the RPC for this
-
- # GetMasterInfo will raise an exception if not able to return data
- master_netdev, master_ip, _, _, master_netmask = GetMasterInfo()
+ @type master_params: L{objects.MasterNetworkParameters}
+ @param master_params: network parameters of the master
+ @type use_external_mip_script: boolean
+ @param use_external_mip_script: whether to use an external master IP
+ address setup script
+ @raise RPCFail: in case of errors during the IP turndown
- result = utils.RunCmd([constants.IP_COMMAND_PATH, "address", "del",
- "%s/%s" % (master_ip, master_netmask),
- "dev", master_netdev])
- if result.failed:
- logging.error("Can't remove the master IP, error: %s", result.output)
- # but otherwise ignore the failure
+ """
+ _RunMasterSetupScript(master_params, _MASTER_STOP,
+ use_external_mip_script)
def StopMasterDaemons():
result.cmd, result.exit_code, result.output)
-def ChangeMasterNetmask(netmask):
+def ChangeMasterNetmask(old_netmask, netmask, master_ip, master_netdev):
"""Change the netmask of the master IP.
+ @param old_netmask: the old value of the netmask
+ @param netmask: the new value of the netmask
+ @param master_ip: the master IP
+ @param master_netdev: the master network device
+
"""
- master_netdev, master_ip, _, _, old_netmask = GetMasterInfo()
if old_netmask == netmask:
return
+ if not netutils.IPAddress.Own(master_ip):
+ _Fail("The master IP address is not up, not attempting to change its"
+ " netmask")
+
result = utils.RunCmd([constants.IP_COMMAND_PATH, "address", "add",
"%s/%s" % (master_ip, netmask),
"dev", master_netdev, "label",
"%s:0" % master_netdev])
if result.failed:
- _Fail("Could not change the master IP netmask")
+ _Fail("Could not set the new netmask on the master IP address")
result = utils.RunCmd([constants.IP_COMMAND_PATH, "address", "del",
"%s/%s" % (master_ip, old_netmask),
"dev", master_netdev, "label",
"%s:0" % master_netdev])
if result.failed:
- _Fail("Could not change the master IP netmask")
+ _Fail("Could not bring down the master IP address with the old netmask")
def EtcHostsModify(mode, host, ip):
result[constants.NV_MASTERIP] = netutils.TcpPing(master_ip, port,
source=source)
+ if constants.NV_USERSCRIPTS in what:
+ result[constants.NV_USERSCRIPTS] = \
+ [script for script in what[constants.NV_USERSCRIPTS]
+ if not (os.path.exists(script) and os.access(script, os.X_OK))]
+
if constants.NV_OOB_PATHS in what:
result[constants.NV_OOB_PATHS] = tmp = []
for path in what[constants.NV_OOB_PATHS]:
device.Assemble()
except errors.BlockDeviceError, err:
_Fail("Can't assemble device after creation, unusual event: %s", err)
- device.SetSyncSpeed(constants.SYNC_SPEED)
if on_primary or disk.OpenOnSecondary():
try:
device.Open(force=True)
if as_primary or disk.AssembleOnSecondary():
r_dev = bdev.Assemble(disk.dev_type, disk.physical_id, children, disk.size)
- r_dev.SetSyncSpeed(constants.SYNC_SPEED)
result = r_dev
if as_primary or disk.OpenOnSecondary():
r_dev.Open()
config.add_section(constants.INISECT_INS)
config.set(constants.INISECT_INS, "name", instance.name)
+ config.set(constants.INISECT_INS, "maxmem", "%d" %
+ instance.beparams[constants.BE_MAXMEM])
+ config.set(constants.INISECT_INS, "minmem", "%d" %
+ instance.beparams[constants.BE_MINMEM])
+ # "memory" is deprecated, but useful for exporting to old ganeti versions
config.set(constants.INISECT_INS, "memory", "%d" %
- instance.beparams[constants.BE_MEMORY])
+ instance.beparams[constants.BE_MAXMEM])
config.set(constants.INISECT_INS, "vcpus", "%d" %
instance.beparams[constants.BE_VCPUS])
config.set(constants.INISECT_INS, "disk_template", instance.disk_template)
# constant
self._BASE_DIR = hooks_base_dir # pylint: disable=C0103
+ def RunLocalHooks(self, node_list, hpath, phase, env):
+ """Check that the hooks will be run only locally and then run them.
+
+ """
+ assert len(node_list) == 1
+ node = node_list[0]
+ _, myself = ssconf.GetMasterAndMyself()
+ assert node == myself
+
+ results = self.RunHooks(hpath, phase, env)
+
+ # Return values in the form expected by HooksMaster
+ return {node: (None, False, results)}
+
def RunHooks(self, hpath, phase, env):
"""Run the scripts in the hooks directory.
projects / ganeti-local / blobdiff