tvl-depot/tests/gc-concurrent.sh

source common.sh

clearStore

drvPath1=$(nix-instantiate gc-concurrent.nix -A test1)
outPath1=$(nix-store -q $drvPath1)

drvPath2=$(nix-instantiate gc-concurrent.nix -A test2)
outPath2=$(nix-store -q $drvPath2)

drvPath3=$(nix-instantiate simple.nix)
outPath3=$(nix-store -r $drvPath3)

(! test -e $outPath3.lock)
touch $outPath3.lock

rm -f "$NIX_STATE_DIR"/gcroots/foo*
ln -s $drvPath2 "$NIX_STATE_DIR"/gcroots/foo
ln -s $outPath3 "$NIX_STATE_DIR"/gcroots/foo2

# Start build #1 in the background.  It starts immediately.
nix-store -rvv "$drvPath1" &
pid1=$!

# Start build #2 in the background after 10 seconds.
(sleep 10 && nix-store -rvv "$drvPath2") &
pid2=$!

# Run the garbage collector while the build is running.
sleep 6
nix-collect-garbage

# Wait for build #1/#2 to finish.
echo waiting for pid $pid1 to finish...
wait $pid1
echo waiting for pid $pid2 to finish...
wait $pid2

# Check that the root of build #1 and its dependencies haven't been
# deleted.  The should not be deleted by the GC because they were
# being built during the GC.
cat $outPath1/foobar
cat $outPath1/input-2/bar

# Check that build #2 has succeeded.  It should succeed because the
# derivation is a GC root.
cat $outPath2/foobar

rm -f "$NIX_STATE_DIR"/gcroots/foo*

# The collector should have deleted lock files for paths that have
# been built previously.
(! test -e $outPath3.lock)

# If we run the collector now, it should delete outPath1/2.
nix-collect-garbage
(! test -e $outPath1)
(! test -e $outPath2)
* Make it easy to run individual tests from the command line. 2006-03-01 13:15:33 +01:00			`source common.sh`

* Argh, stupid timing sensitive tests... 2009-03-27 23:40:22 +01:00			`clearStore`
* Increase the sleep periods a bit to make the test less likely to fail on slow machines. Of course it would be better if this test wasn't timing dependent... 2008-08-14 11:26:30 +02:00
* Refactoring: remove unnecessary variables from the tests. 2011-10-10 23:32:34 +02:00			`drvPath1=$(nix-instantiate gc-concurrent.nix -A test1)`
			`outPath1=$(nix-store -q $drvPath1)`
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00
* Refactoring: remove unnecessary variables from the tests. 2011-10-10 23:32:34 +02:00			`drvPath2=$(nix-instantiate gc-concurrent.nix -A test2)`
			`outPath2=$(nix-store -q $drvPath2)`
* Add a test to check whether concurrent garbage collection (i.e., running the collector while builds are in progress) works correctly. The test currently fails. 2005-01-28 21:36:46 +01:00
* Refactoring: remove unnecessary variables from the tests. 2011-10-10 23:32:34 +02:00			`drvPath3=$(nix-instantiate simple.nix)`
			`outPath3=$(nix-store -r $drvPath3)`
* Simplify deleting .lock files in /nix/store: just don't delete them if they belong a path that's currently being built. This gets rid of some Cygwin-specific code. 2008-12-12 18:03:18 +01:00
Fix tests So all these years I was totally deluded about the meaning of "set -e". You might think that it causes statements like "false && true" or "! true" to fail, but it doesn't... 2014-08-21 21:50:19 +02:00			`(! test -e $outPath3.lock)`
* Simplify deleting .lock files in /nix/store: just don't delete them if they belong a path that's currently being built. This gets rid of some Cygwin-specific code. 2008-12-12 18:03:18 +01:00			`touch $outPath3.lock`

			`rm -f "$NIX_STATE_DIR"/gcroots/foo*`
* Add a test for nix-log2xml. 2006-03-01 14:25:08 +01:00			`ln -s $drvPath2 "$NIX_STATE_DIR"/gcroots/foo`
* Simplify deleting .lock files in /nix/store: just don't delete them if they belong a path that's currently being built. This gets rid of some Cygwin-specific code. 2008-12-12 18:03:18 +01:00			`ln -s $outPath3 "$NIX_STATE_DIR"/gcroots/foo2`
* Acquire a global GC lock to prevent new temporary root files from being created after the garbage collector has read the temproots directory. This blocks the creation of new processes, but the garbage collector could periodically release the GC lock to allow them to run. 2005-01-31 23:23:49 +01:00
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00			`# Start build #1 in the background. It starts immediately.`
* Refactoring: remove unnecessary variables from the tests. 2011-10-10 23:32:34 +02:00			`nix-store -rvv "$drvPath1" &`
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00			`pid1=$!`
* Add a test to check whether concurrent garbage collection (i.e., running the collector while builds are in progress) works correctly. The test currently fails. 2005-01-28 21:36:46 +01:00
* Argh, stupid timing sensitive tests... 2009-03-27 23:40:22 +01:00			`# Start build #2 in the background after 10 seconds.`
* Refactoring: remove unnecessary variables from the tests. 2011-10-10 23:32:34 +02:00			`(sleep 10 && nix-store -rvv "$drvPath2") &`
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00			`pid2=$!`
* Add a test to check whether concurrent garbage collection (i.e., running the collector while builds are in progress) works correctly. The test currently fails. 2005-01-28 21:36:46 +01:00
* Increase the sleep periods a bit to make the test less likely to fail on slow machines. Of course it would be better if this test wasn't timing dependent... 2008-08-14 11:26:30 +02:00			`# Run the garbage collector while the build is running.`
* Argh, stupid timing sensitive tests... 2009-03-27 23:40:22 +01:00			`sleep 6`
* Refactoring: remove unnecessary variables from the tests. 2011-10-10 23:32:34 +02:00			`nix-collect-garbage`
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00
			`# Wait for build #1/#2 to finish.`
			`echo waiting for pid $pid1 to finish...`
			`wait $pid1`
			`echo waiting for pid $pid2 to finish...`
			`wait $pid2`
* Add a test to check whether concurrent garbage collection (i.e., running the collector while builds are in progress) works correctly. The test currently fails. 2005-01-28 21:36:46 +01:00
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00			`# Check that the root of build #1 and its dependencies haven't been`
* Increase the sleep periods a bit to make the test less likely to fail on slow machines. Of course it would be better if this test wasn't timing dependent... 2008-08-14 11:26:30 +02:00			`# deleted. The should not be deleted by the GC because they were`
			`# being built during the GC.`
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00			`cat $outPath1/foobar`
			`cat $outPath1/input-2/bar`
* Add a test to check whether concurrent garbage collection (i.e., running the collector while builds are in progress) works correctly. The test currently fails. 2005-01-28 21:36:46 +01:00
* Increase the sleep periods a bit to make the test less likely to fail on slow machines. Of course it would be better if this test wasn't timing dependent... 2008-08-14 11:26:30 +02:00			`# Check that build #2 has succeeded. It should succeed because the`
			`# derivation is a GC root.`
* Add a test for a more subtle race: a process starting after the temporary root files have been read but creating outputs before the store directory has been read. 2005-01-31 23:01:55 +01:00			`cat $outPath2/foobar`
* Add a test for nix-log2xml. 2006-03-01 14:25:08 +01:00
* Simplify deleting .lock files in /nix/store: just don't delete them if they belong a path that's currently being built. This gets rid of some Cygwin-specific code. 2008-12-12 18:03:18 +01:00			`rm -f "$NIX_STATE_DIR"/gcroots/foo*`

			`# The collector should have deleted lock files for paths that have`
			`# been built previously.`
Fix tests So all these years I was totally deluded about the meaning of "set -e". You might think that it causes statements like "false && true" or "! true" to fail, but it doesn't... 2014-08-21 21:50:19 +02:00			`(! test -e $outPath3.lock)`
* Simplify deleting .lock files in /nix/store: just don't delete them if they belong a path that's currently being built. This gets rid of some Cygwin-specific code. 2008-12-12 18:03:18 +01:00
			`# If we run the collector now, it should delete outPath1/2.`
* Refactoring: remove unnecessary variables from the tests. 2011-10-10 23:32:34 +02:00			`nix-collect-garbage`
Fix tests So all these years I was totally deluded about the meaning of "set -e". You might think that it causes statements like "false && true" or "! true" to fail, but it doesn't... 2014-08-21 21:50:19 +02:00			`(! test -e $outPath1)`
			`(! test -e $outPath2)`