def dump_changesets(repo):
""" Print all the changesets in a repo. """
print "---"
max_rev = repo['tip'].rev()
for rev in range(-1, max_rev + 1):
print hex_version(repo, rev)
print "---"
def dump_changesets(repo):
""" Print all the changesets in a repo. """
print "---"
max_rev = repo['tip'].rev()
for rev in range(-1, max_rev + 1):
print hex_version(repo, rev)
print "---"
def test_modify_file(self):
# setup the server repository
server_repo = self.make_repo('server')
original_page_bytes = 'This the default front page.\n'
self.commit_revision(server_repo,
(('wiki_root/wikitext/FrontPage',
original_page_bytes),),
'Initial checkin of server repo.')
# pull the client repo
client_repo = self.clone_repo(server_repo, 'client')
# get a write overlay for the client repo
overlay = self.get_write_overlay(client_repo)
page_path = 'wiki_root/wikitext/FrontPage'
page_bytes = original_page_bytes + 'Client changes.\n'
# write the updated file into it.
overlay.write(os.path.join(client_repo.root,
page_path),
page_bytes)
# make a submission bundle
raw_zip_bytes = self.make_submission_zip(client_repo)
#(fms_id, usk_hash, base_version, chk, length)
msg_id = 'fake_msg_id_000'
submission_tuple = (DEFAULT_SUBMITTER,
'000000000000',
hex_version(server_repo)[:12],
'CHK@fakechk',
len(raw_zip_bytes))
server_overlay = self.get_hg_overlay(server_repo)
server_overlay.version = hex_version(server_repo) # tip
server_page_path = os.path.join(server_repo.root, page_path)
self.assertTrue(server_overlay.exists(server_page_path))
self.assertTrue(server_overlay.read(server_page_path) ==
original_page_bytes)
# apply the submission bundle to the server repo
self.get_applier(server_repo).apply_submission(msg_id,
submission_tuple,
raw_zip_bytes,
os.path.join(
self.tmp_dir,
'_tmp__applying'))
self.assertTrue(server_overlay.exists(server_page_path))
self.assertTrue(server_overlay.read(server_page_path) ==
original_page_bytes)
server_overlay.version = hex_version(server_repo) # new tip
self.assertTrue(server_overlay.exists(server_page_path))
# check that the versions are the same
self.assertTrue(server_overlay.read(server_page_path) ==
original_page_bytes + 'Client changes.\n')
def fixup_accepted_log(self):
""" INTERNAL: Hack to fix the hg version int the accepted.txt log. """
version = hex_version(self.repo)[:12] # The new tip.
self.logger.debug("fixup_accept_log -- fixing up: %s" % version)
assert len(version) == len(SENTINEL_VER)
full_path = os.path.join(self.full_base_path(), 'accepted.txt')
in_file = open(full_path, 'rb')
try:
lines = in_file.readlines()
in_file.close()
pos = len(lines) -1
while pos >= 0:
if not lines[pos].startswith(SENTINEL_VER):
pos -= 1
continue
lines[pos] = version + lines[pos][len(version):]
break
assert pos >= 0
# Replace existing file.
os.remove(full_path)
try:
out_file = open(full_path, 'wb')
out_file.write("".join(lines))
finally:
out_file.close()
finally:
in_file.close()
def update_change_log(self, msg_id, submission_tuple, result=None,
succeeded=False):
""" Update the accepted.txt or rejected.txt change log
based on the results of a submission. """
self.logger.trace("update_change_log:\n%s\n%s\n%s\n%s" %
(msg_id, submission_tuple, str(result),
str(succeeded)))
full_path = self.full_base_path()
if succeeded:
full_path = os.path.join(full_path, 'accepted.txt')
out_file = open(full_path, 'ab')
try:
out_file.write("%s:%i:%s:%s\n" % ( SENTINEL_VER,
time.time(),
submission_tuple[0],
submission_tuple[3]))
# Created, modified, removed, skipped, forked
op_lut = ('C', 'M', 'R', '*', 'F')
for index, values in enumerate(result):
if index == 3 or index > 4:
continue # HACK # REDFLAG: change order?
if len(values):
values = list(values)
values.sort()
out_file.write("%s:%s\n" % (op_lut[index],
':'.join(values)))
finally:
out_file.close()
# Caller is resposible for commiting or setting "needs commit".
return
# Failed
full_path = os.path.join(full_path, 'rejected.txt')
if result is None:
result = REJECT_UNKNOWN # ??? just assert?
out_file = open(full_path, 'ab')
try:
out_file.write("%s:%i:%s:%s:%i\n" % (hex_version(self.repo)[:12],
time.time(),
submission_tuple[0],
submission_tuple[3],
int(result)))
finally:
out_file.close()
self.notify_needs_commit()
def start_pushing(self, insert_uri, to_versions=('tip',), request_uri=None,
is_keypair=False):
""" Start pushing local changes up to to_version to an existing
Infocalypse repository. """
self.require_state(QUIESCENT)
self.reset()
self.ctx.graph = None
self.ctx['INSERT_URI'] = insert_uri
self.ctx['REQUEST_URI'] = request_uri
# Hmmmm... better exception if to_version isn't in the repo?
self.ctx['TARGET_VERSIONS'] = tuple([hex_version(self.ctx.repo, ver)
for ver in to_versions])
if request_uri is None:
self.ctx['IS_KEYPAIR'] = True
self.transition(INVERTING_URI_4_INSERT)
else:
self.ctx['IS_KEYPAIR'] = is_keypair
self.transition(REQUESTING_URI_4_INSERT)
def start_pushing(self,
insert_uri,
to_versions=('tip', ),
request_uri=None,
is_keypair=False):
""" Start pushing local changes up to to_version to an existing
Infocalypse repository. """
self.require_state(QUIESCENT)
self.reset()
self.ctx.graph = None
self.ctx['INSERT_URI'] = insert_uri
self.ctx['REQUEST_URI'] = request_uri
# Hmmmm... better exception if to_version isn't in the repo?
self.ctx['TARGET_VERSIONS'] = tuple(
[hex_version(self.ctx.repo, ver) for ver in to_versions])
if request_uri is None:
self.ctx['IS_KEYPAIR'] = True
self.transition(INVERTING_URI_4_INSERT)
else:
self.ctx['IS_KEYPAIR'] = is_keypair
self.transition(REQUESTING_URI_4_INSERT)
def test_remove_file_conflict(self):
# setup the server repository
server_repo = self.make_repo('server')
self.commit_revision(server_repo,
(('wiki_root/wikitext/FrontPage',
'This the default front page.\n'),),
'Initial checkin of server repo.')
self.commit_revision(server_repo,
(('wiki_root/wikitext/FrontPage',
'This the updated front page.\n'),),
'Second checkin of server repo.')
# pull the client repo
client_repo = self.clone_repo(server_repo, 'client', '0')
# get a write overlay for the client repo
overlay = self.get_write_overlay(client_repo)
page_path = 'wiki_root/wikitext/FrontPage'
page_bytes = ''
# write a new file into it.
overlay.write(os.path.join(client_repo.root,
page_path),
page_bytes)
# make a submission bundle
raw_zip_bytes = self.make_submission_zip(client_repo)
#(fms_id, usk_hash, base_version, chk, length)
msg_id = 'fake_msg_id_000'
submission_tuple = (DEFAULT_SUBMITTER,
'000000000000',
hex_version(server_repo)[:12],
'CHK@fakechk',
len(raw_zip_bytes))
server_overlay = self.get_hg_overlay(server_repo)
server_overlay.version = hex_version(server_repo, '0')
server_page_path = os.path.join(server_repo.root, page_path)
# Check that the target page exists.
self.assertTrue(server_overlay.exists(server_page_path))
# apply the submission bundle to the server repo
self.get_applier(server_repo).apply_submission(msg_id,
submission_tuple,
raw_zip_bytes,
os.path.join(
self.tmp_dir,
'_tmp__applying'))
self.assertTrue(server_overlay.exists(server_page_path))
server_overlay.version = hex_version(server_repo) # new tip
self.assertTrue(server_overlay.exists(server_page_path))
# Check that the head version is the servers.
self.assertTrue(server_overlay.read(server_page_path) ==
'This the updated front page.\n')
# Check that the forked version was created.
self.has_forked_version(server_overlay, server_page_path, '')
def make_submission_zip(self, repo):
return bundle_wikitext(self.get_write_overlay(repo),
hex_version(repo),
DEFAULT_SUBMITTER)
# Resolve the final fork in client overlay.
overlay.write(os.path.join(client_repo.root,
"%s_%s" % (page_path, new_sha(texts[2]).
hexdigest())),
'')
# make a submission bundle w/ all forks resolved.
raw_zip_bytes = self.make_submission_zip(client_repo)
#(fms_id, usk_hash, base_version, chk, length)
msg_id = 'fake_msg_id_000'
submission_tuple = (DEFAULT_SUBMITTER,
'000000000000',
hex_version(server_repo)[:12],
'CHK@fakechk',
len(raw_zip_bytes))
server_overlay = self.get_hg_overlay(server_repo)
server_overlay.version = hex_version(server_repo, '0')
server_page_path = os.path.join(server_repo.root, page_path)
# Check that the target page exists.
self.assertTrue(server_overlay.exists(server_page_path))
self.assertTrue(server_overlay.read(server_page_path) != page_bytes)
self.assertTrue(overlay.read(os.path.join(client_repo.root,
page_path)) ==
