def test_readonly(self):
f = GitFile(self.path('foo'), 'rb')
self.assertTrue(isinstance(f, io.IOBase))
self.assertEqual(b'foo contents', f.read())
self.assertEqual(b'', f.read())
f.seek(4)
self.assertEqual(b'contents', f.read())
f.close()
def write(self):
"""Write current contents of index to disk."""
f = GitFile(self._filename, 'wb')
try:
f = SHA1Writer(f)
write_index_dict(f, self._byname)
finally:
f.close()
def test_remove_packed_without_peeled(self):
refs_file = os.path.join(self._repo.path, 'packed-refs')
f = GitFile(refs_file)
refs_data = f.read()
f.close()
f = GitFile(refs_file, 'wb')
f.write(b'\n'.join(l for l in refs_data.split(b'\n')
if not l or l[0] not in b'#^'))
f.close()
self._repo = Repo(self._repo.path)
refs = self._repo.refs
self.assertTrue(
refs.remove_if_equals(b'refs/heads/packed',
b'42d06bd4b77fed026b154d16493e5deab78f02ec'))
def read(self):
"""Read current contents of index from disk."""
if not os.path.exists(self._filename):
return
f = GitFile(self._filename, 'rb')
try:
f = SHA1Reader(f)
for x in read_index(f):
self[x[0]] = IndexEntry(*x[1:])
# FIXME: Additional data?
f.read(os.path.getsize(self._filename) - f.tell() - 20)
f.check_sha()
finally:
f.close()
def test_abort_close(self):
foo = self.path('foo')
f = GitFile(foo, 'wb')
f.abort()
try:
f.close()
except (IOError, OSError):
self.fail()
f = GitFile(foo, 'wb')
f.close()
try:
f.abort()
except (IOError, OSError):
self.fail()
def test_open_twice(self):
foo = self.path('foo')
f1 = GitFile(foo, 'wb')
f1.write(b'new')
try:
f2 = GitFile(foo, 'wb')
self.fail()
except FileLocked:
pass
else:
f2.close()
f1.write(b' contents')
f1.close()
# Ensure trying to open twice doesn't affect original.
f = open(foo, 'rb')
self.assertEqual(b'new contents', f.read())
f.close()
def _remove_packed_ref(self, name):
if self._packed_refs is None:
return
filename = os.path.join(self.path, b'packed-refs')
# reread cached refs from disk, while holding the lock
f = GitFile(filename, 'wb')
try:
self._packed_refs = None
self.get_packed_refs()
if name not in self._packed_refs:
return
del self._packed_refs[name]
if name in self._peeled_refs:
del self._peeled_refs[name]
write_packed_refs(f, self._packed_refs, self._peeled_refs)
f.close()
finally:
f.abort()
def set_symbolic_ref(self, name, other, committer=None, timestamp=None,
timezone=None, message=None):
"""Make a ref point at another ref.
:param name: Name of the ref to set
:param other: Name of the ref to point at
:param message: Optional message to describe the change
"""
self._check_refname(name)
self._check_refname(other)
filename = self.refpath(name)
f = GitFile(filename, 'wb')
try:
f.write(SYMREF + other + b'\n')
sha = self.follow(name)[-1]
self._log(name, sha, sha, committer=committer,
timestamp=timestamp, timezone=timezone,
message=message)
except BaseException:
f.abort()
raise
else:
f.close()
def test_write(self):
foo = self.path('foo')
foo_lock = '%s.lock' % foo
orig_f = open(foo, 'rb')
self.assertEqual(orig_f.read(), b'foo contents')
orig_f.close()
self.assertFalse(os.path.exists(foo_lock))
f = GitFile(foo, 'wb')
self.assertFalse(f.closed)
self.assertRaises(AttributeError, getattr, f, 'not_a_file_property')
self.assertTrue(os.path.exists(foo_lock))
f.write(b'new stuff')
f.seek(4)
f.write(b'contents')
f.close()
self.assertFalse(os.path.exists(foo_lock))
new_f = open(foo, 'rb')
self.assertEqual(b'new contents', new_f.read())
new_f.close()
def _complete_thin_pack(self, f, path, copier, indexer):
"""Move a specific file containing a pack into the pack directory.
:note: The file should be on the same file system as the
packs directory.
:param f: Open file object for the pack.
:param path: Path to the pack file.
:param copier: A PackStreamCopier to use for writing pack data.
:param indexer: A PackIndexer for indexing the pack.
"""
entries = list(indexer)
# Update the header with the new number of objects.
f.seek(0)
write_pack_header(f, len(entries) + len(indexer.ext_refs()))
# Must flush before reading (http://bugs.python.org/issue3207)
f.flush()
# Rescan the rest of the pack, computing the SHA with the new header.
new_sha = compute_file_sha(f, end_ofs=-20)
# Must reposition before writing (http://bugs.python.org/issue3207)
f.seek(0, os.SEEK_CUR)
# Complete the pack.
for ext_sha in indexer.ext_refs():
assert len(ext_sha) == 20
type_num, data = self.get_raw(ext_sha)
offset = f.tell()
crc32 = write_pack_object(f, type_num, data, sha=new_sha)
entries.append((ext_sha, offset, crc32))
pack_sha = new_sha.digest()
f.write(pack_sha)
f.close()
# Move the pack in.
entries.sort()
pack_base_name = self._get_pack_basepath(entries)
target_pack = pack_base_name + '.pack'
if sys.platform == 'win32':
# Windows might have the target pack file lingering. Attempt
# removal, silently passing if the target does not exist.
try:
os.remove(target_pack)
except (IOError, OSError) as e:
if e.errno != errno.ENOENT:
raise
os.rename(path, target_pack)
# Write the index.
index_file = GitFile(pack_base_name + '.idx', 'wb')
try:
write_pack_index_v2(index_file, entries, pack_sha)
index_file.close()
finally:
index_file.abort()
# Add the pack to the store and return it.
final_pack = Pack(pack_base_name)
final_pack.check_length_and_checksum()
self._add_known_pack(pack_base_name, final_pack)
return final_pack
def test_default_mode(self):
f = GitFile(self.path('foo'))
self.assertEqual(b'foo contents', f.read())
f.close()