← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/changecache.py

  • Committer: Robey Pointer
  • Date: 2007-01-14 05:40:40 UTC
  • Revision ID: robey@lag.net-20070114054040-7i9lbhq992e612rq
fix up dev.cfg so that nobody will ever have to edit it, by letting the
important params be overridable in loggerhead.conf.

make start-loggerhead actually daemonize, write a pid file, and write logs
to normal log files, instead of requiring 'nohup' stuff.  ie act like a real
server.  added stop-loggerhead to do a clean shutdown.  changed the README
to clarify how it should work now.

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 '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.
 
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.
24
23
 
25
24
once a revision is committed in bazaar, it never changes, so once we have
26
25
cached a change, it's good forever.
27
26
"""
28
27
 
29
 
import cPickle
 
28
import logging
30
29
import os
31
 
import tempfile
32
 
 
33
 
try:
34
 
    from sqlite3 import dbapi2
35
 
except ImportError:
36
 
    from pysqlite2 import dbapi2
37
 
 
38
 
# We take an optimistic approach to concurrency here: we might do work twice
39
 
# in the case of races, but not crash or corrupt data.
40
 
 
41
 
class FakeShelf(object):
42
 
 
43
 
    def __init__(self, filename):
44
 
        create_table = not os.path.exists(filename)
45
 
        if create_table:
46
 
            # To avoid races around creating the database, we create the db in
47
 
            # a temporary file and rename it into the ultimate location.
48
 
            fd, path = tempfile.mkstemp(dir=os.path.dirname(filename))
49
 
            self._create_table(path)
50
 
            os.rename(path, filename)
51
 
        self.connection = dbapi2.connect(filename)
52
 
        self.cursor = self.connection.cursor()
53
 
 
54
 
    def _create_table(self, filename):
55
 
        con = dbapi2.connect(filename)
56
 
        cur = con.cursor()
57
 
        cur.execute(
58
 
            "create table RevisionData "
59
 
            "(revid binary primary key, data binary)")
60
 
        con.commit()
61
 
        con.close()
62
 
 
63
 
    def _serialize(self, obj):
64
 
        return dbapi2.Binary(cPickle.dumps(obj, protocol=2))
65
 
 
66
 
    def _unserialize(self, data):
67
 
        return cPickle.loads(str(data))
68
 
 
69
 
    def get(self, revid):
70
 
        self.cursor.execute(
71
 
            "select data from revisiondata where revid = ?", (revid, ))
72
 
        filechange = self.cursor.fetchone()
73
 
        if filechange is None:
74
 
            return None
75
 
        else:
76
 
            return self._unserialize(filechange[0])
77
 
 
78
 
    def add(self, revid, object):
79
 
        try:
80
 
            self.cursor.execute(
81
 
                "insert into revisiondata (revid, data) values (?, ?)",
82
 
                (revid, self._serialize(object)))
83
 
            self.connection.commit()
84
 
        except dbapi2.IntegrityError:
85
 
            # If another thread or process attempted to set the same key, we
86
 
            # assume it set it to the same value and carry on with our day.
87
 
            pass
88
 
 
89
 
 
90
 
class FileChangeCache(object):
91
 
 
 
30
import shelve
 
31
import threading
 
32
import time
 
33
 
 
34
from loggerhead import util
 
35
from loggerhead.util import decorator
 
36
from loggerhead.lockfile import LockFile
 
37
 
 
38
 
 
39
with_lock = util.with_lock('_lock', 'ChangeCache')
 
40
        
 
41
 
 
42
class ChangeCache (object):
 
43
    
92
44
    def __init__(self, history, cache_path):
93
45
        self.history = history
94
 
 
 
46
        self.log = history.log
 
47
        
95
48
        if not os.path.exists(cache_path):
96
49
            os.mkdir(cache_path)
97
50
 
98
 
        self._changes_filename = os.path.join(cache_path, 'filechanges.sql')
99
 
 
100
 
    def get_file_changes(self, entry):
101
 
        cache = FakeShelf(self._changes_filename)
102
 
        changes = cache.get(entry.revid)
103
 
        if changes is None:
104
 
            changes = self.history.get_file_changes_uncached(entry)
105
 
            cache.add(entry.revid, changes)
106
 
        return changes
 
51
        # keep a separate cache for the diffs, because they're very time-consuming to fetch.
 
52
        self._changes_filename = os.path.join(cache_path, 'changes')
 
53
        self._changes_diffs_filename = os.path.join(cache_path, 'changes-diffs')
 
54
        
 
55
        # use a lockfile since the cache folder could be shared across different processes.
 
56
        self._lock = LockFile(os.path.join(cache_path, 'lock'))
 
57
        self._closed = False
 
58
        
 
59
        # this is fluff; don't slow down startup time with it.
 
60
        def log_sizes():
 
61
            s1, s2 = self.sizes()
 
62
            self.log.info('Using change cache %s; %d/%d entries.' % (cache_path, s1, s2))
 
63
        threading.Thread(target=log_sizes).start()
 
64
    
 
65
    @with_lock
 
66
    def close(self):
 
67
        self.log.debug('Closing cache file.')
 
68
        self._closed = True
 
69
    
 
70
    @with_lock
 
71
    def closed(self):
 
72
        return self._closed
 
73
 
 
74
    @with_lock
 
75
    def flush(self):
 
76
        pass
 
77
    
 
78
    @with_lock
 
79
    def get_changes(self, revid_list, get_diffs=False):
 
80
        """
 
81
        get a list of changes by their revision_ids.  any changes missing
 
82
        from the cache are fetched by calling L{History.get_change_uncached}
 
83
        and inserted into the cache before returning.
 
84
        """
 
85
        if get_diffs:
 
86
            cache = shelve.open(self._changes_diffs_filename, 'c', protocol=2)
 
87
        else:
 
88
            cache = shelve.open(self._changes_filename, 'c', protocol=2)
 
89
 
 
90
        out = []
 
91
        fetch_list = []
 
92
        sfetch_list = []
 
93
        for revid in revid_list:
 
94
            # if the revid is in unicode, use the utf-8 encoding as the key
 
95
            srevid = util.to_utf8(revid)
 
96
            
 
97
            if srevid in cache:
 
98
                out.append(cache[srevid])
 
99
            else:
 
100
                #self.log.debug('Entry cache miss: %r' % (revid,))
 
101
                out.append(None)
 
102
                fetch_list.append(revid)
 
103
                sfetch_list.append(srevid)
 
104
        
 
105
        if len(fetch_list) > 0:
 
106
            # some revisions weren't in the cache; fetch them
 
107
            changes = self.history.get_changes_uncached(fetch_list, get_diffs)
 
108
            if changes is None:
 
109
                return changes
 
110
            for i in xrange(len(revid_list)):
 
111
                if out[i] is None:
 
112
                    cache[sfetch_list.pop(0)] = out[i] = changes.pop(0)
 
113
        
 
114
        cache.close()
 
115
        return out
 
116
    
 
117
    @with_lock
 
118
    def full(self, get_diffs=False):
 
119
        if get_diffs:
 
120
            cache = shelve.open(self._changes_diffs_filename, 'c', protocol=2)
 
121
        else:
 
122
            cache = shelve.open(self._changes_filename, 'c', protocol=2)
 
123
        try:
 
124
            return (len(cache) >= len(self.history.get_revision_history())) and (util.to_utf8(self.history.last_revid) in cache)
 
125
        finally:
 
126
            cache.close()
 
127
 
 
128
    @with_lock
 
129
    def sizes(self):
 
130
        cache = shelve.open(self._changes_filename, 'c', protocol=2)
 
131
        s1 = len(cache)
 
132
        cache.close()
 
133
        cache = shelve.open(self._changes_diffs_filename, 'c', protocol=2)
 
134
        s2 = len(cache)
 
135
        cache.close()
 
136
        return s1, s2
 
137
        
 
138
    def check_rebuild(self, max_time=3600):
 
139
        """
 
140
        check if we need to fill in any missing pieces of the cache.  pull in
 
141
        any missing changes, but don't work any longer than C{max_time}
 
142
        seconds.
 
143
        """
 
144
        if self.closed() or self.full():
 
145
            return
 
146
        
 
147
        self.log.info('Building revision cache...')
 
148
        start_time = time.time()
 
149
        last_update = time.time()
 
150
        count = 0
 
151
 
 
152
        work = list(self.history.get_revision_history())
 
153
        jump = 100
 
154
        for i in xrange(0, len(work), jump):
 
155
            r = work[i:i + jump]
 
156
            # must call into history so we grab the branch lock (otherwise, lock inversion)
 
157
            self.history.get_changes(r)
 
158
            if self.closed():
 
159
                self.flush()
 
160
                return
 
161
            count += jump
 
162
            now = time.time()
 
163
            if now - start_time > max_time:
 
164
                self.log.info('Cache rebuilding will pause for now.')
 
165
                self.flush()
 
166
                return
 
167
            if now - last_update > 60:
 
168
                self.log.info('Revision cache rebuilding continues: %d/%d' % (min(count, len(work)), len(work)))
 
169
                last_update = time.time()
 
170
                self.flush()
 
171
            # give someone else a chance at the lock
 
172
            time.sleep(1)
 
173
        self.log.info('Revision cache rebuild completed.')
 
174
        self.flush()
 
175
 
 
176