Handle strict mode

Strict mode is a new feature in Juju 2.9. The mode allows more things to
fail early if the mode is switched to strict. If no mode is detected
then it will fallback to a more passive mode, where it will fallback to
other solutions and try to carry on.

The purpose of strict mode is to enable people developing with
Juju/pylibjuju is highlight errors more early on and to prevent less
magic in Juju.

The PR for implementing strict mode is simple, EXCEPT when I turned it
one, it found the first error! ModelInfo delta was wrongly implemented
and wasn't gaining all the history correctly from the deltas over time.

This requires[1] juju/juju#12183 to land before this PR is really
useful.

To enable it at bootstrap time:

```sh
juju bootstrap lxd test --config mode=strict
```

 1. juju/juju#12183

Author: SimonRichardson

juju/delta.py

@@ -46,6 +46,9 @@ def get_entity_class(self):
 
 
 class ModelDelta(EntityDelta):
+    def get_id(self):
+        return self.data['model-uuid']
+
     @classmethod
     def get_entity_class(self):
         from .model import ModelInfo

juju/model.py

@@ -301,6 +301,12 @@ def entity_type(self):
         'application' or 'unit', etc.
 
         """
+        # Allow the overriding of entity names from the type instead of from
+        # the class name. Useful because Model and ModelInfo clash and we really
+        # want ModelInfo to be called Model.
+        if hasattr(self.__class__, "entity_name") and callable(self.__class__.entity_name):
+            return self.__class__.entity_name()
+
         def first_lower(s):
             if len(s) == 0:
                 return s
@@ -449,6 +455,7 @@ def __init__(
         self._observers = weakref.WeakValueDictionary()
         self.state = ModelState(self)
         self._info = None
+        self._mode = None
         self._watch_stopping = asyncio.Event(loop=self._connector.loop)
         self._watch_stopped = asyncio.Event(loop=self._connector.loop)
         self._watch_received = asyncio.Event(loop=self._connector.loop)
@@ -797,6 +804,10 @@ def info(self):
         """
         return self._info
 
+    @property
+    def strict_mode(self):
+        return self._mode is not None and "strict" in self._mode
+
     def add_observer(
             self, callable_, entity_type=None, action=None, entity_id=None,
             predicate=None):
@@ -843,7 +854,21 @@ def _watch(self):
         See :meth:`add_observer` to register an onchange callback.
 
         """
+        def _post_step(obj):
+            # Once we get the model, ensure we're running in the correct state
+            # as a post step.
+            if isinstance(obj, ModelInfo) and obj.safe_data is not None:
+                model_config = obj.safe_data["config"]
+                if "mode" in model_config:
+                    self._mode = model_config["mode"]
+
         async def _all_watcher():
+            # First attempt to get the model config so we know what mode the
+            # library should be running in.
+            model_config = await self.get_config()
+            if "mode" in model_config:
+                self._mode = model_config["mode"]["value"]
+
             try:
                 allwatcher = client.AllWatcherFacade.from_connection(
                     self.connection())
@@ -893,16 +918,15 @@ async def _all_watcher():
                         break
                     for delta in results.deltas:
                         try:
-                            delta = get_entity_delta(delta)
-                            old_obj, new_obj = self.state.apply_delta(delta)
-                            await self._notify_observers(delta, old_obj, new_obj)
-                        except KeyError as e:
-                            # TODO (stickupkid): we should raise the unknown delta
-                            # type, so we handle correctly all the types comming from
-                            # the all watcher. Currently they're ignored, causing
-                            # issue.
-                            # raise JujuError("unknown delta type {}".format(e.args))
-                            log.warning("unknown delta type: %s", e.args[0])
+                            entity = get_entity_delta(delta)
+                            old_obj, new_obj = self.state.apply_delta(entity)
+                            await self._notify_observers(entity, old_obj, new_obj)
+                            # Post step ensure that we can handle any settings
+                            # that need to be correctly set as a post step.
+                            _post_step(new_obj)
+                        except KeyError:
+                            if self.strict_mode:
+                                raise JujuError("unknown delta type '{}'".format(delta.entity))
                     self._watch_received.set()
             except CancelledError:
                 pass
@@ -2270,6 +2294,11 @@ def _ignore(self, path):
 
 
 class ModelInfo(ModelEntity):
+
     @property
     def tag(self):
         return tag.model(self.uuid)
+
+    @staticmethod
+    def entity_name():
+        return "model"