Revert "jqueue: Resume jobs from “waitlock” status"
[ganeti-local] / lib / ssconf.py
index b800f25..c29d63c 100644 (file)
@@ -26,13 +26,21 @@ configuration data, which is mostly static and available to all nodes.
 
 """
 
 
 """
 
-import socket
 import sys
 import sys
+import re
+import os
 
 from ganeti import errors
 from ganeti import constants
 from ganeti import utils
 from ganeti import serializer
 
 from ganeti import errors
 from ganeti import constants
 from ganeti import utils
 from ganeti import serializer
+from ganeti import objects
+from ganeti import netutils
+
+
+SSCONF_LOCK_TIMEOUT = 10
+
+RE_VALID_SSCONF_NAME = re.compile(r'^[-_a-z0-9]+$')
 
 
 class SimpleConfigReader(object):
 
 
 class SimpleConfigReader(object):
@@ -47,8 +55,86 @@ class SimpleConfigReader(object):
 
     """
     self._file_name = file_name
 
     """
     self._file_name = file_name
-    self._config_data = serializer.Load(utils.ReadFile(file_name))
-    # TODO: Error handling
+    self._last_inode = None
+    self._last_mtime = None
+    self._last_size = None
+
+    self._config_data = None
+    self._inst_ips_by_link = None
+    self._ip_to_inst_by_link = None
+    self._instances_ips = None
+    self._mc_primary_ips = None
+    self._nodes_primary_ips = None
+
+    # we need a forced reload at class init time, to initialize _last_*
+    self._Load(force=True)
+
+  def _Load(self, force=False):
+    """Loads (or reloads) the config file.
+
+    @type force: boolean
+    @param force: whether to force the reload without checking the mtime
+    @rtype: boolean
+    @return: boolean value that says whether we reloaded the configuration or
+             not (because we decided it was already up-to-date)
+
+    """
+    try:
+      cfg_stat = os.stat(self._file_name)
+    except EnvironmentError, err:
+      raise errors.ConfigurationError("Cannot stat config file %s: %s" %
+                                      (self._file_name, err))
+    inode = cfg_stat.st_ino
+    mtime = cfg_stat.st_mtime
+    size = cfg_stat.st_size
+
+    if (force or inode != self._last_inode or
+        mtime > self._last_mtime or
+        size != self._last_size):
+      self._last_inode = inode
+      self._last_mtime = mtime
+      self._last_size = size
+    else:
+      # Don't reload
+      return False
+
+    try:
+      self._config_data = serializer.Load(utils.ReadFile(self._file_name))
+    except EnvironmentError, err:
+      raise errors.ConfigurationError("Cannot read config file %s: %s" %
+                                      (self._file_name, err))
+    except ValueError, err:
+      raise errors.ConfigurationError("Cannot load config file %s: %s" %
+                                      (self._file_name, err))
+
+    self._ip_to_inst_by_link = {}
+    self._instances_ips = []
+    self._inst_ips_by_link = {}
+    c_nparams = self._config_data['cluster']['nicparams'][constants.PP_DEFAULT]
+    for iname in self._config_data['instances']:
+      instance = self._config_data['instances'][iname]
+      for nic in instance['nics']:
+        if 'ip' in nic and nic['ip']:
+          params = objects.FillDict(c_nparams, nic['nicparams'])
+          if not params['link'] in self._inst_ips_by_link:
+            self._inst_ips_by_link[params['link']] = []
+            self._ip_to_inst_by_link[params['link']] = {}
+          self._ip_to_inst_by_link[params['link']][nic['ip']] = iname
+          self._inst_ips_by_link[params['link']].append(nic['ip'])
+
+    self._nodes_primary_ips = []
+    self._mc_primary_ips = []
+    for node_name in self._config_data["nodes"]:
+      node = self._config_data["nodes"][node_name]
+      self._nodes_primary_ips.append(node["primary_ip"])
+      if node["master_candidate"]:
+        self._mc_primary_ips.append(node["primary_ip"])
+
+    return True
+
+  # Clients can request a reload of the config file, so we export our internal
+  # _Load function as Reload.
+  Reload = _Load
 
   def GetClusterName(self):
     return self._config_data["cluster"]["cluster_name"]
 
   def GetClusterName(self):
     return self._config_data["cluster"]["cluster_name"]
@@ -68,43 +154,311 @@ class SimpleConfigReader(object):
   def GetFileStorageDir(self):
     return self._config_data["cluster"]["file_storage_dir"]
 
   def GetFileStorageDir(self):
     return self._config_data["cluster"]["file_storage_dir"]
 
-  def GetHypervisorType(self):
-    return self._config_data["cluster"]["hypervisor"]
-
   def GetNodeList(self):
     return self._config_data["nodes"].keys()
 
   def GetNodeList(self):
     return self._config_data["nodes"].keys()
 
-  @classmethod
-  def FromDict(cls, val, cfg_file=constants.CLUSTER_CONF_FILE):
-    """Alternative construction from a dictionary.
+  def GetConfigSerialNo(self):
+    return self._config_data["serial_no"]
+
+  def GetClusterSerialNo(self):
+    return self._config_data["cluster"]["serial_no"]
+
+  def GetDefaultNicParams(self):
+    return self._config_data["cluster"]["nicparams"][constants.PP_DEFAULT]
+
+  def GetDefaultNicLink(self):
+    return self.GetDefaultNicParams()[constants.NIC_LINK]
+
+  def GetNodeStatusFlags(self, node):
+    """Get a node's status flags
+
+    @type node: string
+    @param node: node name
+    @rtype: (bool, bool, bool)
+    @return: (master_candidate, drained, offline) (or None if no such node)
+
+    """
+    if node not in self._config_data["nodes"]:
+      return None
+
+    master_candidate = self._config_data["nodes"][node]["master_candidate"]
+    drained = self._config_data["nodes"][node]["drained"]
+    offline = self._config_data["nodes"][node]["offline"]
+    return master_candidate, drained, offline
+
+  def GetInstanceByLinkIp(self, ip, link):
+    """Get instance name from its link and ip address.
+
+    @type ip: string
+    @param ip: ip address
+    @type link: string
+    @param link: nic link
+    @rtype: string
+    @return: instance name
+
+    """
+    if not link:
+      link = self.GetDefaultNicLink()
+    if not link in self._ip_to_inst_by_link:
+      return None
+    if not ip in self._ip_to_inst_by_link[link]:
+      return None
+    return self._ip_to_inst_by_link[link][ip]
+
+  def GetNodePrimaryIp(self, node):
+    """Get a node's primary ip
+
+    @type node: string
+    @param node: node name
+    @rtype: string, or None
+    @return: node's primary ip, or None if no such node
 
     """
 
     """
-    obj = SimpleConfigReader.__new__(cls)
-    obj._config_data = val
-    obj._file_name = cfg_file
-    return obj
+    if node not in self._config_data["nodes"]:
+      return None
+    return self._config_data["nodes"][node]["primary_ip"]
+
+  def GetInstancePrimaryNode(self, instance):
+    """Get an instance's primary node
 
 
+    @type instance: string
+    @param instance: instance name
+    @rtype: string, or None
+    @return: primary node, or None if no such instance
 
 
-class SimpleConfigWriter(SimpleConfigReader):
-  """Simple class to write configuration file.
+    """
+    if instance not in self._config_data["instances"]:
+      return None
+    return self._config_data["instances"][instance]["primary_node"]
+
+  def GetNodesPrimaryIps(self):
+    return self._nodes_primary_ips
+
+  def GetMasterCandidatesPrimaryIps(self):
+    return self._mc_primary_ips
+
+  def GetInstancesIps(self, link):
+    """Get list of nic ips connected to a certain link.
+
+    @type link: string
+    @param link: nic link
+    @rtype: list
+    @return: list of ips connected to that link
+
+    """
+    if not link:
+      link = self.GetDefaultNicLink()
+
+    if link in self._inst_ips_by_link:
+      return self._inst_ips_by_link[link]
+    else:
+      return []
+
+
+class SimpleStore(object):
+  """Interface to static cluster data.
+
+  This is different that the config.ConfigWriter and
+  SimpleConfigReader classes in that it holds data that will always be
+  present, even on nodes which don't have all the cluster data.
+
+  Other particularities of the datastore:
+    - keys are restricted to predefined values
 
   """
 
   """
-  def SetMasterNode(self, node):
-    """Change master node.
+  _SS_FILEPREFIX = "ssconf_"
+  _VALID_KEYS = (
+    constants.SS_CLUSTER_NAME,
+    constants.SS_CLUSTER_TAGS,
+    constants.SS_FILE_STORAGE_DIR,
+    constants.SS_MASTER_CANDIDATES,
+    constants.SS_MASTER_CANDIDATES_IPS,
+    constants.SS_MASTER_IP,
+    constants.SS_MASTER_NETDEV,
+    constants.SS_MASTER_NODE,
+    constants.SS_NODE_LIST,
+    constants.SS_NODE_PRIMARY_IPS,
+    constants.SS_NODE_SECONDARY_IPS,
+    constants.SS_OFFLINE_NODES,
+    constants.SS_ONLINE_NODES,
+    constants.SS_INSTANCE_LIST,
+    constants.SS_RELEASE_VERSION,
+    constants.SS_HYPERVISOR_LIST,
+    constants.SS_MAINTAIN_NODE_HEALTH,
+    constants.SS_UID_POOL,
+    )
+  _MAX_SIZE = 131072
+
+  def __init__(self, cfg_location=None):
+    if cfg_location is None:
+      self._cfg_dir = constants.DATA_DIR
+    else:
+      self._cfg_dir = cfg_location
+
+  def KeyToFilename(self, key):
+    """Convert a given key into filename.
+
+    """
+    if key not in self._VALID_KEYS:
+      raise errors.ProgrammerError("Invalid key requested from SSConf: '%s'"
+                                   % str(key))
+
+    filename = self._cfg_dir + '/' + self._SS_FILEPREFIX + key
+    return filename
+
+  def _ReadFile(self, key):
+    """Generic routine to read keys.
+
+    This will read the file which holds the value requested. Errors
+    will be changed into ConfigurationErrors.
+
+    """
+    filename = self.KeyToFilename(key)
+    try:
+      data = utils.ReadFile(filename, size=self._MAX_SIZE)
+    except EnvironmentError, err:
+      raise errors.ConfigurationError("Can't read from the ssconf file:"
+                                      " '%s'" % str(err))
+    data = data.rstrip('\n')
+    return data
+
+  def WriteFiles(self, values):
+    """Writes ssconf files used by external scripts.
+
+    @type values: dict
+    @param values: Dictionary of (name, value)
+
+    """
+    ssconf_lock = utils.FileLock.Open(constants.SSCONF_LOCK_FILE)
+
+    # Get lock while writing files
+    ssconf_lock.Exclusive(blocking=True, timeout=SSCONF_LOCK_TIMEOUT)
+    try:
+      for name, value in values.iteritems():
+        if value and not value.endswith("\n"):
+          value += "\n"
+        if len(value) > self._MAX_SIZE:
+          raise errors.ConfigurationError("ssconf file %s above maximum size" %
+                                          name)
+        utils.WriteFile(self.KeyToFilename(name), data=value, mode=0444)
+    finally:
+      ssconf_lock.Unlock()
+
+  def GetFileList(self):
+    """Return the list of all config files.
+
+    This is used for computing node replication data.
+
+    """
+    return [self.KeyToFilename(key) for key in self._VALID_KEYS]
+
+  def GetClusterName(self):
+    """Get the cluster name.
+
+    """
+    return self._ReadFile(constants.SS_CLUSTER_NAME)
+
+  def GetFileStorageDir(self):
+    """Get the file storage dir.
+
+    """
+    return self._ReadFile(constants.SS_FILE_STORAGE_DIR)
+
+  def GetMasterCandidates(self):
+    """Return the list of master candidates.
+
+    """
+    data = self._ReadFile(constants.SS_MASTER_CANDIDATES)
+    nl = data.splitlines(False)
+    return nl
+
+  def GetMasterCandidatesIPList(self):
+    """Return the list of master candidates' primary IP.
+
+    """
+    data = self._ReadFile(constants.SS_MASTER_CANDIDATES_IPS)
+    nl = data.splitlines(False)
+    return nl
+
+  def GetMasterIP(self):
+    """Get the IP of the master node for this cluster.
 
     """
 
     """
-    self._config_data["cluster"]["master_node"] = node
+    return self._ReadFile(constants.SS_MASTER_IP)
+
+  def GetMasterNetdev(self):
+    """Get the netdev to which we'll add the master ip.
 
 
-  def Save(self):
-    """Writes configuration file.
+    """
+    return self._ReadFile(constants.SS_MASTER_NETDEV)
 
 
-    Warning: Doesn't take care of locking or synchronizing with other
-    processes.
+  def GetMasterNode(self):
+    """Get the hostname of the master node for this cluster.
 
     """
 
     """
-    utils.WriteFile(self._file_name,
-                    data=serializer.Dump(self._config_data),
-                    mode=0600)
+    return self._ReadFile(constants.SS_MASTER_NODE)
+
+  def GetNodeList(self):
+    """Return the list of cluster nodes.
+
+    """
+    data = self._ReadFile(constants.SS_NODE_LIST)
+    nl = data.splitlines(False)
+    return nl
+
+  def GetNodePrimaryIPList(self):
+    """Return the list of cluster nodes' primary IP.
+
+    """
+    data = self._ReadFile(constants.SS_NODE_PRIMARY_IPS)
+    nl = data.splitlines(False)
+    return nl
+
+  def GetNodeSecondaryIPList(self):
+    """Return the list of cluster nodes' secondary IP.
+
+    """
+    data = self._ReadFile(constants.SS_NODE_SECONDARY_IPS)
+    nl = data.splitlines(False)
+    return nl
+
+  def GetClusterTags(self):
+    """Return the cluster tags.
+
+    """
+    data = self._ReadFile(constants.SS_CLUSTER_TAGS)
+    nl = data.splitlines(False)
+    return nl
+
+  def GetHypervisorList(self):
+    """Return the list of enabled hypervisors.
+
+    """
+    data = self._ReadFile(constants.SS_HYPERVISOR_LIST)
+    nl = data.splitlines(False)
+    return nl
+
+  def GetMaintainNodeHealth(self):
+    """Return the value of the maintain_node_health option.
+
+    """
+    data = self._ReadFile(constants.SS_MAINTAIN_NODE_HEALTH)
+    # we rely on the bool serialization here
+    return data == "True"
+
+  def GetUidPool(self):
+    """Return the user-id pool definition string.
+
+    The separator character is a newline.
+
+    The return value can be parsed using uidpool.ParseUidPool()::
+
+      ss = ssconf.SimpleStore()
+      uid_pool = uidpool.ParseUidPool(ss.GetUidPool(), separator="\\n")
+
+    """
+    data = self._ReadFile(constants.SS_UID_POOL)
+    return data
 
 
 def GetMasterAndMyself(ss=None):
 
 
 def GetMasterAndMyself(ss=None):
@@ -116,10 +470,15 @@ def GetMasterAndMyself(ss=None):
   The function does not handle any errors, these should be handled in
   the caller (errors.ConfigurationError, errors.ResolverError).
 
   The function does not handle any errors, these should be handled in
   the caller (errors.ConfigurationError, errors.ResolverError).
 
+  @param ss: either a sstore.SimpleConfigReader or a
+      sstore.SimpleStore instance
+  @rtype: tuple
+  @return: a tuple (master node name, my own name)
+
   """
   if ss is None:
   """
   if ss is None:
-    ss = SimpleConfigReader()
-  return ss.GetMasterNode(), utils.HostInfo().name
+    ss = SimpleStore()
+  return ss.GetMasterNode(), netutils.HostInfo().name
 
 
 def CheckMaster(debug, ss=None):
 
 
 def CheckMaster(debug, ss=None):