~hudson-openstack/burrow/trunk

« back to all changes in this revision

Viewing changes to burrow/backend/memory.py

  • Committer: Tarmac
  • Author(s): Eric Day
  • Date: 2011-08-10 00:02:50 UTC
  • mfrom: (16.3.22 backend-unittests)
  • Revision ID: tarmac-20110810000250-c3r1k3ws01uy2igv
Backend unittest and cleanup party!

Show diffs side-by-side

added added

removed removed

Lines of Context:
22
22
class Backend(burrow.backend.Backend):
23
23
    '''This backend stores all data using native Python data
24
24
    structures. It uses a linked list of objects to store data
25
 
    (accounts, queues, and messages) with a dict as a secondary index
26
 
    into this list. This is required so we can have O(1) appends,
 
25
    (accounts, queues, and messages) with a dictionary as a secondary
 
26
    index into this list. This is required so we can have O(1) appends,
27
27
    deletes, and lookups by id, along with easy traversal starting
28
28
    anywhere in the list.'''
29
29
 
49
49
 
50
50
    def delete_queues(self, account, filters={}):
51
51
        account = self.accounts.get(account)
52
 
        if account is None:
53
 
            raise burrow.backend.NotFound()
54
52
        if len(filters) == 0:
55
53
            account.queues.reset()
56
54
        else:
64
62
 
65
63
    def get_queues(self, account, filters={}):
66
64
        account = self.accounts.get(account)
67
 
        if account is None:
68
 
            raise burrow.backend.NotFound()
69
65
        detail = self._get_detail(filters, 'id')
70
66
        for queue in account.queues.iter(filters):
71
67
            if detail is not None:
73
69
 
74
70
    def delete_messages(self, account, queue, filters={}):
75
71
        account, queue = self.accounts.get_queue(account, queue)
76
 
        if queue is None:
77
 
            raise burrow.backend.NotFound()
78
72
        detail = self._get_message_detail(filters)
79
73
        for message in queue.messages.iter(filters):
80
74
            queue.messages.delete(message.id)
85
79
 
86
80
    def get_messages(self, account, queue, filters={}):
87
81
        account, queue = self.accounts.get_queue(account, queue)
88
 
        if queue is None:
89
 
            raise burrow.backend.NotFound()
90
82
        detail = self._get_message_detail(filters, 'all')
91
83
        for message in queue.messages.iter(filters):
92
84
            if detail is not None:
93
85
                yield message.detail(detail)
94
86
 
95
 
    def update_messages(self, account, queue, attributes={}, filters={}):
 
87
    def update_messages(self, account, queue, attributes, filters={}):
96
88
        account, queue = self.accounts.get_queue(account, queue)
97
 
        if queue is None:
98
 
            raise burrow.backend.NotFound()
99
89
        notify = False
100
90
        ttl, hide = self._get_attributes(attributes)
101
91
        detail = self._get_message_detail(filters)
113
103
 
114
104
    def create_message(self, account, queue, message, body, attributes={}):
115
105
        account, queue = self.accounts.get_queue(account, queue, True)
116
 
        ttl, hide = self._get_attributes(attributes, default_ttl=0,
117
 
            default_hide=0)
118
 
        if queue.messages.get(message) is None:
 
106
        ttl, hide = self._get_attributes(attributes, ttl=0, hide=0)
 
107
        try:
 
108
            message = queue.messages.get(message)
 
109
            created = False
 
110
        except burrow.backend.NotFound:
 
111
            message = queue.messages.get(message, True)
119
112
            created = True
120
 
        else:
121
 
            created = False
122
 
        message = queue.messages.get(message, True)
123
113
        message.ttl = ttl
124
114
        message.hide = hide
125
115
        message.body = body
129
119
 
130
120
    def delete_message(self, account, queue, message, filters={}):
131
121
        account, queue = self.accounts.get_queue(account, queue)
132
 
        if queue is None:
133
 
            raise burrow.backend.NotFound()
134
122
        message = queue.messages.get(message)
135
 
        if message is None:
136
 
            raise burrow.backend.NotFound()
 
123
        detail = self._get_message_detail(filters)
137
124
        queue.messages.delete(message.id)
138
125
        if queue.messages.count() == 0:
139
126
            self.accounts.delete_queue(account.id, queue.id)
140
 
        return message.detail()
 
127
        return message.detail(detail)
141
128
 
142
129
    def get_message(self, account, queue, message, filters={}):
143
130
        account, queue = self.accounts.get_queue(account, queue)
144
 
        if queue is None:
145
 
            raise burrow.backend.NotFound()
146
131
        message = queue.messages.get(message)
147
 
        if message is None:
148
 
            raise burrow.backend.NotFound()
149
 
        return message.detail()
 
132
        detail = self._get_message_detail(filters, 'all')
 
133
        return message.detail(detail)
150
134
 
151
 
    def update_message(self, account, queue, message, attributes={},
152
 
        filters={}):
 
135
    def update_message(self, account, queue, message, attributes, filters={}):
153
136
        account, queue = self.accounts.get_queue(account, queue)
154
 
        if queue is None:
155
 
            raise burrow.backend.NotFound()
 
137
        message = queue.messages.get(message)
156
138
        ttl, hide = self._get_attributes(attributes)
157
 
        message = queue.messages.get(message)
158
 
        if message is None:
159
 
            raise burrow.backend.NotFound()
 
139
        detail = self._get_message_detail(filters)
160
140
        if ttl is not None:
161
141
            message.ttl = ttl
162
142
        if hide is not None:
163
143
            message.hide = hide
164
144
            if hide == 0:
165
145
                self.notify(account.id, queue.id)
166
 
        return message.detail()
 
146
        return message.detail(detail)
167
147
 
168
148
    def clean(self):
169
149
        now = int(time.time())
181
161
                if queue.messages.count() == 0:
182
162
                    self.accounts.delete_queue(account.id, queue.id)
183
163
 
184
 
    def _get_attributes(self, attributes, default_ttl=None, default_hide=None):
185
 
        ttl = attributes.get('ttl', default_ttl)
186
 
        if ttl is not None and ttl > 0:
187
 
            ttl += int(time.time())
188
 
        hide = attributes.get('hide', default_hide)
189
 
        if hide is not None and hide > 0:
190
 
            hide += int(time.time())
191
 
        return ttl, hide
192
 
 
193
 
    def _get_detail(self, filters, default=None):
194
 
        detail = filters.get('detail', default)
195
 
        if detail == 'none':
196
 
            detail = None
197
 
        elif detail is not None and detail not in ['id', 'all']:
198
 
            raise burrow.backend.BadDetail(detail)
199
 
        return detail
200
 
 
201
 
    def _get_message_detail(self, filters, default=None):
202
 
        detail = filters.get('detail', default)
203
 
        options = ['id', 'attributes', 'body', 'all']
204
 
        if detail == 'none':
205
 
            detail = None
206
 
        elif detail is not None and detail not in options:
207
 
            raise burrow.backend.BadDetail(detail)
208
 
        return detail
209
 
 
210
164
 
211
165
class Item(object):
212
166
    '''Object to represent elements in a indexed linked list.'''
217
171
        self.prev = None
218
172
 
219
173
    def detail(self, detail):
220
 
        if detail == 'all':
 
174
        if detail == 'id':
 
175
            return self.id
 
176
        elif detail == 'all':
221
177
            return dict(id=self.id)
222
 
        return self.id
 
178
        return None
223
179
 
224
180
 
225
181
class IndexedList(object):
259
215
            return self.index[id]
260
216
        elif create:
261
217
            return self.add(self.item_class(id))
262
 
        return None
 
218
        raise burrow.backend.NotFound()
263
219
 
264
220
    def iter(self, filters={}):
265
221
        marker = filters.get('marker', None)
310
266
        elif create:
311
267
            account = self.add(Account(account))
312
268
        else:
313
 
            return None, None
 
269
            raise burrow.backend.NotFound()
314
270
        return account, account.queues.get(queue, create)
315
271
 
316
272
 
347
303
            hide -= int(time.time())
348
304
        if detail == 'attributes':
349
305
            return dict(id=self.id, ttl=ttl, hide=hide)
350
 
        return dict(id=self.id, ttl=ttl, hide=hide, body=self.body)
 
306
        elif detail == 'all':
 
307
            return dict(id=self.id, ttl=ttl, hide=hide, body=self.body)
 
308
        return None
351
309
 
352
310
 
353
311
class Messages(IndexedList):