Synnefo » snf-ganeti

#

#

# Copyright (C) 2009 Google Inc.

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful, but

# WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

# General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

# 02110-1301, USA.

"""Ganeti configuration daemon queries library.

"""

import logging

from ganeti import constants

# constants for some common errors to return from a query

QUERY_UNKNOWN_ENTRY_ERROR = (constants.CONFD_REPL_STATUS_ERROR,

                             constants.CONFD_ERROR_UNKNOWN_ENTRY)

QUERY_INTERNAL_ERROR = (constants.CONFD_REPL_STATUS_ERROR,

                        constants.CONFD_ERROR_INTERNAL)

QUERY_ARGUMENT_ERROR = (constants.CONFD_REPL_STATUS_ERROR,

                        constants.CONFD_ERROR_ARGUMENT)

class ConfdQuery(object):

  """Confd Query base class.

  """

  def __init__(self, reader):

    """Constructor for Confd Query

    @type reader: L{ssconf.SimpleConfigReader}

    @param reader: ConfigReader to use to access the config

    """

    self.reader = reader

  def Exec(self, query): # pylint: disable=R0201,W0613

    """Process a single UDP request from a client.

    Different queries should override this function, which by defaults returns

    a "non-implemented" answer.

    @type query: (undefined)

    @param query: ConfdRequest 'query' field

    @rtype: (integer, undefined)

    @return: status and answer to give to the client

    """

    status = constants.CONFD_REPL_STATUS_NOTIMPLEMENTED

    answer = "not implemented"

    return status, answer

class PingQuery(ConfdQuery):

  """An empty confd query.

  It will return success on an empty argument, and an error on any other

  argument.

  """

  def Exec(self, query):

    """PingQuery main execution.

    """

    if query is None:

      status = constants.CONFD_REPL_STATUS_OK

      answer = "ok"

    else:

      status = constants.CONFD_REPL_STATUS_ERROR

      answer = "non-empty ping query"

    return status, answer

class ClusterMasterQuery(ConfdQuery):

  """Cluster master query.

  It accepts no arguments, and returns the current cluster master.

  """

  def _GetMasterNode(self):

    return self.reader.GetMasterNode()

  def Exec(self, query):

    """ClusterMasterQuery main execution

    """

    if isinstance(query, dict):

      if constants.CONFD_REQQ_FIELDS in query:

        status = constants.CONFD_REPL_STATUS_OK

        req_fields = query[constants.CONFD_REQQ_FIELDS]

        if not isinstance(req_fields, (list, tuple)):

          logging.debug("FIELDS request should be a list")

          return QUERY_ARGUMENT_ERROR

        answer = []

        for field in req_fields:

          if field == constants.CONFD_REQFIELD_NAME:

            answer.append(self._GetMasterNode())

          elif field == constants.CONFD_REQFIELD_IP:

            answer.append(self.reader.GetMasterIP())

          elif field == constants.CONFD_REQFIELD_MNODE_PIP:

            answer.append(self.reader.GetNodePrimaryIp(self._GetMasterNode()))

      else:

        logging.debug("missing FIELDS in query dict")

        return QUERY_ARGUMENT_ERROR

    elif not query:

      status = constants.CONFD_REPL_STATUS_OK

      answer = self.reader.GetMasterNode()

    else:

      logging.debug("Invalid master query argument: not dict or empty")

      return QUERY_ARGUMENT_ERROR

    return status, answer

class NodeRoleQuery(ConfdQuery):

  """A query for the role of a node.

  It will return one of CONFD_NODE_ROLE_*, or an error for non-existing nodes.

  """

  def Exec(self, query):

    """EmptyQuery main execution

    """

    node = query

    if self.reader.GetMasterNode() == node:

      status = constants.CONFD_REPL_STATUS_OK

      answer = constants.CONFD_NODE_ROLE_MASTER

      return status, answer

    flags = self.reader.GetNodeStatusFlags(node)

    if flags is None:

      return QUERY_UNKNOWN_ENTRY_ERROR

    master_candidate, drained, offline = flags

    if master_candidate:

      answer = constants.CONFD_NODE_ROLE_CANDIDATE

    elif drained:

      answer = constants.CONFD_NODE_ROLE_DRAINED

    elif offline:

      answer = constants.CONFD_NODE_ROLE_OFFLINE

    else:

      answer = constants.CONFD_NODE_ROLE_REGULAR

    return constants.CONFD_REPL_STATUS_OK, answer

class InstanceIpToNodePrimaryIpQuery(ConfdQuery):

  """A query for the location of one or more instance's ips.

  """

  def Exec(self, query):

    """InstanceIpToNodePrimaryIpQuery main execution.

    @type query: string or dict

    @param query: instance ip or dict containing:

                  constants.CONFD_REQQ_LINK: nic link (optional)

                  constants.CONFD_REQQ_IPLIST: list of ips

                  constants.CONFD_REQQ_IP: single ip

                  (one IP type request is mandatory)

    @rtype: (integer, ...)

    @return: ((status, answer) or (success, [(status, answer)...])

    """

    if isinstance(query, dict):

      if constants.CONFD_REQQ_IP in query:

        instances_list = [query[constants.CONFD_REQQ_IP]]

        mode = constants.CONFD_REQQ_IP

      elif constants.CONFD_REQQ_IPLIST in query:

        instances_list = query[constants.CONFD_REQQ_IPLIST]

        mode = constants.CONFD_REQQ_IPLIST

      else:

        logging.debug("missing IP or IPLIST in query dict")

        return QUERY_ARGUMENT_ERROR

      if constants.CONFD_REQQ_LINK in query:

        network_link = query[constants.CONFD_REQQ_LINK]

      else:

        network_link = None # default will be used

    else:

      logging.debug("Invalid query argument type for: %s", query)

      return QUERY_ARGUMENT_ERROR

    pnodes_list = []

    for instance_ip in instances_list:

      if not isinstance(instance_ip, basestring):

        logging.debug("Invalid IP type for: %s", instance_ip)

        return QUERY_ARGUMENT_ERROR

      instance = self.reader.GetInstanceByLinkIp(instance_ip, network_link)

      if not instance:

        logging.debug("Unknown instance IP: %s", instance_ip)

        pnodes_list.append(QUERY_UNKNOWN_ENTRY_ERROR)

        continue

      pnode = self.reader.GetInstancePrimaryNode(instance)

      if not pnode:

        logging.error("Instance '%s' doesn't have an associated primary"

                      " node", instance)

        pnodes_list.append(QUERY_INTERNAL_ERROR)

        continue

      pnode_primary_ip = self.reader.GetNodePrimaryIp(pnode)

      if not pnode_primary_ip:

        logging.error("Primary node '%s' doesn't have an associated"

                      " primary IP", pnode)

        pnodes_list.append(QUERY_INTERNAL_ERROR)

        continue

      pnodes_list.append((constants.CONFD_REPL_STATUS_OK, pnode_primary_ip))

    # If a single ip was requested, return a single answer, otherwise

    # the whole list, with a success status (since each entry has its

    # own success/failure)

    if mode == constants.CONFD_REQQ_IP:

      return pnodes_list[0]

    return constants.CONFD_REPL_STATUS_OK, pnodes_list

class NodesPipsQuery(ConfdQuery):

  """A query for nodes primary IPs.

  It returns the list of nodes primary IPs.

  """

  def Exec(self, query):

    """NodesPipsQuery main execution.

    """

    if query is None:

      status = constants.CONFD_REPL_STATUS_OK

      answer = self.reader.GetNodesPrimaryIps()

    else:

      status = constants.CONFD_REPL_STATUS_ERROR

      answer = "non-empty node primary IPs query"

    return status, answer

class MasterCandidatesPipsQuery(ConfdQuery):

  """A query for master candidates primary IPs.

  It returns the list of master candidates primary IPs.

  """

  def Exec(self, query):

    """MasterCandidatesPipsQuery main execution.

    """

    if query is None:

      status = constants.CONFD_REPL_STATUS_OK

      answer = self.reader.GetMasterCandidatesPrimaryIps()

    else:

      status = constants.CONFD_REPL_STATUS_ERROR

      answer = "non-empty master candidates primary IPs query"

    return status, answer

class InstancesIpsQuery(ConfdQuery):

  """A query for instances IPs.

  It returns the list of IPs of NICs connected to the requested link or all the

  instances IPs if no link is submitted.

  """

  def Exec(self, query):

    """InstancesIpsQuery main execution.

    """

    link = query

    status = constants.CONFD_REPL_STATUS_OK

    answer = self.reader.GetInstancesIps(link)

    return status, answer