|
##
|
|
# Copyright © 2019, Oracle and/or its affiliates. All rights reserved.
|
|
#
|
|
# Licensed under the Universal Permissive License v 1.0 as shown at
|
|
# http://oss.oracle.com/licenses/upl.
|
|
#
|
|
# Update this (and the VERSION_HISTORY in version.h) when the version changes.
|
|
VERSION = 1.58
|
|
|
|
#SAN = -fsanitize=thread
|
|
#SAN = -fsanitize=address
|
|
#GCOV_FLAGS = -fprofile-arcs -ftest-coverage
|
|
CFLAGS=-Wall -Wextra -Wshadow -Wconversion -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -Wswitch-enum -Werror -g -O1 -pthread -std=gnu99 $(SAN) $(GCOV_FLAGS)
|
|
CPPFLAGS=-DVERSION=\"$(VERSION)\"
|
|
#CPPFLAGS+=-DSPEW_ENABLED
|
|
|
|
# It turns out that we need -lrt (probably because of clock_gettime()
|
|
# or else we'll end up with a dependency on glibc 2.17, which often is
|
|
# too advanced (e.g., on Oracle Linux 6.9)
|
|
LDLIBS=-lrt
|
|
LDFLAGS=-pthread $(SAN) $(GCOV_FLAGS)
|
|
|
|
VALGRIND = valgrind --leak-check=full --error-exitcode=3 -q
|
|
|
|
PARTAR = partar
|
|
|
|
default: $(PARTAR) parcp parrm $(PARTAR).1.gz parcp.1.gz parrm.1.gz
|
|
|
|
# Don't delete intermediate files (specify .SECONDARY with no dependencies)
|
|
.SECONDARY:
|
|
|
|
rpms: ../fss-parallel-tools-$(VERSION).tar.gz fss-parallel-tools.spec
|
|
mkdir -p ~/rpmbuild/SOURCES
|
|
mkdir -p ~/rpmbuild/SPECS
|
|
cp ../fss-parallel-tools-$(VERSION).tar.gz ~/rpmbuild/SOURCES
|
|
cp fss-parallel-tools.spec ~/rpmbuild/SPECS
|
|
cd ~/rpmbuild/SPECS;rpmbuild -ba fss-parallel-tools.spec
|
|
fss-parallel-tools.spec: fss-parallel-tools.spec.in Makefile
|
|
sed s/VERSION_DEFINED_IN_MAKEFILE/$(VERSION)/ < $< > $@
|
|
mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
|
|
current_dir := $(notdir $(patsubst %/,%,$(dir $(mkfile_path))))
|
|
SOURCES = gitrev.c $(wildcard *.c *.h common/*.c common/*.h) Makefile LICENSE
|
|
|
|
../fss-parallel-tools-$(VERSION).tar.gz: $(SOURCES)
|
|
tar czf $@ --transform 's,^,fss-parallel-tools/,' $(SOURCES)
|
|
tarball: ../fss-parallel-tools-$(VERSION).tar.gz
|
|
|
|
todo.o: todo.h
|
|
dircache.o: dircache.h malloc.h
|
|
htable.o: htable.h malloc.h
|
|
fwg.o: malloc.h fwg.h hashfun.h
|
|
stringset.o: stringset.h hashfun.h malloc.h
|
|
|
|
####################
|
|
# COMMON
|
|
####################
|
|
# sources
|
|
common/assert.o: common/assert.h common/backtrace.h common/spew.h version.h
|
|
COMMON_O += common/assert.o
|
|
COMMON_O += common/backtrace.o
|
|
common/backtrace.o: common/spew.h common/simplest-defs.h common/sparse.h common/backtrace.h
|
|
COMMON_O += common/debug-tag.o
|
|
common/debug-tag.o: common/debug-tag.h common/simplest-defs.h common/sparse.h
|
|
COMMON_O += common/error.o
|
|
common/error.o: common/error.h common/simplest-defs.h common/sparse.h
|
|
COMMON_O += common/spew.o
|
|
common/spew.o: common/spew.h common/backtrace.h common/simplest-defs.h common/tsan.h version.h common/debug-tag.h common/sparse.h common/error.h
|
|
|
|
fdleak.o: fdleak.h
|
|
putils.o: putils.h common/spew.h
|
|
parcp.o: putils.h malloc.h version.h sched.h vector-of-strings.h common/spew.h
|
|
$(PARTAR).o: putils.h malloc.h version.h sched.h vector-of-strings.h inodemap.h stringset.h vec.h fdleak.h fwg.h common/spew.h
|
|
parrm.o: putils.h malloc.h version.h sched.h vector-of-strings.h common/spew.h
|
|
vector-of-strings.o: vector-of-strings.h malloc.h
|
|
$(PARTAR): $(PARTAR).o putils.o sched.o vector-of-strings.o gitrev.o fwg.o stringset.o vec.o fdleak.o inodemap.o $(COMMON_O)
|
|
inodemap.o: inodemap.h malloc.h
|
|
parcp: parcp.o putils.o sched.o vector-of-strings.o gitrev.o inodemap.o todo.o $(COMMON_O)
|
|
parrm: parrm.o putils.o gitrev.o sched.o vector-of-strings.o $(COMMON_O)
|
|
|
|
.DELETE_ON_ERROR:
|
|
|
|
.SUFFIX: .1.gz
|
|
%.1.gz: %
|
|
PATH=$$PATH:. help2man -N --name="parallel implementation of $(subst par,,$<)" $< | gzip - > $@
|
|
|
|
gitrev.o: gitrev.c
|
|
# Don't create a new gitrev.c file if nothing changed. We don't want
|
|
# to rerun all the tests just because I modified the Makefile.
|
|
gitrev.c: $(filter-out gitrev.c,$(wildcard *.c *.h common/*.c common/*.h Makefile))
|
|
echo \#include \"version.h\" > gitrev_new.c
|
|
echo const char gitrev[] = \"$$(git diff-index --quiet HEAD -- || echo "++")$$(git rev-parse HEAD)\"\; >> gitrev_new.c
|
|
if ! diff gitrev_new.c gitrev.c >> /dev/null ; then mv gitrev_new.c gitrev.c; fi
|
|
setup: $(PARTAR)
|
|
rm -rf tar-1.30
|
|
|
|
# Tests
|
|
|
|
.PHONY: check
|
|
TESTS = fifo tar-1.30 linux-4.15 longfilename3
|
|
TESTS_T = $(patsubst %, %.test, $(TESTS))
|
|
check: parrm_eaccess_test.test
|
|
check: parrm_eaccess_test2.test
|
|
check: parrm_eaccess_test3.test
|
|
check: parrm_eaccess_test4.test
|
|
check: excld.test
|
|
check: excld-equal.test
|
|
check: error.test
|
|
check: linklink.test
|
|
check: permissions.test
|
|
check: $(TESTS_T) test_fib.run
|
|
check: decompression-errors.test
|
|
check: parcp0.test parcp1.test parcp2.test parcp3.test parcp4.test parcp5.test parcp6.test parcp7.test
|
|
.SUFFIX: .test
|
|
%.test: %.partar_test %.parcp_test %.parrm_test %.tar_test
|
|
touch $@
|
|
|
|
.SUFFIX: .partar_test
|
|
%.partar_test: %.partar1_diff %.partar2_diff %.partar3_diff %.partar4_diff partar1.test
|
|
touch $@
|
|
|
|
test_fib.run: test_fib
|
|
./test_fib
|
|
touch $@
|
|
|
|
$(info VAR="$(COMMON_O)")
|
|
|
|
test_fib: test_fib.o sched.o $(COMMON_O) gitrev.o
|
|
test_fib.o: malloc.h sched.h common/spew.h
|
|
sched.o: malloc.h sched.h common/spew.h
|
|
|
|
#
|
|
|
|
# These tests run partar in various ways and compare the output to what happened with tar.
|
|
# partar_diff1_test runs "partar pxf %.tar"
|
|
# partar_diff2_test runs "partar pxf - < %.tar"
|
|
# partar_diff3_test runs "partar pxzf %.tar.gz"
|
|
# partar_diff4_test runs "partar pxzf - < %.tar.gz"
|
|
|
|
# partar_test has things that are fifos in it, and we want to ignore
|
|
# diff error messages about those. That's what the grep is about in
|
|
# the diff line.
|
|
|
|
output-with-tar output-with-partar1 output-with-partar2 output-with-partar3 output-with-partar4 uncompressed-tars gzipped-tars:
|
|
mkdir -p $@
|
|
|
|
uncompressed-tars/%.tar: test-tars/%.tar.xz | uncompressed-tars
|
|
xzcat $< > $@
|
|
|
|
gzipped-tars/%.tar.gz: uncompressed-tars/%.tar | gzipped-tars
|
|
gzip < $< > $@
|
|
|
|
%.tar_done: uncompressed-tars/%.tar | output-with-tar
|
|
rm -rf $(patsubst uncompressed-tars/%.tar,output-with-tar/%, $<)
|
|
tar xf $< -C output-with-tar
|
|
touch $@
|
|
|
|
# partar1 tests makes sure that partar works with a named file
|
|
%.partar1_done: uncompressed-tars/%.tar $(PARTAR) | output-with-partar1
|
|
rm -rf $(patsubst uncompressed-tars/%.tar,output-with-partar1/%, $<)
|
|
$(VALGRIND) ./$(PARTAR) xf $< -C output-with-partar1
|
|
touch $@
|
|
|
|
%.partar1_diff: %.tar_done %.partar1_done
|
|
diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar1/%,$<) | (! grep -v "is a fifo.*is a fifo")
|
|
touch $@
|
|
|
|
# partar2 tests make sure that partar works from stdin
|
|
%.partar2_done: uncompressed-tars/%.tar $(PARTAR) | output-with-partar2
|
|
rm -rf $(patsubst uncompressed-tars/%.tar,output-with-partar2/%, $<)
|
|
$(VALGRIND) ./$(PARTAR) xf - -C output-with-partar2 < $<
|
|
touch $@
|
|
|
|
%.partar2_diff: %.tar_done %.partar2_done
|
|
diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar2/%,$<) | (! grep -v "is a fifo.*is a fifo")
|
|
touch $@
|
|
|
|
# partar3 tests make sure that partar works with a gzipped named file.
|
|
.SUFFIX: .partar3_done
|
|
%.partar3_done: gzipped-tars/%.tar.gz $(PARTAR) | output-with-partar3
|
|
rm -rf $(patsubst gzipped-tars/%.tar.gz,output-with-partar3/%, $<)
|
|
$(VALGRIND) ./$(PARTAR) xzf $< -C output-with-partar3
|
|
touch $@
|
|
|
|
.SUFFIX: .partar3_diff
|
|
%.partar3_diff: %.tar_done %.partar3_done
|
|
diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar3/%,$<) | (! grep -v "is a fifo.*is a fifo")
|
|
touch $@
|
|
|
|
# partar4 tests make sure that partar works with a gzipped stdin
|
|
%.partar4_done: gzipped-tars/%.tar.gz $(PARTAR) | output-with-partar4
|
|
rm -rf $(patsubst gzipped-tars/%.tar.gz,output-with-partar4/%, $<)
|
|
$(VALGRIND) ./$(PARTAR) xzf - -C output-with-partar4 < $<
|
|
touch $@
|
|
|
|
%.partar4_diff: %.tar_done %.partar4_done
|
|
diff --no-dereference -r $(patsubst %.tar_done,output-with-tar/%,$<) $(patsubst %.tar_done,output-with-partar4/%,$<) | (! grep -v "is a fifo.*is a fifo")
|
|
touch $@
|
|
|
|
# Test untarring onto a read-only file
|
|
partar1.test: $(PARTAR) | partar1.test.dir
|
|
rm -rf $@.dir/src $@.dir/dst
|
|
mkdir -p $@.dir/src $@.dir/dst
|
|
touch $@.dir/dst/readonly
|
|
chmod guo-w $@.dir/dst/readonly
|
|
echo contents > $@.dir/src/readonly
|
|
chmod guo-w $@.dir/src/readonly
|
|
set -e; set -o pipefail; $(VALGRIND) ./$(PARTAR) c -C $@.dir/src readonly|$(VALGRIND) ./$(PARTAR) x -C $@.dir/dst
|
|
diff -r $@.dir/{src,dst}
|
|
touch $@
|
|
|
|
output-with-parcp output-to-rm output-of-partarred:
|
|
mkdir -p $@
|
|
|
|
.SUFFIX: .parcp_test
|
|
# Turn off valgrind for the big linux parcp
|
|
linux-4.15.parcp_test: VALGRIND=
|
|
%.parcp_test: parcp %.tar_done | output-with-parcp
|
|
rm -rf $(patsubst %.parcp_test,output-with-parcp/%, $@)
|
|
$(VALGRIND) ./parcp -P 3 $(patsubst %.parcp_test,output-with-tar/%, $@) $(patsubst %.parcp_test,output-with-parcp/%, $@)
|
|
diff --no-dereference -r $(patsubst %.parcp_test,output-with-tar/%, $@) $(patsubst %.parcp_test,output-with-parcp/%, $@) | (! grep -v "is a fifo.*is a fifo")
|
|
touch $@
|
|
|
|
.SUFFIX: .parrm_test
|
|
%.parrm_test: uncompressed-tars/%.tar parrm $(PARTAR) | output-to-rm
|
|
$(VALGRIND) ./$(PARTAR) xf - -C output-to-rm < $<
|
|
test -d $(patsubst %.parrm_test,output-to-rm/%,$@)
|
|
$(VALGRIND) ./parrm -P 3 $(patsubst %.parrm_test,output-to-rm/%,$@)
|
|
test ! -d $(patsubst %.parrm_test,output-to-rm/%,$@)
|
|
touch $@
|
|
|
|
# This test only works on a few cases, since the order of the files isn't unique
|
|
.SUFFIX: .tardiff_test
|
|
%.tardiff_test: %.tar_out %.partar_out
|
|
diff $^
|
|
touch $@
|
|
|
|
.SUFFIX: .tar_test
|
|
%.tar_test: %.partar_out %.tar_done | output-of-partarred
|
|
rm -rf $(patsubst %.partar_out,output-of-partarred/%,$<)
|
|
$(VALGRIND) ./$(PARTAR) xf $< -C output-of-partarred
|
|
diff --no-dereference -r $(patsubst %.tar_test,output-with-tar/%,$@) $(patsubst %.tar_test,output-of-partarred/%,$@) | (! grep -v "is a fifo.*is a fifo")
|
|
$(EXTRA_TEST)
|
|
|
|
# These two tests check to see what happens if parrm runs into a
|
|
# directory that it hasn't got permission to access. The whole
|
|
# directory, or a subdirectory, respectively.
|
|
|
|
ED = parrm_eaccess_test_dir
|
|
parrm_eaccess_test.test: parrm
|
|
-chmod u+rwx $(ED) > /dev/null 2>&1 ;true
|
|
rm -rf $(ED)
|
|
mkdir $(ED)
|
|
touch $(ED)/foo
|
|
chmod ugo-rwx $(ED)
|
|
rm -rf $(ED) > parrm_eaccess_test.out 2>&1 ; test $$? = 1
|
|
fgrep Permission parrm_eaccess_test.out > /dev/null
|
|
./parrm $(ED) > parrm_eaccess_test.out 2>&1 ; test $$? = 1
|
|
fgrep Permission parrm_eaccess_test.out > /dev/null
|
|
touch $@
|
|
|
|
ED2 = parrm_eaccess_test2_dir
|
|
parrm_eaccess_test2.test: parrm
|
|
chmod -R u+rwx $(ED2) > /dev/null 2>&1 ;true
|
|
rm -rf $(ED2)
|
|
mkdir -p $(ED2)/$(ED2)
|
|
touch $(ED2)/$(ED2)/foo
|
|
touch $(ED2)/foo
|
|
chmod ugo-rwx $(ED2)/$(ED2)
|
|
./parrm $(ED2) > $(ED2).out 2>&1 ; test $$? = 1
|
|
chmod -R u+rwx $(ED2) > /dev/null 2>&1 ;true
|
|
test ! -f $(ED2)/foo
|
|
test -f $(ED2)/$(ED2)/foo
|
|
touch $@
|
|
|
|
# And these are the same tests where we can access the dir but we cannot unlink it.
|
|
ED3 = parrm_eaccess_test3_dir
|
|
parrm_eaccess_test3.test: parrm
|
|
-chmod u+rwx $(ED3) > /dev/null 2>&1 ;true
|
|
rm -rf $(ED3)
|
|
mkdir $(ED3)
|
|
touch $(ED3)/foo
|
|
chmod ugo-w $(ED3)
|
|
ls -la $(ED3)
|
|
rm -rf $(ED3) > $(ED3).rm.out 2>&1 ; test $$? = 1
|
|
fgrep Permission $(ED3).rm.out > /dev/null
|
|
./parrm $(ED3) > $(ED3).parrm.out 2>&1 ; test $$? = 1
|
|
fgrep Permission $(ED3).parrm.out > /dev/null
|
|
touch $@
|
|
|
|
ED4 = parrm_eaccess_test4_dir
|
|
parrm_eaccess_test4.test: parrm
|
|
chmod -R u+rwx $(ED4) > /dev/null 2>&1 ;true
|
|
rm -rf $(ED4)
|
|
mkdir -p $(ED4)/$(ED4)
|
|
touch $(ED4)/$(ED4)/foo
|
|
touch $(ED4)/foo
|
|
chmod ugo-rx $(ED4)/$(ED4)
|
|
./parrm $(ED4) > $(ED4).out 2>&1 ; test $$? = 1
|
|
chmod -R u+rwx $(ED4) > /dev/null 2>&1 ;true
|
|
test ! -f $(ED4)/foo
|
|
test -f $(ED4)/$(ED4)/foo
|
|
touch $@
|
|
|
|
# Some tarballs have extra requirements that are hard to capture with diff. We'd really like to verify that the topology of two directories is the same, but I don't know how to get diff to really do it. So we'll have an ad hoc test that these two files really are the same.
|
|
longfilename3.tar_test: EXTRA_TEST = test output-of-partarred/longfilename3/aaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbccccccccccccccccdddddddddddddddeeeeeeeeeeeeeeffffffffffffffg -ef output-of-partarred/longfilename3/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
|
|
|
|
.SUFFIX: .tar_out .partar_out
|
|
%.tar_out: %.tar_done
|
|
tar cf $@ $(patsubst %.tar_done,output-with-tar/%,$<)
|
|
%.partar_out: %.tar_done $(PARTAR)
|
|
(cd output-with-tar;../$(PARTAR) cf - $(patsubst %.tar_done,%,$<)) > $@
|
|
|
|
error.test: $(PARTAR)
|
|
! ./$(PARTAR) xf - < /dev/null 2> error.test.out
|
|
fgrep -q ": This does not look like a tar archive" error.test.out
|
|
fgrep -q ": Exiting with failure status due to previous errors" error.test.out
|
|
! ./$(PARTAR) xzf - < /dev/null 2> error.test.out
|
|
fgrep -q "gzip: stdin: unexpected end of file" error.test.out
|
|
fgrep -q ": Child returned status 1" error.test.out
|
|
fgrep -q ": Exiting with failure status due to previous errors" error.test.out
|
|
! ./$(PARTAR) cf error.tar output-with-tar/fifo no-such-file output-with-tar/fifo 2> error.test.out
|
|
fgrep -q ": no-such-file: Cannot stat: No such file or directory" error.test.out
|
|
fgrep -q ": Exiting with failure status due to previous errors" error.test.out
|
|
touch $@
|
|
|
|
# Test excluding files both in "c" mode and in "x" mode.
|
|
excld.test: tar-1.30.tar_done $(PARTAR)
|
|
rm -rf excld.dir.tar excld.dir.partar excld.odir.tar excld.odir.partar
|
|
mkdir excld.dir.tar excld.dir.partar excld.odir.tar excld.odir.partar
|
|
tar cf - -C output-with-tar/ --exclude d\?c tar-1.30 | tar xf - -C excld.dir.tar
|
|
$(VALGRIND) ./$(PARTAR) cf - -C output-with-tar/ --exclude d\?c tar-1.30 | tar xf - -C excld.dir.partar
|
|
diff -r excld.dir.tar excld.dir.partar
|
|
tar c -C output-with-tar/ tar-1.30 | tar x -C excld.odir.tar --exclude d\?c
|
|
diff -r excld.dir.tar excld.odir.tar
|
|
tar c -C output-with-tar/ tar-1.30 | $(VALGRIND) ./$(PARTAR) x -C excld.odir.partar --exclude d\?c
|
|
diff -r excld.dir.tar excld.odir.partar
|
|
touch $@
|
|
|
|
# Test excluding files both in "c" mode and in "x" mode same as above but uses --exclude=PATTERN.
|
|
excld-equal.test: tar-1.30.tar_done $(PARTAR)
|
|
rm -rf excld-equal.dir.tar excld-equal.dir.partar excld-equal.odir.tar excld-equal.odir.partar
|
|
mkdir excld-equal.dir.tar excld-equal.dir.partar excld-equal.odir.tar excld-equal.odir.partar
|
|
tar cf - -C output-with-tar/ --exclude=d\?c tar-1.30 | tar xf - -C excld-equal.dir.tar
|
|
$(VALGRIND) ./$(PARTAR) cf - -C output-with-tar/ --exclude=d\?c tar-1.30 | tar xf - -C excld-equal.dir.partar
|
|
diff -r excld-equal.dir.tar excld-equal.dir.partar
|
|
tar c -C output-with-tar/ tar-1.30 | tar x -C excld-equal.odir.tar --exclude d\?c
|
|
diff -r excld-equal.dir.tar excld-equal.odir.tar
|
|
tar c -C output-with-tar/ tar-1.30 | $(VALGRIND) ./$(PARTAR) x -C excld-equal.odir.partar --exclude=d\?c
|
|
diff -r excld-equal.dir.tar excld-equal.odir.partar
|
|
touch $@
|
|
|
|
# Test the same file appearing twice on the command line. tar makes a hardlink from the file to itself.
|
|
linklink.test: $(PARTAR)
|
|
echo a > linklink.txt
|
|
tar cf linklink.tar linklink.txt linklink.txt
|
|
$(VALGRIND) ./$(PARTAR) cf linklink.partar linklink.txt linklink.txt
|
|
# Don't run the diff unless we have a recent version of tar
|
|
if (tar --version|head -1|fgrep 1.3 > /dev/null); then diff linklink.tar linklink.partar; fi
|
|
mkdir -p linklink.tdir
|
|
tar xf linklink.tar -C linklink.tdir
|
|
mkdir -p linklink.pdir
|
|
tar xf linklink.partar -C linklink.pdir
|
|
diff -r linklink.tdir linklink.pdir
|
|
touch $@
|
|
|
|
# This isn't part of the standard tests, since it requires sudo to run properly.
|
|
permissions.sudo.test: $(PARTAR)
|
|
sudo rm -rf permissions.sudopartar.testdir permissions.sudountar.testdir
|
|
mkdir -p permissions.sudopartar.testdir
|
|
mkdir -p permissions.sudountar.testdir
|
|
sudo tar pxf test-tars/permissions.tar -C permissions.sudountar.testdir
|
|
sudo ./$(PARTAR) pxf test-tars/permissions.tar -C permissions.sudopartar.testdir
|
|
# for some reason tar doesn't set the mtime on partar/src/bin in those directories, so let's ignore bin.
|
|
(cd permissions.sudopartar.testdir; ls -lR)|sort | egrep -v "bin$$" > permissions.sudopartar.out
|
|
(cd permissions.sudountar.testdir; ls -lR)|sort | egrep -v "bin$$" > permissions.sudountar.out
|
|
diff permissions.sudopartar.out permissions.sudountar.out
|
|
|
|
# permissions test for not sudo
|
|
permissions.test: $(PARTAR)
|
|
rm -rf permissions.in.dir permissions.tar.out.dir permissions.partar.out.dir permissions.tar.ls permissions.partar.ls
|
|
mkdir -p permissions.in.dir/s
|
|
mkdir -p permissions.in.dir/s/d1
|
|
mkdir -p permissions.in.dir/s/d2
|
|
ls -l permissions.in.dir/s
|
|
chmod 770 permissions.in.dir/s/d1
|
|
chmod 750 permissions.in.dir/s/d2
|
|
ls -l permissions.in.dir/s
|
|
mkdir -p permissions.tar.out.dir
|
|
tar cf - -C permissions.in.dir s | tar xf - -C permissions.tar.out.dir
|
|
ls -l permissions.tar.out.dir/s | sort > permissions.tar.ls
|
|
mkdir -p permissions.partar.out.dir
|
|
tar cf - -C permissions.in.dir s | $(VALGRIND) ./$(PARTAR) xf - -C permissions.partar.out.dir
|
|
ls -l permissions.partar.out.dir/s | sort > permissions.partar.ls
|
|
diff permissions.tar.ls permissions.partar.ls
|
|
touch $@
|
|
|
|
# Test for detecting .gz and .xz inputs.
|
|
decompression-errors.test: ./partar
|
|
! ./partar xf test-tars/fifo.tar.xz 2> decompression-errors.out
|
|
fgrep "Input does not appear to be a tar file." decompression-errors.out > /dev/null
|
|
fgrep "Input appears to be xz compressed" decompression-errors.out > /dev/null
|
|
!(xzcat test-tars/fifo.tar.xz |gzip|./partar xf - 2> decompression-errors.out)
|
|
fgrep "Input does not appear to be a tar file." decompression-errors.out > /dev/null
|
|
fgrep "appears to be gzipped" decompression-errors.out > /dev/null
|
|
touch $@
|
|
|
|
%.dir:
|
|
mkdir $@
|
|
|
|
# Some specific tests for parcp
|
|
parcp0.test: parcp tar-1.30.tar_done | parcp0.test.dir
|
|
rm -rf $@.dir/*
|
|
./parcp --restore -- output-with-tar/tar-1.30 $@.dir
|
|
touch $@
|
|
|
|
parcp1.test: parcp
|
|
./parcp --version |fgrep $(VERSION) > /dev/null
|
|
./parcp --help |fgrep OPTION > /dev/null
|
|
touch $@
|
|
|
|
# test that if we copy into an existing file that is longer, that it's properly trunated
|
|
parcp2.test: parcp | parcp2.test.dir
|
|
rm -rf $@.dir/*
|
|
mkdir -p $@.dir/src $@.dir/dst/src
|
|
echo "hello" > $@.dir/src/hello
|
|
echo "hello there" > $@.dir/dst/src/hello
|
|
ls -i $@.dir/dst/src/hello > $@.dir/original.inode
|
|
./parcp -P 3 $@.dir/src $@.dir/dst
|
|
ls -i $@.dir/dst/src/hello > $@.dir/new.inode
|
|
diff $@.dir/src/hello $@.dir/dst/src/hello
|
|
diff $@.dir/new.inode $@.dir/original.inode
|
|
touch $@
|
|
|
|
parcp3.test: parcp | parcp3.dir
|
|
rm -rf $@.dir/*
|
|
mkdir -p $@.dir/src $@.dir/dst
|
|
# source and dest are the same symlink, so expect no change
|
|
ln -s unchanged $@.dir/src/uc
|
|
ln -s unchanged $@.dir/dst/uc
|
|
# source and dest are slightly different symlinks, the same length.
|
|
ln -s changed0 $@.dir/src/ch
|
|
ln -s changed1 $@.dir/dst/ch
|
|
# source and dest are different symlinks of different length.
|
|
ln -s shortch $@.dir/src/chlen
|
|
ln -s longerch $@.dir/dst/chlen
|
|
# source is symlink, dest is not there
|
|
ln -s notthere $@.dir/src/nt
|
|
# source is a symlink, dest is a dir
|
|
ln -s dest-was-dir $@.dir/src/wasdir
|
|
mkdir $@.dir/dst/wasdir
|
|
# source is a symlink, dest is a regular file.
|
|
ln -s dest-was-reg $@.dir/src/wasreg
|
|
touch $@.dir/dst/wasreg
|
|
#ls -l $@.dir/dst
|
|
ls -i parcp3.test.dir/dst/uc > $@.dir/original.uc.symlink
|
|
# source and dest are fifos. Make sure the inode is reused
|
|
mknod $@.dir/src/src_fifo_dst_fifo p
|
|
mknod $@.dir/dst/src_fifo_dst_fifo p
|
|
ls -i $@.dir/dst/src_fifo_dst_fifo > $@.dir/src_fifo_dst_fifo.original
|
|
# source is fifo and dest is regular. Make sure dest becomes fifo
|
|
mknod $@.dir/src/src_fifo_dst_reg p
|
|
touch $@.dir/dst/src_fifo_dst_reg
|
|
# source is regular and dest is fifo. Make sure dest becomes reg
|
|
touch $@.dir/src/src_reg_dst_fifo
|
|
mknod $@.dir/dst/src_reg_dst_fifo p
|
|
# source is file, dest is dir
|
|
touch $@.dir/src/src_reg_dst_dir
|
|
mkdir $@.dir/dst/src_reg_dst_dir
|
|
# source is dir, dest is file
|
|
mkdir $@.dir/src/src_dir_dst_reg
|
|
touch $@.dir/dst/src_dir_dst_reg
|
|
# two files that are the same inode in src, nothing in dst
|
|
touch $@.dir/src/src_two_inodes_dst_null.1
|
|
ln $@.dir/src/src_two_inodes_dst_null.1 $@.dir/src/src_two_inodes_dst_null.2
|
|
# two files the same inode in src, a file in dst
|
|
touch $@.dir/src/src_two_inodes_dst_reg.1
|
|
ln $@.dir/src/src_two_inodes_dst_reg.1 $@.dir/src/src_two_inodes_dst_reg.2
|
|
touch $@.dir/dst/src_two_inodes_dst_reg.1
|
|
# two files the same inode in src, two dirs in dst
|
|
touch $@.dir/src/src_two_inodes_dst_two_dirs.1
|
|
ln $@.dir/src/src_two_inodes_dst_two_dirs.1 $@.dir/src/src_two_inodes_dst_two_dirs.2
|
|
mkdir $@.dir/dst/src_two_inodes_dst_two_dirs.1
|
|
mkdir $@.dir/dst/src_two_inodes_dst_two_dirs.2
|
|
# three files the same inode in src, three files in dst, two of which are the same inode.
|
|
touch $@.dir/src/src_3_inodes_dst_3_files.1
|
|
ln $@.dir/src/src_3_inodes_dst_3_files.1 $@.dir/src/src_3_inodes_dst_3_files.2
|
|
ln $@.dir/src/src_3_inodes_dst_3_files.1 $@.dir/src/src_3_inodes_dst_3_files.3
|
|
touch $@.dir/dst/src_3_inodes_dst_3_files.1
|
|
ln $@.dir/dst/src_3_inodes_dst_3_files.1 $@.dir/dst/src_3_inodes_dst_3_files.2
|
|
touch $@.dir/dst/src_3_inodes_dst_3_files.3
|
|
# do the copy
|
|
$(VALGRIND) ./parcp $@.dir/src $@.dir/dst
|
|
ls -l $@.dir/dst
|
|
test -h $@.dir/dst/ch
|
|
ls -l $@.dir/dst/ch | fgrep "ch -> changed0"
|
|
ls -l $@.dir/dst/nt | fgrep "nt -> notthere"
|
|
ls -l $@.dir/dst/wasdir | fgrep "wasdir -> dest-was-dir"
|
|
ls -l $@.dir/dst/chlen | fgrep "chlen -> shortch"
|
|
test -h $@.dir/dst/wasreg
|
|
ls -l $@.dir/dst/wasreg| fgrep "wasreg -> dest-was-reg"
|
|
# test follows symlinks so we must do htis more carefully
|
|
ls -i parcp3.test.dir/dst/uc > $@.dir/new.uc.symlink
|
|
diff $@.dir/original.uc.symlink $@.dir/new.uc.symlink
|
|
ls -i $@.dir/dst/src_fifo_dst_fifo > $@.dir/src_fifo_dst_fifo.new
|
|
diff $@.dir/src_fifo_dst_fifo.new $@.dir/src_fifo_dst_fifo.original
|
|
test -p $@.dir/dst/src_fifo_dst_reg
|
|
test -f $@.dir/dst/src_reg_dst_fifo
|
|
test -f $@.dir/dst/src_reg_dst_dir
|
|
test -d $@.dir/dst/src_dir_dst_reg
|
|
test parcp3.test.dir/dst/src_two_inodes_dst_null.1 -ef parcp3.test.dir/dst/src_two_inodes_dst_null.2
|
|
test parcp3.test.dir/dst/src_two_inodes_dst_reg.1 -ef parcp3.test.dir/dst/src_two_inodes_dst_reg.2
|
|
test parcp3.test.dir/dst/src_3_inodes_dst_3_files.1 -ef parcp3.test.dir/dst/src_3_inodes_dst_3_files.2
|
|
test parcp3.test.dir/dst/src_3_inodes_dst_3_files.1 -ef parcp3.test.dir/dst/src_3_inodes_dst_3_files.3
|
|
touch $@
|
|
|
|
# Check --delete
|
|
parcp4.test: parcp | parcp4.test.dir
|
|
rm -rf $@.dir/*
|
|
mkdir -p $@.dir/src $@.dir/dst
|
|
mkdir -p $@.dir/dst/a/b/c/d/e
|
|
touch $@.dir/dst/a/b/c/d/e/f
|
|
mkdir -p $@.dir/dst/a/b/c/d/e2
|
|
touch $@.dir/dst/a/b/c/d/e2/f
|
|
mkdir -p $@.dir/src/x/y/z
|
|
mkdir -p $@.dir/src/a/w
|
|
touch $@.dir/src/a/w/foo
|
|
$(VALGRIND) ./parcp --delete $@.dir/src $@.dir/dst
|
|
diff -r $@.dir/src $@.dir/dst
|
|
touch $@
|
|
|
|
# Check --exclude-from
|
|
parcp5.test: parcp | parcp5.test.dir
|
|
rm -rf $@.dir/*
|
|
mkdir -p $@.dir/src $@.dir/dst
|
|
mkdir $@.dir/src/wanted
|
|
mkdir $@.dir/src/unwanted
|
|
touch $@.dir/src/wanted/file1.keep
|
|
touch $@.dir/src/wanted/file2.nokeep
|
|
touch $@.dir/src/wanted/file3.nokeep
|
|
echo unwanted > $@.dir/excludelist
|
|
echo wanted/file2.nokeep >> $@.dir/excludelist
|
|
echo file3.nokeep >> $@.dir/excludelist
|
|
$(VALGRIND) ./parcp --exclude-from=$@.dir/excludelist $@.dir/src $@.dir/dst
|
|
test -d $@.dir/dst/wanted
|
|
test -f $@.dir/dst/wanted/file1.keep
|
|
ls $@.dir/dst/wanted|fgrep -v file2.nokeep > /dev/null
|
|
ls $@.dir/dst/wanted|fgrep -v file3.nokeep > /dev/null
|
|
test ! -d $@.dir/dst/unwanted
|
|
touch $@
|
|
|
|
# Check --exclude-from with --delete
|
|
parcp6.test: parcp Makefile | parcp6.test.dir
|
|
rm -rf $@.dir/*
|
|
mkdir -p $@.dir/src $@.dir/dst
|
|
mkdir -p $@.dir/src/src_wanted
|
|
mkdir -p $@.dir/dst/dst_wanted
|
|
mkdir -p $@.dir/dst/dst_extra
|
|
mkdir -p $@.dir/dst/dst_extra2
|
|
mkdir -p $@.dir/dst/dst_kill
|
|
touch $@.dir/dst/dst_wanted/keepme
|
|
touch $@.dir/dst/dst_extra/dst_wanted_file
|
|
touch $@.dir/dst/dst_extra2/keep2
|
|
touch $@.dir/dst/dst_extra2/killme
|
|
touch $@.dir/dst/dst_kill/killme2
|
|
echo dst_wanted > $@.dir/excludelist
|
|
echo dst_wanted_file >> $@.dir/excludelist
|
|
echo dst_extra2/keep2 >> $@.dir/excludelist
|
|
$(VALGRIND) ./parcp --exclude-from=$@.dir/excludelist --delete $@.dir/src $@.dir/dst
|
|
test -f $@.dir/dst/dst_wanted/keepme
|
|
test -f $@.dir/dst/dst_extra/dst_wanted_file
|
|
test -f $@.dir/dst/dst_extra2/keep2
|
|
test ! -f $@.dir/dst/dst_extra2/killme
|
|
test ! -f $@.dir/dst/dst_kill/killme2
|
|
test ! -d $@.dir/dst/dst_kill
|
|
touch $@
|
|
|
|
# Check target contains a read-only file
|
|
# Three cases: 1) No such file in src
|
|
# 2) Exactly the same file in src
|
|
# 3) A different file in src
|
|
parcp7.test: parcp | parcp7.test.dir
|
|
rm -rf $@.dir/*
|
|
mkdir -p $@.dir/src $@.dir/dst
|
|
touch $@.dir/dst/no-such-file-in-src
|
|
chmod ugo-w $@.dir/dst/no-such-file-in-src
|
|
echo same in src > $@.dir/src/same-file-in-src
|
|
chmod ugo-w $@.dir/src/same-file-in-src
|
|
cp -a $@.dir/src/same-file-in-src $@.dir/dst/same-file-in-src
|
|
echo diffrent in src > $@.dir/src/diff-file-in-src
|
|
chmod ugo-w $@.dir/src/diff-file-in-src
|
|
echo diffrent in dst dst > $@.dir/dst/diff-file-in-src
|
|
chmod ugo-w $@.dir/dst/diff-file-in-src
|
|
ls -l $@.dir/{src,dst}
|
|
$(VALGRIND) ./parcp --delete $@.dir/src $@.dir/dst
|
|
ls -l $@.dir/{src,dst}
|
|
test ! -f $@.dir/dst/no-such-file-in-src
|
|
test -f $@.dir/dst/diff-file-in-src
|
|
test -f $@.dir/dst/same-file-in-src
|
|
diff -r $@.dir/{src,dst}
|
|
touch $@
|
|
|
|
parcp8.test: parcp | parcp7.test.dir
|
|
rm -rf $@.dir/*
|
|
mkdir -p $@.dir/src $@.dir/dst
|
|
touch $@.dir/src/rws-file
|
|
chmod +sx $@.dir/src/rws-file
|
|
./parcp $@.dir/src $@.dir/dst
|
|
test -x parcp8.test.dir/dst/rws-file
|
|
test -u parcp8.test.dir/dst/rws-file
|
|
echo touch $@
|
|
|
|
.PHONY: clean
|
|
clean:
|
|
rm -rf parrm parcp $(PARTAR) parrm.1.gz parcp.1.gz $(PARTAR).1.gz *.o output-with-tar output-to-rm output-with-parcp *.tar_done *.parrm_test *.parcp_test *.partar_test
|
|
rm -rf gitrev.c
|
|
rm -rf output-with-partar{1,2,3,4} output-of-partarred
|
|
rm -rf uncompressed-tars gzipped-tars
|
|
rm -rf *.partar{1,2,3,4}_diff
|
|
rm -rf *.partar{1,2,3,4}_done
|
|
rm -rf excld.dir.*tar excld.test
|
|
rm -rf excld-equal.dir.*tar excld-equal.test
|
|
if test -n "$$(find . -maxdepth 1 -name 'parrm_eaccess_test*_dir' -print -quit)"; then chmod -R u+rwx parrm_eaccess_test*_dir; fi
|
|
rm -rf parrm_eaccess_test*{.out,_dir}
|
|
rm -rf error.test.out error.tar linklink.tar linklink.partar linklink.tdir linklink.pdir linklink.txt excld.odir.partar excld.odir.tar
|
|
rm -rf permissions.in.dir permissions.tar.out.dir permissions.partar.out.dir permissions.tar.ls permissions.partar.ls
|
|
rm -rf *.ls *.test *.tar_test
|
|
rm -rf *.partar_out *.tar_out test1.out *.out
|
|
rm -rf test_fin
|
|
rm -f *.gcda *.gcno common/*.gcda common/*.gcno
|
|
rm -rf *.dir/
|
|
rm -rf *.1.gz
|
|
rm -f $(COMMON_O)
|
|
rm -rf partar_log
|
|
|
|
.PHONY: realclean
|
|
realclean: clean
|