#
# Library code for git p4 tests
#

# p4 tests never use the top-level repo; always build/clone into
# a subdirectory called "$git"
setvar TEST_NO_CREATE_REPO = 'NoThanks'

# Some operations require multiple attempts to be successful. Define
# here the maximal retry timeout in seconds.
setvar RETRY_TIMEOUT = '60'

# Sometimes p4d seems to hang. Terminate the p4d process automatically after
# the defined timeout in seconds.
setvar P4D_TIMEOUT = '300'

source ./test-lib.sh

if ! test_have_prereq PYTHON
{
	setvar skip_all = ''skipping git p4 tests; python not available''
	test_done
}
shell { p4 -h && p4d -h } >/dev/null 2>&1 || do {
	setvar skip_all = ''skipping git p4 tests; no p4 or p4d''
	test_done
}

# On cygwin, the NT version of Perforce can be used.  When giving
# it paths, either on the command-line or in client specifications,
# be sure to use the native windows form.
#
# Older versions of perforce were available compiled natively for
# cygwin.  Those do not accept native windows paths, so make sure
# not to convert for them.
proc native_path {
	setvar path = "$1" &&
	if test_have_prereq CYGWIN && ! p4 -V | grep -q CYGWIN
	{
		setvar path = $(cygpath --windows "$path")
	} else {
		setvar path = $(test-path-utils real_path "$path")
	} &&
	echo $path
}

# On Solaris the 'date +%s' function is not supported and therefore we
# need this replacement.
# Attention: This function is not safe again against time offset updates
# at runtime (e.g. via NTP). The 'clock_gettime(CLOCK_MONOTONIC)'
# function could fix that but it is not in Python until 3.3.
proc time_in_seconds {
	shell {cd / && $PYTHON_PATH -c 'import time; print(int(time.time()))'}
}

# Try to pick a unique port: guess a large number, then hope
# no more than one of each test is running.
#
# This does not handle the case where somebody else is running the
# same tests and has chosen the same ports.
setvar testid = ${this_test#t}
setvar git_p4_test_start = '9800'
setvar P4DPORT = $((10669 + ($testid - $git_p4_test_start)))

setvar P4PORT = "localhost:$P4DPORT"
setvar P4CLIENT = 'client'
setvar P4USER = 'author'
setvar P4EDITOR = 'true'
unset P4CHARSET
export P4PORT P4CLIENT P4USER P4EDITOR P4CHARSET

setvar db = ""$TRASH_DIRECTORY/db""
setvar cli = ""$TRASH_DIRECTORY/cli""
setvar git = ""$TRASH_DIRECTORY/git""
setvar pidfile = ""$TRASH_DIRECTORY/p4d.pid""

# Sometimes "prove" seems to hang on exit because p4d is still running
proc cleanup {
	if test -f $pidfile
	{
		kill -9 $(cat "$pidfile") 2>/dev/null && exit 255
	}
}
trap cleanup EXIT

# git p4 submit generates a temp file, which will
# not get cleaned up if the submission fails.  Don't
# clutter up /tmp on the test machine.
setvar TMPDIR = "$TRASH_DIRECTORY"
export TMPDIR

proc start_p4d {
	mkdir -p $db $cli $git &&
	rm -f $pidfile &&
	shell {
		cd $db &&
		do {
			p4d -q -p $P4DPORT @ARGV &
			echo $! >"$pidfile"
		}
	} &&

	# This gives p4d a long time to start up, as it can be
	# quite slow depending on the machine.  Set this environment
	# variable to something smaller to fail faster in, say,
	# an automated test setup.  If the p4d process dies, that
	# will be caught with the "kill -0" check below.
	setvar i = ${P4D_START_PATIENCE:-300}
	setvar pid = $(cat "$pidfile")

	setvar timeout = $(($(time_in_seconds) + $P4D_TIMEOUT))
	while true
	{
		if test $(time_in_seconds) -gt $timeout
		{
			kill -9 $pid
			exit 1
		}
		sleep 1
	} &
	setvar watchdog_pid = ""$!

	setvar ready = ''
	while test $i -gt 0
	{
		# succeed when p4 client commands start to work
		if p4 info >/dev/null 2>&1
		{
			setvar ready = 'true'
			break
		}
		# fail if p4d died
		kill -0 $pid 2>/dev/null || break
		echo waiting for p4d to start
		sleep 1
		setvar i = $(( $i - 1 ))
	}

	if test -z $ready
	{
		# p4d failed to start
		return 1
	}

	# build a p4 user so author@example.com has an entry
	p4_add_user author

	# build a client
	client_view "//depot/... //client/..." &&

	return 0
}

proc p4_add_user {
	setvar name = "$1" &&
	p4 user -f -i <<< """
	User: $name
	Email: $name@example.com
	FullName: Dr. $name
"""
}

proc p4_add_job {
	p4 job -f -i <<< """
	Job: $1
	Status: open
	User: dummy
	Description:
"""
}

proc retry_until_success {
	setvar timeout = $(($(time_in_seconds) + $RETRY_TIMEOUT))
	while ! "$@" 2>/dev/null || test $(time_in_seconds) -gt $timeout
	{
		sleep 1
	}
}

proc retry_until_fail {
	setvar timeout = $(($(time_in_seconds) + $RETRY_TIMEOUT))
	while ! ! "$@" 2>/dev/null || test $(time_in_seconds) -gt $timeout
	{
		sleep 1
	}
}

proc kill_p4d {
	setvar pid = $(cat "$pidfile")
	retry_until_fail kill $pid
	retry_until_fail kill -9 $pid
	# complain if it would not die
	test_must_fail kill $pid >/dev/null 2>&1 &&
	rm -rf $db $cli $pidfile &&
	retry_until_fail kill -9 $watchdog_pid
}

proc cleanup_git {
	retry_until_success rm -r $git
	test_must_fail test -d $git &&
	retry_until_success mkdir $git
}

proc marshal_dump {
	setvar what = "$1" &&
	setvar line = ${2:-1} &&
	cat >"$TRASH_DIRECTORY/marshal-dump.py" <<< """ &&
	import marshal
	import sys
	instream = getattr(sys.stdin, 'buffer', sys.stdin)
	for i in range($line):
	    d = marshal.load(instream)
	print(d[b'$what'].decode('utf-8'))
"""
	$PYTHON_PATH "$TRASH_DIRECTORY/marshal-dump.py"
}

#
# Construct a client with this list of View lines
#
proc client_view {
	shell {
		cat <<< """ &&
		Client: $P4CLIENT
		Description: $P4CLIENT
		Root: $cli
		AltRoots: $(native_path "$cli")
		LineEnd: unix
		View:
"""
		printf "\t%s\n" @ARGV
	} | p4 client -i
}

proc is_cli_file_writeable {
	# cygwin version of p4 does not set read-only attr,
	# will be marked 444 but -w is true
	setvar file = "$1" &&
	if test_have_prereq CYGWIN && p4 -V | grep -q CYGWIN
	{
		setvar stat = $(stat --format=%a "$file") &&
		test $stat = 644
	} else {
		test -w $file
	}
}