Merge pull request #507 from DomFleischmann/local-upgrades

#507

This commit will add support for upgrading from a locally built charm with local resources.

Author: jujubot

examples/local_refresh.py

@@ -0,0 +1,30 @@
+"""
+This example:
+
+1. Connects to the current model
+2. Upgrades previously deployed ubuntu charm
+
+"""
+from juju import loop
+from juju.model import Model
+
+
+async def main():
+    model = Model()
+    print('Connecting to model')
+    # connect to current model with current user, per Juju CLI
+    await model.connect()
+
+    try:
+        print('Get deployed application')
+        app = model.appplications["ubuntu"]
+
+        print('Refresh/Upgrade Ubuntu charm with local charm')
+        await app.refresh(path="path/to/local/ubuntu.charm")
+    finally:
+        print('Disconnecting from model')
+        await model.disconnect()
+
+
+if __name__ == '__main__':
+    loop.run(main())

juju/application.py

@@ -15,13 +15,16 @@
 import asyncio
 import json
 import logging
+import os
 
 from . import model, tag
 from .status import derive_status
 from .annotationhelper import _get_annotations, _set_annotations
 from .client import client
 from .errors import JujuError
+from .bundle import get_charm_series
 from .placement import parse as parse_placement
+from .charm import get_local_charm_metadata
 
 log = logging.getLogger(__name__)
 
@@ -578,9 +581,10 @@ async def refresh(
         :param str switch: Crossgrade charm url
 
         """
-        # TODO: Support local upgrades
         if path is not None:
-            raise NotImplementedError("path option is not implemented")
+            await self.local_refresh(channel, force, force_series, force_units,
+                                     path, resources)
+            return
         if resources is not None:
             raise NotImplementedError("resources option is not implemented")
 
@@ -684,6 +688,61 @@ async def refresh(
 
     upgrade_charm = refresh
 
+    async def local_refresh(
+            self, channel=None, force=False, force_series=False, force_units=False,
+            path=None, resources=None):
+        """Refresh the charm for this application with a local charm.
+
+        :param str channel: Channel to use when getting the charm from the
+            charm store, e.g. 'development'
+        :param bool force_series: Refresh even if series of deployed
+            application is not supported by the new charm
+        :param bool force_units: Refresh all units immediately, even if in
+            error state
+        :param str path: Refresh to a charm located at path
+        :param dict resources: Dictionary of resource name/filepath pairs
+        :param int revision: Explicit refresh revision
+        :param str switch: Crossgrade charm url
+
+        """
+        app_facade = self._facade()
+
+        charm_dir = os.path.abspath(
+            os.path.expanduser(path))
+        model_config = await self.get_config()
+
+        series = get_charm_series(charm_dir)
+        if not series:
+            model_config = await self.get_config()
+            default_series = model_config.get("default-series")
+            if default_series:
+                series = default_series.value
+        charm_url = await self.model.add_local_charm_dir(charm_dir, series)
+        metadata = get_local_charm_metadata(path)
+        if resources is not None:
+            resources = await self.model.add_local_resources(self.entity_id,
+                                                             charm_url,
+                                                             metadata,
+                                                             resources=resources)
+
+        # Update application
+        await app_facade.SetCharm(
+            application=self.entity_id,
+            channel=channel,
+            charm_url=charm_url,
+            config_settings=None,
+            config_settings_yaml=None,
+            force=force,
+            force_series=force_series,
+            force_units=force_units,
+            resource_ids=resources,
+            storage_constraints=None,
+        )
+
+        await self.model.block_until(
+            lambda: self.data['charm-url'] == charm_url
+        )
+
     async def get_metrics(self):
         """Get metrics for this application's units.
 

juju/charm.py

@@ -13,11 +13,31 @@
 #     limitations under the License.
 
 import logging
-
+import zipfile
+import yaml
+from pathlib import Path
 from . import model
 
 log = logging.getLogger(__name__)
 
 
+def get_local_charm_metadata(path):
+    """Retrieve Metadata of a Charm from its path
+
+    :patam str path: Path of charm directory or .charm file
+
+    :return: Object of charm metadata
+    """
+    if str(path).endswith('.charm'):
+        with zipfile.ZipFile(path, 'r') as charm_file:
+            metadata = yaml.load(charm_file.read('metadata.yaml'), Loader=yaml.FullLoader)
+    else:
+        entity_path = Path(path)
+        metadata_path = entity_path / 'metadata.yaml'
+        metadata = yaml.load(metadata_path.read_text(), Loader=yaml.FullLoader)
+
+    return metadata
+
+
 class Charm(model.ModelEntity):
     pass

juju/model.py

@@ -1492,10 +1492,10 @@ async def deploy(
                         "Pass a 'series' kwarg to Model.deploy().".format(
                             charm_dir))
                 entity_id = await self.add_local_charm_dir(charm_dir, series)
-                resources = await self._add_local_resources(application_name,
-                                                            entity_id,
-                                                            metadata,
-                                                            resources=resources)
+                resources = await self.add_local_resources(application_name,
+                                                           entity_id,
+                                                           metadata,
+                                                           resources=resources)
 
             if config is None:
                 config = {}
@@ -1561,7 +1561,7 @@ async def _add_store_resources(self, application, entity_url,
                         in zip(resources, response.pending_ids)}
         return resource_map
 
-    async def _add_local_resources(self, application, entity_url, metadata, resources):
+    async def add_local_resources(self, application, entity_url, metadata, resources):
         if not resources:
             return None
 

tests/integration/test_application.py

@@ -1,4 +1,5 @@
 import asyncio
+from pathlib import Path
 
 import pytest
 
@@ -143,6 +144,20 @@ async def test_upgrade_charm_switch(event_loop):
         assert app.data['charm-url'] == 'cs:ubuntu-8'
 
 
+@base.bootstrapped
+@pytest.mark.asyncio
+async def test_upgrade_local_charm(event_loop):
+    async with base.CleanModel() as model:
+        tests_dir = Path(__file__).absolute().parent
+        charm_path = tests_dir / 'upgrade-charm'
+        app = await model.deploy('ubuntu', series='focal')
+        await model.wait_for_idle(wait_for_active=True)
+        assert app.data['charm-url'].startswith('cs:ubuntu')
+        await app.upgrade_charm(path=charm_path)
+        await model.wait_for_idle()  # nb: can't use wait_for_active because test charm goes to "waiting"
+        assert app.data['charm-url'] == 'local:focal/ubuntu-0'
+
+
 @base.bootstrapped
 @pytest.mark.asyncio
 async def test_upgrade_charm_resource(event_loop):

tests/integration/upgrade-charm/dispatch

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+resource_file="$(resource-get oci-image)"
+if [[ -z "$resource_file" ]]; then
+  status-set waiting
+elif grep -q "ubuntu/latest" "$resource_file"; then
+  status-set active
+else
+  status-set error
+fi

tests/integration/upgrade-charm/metadata.yaml

@@ -0,0 +1,5 @@
+name: ubuntu
+series: ["focal"]
+summary: "test"
+description: "test"
+maintainers: ["test"]