/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 breezy/git/transportgit.py

  • Committer: Jelmer Vernooij
  • Date: 2019-06-03 23:48:08 UTC
  • mfrom: (7316 work)
  • mto: This revision was merged to the branch mainline in revision 7328.
  • Revision ID: jelmer@jelmer.uk-20190603234808-15yk5c7054tj8e2b
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/git/transportgit.py
80
80
    )
81
81
 
82
82
from ..lock import LogicalLockResult
83
 
from ..trace import warning
84
83
 
85
84
 
86
85
class TransportRefsContainer(RefsContainer):
212
211
        except NoSuchFile:
213
212
            return None
214
213
        with f:
215
 
            try:
216
 
                header = f.read(len(SYMREF))
217
 
            except ReadError:
218
 
                # probably a directory
219
 
                return None
 
214
            header = f.read(len(SYMREF))
220
215
            if header == SYMREF:
221
216
                # Read only the first line
222
217
                return header + next(iter(f)).rstrip(b"\r\n")
238
233
        del self._packed_refs[name]
239
234
        if name in self._peeled_refs:
240
235
            del self._peeled_refs[name]
241
 
        with self.transport.open_write_stream("packed-refs") as f:
 
236
        f = self.transport.open_write_stream("packed-refs")
 
237
        try:
242
238
            write_packed_refs(f, self._packed_refs, self._peeled_refs)
 
239
        finally:
 
240
            f.close()
243
241
 
244
242
    def set_symbolic_ref(self, name, other):
245
243
        """Make a ref point at another ref.
432
430
            refs_container = InfoRefsContainer(BytesIO(refs_text))
433
431
            try:
434
432
                head = TransportRefsContainer(
435
 
                    self._commontransport).read_loose_ref(b"HEAD")
 
433
                    self._commontransport).read_loose_ref("HEAD")
436
434
            except KeyError:
437
435
                pass
438
436
            else:
439
 
                refs_container._refs[b"HEAD"] = head
 
437
                refs_container._refs["HEAD"] = head
440
438
        else:
441
439
            refs_container = TransportRefsContainer(
442
440
                self._commontransport, self._controltransport)
591
589
            return ret
592
590
 
593
591
    def _update_pack_cache(self):
594
 
        pack_files = set(self._pack_names())
 
592
        pack_files = set()
 
593
        pack_dir_contents = self._pack_names()
 
594
        for name in pack_dir_contents:
 
595
            if name.startswith("pack-") and name.endswith(".pack"):
 
596
                # verify that idx exists first (otherwise the pack was not yet
 
597
                # fully written)
 
598
                idx_name = os.path.splitext(name)[0] + ".idx"
 
599
                if idx_name in pack_dir_contents:
 
600
                    pack_files.add(os.path.splitext(name)[0])
 
601
 
595
602
        new_packs = []
596
603
        for basename in pack_files:
597
604
            pack_name = basename + ".pack"
600
607
                    size = self.pack_transport.stat(pack_name).st_size
601
608
                except TransportNotPossible:
602
609
                    f = self.pack_transport.get(pack_name)
603
 
                    # TODO(jelmer): Don't read entire file into memory?
604
 
                    f = BytesIO(f.read())
605
610
                    pd = PackData(pack_name, f)
606
611
                else:
607
612
                    pd = PackData(
620
625
        return new_packs
621
626
 
622
627
    def _pack_names(self):
623
 
        pack_files = []
624
628
        try:
625
 
            dir_contents = self.pack_transport.list_dir(".")
626
 
            for name in dir_contents:
627
 
                if name.startswith("pack-") and name.endswith(".pack"):
628
 
                    # verify that idx exists first (otherwise the pack was not yet
629
 
                    # fully written)
630
 
                    idx_name = os.path.splitext(name)[0] + ".idx"
631
 
                    if idx_name in dir_contents:
632
 
                        pack_files.append(os.path.splitext(name)[0])
 
629
            return self.pack_transport.list_dir(".")
633
630
        except TransportNotPossible:
634
631
            try:
635
632
                f = self.transport.get('info/packs')
636
633
            except NoSuchFile:
637
 
                warning('No info/packs on remote host;'
638
 
                        'run \'git update-server-info\' on remote.')
 
634
                # Hmm, warn about running 'git update-server-info' ?
 
635
                return iter([])
639
636
            else:
640
637
                with f:
641
 
                    pack_files = [
642
 
                        os.path.splitext(name)[0]
643
 
                        for name in read_packs_file(f)]
 
638
                    return read_packs_file(f)
644
639
        except NoSuchFile:
645
 
            pass
646
 
        return pack_files
 
640
            return iter([])
647
641
 
648
642
    def _remove_pack(self, pack):
649
643
        self.pack_transport.delete(os.path.basename(pack.index.path))
706
700
        p._filename = basename + ".pack"
707
701
        f.seek(0)
708
702
        self.pack_transport.put_file(basename + ".pack", f)
709
 
        with self.pack_transport.open_write_stream(basename + ".idx") as idxfile:
 
703
        idxfile = self.pack_transport.open_write_stream(basename + ".idx")
 
704
        try:
710
705
            write_pack_index_v2(idxfile, entries, p.get_stored_checksum())
 
706
        finally:
 
707
            idxfile.close()
711
708
        idxfile = self.pack_transport.get(basename + ".idx")
712
709
        idx = load_pack_index_file(basename + ".idx", idxfile)
713
710
        final_pack = Pack.from_objects(p, idx)
732
729
 
733
730
        pack_sha = p.index.objects_sha1()
734
731
 
735
 
        with self.pack_transport.open_write_stream(
736
 
                "pack-%s.pack" % pack_sha.decode('ascii')) as datafile:
 
732
        datafile = self.pack_transport.open_write_stream(
 
733
            "pack-%s.pack" % pack_sha.decode('ascii'))
 
734
        try:
737
735
            entries, data_sum = write_pack_objects(datafile, p.pack_tuples())
 
736
        finally:
 
737
            datafile.close()
738
738
        entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
739
 
        with self.pack_transport.open_write_stream(
740
 
                "pack-%s.idx" % pack_sha.decode('ascii')) as idxfile:
 
739
        idxfile = self.pack_transport.open_write_stream(
 
740
            "pack-%s.idx" % pack_sha.decode('ascii'))
 
741
        try:
741
742
            write_pack_index_v2(idxfile, entries, data_sum)
 
743
        finally:
 
744
            idxfile.close()
742
745
 
743
746
    def add_pack(self):
744
747
        """Add a new pack to this object store.