Python object_store.DiskObjectStore类代码示例

    def test_add_thin_pack_empty(self):
        o = DiskObjectStore(self.store_dir)

        f = BytesIO()
        entries = build_pack(f, [], store=o)
        self.assertEquals([], entries)
        o.add_thin_pack(f.read, None)

 def _init_maybe_bare(cls, path, bare):
     for d in BASE_DIRECTORIES:
         os.mkdir(os.path.join(path, *d))
     DiskObjectStore.init(os.path.join(path, OBJECTDIR))
     ret = cls(path)
     ret.refs.set_symbolic_ref(b"HEAD", b"refs/heads/master")
     ret._init_files(bare)
     return ret

 def create(worktree: Path, store: Path):
     List.wrap(BASE_DIRECTORIES)\
         .smap(store.joinpath) %\
         __.mkdir(parents=True, exist_ok=True)
     DiskObjectStore.init(str(store / OBJECTDIR))
     repo = DulwichRepo(store, worktree)
     repo.refs.set_symbolic_ref(b'HEAD', _master_ref.encode())
     return repo

 def _init_maybe_bare(cls, path, bare):
     for d in BASE_DIRECTORIES:
         os.mkdir(os.path.join(path, *d))
     DiskObjectStore.init(os.path.join(path, OBJECTDIR))
     ret = cls(path)
     ret.refs.set_symbolic_ref(b'HEAD', DEFAULT_REF)
     ret._init_files(bare)
     return ret

 def test_add_pack(self):
     o = DiskObjectStore(self.store_dir)
     f, commit, abort = o.add_pack()
     try:
         b = make_object(Blob, data=b"more yummy data")
         write_pack_objects(f, [(b, None)])
     except BaseException:
         abort()
         raise
     else:
         commit()

 def _init_maybe_bare(cls, path, bare):
     if not isinstance(path, bytes):
         path_bytes = path.encode(sys.getfilesystemencoding())
     else:
         path_bytes = path
     for d in BASE_DIRECTORIES:
         os.mkdir(os.path.join(path_bytes, *d))
     DiskObjectStore.init(os.path.join(path_bytes, OBJECTDIR))
     ret = cls(path)
     ret.refs.set_symbolic_ref(b'HEAD', b"refs/heads/master")
     ret._init_files(bare)
     return ret

    def init_bare(cls, path, mkdir=True):
        for d in BASE_DIRECTORIES:
            os.mkdir(os.path.join(path, *d))
        DiskObjectStore.init(os.path.join(path, OBJECTDIR))
        ret = cls(path)
        ret.refs.set_symbolic_ref("HEAD", "refs/heads/master")
        ret._put_named_file('description', "Unnamed repository")
        ret._put_named_file('config', """[core]
    repositoryformatversion = 0
    filemode = true
    bare = false
    logallrefupdates = true
""")
        ret._put_named_file(os.path.join('info', 'excludes'), '')
        return ret

 def setUp(self):
     TestCase.setUp(self)
     self.store_dir = tempfile.mkdtemp()
     if not isinstance(self.store_dir, bytes):
         self.store_dir = self.store_dir.encode(sys.getfilesystemencoding())
     self.addCleanup(shutil.rmtree, self.store_dir)
     self.store = DiskObjectStore.init(self.store_dir)

 def test_add_alternate_path(self):
     store = DiskObjectStore(self.store_dir)
     self.assertEquals([], store._read_alternate_paths())
     store.add_alternate_path("/foo/path")
     self.assertEquals(["/foo/path"], store._read_alternate_paths())
     store.add_alternate_path("/bar/path")
     self.assertEquals(
         ["/foo/path", "/bar/path"],
         store._read_alternate_paths())

 def test_add_alternate_path(self):
     store = DiskObjectStore(self.store_dir)
     self.assertEqual([], list(store._read_alternate_paths()))
     store.add_alternate_path(b'/foo/path')
     self.assertEqual([b'/foo/path'], list(store._read_alternate_paths()))
     store.add_alternate_path(b'/bar/path')
     self.assertEqual(
         [b'/foo/path', b'/bar/path'],
         list(store._read_alternate_paths()))

 def __init__(self, root):
     if os.path.isdir(os.path.join(root, ".git", OBJECTDIR)):
         self.bare = False
         self._controldir = os.path.join(root, ".git")
     elif (os.path.isdir(os.path.join(root, OBJECTDIR)) and
           os.path.isdir(os.path.join(root, REFSDIR))):
         self.bare = True
         self._controldir = root
     else:
         raise NotGitRepository(root)
     self.path = root
     self.refs = DiskRefsContainer(self.controldir())
     self.object_store = DiskObjectStore(
         os.path.join(self.controldir(), OBJECTDIR))

 def test_alternates(self):
     alternate_dir = tempfile.mkdtemp()
     self.addCleanup(shutil.rmtree, alternate_dir)
     alternate_store = DiskObjectStore(alternate_dir)
     b2 = make_object(Blob, data="yummy data")
     alternate_store.add_object(b2)
     store = DiskObjectStore(self.store_dir)
     self.assertRaises(KeyError, store.__getitem__, b2.id)
     store.add_alternate_path(alternate_dir)
     self.assertEquals(b2, store[b2.id])

    def test_add_thin_pack(self):
        o = DiskObjectStore(self.store_dir)
        blob = make_object(Blob, data='yummy data')
        o.add_object(blob)

        f = BytesIO()
        entries = build_pack(f, [
          (REF_DELTA, (blob.id, 'more yummy data')),
          ], store=o)
        pack = o.add_thin_pack(f.read, None)
        try:
            packed_blob_sha = sha_to_hex(entries[0][3])
            pack.check_length_and_checksum()
            self.assertEqual(sorted([blob.id, packed_blob_sha]), list(pack))
            self.assertTrue(o.contains_packed(packed_blob_sha))
            self.assertTrue(o.contains_packed(blob.id))
            self.assertEqual((Blob.type_num, 'more yummy data'),
                             o.get_raw(packed_blob_sha))
        finally:
            o.close()
            pack.close()

 def test_rel_alternative_path(self):
     alternate_dir = tempfile.mkdtemp()
     self.addCleanup(shutil.rmtree, alternate_dir)
     alternate_store = DiskObjectStore(alternate_dir)
     b2 = make_object(Blob, data="yummy data")
     alternate_store.add_object(b2)
     store = DiskObjectStore(self.store_dir)
     self.assertRaises(KeyError, store.__getitem__, b2.id)
     store.add_alternate_path(os.path.relpath(alternate_dir, self.store_dir))
     self.assertEqual(list(alternate_store), list(store.alternates[0]))
     self.assertIn(b2.id, store)
     self.assertEqual(b2, store[b2.id])

 def test_alternates(self):
     alternate_dir = tempfile.mkdtemp()
     if not isinstance(alternate_dir, bytes):
         alternate_dir = alternate_dir.encode(sys.getfilesystemencoding())
     self.addCleanup(shutil.rmtree, alternate_dir)
     alternate_store = DiskObjectStore(alternate_dir)
     b2 = make_object(Blob, data=b"yummy data")
     alternate_store.add_object(b2)
     store = DiskObjectStore(self.store_dir)
     self.assertRaises(KeyError, store.__getitem__, b2.id)
     store.add_alternate_path(alternate_dir)
     self.assertIn(b2.id, store)
     self.assertEqual(b2, store[b2.id])