Clear out charmstore in juju/model and juju/bundle

Author: cderici

juju/bundle.py

@@ -34,7 +34,6 @@ def __init__(self, model, trusted=False, forced=False):
         self.overlays = []
         self.overlay_removed_charms = set()
 
-        self.charmstore = model.charmstore
         self.plan = []
         self.references = {}
         self._units_by_app = {}
@@ -235,11 +234,7 @@ async def fetch_plan(self, charm_url, origin, overlays=[]):
             bundle_yaml = (Path(entity_id) / "bundle.yaml").read_text()
             bundle_dir = Path(entity_id)
 
-        if Schema.CHARM_STORE.matches(charm_url.schema):
-            bundle_yaml = await self.charmstore.files(entity_id,
-                                                      filename='bundle.yaml',
-                                                      read_file=True)
-        elif Schema.CHARM_HUB.matches(charm_url.schema):
+        if Schema.CHARM_HUB.matches(charm_url.schema):
             bundle_yaml = await self._download_bundle(charm_url, origin)
 
         if not bundle_yaml:
@@ -361,8 +356,6 @@ async def _resolve_charms(self):
                 channel = Channel.parse(spec['channel'])
                 track, risk = channel.track, channel.risk
 
-                # if not track and series:
-                #     track = utils.get_series_version(series)
             if self.charms_facade is not None:
                 if cons is not None and cons['arch'] != '':
                     architecture = cons['arch']
@@ -379,9 +372,7 @@ async def _resolve_charms(self):
                 charm_url, charm_origin, _ = await self.model._resolve_charm(charm_url, origin)
                 spec['charm'] = str(charm_url)
             else:
-                results = await self.model.charmstore.entity(str(charm_url))
-                charm_url = results.get('Id', charm_url)
-                charm_origin = client.CharmOrigin(source="charm-store",
+                charm_origin = client.CharmOrigin(source="charm-hub",
                                                   risk=risk,
                                                   track=track)
 
@@ -596,9 +587,7 @@ async def run(self, context):
 
         # set the channel to the default value if not specified
         if not self.channel:
-            if Schema.CHARM_STORE.matches(url.schema):
-                self.channel = "stable"
-            elif Schema.CHARM_HUB.matches(url.schema):
+            if Schema.CHARM_HUB.matches(url.schema):
                 self.channel = "latest/stable"
             else:   # for local charms
                 self.channel = ""
@@ -616,17 +605,13 @@ async def run(self, context):
         if origin is None:
             raise JujuError("expected origin to be valid for application {} and charm {} with channel {}".format(self.application, str(url), str(channel)))
 
-        if self.series is None or self.series == "":
+        if not self.series:
             self.series = context.bundle.get("series", None)
 
-        if Schema.CHARM_STORE.matches(url.schema):
-            resources = await context.model._add_store_resources(
-                self.application, charm, overrides=self.resources)
-        elif Schema.CHARM_HUB.matches(url.schema):
+        resources = context.bundle.get("applications", {}).get(self.application, {}).get("resources", {})
+        if Schema.CHARM_HUB.matches(url.schema):
             resources = await context.model._add_charmhub_resources(
                 self.application, charm, origin, overrides=self.resources)
-        else:
-            resources = context.bundle.get("applications", {}).get(self.application, {}).get("resources", {})
 
         await context.model._deploy(
             charm_url=charm,
@@ -723,13 +708,6 @@ async def run(self, context):
         if Schema.LOCAL.matches(url.schema):
             return self.charm
 
-        if Schema.CHARM_STORE.matches(url.schema):
-            entity_id = await context.charmstore.entityId(self.charm, channel=self.channel)
-            log.debug('Adding %s', entity_id)
-            await context.charms_facade.AddCharm(channel=self.channel, url=entity_id, force=False)
-            identifier = entity_id
-            origin = client.CharmOrigin(source="charm-store", risk="stable")
-
         if Schema.CHARM_HUB.matches(url.schema):
             ch = Channel('latest', 'stable')
             if self.channel:

juju/model.py

@@ -23,7 +23,6 @@
 from .annotationhelper import _get_annotations, _set_annotations
 from .bundle import BundleHandler, get_charm_series, is_local_charm
 from .charmhub import CharmHub
-from .charmstore import CharmStore
 from .client import client, connector
 from .client.overrides import Caveat, Macaroon
 from .constraints import parse as parse_constraints
@@ -484,52 +483,6 @@ async def resolve(self, url, architecture, app_name=None, channel=None, series=N
             is_bundle=is_bundle,
         )
 
-
-class CharmStoreDeployType:
-    """CharmStoreDeployType defines a class for resolving and deploying charm
-    store charms and bundle.
-    """
-
-    def __init__(self, charmstore, get_series):
-        self.charmstore = charmstore
-        self.get_series = get_series
-
-    @staticmethod
-    def _default_app_name(meta):
-        suggested_name = meta.get('charm-metadata', {}).get('Name')
-        return suggested_name or meta.get('id', {}).get('Name')
-
-    async def resolve(self, url, architecture, app_name=None, channel=None, series=None, entity_url=None):
-        """resolve attempts to resolve charmstore charms or bundles. A request
-        to the charmstore is required to get more information about the
-        underlying identifier.
-        """
-
-        result = await self.charmstore.entity(str(url),
-                                              channel=channel,
-                                              include_stats=False)
-
-        identifier = result['Id']
-        is_bundle = url.series == "bundle" or url.parse(identifier).series == "bundle"
-        if not series:
-            series = "bundle" if is_bundle else self.get_series(entity_url, result)
-
-        if app_name is None and not is_bundle:
-            app_name = self._default_app_name(result['Meta'])
-
-        origin = client.CharmOrigin(source="charm-store",
-                                    architecture=architecture,
-                                    risk=channel,
-                                    series=series)
-
-        return DeployTypeResult(
-            identifier=identifier,
-            app_name=app_name,
-            origin=origin,
-            is_bundle=is_bundle,
-        )
-
-
 class CharmhubDeployType:
     """CharmhubDeployType defines a class for resolving and deploying charmhub
     charms and bundles.
@@ -618,11 +571,9 @@ def __init__(
         self._watch_stopped.set()
 
         self._charmhub = CharmHub(self)
-        self._charmstore = CharmStore()
 
         self.deploy_types = {
             "local": LocalDeployType(),
-            "cs": CharmStoreDeployType(self._charmstore, self._get_series),
             "ch": CharmhubDeployType(self._resolve_charm),
         }
 
@@ -1107,10 +1058,6 @@ def charmhub(self):
         """
         return self._charmhub
 
-    @property
-    def charmstore(self):
-        return self._charmstore
-
     @property
     def name(self):
         """Return the name of this model
@@ -1653,21 +1600,6 @@ async def debug_log(
         }
         await self.connect(debug_log_conn=target, debug_log_params=params)
 
-    def _get_series(self, entity_url, entity):
-        # try to get the series from the provided charm URL
-        parts = entity_url.split('/')
-
-        if len(parts) > 1:
-            # series was specified in the URL
-            return parts[0]
-        # series was not supplied at all, so use the newest
-        # supported series according to the charm store
-        ss = entity['Meta'].get('supported-series')
-        if not ss:
-            log.error("Entity {} has no 'supported-series' in {}".format(entity_url, entity))
-            raise JujuError("Unable to determine series for {}".format(entity_url))
-        return ss['SupportedSeries'][0]
-
     async def deploy(
             self, entity_url, application_name=None, bind=None,
             channel=None, config=None, constraints=None, force=False,
@@ -1733,7 +1665,7 @@ async def deploy(
         architecture = await self._resolve_architecture(url)
 
         if str(url.schema) not in self.deploy_types:
-            raise JujuError("unknown deploy type {}, expected charmhub, charmstore or local".format(url.schema))
+            raise JujuError("unknown deploy type {}, expected charmhub or local".format(url.schema))
 
         res = await self.deploy_types[str(url.schema)].resolve(url, architecture, application_name, channel, series, entity_url)
 
@@ -1782,9 +1714,6 @@ async def deploy(
                             raise JujuError("cannot use num_units with subordinate application")
                         num_units = 0
 
-                if Schema.CHARM_STORE.matches(url.schema):
-                    resources = await self._add_store_resources(res.app_name,
-                                                                identifier)
             else:
                 # We have a local charm dir that needs to be uploaded
                 charm_dir = os.path.abspath(os.path.expanduser(identifier))
@@ -1869,18 +1798,11 @@ async def _resolve_charm(self, url, origin):
         #  origin should be set (including the base) before calling this,
         #  though all tests need to run (in earlier versions too) before
         #  committing to make sure there's no regression
-        if Schema.CHARM_STORE.matches(url.schema):
-            source = "charm-store"
-        else:
-            source = "charm-hub"
+        source = "charm-hub"
 
-        resolve_origin = {
-            'source': source,
-            'architecture': origin.architecture,
-            'track': origin.track,
-            'risk': origin.risk,
-        }
-        resolve_origin['base'] = origin.base
+        resolve_origin = {'source': source, 'architecture': origin.architecture,
+                          'track': origin.track, 'risk': origin.risk,
+                          'base': origin.base}
 
         resp = await charms_facade.ResolveCharms(resolve=[{
             'reference': str(url),
@@ -1951,48 +1873,6 @@ async def _add_charmhub_resources(self, application,
 
         return resource_map
 
-    async def _add_store_resources(self, application, entity_url,
-                                   overrides=None):
-        entity = await self.charmstore.entity(entity_url,
-                                              include_stats=False)
-        resources = [
-            {
-                'description': resource['Description'],
-                'fingerprint': resource['Fingerprint'],
-                'name': resource['Name'],
-                'path': resource['Path'],
-                'revision': resource['Revision'],
-                'size': resource['Size'],
-                'type_': resource['Type'],
-                'origin': 'store',
-            } for resource in entity['Meta'].get('resources', [])
-        ]
-
-        if overrides:
-            names = {r['name'] for r in resources}
-            unknown = overrides.keys() - names
-            if unknown:
-                raise JujuError('Unrecognized resource{}: {}'.format(
-                    's' if len(unknown) > 1 else '',
-                    ', '.join(unknown)))
-            for resource in resources:
-                if resource['name'] in overrides:
-                    resource['revision'] = overrides[resource['name']]
-
-        if not resources:
-            return None
-
-        resources_facade = client.ResourcesFacade.from_connection(
-            self.connection())
-        response = await resources_facade.AddPendingResources(
-            application_tag=tag.application(application),
-            charm_url=entity_url,
-            resources=[client.CharmResource(**resource) for resource in resources])
-        resource_map = {resource['name']: pid
-                        for resource, pid
-                        in zip(resources, response.pending_ids)}
-        return resource_map
-
     async def add_local_resources(self, application, entity_url, metadata, resources):
         if not resources:
             return None