Update Keystone core to Mitaka.

Change-Id: Ia10d6add16f4a9d25d1f42d420661c46332e69db

6 files changed, 59 insertions, 438 deletions

diff --git a/keystone-moon/keystone/contrib/endpoint_filter/__init__.py b/keystone-moon/keystone/contrib/endpoint_filter/__init__.py
index 72508c3e..e69de29b 100644
--- a/keystone-moon/keystone/contrib/endpoint_filter/__init__.py
+++ b/keystone-moon/keystone/contrib/endpoint_filter/__init__.py
@@ -1,15 +0,0 @@
-# Copyright 2013 OpenStack Foundation
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License. You may obtain
-# a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-# License for the specific language governing permissions and limitations
-# under the License.
-
-from keystone.contrib.endpoint_filter.core import *  # noqa
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)
diff --git a/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/001_add_endpoint_filtering_table.py b/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/001_add_endpoint_filtering_table.py
index 2aa93a86..ac0a30cc 100644
--- a/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/001_add_endpoint_filtering_table.py
+++ b/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/001_add_endpoint_filtering_table.py
@@ -12,27 +12,8 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-import sqlalchemy as sql
+from keystone import exception
 
 
 def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine; bind
-    # migrate_engine to your metadata
-    meta = sql.MetaData()
-    meta.bind = migrate_engine
-
-    endpoint_filtering_table = sql.Table(
-        'project_endpoint',
-        meta,
-        sql.Column(
-            'endpoint_id',
-            sql.String(64),
-            primary_key=True,
-            nullable=False),
-        sql.Column(
-            'project_id',
-            sql.String(64),
-            primary_key=True,
-            nullable=False))
-
-    endpoint_filtering_table.create(migrate_engine, checkfirst=True)
+    raise exception.MigrationMovedFailure(extension='endpoint_filter')
diff --git a/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/002_add_endpoint_groups.py b/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/002_add_endpoint_groups.py
index 2c218b0d..ac5aa5b3 100644
--- a/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/002_add_endpoint_groups.py
+++ b/keystone-moon/keystone/contrib/endpoint_filter/migrate_repo/versions/002_add_endpoint_groups.py
@@ -12,30 +12,8 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-import sqlalchemy as sql
+from keystone import exception
 
 
 def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine; bind
-    # migrate_engine to your metadata
-    meta = sql.MetaData()
-    meta.bind = migrate_engine
-
-    endpoint_group_table = sql.Table(
-        'endpoint_group',
-        meta,
-        sql.Column('id', sql.String(64), primary_key=True),
-        sql.Column('name', sql.String(255), nullable=False),
-        sql.Column('description', sql.Text, nullable=True),
-        sql.Column('filters', sql.Text(), nullable=False))
-    endpoint_group_table.create(migrate_engine, checkfirst=True)
-
-    project_endpoint_group_table = sql.Table(
-        'project_endpoint_group',
-        meta,
-        sql.Column('endpoint_group_id', sql.String(64),
-                   sql.ForeignKey('endpoint_group.id'), nullable=False),
-        sql.Column('project_id', sql.String(64), nullable=False),
-        sql.PrimaryKeyConstraint('endpoint_group_id',
-                                 'project_id'))
-    project_endpoint_group_table.create(migrate_engine, checkfirst=True)
+    raise exception.MigrationMovedFailure(extension='endpoint_filter')
diff --git a/keystone-moon/keystone/contrib/endpoint_filter/routers.py b/keystone-moon/keystone/contrib/endpoint_filter/routers.py
index 285b9df2..f75110f9 100644
--- a/keystone-moon/keystone/contrib/endpoint_filter/routers.py
+++ b/keystone-moon/keystone/contrib/endpoint_filter/routers.py
@@ -12,151 +12,22 @@
 # License for the specific language governing permissions and limitations
 # under the License.
 
-import functools
+from oslo_log import log
+from oslo_log import versionutils
 
-from keystone.common import json_home
 from keystone.common import wsgi
-from keystone.contrib.endpoint_filter import controllers
+from keystone.i18n import _
 
 
-build_resource_relation = functools.partial(
-    json_home.build_v3_extension_resource_relation,
-    extension_name='OS-EP-FILTER', extension_version='1.0')
+LOG = log.getLogger(__name__)
 
-build_parameter_relation = functools.partial(
-    json_home.build_v3_extension_parameter_relation,
-    extension_name='OS-EP-FILTER', extension_version='1.0')
 
-ENDPOINT_GROUP_PARAMETER_RELATION = build_parameter_relation(
-    parameter_name='endpoint_group_id')
+class EndpointFilterExtension(wsgi.Middleware):
 
-
-class EndpointFilterExtension(wsgi.V3ExtensionRouter):
-    """API Endpoints for the Endpoint Filter extension.
-
-    The API looks like::
-
-        PUT /OS-EP-FILTER/projects/{project_id}/endpoints/{endpoint_id}
-        GET /OS-EP-FILTER/projects/{project_id}/endpoints/{endpoint_id}
-        HEAD /OS-EP-FILTER/projects/{project_id}/endpoints/{endpoint_id}
-        DELETE /OS-EP-FILTER/projects/{project_id}/endpoints/{endpoint_id}
-        GET /OS-EP-FILTER/endpoints/{endpoint_id}/projects
-        GET /OS-EP-FILTER/projects/{project_id}/endpoints
-        GET /OS-EP-FILTER/projects/{project_id}/endpoint_groups
-
-        GET /OS-EP-FILTER/endpoint_groups
-        POST /OS-EP-FILTER/endpoint_groups
-        GET /OS-EP-FILTER/endpoint_groups/{endpoint_group_id}
-        HEAD /OS-EP-FILTER/endpoint_groups/{endpoint_group_id}
-        PATCH /OS-EP-FILTER/endpoint_groups/{endpoint_group_id}
-        DELETE /OS-EP-FILTER/endpoint_groups/{endpoint_group_id}
-
-        GET /OS-EP-FILTER/endpoint_groups/{endpoint_group_id}/projects
-        GET /OS-EP-FILTER/endpoint_groups/{endpoint_group_id}/endpoints
-
-        PUT /OS-EP-FILTER/endpoint_groups/{endpoint_group}/projects/
-            {project_id}
-        GET /OS-EP-FILTER/endpoint_groups/{endpoint_group}/projects/
-            {project_id}
-        HEAD /OS-EP-FILTER/endpoint_groups/{endpoint_group}/projects/
-            {project_id}
-        DELETE /OS-EP-FILTER/endpoint_groups/{endpoint_group}/projects/
-            {project_id}
-
-    """
-    PATH_PREFIX = '/OS-EP-FILTER'
-    PATH_PROJECT_ENDPOINT = '/projects/{project_id}/endpoints/{endpoint_id}'
-    PATH_ENDPOINT_GROUPS = '/endpoint_groups/{endpoint_group_id}'
-    PATH_ENDPOINT_GROUP_PROJECTS = PATH_ENDPOINT_GROUPS + (
-        '/projects/{project_id}')
-
-    def add_routes(self, mapper):
-        endpoint_filter_controller = controllers.EndpointFilterV3Controller()
-        endpoint_group_controller = controllers.EndpointGroupV3Controller()
-        project_endpoint_group_controller = (
-            controllers.ProjectEndpointGroupV3Controller())
-
-        self._add_resource(
-            mapper, endpoint_filter_controller,
-            path=self.PATH_PREFIX + '/endpoints/{endpoint_id}/projects',
-            get_action='list_projects_for_endpoint',
-            rel=build_resource_relation(resource_name='endpoint_projects'),
-            path_vars={
-                'endpoint_id': json_home.Parameters.ENDPOINT_ID,
-            })
-        self._add_resource(
-            mapper, endpoint_filter_controller,
-            path=self.PATH_PREFIX + self.PATH_PROJECT_ENDPOINT,
-            get_head_action='check_endpoint_in_project',
-            put_action='add_endpoint_to_project',
-            delete_action='remove_endpoint_from_project',
-            rel=build_resource_relation(resource_name='project_endpoint'),
-            path_vars={
-                'endpoint_id': json_home.Parameters.ENDPOINT_ID,
-                'project_id': json_home.Parameters.PROJECT_ID,
-            })
-        self._add_resource(
-            mapper, endpoint_filter_controller,
-            path=self.PATH_PREFIX + '/projects/{project_id}/endpoints',
-            get_action='list_endpoints_for_project',
-            rel=build_resource_relation(resource_name='project_endpoints'),
-            path_vars={
-                'project_id': json_home.Parameters.PROJECT_ID,
-            })
-        self._add_resource(
-            mapper, endpoint_group_controller,
-            path=self.PATH_PREFIX + '/projects/{project_id}/endpoint_groups',
-            get_action='list_endpoint_groups_for_project',
-            rel=build_resource_relation(
-                resource_name='project_endpoint_groups'),
-            path_vars={
-                'project_id': json_home.Parameters.PROJECT_ID,
-            })
-        self._add_resource(
-            mapper, endpoint_group_controller,
-            path=self.PATH_PREFIX + '/endpoint_groups',
-            get_action='list_endpoint_groups',
-            post_action='create_endpoint_group',
-            rel=build_resource_relation(resource_name='endpoint_groups'))
-        self._add_resource(
-            mapper, endpoint_group_controller,
-            path=self.PATH_PREFIX + self.PATH_ENDPOINT_GROUPS,
-            get_head_action='get_endpoint_group',
-            patch_action='update_endpoint_group',
-            delete_action='delete_endpoint_group',
-            rel=build_resource_relation(resource_name='endpoint_group'),
-            path_vars={
-                'endpoint_group_id': ENDPOINT_GROUP_PARAMETER_RELATION
-            })
-        self._add_resource(
-            mapper, project_endpoint_group_controller,
-            path=self.PATH_PREFIX + self.PATH_ENDPOINT_GROUP_PROJECTS,
-            get_head_action='get_endpoint_group_in_project',
-            put_action='add_endpoint_group_to_project',
-            delete_action='remove_endpoint_group_from_project',
-            rel=build_resource_relation(
-                resource_name='endpoint_group_to_project_association'),
-            path_vars={
-                'project_id': json_home.Parameters.PROJECT_ID,
-                'endpoint_group_id': ENDPOINT_GROUP_PARAMETER_RELATION
-            })
-        self._add_resource(
-            mapper, endpoint_group_controller,
-            path=self.PATH_PREFIX + self.PATH_ENDPOINT_GROUPS + (
-                '/projects'),
-            get_action='list_projects_associated_with_endpoint_group',
-            rel=build_resource_relation(
-                resource_name='projects_associated_with_endpoint_group'),
-            path_vars={
-                'endpoint_group_id': ENDPOINT_GROUP_PARAMETER_RELATION
-            })
-        self._add_resource(
-            mapper, endpoint_group_controller,
-            path=self.PATH_PREFIX + self.PATH_ENDPOINT_GROUPS + (
-                '/endpoints'),
-            get_action='list_endpoints_associated_with_endpoint_group',
-            rel=build_resource_relation(
-                resource_name='endpoints_in_endpoint_group'),
-            path_vars={
-                'endpoint_group_id': ENDPOINT_GROUP_PARAMETER_RELATION
-            })
+    def __init__(self, *args, **kwargs):
+        super(EndpointFilterExtension, self).__init__(*args, **kwargs)
+        msg = _("Remove endpoint_filter_extension from the paste pipeline, "
+                "the endpoint filter extension is now always available. "
+                "Update the [pipeline:api_v3] section in keystone-paste.ini "
+                "accordingly as it will be removed in the O release.")
+        versionutils.report_deprecated_feature(LOG, msg)