← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/store/text.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-07-14 17:33:13 UTC
  • mfrom: (4476.1.40 1.17-chk-multilevel)
  • Revision ID: pqm@pqm.ubuntu.com-20090714173313-3p3ytzlfuc3y2bm6
(jam) Some rework of the internals of chk_map.iter_interesting_nodes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/store/text.py
1
 
# Copyright (C) 2005 by Canonical Development Ltd
2
 
 
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
 
 
7
#
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
 
 
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""
18
 
A store that keeps the full text of every version.
 
17
"""A store that keeps the full text of every version.
19
18
 
20
19
This store keeps uncompressed versions of the full text. It does not
21
20
do any sort of delta compression.
22
21
"""
23
22
 
24
 
import os, tempfile
 
23
import gzip
 
24
import os
 
25
from cStringIO import StringIO
25
26
 
 
27
from bzrlib import osutils
 
28
from bzrlib.errors import BzrError, NoSuchFile, FileExists
26
29
import bzrlib.store
27
30
from bzrlib.trace import mutter
28
 
from bzrlib.errors import BzrError
29
31
 
30
 
from cStringIO import StringIO
31
 
from stat import ST_SIZE
32
32
 
33
33
 
34
34
class TextStore(bzrlib.store.TransportStore):
41
41
    Files are stored uncompressed, with no delta compression.
42
42
    """
43
43
 
44
 
    def __init__(self, transport):
45
 
        super(TextStore, self).__init__(transport)
46
 
 
47
 
    def _check_fileid(self, fileid):
48
 
        if not isinstance(fileid, basestring):
49
 
            raise TypeError('Fileids should be a string type: %s %r' % (type(fileid), fileid))
50
 
        if '\\' in fileid or '/' in fileid:
51
 
            raise ValueError("invalid store id %r" % fileid)
52
 
 
53
 
    def _relpath(self, fileid):
54
 
        self._check_fileid(fileid)
55
 
        return fileid
56
 
 
57
 
    def add(self, f, fileid):
58
 
        """Add contents of a file into the store.
59
 
 
60
 
        f -- A file-like object, or string
61
 
        """
62
 
        mutter("add store entry %r" % (fileid))
63
 
            
64
 
        fn = self._relpath(fileid)
65
 
        if self._transport.has(fn):
66
 
            raise BzrError("store %r already contains id %r" % (self._transport.base, fileid))
67
 
 
68
 
        self._transport.put(fn, f)
69
 
 
70
 
    def _do_copy(self, other, to_copy, pb, permit_failure=False):
71
 
        if isinstance(other, TextStore):
72
 
            return self._copy_multi_text(other, to_copy, pb,
73
 
                    permit_failure=permit_failure)
74
 
        return super(TextStore, self)._do_copy(other, to_copy,
75
 
                pb, permit_failure=permit_failure)
76
 
 
77
 
    def _copy_multi_text(self, other, to_copy, pb,
78
 
            permit_failure=False):
79
 
        # Because of _transport, we can no longer assume
80
 
        # that they are on the same filesystem, we can, however
81
 
        # assume that we only need to copy the exact bytes,
82
 
        # we don't need to process the files.
83
 
 
84
 
        failed = set()
85
 
        if permit_failure:
86
 
            new_to_copy = set()
87
 
            for fileid, has in zip(to_copy, other.has(to_copy)):
88
 
                if has:
89
 
                    new_to_copy.add(fileid)
90
 
                else:
91
 
                    failed.add(fileid)
92
 
            to_copy = new_to_copy
93
 
            #mutter('_copy_multi_text copying %s, failed %s' % (to_copy, failed))
94
 
 
95
 
        paths = [self._relpath(fileid) for fileid in to_copy]
96
 
        count = other._transport.copy_to(paths, self._transport, pb=pb)
97
 
        assert count == len(to_copy)
98
 
        return count, failed
99
 
 
100
 
    def __contains__(self, fileid):
101
 
        """"""
102
 
        fn = self._relpath(fileid)
103
 
        return self._transport.has(fn)
104
 
 
105
 
    def has(self, fileids, pb=None):
106
 
        """Return True/False for each entry in fileids.
107
 
 
108
 
        :param fileids: A List or generator yielding file ids.
109
 
        :return: A generator or list returning True/False for each entry.
110
 
        """
111
 
        relpaths = (self._relpath(fid) for fid in fileids)
112
 
        return self._transport.has_multi(relpaths, pb=pb)
113
 
 
114
 
    def get(self, fileids, permit_failure=False, pb=None):
115
 
        """Return a set of files, one for each requested entry.
116
 
        
117
 
        TODO: Write some tests to make sure that permit_failure is
118
 
              handled correctly.
119
 
 
120
 
        TODO: What should the exception be for a missing file?
121
 
              KeyError, or NoSuchFile?
122
 
        """
123
 
 
124
 
        # This next code gets a bit hairy because it can allow
125
 
        # to not request a file which doesn't seem to exist.
126
 
        # Also, the same fileid may be requested twice, so we
127
 
        # can't just build up a map.
128
 
        rel_paths = [self._relpath(fid) for fid in fileids]
129
 
        is_requested = []
130
 
 
131
 
        if permit_failure:
132
 
            existing_paths = []
133
 
            for path, has in zip(rel_paths,
134
 
                    self._transport.has_multi(rel_paths)):
135
 
                if has:
136
 
                    existing_paths.append(path)
137
 
                    is_requested.append(True)
138
 
                else:
139
 
                    is_requested.append(False)
140
 
            #mutter('Retrieving %s out of %s' % (existing_paths, rel_paths))
141
 
        else:
142
 
            #mutter('Retrieving all %s' % (rel_paths, ))
143
 
            existing_paths = rel_paths
144
 
            is_requested = [True for x in rel_paths]
145
 
 
146
 
        count = 0
147
 
        for f in self._transport.get_multi(existing_paths, pb=pb):
148
 
            assert count < len(is_requested)
149
 
            while not is_requested[count]:
150
 
                yield None
151
 
                count += 1
152
 
            yield f
153
 
            count += 1
154
 
 
155
 
        while count < len(is_requested):
156
 
            yield None
157
 
            count += 1
158
 
 
159
 
    def __iter__(self):
160
 
        # TODO: case-insensitive?
161
 
        for f in self._transport.list_dir('.'):
162
 
            yield f
163
 
 
164
 
    def __len__(self):
165
 
        return len([f for f in self._transport.list_dir('.')])
166
 
 
167
 
 
168
 
    def __getitem__(self, fileid):
 
44
    def _add_compressed(self, fn, f):
 
45
        from cStringIO import StringIO
 
46
        from bzrlib.osutils import pumpfile
 
47
 
 
48
        if isinstance(f, basestring):
 
49
            f = StringIO(f)
 
50
 
 
51
        sio = StringIO()
 
52
        gf = gzip.GzipFile(mode='wb', fileobj=sio)
 
53
        # if pumpfile handles files that don't fit in ram,
 
54
        # so will this function
 
55
        pumpfile(f, gf)
 
56
        gf.close()
 
57
        sio.seek(0)
 
58
        self._try_put(fn, sio)
 
59
 
 
60
    def _add(self, fn, f):
 
61
        if self._compressed:
 
62
            self._add_compressed(fn, f)
 
63
        else:
 
64
            self._try_put(fn, f)
 
65
 
 
66
    def _try_put(self, fn, f):
 
67
        try:
 
68
            self._transport.put_file(fn, f, mode=self._file_mode)
 
69
        except NoSuchFile:
 
70
            if not self._prefixed:
 
71
                raise
 
72
            try:
 
73
                self._transport.mkdir(os.path.dirname(fn), mode=self._dir_mode)
 
74
            except FileExists:
 
75
                pass
 
76
            self._transport.put_file(fn, f, mode=self._file_mode)
 
77
 
 
78
    def _get(self, fn):
 
79
        if fn.endswith('.gz'):
 
80
            return self._get_compressed(fn)
 
81
        else:
 
82
            return self._transport.get(fn)
 
83
 
 
84
    def _copy_one(self, fileid, suffix, other, pb):
 
85
        # TODO: Once the copy_to interface is improved to allow a source
 
86
        #       and destination targets, then we can always do the copy
 
87
        #       as long as other is a TextStore
 
88
        if not (isinstance(other, TextStore)
 
89
            and other._prefixed == self._prefixed):
 
90
            return super(TextStore, self)._copy_one(fileid, suffix, other, pb)
 
91
 
 
92
        mutter('_copy_one: %r, %r', fileid, suffix)
 
93
        path = other._get_name(fileid, suffix)
 
94
        if path is None:
 
95
            raise KeyError(fileid + '-' + str(suffix))
 
96
 
 
97
        try:
 
98
            result = other._transport.copy_to([path], self._transport,
 
99
                                              mode=self._file_mode)
 
100
        except NoSuchFile:
 
101
            if not self._prefixed:
 
102
                raise
 
103
            try:
 
104
                self._transport.mkdir(osutils.dirname(path), mode=self._dir_mode)
 
105
            except FileExists:
 
106
                pass
 
107
            result = other._transport.copy_to([path], self._transport,
 
108
                                              mode=self._file_mode)
 
109
 
 
110
        if result != 1:
 
111
            raise BzrError('Unable to copy file: %r' % (path,))
 
112
 
 
113
    def _get_compressed(self, filename):
169
114
        """Returns a file reading from a particular entry."""
170
 
        fn = self._relpath(fileid)
171
 
        # This will throw if the file doesn't exist.
172
 
        try:
173
 
            f = self._transport.get(fn)
174
 
        except:
175
 
            raise KeyError('This store (%s) does not contain %s' % (self, fileid))
176
 
 
177
 
        return f
178
 
            
179
 
 
180
 
    def total_size(self):
181
 
        """Return (count, bytes)
182
 
 
183
 
        This is the (compressed) size stored on disk, not the size of
184
 
        the content."""
185
 
        total = 0
186
 
        count = 0
187
 
        relpaths = [self._relpath(fid) for fid in self]
188
 
        for st in self._transport.stat_multi(relpaths):
189
 
            count += 1
190
 
            total += st[ST_SIZE]
191
 
                
192
 
        return count, total
193
 
 
194
 
 
195
 
class ScratchTextStore(TextStore):
196
 
    """Self-destructing test subclass of TextStore.
197
 
 
198
 
    The Store only exists for the lifetime of the Python object.
199
 
    Obviously you should not put anything precious in it.
200
 
    """
201
 
    def __init__(self):
202
 
        from transport import transport
203
 
        super(ScratchTextStore, self).__init__(transport(tempfile.mkdtemp()))
204
 
 
205
 
    def __del__(self):
206
 
        self._transport.delete_multi(self._transport.list_dir('.'))
207
 
        os.rmdir(self._transport.base)
208
 
        mutter("%r destroyed" % self)
209
 
 
 
115
        f = self._transport.get(filename)
 
116
        # gzip.GzipFile.read() requires a tell() function
 
117
        # but some transports return objects that cannot seek
 
118
        # so buffer them in a StringIO instead
 
119
        if getattr(f, 'tell', None) is not None:
 
120
            return gzip.GzipFile(mode='rb', fileobj=f)
 
121
        else:
 
122
            from cStringIO import StringIO
 
123
            sio = StringIO(f.read())
 
124
            return gzip.GzipFile(mode='rb', fileobj=sio)