Update Keystone core to Mitaka.

Change-Id: Ia10d6add16f4a9d25d1f42d420661c46332e69db

2 files changed, 43 insertions, 237 deletions

diff --git a/keystone-moon/keystone/contrib/endpoint_filter/backends/catalog_sql.py b/keystone-moon/keystone/contrib/endpoint_filter/backends/catalog_sql.py
index 22d5796a..ad39d045 100644
--- a/keystone-moon/keystone/contrib/endpoint_filter/backends/catalog_sql.py
+++ b/keystone-moon/keystone/contrib/endpoint_filter/backends/catalog_sql.py
@@ -17,52 +17,52 @@ from oslo_config import cfg
 from keystone.catalog.backends import sql
 from keystone.catalog import core as catalog_core
 from keystone.common import dependency
-from keystone import exception
 
 
 CONF = cfg.CONF
 
 
-@dependency.requires('endpoint_filter_api')
+@dependency.requires('catalog_api')
 class EndpointFilterCatalog(sql.Catalog):
     def get_v3_catalog(self, user_id, project_id):
         substitutions = dict(CONF.items())
-        substitutions.update({'tenant_id': project_id, 'user_id': user_id})
+        substitutions.update({
+            'tenant_id': project_id,
+            'project_id': project_id,
+            'user_id': user_id,
+        })
 
         services = {}
 
-        refs = self.endpoint_filter_api.list_endpoints_for_project(project_id)
+        dict_of_endpoint_refs = (self.catalog_api.
+                                 list_endpoints_for_project(project_id))
 
-        if (not refs and
+        if (not dict_of_endpoint_refs and
                 CONF.endpoint_filter.return_all_endpoints_if_no_filter):
             return super(EndpointFilterCatalog, self).get_v3_catalog(
                 user_id, project_id)
 
-        for entry in refs:
-            try:
-                endpoint = self.get_endpoint(entry['endpoint_id'])
-                if not endpoint['enabled']:
-                    # Skip disabled endpoints.
-                    continue
-                service_id = endpoint['service_id']
-                services.setdefault(
-                    service_id,
-                    self.get_service(service_id))
-                service = services[service_id]
-                del endpoint['service_id']
-                del endpoint['enabled']
-                del endpoint['legacy_endpoint_id']
-                endpoint['url'] = catalog_core.format_url(
-                    endpoint['url'], substitutions)
-                # populate filtered endpoints
-                if 'endpoints' in services[service_id]:
-                    service['endpoints'].append(endpoint)
-                else:
-                    service['endpoints'] = [endpoint]
-            except exception.EndpointNotFound:
-                # remove bad reference from association
-                self.endpoint_filter_api.remove_endpoint_from_project(
-                    entry['endpoint_id'], project_id)
+        for endpoint_id, endpoint in dict_of_endpoint_refs.items():
+            if not endpoint['enabled']:
+                # Skip disabled endpoints.
+                continue
+            service_id = endpoint['service_id']
+            services.setdefault(
+                service_id,
+                self.get_service(service_id))
+            service = services[service_id]
+            del endpoint['service_id']
+            del endpoint['enabled']
+            del endpoint['legacy_endpoint_id']
+            # Include deprecated region for backwards compatibility
+            endpoint['region'] = endpoint['region_id']
+            endpoint['url'] = catalog_core.format_url(
+                endpoint['url'], substitutions)
+            # populate filtered endpoints
+            if 'endpoints' in services[service_id]:
+                service['endpoints'].append(endpoint)
+            else:
+                service['endpoints'] = [endpoint]
 
         # format catalog
         catalog = []
@@ -70,6 +70,7 @@ class EndpointFilterCatalog(sql.Catalog):
             formatted_service = {}
             formatted_service['id'] = service['id']
             formatted_service['type'] = service['type']
+            formatted_service['name'] = service['name']
             formatted_service['endpoints'] = service['endpoints']
             catalog.append(formatted_service)
 
diff --git a/keystone-moon/keystone/contrib/endpoint_filter/backends/sql.py b/keystone-moon/keystone/contrib/endpoint_filter/backends/sql.py
index cf904268..484934bb 100644
--- a/keystone-moon/keystone/contrib/endpoint_filter/backends/sql.py
+++ b/keystone-moon/keystone/contrib/endpoint_filter/backends/sql.py
@@ -12,214 +12,19 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-from keystone.common import sql
-from keystone.contrib import endpoint_filter
-from keystone import exception
-from keystone.i18n import _
+from oslo_log import versionutils
 
+from keystone.catalog.backends import sql
 
-class ProjectEndpoint(sql.ModelBase, sql.ModelDictMixin):
-    """project-endpoint relationship table."""
-    __tablename__ = 'project_endpoint'
-    attributes = ['endpoint_id', 'project_id']
-    endpoint_id = sql.Column(sql.String(64),
-                             primary_key=True,
-                             nullable=False)
-    project_id = sql.Column(sql.String(64),
-                            primary_key=True,
-                            nullable=False)
+_OLD = 'keystone.contrib.endpoint_filter.backends.sql.EndpointFilter'
+_NEW = 'sql'
 
 
-class EndpointGroup(sql.ModelBase, sql.ModelDictMixin):
-    """Endpoint Groups table."""
-    __tablename__ = 'endpoint_group'
-    attributes = ['id', 'name', 'description', 'filters']
-    mutable_attributes = frozenset(['name', 'description', 'filters'])
-    id = sql.Column(sql.String(64), primary_key=True)
-    name = sql.Column(sql.String(255), nullable=False)
-    description = sql.Column(sql.Text, nullable=True)
-    filters = sql.Column(sql.JsonBlob(), nullable=False)
-
-
-class ProjectEndpointGroupMembership(sql.ModelBase, sql.ModelDictMixin):
-    """Project to Endpoint group relationship table."""
-    __tablename__ = 'project_endpoint_group'
-    attributes = ['endpoint_group_id', 'project_id']
-    endpoint_group_id = sql.Column(sql.String(64),
-                                   sql.ForeignKey('endpoint_group.id'),
-                                   nullable=False)
-    project_id = sql.Column(sql.String(64), nullable=False)
-    __table_args__ = (sql.PrimaryKeyConstraint('endpoint_group_id',
-                                               'project_id'), {})
-
-
-class EndpointFilter(endpoint_filter.EndpointFilterDriverV8):
-
-    @sql.handle_conflicts(conflict_type='project_endpoint')
-    def add_endpoint_to_project(self, endpoint_id, project_id):
-        session = sql.get_session()
-        with session.begin():
-            endpoint_filter_ref = ProjectEndpoint(endpoint_id=endpoint_id,
-                                                  project_id=project_id)
-            session.add(endpoint_filter_ref)
-
-    def _get_project_endpoint_ref(self, session, endpoint_id, project_id):
-        endpoint_filter_ref = session.query(ProjectEndpoint).get(
-            (endpoint_id, project_id))
-        if endpoint_filter_ref is None:
-            msg = _('Endpoint %(endpoint_id)s not found in project '
-                    '%(project_id)s') % {'endpoint_id': endpoint_id,
-                                         'project_id': project_id}
-            raise exception.NotFound(msg)
-        return endpoint_filter_ref
-
-    def check_endpoint_in_project(self, endpoint_id, project_id):
-        session = sql.get_session()
-        self._get_project_endpoint_ref(session, endpoint_id, project_id)
-
-    def remove_endpoint_from_project(self, endpoint_id, project_id):
-        session = sql.get_session()
-        endpoint_filter_ref = self._get_project_endpoint_ref(
-            session, endpoint_id, project_id)
-        with session.begin():
-            session.delete(endpoint_filter_ref)
-
-    def list_endpoints_for_project(self, project_id):
-        session = sql.get_session()
-        query = session.query(ProjectEndpoint)
-        query = query.filter_by(project_id=project_id)
-        endpoint_filter_refs = query.all()
-        return [ref.to_dict() for ref in endpoint_filter_refs]
-
-    def list_projects_for_endpoint(self, endpoint_id):
-        session = sql.get_session()
-        query = session.query(ProjectEndpoint)
-        query = query.filter_by(endpoint_id=endpoint_id)
-        endpoint_filter_refs = query.all()
-        return [ref.to_dict() for ref in endpoint_filter_refs]
-
-    def delete_association_by_endpoint(self, endpoint_id):
-        session = sql.get_session()
-        with session.begin():
-            query = session.query(ProjectEndpoint)
-            query = query.filter_by(endpoint_id=endpoint_id)
-            query.delete(synchronize_session=False)
-
-    def delete_association_by_project(self, project_id):
-        session = sql.get_session()
-        with session.begin():
-            query = session.query(ProjectEndpoint)
-            query = query.filter_by(project_id=project_id)
-            query.delete(synchronize_session=False)
-
-    def create_endpoint_group(self, endpoint_group_id, endpoint_group):
-        session = sql.get_session()
-        with session.begin():
-            endpoint_group_ref = EndpointGroup.from_dict(endpoint_group)
-            session.add(endpoint_group_ref)
-        return endpoint_group_ref.to_dict()
-
-    def _get_endpoint_group(self, session, endpoint_group_id):
-        endpoint_group_ref = session.query(EndpointGroup).get(
-            endpoint_group_id)
-        if endpoint_group_ref is None:
-            raise exception.EndpointGroupNotFound(
-                endpoint_group_id=endpoint_group_id)
-        return endpoint_group_ref
-
-    def get_endpoint_group(self, endpoint_group_id):
-        session = sql.get_session()
-        endpoint_group_ref = self._get_endpoint_group(session,
-                                                      endpoint_group_id)
-        return endpoint_group_ref.to_dict()
-
-    def update_endpoint_group(self, endpoint_group_id, endpoint_group):
-        session = sql.get_session()
-        with session.begin():
-            endpoint_group_ref = self._get_endpoint_group(session,
-                                                          endpoint_group_id)
-            old_endpoint_group = endpoint_group_ref.to_dict()
-            old_endpoint_group.update(endpoint_group)
-            new_endpoint_group = EndpointGroup.from_dict(old_endpoint_group)
-            for attr in EndpointGroup.mutable_attributes:
-                setattr(endpoint_group_ref, attr,
-                        getattr(new_endpoint_group, attr))
-        return endpoint_group_ref.to_dict()
-
-    def delete_endpoint_group(self, endpoint_group_id):
-        session = sql.get_session()
-        endpoint_group_ref = self._get_endpoint_group(session,
-                                                      endpoint_group_id)
-        with session.begin():
-            self._delete_endpoint_group_association_by_endpoint_group(
-                session, endpoint_group_id)
-            session.delete(endpoint_group_ref)
-
-    def get_endpoint_group_in_project(self, endpoint_group_id, project_id):
-        session = sql.get_session()
-        ref = self._get_endpoint_group_in_project(session,
-                                                  endpoint_group_id,
-                                                  project_id)
-        return ref.to_dict()
-
-    @sql.handle_conflicts(conflict_type='project_endpoint_group')
-    def add_endpoint_group_to_project(self, endpoint_group_id, project_id):
-        session = sql.get_session()
-
-        with session.begin():
-            # Create a new Project Endpoint group entity
-            endpoint_group_project_ref = ProjectEndpointGroupMembership(
-                endpoint_group_id=endpoint_group_id, project_id=project_id)
-            session.add(endpoint_group_project_ref)
-
-    def _get_endpoint_group_in_project(self, session,
-                                       endpoint_group_id, project_id):
-        endpoint_group_project_ref = session.query(
-            ProjectEndpointGroupMembership).get((endpoint_group_id,
-                                                 project_id))
-        if endpoint_group_project_ref is None:
-            msg = _('Endpoint Group Project Association not found')
-            raise exception.NotFound(msg)
-        else:
-            return endpoint_group_project_ref
-
-    def list_endpoint_groups(self):
-        session = sql.get_session()
-        query = session.query(EndpointGroup)
-        endpoint_group_refs = query.all()
-        return [e.to_dict() for e in endpoint_group_refs]
-
-    def list_endpoint_groups_for_project(self, project_id):
-        session = sql.get_session()
-        query = session.query(ProjectEndpointGroupMembership)
-        query = query.filter_by(project_id=project_id)
-        endpoint_group_refs = query.all()
-        return [ref.to_dict() for ref in endpoint_group_refs]
-
-    def remove_endpoint_group_from_project(self, endpoint_group_id,
-                                           project_id):
-        session = sql.get_session()
-        endpoint_group_project_ref = self._get_endpoint_group_in_project(
-            session, endpoint_group_id, project_id)
-        with session.begin():
-            session.delete(endpoint_group_project_ref)
-
-    def list_projects_associated_with_endpoint_group(self, endpoint_group_id):
-        session = sql.get_session()
-        query = session.query(ProjectEndpointGroupMembership)
-        query = query.filter_by(endpoint_group_id=endpoint_group_id)
-        endpoint_group_refs = query.all()
-        return [ref.to_dict() for ref in endpoint_group_refs]
-
-    def _delete_endpoint_group_association_by_endpoint_group(
-            self, session, endpoint_group_id):
-        query = session.query(ProjectEndpointGroupMembership)
-        query = query.filter_by(endpoint_group_id=endpoint_group_id)
-        query.delete()
-
-    def delete_endpoint_group_association_by_project(self, project_id):
-        session = sql.get_session()
-        with session.begin():
-            query = session.query(ProjectEndpointGroupMembership)
-            query = query.filter_by(project_id=project_id)
-            query.delete()
+class EndpointFilter(sql.Catalog):
+    @versionutils.deprecated(
+        as_of=versionutils.deprecated.MITAKA,
+        in_favor_of=_NEW,
+        what=_OLD,
+        remove_in=2)
+    def __init__(self, *args, **kwargs):
+        super(EndpointFilter, self).__init__(*args, **kwargs)