← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/changecache.py

Don't suggest that we support .bzr/ access on remote branches

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
 
with_lock = util.with_lock('_lock', 'ChangeCache')
35
 
 
36
 
SQLITE_INTERFACE = os.environ.get('SQLITE_INTERFACE', 'sqlite3')
37
 
 
38
 
if SQLITE_INTERFACE == 'sqlite3':
 
32
import tempfile
 
33
import zlib
 
34
 
 
35
try:
39
36
    from sqlite3 import dbapi2
40
 
    _param_marker = '?'
41
 
 
42
 
_select_stmt = ("select data from revisiondata where revid = ?"
43
 
                ).replace('?', _param_marker)
44
 
_insert_stmt = ("insert into revisiondata (revid, data) "
45
 
                "values (?, ?)").replace('?', _param_marker)
46
 
 
47
 
 
48
 
 
 
37
except ImportError:
 
38
    from pysqlite2 import dbapi2
 
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)
49
54
 
50
55
class FakeShelf(object):
 
56
 
51
57
    def __init__(self, filename):
52
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)")
53
63
        self.connection = dbapi2.connect(filename)
54
64
        self.cursor = self.connection.cursor()
55
 
        if create_table:
56
 
            self._create_table()
57
 
    def _create_table(self):
58
 
        self.cursor.execute(
 
65
 
 
66
    def _create_table(self, filename):
 
67
        con = dbapi2.connect(filename)
 
68
        cur = con.cursor()
 
69
        cur.execute(
59
70
            "create table RevisionData "
60
71
            "(revid binary primary key, data binary)")
61
 
        self.connection.commit()
 
72
        con.commit()
 
73
        con.close()
 
74
 
62
75
    def _serialize(self, obj):
63
 
        r = dbapi2.Binary(cPickle.dumps(obj, protocol=2))
64
 
        return r
 
76
        return dbapi2.Binary(cPickle.dumps(obj, protocol=2))
 
77
 
65
78
    def _unserialize(self, data):
66
79
        return cPickle.loads(str(data))
 
80
 
67
81
    def get(self, revid):
68
 
        self.cursor.execute(_select_stmt, (revid,))
 
82
        self.cursor.execute(
 
83
            "select data from revisiondata where revid = ?", (revid, ))
69
84
        filechange = self.cursor.fetchone()
70
85
        if filechange is None:
71
86
            return None
72
87
        else:
73
88
            return self._unserialize(filechange[0])
74
 
    def add(self, revid_obj_pairs):
75
 
        for  (r, d) in revid_obj_pairs:
76
 
            self.cursor.execute(_insert_stmt, (r, self._serialize(d)))
77
 
        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
78
100
 
79
101
 
80
102
class FileChangeCache(object):
81
 
    def __init__(self, history, cache_path):
82
 
        self.history = history
 
103
 
 
104
    def __init__(self, cache_path):
83
105
 
84
106
        if not os.path.exists(cache_path):
85
107
            os.mkdir(cache_path)
86
108
 
87
109
        self._changes_filename = os.path.join(cache_path, 'filechanges.sql')
88
110
 
89
 
        # use a lockfile since the cache folder could be shared across
90
 
        # different processes.
91
 
        self._lock = LockFile(os.path.join(cache_path, 'filechange-lock'))
92
 
 
93
 
    @with_lock
94
 
    def get_file_changes(self, entries):
95
 
        out = []
96
 
        missing_entries = []
97
 
        missing_entry_indices = []
 
111
    def get_file_changes(self, entry):
98
112
        cache = FakeShelf(self._changes_filename)
99
 
        for entry in entries:
100
 
            changes = cache.get(entry.revid)
101
 
            if changes is not None:
102
 
                out.append(changes)
103
 
            else:
104
 
                missing_entries.append(entry)
105
 
                missing_entry_indices.append(len(out))
106
 
                out.append(None)
107
 
        if missing_entries:
108
 
            missing_changes = self.history.get_file_changes_uncached(missing_entries)
109
 
            revid_changes_pairs = []
110
 
            for i, entry, changes in zip(
111
 
                missing_entry_indices, missing_entries, missing_changes):
112
 
                revid_changes_pairs.append((entry.revid, changes))
113
 
                out[i] = changes
114
 
            cache.add(revid_changes_pairs)
115
 
        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