Synnefo » snf-ganeti

#

#

# Copyright (C) 2006, 2007 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.

"""Module implementing the master-side code."""

# pylint: disable-msg=W0613,W0201

import os

import os.path

import sha

import time

import tempfile

import re

import platform

from ganeti import rpc

from ganeti import ssh

from ganeti import logger

from ganeti import utils

from ganeti import errors

from ganeti import hypervisor

from ganeti import config

from ganeti import constants

from ganeti import objects

from ganeti import opcodes

from ganeti import ssconf

class LogicalUnit(object):

  """Logical Unit base class.

  Subclasses must follow these rules:

    - implement CheckPrereq which also fills in the opcode instance

      with all the fields (even if as None)

    - implement Exec

    - implement BuildHooksEnv

    - redefine HPATH and HTYPE

    - optionally redefine their run requirements (REQ_CLUSTER,

      REQ_MASTER); note that all commands require root permissions

  """

  HPATH = None

  HTYPE = None

  _OP_REQP = []

  REQ_CLUSTER = True

  REQ_MASTER = True

  def __init__(self, processor, op, cfg, sstore):

    """Constructor for LogicalUnit.

    This needs to be overriden in derived classes in order to check op

    validity.

    """

    self.proc = processor

    self.op = op

    self.cfg = cfg

    self.sstore = sstore

    self.__ssh = None

    for attr_name in self._OP_REQP:

      attr_val = getattr(op, attr_name, None)

      if attr_val is None:

        raise errors.OpPrereqError("Required parameter '%s' missing" %

                                   attr_name)

    if self.REQ_CLUSTER:

      if not cfg.IsCluster():

        raise errors.OpPrereqError("Cluster not initialized yet,"

                                   " use 'gnt-cluster init' first.")

      if self.REQ_MASTER:

        master = sstore.GetMasterNode()

        if master != utils.HostInfo().name:

          raise errors.OpPrereqError("Commands must be run on the master"

                                     " node %s" % master)

  def __GetSSH(self):

    """Returns the SshRunner object

    """

    if not self.__ssh:

      self.__ssh = ssh.SshRunner(self.sstore)

    return self.__ssh

  ssh = property(fget=__GetSSH)

  def CheckPrereq(self):

    """Check prerequisites for this LU.

    This method should check that the prerequisites for the execution

    of this LU are fulfilled. It can do internode communication, but

    it should be idempotent - no cluster or system changes are

    allowed.

    The method should raise errors.OpPrereqError in case something is

    not fulfilled. Its return value is ignored.

    This method should also update all the parameters of the opcode to

    their canonical form; e.g. a short node name must be fully

    expanded after this method has successfully completed (so that

    hooks, logging, etc. work correctly).

    """

    raise NotImplementedError

  def Exec(self, feedback_fn):

    """Execute the LU.

    This method should implement the actual work. It should raise

    errors.OpExecError for failures that are somewhat dealt with in

    code, or expected.

    """

    raise NotImplementedError

  def BuildHooksEnv(self):

    """Build hooks environment for this LU.

    This method should return a three-node tuple consisting of: a dict

    containing the environment that will be used for running the

    specific hook for this LU, a list of node names on which the hook

    should run before the execution, and a list of node names on which

    the hook should run after the execution.

    The keys of the dict must not have 'GANETI_' prefixed as this will

    be handled in the hooks runner. Also note additional keys will be

    added by the hooks runner. If the LU doesn't define any

    environment, an empty dict (and not None) should be returned.

    As for the node lists, the master should not be included in the

    them, as it will be added by the hooks runner in case this LU

    requires a cluster to run on (otherwise we don't have a node

    list). No nodes should be returned as an empty list (and not

    None).

    Note that if the HPATH for a LU class is None, this function will

    not be called.

    """

    raise NotImplementedError

class NoHooksLU(LogicalUnit):

  """Simple LU which runs no hooks.

  This LU is intended as a parent for other LogicalUnits which will

  run no hooks, in order to reduce duplicate code.

  """

  HPATH = None

  HTYPE = None

  def BuildHooksEnv(self):

    """Build hooks env.

    This is a no-op, since we don't run hooks.

    """

    return {}, [], []

def _AddHostToEtcHosts(hostname):

  """Wrapper around utils.SetEtcHostsEntry.

  """

  hi = utils.HostInfo(name=hostname)

  utils.SetEtcHostsEntry(constants.ETC_HOSTS, hi.ip, hi.name, [hi.ShortName()])

def _RemoveHostFromEtcHosts(hostname):

  """Wrapper around utils.RemoveEtcHostsEntry.

  """

  hi = utils.HostInfo(name=hostname)

  utils.RemoveEtcHostsEntry(constants.ETC_HOSTS, hi.name)

  utils.RemoveEtcHostsEntry(constants.ETC_HOSTS, hi.ShortName())

def _GetWantedNodes(lu, nodes):

  """Returns list of checked and expanded node names.

  Args:

    nodes: List of nodes (strings) or None for all

  """

  if not isinstance(nodes, list):

    raise errors.OpPrereqError("Invalid argument type 'nodes'")

  if nodes:

    wanted = []

    for name in nodes:

      node = lu.cfg.ExpandNodeName(name)

      if node is None:

        raise errors.OpPrereqError("No such node name '%s'" % name)

      wanted.append(node)

  else:

    wanted = lu.cfg.GetNodeList()

  return utils.NiceSort(wanted)

def _GetWantedInstances(lu, instances):

  """Returns list of checked and expanded instance names.

  Args:

    instances: List of instances (strings) or None for all

  """

  if not isinstance(instances, list):

    raise errors.OpPrereqError("Invalid argument type 'instances'")

  if instances:

    wanted = []

    for name in instances:

      instance = lu.cfg.ExpandInstanceName(name)

      if instance is None:

        raise errors.OpPrereqError("No such instance name '%s'" % name)

      wanted.append(instance)

  else:

    wanted = lu.cfg.GetInstanceList()

  return utils.NiceSort(wanted)

def _CheckOutputFields(static, dynamic, selected):

  """Checks whether all selected fields are valid.

  Args:

    static: Static fields

    dynamic: Dynamic fields

  """

  static_fields = frozenset(static)

  dynamic_fields = frozenset(dynamic)

  all_fields = static_fields | dynamic_fields

  if not all_fields.issuperset(selected):

    raise errors.OpPrereqError("Unknown output fields selected: %s"

                               % ",".join(frozenset(selected).

                                          difference(all_fields)))

def _BuildInstanceHookEnv(name, primary_node, secondary_nodes, os_type, status,

                          memory, vcpus, nics):

  """Builds instance related env variables for hooks from single variables.

  Args:

    secondary_nodes: List of secondary nodes as strings

  """

  env = {

    "OP_TARGET": name,

    "INSTANCE_NAME": name,

    "INSTANCE_PRIMARY": primary_node,

    "INSTANCE_SECONDARIES": " ".join(secondary_nodes),

    "INSTANCE_OS_TYPE": os_type,

    "INSTANCE_STATUS": status,

    "INSTANCE_MEMORY": memory,

    "INSTANCE_VCPUS": vcpus,

  }

  if nics:

    nic_count = len(nics)

    for idx, (ip, bridge, mac) in enumerate(nics):

      if ip is None:

        ip = ""

      env["INSTANCE_NIC%d_IP" % idx] = ip

      env["INSTANCE_NIC%d_BRIDGE" % idx] = bridge

      env["INSTANCE_NIC%d_HWADDR" % idx] = mac

  else:

    nic_count = 0

  env["INSTANCE_NIC_COUNT"] = nic_count

  return env

def _BuildInstanceHookEnvByObject(instance, override=None):

  """Builds instance related env variables for hooks from an object.

  Args:

    instance: objects.Instance object of instance

    override: dict of values to override

  """

  args = {

    'name': instance.name,

    'primary_node': instance.primary_node,

    'secondary_nodes': instance.secondary_nodes,

    'os_type': instance.os,

    'status': instance.os,

    'memory': instance.memory,

    'vcpus': instance.vcpus,

    'nics': [(nic.ip, nic.bridge, nic.mac) for nic in instance.nics],

  }

  if override:

    args.update(override)

  return _BuildInstanceHookEnv(**args)

def _HasValidVG(vglist, vgname):

  """Checks if the volume group list is valid.

  A non-None return value means there's an error, and the return value

  is the error message.

  """

  vgsize = vglist.get(vgname, None)

  if vgsize is None:

    return "volume group '%s' missing" % vgname

  elif vgsize < 20480:

    return ("volume group '%s' too small (20480MiB required, %dMib found)" %

            (vgname, vgsize))

  return None

def _InitSSHSetup(node):

  """Setup the SSH configuration for the cluster.

  This generates a dsa keypair for root, adds the pub key to the

  permitted hosts and adds the hostkey to its own known hosts.

  Args:

    node: the name of this host as a fqdn

  """

  priv_key, pub_key, auth_keys = ssh.GetUserFiles(constants.GANETI_RUNAS)

  for name in priv_key, pub_key:

    if os.path.exists(name):

      utils.CreateBackup(name)

    utils.RemoveFile(name)

  result = utils.RunCmd(["ssh-keygen", "-t", "dsa",

                         "-f", priv_key,

                         "-q", "-N", ""])

  if result.failed:

    raise errors.OpExecError("Could not generate ssh keypair, error %s" %

                             result.output)

  f = open(pub_key, 'r')

  try:

    utils.AddAuthorizedKey(auth_keys, f.read(8192))

  finally:

    f.close()

def _InitGanetiServerSetup(ss):

  """Setup the necessary configuration for the initial node daemon.

  This creates the nodepass file containing the shared password for

  the cluster and also generates the SSL certificate.

  """

  # Create pseudo random password

  randpass = sha.new(os.urandom(64)).hexdigest()

  # and write it into sstore

  ss.SetKey(ss.SS_NODED_PASS, randpass)

  result = utils.RunCmd(["openssl", "req", "-new", "-newkey", "rsa:1024",

                         "-days", str(365*5), "-nodes", "-x509",

                         "-keyout", constants.SSL_CERT_FILE,

                         "-out", constants.SSL_CERT_FILE, "-batch"])

  if result.failed:

    raise errors.OpExecError("could not generate server ssl cert, command"

                             " %s had exitcode %s and error message %s" %

                             (result.cmd, result.exit_code, result.output))

  os.chmod(constants.SSL_CERT_FILE, 0400)

  result = utils.RunCmd([constants.NODE_INITD_SCRIPT, "restart"])

  if result.failed:

    raise errors.OpExecError("Could not start the node daemon, command %s"

                             " had exitcode %s and error %s" %

                             (result.cmd, result.exit_code, result.output))

def _CheckInstanceBridgesExist(instance):

  """Check that the brigdes needed by an instance exist.

  """

  # check bridges existance

  brlist = [nic.bridge for nic in instance.nics]

  if not rpc.call_bridges_exist(instance.primary_node, brlist):

    raise errors.OpPrereqError("one or more target bridges %s does not"

                               " exist on destination node '%s'" %

                               (brlist, instance.primary_node))

class LUInitCluster(LogicalUnit):

  """Initialise the cluster.

  """

  HPATH = "cluster-init"

  HTYPE = constants.HTYPE_CLUSTER

  _OP_REQP = ["cluster_name", "hypervisor_type", "vg_name", "mac_prefix",

              "def_bridge", "master_netdev"]

  REQ_CLUSTER = False

  def BuildHooksEnv(self):

    """Build hooks env.

    Notes: Since we don't require a cluster, we must manually add

    ourselves in the post-run node list.

    """

    env = {"OP_TARGET": self.op.cluster_name}

    return env, [], [self.hostname.name]

  def CheckPrereq(self):

    """Verify that the passed name is a valid one.

    """

    if config.ConfigWriter.IsCluster():

      raise errors.OpPrereqError("Cluster is already initialised")

    if self.op.hypervisor_type == constants.HT_XEN_HVM31:

      if not os.path.exists(constants.VNC_PASSWORD_FILE):

        raise errors.OpPrereqError("Please prepare the cluster VNC"

                                   "password file %s" %

                                   constants.VNC_PASSWORD_FILE)

    self.hostname = hostname = utils.HostInfo()

    if hostname.ip.startswith("127."):

      raise errors.OpPrereqError("This host's IP resolves to the private"

                                 " range (%s). Please fix DNS or %s." %

                                 (hostname.ip, constants.ETC_HOSTS))

    if not utils.TcpPing(hostname.ip, constants.DEFAULT_NODED_PORT,

                         source=constants.LOCALHOST_IP_ADDRESS):

      raise errors.OpPrereqError("Inconsistency: this host's name resolves"

                                 " to %s,\nbut this ip address does not"

                                 " belong to this host."

                                 " Aborting." % hostname.ip)

    self.clustername = clustername = utils.HostInfo(self.op.cluster_name)

    if utils.TcpPing(clustername.ip, constants.DEFAULT_NODED_PORT,

                     timeout=5):

      raise errors.OpPrereqError("Cluster IP already active. Aborting.")

    secondary_ip = getattr(self.op, "secondary_ip", None)

    if secondary_ip and not utils.IsValidIP(secondary_ip):

      raise errors.OpPrereqError("Invalid secondary ip given")

    if (secondary_ip and

        secondary_ip != hostname.ip and

        (not utils.TcpPing(secondary_ip, constants.DEFAULT_NODED_PORT,

                           source=constants.LOCALHOST_IP_ADDRESS))):

      raise errors.OpPrereqError("You gave %s as secondary IP,"

                                 " but it does not belong to this host." %

                                 secondary_ip)

    self.secondary_ip = secondary_ip

    # checks presence of the volume group given

    vgstatus = _HasValidVG(utils.ListVolumeGroups(), self.op.vg_name)

    if vgstatus:

      raise errors.OpPrereqError("Error: %s" % vgstatus)

    if not re.match("^[0-9a-z]{2}:[0-9a-z]{2}:[0-9a-z]{2}$",

                    self.op.mac_prefix):

      raise errors.OpPrereqError("Invalid mac prefix given '%s'" %

                                 self.op.mac_prefix)

    if self.op.hypervisor_type not in constants.HYPER_TYPES:

      raise errors.OpPrereqError("Invalid hypervisor type given '%s'" %

                                 self.op.hypervisor_type)

    result = utils.RunCmd(["ip", "link", "show", "dev", self.op.master_netdev])

    if result.failed:

      raise errors.OpPrereqError("Invalid master netdev given (%s): '%s'" %

                                 (self.op.master_netdev,

                                  result.output.strip()))

    if not (os.path.isfile(constants.NODE_INITD_SCRIPT) and

            os.access(constants.NODE_INITD_SCRIPT, os.X_OK)):

      raise errors.OpPrereqError("Init.d script '%s' missing or not"

                                 " executable." % constants.NODE_INITD_SCRIPT)

  def Exec(self, feedback_fn):

    """Initialize the cluster.

    """

    clustername = self.clustername

    hostname = self.hostname

    # set up the simple store

    self.sstore = ss = ssconf.SimpleStore()

    ss.SetKey(ss.SS_HYPERVISOR, self.op.hypervisor_type)

    ss.SetKey(ss.SS_MASTER_NODE, hostname.name)

    ss.SetKey(ss.SS_MASTER_IP, clustername.ip)

    ss.SetKey(ss.SS_MASTER_NETDEV, self.op.master_netdev)

    ss.SetKey(ss.SS_CLUSTER_NAME, clustername.name)

    # set up the inter-node password and certificate

    _InitGanetiServerSetup(ss)

    # start the master ip

    rpc.call_node_start_master(hostname.name)

    # set up ssh config and /etc/hosts

    f = open(constants.SSH_HOST_RSA_PUB, 'r')

    try:

      sshline = f.read()

    finally:

      f.close()

    sshkey = sshline.split(" ")[1]

    _AddHostToEtcHosts(hostname.name)

    _InitSSHSetup(hostname.name)

    # init of cluster config file

    self.cfg = cfgw = config.ConfigWriter()

    cfgw.InitConfig(hostname.name, hostname.ip, self.secondary_ip,

                    sshkey, self.op.mac_prefix,

                    self.op.vg_name, self.op.def_bridge)

    ssh.WriteKnownHostsFile(cfgw, ss, constants.SSH_KNOWN_HOSTS_FILE)

class LUDestroyCluster(NoHooksLU):

  """Logical unit for destroying the cluster.

  """

  _OP_REQP = []

  def CheckPrereq(self):

    """Check prerequisites.

    This checks whether the cluster is empty.

    Any errors are signalled by raising errors.OpPrereqError.

    """

    master = self.sstore.GetMasterNode()

    nodelist = self.cfg.GetNodeList()

    if len(nodelist) != 1 or nodelist[0] != master:

      raise errors.OpPrereqError("There are still %d node(s) in"

                                 " this cluster." % (len(nodelist) - 1))

    instancelist = self.cfg.GetInstanceList()

    if instancelist:

      raise errors.OpPrereqError("There are still %d instance(s) in"

                                 " this cluster." % len(instancelist))

  def Exec(self, feedback_fn):

    """Destroys the cluster.

    """

    master = self.sstore.GetMasterNode()

    if not rpc.call_node_stop_master(master):

      raise errors.OpExecError("Could not disable the master role")

    priv_key, pub_key, _ = ssh.GetUserFiles(constants.GANETI_RUNAS)

    utils.CreateBackup(priv_key)

    utils.CreateBackup(pub_key)

    rpc.call_node_leave_cluster(master)

class LUVerifyCluster(NoHooksLU):

  """Verifies the cluster status.

  """

  _OP_REQP = []

  def _VerifyNode(self, node, file_list, local_cksum, vglist, node_result,

                  remote_version, feedback_fn):

    """Run multiple tests against a node.

    Test list:

      - compares ganeti version

      - checks vg existance and size > 20G

      - checks config file checksum

      - checks ssh to other nodes

    Args:

      node: name of the node to check

      file_list: required list of files

      local_cksum: dictionary of local files and their checksums

    """

    # compares ganeti version

    local_version = constants.PROTOCOL_VERSION

    if not remote_version:

      feedback_fn(" - ERROR: connection to %s failed" % (node))

      return True

    if local_version != remote_version:

      feedback_fn("  - ERROR: sw version mismatch: master %s, node(%s) %s" %

                      (local_version, node, remote_version))

      return True

    # checks vg existance and size > 20G

    bad = False

    if not vglist:

      feedback_fn("  - ERROR: unable to check volume groups on node %s." %

                      (node,))

      bad = True

    else:

      vgstatus = _HasValidVG(vglist, self.cfg.GetVGName())

      if vgstatus:

        feedback_fn("  - ERROR: %s on node %s" % (vgstatus, node))

        bad = True

    # checks config file checksum

    # checks ssh to any

    if 'filelist' not in node_result:

      bad = True

      feedback_fn("  - ERROR: node hasn't returned file checksum data")

    else:

      remote_cksum = node_result['filelist']

      for file_name in file_list:

        if file_name not in remote_cksum:

          bad = True

          feedback_fn("  - ERROR: file '%s' missing" % file_name)

        elif remote_cksum[file_name] != local_cksum[file_name]:

          bad = True

          feedback_fn("  - ERROR: file '%s' has wrong checksum" % file_name)

    if 'nodelist' not in node_result:

      bad = True

      feedback_fn("  - ERROR: node hasn't returned node connectivity data")

    else:

      if node_result['nodelist']:

        bad = True

        for node in node_result['nodelist']:

          feedback_fn("  - ERROR: communication with node '%s': %s" %

                          (node, node_result['nodelist'][node]))

    hyp_result = node_result.get('hypervisor', None)

    if hyp_result is not None:

      feedback_fn("  - ERROR: hypervisor verify failure: '%s'" % hyp_result)

    return bad

  def _VerifyInstance(self, instance, node_vol_is, node_instance, feedback_fn):

    """Verify an instance.

    This function checks to see if the required block devices are

    available on the instance's node.

    """

    bad = False

    instancelist = self.cfg.GetInstanceList()

    if not instance in instancelist:

      feedback_fn("  - ERROR: instance %s not in instance list %s" %

                      (instance, instancelist))

      bad = True

    instanceconfig = self.cfg.GetInstanceInfo(instance)

    node_current = instanceconfig.primary_node

    node_vol_should = {}

    instanceconfig.MapLVsByNode(node_vol_should)

    for node in node_vol_should:

      for volume in node_vol_should[node]:

        if node not in node_vol_is or volume not in node_vol_is[node]:

          feedback_fn("  - ERROR: volume %s missing on node %s" %

                          (volume, node))

          bad = True

    if not instanceconfig.status == 'down':

      if not instance in node_instance[node_current]:

        feedback_fn("  - ERROR: instance %s not running on node %s" %

                        (instance, node_current))

        bad = True

    for node in node_instance:

      if (not node == node_current):

        if instance in node_instance[node]:

          feedback_fn("  - ERROR: instance %s should not run on node %s" %

                          (instance, node))

          bad = True

    return bad

  def _VerifyOrphanVolumes(self, node_vol_should, node_vol_is, feedback_fn):

    """Verify if there are any unknown volumes in the cluster.

    The .os, .swap and backup volumes are ignored. All other volumes are

    reported as unknown.

    """

    bad = False

    for node in node_vol_is:

      for volume in node_vol_is[node]:

        if node not in node_vol_should or volume not in node_vol_should[node]:

          feedback_fn("  - ERROR: volume %s on node %s should not exist" %

                      (volume, node))

          bad = True

    return bad

  def _VerifyOrphanInstances(self, instancelist, node_instance, feedback_fn):

    """Verify the list of running instances.

    This checks what instances are running but unknown to the cluster.

    """

    bad = False

    for node in node_instance:

      for runninginstance in node_instance[node]:

        if runninginstance not in instancelist:

          feedback_fn("  - ERROR: instance %s on node %s should not exist" %

                          (runninginstance, node))

          bad = True

    return bad

  def CheckPrereq(self):

    """Check prerequisites.

    This has no prerequisites.

    """

    pass

  def Exec(self, feedback_fn):

    """Verify integrity of cluster, performing various test on nodes.

    """