/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to transportgit.py

https://launchpad.net/bugs/508288
Provide VersionedFiles.get_annotator.

Show diffs side-by-side

added added

removed removed

Lines of Context:
transportgit.py
16
16
 
17
17
"""A Git repository implementation that uses a Bazaar transport."""
18
18
 
 
19
from cStringIO import StringIO
19
20
 
20
21
from dulwich.errors import (
21
22
    NotGitRepository,
37
38
    )
38
39
from dulwich.repo import (
39
40
    BaseRepo,
40
 
    DictRefsContainer,
 
41
    RefsContainer,
 
42
    INDEX_FILENAME,
41
43
    OBJECTDIR,
42
 
    read_info_refs,
 
44
    REFSDIR,
 
45
    SYMREF,
 
46
    check_ref_format,
 
47
    read_packed_refs_with_peeled,
 
48
    read_packed_refs,
 
49
    write_packed_refs,
43
50
    )
44
51
 
45
52
from bzrlib.errors import (
46
53
    FileExists,
47
54
    NoSuchFile,
 
55
    TransportNotPossible,
48
56
    )
49
57
 
50
58
 
 
59
class TransportRefsContainer(RefsContainer):
 
60
    """Refs container that reads refs from a transport."""
 
61
 
 
62
    def __init__(self, transport):
 
63
        self.transport = transport
 
64
        self._packed_refs = None
 
65
        self._peeled_refs = None
 
66
 
 
67
    def __repr__(self):
 
68
        return "%s(%r)" % (self.__class__.__name__, self.transport)
 
69
 
 
70
    def _ensure_dir_exists(self, path):
 
71
        for n in range(path.count("/")):
 
72
            dirname = "/".join(path.split("/")[:n+1])
 
73
            try:
 
74
                self.transport.mkdir(dirname)
 
75
            except FileExists:
 
76
                pass
 
77
 
 
78
    def subkeys(self, base):
 
79
        keys = set()
 
80
        try:
 
81
            iter_files = self.transport.clone(base).iter_files_recursive()
 
82
            keys.update(("%s/%s" % (base, refname)).strip("/") for 
 
83
                    refname in iter_files if check_ref_format("%s/%s" % (base, refname)))
 
84
        except (TransportNotPossible, NoSuchFile):
 
85
            pass
 
86
        for key in self.get_packed_refs():
 
87
            if key.startswith(base):
 
88
                keys.add(key[len(base):].strip("/"))
 
89
        return keys
 
90
 
 
91
    def allkeys(self):
 
92
        keys = set()
 
93
        if self.transport.has("HEAD"):
 
94
            keys.add("HEAD")
 
95
        try:
 
96
            iter_files = list(self.transport.clone("refs").iter_files_recursive())
 
97
            for filename in iter_files:
 
98
                refname = "refs/%s" % filename
 
99
                if check_ref_format(refname):
 
100
                    keys.add(refname)
 
101
        except (TransportNotPossible, NoSuchFile):
 
102
            pass
 
103
        keys.update(self.get_packed_refs())
 
104
        return keys
 
105
 
 
106
    def get_packed_refs(self):
 
107
        """Get contents of the packed-refs file.
 
108
 
 
109
        :return: Dictionary mapping ref names to SHA1s
 
110
 
 
111
        :note: Will return an empty dictionary when no packed-refs file is
 
112
            present.
 
113
        """
 
114
        # TODO: invalidate the cache on repacking
 
115
        if self._packed_refs is None:
 
116
            # set both to empty because we want _peeled_refs to be
 
117
            # None if and only if _packed_refs is also None.
 
118
            self._packed_refs = {}
 
119
            self._peeled_refs = {}
 
120
            try:
 
121
                f = self.transport.get("packed-refs")
 
122
            except NoSuchFile:
 
123
                return {}
 
124
            try:
 
125
                first_line = iter(f).next().rstrip()
 
126
                if (first_line.startswith("# pack-refs") and " peeled" in
 
127
                        first_line):
 
128
                    for sha, name, peeled in read_packed_refs_with_peeled(f):
 
129
                        self._packed_refs[name] = sha
 
130
                        if peeled:
 
131
                            self._peeled_refs[name] = peeled
 
132
                else:
 
133
                    f.seek(0)
 
134
                    for sha, name in read_packed_refs(f):
 
135
                        self._packed_refs[name] = sha
 
136
            finally:
 
137
                f.close()
 
138
        return self._packed_refs
 
139
 
 
140
    def get_peeled(self, name):
 
141
        """Return the cached peeled value of a ref, if available.
 
142
 
 
143
        :param name: Name of the ref to peel
 
144
        :return: The peeled value of the ref. If the ref is known not point to a
 
145
            tag, this will be the SHA the ref refers to. If the ref may point to
 
146
            a tag, but no cached information is available, None is returned.
 
147
        """
 
148
        self.get_packed_refs()
 
149
        if self._peeled_refs is None or name not in self._packed_refs:
 
150
            # No cache: no peeled refs were read, or this ref is loose
 
151
            return None
 
152
        if name in self._peeled_refs:
 
153
            return self._peeled_refs[name]
 
154
        else:
 
155
            # Known not peelable
 
156
            return self[name]
 
157
 
 
158
    def read_loose_ref(self, name):
 
159
        """Read a reference file and return its contents.
 
160
 
 
161
        If the reference file a symbolic reference, only read the first line of
 
162
        the file. Otherwise, only read the first 40 bytes.
 
163
 
 
164
        :param name: the refname to read, relative to refpath
 
165
        :return: The contents of the ref file, or None if the file does not
 
166
            exist.
 
167
        :raises IOError: if any other error occurs
 
168
        """
 
169
        try:
 
170
            f = self.transport.get(name)
 
171
        except NoSuchFile:
 
172
            return None
 
173
        try:
 
174
            header = f.read(len(SYMREF))
 
175
            if header == SYMREF:
 
176
                # Read only the first line
 
177
                return header + iter(f).next().rstrip("\r\n")
 
178
            else:
 
179
                # Read only the first 40 bytes
 
180
                return header + f.read(40-len(SYMREF))
 
181
        finally:
 
182
            f.close()
 
183
 
 
184
    def _remove_packed_ref(self, name):
 
185
        if self._packed_refs is None:
 
186
            return
 
187
        # reread cached refs from disk, while holding the lock
 
188
 
 
189
        self._packed_refs = None
 
190
        self.get_packed_refs()
 
191
 
 
192
        if name not in self._packed_refs:
 
193
            return
 
194
 
 
195
        del self._packed_refs[name]
 
196
        if name in self._peeled_refs:
 
197
            del self._peeled_refs[name]
 
198
        f = self.transport.open_write_stream("packed-refs")
 
199
        try:
 
200
            write_packed_refs(f, self._packed_refs, self._peeled_refs)
 
201
        finally:
 
202
            f.close()
 
203
 
 
204
    def set_symbolic_ref(self, name, other):
 
205
        """Make a ref point at another ref.
 
206
 
 
207
        :param name: Name of the ref to set
 
208
        :param other: Name of the ref to point at
 
209
        """
 
210
        self._check_refname(name)
 
211
        self._check_refname(other)
 
212
        self._ensure_dir_exists(name)
 
213
        self.transport.put_bytes(name, SYMREF + other + '\n')
 
214
 
 
215
    def set_if_equals(self, name, old_ref, new_ref):
 
216
        """Set a refname to new_ref only if it currently equals old_ref.
 
217
 
 
218
        This method follows all symbolic references, and can be used to perform
 
219
        an atomic compare-and-swap operation.
 
220
 
 
221
        :param name: The refname to set.
 
222
        :param old_ref: The old sha the refname must refer to, or None to set
 
223
            unconditionally.
 
224
        :param new_ref: The new sha the refname will refer to.
 
225
        :return: True if the set was successful, False otherwise.
 
226
        """
 
227
        try:
 
228
            realname, _ = self._follow(name)
 
229
        except KeyError:
 
230
            realname = name
 
231
        self._ensure_dir_exists(realname)
 
232
        self.transport.put_bytes(realname, new_ref+"\n")
 
233
        return True
 
234
 
 
235
    def add_if_new(self, name, ref):
 
236
        """Add a new reference only if it does not already exist.
 
237
 
 
238
        This method follows symrefs, and only ensures that the last ref in the
 
239
        chain does not exist.
 
240
 
 
241
        :param name: The refname to set.
 
242
        :param ref: The new sha the refname will refer to.
 
243
        :return: True if the add was successful, False otherwise.
 
244
        """
 
245
        try:
 
246
            realname, contents = self._follow(name)
 
247
            if contents is not None:
 
248
                return False
 
249
        except KeyError:
 
250
            realname = name
 
251
        self._check_refname(realname)
 
252
        self._ensure_dir_exists(realname)
 
253
        self.transport.put_bytes(realname, ref+"\n")
 
254
        return True
 
255
 
 
256
    def remove_if_equals(self, name, old_ref):
 
257
        """Remove a refname only if it currently equals old_ref.
 
258
 
 
259
        This method does not follow symbolic references. It can be used to
 
260
        perform an atomic compare-and-delete operation.
 
261
 
 
262
        :param name: The refname to delete.
 
263
        :param old_ref: The old sha the refname must refer to, or None to delete
 
264
            unconditionally.
 
265
        :return: True if the delete was successful, False otherwise.
 
266
        """
 
267
        self._check_refname(name)
 
268
        # may only be packed
 
269
        try:
 
270
            self.transport.delete(name)
 
271
        except NoSuchFile:
 
272
            pass
 
273
        self._remove_packed_ref(name)
 
274
        return True
 
275
 
 
276
 
51
277
class TransportRepo(BaseRepo):
52
278
 
53
279
    def __init__(self, transport):
54
280
        self.transport = transport
55
281
        try:
56
 
            if self.transport.has(".git/info/refs"):
 
282
            if self.transport.has(".git/%s" % OBJECTDIR):
57
283
                self.bare = False
58
284
                self._controltransport = self.transport.clone('.git')
59
 
            elif self.transport.has("info/refs"):
 
285
            elif self.transport.has(OBJECTDIR) or self.transport.has(REFSDIR):
60
286
                self.bare = True
61
287
                self._controltransport = self.transport
62
288
            else:
65
291
            raise NotGitRepository(self.transport)
66
292
        object_store = TransportObjectStore(
67
293
            self._controltransport.clone(OBJECTDIR))
68
 
        refs = {}
69
 
        refs["HEAD"] = self._controltransport.get_bytes("HEAD").rstrip("\n")
70
 
        refs.update(read_info_refs(self._controltransport.get('info/refs')))
71
294
        super(TransportRepo, self).__init__(object_store, 
72
 
                DictRefsContainer(refs))
 
295
                TransportRefsContainer(self._controltransport))
73
296
 
74
297
    def get_named_file(self, path):
75
298
        """Get a file from the control dir with a specific name.
86
309
        except NoSuchFile:
87
310
            return None
88
311
 
 
312
    def index_path(self):
 
313
        """Return the path to the index file."""
 
314
        return self._controltransport.local_abspath(INDEX_FILENAME)
 
315
 
89
316
    def open_index(self):
90
317
        """Open the index for this repository."""
91
 
        raise NoIndexPresent()
 
318
        from dulwich.index import Index
 
319
        if not self.has_index():
 
320
            raise NoIndexPresent()
 
321
        return Index(self.index_path())
 
322
 
 
323
    def has_index(self):
 
324
        """Check if an index is present."""
 
325
        # Bare repos must never have index files; non-bare repos may have a
 
326
        # missing index file, which is treated as empty.
 
327
        return not self.bare
92
328
 
93
329
    def __repr__(self):
94
330
        return "<TransportRepo for %r>" % self.transport
130
366
        ret = []
131
367
        for name in self._pack_names():
132
368
            if name.startswith("pack-") and name.endswith(".pack"):
133
 
                size = self.pack_transport.stat(name).st_size
134
 
                pd = PackData(name, self.pack_transport.get(name), size=size)
 
369
                try:
 
370
                    size = self.pack_transport.stat(name).st_size
 
371
                except TransportNotPossible:
 
372
                    # FIXME: This reads the whole pack file at once
 
373
                    f = self.pack_transport.get(name)
 
374
                    contents = f.read()
 
375
                    pd = PackData(name, StringIO(contents), size=len(contents))
 
376
                else:
 
377
                    pd = PackData(name, self.pack_transport.get(name),
 
378
                            size=size)
135
379
                idxname = name.replace(".pack", ".idx")
136
380
                idx = load_pack_index_file(idxname, self.pack_transport.get(idxname))
137
 
                ret.append(Pack.from_objects(pd, idx))
 
381
                pack = Pack.from_objects(pd, idx)
 
382
                ret.append(pack)
138
383
        return ret
139
384
 
140
385
    def _iter_loose_objects(self):
147
392
    def _split_loose_object(self, sha):
148
393
        return (sha[:2], sha[2:])
149
394
 
 
395
    def _remove_loose_object(self, sha):
 
396
        path = '%s/%s' % self._split_loose_object(sha)
 
397
        self.transport.delete(path)
 
398
 
150
399
    def _get_loose_object(self, sha):
151
400
        path = '%s/%s' % self._split_loose_object(sha)
152
401
        try:
183
432
        basename = "pack-%s" % iter_sha1(entry[0] for entry in entries)
184
433
        f.seek(0)
185
434
        self.pack_transport.put_file(basename + ".pack", f)
186
 
        index_path = self.pack_transport.local_abspath(basename+".idx")
187
 
        write_pack_index_v2(index_path, entries, p.get_stored_checksum())
188
 
        idx = load_pack_index_file(basename+".idx",
189
 
                self.pack_transport.get(basename+".idx"))
 
435
        idxfile = self.pack_transport.open_write_stream(basename + ".idx")
 
436
        try:
 
437
            write_pack_index_v2(idxfile, entries, p.get_stored_checksum())
 
438
        finally:
 
439
            idxfile.close()
 
440
        idxfile = self.pack_transport.get(basename + ".idx")
 
441
        idx = load_pack_index_file(basename+".idx", idxfile)
190
442
        final_pack = Pack.from_objects(p, idx)
191
443
        self._add_known_pack(final_pack)
192
444
        return final_pack