charm metadata support for subordinates

juju/charm/metadata.py

 import logging
 import os
 
 import yaml
 
 from juju.charm.errors import MetaDataError
 from juju.errors import FileNotFound
 from juju.lib.schema import (
     SchemaError, Bool, Constant, Dict, Int,
     KeyDict, OneOf, UnicodeOrString)
 
 
 log = logging.getLogger("juju.charm")
 
 
 UTF8_SCHEMA = UnicodeOrString("utf-8")
 
+SCOPE_GLOBAL = "global"
+SCOPE_CONTAINER = "container"
+
+
 INTERFACE_SCHEMA = KeyDict({
-        "interface": UTF8_SCHEMA,
-        "limit": OneOf(Constant(None), Int()),
-        "optional": Bool()})
+    "interface": UTF8_SCHEMA,
+    "limit": OneOf(Constant(None), Int()),
+    "scope": OneOf(Constant(SCOPE_GLOBAL), Constant(SCOPE_CONTAINER)),
+    "optional": Bool()},
+    optional=["scope"])
 
 
 class InterfaceExpander(object):
     """Schema coercer that expands the interface shorthand notation.
 
     We need this class because our charm shorthand is difficult to
     work with (unfortunately). So we coerce shorthand and then store
     the desired format in ZK.
 
     Supports the following variants::
@@ skipping 27 matching lines @@
 
         Helper method to support each of the variants, either the
         charm does not specify limit and optional, such as foobar in
         the above example; or the interface spec is just a string,
         such as the ``server: riak`` example.
         """
         if not isinstance(value, dict):
             return {
                 "interface": UTF8_SCHEMA.coerce(value, path),
                 "limit": self.limit,
+                "scope": "global",
                 "optional": False}
         else:
             # Optional values are context-sensitive and/or have
             # defaults, which is different than what KeyDict can
             # readily support. So just do it here first, then
             # coerce.
             if "limit" not in value:
                 value["limit"] = self.limit
             if "optional" not in value:
                 value["optional"] = False
+            value["scope"] = value.get("scope", "global")
             return INTERFACE_SCHEMA.coerce(value, path)
 
 
 SCHEMA = KeyDict({
     "name": UTF8_SCHEMA,
     "revision": Int(),
     "summary": UTF8_SCHEMA,
     "description": UTF8_SCHEMA,
     "peers": Dict(UTF8_SCHEMA, InterfaceExpander(limit=1)),
     "provides": Dict(UTF8_SCHEMA, InterfaceExpander(limit=None)),
     "requires": Dict(UTF8_SCHEMA, InterfaceExpander(limit=1)),
-    }, optional=set(["provides", "requires", "peers", "revision"]))
+    "subordinate": Bool(),
+    }, optional=set(["provides", "requires", "peers", "revision", "subordinate"]))
 
 
 class MetaData(object):
     """Represents the charm info file.
 
     The main metadata for a charm (name, revision, etc) is maintained
     in the charm's info file.  This class is able to parse,
     validate, and provide access to data in the info file.
     """
 
@@ skipping 36 matching lines @@
     @property
     def requires(self):
         """The charm requires relations."""
         return self._data.get("requires")
 
     @property
     def peers(self):
         """The charm peers relations."""
         return self._data.get("peers")
 
+    @property
+    def is_subordinate(self):
+        """Indicates the charm requires a contained relationship.
+
+        This property will effect the deployment options of its
+        charm. When a charm is_subordinate it can only be deployed
+        when its contained relationship is satisfied. See the
+        subordinates specification.
+        """
+        if self._data.get("subordinate", False) is False:
+            return False
+
+        if not self.requires:
+            return False
+
+        for relation_data in self.requires.values():
+            if relation_data.get("scope") == "container":
+                return True
+        return False
+
     def get_serialization_data(self):
         """Get internal dictionary representing the state of this instance.
 
         This is useful to embed this information inside other storage-related
         dictionaries.
         """
         return dict(self._data)
 
     def load(self, path):
         """Load and parse the info file.
@@ skipping 23 matching lines @@
             # Capture the path name on the error if present.
             if path is not None:
                 e.problem_mark.name = path
             raise
 
         if "revision" in self._data and path:
             log.warning(
                 "%s: revision field is obsolete. Move it to the 'revision' "
                 "file." % path)
 
+        if self._data.get("subordinate", False) is True:
+            proper_subordinate = False
+            if self.requires:
+                for relation_data in self.requires.values():
+                    if relation_data.get("scope") == "container":
+                        proper_subordinate = True
+            if not proper_subordinate:
+                log.warning(
+                    "%s labeled subordinate but lacking scope:container `requires` relation",
+                    path)

[hazmat, 2012/02/27 19:21:20]

Feels like this should be an error that's raised.

[bcsaller, 2012/02/28 00:22:58]

It isn't currently because the other checks in the method only log. However
you're correct that this indicates a usage error and should be corrected so I'm
changing it to a MetadataError(...)

+
     def parse_serialization_data(self, serialization_data, path=None):
         """Parse the unprocessed serialization data and load in this instance.
 
         @param serialization_data: Unprocessed data matching the
             metadata schema.
         @param path: Optional path of the loaded file.  Used when
             raising errors.
 
         @raise MetaDataError: When errors are found in the info data.
         """
         try:
             self._data = SCHEMA.coerce(serialization_data, [])
         except SchemaError, error:
             if path:
                 path_info = " %s:" % path
             else:
                 path_info = ""
             raise MetaDataError("Bad data in charm info:%s %s" %
                                 (path_info, error))