← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/store/text.py

  • Committer: Richard Wilbur
  • Date: 2016-02-04 19:07:28 UTC
  • mto: This revision was merged to the branch mainline in revision 6618.
  • Revision ID: richard.wilbur@gmail.com-20160204190728-p0zvfii6zase0fw7
Update COPYING.txt from the original http://www.gnu.org/licenses/gpl-2.0.txt  (Only differences were in whitespace.)  Thanks to Petr Stodulka for pointing out the discrepancy.

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, 2006, 2008, 2009, 2010 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
25
 
 
 
23
from __future__ import absolute_import
 
24
 
 
25
import gzip
 
26
import os
 
27
 
 
28
from bzrlib import osutils
 
29
from bzrlib.errors import BzrError, NoSuchFile, FileExists
26
30
import bzrlib.store
27
31
from bzrlib.trace import mutter
28
 
from bzrlib.errors import BzrError
29
 
 
30
 
from cStringIO import StringIO
31
 
from stat import ST_SIZE
32
 
 
33
 
class TextStore(bzrlib.store.Store):
 
32
 
 
33
 
 
34
 
 
35
class TextStore(bzrlib.store.TransportStore):
34
36
    """Store that holds files indexed by unique names.
35
37
 
36
38
    Files can be added, but not modified once they are in.  Typically
38
40
    such as a UUID.
39
41
 
40
42
    Files are stored uncompressed, with no delta compression.
41
 
 
42
43
    """
43
44
 
44
 
    def __init__(self, basedir):
45
 
        super(TextStore, self).__init__(basedir)
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):
 
45
    def _add_compressed(self, fn, f):
 
46
        from cStringIO import StringIO
 
47
        from bzrlib.osutils import pumpfile
 
48
 
 
49
        if isinstance(f, basestring):
 
50
            f = StringIO(f)
 
51
 
 
52
        sio = StringIO()
 
53
        gf = gzip.GzipFile(mode='wb', fileobj=sio)
 
54
        # if pumpfile handles files that don't fit in ram,
 
55
        # so will this function
 
56
        pumpfile(f, gf)
 
57
        gf.close()
 
58
        sio.seek(0)
 
59
        self._try_put(fn, sio)
 
60
 
 
61
    def _add(self, fn, f):
 
62
        if self._compressed:
 
63
            self._add_compressed(fn, f)
 
64
        else:
 
65
            self._try_put(fn, f)
 
66
 
 
67
    def _try_put(self, fn, f):
 
68
        try:
 
69
            self._transport.put_file(fn, f, mode=self._file_mode)
 
70
        except NoSuchFile:
 
71
            if not self._prefixed:
 
72
                raise
 
73
            try:
 
74
                self._transport.mkdir(os.path.dirname(fn), mode=self._dir_mode)
 
75
            except FileExists:
 
76
                pass
 
77
            self._transport.put_file(fn, f, mode=self._file_mode)
 
78
 
 
79
    def _get(self, fn):
 
80
        if fn.endswith('.gz'):
 
81
            return self._get_compressed(fn)
 
82
        else:
 
83
            return self._transport.get(fn)
 
84
 
 
85
    def _copy_one(self, fileid, suffix, other, pb):
 
86
        # TODO: Once the copy_to interface is improved to allow a source
 
87
        #       and destination targets, then we can always do the copy
 
88
        #       as long as other is a TextStore
 
89
        if not (isinstance(other, TextStore)
 
90
            and other._prefixed == self._prefixed):
 
91
            return super(TextStore, self)._copy_one(fileid, suffix, other, pb)
 
92
 
 
93
        mutter('_copy_one: %r, %r', fileid, suffix)
 
94
        path = other._get_name(fileid, suffix)
 
95
        if path is None:
 
96
            raise KeyError(fileid + '-' + str(suffix))
 
97
 
 
98
        try:
 
99
            result = other._transport.copy_to([path], self._transport,
 
100
                                              mode=self._file_mode)
 
101
        except NoSuchFile:
 
102
            if not self._prefixed:
 
103
                raise
 
104
            try:
 
105
                self._transport.mkdir(osutils.dirname(path), mode=self._dir_mode)
 
106
            except FileExists:
 
107
                pass
 
108
            result = other._transport.copy_to([path], self._transport,
 
109
                                              mode=self._file_mode)
 
110
 
 
111
        if result != 1:
 
112
            raise BzrError('Unable to copy file: %r' % (path,))
 
113
 
 
114
    def _get_compressed(self, filename):
169
115
        """Returns a file reading from a particular entry."""
170
 
        fn = self._relpath(fileid)
171
 
        # This will throw if the file doesn't exist.
 
116
        f = self._transport.get(filename)
 
117
        # gzip.GzipFile.read() requires a tell() function
 
118
        # but some transports return objects that cannot seek
 
119
        # so buffer them in a StringIO instead
 
120
        if getattr(f, 'tell', None) is not None:
 
121
            return gzip.GzipFile(mode='rb', fileobj=f)
172
122
        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
 
class ScratchTextStore(TextStore):
195
 
    """Self-destructing test subclass of TextStore.
196
 
 
197
 
    The Store only exists for the lifetime of the Python object.
198
 
    Obviously you should not put anything precious in it.
199
 
    """
200
 
    def __init__(self):
201
 
        from transport import transport
202
 
        super(ScratchTextStore, self).__init__(transport(tempfile.mkdtemp()))
203
 
 
204
 
    def __del__(self):
205
 
        self._transport.delete_multi(self._transport.list_dir('.'))
206
 
        os.rmdir(self._transport.base)
207
 
        mutter("%r destroyed" % self)
208
 
 
 
123
            from cStringIO import StringIO
 
124
            sio = StringIO(f.read())
 
125
            return gzip.GzipFile(mode='rb', fileobj=sio)
 
126
        finally:
 
127
            f.close()