def stage(self, fs_paths):
"""Stage a set of paths.
:param fs_paths: List of paths, relative to the repository path
"""
root_path_bytes = self.path.encode(sys.getfilesystemencoding())
if not isinstance(fs_paths, list):
fs_paths = [fs_paths]
from dulwich.index import (
blob_from_path_and_stat,
index_entry_from_stat,
_fs_to_tree_path,
)
index = self.open_index()
for fs_path in fs_paths:
if not isinstance(fs_path, bytes):
fs_path = fs_path.encode(sys.getfilesystemencoding())
tree_path = _fs_to_tree_path(fs_path)
full_path = os.path.join(root_path_bytes, fs_path)
try:
st = os.lstat(full_path)
except OSError:
# File no longer exists
try:
del index[tree_path]
except KeyError:
pass # already removed
else:
blob = blob_from_path_and_stat(full_path, st)
self.object_store.add_object(blob)
index[tree_path] = index_entry_from_stat(st, blob.id, 0)
index.write()
def _import_one(self, name, data, message, author=None):
"""Import a single object.
:param name: name of the object
:param data: serialized object as list of bytes
:param message: Commit message
:param author: Optional author
:return: etag
"""
try:
with locked_index(self.repo.index_path()) as index:
p = os.path.join(self.repo.path, name)
with open(p, 'wb') as f:
f.writelines(data)
st = os.lstat(p)
blob = Blob.from_string(b''.join(data))
encoded_name = name.encode(DEFAULT_ENCODING)
if (encoded_name not in index
or blob.id != index[encoded_name].sha):
self.repo.object_store.add_object(blob)
index[encoded_name] = IndexEntry(
*index_entry_from_stat(st, blob.id, 0))
self._commit_tree(index,
message.encode(DEFAULT_ENCODING),
author=author)
return blob.id
except OSError as e:
if e.errno == errno.ENOSPC:
raise OutOfSpaceError()
raise
def stage(self, fs_paths):
"""Stage a set of paths.
:param fs_paths: List of paths, relative to the repository path
"""
root_path_bytes = self.path.encode(sys.getfilesystemencoding())
if not isinstance(fs_paths, list):
fs_paths = [fs_paths]
from dulwich.index import (
blob_from_path_and_stat,
index_entry_from_stat,
_fs_to_tree_path,
)
index = self.open_index()
for fs_path in fs_paths:
if not isinstance(fs_path, bytes):
fs_path = fs_path.encode(sys.getfilesystemencoding())
tree_path = _fs_to_tree_path(fs_path)
full_path = os.path.join(root_path_bytes, fs_path)
try:
st = os.lstat(full_path)
except OSError:
# File no longer exists
try:
del index[tree_path]
except KeyError:
pass # already removed
else:
blob = blob_from_path_and_stat(full_path, st)
self.object_store.add_object(blob)
index[tree_path] = index_entry_from_stat(st, blob.id, 0)
index.write()
def unstage(self,repo,paths=None):
from dulwich import porcelain
from dulwich.index import index_entry_from_stat
# if tree_entry does not exist, this was an add, so remove index entry to undo
# if index_ entry does not exist, this was a remove.. add back in
if paths:
for path in paths:
#print path
full_path = os.path.join(repo.path, path)
index=repo.open_index()
tree_id=repo.object_store[repo.head()]._tree
try:
tree_entry=repo.object_store[tree_id]._entries[path]
except KeyError:
try:
del(index[path])
index.write()
except KeyError:
console.hud_alert('file not in index...')
return
try:
index_entry=list(index[path])
except KeyError:
if os.path.exists(full_path):
index_entry=list(index_entry_from_stat(posix.lstat(full_path),tree_entry[1] ,0 ))
else:
index_entry=[[0]*11,tree_entry[1],0]
index_entry[4]=tree_entry[0] #mode
index_entry[7]=len(repo.object_store [tree_entry[1]].data) #size
index_entry[8]=tree_entry[1] #sha
index_entry[0]=repo.object_store[repo.head()].commit_time #ctime
index_entry[1]=repo.object_store[repo.head()].commit_time #mtime
index[path]=index_entry
index.write()
def stage(self, paths, fsencoding=sys.getfilesystemencoding()):
"""Stage a set of paths.
:param paths: List of paths, relative to the repository path
"""
if not isinstance(paths, list):
paths = [paths]
from dulwich.index import (
blob_from_path_and_stat,
index_entry_from_stat,
)
index = self.open_index()
for path in paths:
if not isinstance(path, bytes):
disk_path_bytes = path.encode(sys.getfilesystemencoding())
repo_path_bytes = path.encode(fsencoding)
else:
disk_path_bytes, repo_path_bytes = path, path
full_path = os.path.join(self._path_bytes, disk_path_bytes)
try:
st = os.lstat(full_path)
except OSError:
# File no longer exists
try:
del index[repo_path_bytes]
except KeyError:
pass # already removed
else:
blob = blob_from_path_and_stat(full_path, st)
self.object_store.add_object(blob)
index[repo_path_bytes] = index_entry_from_stat(st, blob.id, 0)
index.write()
def stage(self, paths):
"""Stage a set of paths.
:param paths: List of paths, relative to the repository path
"""
if isinstance(paths, basestring):
paths = [paths]
from dulwich.index import index_entry_from_stat
index = self.open_index()
for path in paths:
full_path = os.path.join(self.path, path)
try:
st = os.stat(full_path)
except OSError:
# File no longer exists
try:
del index[path]
except KeyError:
pass # already removed
else:
blob = Blob()
f = open(full_path, 'rb')
try:
blob.data = f.read()
finally:
f.close()
self.object_store.add_object(blob)
index[path] = index_entry_from_stat(st, blob.id, 0)
index.write()
def test_override_mode(self):
st = os.stat_result((
stat.S_IFREG + 0o644,
131078,
64769,
154,
1000,
1000,
12288,
1323629595,
1324180496,
1324180496,
))
entry = index_entry_from_stat(st,
"22" * 20,
0,
mode=stat.S_IFREG + 0o755)
self.assertEqual(
entry,
(
1324180496,
1324180496,
64769,
131078,
33261,
1000,
1000,
12288,
"2222222222222222222222222222222222222222",
0,
),
)
def test_simple(self):
st = os.stat_result((16877, 131078, 64769, 154, 1000, 1000, 12288,
1323629595, 1324180496, 1324180496))
entry = index_entry_from_stat(st, "22" * 20, 0)
self.assertEqual(
entry, (1324180496, 1324180496, 64769, 131078, 16384, 1000, 1000,
12288, '2222222222222222222222222222222222222222', 0))
def unstage(self, repo, paths=None):
from dulwich import porcelain
from dulwich.index import index_entry_from_stat
# if tree_entry does not exist, this was an add, so remove index entry to undo
# if index_ entry does not exist, this was a remove.. add back in
if paths:
for path in paths:
# print path
full_path = os.path.join(repo.path, path)
index = repo.open_index()
tree_id = repo.object_store[repo.head()]._tree
try:
tree_entry = repo.object_store[tree_id]._entries[path]
except KeyError:
try:
del(index[path])
index.write()
except KeyError:
console.hud_alert('file not in index...')
return
try:
index_entry = list(index[path])
except KeyError:
if os.path.exists(full_path):
index_entry = list(index_entry_from_stat(posix.lstat(full_path), tree_entry[1], 0))
else:
index_entry = [[0] * 11, tree_entry[1], 0]
index_entry[4] = tree_entry[0] # mode
index_entry[7] = len(repo.object_store[tree_entry[1]].data) # size
index_entry[8] = tree_entry[1] # sha
index_entry[0] = repo.object_store[repo.head()].commit_time # ctime
index_entry[1] = repo.object_store[repo.head()].commit_time # mtime
index[path] = index_entry
index.write()
def stage(self, paths, fsencoding=sys.getfilesystemencoding()):
"""Stage a set of paths.
:param paths: List of paths, relative to the repository path
"""
if not isinstance(paths, list):
paths = [paths]
from dulwich.index import (
blob_from_path_and_stat,
index_entry_from_stat,
)
index = self.open_index()
for path in paths:
full_path = os.path.join(self.path, path)
try:
st = os.lstat(full_path)
except OSError:
# File no longer exists
try:
del index[path.encode(fsencoding)]
except KeyError:
pass # already removed
else:
blob = blob_from_path_and_stat(full_path, st)
self.object_store.add_object(blob)
index[path.encode(fsencoding)] = index_entry_from_stat(st, blob.id, 0)
index.write()
def stage(self, paths):
"""Stage a set of paths.
:param paths: List of paths, relative to the repository path
"""
if isinstance(paths, basestring):
paths = [paths]
from dulwich.index import index_entry_from_stat
index = self.open_index()
for path in paths:
full_path = os.path.join(self.path, path)
try:
st = os.stat(full_path)
except OSError:
# File no longer exists
try:
del index[path]
except KeyError:
pass # already removed
else:
blob = Blob()
f = open(full_path, 'rb')
try:
blob.data = f.read()
finally:
f.close()
self.object_store.add_object(blob)
index[path] = index_entry_from_stat(st, blob.id, 0)
index.write()
def _live_entry(self, path):
path = urlutils.quote_from_bytes(path)
stat_val = self._lstat(path)
if stat.S_ISDIR(stat_val.st_mode):
return None
elif stat.S_ISLNK(stat_val.st_mode):
blob = Blob.from_string(
self._file_transport.readlink(path).encode('utf-8'))
elif stat.S_ISREG(stat_val.st_mode):
blob = Blob.from_string(self._file_transport.get_bytes(path))
else:
raise AssertionError('unknown type %d' % stat_val.st_mode)
return index_entry_from_stat(stat_val, blob.id, 0)
def stage(self, fs_paths):
"""Stage a set of paths.
Args:
fs_paths: List of paths, relative to the repository path
"""
root_path_bytes = os.fsencode(self.path)
if not isinstance(fs_paths, list):
fs_paths = [fs_paths]
from dulwich.index import (
blob_from_path_and_stat,
index_entry_from_stat,
_fs_to_tree_path,
)
index = self.open_index()
blob_normalizer = self.get_blob_normalizer()
for fs_path in fs_paths:
if not isinstance(fs_path, bytes):
fs_path = os.fsencode(fs_path)
if os.path.isabs(fs_path):
raise ValueError(
"path %r should be relative to "
"repository root, not absolute" % fs_path)
tree_path = _fs_to_tree_path(fs_path)
full_path = os.path.join(root_path_bytes, fs_path)
try:
st = os.lstat(full_path)
except OSError:
# File no longer exists
try:
del index[tree_path]
except KeyError:
pass # already removed
else:
if (not stat.S_ISREG(st.st_mode) and
not stat.S_ISLNK(st.st_mode)):
try:
del index[tree_path]
except KeyError:
pass
else:
blob = blob_from_path_and_stat(full_path, st)
blob = blob_normalizer.checkin_normalize(blob, fs_path)
self.object_store.add_object(blob)
index[tree_path] = index_entry_from_stat(st, blob.id, 0)
index.write()
def test_simple(self):
st = os.stat_result((16877, 131078, 64769,
154, 1000, 1000, 12288,
1323629595, 1324180496, 1324180496))
entry = index_entry_from_stat(st, "22" * 20, 0)
self.assertEqual(entry, (
1324180496,
1324180496,
64769,
131078,
16384,
1000,
1000,
12288,
'2222222222222222222222222222222222222222',
0))
def test_override_mode(self):
st = os.stat_result((stat.S_IFREG + 0o644, 131078, 64769,
154, 1000, 1000, 12288,
1323629595, 1324180496, 1324180496))
entry = index_entry_from_stat(st, "22" * 20, 0,
mode=stat.S_IFREG + 0o755)
self.assertEqual(entry, (
1324180496,
1324180496,
64769,
131078,
33261,
1000,
1000,
12288,
'2222222222222222222222222222222222222222',
0))
def stage(self, fs_paths):
"""Stage a set of paths.
:param fs_paths: List of paths, relative to the repository path
"""
root_path_bytes = self.path.encode(sys.getfilesystemencoding())
if not isinstance(fs_paths, list):
fs_paths = [fs_paths]
from dulwich.index import (
blob_from_path_and_stat,
index_entry_from_stat,
_fs_to_tree_path,
)
index = self.open_index()
blob_normalizer = self.get_blob_normalizer()
for fs_path in fs_paths:
if not isinstance(fs_path, bytes):
fs_path = fs_path.encode(sys.getfilesystemencoding())
if os.path.isabs(fs_path):
raise ValueError(
"path %r should be relative to "
"repository root, not absolute" % fs_path)
tree_path = _fs_to_tree_path(fs_path)
full_path = os.path.join(root_path_bytes, fs_path)
try:
st = os.lstat(full_path)
except OSError:
# File no longer exists
try:
del index[tree_path]
except KeyError:
pass # already removed
else:
if not stat.S_ISDIR(st.st_mode):
blob = blob_from_path_and_stat(full_path, st)
blob = blob_normalizer.checkin_normalize(blob, fs_path)
self.object_store.add_object(blob)
index[tree_path] = index_entry_from_stat(st, blob.id, 0)
else:
try:
del index[tree_path]
except KeyError:
pass
index.write()
def _checkout_entry(self,index,path,mode,sha):
full_path = os.path.join(self.path, path)
checked_out_entry = False
if stat.S_ISREG(mode):
if not os.path.exists(os.path.dirname(full_path)):
os.makedirs(os.path.dirname(full_path))
f = open(full_path, 'wb')
try:
f.write(self.object_store[sha].as_raw_string())
finally:
f.close()
os.chmod(full_path, mode)
checked_out_entry = True
elif dulwich.objects.S_ISGITLINK(mode) and path in self.subrepo:
self.subrepo[path][1].checkout(self.subrepo[path][0])
checked_out_entry = True
if checked_out_entry:
st = os.lstat(full_path)
index[path] = index_entry_from_stat(st, sha, 0, mode=mode)
index.write()
def unstage(commit='HEAD', paths=[]):
repo = _get_repo().repo
for somepath in paths:
#print path
path = _get_repo().relpath(somepath)
full_path = os.path.join(repo.path, path)
index = repo.open_index()
tree_id = repo[commit]._tree
try:
tree_entry = repo[tree_id].lookup_path(lambda x: repo[x], path)
except KeyError:
#if tree_entry didnt exist, this file was being added, so remove index entry
try:
del (index[path])
index.write()
except KeyError:
print('file not in index.', path)
return
try:
index_entry = list(index[path])
except KeyError:
#if index_entry doesnt exist, this file was being removed. readd it
if os.path.exists(full_path):
index_entry = list(
index_entry_from_stat(posix.lstat(full_path),
tree_entry[1], 0))
else:
index_entry = [[0] * 11, tree_entry[1], 0]
#update index entry stats to reflect commit
index_entry[4] = tree_entry[0] #mode
index_entry[7] = len(repo[tree_entry[1]].data) #size
index_entry[8] = tree_entry[1] #sha
index_entry[0] = repo[commit].commit_time #ctime
index_entry[1] = repo[commit].commit_time #mtime
index[path] = index_entry
index.write()
def _import_one(self, name, data, message, author=None):
"""Import a single object.
:param name: name of the object
:param data: serialized object as list of bytes
:param message: Commit message
:param author: Optional author
:return: etag
"""
with locked_index(self.repo.index_path()) as index:
p = os.path.join(self.repo.path, name)
with open(p, 'wb') as f:
f.writelines(data)
st = os.lstat(p)
blob = Blob.from_string(b''.join(data))
self.repo.object_store.add_object(blob)
index[name.encode(DEFAULT_ENCODING)] = IndexEntry(
*index_entry_from_stat(st, blob.id, 0))
self._commit_tree(index,
message.encode(DEFAULT_ENCODING),
author=author)
return blob.id
def unstage(commit='HEAD',paths=[]):
repo=_get_repo().repo
for somepath in paths:
#print path
path=_get_repo().relpath(somepath)
full_path = os.path.join(repo.path, path)
index=repo.open_index()
tree_id=repo[commit]._tree
try:
tree_entry=repo[tree_id].lookup_path(lambda x:repo[x],path)
except KeyError:
#if tree_entry didnt exist, this file was being added, so remove index entry
try:
del(index[path])
index.write()
except KeyError:
print 'file not in index.',path
return
try:
index_entry=list(index[path])
except KeyError:
#if index_entry doesnt exist, this file was being removed. readd it
if os.path.exists(full_path):
index_entry=list(index_entry_from_stat(posix.lstat(full_path),tree_entry[1] ,0 ))
else:
index_entry=[[0]*11,tree_entry[1],0]
#update index entry stats to reflect commit
index_entry[4]=tree_entry[0] #mode
index_entry[7]=len(repo[tree_entry[1]].data) #size
index_entry[8]=tree_entry[1] #sha
index_entry[0]=repo[commit].commit_time #ctime
index_entry[1]=repo[commit].commit_time #mtime
index[path]=index_entry
index.write()
