/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

More docstrings, prefer migrating git.db to migrating git.tdb.

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
20
19
 
21
20
from dulwich.errors import (
22
21
    NotGitRepository,
30
29
    PACKDIR,
31
30
    )
32
31
from dulwich.pack import (
33
 
    MemoryPackIndex,
34
32
    PackData,
35
33
    Pack,
36
 
    ThinPackData,
37
 
    iter_sha1,
38
34
    load_pack_index_file,
39
 
    write_pack_data,
40
 
    write_pack_index_v2,
41
35
    )
42
36
from dulwich.repo import (
43
37
    BaseRepo,
44
 
    RefsContainer,
45
 
    INDEX_FILENAME,
 
38
    DictRefsContainer,
46
39
    OBJECTDIR,
47
 
    REFSDIR,
48
 
    SYMREF,
49
 
    check_ref_format,
50
 
    read_packed_refs_with_peeled,
51
 
    read_packed_refs,
52
 
    write_packed_refs,
 
40
    read_info_refs,
53
41
    )
54
42
 
55
43
from bzrlib.errors import (
56
 
    FileExists,
57
44
    NoSuchFile,
58
 
    TransportNotPossible,
59
45
    )
60
46
 
61
47
 
62
 
class TransportRefsContainer(RefsContainer):
63
 
    """Refs container that reads refs from a transport."""
64
 
 
65
 
    def __init__(self, transport):
66
 
        self.transport = transport
67
 
        self._packed_refs = None
68
 
        self._peeled_refs = None
69
 
 
70
 
    def __repr__(self):
71
 
        return "%s(%r)" % (self.__class__.__name__, self.transport)
72
 
 
73
 
    def _ensure_dir_exists(self, path):
74
 
        for n in range(path.count("/")):
75
 
            dirname = "/".join(path.split("/")[:n+1])
76
 
            try:
77
 
                self.transport.mkdir(dirname)
78
 
            except FileExists:
79
 
                pass
80
 
 
81
 
    def subkeys(self, base):
82
 
        keys = set()
83
 
        try:
84
 
            iter_files = self.transport.clone(base).iter_files_recursive()
85
 
            keys.update(("%s/%s" % (base, refname)).strip("/") for 
86
 
                    refname in iter_files if check_ref_format("%s/%s" % (base, refname)))
87
 
        except (TransportNotPossible, NoSuchFile):
88
 
            pass
89
 
        for key in self.get_packed_refs():
90
 
            if key.startswith(base):
91
 
                keys.add(key[len(base):].strip("/"))
92
 
        return keys
93
 
 
94
 
    def allkeys(self):
95
 
        keys = set()
96
 
        if self.transport.has("HEAD"):
97
 
            keys.add("HEAD")
98
 
        try:
99
 
            iter_files = list(self.transport.clone("refs").iter_files_recursive())
100
 
            for filename in iter_files:
101
 
                refname = "refs/%s" % filename
102
 
                if check_ref_format(refname):
103
 
                    keys.add(refname)
104
 
        except (TransportNotPossible, NoSuchFile):
105
 
            pass
106
 
        keys.update(self.get_packed_refs())
107
 
        return keys
108
 
 
109
 
    def get_packed_refs(self):
110
 
        """Get contents of the packed-refs file.
111
 
 
112
 
        :return: Dictionary mapping ref names to SHA1s
113
 
 
114
 
        :note: Will return an empty dictionary when no packed-refs file is
115
 
            present.
116
 
        """
117
 
        # TODO: invalidate the cache on repacking
118
 
        if self._packed_refs is None:
119
 
            # set both to empty because we want _peeled_refs to be
120
 
            # None if and only if _packed_refs is also None.
121
 
            self._packed_refs = {}
122
 
            self._peeled_refs = {}
123
 
            try:
124
 
                f = self.transport.get("packed-refs")
125
 
            except NoSuchFile:
126
 
                return {}
127
 
            try:
128
 
                first_line = iter(f).next().rstrip()
129
 
                if (first_line.startswith("# pack-refs") and " peeled" in
130
 
                        first_line):
131
 
                    for sha, name, peeled in read_packed_refs_with_peeled(f):
132
 
                        self._packed_refs[name] = sha
133
 
                        if peeled:
134
 
                            self._peeled_refs[name] = peeled
135
 
                else:
136
 
                    f.seek(0)
137
 
                    for sha, name in read_packed_refs(f):
138
 
                        self._packed_refs[name] = sha
139
 
            finally:
140
 
                f.close()
141
 
        return self._packed_refs
142
 
 
143
 
    def get_peeled(self, name):
144
 
        """Return the cached peeled value of a ref, if available.
145
 
 
146
 
        :param name: Name of the ref to peel
147
 
        :return: The peeled value of the ref. If the ref is known not point to a
148
 
            tag, this will be the SHA the ref refers to. If the ref may point to
149
 
            a tag, but no cached information is available, None is returned.
150
 
        """
151
 
        self.get_packed_refs()
152
 
        if self._peeled_refs is None or name not in self._packed_refs:
153
 
            # No cache: no peeled refs were read, or this ref is loose
154
 
            return None
155
 
        if name in self._peeled_refs:
156
 
            return self._peeled_refs[name]
157
 
        else:
158
 
            # Known not peelable
159
 
            return self[name]
160
 
 
161
 
    def read_loose_ref(self, name):
162
 
        """Read a reference file and return its contents.
163
 
 
164
 
        If the reference file a symbolic reference, only read the first line of
165
 
        the file. Otherwise, only read the first 40 bytes.
166
 
 
167
 
        :param name: the refname to read, relative to refpath
168
 
        :return: The contents of the ref file, or None if the file does not
169
 
            exist.
170
 
        :raises IOError: if any other error occurs
171
 
        """
172
 
        try:
173
 
            f = self.transport.get(name)
174
 
        except NoSuchFile:
175
 
            return None
176
 
        try:
177
 
            header = f.read(len(SYMREF))
178
 
            if header == SYMREF:
179
 
                # Read only the first line
180
 
                return header + iter(f).next().rstrip("\r\n")
181
 
            else:
182
 
                # Read only the first 40 bytes
183
 
                return header + f.read(40-len(SYMREF))
184
 
        finally:
185
 
            f.close()
186
 
 
187
 
    def _remove_packed_ref(self, name):
188
 
        if self._packed_refs is None:
189
 
            return
190
 
        # reread cached refs from disk, while holding the lock
191
 
 
192
 
        self._packed_refs = None
193
 
        self.get_packed_refs()
194
 
 
195
 
        if name not in self._packed_refs:
196
 
            return
197
 
 
198
 
        del self._packed_refs[name]
199
 
        if name in self._peeled_refs:
200
 
            del self._peeled_refs[name]
201
 
        f = self.transport.open_write_stream("packed-refs")
202
 
        try:
203
 
            write_packed_refs(f, self._packed_refs, self._peeled_refs)
204
 
        finally:
205
 
            f.close()
206
 
 
207
 
    def set_symbolic_ref(self, name, other):
208
 
        """Make a ref point at another ref.
209
 
 
210
 
        :param name: Name of the ref to set
211
 
        :param other: Name of the ref to point at
212
 
        """
213
 
        self._check_refname(name)
214
 
        self._check_refname(other)
215
 
        self._ensure_dir_exists(name)
216
 
        self.transport.put_bytes(name, SYMREF + other + '\n')
217
 
 
218
 
    def set_if_equals(self, name, old_ref, new_ref):
219
 
        """Set a refname to new_ref only if it currently equals old_ref.
220
 
 
221
 
        This method follows all symbolic references, and can be used to perform
222
 
        an atomic compare-and-swap operation.
223
 
 
224
 
        :param name: The refname to set.
225
 
        :param old_ref: The old sha the refname must refer to, or None to set
226
 
            unconditionally.
227
 
        :param new_ref: The new sha the refname will refer to.
228
 
        :return: True if the set was successful, False otherwise.
229
 
        """
230
 
        try:
231
 
            realname, _ = self._follow(name)
232
 
        except KeyError:
233
 
            realname = name
234
 
        self._ensure_dir_exists(realname)
235
 
        self.transport.put_bytes(realname, new_ref+"\n")
236
 
        return True
237
 
 
238
 
    def add_if_new(self, name, ref):
239
 
        """Add a new reference only if it does not already exist.
240
 
 
241
 
        This method follows symrefs, and only ensures that the last ref in the
242
 
        chain does not exist.
243
 
 
244
 
        :param name: The refname to set.
245
 
        :param ref: The new sha the refname will refer to.
246
 
        :return: True if the add was successful, False otherwise.
247
 
        """
248
 
        try:
249
 
            realname, contents = self._follow(name)
250
 
            if contents is not None:
251
 
                return False
252
 
        except KeyError:
253
 
            realname = name
254
 
        self._check_refname(realname)
255
 
        self._ensure_dir_exists(realname)
256
 
        self.transport.put_bytes(realname, ref+"\n")
257
 
        return True
258
 
 
259
 
    def remove_if_equals(self, name, old_ref):
260
 
        """Remove a refname only if it currently equals old_ref.
261
 
 
262
 
        This method does not follow symbolic references. It can be used to
263
 
        perform an atomic compare-and-delete operation.
264
 
 
265
 
        :param name: The refname to delete.
266
 
        :param old_ref: The old sha the refname must refer to, or None to delete
267
 
            unconditionally.
268
 
        :return: True if the delete was successful, False otherwise.
269
 
        """
270
 
        self._check_refname(name)
271
 
        # may only be packed
272
 
        try:
273
 
            self.transport.delete(name)
274
 
        except NoSuchFile:
275
 
            pass
276
 
        self._remove_packed_ref(name)
277
 
        return True
278
 
 
279
 
 
280
48
class TransportRepo(BaseRepo):
281
49
 
282
50
    def __init__(self, transport):
283
51
        self.transport = transport
284
52
        try:
285
 
            if self.transport.has(".git/%s" % OBJECTDIR):
 
53
            if self.transport.has(".git/info/refs"):
286
54
                self.bare = False
287
55
                self._controltransport = self.transport.clone('.git')
288
 
            elif self.transport.has_any(["info/refs", OBJECTDIR, REFSDIR]):
 
56
            elif self.transport.has("info/refs"):
289
57
                self.bare = True
290
58
                self._controltransport = self.transport
291
59
            else:
294
62
            raise NotGitRepository(self.transport)
295
63
        object_store = TransportObjectStore(
296
64
            self._controltransport.clone(OBJECTDIR))
 
65
        refs = {}
 
66
        refs["HEAD"] = self._controltransport.get_bytes("HEAD").rstrip("\n")
 
67
        refs.update(read_info_refs(self._controltransport.get('info/refs')))
297
68
        super(TransportRepo, self).__init__(object_store, 
298
 
                TransportRefsContainer(self._controltransport))
 
69
                DictRefsContainer(refs))
299
70
 
300
71
    def get_named_file(self, path):
301
72
        """Get a file from the control dir with a specific name.
312
83
        except NoSuchFile:
313
84
            return None
314
85
 
315
 
    def index_path(self):
316
 
        """Return the path to the index file."""
317
 
        return self._controltransport.local_abspath(INDEX_FILENAME)
318
 
 
319
86
    def open_index(self):
320
87
        """Open the index for this repository."""
321
 
        from dulwich.index import Index
322
 
        if not self.has_index():
323
 
            raise NoIndexPresent()
324
 
        return Index(self.index_path())
325
 
 
326
 
    def has_index(self):
327
 
        """Check if an index is present."""
328
 
        # Bare repos must never have index files; non-bare repos may have a
329
 
        # missing index file, which is treated as empty.
330
 
        return not self.bare
 
88
        raise NoIndexPresent()
331
89
 
332
90
    def __repr__(self):
333
 
        return "<%s for %r>" % (self.__class__.__name__, self.transport)
 
91
        return "<TransportRepo for %r>" % self.transport
334
92
 
335
93
 
336
94
class TransportObjectStore(PackBasedObjectStore):
345
103
        self.transport = transport
346
104
        self.pack_transport = self.transport.clone(PACKDIR)
347
105
 
348
 
    def __repr__(self):
349
 
        return "%s(%r)" % (self.__class__.__name__, self.transport)
350
 
 
351
 
    def _pack_cache_stale(self):
352
 
        return False # FIXME
353
 
 
354
 
    def _pack_names(self):
355
 
        try:
356
 
            f = self.transport.get('info/packs')
357
 
        except NoSuchFile:
358
 
            return self.pack_transport.list_dir(".")
359
 
        else:
360
 
            ret = []
361
 
            for line in f.readlines():
362
 
                line = line.rstrip("\n")
363
 
                if not line:
364
 
                    continue
365
 
                (kind, name) = line.split(" ", 1)
366
 
                if kind != "P":
367
 
                    continue
368
 
                ret.append(name)
369
 
            return ret
370
 
 
371
106
    def _load_packs(self):
372
107
        ret = []
373
 
        for name in self._pack_names():
 
108
        for line in self.transport.get('info/packs').readlines():
 
109
            line = line.rstrip("\n")
 
110
            if not line:
 
111
                continue
 
112
            (kind, name) = line.split(" ", 1)
 
113
            if kind != "P":
 
114
                continue
374
115
            if name.startswith("pack-") and name.endswith(".pack"):
375
 
                try:
376
 
                    size = self.pack_transport.stat(name).st_size
377
 
                except TransportNotPossible:
378
 
                    # FIXME: This reads the whole pack file at once
379
 
                    f = self.pack_transport.get(name)
380
 
                    contents = f.read()
381
 
                    pd = PackData(name, StringIO(contents), size=len(contents))
382
 
                else:
383
 
                    pd = PackData(name, self.pack_transport.get(name),
384
 
                            size=size)
 
116
                pd = PackData(name, self.pack_transport.get(name))
385
117
                idxname = name.replace(".pack", ".idx")
386
118
                idx = load_pack_index_file(idxname, self.pack_transport.get(idxname))
387
 
                pack = Pack.from_objects(pd, idx)
388
 
                ret.append(pack)
 
119
                ret.append(Pack.from_objects(pd, idx))
389
120
        return ret
390
121
 
391
122
    def _iter_loose_objects(self):
398
129
    def _split_loose_object(self, sha):
399
130
        return (sha[:2], sha[2:])
400
131
 
401
 
    def _remove_loose_object(self, sha):
402
 
        path = '%s/%s' % self._split_loose_object(sha)
403
 
        self.transport.delete(path)
404
 
 
405
132
    def _get_loose_object(self, sha):
406
133
        path = '%s/%s' % self._split_loose_object(sha)
407
134
        try:
408
 
            return ShaFile.from_file(self.transport.get(path))
 
135
            return ShaFile._parse_file(self.transport.get(path).read())
409
136
        except NoSuchFile:
410
137
            return None
411
138
 
415
142
        :param obj: Object to add
416
143
        """
417
144
        (dir, file) = self._split_loose_object(obj.id)
418
 
        try:
419
 
            self.transport.mkdir(dir)
420
 
        except FileExists:
421
 
            pass
 
145
        self.transport.mkdir(dir)
422
146
        path = "%s/%s" % (dir, file)
423
147
        if self.transport.has(path):
424
148
            return # Already there, no need to write again
425
149
        self.transport.put_bytes(path, obj.as_legacy_object())
426
150
 
427
 
    def move_in_pack(self, f):
428
 
        """Move a specific file containing a pack into the pack directory.
429
 
 
430
 
        :note: The file should be on the same file system as the
431
 
            packs directory.
432
 
 
433
 
        :param path: Path to the pack file.
434
 
        """
435
 
        f.seek(0)
436
 
        p = PackData(None, f, len(f.getvalue()))
437
 
        entries = p.sorted_entries()
438
 
        basename = "pack-%s" % iter_sha1(entry[0] for entry in entries)
439
 
        f.seek(0)
440
 
        self.pack_transport.put_file(basename + ".pack", f)
441
 
        idxfile = self.pack_transport.open_write_stream(basename + ".idx")
442
 
        try:
443
 
            write_pack_index_v2(idxfile, entries, p.get_stored_checksum())
444
 
        finally:
445
 
            idxfile.close()
446
 
        idxfile = self.pack_transport.get(basename + ".idx")
447
 
        idx = load_pack_index_file(basename+".idx", idxfile)
448
 
        final_pack = Pack.from_objects(p, idx)
449
 
        self._add_known_pack(final_pack)
450
 
        return final_pack
451
 
 
452
 
    def add_thin_pack(self):
453
 
        """Add a new thin pack to this object store.
454
 
 
455
 
        Thin packs are packs that contain deltas with parents that exist
456
 
        in a different pack.
457
 
        """
458
 
        from cStringIO import StringIO
459
 
        f = StringIO()
460
 
        def commit():
461
 
            if len(f.getvalue()) > 0:
462
 
                return self.move_in_thin_pack(f)
463
 
            else:
464
 
                return None
465
 
        return f, commit
466
 
 
467
 
    def move_in_thin_pack(self, f):
468
 
        """Move a specific file containing a pack into the pack directory.
469
 
 
470
 
        :note: The file should be on the same file system as the
471
 
            packs directory.
472
 
 
473
 
        :param path: Path to the pack file.
474
 
        """
475
 
        f.seek(0)
476
 
        data = ThinPackData.from_file(self.get_raw, f, len(f.getvalue()))
477
 
        idx = MemoryPackIndex(data.sorted_entries(), data.get_stored_checksum())
478
 
        p = Pack.from_objects(data, idx)
479
 
 
480
 
        pack_sha = idx.objects_sha1()
481
 
 
482
 
        datafile = self.pack_transport.open_write_stream("pack-%s.pack" % pack_sha)
483
 
        try:
484
 
            entries, data_sum = write_pack_data(datafile, ((o, None) for o in p.iterobjects()), len(p))
485
 
        finally:
486
 
            datafile.close()
487
 
        entries.sort()
488
 
        idxfile = self.pack_transport.open_write_stream("pack-%s.idx" % pack_sha)
489
 
        try:
490
 
            write_pack_index_v2(idxfile, data.sorted_entries(), data_sum)
491
 
        finally:
492
 
            idxfile.close()
493
 
        final_pack = Pack("pack-%s" % pack_sha)
494
 
        self._add_known_pack(final_pack)
495
 
        return final_pack
496
 
 
497
 
 
498
 
 
499
151
    def add_pack(self):
500
152
        """Add a new pack to this object store. 
501
153
 
502
154
        :return: Fileobject to write to and a commit function to 
503
155
            call when the pack is finished.
504
156
        """
505
 
        from cStringIO import StringIO
506
 
        f = StringIO()
507
 
        def commit():
508
 
            if len(f.getvalue()) > 0:
509
 
                return self.move_in_pack(f)
510
 
            else:
511
 
                return None
512
 
        return f, commit
513
 
 
514
 
    @classmethod
515
 
    def init(cls, transport):
516
 
        transport.mkdir('info')
517
 
        transport.mkdir(PACKDIR)
518
 
        return cls(transport)
 
157
        raise NotImplementedError(self.add_pack)