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

   1 #
   2 #
   3
   4 # Copyright (C) 2009, 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 """Ganeti configuration daemon queries library.
  23
  24 """
  25
  26 import logging
  27
  28 from ganeti import constants
  29
  30
  31 # constants for some common errors to return from a query
  32 QUERY_UNKNOWN_ENTRY_ERROR = (constants.CONFD_REPL_STATUS_ERROR,
  33                              constants.CONFD_ERROR_UNKNOWN_ENTRY)
  34 QUERY_INTERNAL_ERROR = (constants.CONFD_REPL_STATUS_ERROR,
  35                         constants.CONFD_ERROR_INTERNAL)
  36 QUERY_ARGUMENT_ERROR = (constants.CONFD_REPL_STATUS_ERROR,
  37                         constants.CONFD_ERROR_ARGUMENT)
  38
  39
  40 class ConfdQuery(object):
  41   """Confd Query base class.
  42
  43   """
  44   def __init__(self, reader):
  45     """Constructor for Confd Query
  46
  47     @type reader: L{ssconf.SimpleConfigReader}
  48     @param reader: ConfigReader to use to access the config
  49
  50     """
  51     self.reader = reader
  52
  53   def Exec(self, query): # pylint: disable-msg=R0201,W0613
  54     """Process a single UDP request from a client.
  55
  56     Different queries should override this function, which by defaults returns
  57     a "non-implemented" answer.
  58
  59     @type query: (undefined)
  60     @param query: ConfdRequest 'query' field
  61     @rtype: (integer, undefined)
  62     @return: status and answer to give to the client
  63
  64     """
  65     status = constants.CONFD_REPL_STATUS_NOTIMPLEMENTED
  66     answer = 'not implemented'
  67     return status, answer
  68
  69
  70 class PingQuery(ConfdQuery):
  71   """An empty confd query.
  72
  73   It will return success on an empty argument, and an error on any other
  74   argument.
  75
  76   """
  77   def Exec(self, query):
  78     """PingQuery main execution.
  79
  80     """
  81     if query is None:
  82       status = constants.CONFD_REPL_STATUS_OK
  83       answer = 'ok'
  84     else:
  85       status = constants.CONFD_REPL_STATUS_ERROR
  86       answer = 'non-empty ping query'
  87
  88     return status, answer
  89
  90
  91 class ClusterMasterQuery(ConfdQuery):
  92   """Cluster master query.
  93
  94   It accepts no arguments, and returns the current cluster master.
  95
  96   """
  97   def _GetMasterNode(self):
  98     return self.reader.GetMasterNode()
  99
 100   def Exec(self, query):
 101     """ClusterMasterQuery main execution
 102
 103     """
 104     if isinstance(query, dict):
 105       if constants.CONFD_REQQ_FIELDS in query:
 106         status = constants.CONFD_REPL_STATUS_OK
 107         req_fields = query[constants.CONFD_REQQ_FIELDS]
 108         if not isinstance(req_fields, (list, tuple)):
 109           logging.debug("FIELDS request should be a list")
 110           return QUERY_ARGUMENT_ERROR
 111
 112         answer = []
 113         for field in req_fields:
 114           if field == constants.CONFD_REQFIELD_NAME:
 115             answer.append(self._GetMasterNode())
 116           elif field == constants.CONFD_REQFIELD_IP:
 117             answer.append(self.reader.GetMasterIP())
 118           elif field == constants.CONFD_REQFIELD_MNODE_PIP:
 119             answer.append(self.reader.GetNodePrimaryIp(self._GetMasterNode()))
 120       else:
 121         logging.debug("missing FIELDS in query dict")
 122         return QUERY_ARGUMENT_ERROR
 123     elif not query:
 124       status = constants.CONFD_REPL_STATUS_OK
 125       answer = self.reader.GetMasterNode()
 126     else:
 127       logging.debug("Invalid master query argument: not dict or empty")
 128       return QUERY_ARGUMENT_ERROR
 129
 130     return status, answer
 131
 132
 133 class NodeRoleQuery(ConfdQuery):
 134   """A query for the role of a node.
 135
 136   It will return one of CONFD_NODE_ROLE_*, or an error for non-existing nodes.
 137
 138   """
 139   def Exec(self, query):
 140     """EmptyQuery main execution
 141
 142     """
 143     node = query
 144     if self.reader.GetMasterNode() == node:
 145       status = constants.CONFD_REPL_STATUS_OK
 146       answer = constants.CONFD_NODE_ROLE_MASTER
 147       return status, answer
 148     flags = self.reader.GetNodeStatusFlags(node)
 149     if flags is None:
 150       return QUERY_UNKNOWN_ENTRY_ERROR
 151
 152     master_candidate, drained, offline = flags
 153     if master_candidate:
 154       answer = constants.CONFD_NODE_ROLE_CANDIDATE
 155     elif drained:
 156       answer = constants.CONFD_NODE_ROLE_DRAINED
 157     elif offline:
 158       answer = constants.CONFD_NODE_ROLE_OFFLINE
 159     else:
 160       answer = constants.CONFD_NODE_ROLE_REGULAR
 161
 162     return constants.CONFD_REPL_STATUS_OK, answer
 163
 164
 165 class InstanceIpToNodePrimaryIpQuery(ConfdQuery):
 166   """A query for the location of one or more instance's ips.
 167
 168   """
 169   def Exec(self, query):
 170     """InstanceIpToNodePrimaryIpQuery main execution.
 171
 172     @type query: string or dict
 173     @param query: instance ip or dict containing:
 174                   constants.CONFD_REQQ_LINK: nic link (optional)
 175                   constants.CONFD_REQQ_IPLIST: list of ips
 176                   constants.CONFD_REQQ_IP: single ip
 177                   (one IP type request is mandatory)
 178     @rtype: (integer, ...)
 179     @return: ((status, answer) or (success, [(status, answer)...])
 180
 181     """
 182     if isinstance(query, dict):
 183       if constants.CONFD_REQQ_IP in query:
 184         instances_list = [query[constants.CONFD_REQQ_IP]]
 185         mode = constants.CONFD_REQQ_IP
 186       elif constants.CONFD_REQQ_IPLIST in query:
 187         instances_list = query[constants.CONFD_REQQ_IPLIST]
 188         mode = constants.CONFD_REQQ_IPLIST
 189       else:
 190         logging.debug("missing IP or IPLIST in query dict")
 191         return QUERY_ARGUMENT_ERROR
 192
 193       if constants.CONFD_REQQ_LINK in query:
 194         network_link = query[constants.CONFD_REQQ_LINK]
 195       else:
 196         network_link = None # default will be used
 197     elif isinstance(query, basestring):
 198       # 2.1 beta1 and beta2 mode, to be deprecated for 2.2
 199       instances_list = [query]
 200       network_link = None
 201       mode = constants.CONFD_REQQ_IP
 202     else:
 203       logging.debug("Invalid query argument type for: %s", query)
 204       return QUERY_ARGUMENT_ERROR
 205
 206     pnodes_list = []
 207
 208     for instance_ip in instances_list:
 209       if not isinstance(instance_ip, basestring):
 210         logging.debug("Invalid IP type for: %s", instance_ip)
 211         return QUERY_ARGUMENT_ERROR
 212
 213       instance = self.reader.GetInstanceByLinkIp(instance_ip, network_link)
 214       if not instance:
 215         logging.debug("Unknown instance IP: %s", instance_ip)
 216         pnodes_list.append(QUERY_UNKNOWN_ENTRY_ERROR)
 217         continue
 218
 219       pnode = self.reader.GetInstancePrimaryNode(instance)
 220       if not pnode:
 221         logging.error("Instance '%s' doesn't have an associated primary"
 222                       " node", instance)
 223         pnodes_list.append(QUERY_INTERNAL_ERROR)
 224         continue
 225
 226       pnode_primary_ip = self.reader.GetNodePrimaryIp(pnode)
 227       if not pnode_primary_ip:
 228         logging.error("Primary node '%s' doesn't have an associated"
 229                       " primary IP", pnode)
 230         pnodes_list.append(QUERY_INTERNAL_ERROR)
 231         continue
 232
 233       pnodes_list.append((constants.CONFD_REPL_STATUS_OK, pnode_primary_ip))
 234
 235     # If a single ip was requested, return a single answer, otherwise
 236     # the whole list, with a success status (since each entry has its
 237     # own success/failure)
 238     if mode == constants.CONFD_REQQ_IP:
 239       return pnodes_list[0]
 240
 241     return constants.CONFD_REPL_STATUS_OK, pnodes_list
 242
 243
 244 class NodesPipsQuery(ConfdQuery):
 245   """A query for nodes primary IPs.
 246
 247   It returns the list of nodes primary IPs.
 248
 249   """
 250   def Exec(self, query):
 251     """NodesPipsQuery main execution.
 252
 253     """
 254     if query is None:
 255       status = constants.CONFD_REPL_STATUS_OK
 256       answer = self.reader.GetNodesPrimaryIps()
 257     else:
 258       status = constants.CONFD_REPL_STATUS_ERROR
 259       answer = "non-empty node primary IPs query"
 260
 261     return status, answer
 262
 263
 264 class MasterCandidatesPipsQuery(ConfdQuery):
 265   """A query for master candidates primary IPs.
 266
 267   It returns the list of master candidates primary IPs.
 268
 269   """
 270   def Exec(self, query):
 271     """MasterCandidatesPipsQuery main execution.
 272
 273     """
 274     if query is None:
 275       status = constants.CONFD_REPL_STATUS_OK
 276       answer = self.reader.GetMasterCandidatesPrimaryIps()
 277     else:
 278       status = constants.CONFD_REPL_STATUS_ERROR
 279       answer = "non-empty master candidates primary IPs query"
 280
 281     return status, answer
 282
 283
 284 class InstancesIpsQuery(ConfdQuery):
 285   """A query for instances IPs.
 286
 287   It returns the list of IPs of NICs connected to the requested link or all the
 288   instances IPs if no link is submitted.
 289
 290   """
 291   def Exec(self, query):
 292     """InstancesIpsQuery main execution.
 293
 294     """
 295     link = query
 296     status = constants.CONFD_REPL_STATUS_OK
 297     answer = self.reader.GetInstancesIps(link)
 298
 299     return status, answer