# See the file LICENSE for redistribution information.
#
# Copyright (c) 2003-2009 Oracle.  All rights reserved.
#
# $Id$
#
# TEST	txn011
# TEST	Test durable and non-durable txns.
# TEST	Test a mixed env (with both durable and non-durable
# TEST	dbs), then a purely non-durable env.  Make sure commit
# TEST	and abort work, and that only the log records we
# TEST	expect are written.
# TEST	Test that we can't get a durable handle on an open ND
# TEST	database, or vice versa.  Test that all subdb's
# TEST	must be of the same type (D or ND).
proc txn011 { {ntxns 100} } {
	source ./include.tcl
	global util_path

	foreach envtype { "" "-private" } {
		puts "Txn011: Non-durable txns ($envtype)."
		env_cleanup $testdir

		puts "\tTxn011.a: Persistent env recovery with -log_inmemory"
		set lbuf [expr 8 * [expr 1024 * 1024]]
		set env_cmd "berkdb_env -create \
		    -home $testdir -txn -log_inmemory -log_buffer $lbuf"
		set ndenv [eval $env_cmd $envtype]
		set db [berkdb_open -create -auto_commit \
		    -btree -env $ndenv -notdurable test.db]
		check_log_records $testdir
		error_check_good db_close [$db close] 0
		error_check_good ndenv_close [$ndenv close] 0

		# Run recovery with -e to retain environment.
		set stat [catch {exec $util_path/db_recover -e -h $testdir} ret]
		error_check_good db_printlog $stat 0

		# Rejoin env and make sure that the db is still there.
		set ndenv [berkdb_env -home $testdir]
		set db [berkdb_open -auto_commit -env $ndenv test.db]
		error_check_good db_close [$db close] 0
		error_check_good ndenv_close [$ndenv close] 0
		env_cleanup $testdir

		# Start with a new env for the next test.
		set ndenv [eval $env_cmd]
		error_check_good env_open [is_valid_env $ndenv] TRUE

		# Open/create the database.
		set testfile notdurable.db
		set db [eval berkdb_open -create \
		    -auto_commit -env $ndenv -notdurable -btree $testfile]
		error_check_good dbopen [is_valid_db $db] TRUE

		puts "\tTxn011.b: Abort txns in in-memory logging env."
		txn011_runtxns $ntxns $db $ndenv abort
		# Make sure there is nothing in the db.
		txn011_check_empty $db $ndenv

		puts "\tTxn011.c: Commit txns in in-memory logging env."
		txn011_runtxns $ntxns $db $ndenv commit

		# Make sure we haven't written any inappropriate log records
		check_log_records $testdir

		# Clean up non-durable env tests.
		error_check_good db_close [$db close] 0
		error_check_good ndenv_close [$ndenv close] 0
		env_cleanup $testdir

		puts "\tTxn011.d: Set up mixed durable/non-durable test."
		# Open/create the mixed environment
		set mixed_env_cmd "berkdb_env_noerr -create \
			-home $testdir -txn -log_inmemory -log_buffer $lbuf"
		set env [eval $mixed_env_cmd]
		error_check_good env_open [is_valid_env $env] TRUE
		check_log_records $testdir

		# Open/create the non-durable database
		set nondurfile nondurable.db
		set ndb [berkdb_open_noerr -create\
		    -auto_commit -env $env -btree -notdurable $nondurfile]
		error_check_good dbopen [is_valid_db $ndb] TRUE
		check_log_records $testdir

		puts "\tTxn011.e: Abort txns in non-durable db."
		txn011_runtxns $ntxns $ndb $env abort
		# Make sure there is nothing in the db.
		txn011_check_empty $ndb $env
		check_log_records $testdir

		puts "\tTxn011.f: Commit txns in non-durable db."
		txn011_runtxns $ntxns $ndb $env commit
		check_log_records $testdir

		# Open/create the durable database
		set durfile durable.db
		set ddb [eval berkdb_open_noerr \
		   -create -auto_commit -env $env -btree $durfile]
		error_check_good dbopen [is_valid_db $ddb] TRUE

		# Try to get a not-durable handle on the durable db.
		puts "\tTxn011.g: Try to get a not-durable handle on\
		    an open durable db."
		set errormsg "Cannot open DURABLE and NOT DURABLE handles"
		catch {berkdb_open_noerr \
		    -auto_commit -env $env -notdurable $durfile} res
		error_check_good handle_error1 [is_substr $res $errormsg] 1
		error_check_good ddb_close [$ddb close] 0

		# Try to get a not-durable handle when reopening the durable 
		# db (this should work).
		set db [berkdb_open_noerr \
		    -auto_commit -env $env -notdurable $durfile]  
		error_check_good db_reopen [is_valid_db $db] TRUE
		error_check_good db_close [$db close] 0

		# Now reopen as durable for the remainder of the test.
		set ddb [berkdb_open_noerr \
		    -auto_commit -env $env -btree $durfile]
		error_check_good dbopen [is_valid_db $ddb] TRUE

		puts "\tTxn011.h: Abort txns in durable db."
		# Add items to db in several txns but abort every one.
		txn011_runtxns $ntxns $ddb $env abort
		# Make sure there is nothing in the db.
		txn011_check_empty $ddb $env

		puts "\tTxn011.i: Commit txns in durable db."
		txn011_runtxns $ntxns $ddb $env commit

		puts "\tTxn011.j: Subdbs must all be durable or all not durable."
		# Ask for -notdurable on durable db/subdb
		set sdb1 [eval berkdb_open_noerr -create -auto_commit \
		    -env $env -btree testfile1.db subdb1]
		catch {set sdb2 [eval berkdb_open_noerr -create -auto_commit \
		    -env $env -btree -notdurable testfile1.db subdb2]} res
		error_check_good same_type_subdb1 [is_substr $res $errormsg] 1
		error_check_good sdb1_close [$sdb1 close] 0

		# Ask for durable on notdurable db/subdb
		set sdb3 [eval berkdb_open_noerr -create -auto_commit \
		    -env $env -btree -notdurable testfile2.db subdb3]
		catch {set sdb4 [eval berkdb_open_noerr -create -auto_commit \
		    -env $env -btree testfile2.db subdb4]} res
		error_check_good same_type_subdb2 [is_substr $res $errormsg] 1
		error_check_good sdb3_close [$sdb3 close] 0

		puts "\tTxn011.k: Try to get a durable handle on a\
		    not-durable db."
		# Try to get a durable handle on a not-durable database,
		# while open.  This should fail, but getting a durable handle
		# when re-opening should work. 
		catch {berkdb_open_noerr -auto_commit -env $env $nondurfile} res
		error_check_good handle_error [is_substr $res $errormsg] 1
		error_check_good ndb_close [$ndb close] 0

		set ndb [berkdb_open_noerr -auto_commit -env $env $nondurfile]
		error_check_good ndb_reopen [is_valid_db $ndb] TRUE
		error_check_good ndb_close [$ndb close] 0

		# Clean up mixed env.
		error_check_good ddb_close [$ddb close] 0
		error_check_good env_close [$env close] 0
	}
}

proc txn011_runtxns { ntxns db env end } {
	source ./include.tcl

	set did [open $dict]
	set i 0
	while { [gets $did str] != -1 && $i < $ntxns } {
		set txn [$env txn]
		error_check_good txn_begin [is_valid_txn $txn $env] TRUE

		error_check_good db_put_txn [$db put -txn $txn $i $str] 0
		error_check_good txn_$end [$txn $end] 0
		incr i
	}
	close $did
}

# Verify that a database is empty
proc txn011_check_empty { db env } {
	# Start a transaction
	set t [$env txn]
	error_check_good txn [is_valid_txn $t $env] TRUE
	set txn "-txn $t"

	# If a cursor get -first returns nothing, the db is empty.
	set dbc [eval {$db cursor} $txn]
	error_check_good db_cursor [is_substr $dbc $db] 1
	set ret [$dbc get -first]
	error_check_good get_on_empty [string length $ret] 0
	error_check_good dbc_close [$dbc close] 0

	# End transaction
	error_check_good txn [$t commit] 0
}

# Some log records are still produced when we run create in a
# non-durable db in a regular env.  Just make sure we don't see
# any unexpected types.
proc check_log_records { dir } {
	global util_path

	set tmpfile $dir/printlog.out
	set stat [catch {exec $util_path/db_printlog -h $dir > $tmpfile} ret]
	error_check_good db_printlog $stat 0

	set f [open $tmpfile r]
	while { [gets $f record] >= 0 } {
		set r [regexp {\[[^\]]*\]\[[^\]]*\]([^\:]*)\:} $record whl name]
		if { $r == 1 && [string match *_debug $name] != 1 && \
		    [string match __txn_regop $name] != 1 && \
		    [string match __txn_child $name] != 1 } {
			puts "FAIL: unexpected log record $name found"
		}
	}
	close $f
	fileremove $tmpfile
}