/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

Escape slashes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
transportgit.py
18
18
 
19
19
from cStringIO import StringIO
20
20
 
 
21
import os
 
22
 
21
23
from dulwich.errors import (
22
24
    NotGitRepository,
23
25
    NoIndexPresent,
33
35
    MemoryPackIndex,
34
36
    PackData,
35
37
    Pack,
36
 
    ThinPackData,
37
38
    iter_sha1,
38
39
    load_pack_index_file,
39
40
    write_pack_data,
42
43
from dulwich.repo import (
43
44
    BaseRepo,
44
45
    RefsContainer,
 
46
    BASE_DIRECTORIES,
45
47
    INDEX_FILENAME,
46
48
    OBJECTDIR,
47
49
    REFSDIR,
52
54
    write_packed_refs,
53
55
    )
54
56
 
 
57
from bzrlib import (
 
58
    transport as _mod_transport,
 
59
    )
55
60
from bzrlib.errors import (
56
61
    FileExists,
57
62
    NoSuchFile,
312
317
        except NoSuchFile:
313
318
            return None
314
319
 
 
320
    def _put_named_file(self, relpath, contents):
 
321
        self._controltransport.put_bytes(relpath, contents)
 
322
 
315
323
    def index_path(self):
316
324
        """Return the path to the index file."""
317
325
        return self._controltransport.local_abspath(INDEX_FILENAME)
332
340
    def __repr__(self):
333
341
        return "<%s for %r>" % (self.__class__.__name__, self.transport)
334
342
 
 
343
    @classmethod
 
344
    def init(cls, transport, bare=False):
 
345
        if not bare:
 
346
            transport.mkdir(".git")
 
347
            control_transport = transport.clone(".git")
 
348
        else:
 
349
            control_transport = transport
 
350
        for d in BASE_DIRECTORIES:
 
351
            control_transport.mkdir("/".join(d))
 
352
        control_transport.mkdir(OBJECTDIR)
 
353
        TransportObjectStore.init(control_transport.clone(OBJECTDIR))
 
354
        ret = cls(transport)
 
355
        ret.refs.set_symbolic_ref("HEAD", "refs/heads/master")
 
356
        ret._init_files(bare)
 
357
        return ret
 
358
 
335
359
 
336
360
class TransportObjectStore(PackBasedObjectStore):
337
361
    """Git-style object store that exists on disk."""
344
368
        super(TransportObjectStore, self).__init__()
345
369
        self.transport = transport
346
370
        self.pack_transport = self.transport.clone(PACKDIR)
 
371
        self._alternates = None
347
372
 
348
373
    def __repr__(self):
349
374
        return "%s(%r)" % (self.__class__.__name__, self.transport)
351
376
    def _pack_cache_stale(self):
352
377
        return False # FIXME
353
378
 
 
379
    @property
 
380
    def alternates(self):
 
381
        if self._alternates is not None:
 
382
            return self._alternates
 
383
        self._alternates = []
 
384
        for path in self._read_alternate_paths():
 
385
            # FIXME: Check path
 
386
            t = _mod_transport.get_transport_from_path(path)
 
387
            self._alternates.append(self.__class__(t))
 
388
        return self._alternates
 
389
 
 
390
    def _read_alternate_paths(self):
 
391
        try:
 
392
            f = self.transport.get("info/alternates")
 
393
        except NoSuchFile:
 
394
            return []
 
395
        ret = []
 
396
        try:
 
397
            for l in f.readlines():
 
398
                l = l.rstrip("\n")
 
399
                if l[0] == "#":
 
400
                    continue
 
401
                if os.path.isabs(l):
 
402
                    continue
 
403
                ret.append(l)
 
404
            return ret
 
405
        finally:
 
406
            f.close()
 
407
 
354
408
    def _pack_names(self):
355
409
        try:
356
410
            f = self.transport.get('info/packs')
473
527
        :param path: Path to the pack file.
474
528
        """
475
529
        f.seek(0)
476
 
        data = ThinPackData.from_file(self.get_raw, f, len(f.getvalue()))
 
530
        data = PackData.from_file(self.get_raw, f, len(f.getvalue()))
477
531
        idx = MemoryPackIndex(data.sorted_entries(), data.get_stored_checksum())
478
532
        p = Pack.from_objects(data, idx)
479
533
 
480
534
        pack_sha = idx.objects_sha1()
481
535
 
482
 
        datafile = self.pack_transport.open_write_stream("pack-%s.pack" % pack_sha)
 
536
        datafile = self.pack_transport.open_write_stream(
 
537
                "pack-%s.pack" % pack_sha)
483
538
        try:
484
 
            entries, data_sum = write_pack_data(datafile, ((o, None) for o in p.iterobjects()), len(p))
 
539
            entries, data_sum = write_pack_data(datafile, p.pack_tuples())
485
540
        finally:
486
541
            datafile.close()
487
542
        entries.sort()
488
 
        idxfile = self.pack_transport.open_write_stream("pack-%s.idx" % pack_sha)
 
543
        idxfile = self.pack_transport.open_write_stream(
 
544
            "pack-%s.idx" % pack_sha)
489
545
        try:
490
546
            write_pack_index_v2(idxfile, data.sorted_entries(), data_sum)
491
547
        finally:
494
550
        self._add_known_pack(final_pack)
495
551
        return final_pack
496
552
 
497
 
 
498
 
 
499
553
    def add_pack(self):
500
554
        """Add a new pack to this object store. 
501
555