← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/changecache.py

  • Committer: Matt Nordhoff
  • Date: 2009-05-13 14:03:48 UTC
  • mto: (389.2.2 pep8-2009-10)
  • mto: This revision was merged to the branch mainline in revision 392.
  • Revision ID: mnordhoff@mattnordhoff.com-20090513140348-yn43gztulksm62e9
Always use a tuple in string formatting

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/changecache.py
17
17
#
18
18
 
19
19
"""
20
 
a cache for chewed-up "change" data structures, which are basically just a
21
 
different way of storing a revision.  the cache improves lookup times 10x
22
 
over bazaar's xml revision structure, though, so currently still worth doing.
 
20
a cache for chewed-up 'file change' data structures, which are basically just
 
21
a different way of storing a revision delta.  the cache improves lookup times
 
22
10x over bazaar's xml revision structure, though, so currently still worth
 
23
doing.
23
24
 
24
25
once a revision is committed in bazaar, it never changes, so once we have
25
26
cached a change, it's good forever.
26
27
"""
27
28
 
28
29
import cPickle
 
30
import marshal
29
31
import os
30
 
 
31
 
from loggerhead import util
32
 
from loggerhead.lockfile import LockFile
33
 
 
34
 
 
35
 
with_lock = util.with_lock('_lock', 'ChangeCache')
36
 
 
37
 
SQLITE_INTERFACE = os.environ.get('SQLITE_INTERFACE', 'sqlite')
38
 
 
39
 
if SQLITE_INTERFACE == 'pysqlite2':
 
32
import tempfile
 
33
import zlib
 
34
 
 
35
try:
 
36
    from sqlite3 import dbapi2
 
37
except ImportError:
40
38
    from pysqlite2 import dbapi2
41
 
    _param_marker = '?'
42
 
elif SQLITE_INTERFACE == 'sqlite':
43
 
    import sqlite as dbapi2
44
 
    _param_marker = '%s'
45
 
else:
46
 
    raise AssertionError("bad sqlite interface %r!?"%SQLITE_INTERFACE)
47
 
 
48
 
_select_stmt = ("select data from revisiondata where revid = ?"
49
 
                ).replace('?', _param_marker)
50
 
_insert_stmt = ("insert into revisiondata (revid, data) "
51
 
                "values (?, ?)").replace('?', _param_marker)
52
 
 
53
 
 
54
 
 
 
39
 
 
40
# We take an optimistic approach to concurrency here: we might do work twice
 
41
# in the case of races, but not crash or corrupt data.
 
42
 
 
43
def safe_init_db(filename, init_sql):
 
44
    # To avoid races around creating the database, we create the db in
 
45
    # a temporary file and rename it into the ultimate location.
 
46
    fd, temp_path = tempfile.mkstemp(dir=os.path.dirname(filename))
 
47
    os.close(fd)
 
48
    con = dbapi2.connect(temp_path)
 
49
    cur = con.cursor()
 
50
    cur.execute(init_sql)
 
51
    con.commit()
 
52
    con.close()
 
53
    os.rename(temp_path, filename)
55
54
 
56
55
class FakeShelf(object):
 
56
 
57
57
    def __init__(self, filename):
58
58
        create_table = not os.path.exists(filename)
 
59
        if create_table:
 
60
            safe_init_db(
 
61
                filename, "create table RevisionData "
 
62
                "(revid binary primary key, data binary)")
59
63
        self.connection = dbapi2.connect(filename)
60
64
        self.cursor = self.connection.cursor()
61
 
        if create_table:
62
 
            self._create_table()
63
 
    def _create_table(self):
64
 
        self.cursor.execute(
 
65
 
 
66
    def _create_table(self, filename):
 
67
        con = dbapi2.connect(filename)
 
68
        cur = con.cursor()
 
69
        cur.execute(
65
70
            "create table RevisionData "
66
71
            "(revid binary primary key, data binary)")
67
 
        self.connection.commit()
 
72
        con.commit()
 
73
        con.close()
 
74
 
68
75
    def _serialize(self, obj):
69
 
        r = dbapi2.Binary(cPickle.dumps(obj, protocol=2))
70
 
        return r
 
76
        return dbapi2.Binary(cPickle.dumps(obj, protocol=2))
 
77
 
71
78
    def _unserialize(self, data):
72
79
        return cPickle.loads(str(data))
 
80
 
73
81
    def get(self, revid):
74
 
        self.cursor.execute(_select_stmt, (revid,))
 
82
        self.cursor.execute(
 
83
            "select data from revisiondata where revid = ?", (revid, ))
75
84
        filechange = self.cursor.fetchone()
76
85
        if filechange is None:
77
86
            return None
78
87
        else:
79
88
            return self._unserialize(filechange[0])
80
 
    def add(self, revid_obj_pairs):
81
 
        for  (r, d) in revid_obj_pairs:
82
 
            self.cursor.execute(_insert_stmt, (r, self._serialize(d)))
83
 
        self.connection.commit()
 
89
 
 
90
    def add(self, revid, object):
 
91
        try:
 
92
            self.cursor.execute(
 
93
                "insert into revisiondata (revid, data) values (?, ?)",
 
94
                (revid, self._serialize(object)))
 
95
            self.connection.commit()
 
96
        except dbapi2.IntegrityError:
 
97
            # If another thread or process attempted to set the same key, we
 
98
            # assume it set it to the same value and carry on with our day.
 
99
            pass
84
100
 
85
101
 
86
102
class FileChangeCache(object):
87
 
    def __init__(self, history, cache_path):
88
 
        self.history = history
 
103
 
 
104
    def __init__(self, cache_path):
89
105
 
90
106
        if not os.path.exists(cache_path):
91
107
            os.mkdir(cache_path)
92
108
 
93
109
        self._changes_filename = os.path.join(cache_path, 'filechanges.sql')
94
110
 
95
 
        # use a lockfile since the cache folder could be shared across
96
 
        # different processes.
97
 
        self._lock = LockFile(os.path.join(cache_path, 'filechange-lock'))
98
 
 
99
 
    @with_lock
100
 
    def get_file_changes(self, entries):
101
 
        out = []
102
 
        missing_entries = []
103
 
        missing_entry_indices = []
 
111
    def get_file_changes(self, entry):
104
112
        cache = FakeShelf(self._changes_filename)
105
 
        for entry in entries:
106
 
            changes = cache.get(entry.revid)
107
 
            if changes is not None:
108
 
                out.append(changes)
109
 
            else:
110
 
                missing_entries.append(entry)
111
 
                missing_entry_indices.append(len(out))
112
 
                out.append(None)
113
 
        if missing_entries:
114
 
            missing_changes = self.history.get_file_changes_uncached(missing_entries)
115
 
            revid_changes_pairs = []
116
 
            for i, entry, changes in zip(
117
 
                missing_entry_indices, missing_entries, missing_changes):
118
 
                revid_changes_pairs.append((entry.revid, changes))
119
 
                out[i] = changes
120
 
            cache.add(revid_changes_pairs)
121
 
        return out
 
113
        changes = cache.get(entry.revid)
 
114
        if changes is None:
 
115
            changes = self.history.get_file_changes_uncached(entry)
 
116
            cache.add(entry.revid, changes)
 
117
        return changes
 
118
 
 
119
 
 
120
class RevInfoDiskCache(object):
 
121
    """Like `RevInfoMemoryCache` but backed in a sqlite DB."""
 
122
 
 
123
    def __init__(self, cache_path):
 
124
        if not os.path.exists(cache_path):
 
125
            os.mkdir(cache_path)
 
126
        filename = os.path.join(cache_path, 'revinfo.sql')
 
127
        create_table = not os.path.exists(filename)
 
128
        if create_table:
 
129
            safe_init_db(
 
130
                filename, "create table Data "
 
131
                "(key binary primary key, revid binary, data binary)")
 
132
        self.connection = dbapi2.connect(filename)
 
133
        self.cursor = self.connection.cursor()
 
134
 
 
135
    def get(self, key, revid):
 
136
        self.cursor.execute(
 
137
            "select revid, data from data where key = ?", (dbapi2.Binary(key),))
 
138
        row = self.cursor.fetchone()
 
139
        if row is None:
 
140
            return None
 
141
        elif str(row[0]) != revid:
 
142
            return None
 
143
        else:
 
144
            return marshal.loads(zlib.decompress(row[1]))
 
145
 
 
146
    def set(self, key, revid, data):
 
147
        try:
 
148
            self.cursor.execute(
 
149
                'delete from data where key = ?', (dbapi2.Binary(key), ))
 
150
            blob = zlib.compress(marshal.dumps(data))
 
151
            self.cursor.execute(
 
152
                "insert into data (key, revid, data) values (?, ?, ?)",
 
153
                map(dbapi2.Binary, [key, revid, blob]))
 
154
            self.connection.commit()
 
155
        except dbapi2.IntegrityError:
 
156
            # If another thread or process attempted to set the same key, we
 
157
            # don't care too much -- it's only a cache after all!
 
158
            pass