~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-19 00:17:59 UTC
  • mfrom: (33.1.3 doc-updates)
  • Revision ID: tarmac-20110819001759-u3vpt3olpzs1g2xg
Backend module cleanup.

Show diffs side-by-side

added added

removed removed

Lines of Context:
31
31
        super(Backend, self).__init__(config)
32
32
        self.accounts = Accounts()
33
33
 
34
 
    def delete_accounts(self, filters={}):
35
 
        if len(filters) == 0:
 
34
    def delete_accounts(self, filters=None):
 
35
        if filters is None or len(filters) == 0:
36
36
            self.accounts.reset()
37
37
            return
38
38
        detail = self._get_detail(filters)
41
41
            if detail is not None:
42
42
                yield account.detail(detail)
43
43
 
44
 
    def get_accounts(self, filters={}):
 
44
    def get_accounts(self, filters=None):
45
45
        detail = self._get_detail(filters, 'id')
46
46
        for account in self.accounts.iter(filters):
47
47
            if detail is not None:
48
48
                yield account.detail(detail)
49
49
 
50
 
    def delete_queues(self, account, filters={}):
 
50
    def delete_queues(self, account, filters=None):
51
51
        account = self.accounts.get(account)
52
 
        if len(filters) == 0:
 
52
        if filters is None or len(filters) == 0:
53
53
            account.queues.reset()
54
54
        else:
55
55
            detail = self._get_detail(filters)
60
60
        if account.queues.count() == 0:
61
61
            self.accounts.delete(account.id)
62
62
 
63
 
    def get_queues(self, account, filters={}):
 
63
    def get_queues(self, account, filters=None):
64
64
        account = self.accounts.get(account)
65
65
        detail = self._get_detail(filters, 'id')
66
66
        for queue in account.queues.iter(filters):
68
68
                yield queue.detail(detail)
69
69
 
70
70
    @burrow.backend.wait_without_attributes
71
 
    def delete_messages(self, account, queue, filters={}):
 
71
    def delete_messages(self, account, queue, filters=None):
72
72
        account, queue = self.accounts.get_queue(account, queue)
73
73
        detail = self._get_message_detail(filters)
74
74
        for message in queue.messages.iter(filters):
79
79
            self.accounts.delete_queue(account.id, queue.id)
80
80
 
81
81
    @burrow.backend.wait_without_attributes
82
 
    def get_messages(self, account, queue, filters={}):
 
82
    def get_messages(self, account, queue, filters=None):
83
83
        account, queue = self.accounts.get_queue(account, queue)
84
84
        detail = self._get_message_detail(filters, 'all')
85
85
        for message in queue.messages.iter(filters):
87
87
                yield message.detail(detail)
88
88
 
89
89
    @burrow.backend.wait_with_attributes
90
 
    def update_messages(self, account, queue, attributes, filters={}):
 
90
    def update_messages(self, account, queue, attributes, filters=None):
91
91
        account, queue = self.accounts.get_queue(account, queue)
92
92
        notify = False
93
93
        ttl, hide = self._get_attributes(attributes)
102
102
            if detail is not None:
103
103
                yield message.detail(detail)
104
104
        if notify:
105
 
            self._notify(account.id, queue.id)
 
105
            self.notify(account.id, queue.id)
106
106
 
107
 
    def create_message(self, account, queue, message, body, attributes={}):
 
107
    def create_message(self, account, queue, message, body, attributes=None):
108
108
        account, queue = self.accounts.get_queue(account, queue, True)
109
109
        ttl, hide = self._get_attributes(attributes, ttl=0, hide=0)
110
110
        try:
117
117
        message.hide = hide
118
118
        message.body = body
119
119
        if created or hide == 0:
120
 
            self._notify(account.id, queue.id)
 
120
            self.notify(account.id, queue.id)
121
121
        return created
122
122
 
123
 
    def delete_message(self, account, queue, message, filters={}):
 
123
    def delete_message(self, account, queue, message, filters=None):
124
124
        account, queue = self.accounts.get_queue(account, queue)
125
125
        message = queue.messages.get(message)
126
126
        detail = self._get_message_detail(filters)
129
129
            self.accounts.delete_queue(account.id, queue.id)
130
130
        return message.detail(detail)
131
131
 
132
 
    def get_message(self, account, queue, message, filters={}):
 
132
    def get_message(self, account, queue, message, filters=None):
133
133
        account, queue = self.accounts.get_queue(account, queue)
134
134
        message = queue.messages.get(message)
135
135
        detail = self._get_message_detail(filters, 'all')
136
136
        return message.detail(detail)
137
137
 
138
 
    def update_message(self, account, queue, message, attributes, filters={}):
 
138
    def update_message(self, account, queue, message, attributes,
 
139
        filters=None):
139
140
        account, queue = self.accounts.get_queue(account, queue)
140
141
        message = queue.messages.get(message)
141
142
        ttl, hide = self._get_attributes(attributes)
145
146
        if hide is not None:
146
147
            message.hide = hide
147
148
            if hide == 0:
148
 
                self._notify(account.id, queue.id)
 
149
                self.notify(account.id, queue.id)
149
150
        return message.detail(detail)
150
151
 
151
152
    def clean(self):
160
161
                        message.hide = 0
161
162
                        notify = True
162
163
                if notify:
163
 
                    self._notify(account.id, queue.id)
 
164
                    self.notify(account.id, queue.id)
164
165
                if queue.messages.count() == 0:
165
166
                    self.accounts.delete_queue(account.id, queue.id)
166
167
 
184
185
class IndexedList(object):
185
186
    '''Class for managing an indexed linked list.'''
186
187
 
 
188
    item_class = Item
 
189
 
187
190
    def __init__(self):
188
191
        self.first = None
189
192
        self.last = None
220
223
            return self.add(self.item_class(id))
221
224
        raise burrow.backend.NotFound()
222
225
 
223
 
    def iter(self, filters={}):
224
 
        marker = filters.get('marker', None)
 
226
    def iter(self, filters=None):
 
227
        if filters is None:
 
228
            marker = None
 
229
            limit = None
 
230
        else:
 
231
            marker = filters.get('marker', None)
 
232
            limit = filters.get('limit', None)
225
233
        if marker is not None and marker in self.index:
226
234
            item = self.index[marker].next
227
235
        else:
228
236
            item = self.first
229
237
        if item is None:
230
238
            raise burrow.backend.NotFound()
231
 
        limit = filters.get('limit', None)
232
239
        while item is not None:
233
240
            yield item
234
241
            if limit:
315
322
 
316
323
    item_class = Message
317
324
 
318
 
    def iter(self, filters={}):
319
 
        marker = filters.get('marker', None)
 
325
    def iter(self, filters=None):
 
326
        if filters is None:
 
327
            marker = None
 
328
            limit = None
 
329
            match_hidden = False
 
330
        else:
 
331
            marker = filters.get('marker', None)
 
332
            limit = filters.get('limit', None)
 
333
            match_hidden = filters.get('match_hidden', False)
320
334
        if marker is not None and marker in self.index:
321
335
            item = self.index[marker].next
322
336
        else:
323
337
            item = self.first
324
 
        limit = filters.get('limit', None)
325
 
        match_hidden = filters.get('match_hidden', False)
326
338
        count = 0
327
339
        while item is not None:
328
340
            if match_hidden or item.hide == 0: