← Back to branch summary

~ubuntu-branches/ubuntu/saucy/keystone/saucy-proposed

« back to all changes in this revision

Viewing changes to keystone/backends/sqlalchemy/api/endpoint_template.py

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-08-23 10:18:22 UTC
  • Revision ID: james.westby@ubuntu.com-20110823101822-enve6zceb3lqhuvj
Tags: upstream-1.0~d4~20110823.1078
Import upstream version 1.0~d4~20110823.1078

Show diffs side-by-side

added added

removed removed

Lines of Context:
keystone/backends/sqlalchemy/api/endpoint_template.py
 
1
# vim: tabstop=4 shiftwidth=4 softtabstop=4
 
2
 
 
3
# Copyright 2010 OpenStack LLC.
 
4
# All Rights Reserved.
 
5
#
 
6
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
 
7
#    not use this file except in compliance with the License. You may obtain
 
8
#    a copy of the License at
 
9
#
 
10
#         http://www.apache.org/licenses/LICENSE-2.0
 
11
#
 
12
#    Unless required by applicable law or agreed to in writing, software
 
13
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 
14
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 
15
#    License for the specific language governing permissions and limitations
 
16
#    under the License.
 
17
 
 
18
from keystone.backends.sqlalchemy import get_session, models, aliased
 
19
from keystone.backends.api import BaseEndpointTemplateAPI
 
20
 
 
21
 
 
22
class EndpointTemplateAPI(BaseEndpointTemplateAPI):
 
23
    def create(self, values):
 
24
        endpoint_template = models.EndpointTemplates()
 
25
        endpoint_template.update(values)
 
26
        endpoint_template.save()
 
27
        return endpoint_template
 
28
 
 
29
    def update(self, id, values, session=None):
 
30
        if not session:
 
31
            session = get_session()
 
32
        with session.begin():
 
33
            endpoint_template_ref = self.get(id, session)
 
34
            endpoint_template_ref.update(values)
 
35
            endpoint_template_ref.save(session=session)
 
36
            return endpoint_template_ref
 
37
 
 
38
    def delete(self, id, session=None):
 
39
        if not session:
 
40
            session = get_session()
 
41
        with session.begin():
 
42
            endpoint_template = self.get(id, session)
 
43
            session.delete(endpoint_template)
 
44
 
 
45
    def get(self, id, session=None):
 
46
        if not session:
 
47
            session = get_session()
 
48
        result = session.query(models.EndpointTemplates).\
 
49
            filter_by(id=id).first()
 
50
        return result
 
51
 
 
52
    def get_all(self, session=None):
 
53
        if not session:
 
54
            session = get_session()
 
55
        return session.query(models.EndpointTemplates).all()
 
56
 
 
57
    def get_by_service(self, service_id, session=None):
 
58
        if not session:
 
59
            session = get_session()
 
60
        return session.query(models.EndpointTemplates).\
 
61
            filter_by(service=service_id).all()
 
62
 
 
63
    def get_page(self, marker, limit, session=None):
 
64
        if not session:
 
65
            session = get_session()
 
66
 
 
67
        if marker:
 
68
            return session.query(models.EndpointTemplates).\
 
69
                    filter("id>:marker").params(\
 
70
                    marker='%s' % marker).order_by(\
 
71
                    models.EndpointTemplates.id.desc()).limit(limit).all()
 
72
        else:
 
73
            return session.query(models.EndpointTemplates).order_by(\
 
74
                                models.EndpointTemplates.id.desc()).\
 
75
                                limit(limit).all()
 
76
 
 
77
    def get_page_markers(self, marker, limit, session=None):
 
78
        if not session:
 
79
            session = get_session()
 
80
        first = session.query(models.EndpointTemplates).order_by(\
 
81
                            models.EndpointTemplates.id).first()
 
82
        last = session.query(models.EndpointTemplates).order_by(\
 
83
                            models.EndpointTemplates.id.desc()).first()
 
84
        if first is None:
 
85
            return (None, None)
 
86
        if marker is None:
 
87
            marker = first.id
 
88
        next_page = session.query(models.EndpointTemplates).\
 
89
            filter("id > :marker").\
 
90
            params(marker='%s' % marker).\
 
91
            order_by(models.EndpointTemplates.id).\
 
92
            limit(limit).\
 
93
            all()
 
94
        prev_page = session.query(models.EndpointTemplates).\
 
95
            filter("id < :marker").\
 
96
            params(marker='%s' % marker).\
 
97
            order_by(models.EndpointTemplates.id.desc()).\
 
98
            limit(int(limit)).\
 
99
            all()
 
100
        if len(next_page) == 0:
 
101
            next_page = last
 
102
        else:
 
103
            for t in next_page:
 
104
                next_page = t
 
105
        if len(prev_page) == 0:
 
106
            prev_page = first
 
107
        else:
 
108
            for t in prev_page:
 
109
                prev_page = t
 
110
        if prev_page.id == marker:
 
111
            prev_page = None
 
112
        else:
 
113
            prev_page = prev_page.id
 
114
        if next_page.id == last.id:
 
115
            next_page = None
 
116
        else:
 
117
            next_page = next_page.id
 
118
        return (prev_page, next_page)
 
119
 
 
120
    def endpoint_get_by_tenant_get_page(self, tenant_id, marker, limit,
 
121
                                            session=None):
 
122
        if not session:
 
123
            session = get_session()
 
124
        if marker:
 
125
            return session.query(models.Endpoints).\
 
126
                filter(models.Endpoints.tenant_id == tenant_id).\
 
127
                filter("id >= :marker").params(
 
128
                marker='%s' % marker).order_by(
 
129
                models.Endpoints.id).limit(limit).all()
 
130
        else:
 
131
            return session.query(models.Endpoints).\
 
132
                filter(models.Endpoints.tenant_id == tenant_id).\
 
133
                order_by(models.Endpoints.id).limit(limit).all()
 
134
 
 
135
    def endpoint_get_by_tenant_get_page_markers(self, tenant_id, marker, limit,
 
136
                                                    session=None):
 
137
        if not session:
 
138
            session = get_session()
 
139
        tba = aliased(models.Endpoints)
 
140
        first = session.query(tba).\
 
141
                        filter(tba.tenant_id == tenant_id).\
 
142
                        order_by(tba.id).first()
 
143
        last = session.query(tba).\
 
144
                    filter(tba.tenant_id == tenant_id).\
 
145
                    order_by(tba.id.desc()).first()
 
146
        if first is None:
 
147
            return (None, None)
 
148
        if marker is None:
 
149
            marker = first.id
 
150
        next_page = session.query(tba).\
 
151
                    filter(tba.tenant_id == tenant_id).\
 
152
                    filter("id>=:marker").params(
 
153
                    marker='%s' % marker).order_by(
 
154
                    tba.id).limit(int(limit)).all()
 
155
 
 
156
        prev_page = session.query(tba).\
 
157
                        filter(tba.tenant_id == tenant_id).\
 
158
                        filter("id < :marker").params(
 
159
                        marker='%s' % marker).order_by(
 
160
                        tba.id).limit(int(limit) + 1).all()
 
161
        next_len = len(next_page)
 
162
        prev_len = len(prev_page)
 
163
 
 
164
        if next_len == 0:
 
165
            next_page = last
 
166
        else:
 
167
            for t in next_page:
 
168
                next_page = t
 
169
        if prev_len == 0:
 
170
            prev_page = first
 
171
        else:
 
172
            for t in prev_page:
 
173
                prev_page = t
 
174
        if first.id == marker:
 
175
            prev_page = None
 
176
        else:
 
177
            prev_page = prev_page.id
 
178
        if marker == last.id:
 
179
            next_page = None
 
180
        else:
 
181
            next_page = next_page.id
 
182
        return (prev_page, next_page)
 
183
 
 
184
    def endpoint_add(self, values):
 
185
        endpoints = models.Endpoints()
 
186
        endpoints.update(values)
 
187
        endpoints.save()
 
188
        return endpoints
 
189
 
 
190
    def endpoint_get(self, id, session=None):
 
191
        if not session:
 
192
            session = get_session()
 
193
        result = session.query(models.Endpoints).\
 
194
                        filter_by(id=id).first()
 
195
        return result
 
196
 
 
197
    def endpoint_get_by_tenant(self, tenant_id, session=None):
 
198
        if not session:
 
199
            session = get_session()
 
200
        result = session.query(models.Endpoints).\
 
201
                        filter_by(tenant_id=tenant_id).first()
 
202
        return result
 
203
 
 
204
    def endpoint_get_by_endpoint_template(
 
205
        self, endpoint_template_id, session=None):
 
206
        if not session:
 
207
            session = get_session()
 
208
        result = session.query(models.Endpoints).\
 
209
            filter_by(endpoint_template_id=endpoint_template_id).all()
 
210
        return result
 
211
 
 
212
    def endpoint_delete(self, id, session=None):
 
213
        if not session:
 
214
            session = get_session()
 
215
        with session.begin():
 
216
            endpoints = self.endpoint_get(id, session)
 
217
            if endpoints:
 
218
                session.delete(endpoints)
 
219
 
 
220
 
 
221
def get():
 
222
    return EndpointTemplateAPI()