← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/store/text.py

  • Committer: Aaron Bentley
  • Date: 2007-03-12 19:56:41 UTC
  • mto: (1551.19.24 Aaron's mergeable stuff)
  • mto: This revision was merged to the branch mainline in revision 2353.
  • Revision ID: abentley@panoramicfeedback.com-20070312195641-ezjnseqwgjtkh0iu
merge3 auto-detects line endings for conflict markers

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
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
25
 
 
 
23
import os
26
24
import bzrlib.store
27
25
from bzrlib.trace import mutter
28
 
from bzrlib.errors import BzrError
 
26
from bzrlib.errors import BzrError, NoSuchFile, FileExists
29
27
 
 
28
import gzip
30
29
from cStringIO import StringIO
31
 
from stat import ST_SIZE
32
30
 
33
31
 
34
32
class TextStore(bzrlib.store.TransportStore):
41
39
    Files are stored uncompressed, with no delta compression.
42
40
    """
43
41
 
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.
 
42
    def _add_compressed(self, fn, f):
 
43
        from cStringIO import StringIO
 
44
        from bzrlib.osutils import pumpfile
116
45
        
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):
 
46
        if isinstance(f, basestring):
 
47
            f = StringIO(f)
 
48
            
 
49
        sio = StringIO()
 
50
        gf = gzip.GzipFile(mode='wb', fileobj=sio)
 
51
        # if pumpfile handles files that don't fit in ram,
 
52
        # so will this function
 
53
        pumpfile(f, gf)
 
54
        gf.close()
 
55
        sio.seek(0)
 
56
        self._try_put(fn, sio)
 
57
 
 
58
    def _add(self, fn, f):
 
59
        if self._compressed:
 
60
            self._add_compressed(fn, f)
 
61
        else:
 
62
            self._try_put(fn, f)
 
63
 
 
64
    def _try_put(self, fn, f):
 
65
        try:
 
66
            self._transport.put_file(fn, f, mode=self._file_mode)
 
67
        except NoSuchFile:
 
68
            if not self._prefixed:
 
69
                raise
 
70
            try:
 
71
                self._transport.mkdir(os.path.dirname(fn), mode=self._dir_mode)
 
72
            except FileExists:
 
73
                pass
 
74
            self._transport.put_file(fn, f, mode=self._file_mode)
 
75
 
 
76
    def _get(self, fn):
 
77
        if fn.endswith('.gz'):
 
78
            return self._get_compressed(fn)
 
79
        else:
 
80
            return self._transport.get(fn)
 
81
 
 
82
    def _copy_one(self, fileid, suffix, other, pb):
 
83
        # TODO: Once the copy_to interface is improved to allow a source
 
84
        #       and destination targets, then we can always do the copy
 
85
        #       as long as other is a TextStore
 
86
        if not (isinstance(other, TextStore)
 
87
            and other._prefixed == self._prefixed):
 
88
            return super(TextStore, self)._copy_one(fileid, suffix, other, pb)
 
89
 
 
90
        mutter('_copy_one: %r, %r', fileid, suffix)
 
91
        path = other._get_name(fileid, suffix)
 
92
        if path is None:
 
93
            raise KeyError(fileid + '-' + str(suffix))
 
94
 
 
95
        try:
 
96
            result = other._transport.copy_to([path], self._transport,
 
97
                                              mode=self._file_mode)
 
98
        except NoSuchFile:
 
99
            if not self._prefixed:
 
100
                raise
 
101
            try:
 
102
                self._transport.mkdir(self.hash_prefix(fileid)[:-1], mode=self._dir_mode)
 
103
            except FileExists:
 
104
                pass
 
105
            result = other._transport.copy_to([path], self._transport,
 
106
                                              mode=self._file_mode)
 
107
 
 
108
        if result != 1:
 
109
            raise BzrError('Unable to copy file: %r' % (path,))
 
110
 
 
111
    def _get_compressed(self, filename):
169
112
        """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
 
 
 
113
        f = self._transport.get(filename)
 
114
        # gzip.GzipFile.read() requires a tell() function
 
115
        # but some transports return objects that cannot seek
 
116
        # so buffer them in a StringIO instead
 
117
        if getattr(f, 'tell', None) is not None:
 
118
            return gzip.GzipFile(mode='rb', fileobj=f)
 
119
        else:
 
120
            from cStringIO import StringIO
 
121
            sio = StringIO(f.read())
 
122
            return gzip.GzipFile(mode='rb', fileobj=sio)