committer_email = email
committer_name = name
message = b'a'
# ASCII hex of parents.
parents = ()
# Blob.
blob_sha_ascii, blob_sha = util.save_object(b'blob', blob_content)
# Check sha matches Git.
blob_sha_git = util.get_git_hash_object(b'blob', blob_content)
assert blob_sha_ascii == blob_sha_git
# Tree.
tree_sha_ascii, tree_sha, tree_content = util.save_tree_object(blob_mode, blob_basename, blob_sha)
# Check sha matches Git.
tree_sha_git = util.get_git_hash_object(b'tree', tree_content)
assert tree_sha_ascii == tree_sha_git
# Commit.
commit_sha_ascii, commit_sha, commit_content = util.save_commit_object(
tree_sha_ascii, parents,
author_name, author_email, author_date,
committer_name, committer_email, committer_date,
message)
commit_sha_git = util.get_git_hash_object(b'commit', commit_content)
assert commit_sha_ascii == commit_sha_git
# Finish.
util.create_master(commit_sha_ascii)
util.clone()
email = b'*****@*****.**'
name = b''
util.init()
tree = util.create_tree_with_one_file()
commit = None
n = 1000000
for i in range(n):
now = int(time.time())
commit, _, _ = util.save_commit_object(
tree,
(commit, ),
author_date_s=0,
author_email=email,
author_name=name,
committer_date_s=0,
committer_email=email,
committer_name=name,
message=b'',
)
if i % 100000 == 0:
print(i)
print(datetime.datetime.now())
# Lose objects are too large and blow up the tmpfs.
# Does clean packets, but the calculation takes more and more memory,
# and slows down and blows up at the end. TODO which subcommand blows up eactly?.
#subprocess.check_output(['git', 'gc'])
subprocess.check_output(['git', 'repack'])
subprocess.check_output(['git', 'prune-packed'])
subprocess.check_output(['git', 'tag', str(i), commit])
tree = util.create_tree_with_one_file()
commit = None
n = 1000000
percent = (n / 100)
p = 0
i = 0
data_paths = sorted(os.listdir(data_dir_path))
for data_path in data_paths:
data_path = os.path.join(data_dir_path, data_path)
with open(data_path, 'rb') as f:
for line in f:
email = line.rstrip()[:255]
commit, _, _ = util.save_commit_object(
tree,
(commit, ),
author_email=email,
committer_email=email,
)
if i % percent == 0:
print(p)
print(email)
print(datetime.datetime.now())
p += 1
# Lose objects are too large and blow up the tmpfs.
# Does clean packets, but the calculation takes more and more memory,
# and slows down and blows up at the end. TODO which subcommand blows up eactly?.
#subprocess.check_output(['git', 'gc'])
subprocess.check_output(['git', 'repack'])
util.init()
tree = util.create_tree_with_one_file()
commit = None
n = 1000000
percent = (n / 100)
p = 0
for i in range(n):
now = int(time.time())
commit, _, _ = util.save_commit_object(
tree,
(commit,),
author_date_s=now,
author_email=email,
author_name=name,
committer_date_s=now,
committer_email=email,
committer_name=name,
message=(str(i).encode('ascii')),
)
if i % percent == 0:
print(p)
print(datetime.datetime.now())
p += 1
# Lose objects are too large and blow up the tmpfs.
# Does clean packets, but the calculation takes more and more memory,
# and slows down and blows up at the end. TODO which subcommand blows up eactly?.
#subprocess.check_output(['git', 'gc'])
tree = util.create_tree_with_one_file()
commit = None
n = 1000000
percent = (n / 100)
p = 0
i = 0
data_paths = sorted(os.listdir(data_dir_path))
for data_path in data_paths:
data_path = os.path.join(data_dir_path, data_path)
with open(data_path, 'rb') as f:
for line in f:
email = line.rstrip()[:255]
commit, _, _ = util.save_commit_object(
tree,
(commit,),
author_email=email,
committer_email=email,
)
if i % percent == 0:
print(p)
print(email)
print(datetime.datetime.now())
p += 1
# Lose objects are too large and blow up the tmpfs.
# Does clean packets, but the calculation takes more and more memory,
# and slows down and blows up at the end. TODO which subcommand blows up eactly?.
#subprocess.check_output(['git', 'gc'])
subprocess.check_output(['git', 'repack'])
name = b''
util.init()
tree = util.create_tree_with_one_file()
commit = None
if len(sys.argv) > 1:
n = int(sys.argv[1])
else:
n = 1000
base_commit, _, _ = util.save_commit_object(
tree,
(commit,),
author_date_s=0,
author_email=email,
author_name=name,
committer_date_s=0,
committer_email=email,
committer_name=name,
message=b'',
)
parents = []
for i in range(n):
now = int(time.time())
commit, _, _ = util.save_commit_object(
tree,
(base_commit,),
author_date_s=i,
author_email=email,
author_name=name,
committer_date_s=0,
#!/usr/bin/env python3 """ Git does not let a commit have twice the same parent, but GitHub does, and normally shows it. But as of 2016-05-17 they didn't page this edge case, and it 502's the commit for large numbers of links. If you increase the value a lot, when you clone and cd into the repo. your computer may bog down if you show a git status on the bash, because Git memory explodes trying to parse that. Actual compressed size is very small though, since gzip compresses all that repeated data very efficiently. push would require an obscene ammount of memory (malloc fails on `ulimit -Sv`), so I couldn't test it. """ import itertools import util util.init() tree = util.create_tree_with_one_file() commit, _, _ = util.save_commit_object(tree, author_name=b'a') commit, _, _ = util.save_commit_object(tree, itertools.repeat(commit, 10000000), author_name=b'b') # Finish. util.create_master(commit) util.clone()
import time
import sys
import util
email = b'*****@*****.**'
name = b''
util.init()
tree = util.create_tree_with_one_file()
commit, _, _ = util.save_commit_object(
tree,
(None,),
author_date_s=0,
author_email=email,
author_name=name,
committer_date_s=0,
committer_email=email,
committer_name=name,
message=b'',
)
tag_sha, _, _ = util.save_tag_object(
commit,
b'mytag',
object_type=b'commit',
user_name=name,
user_email=email,
date_s=0,
message=b'abc'
)
util.create_master(commit)
#!/usr/bin/env python3
"""
Git does not let a commit have twice the same parent, but GitHub does, and normally shows it.
But as of 2016-05-17 they didn't page this edge case, and it 502's the commit for large numbers of links.
If you increase the value a lot, when you clone and cd into the repo. your computer may bog down
if you show a git status on the bash, because Git memory explodes trying to parse that.
Actual compressed size is very small though, since gzip compresses all that repeated data very efficiently.
push would require an obscene ammount of memory (malloc fails on `ulimit -Sv`), so I couldn't test it.
"""
import itertools
import util
util.init()
tree = util.create_tree_with_one_file()
commit, _, _ = util.save_commit_object(tree, author_name=b'a')
commit, _, _ = util.save_commit_object(tree,
itertools.repeat(commit, 10000000),
author_name=b'b')
# Finish.
util.create_master(commit)
util.clone()
util.init()
tree = util.create_tree_with_one_file()
commit = None
n = 1000000
percent = (n / 100)
p = 0
for i in range(n):
now = int(time.time())
commit, _, _ = util.save_commit_object(
tree,
(commit, ),
author_date_s=now,
author_email=email,
author_name=name,
committer_date_s=now,
committer_email=email,
committer_name=name,
message=(str(i).encode('ascii')),
)
if i % percent == 0:
print(p)
print(datetime.datetime.now())
p += 1
# Lose objects are too large and blow up the tmpfs.
# Does clean packets, but the calculation takes more and more memory,
# and slows down and blows up at the end. TODO which subcommand blows up eactly?.
#subprocess.check_output(['git', 'gc'])
name = b''
util.init()
tree = util.create_tree_with_one_file()
commit = None
if len(sys.argv) > 1:
n = int(sys.argv[1])
else:
n = 1000
base_commit, _, _ = util.save_commit_object(
tree,
(commit, ),
author_date_s=0,
author_email=email,
author_name=name,
committer_date_s=0,
committer_email=email,
committer_name=name,
message=b'',
)
parents = []
for i in range(n):
now = int(time.time())
commit, _, _ = util.save_commit_object(
tree,
(base_commit, ),
author_date_s=i,
author_email=email,
author_name=name,
committer_date_s=0,