This is an archive of the discontinued Mercurial Phabricator instance.

p4fastimport: allow sync commits only when imported repository is up-to-date
AcceptedPublic

Authored by dsp on Dec 21 2017, 8:18 PM.

Download Raw Diff

Details

Reviewers

Summary

Previously we allowed a sync commit to happen at any time, but imported the
full repository to bring it into sync. This is slow for very large repositories
and might be accidentally triggered. We change this behavior to only do a sync
commit if only the imported client changed but nothing else.

Test Plan

cd tests
python ../../hg-crew/tests/run-tests.py test-p4fastimport-*.t test-check*.t

Diff Detail

Lint

Lint Skipped

Unit

Unit Tests Skipped

Event Timeline

dsp created this revision.Dec 21 2017, 8:18 PM

kaleyh requested changes to this revision.Dec 22 2017, 5:37 PM

kaleyh added a subscriber: kaleyh.

kaleyh added inline comments.

tests/test-p4fastimport-blobcommit.t
134	What client will it use if we fall back to `fast import` ? Since CL 5 touches files that are not in the current client spec, will `fast import` be able to update the repo to CL5?

This revision now requires changes to proceed.Dec 22 2017, 5:37 PM

dsp added inline comments.Jan 2 2018, 2:37 PM

tests/test-p4fastimport-blobcommit.t
134	Yes, using the old clientspec it will be able to update it.

dsp requested review of this revision.Jan 2 2018, 2:38 PM

dsp added inline comments.Jan 2 2018, 2:42 PM

tests/test-p4fastimport-blobcommit.t
134	In case `p4fastimport` uses the new client-spec, it behaves like before: if a file changes it will happily included it. So what we want to do is: use the new-spec only after p4syncimport changed. Maybe in an upcoming change we can save information about the clientspec in Mercurial to automatically detect a change in the p4fastimport case

kaleyh accepted this revision.Jan 3 2018, 4:56 PM

kaleyh added inline comments.

tests/test-p4fastimport-blobcommit.t
134	that can be a good idea

This revision is now accepted and ready to land.Jan 3 2018, 4:56 PM

Revision Contents
Changeset List

			Path	Packages
M			hgext3rd/p4fastimport/__init__.py (37 lines)
M			hgext3rd/p4fastimport/importer.py (4 lines)
M			hgext3rd/p4fastimport/util.py (12 lines)
M			tests/test-p4fastimport-blobcommit-lfs.t (45 lines)
M			tests/test-p4fastimport-blobcommit.t (184 lines)

Status	Author	Revision
Accepted	dsp	D1743 p4fastimport: allow sync commits only when imported repository is up-to-date
Accepted	dsp	D1742 p4fastimport: return the last changelist number that affects the client view
Accepted	dsp	D1741 p4fastimport: fix symlink test on MacOS

Diff 4577

hgext3rd/p4fastimport/init.py

	import sqlite3			import sqlite3

	from . import (			from . import (
	p4,			p4,
	importer,			importer,
	filetransaction as ftrmod			filetransaction as ftrmod
	)			)

	from .util import runworker, lastcl, decodefileflags			from .util import runworker, lastcl, getcl, decodefileflags

	from mercurial.i18n import _			from mercurial.i18n import _
	from mercurial.node import short, hex			from mercurial.node import short, hex
	from mercurial import (			from mercurial import (
	error,			error,
	extensions,			extensions,
	registrar,			registrar,
	revlog,			revlog,
	tr.release()			tr.release()
	finally:			finally:
	ftr.release()			ftr.release()

	@command(			@command(
	'p4syncimport',			'p4syncimport',
	[('P', 'path', '.', _('path to the local depot store'), _('PATH')),			[('P', 'path', '.', _('path to the local depot store'), _('PATH')),
	('B', 'bookmark', '', _('bookmark to set'), _('NAME'))],			('B', 'bookmark', '', _('bookmark to set'), _('NAME'))],
	_('[-P PATH] client [-B NAME] bookmarkname'),			_('[-P PATH] [-B NAME] oldclient newclient'),
	)			)
	def p4syncimport(ui, repo, client, **opts):			def p4syncimport(ui, repo, oldclient, newclient, **opts):
	if opts.get('bookmark'):			if opts.get('bookmark'):
	scmutil.checknewlabel(repo, opts['bookmark'], 'bookmark')			scmutil.checknewlabel(repo, opts['bookmark'], 'bookmark')

	if len(repo) == 0:			if len(repo) == 0:
	raise error.Abort(_('p4 sync commit does not support empty repo yet.'))			raise error.Abort(_('p4 sync commit does not support empty repo yet.'))

	p1ctx, startcl, __ = startfrom(ui, repo, opts)			p1ctx, startcl, __ = startfrom(ui, repo, opts)

	# Fail if the specified client does not exist			# Fail if the specified client does not exist
	if not p4.exists_client(client):			if not p4.exists_client(oldclient):
	raise error.Abort(_('p4 client %s does not exist.') % client)			raise error.Abort(_('p4 client %s does not exist.') % oldclient)
				if not p4.exists_client(newclient):
				raise error.Abort(_('p4 client %s does not exist.') % newclient)

	# Get a list of files that we will have to import			# Get a list of files that we will have to import
	latestcl = p4.get_latest_cl(client)			oldcl = p4.get_latest_cl(oldclient)
				latestcl = p4.get_latest_cl(newclient)
				lastimportedcl = getcl(p1ctx)
	if latestcl is None:			if latestcl is None:
	raise error.Abort(_('Cannot find latest p4 changelist number.'))			raise error.Abort(_('cannot find latest p4 changelist number'))
				ui.debug('%r (current client) %r (requested client) '
				'%r (latest imported)\n' % (oldcl, latestcl, lastimportedcl))
				if oldcl != lastimportedcl:
				# Consider running p4fastimport from here
				raise error.Abort(_('repository must contain most recent changes'))

	ui.note(_('Latest change list number %s\n') % latestcl)			ui.note(_('latest change list number %s\n') % latestcl)
	p4filelogs = p4.get_filelogs_at_cl(client, latestcl)			p4filelogs = p4.get_filelogs_at_cl(newclient, latestcl)
	p4filelogs = sorted(p4filelogs)			p4filelogs = sorted(p4filelogs)
	newp4filelogs, reusep4filelogs = importer.get_filelogs_to_sync(			newp4filelogs, reusep4filelogs = importer.get_filelogs_to_sync(
	client, repo, p1ctx, startcl - 1, p4filelogs)			newclient, repo, p1ctx, startcl - 1, p4filelogs)

				if not newp4filelogs and not reusep4filelogs:
				raise error.Abort(_('nothing to import.'))

	# sync import.			# sync import.
	with repo.wlock(), repo.lock():			with repo.wlock(), repo.lock():
	ui.note(_('running a sync import.\n'))			ui.note(_('running a sync import.\n'))
	count = 0			count = 0
	fileinfo = {}			fileinfo = {}
	largefileslist = []			largefileslist = []
	tr = repo.transaction('syncimport')			tr = repo.transaction('syncimport')
	try:			try:
	for p4fl, localname in newp4filelogs:			for p4fl, localname in newp4filelogs:
	bfi = importer.SyncFileImporter(			bfi = importer.SyncFileImporter(
	ui, repo, client, latestcl, p4fl, localfile=localname)			ui, repo, newclient, latestcl, p4fl,
				localfile=localname)
	# Create hg filelog			# Create hg filelog
	fileflags, largefiles, oldtiprev, newtiprev = bfi.create(tr)			fileflags, largefiles, oldtiprev, newtiprev = bfi.create(tr)
	fileinfo[p4fl.depotfile] = {			fileinfo[p4fl.depotfile] = {
	'flags': fileflags,			'flags': fileflags,
	'localname': bfi.relpath,			'localname': bfi.relpath,
	'baserev': oldtiprev,			'baserev': oldtiprev,
	}			}
	largefileslist.extend(largefiles)			largefileslist.extend(largefiles)
	count += 1			count += 1
	# Generate manifest and changelog			# Generate manifest and changelog
	clog = importer.SyncChangeManifestImporter(			clog = importer.SyncChangeManifestImporter(
	ui, repo, client, latestcl, p1ctx=p1ctx)			ui, repo, newclient, latestcl, p1ctx=p1ctx)
	revisions = []			revisions = []
	for cl, hgnode in clog.creategen(tr, fileinfo, reusep4filelogs):			for cl, hgnode in clog.creategen(tr, fileinfo, reusep4filelogs):
	revisions.append((cl, hex(hgnode)))			revisions.append((cl, hex(hgnode)))

	if opts.get('bookmark'):			if opts.get('bookmark'):
	ui.note(_('writing bookmark\n'))			ui.note(_('writing bookmark\n'))
	writebookmark(tr, repo, revisions, opts['bookmark'])			writebookmark(tr, repo, revisions, opts['bookmark'])

hgext3rd/p4fastimport/importer.py

	P4_ADMIN_USER = 'p4admin'			P4_ADMIN_USER = 'p4admin'

	def relpath(client, depotfile):			def relpath(client, depotfile):
	where = p4.parse_where(client, depotfile)			where = p4.parse_where(client, depotfile)
	filename = where['clientFile'].replace('//%s/' % client, '')			filename = where['clientFile'].replace('//%s/' % client, '')
	return p4.decodefilename(filename)			return p4.decodefilename(filename)

	def get_filelogs_to_sync(client, repo, p1ctx, cl, p4filelogs):			def get_filelogs_to_sync(client, repo, p1ctx, cl, p4filelogs):
	latestcl = p4.get_latest_cl(client)
	if latestcl > cl or latestcl is None:
	p4filelogslist = [(p4fl, None) for p4fl in p4filelogs]
	return p4filelogslist, []
	p1 = repo[p1ctx.node()]			p1 = repo[p1ctx.node()]
	hgfilelogs = p1.manifest().copy()			hgfilelogs = p1.manifest().copy()
	addedp4filelogs = []			addedp4filelogs = []
	reusep4filelogs = []			reusep4filelogs = []
	for p4fl in p4filelogs:			for p4fl in p4filelogs:
	localname = relpath(client, p4fl.depotfile)			localname = relpath(client, p4fl.depotfile)
	if localname in hgfilelogs:			if localname in hgfilelogs:
	reusep4filelogs.append(localname)			reusep4filelogs.append(localname)

hgext3rd/p4fastimport/util.py

	return sorted(conflicts)			return sorted(conflicts)

	def decodefileflags(json):			def decodefileflags(json):
	r = collections.defaultdict(dict)			r = collections.defaultdict(dict)
	for changelist, flag in json.items():			for changelist, flag in json.items():
	r[int(changelist)] = flag.encode('ascii')			r[int(changelist)] = flag.encode('ascii')
	return r			return r

	def lastcl(node):			def getcl(node):
	if node:			if node:
	assert node.extra().get('p4changelist') or \			assert node.extra().get('p4changelist') or \
	node.extra().get('p4fullimportbasechangelist')			node.extra().get('p4fullimportbasechangelist')
	if node.extra().get('p4changelist'):			if node.extra().get('p4changelist'):
	return int(node.extra()['p4changelist']) + 1			return int(node.extra()['p4changelist'])
	else:			else:
	return int(node.extra()['p4fullimportbasechangelist']) + 1			return int(node.extra()['p4fullimportbasechangelist'])
				return None

				def lastcl(node):
				clnum = getcl(node)
				if clnum:
				return clnum + 1
	return None			return None

	def runworker(ui, fn, wargs, items):			def runworker(ui, fn, wargs, items):
	# 0.4 is the cost per argument. So if we have at least 100 files			# 0.4 is the cost per argument. So if we have at least 100 files
	# on a 4 core machine than our linear cost outweights the			# on a 4 core machine than our linear cost outweights the
	# drawback of spwaning. We are overwritign this if we force a			# drawback of spwaning. We are overwritign this if we force a
	# worker to run with a ridiculous high number.			# worker to run with a ridiculous high number.
	weight = 0.0 # disable worker			weight = 0.0 # disable worker

tests/test-p4fastimport-blobcommit-lfs.t

	#require p4			#require p4

	$ . $TESTDIR/p4setup.sh			$ . $TESTDIR/p4setup.sh
	$ cat >> $HGRCPATH<<EOF			$ cat >> $HGRCPATH<<EOF
	> [extensions]			> [extensions]
	> lfs=$TESTDIR/../hgext3rd/lfs			> lfs=$TESTDIR/../hgext3rd/lfs
	> [p4fastimport]			> [p4fastimport]
	> lfspointeronly=True			> lfspointeronly=True
	> lfsmetadata=lfs.sql			> lfsmetadata=lfs.sql
	> [lfs]			> [lfs]
	> threshold=10			> threshold=10
	> EOF			> EOF

				$ p4 client -o hg-p4-import-narrow \| sed '/^View:/,$ d' >p4client
				$ echo "View:" >>p4client
				$ echo " //depot/Main/... //hg-p4-import-narrow/Main/..." >>p4client
				$ p4 client -i <p4client
				Client hg-p4-import-narrow saved.

	populate the depot			populate the depot
	$ mkdir Main			$ mkdir Main
	$ echo a > Main/a			$ echo a > Main/a
	$ echo thisisasuperlargefilebewithmorethank10ksize >> Main/largefile			$ echo thisisasuperlargefilebewithmorethank10ksize >> Main/largefile
	$ p4 add Main/a Main/largefile			$ p4 add Main/a Main/largefile
	//depot/Main/a#1 - opened for add			//depot/Main/a#1 - opened for add
	//depot/Main/largefile#1 - opened for add			//depot/Main/largefile#1 - opened for add
	$ p4 submit -d initial			$ p4 submit -d initial
	edit //depot/Main/a#2			edit //depot/Main/a#2
	edit //depot/Main/largefile#2			edit //depot/Main/largefile#2
	Change 2 submitted.			Change 2 submitted.

	Sync Commit			Sync Commit

	$ cd $hgwd			$ cd $hgwd
	$ hg init --config 'format.usefncache=False'			$ hg init --config 'format.usefncache=False'
	$ hg p4fastimport --debug -P $P4ROOT hg-p4-import			$ hg p4fastimport --debug -P $P4ROOT hg-p4-import-narrow
	loading changelist numbers.			loading changelist numbers.
	2 changelists to import.			2 changelists to import.
	loading list of files.			loading list of files.
	2 files to import.			2 files to import.
	reading filelog * (glob)			reading filelog * (glob)
	reading filelog * (glob)			reading filelog * (glob)
	updating the branch cache (?)			updating the branch cache (?)
	importing repository.			importing repository.
	writing filelog: b789fdd96dc2, p1 000000000000, linkrev 0, 2 bytes, src: *, path: Main/a (glob)			writing filelog: b789fdd96dc2, p1 000000000000, linkrev 0, 2 bytes, src: *, path: Main/a (glob)
	writing filelog: a80d06849b33, p1 b789fdd96dc2, linkrev 1, 4 bytes, src: *, path: Main/a (glob)			writing filelog: a80d06849b33, p1 b789fdd96dc2, linkrev 1, 4 bytes, src: *, path: Main/a (glob)
	writing filelog: b3a729dd094e, p1 000000000000, linkrev 0, 44 bytes, src: *, path: Main/largefile (glob)			writing filelog: b3a729dd094e, p1 000000000000, linkrev 0, 44 bytes, src: *, path: Main/largefile (glob)
	largefile: Main/largefile, oid: 37a7b43abd9e105a0e6b22088b140735a02f288767fe7a6f4f436cb46b064ca9			largefile: Main/largefile, oid: 37a7b43abd9e105a0e6b22088b140735a02f288767fe7a6f4f436cb46b064ca9
	writing filelog: 9f14f96519e1, p1 b3a729dd094e, linkrev 1, 88 bytes, src: *, path: Main/largefile (glob)			writing filelog: 9f14f96519e1, p1 b3a729dd094e, linkrev 1, 88 bytes, src: *, path: Main/largefile (glob)
	largefile: Main/largefile, oid: b0d5c1968efbabbff9d94160f284cd7b52686ca3c46cfffdd351de07384fce9c			largefile: Main/largefile, oid: b0d5c1968efbabbff9d94160f284cd7b52686ca3c46cfffdd351de07384fce9c
	changelist 1: writing manifest. node: 9bbc5d2af2f4 p1: 000000000000 p2: 000000000000 linkrev: 0			changelist 1: writing manifest. node: 9bbc5d2af2f4 p1: 000000000000 p2: 000000000000 linkrev: 0
	changelist 1: writing changelog: initial			changelist 1: writing changelog: initial
	changelist 2: writing manifest. node: c14352bb3510 p1: 9bbc5d2af2f4 p2: 000000000000 linkrev: 1			changelist 2: writing manifest. node: c14352bb3510 p1: 9bbc5d2af2f4 p2: 000000000000 linkrev: 1
	changelist 2: writing changelog: second			changelist 2: writing changelog: second
	writing lfs metadata to sqlite			writing lfs metadata to sqlite
	updating the branch cache			updating the branch cache
	2 revision(s), 2 file(s) imported.			2 revision(s), 2 file(s) imported.

	$ cd $p4wd			$ cd $p4wd
	$ echo thisisanotherlargefile > Main/anotherlargefile			$ mkdir Outside
	$ p4 add Main/anotherlargefile			$ echo thisisanotherlargefile > Outside/anotherlargefile
	//depot/Main/anotherlargefile#1 - opened for add			$ p4 add Outside/anotherlargefile
				//depot/Outside/anotherlargefile#1 - opened for add
	$ p4 submit -d third			$ p4 submit -d third
	Submitting change 3.			Submitting change 3.
	Locking 1 files ...			Locking 1 files ...
	add //depot/Main/anotherlargefile#1			add //depot/Outside/anotherlargefile#1
	Change 3 submitted.			Change 3 submitted.

	$ cd $hgwd			$ cd $hgwd
	$ hg p4syncimport --debug -P $P4ROOT hg-p4-import			$ hg p4syncimport --debug -P $P4ROOT hg-p4-import-narrow hg-p4-import
	incremental import from changelist: 3, node: * (glob)			incremental import from changelist: 3, node: * (glob)
	Latest change list number 3			2 (current client) 3 (requested client) 2 (latest imported)
				latest change list number 3
	running a sync import.			running a sync import.
	writing filelog: fc4d9d827df8, p1 a80d06849b33, linkrev 2, 4 bytes, src: *, path: Main/a (glob)			writing filelog: cf38a89d2b54, p1 000000000000, linkrev 2, 23 bytes, src: *, path: Outside/anotherlargefile (glob)
	writing filelog: cf38a89d2b54, p1 000000000000, linkrev 2, 23 bytes, src: *, path: Main/anotherlargefile (glob)			largefile: Outside/anotherlargefile, oid: 9703972eff7a4df07317eda436ab7ef827ed16ea28c62abdcd7de269745c610c
	largefile: Main/anotherlargefile, oid: 9703972eff7a4df07317eda436ab7ef827ed16ea28c62abdcd7de269745c610c			changelist 3: writing manifest. node: ff600511f8ae p1: c14352bb3510 p2: 000000000000 linkrev: 2
	writing filelog: fa4df9fc788c, p1 9f14f96519e1, linkrev 2, 88 bytes, src: *, path: Main/largefile (glob)
	largefile: Main/largefile, oid: b0d5c1968efbabbff9d94160f284cd7b52686ca3c46cfffdd351de07384fce9c
	changelist 3: writing manifest. node: a6a6dbeefd0a p1: c14352bb3510 p2: 000000000000 linkrev: 2
	changelist 3: writing changelog: p4fastimport synchronizing client view			changelist 3: writing changelog: p4fastimport synchronizing client view
	writing lfs metadata to sqlite			writing lfs metadata to sqlite
	updating the branch cache			updating the branch cache
	1 revision, 3 file(s) imported.			1 revision, 1 file(s) imported.
				$ hg manifest -r tip
				Main/a
				Main/largefile
				Outside/anotherlargefile

	Verify			Verify
	(waiting for https://patchwork.mercurial-scm.org/patch/20582/)			(waiting for https://patchwork.mercurial-scm.org/patch/20582/)

				$ cd $hgwd
	$ hg --debug verify --config verify.skipflags=8192			$ hg --debug verify --config verify.skipflags=8192
	repository uses revlog format 1			repository uses revlog format 1
	checking changesets			checking changesets
	checking manifests			checking manifests
	crosschecking files in changesets and manifests			crosschecking files in changesets and manifests
	checking files			checking files
	3 files, 3 changesets, 7 total revisions			3 files, 3 changesets, 5 total revisions

	$ test -d .hg/store/lfs/objects			$ test -d .hg/store/lfs/objects
	[1]			[1]
	$ sqlite3 lfs.sql "SELECT * FROM p4_lfs_map"			$ sqlite3 lfs.sql "SELECT * FROM p4_lfs_map"
	1\|1\|*\|37a7b43abd9e105a0e6b22088b140735a02f288767fe7a6f4f436cb46b064ca9\|//depot/Main/largefile (glob)			1\|1\|*\|37a7b43abd9e105a0e6b22088b140735a02f288767fe7a6f4f436cb46b064ca9\|//depot/Main/largefile (glob)
	2\|2\|*\|b0d5c1968efbabbff9d94160f284cd7b52686ca3c46cfffdd351de07384fce9c\|//depot/Main/largefile (glob)			2\|2\|*\|b0d5c1968efbabbff9d94160f284cd7b52686ca3c46cfffdd351de07384fce9c\|//depot/Main/largefile (glob)
	3\|3\|*\|9703972eff7a4df07317eda436ab7ef827ed16ea28c62abdcd7de269745c610c\|//depot/Main/anotherlargefile (glob)			3\|3\|*\|9703972eff7a4df07317eda436ab7ef827ed16ea28c62abdcd7de269745c610c\|//depot/Outside/anotherlargefile (glob)
	4\|3\|*\|b0d5c1968efbabbff9d94160f284cd7b52686ca3c46cfffdd351de07384fce9c\|//depot/Main/largefile (glob)

	End Test			End Test

	stopping the p4 server			stopping the p4 server

tests/test-p4fastimport-blobcommit.t

	#require p4			#require p4

	$ . $TESTDIR/p4setup.sh			$ . $TESTDIR/p4setup.sh

				$ p4 client -o hg-p4-import-narrow \| sed '/^View:/,$ d' >p4client
				$ echo "View:" >>p4client
				$ echo " //depot/Main/Narrow/... //hg-p4-import-narrow/Main/Narrow/..." >>p4client
				$ p4 client -i <p4client
				Client hg-p4-import-narrow saved.

	Populate the Depot			Populate the Depot
	$ mkdir Main			$ mkdir Main
	$ echo a > Main/a			$ mkdir Main/Narrow
	$ echo b > Main/b			$ echo a > Main/Narrow/a
	$ p4 add Main/a Main/b			$ echo b > Main/Narrow/b
	//depot/Main/a#1 - opened for add			$ p4 add Main/Narrow/a Main/Narrow/b
	//depot/Main/b#1 - opened for add			//depot/Main/Narrow/a#1 - opened for add
				//depot/Main/Narrow/b#1 - opened for add
	$ p4 submit -d initial			$ p4 submit -d initial
	Submitting change 1.			Submitting change 1.
	Locking 2 files ...			Locking 2 files ...
	add //depot/Main/a#1			add //depot/Main/Narrow/a#1
	add //depot/Main/b#1			add //depot/Main/Narrow/b#1
	Change 1 submitted.			Change 1 submitted.

	$ p4 edit Main/a			$ p4 edit Main/Narrow/a
	//depot/Main/a#1 - opened for edit			//depot/Main/Narrow/a#1 - opened for edit
	$ echo a >> Main/a			$ echo a >> Main/Narrow/a
	$ p4 submit -d second			$ p4 submit -d second
	Submitting change 2.			Submitting change 2.
	Locking 1 files ...			Locking 1 files ...
	edit //depot/Main/a#2			edit //depot/Main/Narrow/a#2
	Change 2 submitted.			Change 2 submitted.

				$ mkdir Main/Outside
				$ echo a >> Main/Outside/a
				$ p4 add Main/Outside/a
				//depot/Main/Outside/a#1 - opened for add
				$ p4 submit -d third
				Submitting change 3.
				Locking 1 files ...
				add //depot/Main/Outside/a#1
				Change 3 submitted.

				$ p4 edit Main/Outside/a
				//depot/Main/Outside/a#1 - opened for edit
				$ echo a >> Main/Outside/a
				$ p4 submit -d fourth
				Submitting change 4.
				Locking 1 files ...
				edit //depot/Main/Outside/a#2
				Change 4 submitted.

	Fast Import			Fast Import

	$ cd $hgwd			$ cd $hgwd
	$ hg init --config 'format.usefncache=False'			$ hg init --config 'format.usefncache=False'
	$ hg p4fastimport --bookmark master --debug -P $P4ROOT hg-p4-import			$ hg p4fastimport --bookmark master --debug -P $P4ROOT hg-p4-import-narrow
	loading changelist numbers.			loading changelist numbers.
	2 changelists to import.			2 changelists to import.
	loading list of files.			loading list of files.
	2 files to import.			2 files to import.
	reading filelog * (glob)			reading filelog * (glob)
	reading filelog * (glob)			reading filelog * (glob)
	importing repository.			importing repository.
	writing filelog: b789fdd96dc2, p1 000000000000, linkrev 0, 2 bytes, src: *, path: Main/a (glob)			writing filelog: b789fdd96dc2, p1 000000000000, linkrev 0, 2 bytes, src: *, path: Main/Narrow/a (glob)
	writing filelog: a80d06849b33, p1 b789fdd96dc2, linkrev 1, 4 bytes, src: *, path: Main/a (glob)			writing filelog: a80d06849b33, p1 b789fdd96dc2, linkrev 1, 4 bytes, src: *, path: Main/Narrow/a (glob)
	writing filelog: 1e88685f5dde, p1 000000000000, linkrev 0, 2 bytes, src: *, path: Main/b (glob)			writing filelog: 1e88685f5dde, p1 000000000000, linkrev 0, 2 bytes, src: *, path: Main/Narrow/b (glob)
	changelist 1: writing manifest. node: dbcf87f9f16c p1: 000000000000 p2: 000000000000 linkrev: 0			changelist 1: writing manifest. node: f32ae4efccd8 p1: 000000000000 p2: 000000000000 linkrev: 0
	changelist 1: writing changelog: initial			changelist 1: writing changelog: initial
	changelist 2: writing manifest. node: 5c8695bebd8f p1: dbcf87f9f16c p2: 000000000000 linkrev: 1			changelist 2: writing manifest. node: 11c5dab8abaf p1: f32ae4efccd8 p2: 000000000000 linkrev: 1
	changelist 2: writing changelog: second			changelist 2: writing changelog: second
	writing bookmark			writing bookmark
	updating the branch cache			updating the branch cache
	2 revision(s), 2 file(s) imported.			2 revision(s), 2 file(s) imported.
	$ cd $p4wd
	$ p4 edit Main/b
	//depot/Main/b#1 - opened for edit
	$ echo b >> Main/b
	$ echo c > Main/c
	$ mkdir Main/d
	$ echo e > Main/d/e
	$ mkdir Main/d/f
	$ echo g > Main/d/f/g
	$ p4 add Main/c Main/d/e Main/d/f/g
	//depot/Main/c#1 - opened for add
	//depot/Main/d/e#1 - opened for add
	//depot/Main/d/f/g#1 - opened for add
	$ p4 delete Main/a
	//depot/Main/a#2 - opened for delete
	$ p4 submit -d third
	Submitting change 3.
	Locking 5 files ...
	delete //depot/Main/a#3
	edit //depot/Main/b#2
	add //depot/Main/c#1
	add //depot/Main/d/e#1
	add //depot/Main/d/f/g#1
	Change 3 submitted.

	Sync Import			Sync Import

	$ cd $hgwd			$ hg p4syncimport --bookmark master --debug -P $P4ROOT hg-p4-import-narrow hg-p4-import
	$ cd $hgwd
	$ hg p4syncimport --bookmark master --debug -P $P4ROOT hg-p4-import
	incremental import from changelist: 3, node: * (glob)			incremental import from changelist: 3, node: * (glob)
	Latest change list number 3			2 (current client) 4 (requested client) 2 (latest imported)
				latest change list number 4
	running a sync import.			running a sync import.
	writing filelog: 861f64b39056, p1 1e88685f5dde, linkrev 2, 4 bytes, src: *, path: Main/b (glob)			writing filelog: b8a08782de62, p1 000000000000, linkrev 2, 4 bytes, src: *, path: Main/Outside/a (glob)
	writing filelog: 149da44f2a4e, p1 000000000000, linkrev 2, 2 bytes, src: *, path: Main/c (glob)			changelist 4: writing manifest. node: * p1: 11c5dab8abaf p2: 000000000000 linkrev: 2 (glob)
	writing filelog: 6b67ccefd5ce, p1 000000000000, linkrev 2, 2 bytes, src: *, path: Main/d/e (glob)			changelist 4: writing changelog: p4fastimport synchronizing client view
	writing filelog: 0973eb1b2ecc, p1 000000000000, linkrev 2, 2 bytes, src: *, path: Main/d/f/g (glob)
	changelist 3: writing manifest. node: f0ca72fbd536 p1: 5c8695bebd8f p2: 000000000000 linkrev: 2
	changelist 3: writing changelog: p4fastimport synchronizing client view
	writing bookmark			writing bookmark
	updating the branch cache			updating the branch cache
	1 revision, 4 file(s) imported.			1 revision, 1 file(s) imported.

	Verify			$ hg manifest -r tip
				Main/Narrow/a
	$ hg verify			Main/Narrow/b
	checking changesets			Main/Outside/a
	checking manifests
	crosschecking files in changesets and manifests
	checking files
	5 files, 3 changesets, 7 total revisions

	$ hg update master
	4 files updated, 0 files merged, 0 files removed, 0 files unresolved
	(activating bookmark master)

	Sync Import without New Changes

	$ hg p4syncimport --bookmark master --debug -P $P4ROOT hg-p4-import
	incremental import from changelist: 4, node: * (glob)
	Latest change list number 3
	running a sync import.
	changelist 3: writing manifest. node: 2037a8409eae p1: f0ca72fbd536 p2: 000000000000 linkrev: 3
	changelist 3: writing changelog: p4fastimport synchronizing client view
	writing bookmark
	updating the branch cache
	1 revision, 0 file(s) imported.

	Verify			Verify

	$ hg verify			$ hg verify
	checking changesets			checking changesets
	checking manifests			checking manifests
	crosschecking files in changesets and manifests			crosschecking files in changesets and manifests
	checking files			checking files
	5 files, 4 changesets, 7 total revisions			3 files, 3 changesets, 4 total revisions

	$ hg update master			$ hg update master
	0 files updated, 0 files merged, 0 files removed, 0 files unresolved			3 files updated, 0 files merged, 0 files removed, 0 files unresolved
				(activating bookmark master)

	Fast Import after Sync Import			Fast Import after Sync Import

	$ hg p4fastimport --bookmark master --debug -P $P4ROOT hg-p4-import			$ hg p4fastimport --bookmark master --debug -P $P4ROOT hg-p4-import
	incremental import from changelist: 4, node: * (glob)			incremental import from changelist: 5, node: * (glob)
	loading changelist numbers.			loading changelist numbers.
	0 changelists to import.			0 changelists to import.

	Verify			Syncimport must abort if there are newer commits

	$ hg verify			$ cd $p4wd
	checking changesets			$ p4 edit Main/Outside/a
	checking manifests			//depot/Main/Outside/a#2 - opened for edit
	crosschecking files in changesets and manifests			$ echo a >> Main/Outside/a
	checking files			$ p4 submit -d fifth
	5 files, 4 changesets, 7 total revisions			Submitting change 5.
				Locking 1 files ...
				edit //depot/Main/Outside/a#3
				Change 5 submitted.

	$ hg update master			$ cd $hgwd
	0 files updated, 0 files merged, 0 files removed, 0 files unresolved			$ hg p4syncimport --bookmark master --debug -P $P4ROOT hg-p4-import-narrow hg-p4-import
				incremental import from changelist: 5, node: * (glob)
				2 (current client) 5 (requested client) 4 (latest imported)
				abort: repository must contain most recent changes
				[255]

				kaleyhUnsubmitted Not Done What client will it use if we fall back to `fast import` ? Since CL 5 touches files that are not in the current client spec, will `fast import` be able to update the repo to CL5? kaleyh: What client will it use if we fall back to `fast import` ? Since CL 5 touches files that are…
				dspAuthorUnsubmitted Not Done Yes, using the old clientspec it will be able to update it. dsp: Yes, using the old clientspec it will be able to update it.
				dspAuthorUnsubmitted Not Done In case `p4fastimport` uses the new client-spec, it behaves like before: if a file changes it will happily included it. So what we want to do is: use the new-spec only after p4syncimport changed. Maybe in an upcoming change we can save information about the clientspec in Mercurial to automatically detect a change in the p4fastimport case dsp: In case `p4fastimport` uses the new client-spec, it behaves like before: if a file changes it…
				kaleyhUnsubmitted Not Done that can be a good idea kaleyh: that can be a good idea
				Remove stuff

				$ hg p4fastimport --bookmark master -P $P4ROOT hg-p4-import
				$ hg p4syncimport --bookmark master --debug -P $P4ROOT hg-p4-import hg-p4-import-narrow
				incremental import from changelist: 6, node: * (glob)
				5 (current client) 2 (requested client) 5 (latest imported)
				latest change list number 2
				running a sync import.
				changelist 2: writing manifest. node: 38e379ab01af p1: e432a49b940b p2: 000000000000 linkrev: 4
				changelist 2: writing changelog: p4fastimport synchronizing client view
				writing bookmark
				updating the branch cache
				1 revision, 0 file(s) imported.

				$ hg manifest -r tip
				Main/Narrow/a
				Main/Narrow/b

	End Test			End Test
	stopping the p4 server			stopping the p4 server

Diff	ID	Base	Description	Created	Lint	Unit
Base			Base
Diff 1	4577			Dec 21 2017, 8:18 PM	★	★