Source Code for Module ganeti.hooksmaster

  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, nodes=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 form 
180      {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 nodes: overrides the predefined list of nodes for the given phase 
185      @return: the processed results of the hooks multi-node rpc call 
186      @raise errors.HooksFailure: on communication failure to the nodes 
187      @raise errors.HooksAbort: on failure of one of the hooks 
188   
189      """ 
190      if phase == constants.HOOKS_PHASE_PRE: 
191        if nodes is None: 
192          nodes = self.pre_nodes 
193        env = self.pre_env 
194      elif phase == constants.HOOKS_PHASE_POST: 
195        if nodes is None: 
196          nodes = self.post_nodes 
197        env = self._BuildEnv(phase) 
198      else: 
199        raise AssertionError("Unknown phase '%s'" % phase) 
200   
201      if not nodes: 
202        # empty node list, we should not attempt to run this as either 
203        # we're in the cluster init phase and the rpc client part can't 
204        # even attempt to run, or this LU doesn't do hooks at all 
205        return 
206   
207      results = self._RunWrapper(nodes, self.hooks_path, phase, env) 
208      if not results: 
209        msg = "Communication Failure" 
210        if phase == constants.HOOKS_PHASE_PRE: 
211          raise errors.HooksFailure(msg) 
212        else: 
213          self.log_fn(msg) 
214          return results 
215   
216      converted_res = results 
217      if self.hooks_results_adapt_fn: 
218        converted_res = self.hooks_results_adapt_fn(results) 
219   
220      errs = [] 
221      for node_name, (fail_msg, offline, hooks_results) in converted_res.items(): 
222        if offline: 
223          continue 
224   
225        if fail_msg: 
226          self.log_fn("Communication failure to node %s: %s", node_name, fail_msg) 
227          continue 
228   
229        for script, hkr, output in hooks_results: 
230          if hkr == constants.HKR_FAIL: 
231            if phase == constants.HOOKS_PHASE_PRE: 
232              errs.append((node_name, script, output)) 
233            else: 
234              if not output: 
235                output = "(no output)" 
236              self.log_fn("On %s script %s failed, output: %s" % 
237                          (node_name, script, output)) 
238   
239      if errs and phase == constants.HOOKS_PHASE_PRE: 
240        raise errors.HooksAbort(errs) 
241   
242      return results 
243   
244 -  def RunConfigUpdate(self): 
245      """Run the special configuration update hook 
246   
247      This is a special hook that runs only on the master after each 
248      top-level LI if the configuration has been updated. 
249   
250      """ 
251      phase = constants.HOOKS_PHASE_POST 
252      hpath = constants.HOOKS_NAME_CFGUPDATE 
253      nodes = [self.master_name] 
254      self._RunWrapper(nodes, hpath, phase, self.pre_env) 
255   
256    @staticmethod 
257 -  def BuildFromLu(hooks_execution_fn, lu): 
258      if lu.HPATH is None: 
259        nodes = (None, None) 
260      else: 
261        nodes = map(frozenset, lu.BuildHooksNodes()) 
262   
263      master_name = cluster_name = None 
264      if lu.cfg: 
265        master_name = lu.cfg.GetMasterNode() 
266        cluster_name = lu.cfg.GetClusterName() 
267   
268      return HooksMaster(lu.op.OP_ID, lu.HPATH, nodes, hooks_execution_fn, 
269                         _RpcResultsToHooksResults, lu.BuildHooksEnv, 
270                         lu.LogWarning, lu.HTYPE, cluster_name, master_name) 
271