code.grnet.gr Git - ganeti-local/blob - lib/hooksmaster.py

   1 #
   2 #
   3
   4 # Copyright (C) 2006, 2007, 2011, 2012 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21
  22 """Module implementing the logic for running hooks.
  23
  24 """
  25
  26 from ganeti import constants
  27 from ganeti import errors
  28 from ganeti import utils
  29 from ganeti import compat
  30 from ganeti import pathutils
  31
  32
  33 def _RpcResultsToHooksResults(rpc_results):
  34   """Function to convert RPC results to the format expected by HooksMaster.
  35
  36   @type rpc_results: dict(node: L{rpc.RpcResult})
  37   @param rpc_results: RPC results
  38   @rtype: dict(node: (fail_msg, offline, hooks_results))
  39   @return: RPC results unpacked according to the format expected by
  40     L({hooksmaster.HooksMaster}
  41
  42   """
  43   return dict((node, (rpc_res.fail_msg, rpc_res.offline, rpc_res.payload))
  44               for (node, rpc_res) in rpc_results.items())
  45
  46
  47 class HooksMaster(object):
  48   def __init__(self, opcode, hooks_path, nodes, hooks_execution_fn,
  49                hooks_results_adapt_fn, build_env_fn, log_fn, htype=None,
  50                cluster_name=None, master_name=None):
  51     """Base class for hooks masters.
  52
  53     This class invokes the execution of hooks according to the behaviour
  54     specified by its parameters.
  55
  56     @type opcode: string
  57     @param opcode: opcode of the operation to which the hooks are tied
  58     @type hooks_path: string
  59     @param hooks_path: prefix of the hooks directories
  60     @type nodes: 2-tuple of lists
  61     @param nodes: 2-tuple of lists containing nodes on which pre-hooks must be
  62       run and nodes on which post-hooks must be run
  63     @type hooks_execution_fn: function that accepts the following parameters:
  64       (node_list, hooks_path, phase, environment)
  65     @param hooks_execution_fn: function that will execute the hooks; can be
  66       None, indicating that no conversion is necessary.
  67     @type hooks_results_adapt_fn: function
  68     @param hooks_results_adapt_fn: function that will adapt the return value of
  69       hooks_execution_fn to the format expected by RunPhase
  70     @type build_env_fn: function that returns a dictionary having strings as
  71       keys
  72     @param build_env_fn: function that builds the environment for the hooks
  73     @type log_fn: function that accepts a string
  74     @param log_fn: logging function
  75     @type htype: string or None
  76     @param htype: None or one of L{constants.HTYPE_CLUSTER},
  77      L{constants.HTYPE_NODE}, L{constants.HTYPE_INSTANCE}
  78     @type cluster_name: string
  79     @param cluster_name: name of the cluster
  80     @type master_name: string
  81     @param master_name: name of the master
  82
  83     """
  84     self.opcode = opcode
  85     self.hooks_path = hooks_path
  86     self.hooks_execution_fn = hooks_execution_fn
  87     self.hooks_results_adapt_fn = hooks_results_adapt_fn
  88     self.build_env_fn = build_env_fn
  89     self.log_fn = log_fn
  90     self.htype = htype
  91     self.cluster_name = cluster_name
  92     self.master_name = master_name
  93
  94     self.pre_env = self._BuildEnv(constants.HOOKS_PHASE_PRE)
  95     (self.pre_nodes, self.post_nodes) = nodes
  96
  97   def _BuildEnv(self, phase):
  98     """Compute the environment and the target nodes.
  99
 100     Based on the opcode and the current node list, this builds the
 101     environment for the hooks and the target node list for the run.
 102
 103     """
 104     if phase == constants.HOOKS_PHASE_PRE:
 105       prefix = "GANETI_"
 106     elif phase == constants.HOOKS_PHASE_POST:
 107       prefix = "GANETI_POST_"
 108     else:
 109       raise AssertionError("Unknown phase '%s'" % phase)
 110
 111     env = {}
 112
 113     if self.hooks_path is not None:
 114       phase_env = self.build_env_fn()
 115       if phase_env:
 116         assert not compat.any(key.upper().startswith(prefix)
 117                               for key in phase_env)
 118         env.update(("%s%s" % (prefix, key), value)
 119                    for (key, value) in phase_env.items())
 120
 121     if phase == constants.HOOKS_PHASE_PRE:
 122       assert compat.all((key.startswith("GANETI_") and
 123                          not key.startswith("GANETI_POST_"))
 124                         for key in env)
 125
 126     elif phase == constants.HOOKS_PHASE_POST:
 127       assert compat.all(key.startswith("GANETI_POST_") for key in env)
 128       assert isinstance(self.pre_env, dict)
 129
 130       # Merge with pre-phase environment
 131       assert not compat.any(key.startswith("GANETI_POST_")
 132                             for key in self.pre_env)
 133       env.update(self.pre_env)
 134     else:
 135       raise AssertionError("Unknown phase '%s'" % phase)
 136
 137     return env
 138
 139   def _RunWrapper(self, node_list, hpath, phase, phase_env):
 140     """Simple wrapper over self.callfn.
 141
 142     This method fixes the environment before executing the hooks.
 143
 144     """
 145     env = {
 146       "PATH": constants.HOOKS_PATH,
 147       "GANETI_HOOKS_VERSION": constants.HOOKS_VERSION,
 148       "GANETI_OP_CODE": self.opcode,
 149       "GANETI_DATA_DIR": pathutils.DATA_DIR,
 150       "GANETI_HOOKS_PHASE": phase,
 151       "GANETI_HOOKS_PATH": hpath,
 152       }
 153
 154     if self.htype:
 155       env["GANETI_OBJECT_TYPE"] = self.htype
 156
 157     if self.cluster_name is not None:
 158       env["GANETI_CLUSTER"] = self.cluster_name
 159
 160     if self.master_name is not None:
 161       env["GANETI_MASTER"] = self.master_name
 162
 163     if phase_env:
 164       env = utils.algo.JoinDisjointDicts(env, phase_env)
 165
 166     # Convert everything to strings
 167     env = dict([(str(key), str(val)) for key, val in env.iteritems()])
 168
 169     assert compat.all(key == "PATH" or key.startswith("GANETI_")
 170                       for key in env)
 171
 172     return self.hooks_execution_fn(node_list, hpath, phase, env)
 173
 174   def RunPhase(self, phase, node_names=None):
 175     """Run all the scripts for a phase.
 176
 177     This is the main function of the HookMaster.
 178     It executes self.hooks_execution_fn, and after running
 179     self.hooks_results_adapt_fn on its results it expects them to be in the
 180     form {node_name: (fail_msg, [(script, result, output), ...]}).
 181
 182     @param phase: one of L{constants.HOOKS_PHASE_POST} or
 183         L{constants.HOOKS_PHASE_PRE}; it denotes the hooks phase
 184     @param node_names: overrides the predefined list of nodes for the given
 185         phase
 186     @return: the processed results of the hooks multi-node rpc call
 187     @raise errors.HooksFailure: on communication failure to the nodes
 188     @raise errors.HooksAbort: on failure of one of the hooks
 189
 190     """
 191     if phase == constants.HOOKS_PHASE_PRE:
 192       if node_names is None:
 193         node_names = self.pre_nodes
 194       env = self.pre_env
 195     elif phase == constants.HOOKS_PHASE_POST:
 196       if node_names is None:
 197         node_names = self.post_nodes
 198       env = self._BuildEnv(phase)
 199     else:
 200       raise AssertionError("Unknown phase '%s'" % phase)
 201
 202     if not node_names:
 203       # empty node list, we should not attempt to run this as either
 204       # we're in the cluster init phase and the rpc client part can't
 205       # even attempt to run, or this LU doesn't do hooks at all
 206       return
 207
 208     results = self._RunWrapper(node_names, self.hooks_path, phase, env)
 209     if not results:
 210       msg = "Communication Failure"
 211       if phase == constants.HOOKS_PHASE_PRE:
 212         raise errors.HooksFailure(msg)
 213       else:
 214         self.log_fn(msg)
 215         return results
 216
 217     converted_res = results
 218     if self.hooks_results_adapt_fn:
 219       converted_res = self.hooks_results_adapt_fn(results)
 220
 221     errs = []
 222     for node_name, (fail_msg, offline, hooks_results) in converted_res.items():
 223       if offline:
 224         continue
 225
 226       if fail_msg:
 227         self.log_fn("Communication failure to node %s: %s", node_name, fail_msg)
 228         continue
 229
 230       for script, hkr, output in hooks_results:
 231         if hkr == constants.HKR_FAIL:
 232           if phase == constants.HOOKS_PHASE_PRE:
 233             errs.append((node_name, script, output))
 234           else:
 235             if not output:
 236               output = "(no output)"
 237             self.log_fn("On %s script %s failed, output: %s" %
 238                         (node_name, script, output))
 239
 240     if errs and phase == constants.HOOKS_PHASE_PRE:
 241       raise errors.HooksAbort(errs)
 242
 243     return results
 244
 245   def RunConfigUpdate(self):
 246     """Run the special configuration update hook
 247
 248     This is a special hook that runs only on the master after each
 249     top-level LI if the configuration has been updated.
 250
 251     """
 252     phase = constants.HOOKS_PHASE_POST
 253     hpath = constants.HOOKS_NAME_CFGUPDATE
 254     nodes = [self.master_name]
 255     self._RunWrapper(nodes, hpath, phase, self.pre_env)
 256
 257   @staticmethod
 258   def BuildFromLu(hooks_execution_fn, lu):
 259     if lu.HPATH is None:
 260       nodes = (None, None)
 261     else:
 262       hooks_nodes = lu.BuildHooksNodes()
 263       to_name = lambda node_uuids: frozenset(lu.cfg.GetNodeNames(node_uuids))
 264       if len(hooks_nodes) == 2:
 265         nodes = (to_name(hooks_nodes[0]), to_name(hooks_nodes[1]))
 266       elif len(hooks_nodes) == 3:
 267         nodes = (to_name(hooks_nodes[0]),
 268                  to_name(hooks_nodes[1]) | frozenset(hooks_nodes[2]))
 269       else:
 270         raise errors.ProgrammerError(
 271           "LogicalUnit.BuildHooksNodes must return a 2- or 3-tuple")
 272
 273     master_name = cluster_name = None
 274     if lu.cfg:
 275       master_name = lu.cfg.GetMasterNodeName()
 276       cluster_name = lu.cfg.GetClusterName()
 277
 278     return HooksMaster(lu.op.OP_ID, lu.HPATH, nodes, hooks_execution_fn,
 279                        _RpcResultsToHooksResults, lu.BuildHooksEnv,
 280                        lu.LogWarning, lu.HTYPE, cluster_name, master_name)