Synnefo » snf-ganeti » ganeti-local

#!/usr/bin/python

#

# 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 socket

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.processor = processor

    self.op = op

    self.cfg = cfg

    self.sstore = sstore

    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 != socket.gethostname():

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

                                     " node %s" % master)

  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 _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 = {

    "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) in enumerate(nics):

      if ip is None:

        ip = ""

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

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

  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) for nic in instance.nics],

  }

  if override:

    args.update(override)

  return _BuildInstanceHookEnv(**args)

def _UpdateEtcHosts(fullnode, ip):

  """Ensure a node has a correct entry in /etc/hosts.

  Args:

    fullnode - Fully qualified domain name of host. (str)

    ip       - IPv4 address of host (str)

  """

  node = fullnode.split(".", 1)[0]

  f = open('/etc/hosts', 'r+')

  inthere = False

  save_lines = []

  add_lines = []

  removed = False

  while True:

    rawline = f.readline()

    if not rawline:

      # End of file

      break

    line = rawline.split('\n')[0]

    # Strip off comments

    line = line.split('#')[0]

    if not line:

      # Entire line was comment, skip

      save_lines.append(rawline)

      continue

    fields = line.split()

    haveall = True

    havesome = False

    for spec in [ ip, fullnode, node ]:

      if spec not in fields:

        haveall = False

      if spec in fields:

        havesome = True

    if haveall:

      inthere = True

      save_lines.append(rawline)

      continue

    if havesome and not haveall:

      # Line (old, or manual?) which is missing some.  Remove.

      removed = True

      continue

    save_lines.append(rawline)

  if not inthere:

    add_lines.append('%s\t%s %s\n' % (ip, fullnode, node))

  if removed:

    if add_lines:

      save_lines = save_lines + add_lines

    # We removed a line, write a new file and replace old.

    fd, tmpname = tempfile.mkstemp('tmp', 'hosts_', '/etc')

    newfile = os.fdopen(fd, 'w')

    newfile.write(''.join(save_lines))

    newfile.close()

    os.rename(tmpname, '/etc/hosts')

  elif add_lines:

    # Simply appending a new line will do the trick.

    f.seek(0, 2)

    for add in add_lines:

      f.write(add)

  f.close()

def _UpdateKnownHosts(fullnode, ip, pubkey):

  """Ensure a node has a correct known_hosts entry.

  Args:

    fullnode - Fully qualified domain name of host. (str)

    ip       - IPv4 address of host (str)

    pubkey   - the public key of the cluster

  """

  if os.path.exists(constants.SSH_KNOWN_HOSTS_FILE):

    f = open(constants.SSH_KNOWN_HOSTS_FILE, 'r+')

  else:

    f = open(constants.SSH_KNOWN_HOSTS_FILE, 'w+')

  inthere = False

  save_lines = []

  add_lines = []

  removed = False

  while True:

    rawline = f.readline()

    logger.Debug('read %s' % (repr(rawline),))

    if not rawline:

      # End of file

      break

    line = rawline.split('\n')[0]

    parts = line.split(' ')

    fields = parts[0].split(',')

    key = parts[2]

    haveall = True

    havesome = False

    for spec in [ ip, fullnode ]:

      if spec not in fields:

        haveall = False

      if spec in fields:

        havesome = True

    logger.Debug("key, pubkey = %s." % (repr((key, pubkey)),))

    if haveall and key == pubkey:

      inthere = True

      save_lines.append(rawline)

      logger.Debug("Keeping known_hosts '%s'." % (repr(rawline),))

      continue

    if havesome and (not haveall or key != pubkey):

      removed = True

      logger.Debug("Discarding known_hosts '%s'." % (repr(rawline),))

      continue

    save_lines.append(rawline)

  if not inthere:

    add_lines.append('%s,%s ssh-rsa %s\n' % (fullnode, ip, pubkey))

    logger.Debug("Adding known_hosts '%s'." % (repr(add_lines[-1]),))

  if removed:

    save_lines = save_lines + add_lines

    # Write a new file and replace old.

    fd, tmpname = tempfile.mkstemp('.tmp', 'known_hosts.',

                                   constants.DATA_DIR)

    newfile = os.fdopen(fd, 'w')

    try:

      newfile.write(''.join(save_lines))

    finally:

      newfile.close()

    logger.Debug("Wrote new known_hosts.")

    os.rename(tmpname, constants.SSH_KNOWN_HOSTS_FILE)

  elif add_lines:

    # Simply appending a new line will do the trick.

    f.seek(0, 2)

    for add in add_lines:

      f.write(add)

  f.close()

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

  """

  if os.path.exists('/root/.ssh/id_dsa'):

    utils.CreateBackup('/root/.ssh/id_dsa')

  if os.path.exists('/root/.ssh/id_dsa.pub'):

    utils.CreateBackup('/root/.ssh/id_dsa.pub')

  utils.RemoveFile('/root/.ssh/id_dsa')

  utils.RemoveFile('/root/.ssh/id_dsa.pub')

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

                         "-f", "/root/.ssh/id_dsa",

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

  if result.failed:

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

                             result.output)

  f = open('/root/.ssh/id_dsa.pub', 'r')

  try:

    utils.AddAuthorizedKey('/root/.ssh/authorized_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))

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 = {

      "CLUSTER": self.op.cluster_name,

      "MASTER": self.hostname.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")

    hostname_local = socket.gethostname()

    self.hostname = hostname = utils.LookupHostname(hostname_local)

    if not hostname:

      raise errors.OpPrereqError("Cannot resolve my own hostname ('%s')" %

                                 hostname_local)

    if hostname.name != hostname_local:

      raise errors.OpPrereqError("My own hostname (%s) does not match the"

                                 " resolver (%s): probably not using FQDN"

                                 " for hostname." %

                                 (hostname_local, hostname.name))

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

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

                                 " range (%s). Please fix DNS or /etc/hosts." %

                                 (hostname.ip,))

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

    if not clustername:

      raise errors.OpPrereqError("Cannot resolve given cluster name ('%s')"

                                 % self.op.cluster_name)

    result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", hostname.ip])

    if result.failed:

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

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

                                 " belong to this host."

                                 " Aborting." % hostname.ip)

    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:

      result = utils.RunCmd(["fping", "-S127.0.0.1", "-q", secondary_ip])

      if result.failed:

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

                                   "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 hypervisor.VALID_HTYPES:

      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()))

  def Exec(self, feedback_fn):

    """Initialize the cluster.

    """

    clustername = self.clustername

    hostname = self.hostname

    # set up the simple store

    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('/etc/ssh/ssh_host_rsa_key.pub', 'r')

    try:

      sshline = f.read()

    finally:

      f.close()

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

    _UpdateEtcHosts(hostname.name, hostname.ip)

    _UpdateKnownHosts(hostname.name, hostname.ip, sshkey)

    _InitSSHSetup(hostname.name)

    # init of cluster config file

    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)

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.

    """

    utils.CreateBackup('/root/.ssh/id_dsa')

    utils.CreateBackup('/root/.ssh/id_dsa.pub')

    rpc.call_node_leave_cluster(self.sstore.GetMasterNode())

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")