← Back to branch summary

~unity-2d-team/unity-2d/Shell-MultiMonitor

« back to all changes in this revision

Viewing changes to grackle/model.py

  • Committer: William Grant
  • Date: 2012-04-20 02:20:58 UTC
  • mfrom: (6.1.70 trunk)
  • Revision ID: william.grant@canonical.com-20120420022058-3nkracsmlg7akydu
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
grackle/model.py
14
14
# License along with this program. If not, see
15
15
# <http://www.gnu.org/licenses/>.
16
16
 
 
17
import calendar
17
18
import datetime
18
 
import dateutil.tz
19
19
import email.parser
20
20
from email.utils import parsedate_tz
 
21
import functools
21
22
import logging
22
 
import time
23
23
import uuid
24
24
 
25
 
import pycassa
 
25
import dateutil.tz
 
26
import pycassa.pool
26
27
from pycassa.system_manager import (
27
28
    LEXICAL_UUID_TYPE,
28
29
    SystemManager,
85
86
 
86
87
 
87
88
def _utc_timestamp(dt):
88
 
    return time.mktime(_utc_datetime(dt).timetuple()) - time.timezone
 
89
    return calendar.timegm(_utc_datetime(dt).timetuple())
89
90
 
90
91
 
91
92
def _utc_timeuuid(dt, lowest_val=True):
104
105
    return a
105
106
 
106
107
 
 
108
def _make_bounds(memo, range_start, range_finish, backward):
 
109
    start = finish = ''
 
110
    if memo != '':
 
111
        memo = uuid.UUID(memo)
 
112
    if backward:
 
113
        finish = memo
 
114
    else:
 
115
        start = memo
 
116
    if range_start is not None:
 
117
        start = _bound_timeuuid(
 
118
            start, _utc_timeuuid(range_start), max=True)
 
119
    if range_finish is not None:
 
120
        finish = _bound_timeuuid(
 
121
            finish, _utc_timeuuid(range_finish, lowest_val=False))
 
122
    return memo, start, finish
 
123
 
 
124
 
 
125
LEGAL_HEADERS = set([
 
126
    'date', 'from', 'subject', 'message-id',
 
127
    ])
 
128
 
 
129
 
 
130
def _format_message(message, headers=[], include_raw=False):
 
131
    data = {}
 
132
 
 
133
    if headers:
 
134
        assert not set(headers).difference(LEGAL_HEADERS)
 
135
        hdict = {}
 
136
        for header in headers:
 
137
            hdict[header] = message.get(header)
 
138
        data['headers'] = hdict
 
139
 
 
140
    if include_raw:
 
141
        data['raw'] = message['raw']
 
142
 
 
143
    return data
 
144
 
 
145
 
107
146
class CassandraConnection(object):
108
147
 
109
 
    def __init__(self, keyspace, host):
 
148
    def __init__(self, keyspace, hosts):
110
149
        self._keyspace = keyspace
111
 
        self._host = host
 
150
        self._hosts = hosts
112
151
        self._connection = self._connect()
 
152
        self._pool = self._connect()
113
153
        self.messages = self._column_family('message')
114
154
        self.archive_messages = self._column_family('archive_message')
115
155
 
116
156
    def _connect(self):
117
 
        return pycassa.connect(self._keyspace, self._host)
 
157
        return pycassa.pool.ConnectionPool(self._keyspace, self._hosts)
118
158
 
119
159
    def _column_family(self, name):
120
 
        return pycassa.ColumnFamily(self._connection, name)
 
160
        return pycassa.ColumnFamily(self._pool, name)
121
161
 
122
162
    def add_message(self, archive_uuid, message):
123
163
        message_uuid = uuid.uuid4()
124
164
        message_date, message_dict = _parse_message(message)
125
 
        message_dict['content'] = message
 
165
        message_dict['raw'] = message
126
166
        message_dict['date_created'] = (
127
167
            datetime.datetime.utcnow().isoformat() + 'Z')
128
168
        self.messages.insert(message_uuid, message_dict)
134
174
            % (message_dict.get('message-id', None), archive_uuid))
135
175
        return message_uuid
136
176
 
137
 
    def _format_message(self, message):
138
 
        return {
139
 
            'date': message.get('date'),
140
 
            'from': message.get('from'),
141
 
            'subject': message.get('subject'),
142
 
            'message-id': message.get('message-id'),
143
 
            }
144
 
 
145
177
    def _trim(self, sequence, end):
146
178
        """Return the sequence with one of the ends trimmed.
147
179
 
154
186
            return sequence[1:]
155
187
 
156
188
    def get_messages(self, archive_uuid, order, count, memo, backward=False,
157
 
                     start_date=None, finish_date=None):
 
189
                     start_date=None, finish_date=None, format='all',
 
190
                     headers=['from', 'date', 'subject', 'message-id']):
158
191
        if order in ("date", "-date"):
159
192
            reversed = order[0] == '-'
160
193
        else:
161
194
            raise AssertionError("Unsupported order.")
162
 
        if memo != '':
163
 
            memo = uuid.UUID(memo)
164
 
        if backward:
165
 
            start = ''
166
 
            finish = memo
167
 
        else:
168
 
            start = memo
169
 
            finish = ''
170
 
        if start_date is not None:
171
 
            start = _bound_timeuuid(
172
 
                start, _utc_timeuuid(start_date, lowest_val=False), max=True)
173
 
        if finish_date is not None:
174
 
            finish = _bound_timeuuid(
175
 
                finish, _utc_timeuuid(finish_date, lowest_val=False))
 
195
 
 
196
        memo, start, finish = _make_bounds(
 
197
            memo, start_date, finish_date, backward)
176
198
 
177
199
        # Get up to n+1 messages from the memo: the last item of the
178
200
        # previous batch (because that's where the memo starts) + this
197
219
 
198
220
        # We've narrowed down the message references. Fetch the messages.
199
221
        ids = [v for k, v in pairs]
200
 
        messages = self.messages.multiget(
201
 
            ids, columns=['date', 'from', 'subject', 'message-id'])
 
222
        formatter = functools.partial(
 
223
            _format_message, headers=headers, include_raw=True)
 
224
        # XXX: No need to get all columns. Restrict based on format.
 
225
        messages = self.messages.multiget(ids)
202
226
 
203
227
        return (
204
228
            str(pairs[0][0]),
205
 
            [self._format_message(messages[id]) for id in ids],
 
229
            [formatter(messages[id]) for id in ids],
206
230
            str(pairs[-1][0]),
207
231
            )