guix/tests/gc-concurrent.sh

source common.sh

$NIX_BIN_DIR/nix-collect-garbage -vvvvv

drvPath1=$($nixinstantiate gc-concurrent.nix)
outPath1=$($nixstore -q $drvPath1)

drvPath2=$($nixinstantiate gc-concurrent2.nix)
outPath2=$($nixstore -q $drvPath2)

drvPath3=$($nixinstantiate simple.nix)
outPath3=$($nixstore -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.
$nixstore -rvv "$drvPath1" &
pid1=$!

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

# Run the garbage collector while the build is running.
sleep 4
$NIX_BIN_DIR/nix-collect-garbage -vvvvv

# 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_BIN_DIR/nix-collect-garbage -vvvvv
! test -e $outPath1
! test -e $outPath2
* Make it easy to run individual tests from the command line. 2006-03-01 12:15:33 +00:00			`source common.sh`

* 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 09:26:30 +00:00			`$NIX_BIN_DIR/nix-collect-garbage -vvvvv`

* Simplification. 2006-03-01 12:51:18 +00:00			`drvPath1=$($nixinstantiate gc-concurrent.nix)`
			`outPath1=$($nixstore -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 22:01:55 +00:00
* Simplification. 2006-03-01 12:51:18 +00:00			`drvPath2=$($nixinstantiate gc-concurrent2.nix)`
			`outPath2=$($nixstore -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 20:36:46 +00: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 17:03:18 +00:00			`drvPath3=$($nixinstantiate simple.nix)`
			`outPath3=$($nixstore -r $drvPath3)`

			`! test -e $outPath3.lock`
			`touch $outPath3.lock`

			`rm -f "$NIX_STATE_DIR"/gcroots/foo*`
* Add a test for nix-log2xml. 2006-03-01 13:25:08 +00: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 17:03:18 +00: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 22:23:49 +00: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 22:01:55 +00:00			`# Start build #1 in the background. It starts immediately.`
* Simplification. 2006-03-01 12:51:18 +00:00			`$nixstore -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 22:01:55 +00: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 20:36:46 +00: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 09:26:30 +00:00			`# Start build #2 in the background after 6 seconds.`
			`(sleep 6 && $nixstore -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 22:01:55 +00: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 20:36:46 +00: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 09:26:30 +00:00			`# Run the garbage collector while the build is running.`
			`sleep 4`
			`$NIX_BIN_DIR/nix-collect-garbage -vvvvv`
* 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 22:01:55 +00: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 20:36:46 +00: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 22:01:55 +00: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 09:26:30 +00: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 22:01:55 +00: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 20:36:46 +00: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 09:26:30 +00: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 22:01:55 +00:00			`cat $outPath2/foobar`
* Add a test for nix-log2xml. 2006-03-01 13:25:08 +00: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 17:03:18 +00:00			`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_BIN_DIR/nix-collect-garbage -vvvvv`
			`! test -e $outPath1`
			`! test -e $outPath2`