Merge remote-tracking branch 'origin/stable-2.8'

[ganeti-local] / lib / config.py

diff --git a/lib/config.py b/lib/config.py
index 5a882da..b968fcf 100644 (file)
--- a/lib/config.py
+++ b/lib/config.py
@@ -1,7 +1,7 @@
 #
 #
 
 #
 #
 

-# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Google Inc.
+# Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 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
 #
 # 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

@@ -270,17 +270,15 @@ class ConfigWriter:
     """
     return self._config_data.cluster.SimpleFillDP(group.diskparams)
 
     """
     return self._config_data.cluster.SimpleFillDP(group.diskparams)
 

-  def _UnlockedGetNetworkMACPrefix(self, net):
+  def _UnlockedGetNetworkMACPrefix(self, net_uuid):

     """Return the network mac prefix if it exists or the cluster level default.
 
     """
     prefix = None
     """Return the network mac prefix if it exists or the cluster level default.
 
     """
     prefix = None

-    if net:
-      net_uuid = self._UnlockedLookupNetwork(net)
-      if net_uuid:
-        nobj = self._UnlockedGetNetwork(net_uuid)
-        if nobj.mac_prefix:
-          prefix = nobj.mac_prefix
+    if net_uuid:
+      nobj = self._UnlockedGetNetwork(net_uuid)
+      if nobj.mac_prefix:
+        prefix = nobj.mac_prefix

 
     return prefix
 
 
     return prefix
 

@@ -303,14 +301,14 @@ class ConfigWriter:
     return GenMac
 
   @locking.ssynchronized(_config_lock, shared=1)
     return GenMac
 
   @locking.ssynchronized(_config_lock, shared=1)

-  def GenerateMAC(self, net, ec_id):
+  def GenerateMAC(self, net_uuid, ec_id):

     """Generate a MAC for an instance.
 
     This should check the current instances for duplicates.
 
     """
     existing = self._AllMACs()
     """Generate a MAC for an instance.
 
     This should check the current instances for duplicates.
 
     """
     existing = self._AllMACs()

-    prefix = self._UnlockedGetNetworkMACPrefix(net)
+    prefix = self._UnlockedGetNetworkMACPrefix(net_uuid)

     gen_mac = self._GenerateOneMAC(prefix)
     return self._temporary_ids.Generate(existing, gen_mac, ec_id)
 
     gen_mac = self._GenerateOneMAC(prefix)
     return self._temporary_ids.Generate(existing, gen_mac, ec_id)
 

@@ -359,22 +357,20 @@ class ConfigWriter:
                                 (constants.RELEASE_ACTION, address, net_uuid))
 
   @locking.ssynchronized(_config_lock, shared=1)
                                 (constants.RELEASE_ACTION, address, net_uuid))
 
   @locking.ssynchronized(_config_lock, shared=1)

-  def ReleaseIp(self, net, address, ec_id):
+  def ReleaseIp(self, net_uuid, address, ec_id):

     """Give a specified IP address back to an IP pool.
 
     This is just a wrapper around _UnlockedReleaseIp.
 
     """
     """Give a specified IP address back to an IP pool.
 
     This is just a wrapper around _UnlockedReleaseIp.
 
     """

-    net_uuid = self._UnlockedLookupNetwork(net)

     if net_uuid:
       self._UnlockedReleaseIp(net_uuid, address, ec_id)
 
   @locking.ssynchronized(_config_lock, shared=1)
     if net_uuid:
       self._UnlockedReleaseIp(net_uuid, address, ec_id)
 
   @locking.ssynchronized(_config_lock, shared=1)

-  def GenerateIp(self, net, ec_id):
+  def GenerateIp(self, net_uuid, ec_id):

     """Find a free IPv4 address for an instance.
 
     """
     """Find a free IPv4 address for an instance.
 
     """

-    net_uuid = self._UnlockedLookupNetwork(net)

     nobj = self._UnlockedGetNetwork(net_uuid)
     pool = network.AddressPool(nobj)
 
     nobj = self._UnlockedGetNetwork(net_uuid)
     pool = network.AddressPool(nobj)
 

@@ -406,11 +402,10 @@ class ConfigWriter:
                                         address, net_uuid))
 
   @locking.ssynchronized(_config_lock, shared=1)
                                         address, net_uuid))
 
   @locking.ssynchronized(_config_lock, shared=1)

-  def ReserveIp(self, net, address, ec_id):
+  def ReserveIp(self, net_uuid, address, ec_id):

     """Reserve a given IPv4 address for use by an instance.
 
     """
     """Reserve a given IPv4 address for use by an instance.
 
     """

-    net_uuid = self._UnlockedLookupNetwork(net)

     if net_uuid:
       return self._UnlockedReserveIp(net_uuid, address, ec_id)
 
     if net_uuid:
       return self._UnlockedReserveIp(net_uuid, address, ec_id)
 

@@ -450,6 +445,24 @@ class ConfigWriter:
         lvnames.update(lv_list)
     return lvnames
 
         lvnames.update(lv_list)
     return lvnames
 

+  def _AllDisks(self):
+    """Compute the list of all Disks.
+
+    """
+    disks = []
+    for instance in self._config_data.instances.values():
+      disks.extend(instance.disks)
+    return disks
+
+  def _AllNICs(self):
+    """Compute the list of all NICs.
+
+    """
+    nics = []
+    for instance in self._config_data.instances.values():
+      nics.extend(instance.nics)
+    return nics
+

   def _AllIDs(self, include_temporary):
     """Compute the list of all UUIDs and names we have.
 
   def _AllIDs(self, include_temporary):
     """Compute the list of all UUIDs and names we have.
 

@@ -582,13 +595,21 @@ class ConfigWriter:
     invalid_hvs = set(cluster.enabled_hypervisors) - constants.HYPER_TYPES
     if invalid_hvs:
       result.append("enabled hypervisors contains invalid entries: %s" %
     invalid_hvs = set(cluster.enabled_hypervisors) - constants.HYPER_TYPES
     if invalid_hvs:
       result.append("enabled hypervisors contains invalid entries: %s" %

-                    invalid_hvs)
+                    utils.CommaJoin(invalid_hvs))

     missing_hvp = (set(cluster.enabled_hypervisors) -
                    set(cluster.hvparams.keys()))
     if missing_hvp:
       result.append("hypervisor parameters missing for the enabled"
                     " hypervisor(s) %s" % utils.CommaJoin(missing_hvp))
 
     missing_hvp = (set(cluster.enabled_hypervisors) -
                    set(cluster.hvparams.keys()))
     if missing_hvp:
       result.append("hypervisor parameters missing for the enabled"
                     " hypervisor(s) %s" % utils.CommaJoin(missing_hvp))
 

+    if not cluster.enabled_disk_templates:
+      result.append("enabled disk templates list doesn't have any entries")
+    invalid_disk_templates = set(cluster.enabled_disk_templates) \
+                               - constants.DISK_TEMPLATES
+    if invalid_disk_templates:
+      result.append("enabled disk templates list contains invalid entries:"
+                    " %s" % utils.CommaJoin(invalid_disk_templates))
+

     if cluster.master_node not in data.nodes:
       result.append("cluster has invalid primary node '%s'" %
                     cluster.master_node)
     if cluster.master_node not in data.nodes:
       result.append("cluster has invalid primary node '%s'" %
                     cluster.master_node)

@@ -605,17 +626,18 @@ class ConfigWriter:
       except errors.ConfigurationError, err:
         result.append("%s has invalid nicparams: %s" % (owner, err))
 
       except errors.ConfigurationError, err:
         result.append("%s has invalid nicparams: %s" % (owner, err))
 

-    def _helper_ipolicy(owner, params, check_std):
+    def _helper_ipolicy(owner, ipolicy, iscluster):

       try:
       try:

-        objects.InstancePolicy.CheckParameterSyntax(params, check_std)
+        objects.InstancePolicy.CheckParameterSyntax(ipolicy, iscluster)

       except errors.ConfigurationError, err:
         result.append("%s has invalid instance policy: %s" % (owner, err))
       except errors.ConfigurationError, err:
         result.append("%s has invalid instance policy: %s" % (owner, err))

-
-    def _helper_ispecs(owner, params):
-      for key, value in params.items():
-        if key in constants.IPOLICY_ISPECS:
-          fullkey = "ipolicy/" + key
-          _helper(owner, fullkey, value, constants.ISPECS_PARAMETER_TYPES)
+      for key, value in ipolicy.items():
+        if key == constants.ISPECS_MINMAX:
+          for k in range(len(value)):
+            _helper_ispecs(owner, "ipolicy/%s[%s]" % (key, k), value[k])
+        elif key == constants.ISPECS_STD:
+          _helper(owner, "ipolicy/" + key, value,
+                  constants.ISPECS_PARAMETER_TYPES)

         else:
           # FIXME: assuming list type
           if key in constants.IPOLICY_PARAMETERS:
         else:
           # FIXME: assuming list type
           if key in constants.IPOLICY_PARAMETERS:

@@ -627,6 +649,11 @@ class ConfigWriter:
                           " expecting %s, got %s" %
                           (owner, key, exp_type.__name__, type(value)))
 
                           " expecting %s, got %s" %
                           (owner, key, exp_type.__name__, type(value)))
 

+    def _helper_ispecs(owner, parentkey, params):
+      for (key, value) in params.items():
+        fullkey = "/".join([parentkey, key])
+        _helper(owner, fullkey, value, constants.ISPECS_PARAMETER_TYPES)
+

     # check cluster parameters
     _helper("cluster", "beparams", cluster.SimpleFillBE({}),
             constants.BES_PARAMETER_TYPES)
     # check cluster parameters
     _helper("cluster", "beparams", cluster.SimpleFillBE({}),
             constants.BES_PARAMETER_TYPES)

@@ -635,8 +662,7 @@ class ConfigWriter:
     _helper_nic("cluster", cluster.SimpleFillNIC({}))
     _helper("cluster", "ndparams", cluster.SimpleFillND({}),
             constants.NDS_PARAMETER_TYPES)
     _helper_nic("cluster", cluster.SimpleFillNIC({}))
     _helper("cluster", "ndparams", cluster.SimpleFillND({}),
             constants.NDS_PARAMETER_TYPES)

-    _helper_ipolicy("cluster", cluster.SimpleFillIPolicy({}), True)
-    _helper_ispecs("cluster", cluster.SimpleFillIPolicy({}))
+    _helper_ipolicy("cluster", cluster.ipolicy, True)

 
     # per-instance checks
     for instance_name in data.instances:
 
     # per-instance checks
     for instance_name in data.instances:

@@ -664,6 +690,11 @@ class ConfigWriter:
                   filled, constants.NICS_PARAMETER_TYPES)
           _helper_nic(owner, filled)
 
                   filled, constants.NICS_PARAMETER_TYPES)
           _helper_nic(owner, filled)
 

+      # disk template checks
+      if not instance.disk_template in data.cluster.enabled_disk_templates:
+        result.append("instance '%s' uses the disabled disk template '%s'." %
+                      (instance_name, instance.disk_template))
+

       # parameter checks
       if instance.beparams:
         _helper("instance %s" % instance.name, "beparams",
       # parameter checks
       if instance.beparams:
         _helper("instance %s" % instance.name, "beparams",

@@ -767,7 +798,6 @@ class ConfigWriter:
       group_name = "group %s" % nodegroup.name
       _helper_ipolicy(group_name, cluster.SimpleFillIPolicy(nodegroup.ipolicy),
                       False)
       group_name = "group %s" % nodegroup.name
       _helper_ipolicy(group_name, cluster.SimpleFillIPolicy(nodegroup.ipolicy),
                       False)

-      _helper_ispecs(group_name, cluster.SimpleFillIPolicy(nodegroup.ipolicy))

       if nodegroup.ndparams:
         _helper(group_name, "ndparams",
                 cluster.SimpleFillND(nodegroup.ndparams),
       if nodegroup.ndparams:
         _helper(group_name, "ndparams",
                 cluster.SimpleFillND(nodegroup.ndparams),

@@ -1455,11 +1485,9 @@ class ConfigWriter:
     instance = self._UnlockedGetInstanceInfo(instance_name)
 
     for nic in instance.nics:
     instance = self._UnlockedGetInstanceInfo(instance_name)
 
     for nic in instance.nics:

-      if nic.network is not None and nic.ip is not None:
-        net_uuid = self._UnlockedLookupNetwork(nic.network)
-        if net_uuid:
-          # Return all IP addresses to the respective address pools
-          self._UnlockedCommitIp(constants.RELEASE_ACTION, net_uuid, nic.ip)
+      if nic.network and nic.ip:
+        # Return all IP addresses to the respective address pools
+        self._UnlockedCommitIp(constants.RELEASE_ACTION, nic.network, nic.ip)

 
     del self._config_data.instances[instance_name]
     self._config_data.cluster.serial_no += 1
 
     del self._config_data.instances[instance_name]
     self._config_data.cluster.serial_no += 1

@@ -1578,6 +1606,24 @@ class ConfigWriter:
                      for node_name in nodes)
 
   @locking.ssynchronized(_config_lock, shared=1)
                      for node_name in nodes)
 
   @locking.ssynchronized(_config_lock, shared=1)

+  def GetInstanceNetworks(self, instance_name):
+    """Returns set of network UUIDs for instance's nics.
+
+    @rtype: frozenset
+
+    """
+    instance = self._UnlockedGetInstanceInfo(instance_name)
+    if not instance:
+      raise errors.ConfigurationError("Unknown instance '%s'" % instance_name)
+
+    networks = set()
+    for nic in instance.nics:
+      if nic.network:
+        networks.add(nic.network)
+
+    return frozenset(networks)
+
+  @locking.ssynchronized(_config_lock, shared=1)

   def GetMultiInstanceInfo(self, instances):
     """Get the configuration of multiple instances.
 
   def GetMultiInstanceInfo(self, instances):
     """Get the configuration of multiple instances.
 

@@ -2010,6 +2056,9 @@ class ConfigWriter:
     return (self._config_data.instances.values() +
             self._config_data.nodes.values() +
             self._config_data.nodegroups.values() +
     return (self._config_data.instances.values() +
             self._config_data.nodes.values() +
             self._config_data.nodegroups.values() +

+            self._config_data.networks.values() +
+            self._AllDisks() +
+            self._AllNICs() +

             [self._config_data.cluster])
 
   def _OpenConfig(self, accept_foreign):
             [self._config_data.cluster])
 
   def _OpenConfig(self, accept_foreign):

@@ -2092,6 +2141,12 @@ class ConfigWriter:
       # This is ok even if it acquires the internal lock, as _UpgradeConfig is
       # only called at config init time, without the lock held
       self.DropECReservations(_UPGRADE_CONFIG_JID)
       # This is ok even if it acquires the internal lock, as _UpgradeConfig is
       # only called at config init time, without the lock held
       self.DropECReservations(_UPGRADE_CONFIG_JID)

+    else:
+      config_errors = self._UnlockedVerifyConfig()
+      if config_errors:
+        errmsg = ("Loaded configuration data is not consistent: %s" %
+                  (utils.CommaJoin(config_errors)))
+        logging.critical(errmsg)

 
   def _DistributeConfig(self, feedback_fn):
     """Distribute the configuration to the other nodes.
 
   def _DistributeConfig(self, feedback_fn):
     """Distribute the configuration to the other nodes.

@@ -2477,12 +2532,6 @@ class ConfigWriter:
     if check_uuid:
       self._EnsureUUID(net, ec_id)
 
     if check_uuid:
       self._EnsureUUID(net, ec_id)
 

-    existing_uuid = self._UnlockedLookupNetwork(net.name)
-    if existing_uuid:
-      raise errors.OpPrereqError("Desired network name '%s' already"
-                                 " exists as a network (UUID: %s)" %
-                                 (net.name, existing_uuid),
-                                 errors.ECODE_EXISTS)

     net.serial_no = 1
     self._config_data.networks[net.uuid] = net
     self._config_data.cluster.serial_no += 1
     net.serial_no = 1
     self._config_data.networks[net.uuid] = net
     self._config_data.cluster.serial_no += 1

@@ -2497,12 +2546,15 @@ class ConfigWriter:
     @raises errors.OpPrereqError: when the target network cannot be found
 
     """
     @raises errors.OpPrereqError: when the target network cannot be found
 
     """

+    if target is None:
+      return None

     if target in self._config_data.networks:
       return target
     for net in self._config_data.networks.values():
       if net.name == target:
         return net.uuid
     if target in self._config_data.networks:
       return target
     for net in self._config_data.networks.values():
       if net.name == target:
         return net.uuid

-    return None
+    raise errors.OpPrereqError("Network '%s' not found" % target,
+                               errors.ECODE_NOENT)

 
   @locking.ssynchronized(_config_lock, shared=1)
   def LookupNetwork(self, target):
 
   @locking.ssynchronized(_config_lock, shared=1)
   def LookupNetwork(self, target):

@@ -2535,23 +2587,19 @@ class ConfigWriter:
     self._config_data.cluster.serial_no += 1
     self._WriteConfig()
 
     self._config_data.cluster.serial_no += 1
     self._WriteConfig()
 

-  def _UnlockedGetGroupNetParams(self, net, node):
+  def _UnlockedGetGroupNetParams(self, net_uuid, node):

     """Get the netparams (mode, link) of a network.
 
     Get a network's netparams for a given node.
 
     """Get the netparams (mode, link) of a network.
 
     Get a network's netparams for a given node.
 

-    @type net: string
-    @param net: network name
+    @type net_uuid: string
+    @param net_uuid: network uuid

     @type node: string
     @param node: node name
     @rtype: dict or None
     @return: netparams
 
     """
     @type node: string
     @param node: node name
     @rtype: dict or None
     @return: netparams
 
     """

-    net_uuid = self._UnlockedLookupNetwork(net)
-    if net_uuid is None:
-      return None
-

     node_info = self._UnlockedGetNodeInfo(node)
     nodegroup_info = self._UnlockedGetNodeGroup(node_info.group)
     netparams = nodegroup_info.networks.get(net_uuid, None)
     node_info = self._UnlockedGetNodeInfo(node)
     nodegroup_info = self._UnlockedGetNodeGroup(node_info.group)
     netparams = nodegroup_info.networks.get(net_uuid, None)

@@ -2559,11 +2607,11 @@ class ConfigWriter:
     return netparams
 
   @locking.ssynchronized(_config_lock, shared=1)
     return netparams
 
   @locking.ssynchronized(_config_lock, shared=1)

-  def GetGroupNetParams(self, net, node):
+  def GetGroupNetParams(self, net_uuid, node):

     """Locking wrapper of _UnlockedGetGroupNetParams()
 
     """
     """Locking wrapper of _UnlockedGetGroupNetParams()
 
     """

-    return self._UnlockedGetGroupNetParams(net, node)
+    return self._UnlockedGetGroupNetParams(net_uuid, node)

 
   @locking.ssynchronized(_config_lock, shared=1)
   def CheckIPInNodeGroup(self, ip, node):
 
   @locking.ssynchronized(_config_lock, shared=1)
   def CheckIPInNodeGroup(self, ip, node):