From: Kern Sibbald Date: Thu, 4 Oct 2007 09:27:43 +0000 (+0000) Subject: Copy trunk regress into Branch X-Git-Tag: Release-2.2.5~16 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=5a3aaf2bd19fda6082069e3ba9571a45f030b519;p=bacula%2Fbacula Copy trunk regress into Branch git-svn-id: https://bacula.svn.sourceforge.net/svnroot/bacula/branches/Branch-2.2@5717 91ce42f0-d328-0410-95d8-f526ca767f89 --- diff --git a/regress/regress/Makefile b/regress/regress/Makefile new file mode 100644 index 0000000000..c7e575c37c --- /dev/null +++ b/regress/regress/Makefile @@ -0,0 +1,68 @@ +# +# Makefile for Bacula regression testing +# +# Before running, you must create a file named config containing +# the configuration parameters. Create it by doing: +# +# cp prototype.conf config +# +# Then edit config and set the value for what are appropriate for you. +# + +first_rule: all + +all: + +setup: bacula sed + +# +# Some machines cannot handle the sticky bit and other garbage that +# is in weird-files, so we load and run it only on Linux machines. +# +bacula: all + @rm -rf bin build weird-files tmp + @rm -f w.tar.gz w.tar + @cp weird-files.tar.gz w.tar.gz + @-gunzip w.tar.gz + @-tar xf w.tar + @rm -f w.tar.gz w.tar + @rm -rf tmp working + mkdir tmp working + echo "Doing: scripts/setup" + scripts/setup + +sed: + echo "Doing: scripts/do_sed" + scripts/do_sed + +# Run all non-root userid tests +test: + ./all-non-root-tests + +# run all file and tape tests +full_test: + ./all-tape-and-file-tests + +# These tests require you to run as root +root_test: + ./all-root-tests + +clean: + scripts/cleanup + rm -f tmp/file-list + rm -fr tmp/* working/* + rm -f test.out + rm -f diff + rm -f 1 2 3 scripts/1 scripts/2 scripts/3 tests/1 tests/2 tests/3 + find . -name .#* -exec rm -rf {} \; + +# Reset our userid after running as root +reset: + chown -R ${USER}:${USER} . tmp working + scripts/cleanup + rm -f tmp/* working/* + +distclean: clean + rm -rf bin build weird-files weird-files weird-files2 tmp working + rm -f scripts/*.conf + diff --git a/regress/regress/README b/regress/regress/README new file mode 100644 index 0000000000..d289c630a3 --- /dev/null +++ b/regress/regress/README @@ -0,0 +1,204 @@ + Bacula Regression + Kern Sibbald + +This is Bacula's regression script directory. + +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +Warning!!!! Make sure not to run it on the same system +with your production Catalog because the tables will all +be cleared. You can run it on the your production system +if you use a different database. E.g. if your production +system uses MySQL, you can use SQLite here. +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + + +To set it up, create your personal configuration file, by +copying prototype.conf to config or simply editing prototype.conf +directly then copying it to the file config. + +You must end up with a file named config in the main regress +directory that has all the specifications that correspond to +your system. + +If you are using SQLite, make sure that depkgs is pre-built if it +isn't already: (cd your-depkgs; make sqlite). + +Note, if you use any database other than SQLite, be sure it is not +your production database because Bacula will delete all the tables +and recreate them. With SQLite, a new different database is created, +so it will not affect your production system. + +Using the .conf file, you can now select between any Catalog type: +SQLite, SQLite3, MySQL, or PostgreSQL. Be aware, however, if you +use an installed database on a production server, running these +tests will delete all the tables !!!!!!!!!!!!!!!!!! I run my +tests on a non-production machine, and in addition, I normally use +SQLite as the database, while my production uses MySQL. + +Then do: + + make setup + +You run the above one time. This will build a Makefile from +Makefile.in and your xxx.conf file, copy the Bacula source, +configure, build it, and configure all the Bacula scripts +and conf files. If you change your source, you will need to +redo this command. + +Then you can run any of the tests in the tests subdirectory. +Each test whose name ends in -root requires you to be root for +a resonable run. Each test is totally independent of any other +test. Aside from the required "make setup", each test is totally +self-initalizing and should clean up after itself. + +All the tests expect you to execute them from the main regress +directory! + +You can run all the disk based tests by doing: + + ./do_file + +The disk based tests are totally separate from any production +system, provided you have configured the database appropriately +as noted above. + +You can run all the disk and most of the tape tests by doing: + + ./do_all + +======== Important !!! ============ +When running the tape tests, Bacula will write on any tape that +is in the tape drive that you have configured. If it is a production +Bacula tape, it will be destroyed. If you have configured an Autochanger, +Bacula will write on the tapes in slots 1 and 2 thus destroying any +information on those tapes, even if they are Bacula production tapes. +=================================== + +Each of the above calls one or more scripts. By looking at the +scripts available in this directory, you can see that there are a number +of options for running tests. + +You can run them individually as: + + tests/two-jobs-test + +or all non-root tests (my normal testing under my account) + + ./all-non-root-tests + +or all tests (I only run these before a production release): + + su + ./all-tests + + +after running the root tests, while still root, it is a good idea +to do: + + make reset + +this cleans up any files that may be created with root permissions. + +If you want to add more tests, do so by putting the shell script +in the tests subdirectory. Be careful when adding (or better not) +new clients, pools, and such to the test-bacula-dir.conf.in file +as it may invalidate a good number of tests, which respond to +questions by answering with a number (i.e. the order of the selection +list is known). It might be better to add your own testb-bacula... +configuration file. + +To avoid re-doing a make setup if you have made a change to the +conf files, and you do not need a new copy of the source, you can simply do: + + make sed + +Debugging failed tests: +Prior versions required editing the tests/xxxx and changing a debug flag. +However, that has been replaced by two environment variables: + + REGRESS_DEBUG + REGRESS_WAIT + +If you define REGRESS_DEBUG, e.g. + + REGRESS_DEBUG=1 + export REGRESS_DEBUG + +then run a test, it will display the job and debug output. + +If you define REGRESS_WAIT, the script will stop and request: + +Start Bacula under debugger and enter anything when ready ... + +At this point, you can start any of the daemons under the debugger, +then answer the message by entering any character. The script will +then continue. For any daemon or daemons that you have manually started, +you will see an error message when the script attempts to run a second +copy, but those messages can be ignored. This makes it reasonably easy +to run any component or components under the debugger if necessary. + +Explicit example: + +In shell window 1. + +cd regress +export REGRESS_DEBUG=1 +export REGRESS_WAIT=1 +tests/name-of-script-test +(wait until it tells you to start the debugger) + +In shell window 2 + +cd regress/bin +gdb bacula-xx (where xx is the component you want to debug). +(possibly set a break point -- normally not) +run -s -f +(wait for the output to stop) + +In shell window 1 +(enter any character or simply a return) +(ignore the error message it prints complaining that the daemon +you are debugging is already running, which is in fact the case). + + +That is all there is to it. The debugger window will get some +output and will stop waiting for input if anything goes wrong +like a seg fault. At that point, you can enter commands. + +The procedure avoids modifying the test scripts and trying to +find pids and the such. If you want less debug output when +debugging, don't set REGRESS_DEBUG=1. + +=== + +Also, if you run from time to time on a computer that is not connected +to the network, please be sure that "hostname" is set to "localhost", +otherwise, your tests may fail because the hostname used by Bacula's +./configure cannot be properly resolved. + +Anyway, you can debug where it is happening in the source code using the +following example. For example, here I get the following backtrace: + +======= Backtrace: ========= +/lib/libc.so.6[0xb7b9d6e1] +/lib/libc.so.6(cfree+0x89)[0xb7b9ed79] +/home/kern/bacula/regress/bin/bacula-fd[0x8082ae5] +/home/kern/bacula/regress/bin/bacula-fd[0x8082d58] +/home/kern/bacula/regress/bin/bacula-fd[0x80838ac] +/home/kern/bacula/regress/bin/bacula-fd[0x807aa3f] +/home/kern/bacula/regress/bin/bacula-fd[0x807ac29] +/home/kern/bacula/regress/bin/bacula-fd[0x804d188] +/lib/libc.so.6(__libc_start_main+0xdc)[0xb7b4ef9c] +/home/kern/bacula/regress/bin/bacula-fd[0x804cd21] + +Now to convert this into something more meaningful, kill off any hung Bacula +processes. Note the one that was running -- above you see that it was +bacula-fd, then bring the same binary up in the debugger. Then start at the +first bacula-fd line, and feed the hex number to gdb as follows: + +info symbol 0x8082ae5 +free_addresses(dlist*) + 53 in section .text + +info symbol 0x8082d58 +add_address(dlist**, IPADDR::i_type, unsigned short, int, char const*, char +const*, char**) + 568 in section .text diff --git a/regress/regress/README.mingw32 b/regress/regress/README.mingw32 new file mode 100644 index 0000000000..14e6df0087 --- /dev/null +++ b/regress/regress/README.mingw32 @@ -0,0 +1,44 @@ + Re: [Bacula-devel] Win32 Regression Scripts +From: "Michael Short" (Securenets.us) + To: bacula-devel@lists.sourceforge.net +Date: 30 August 2007 04:09:00 + + +Hey guys, I've made a bit of progress on the win32 regression scripts. + +In order to use the win32 bacula regression scripts, it is important to have +some unix tools (such as sed, grep, and diff). To make things simple, I +downloaded UnxUtils from http://sourceforge.net/projects/unxutils + +Extract this somewhere on your hdd and add the the files in usr\local\wbin to +c:\regress\tools and then add c:\regress\tools to your {$PATH} on your windows +box. If you also want to make use of the shell (from unxutils) you may want +to add the ./bin directory as well (or just copy the sh.exe file to +usr\local\wbin). + +Now that you have a working toolset (with sed) we can continue setting up +regression tools. Compile the Ming32 version of bacula (from linux) and then +copy the entire source directory of bacula (with binaries) to somewhere on +your windows hdd (say... C:\bacula :P). + +Copy a version of the regression scripts ( from regress/win32 ) to your +windows hdd (hmm... C:\regress ). Edit the prototype.conf file and set your +bacula source directory ( C:/bacula ) and your e-mail address (!!). Run +"config prototype.conf" from within the regression directory to configure +the regression scripts. + +Edit regress\scripts\install_bacula.cmd and replace "COPY bin\sqlite.dll +bin\bacula_cats.dll > nul" and replace "cats_sqlite.dll" with +"cats_sqlite3.dll". ( FixMe ) + +>From the regress directory, run "make setup" and the script should copy the +binaries from the bacula sources and create a local bacula testing platform. +----------- + +After the "make setup" all the configuration files are blank, so you must +fix that before running the scripts. + +With the above, most of the regressions scripts seem to function flawlessly. + +[KES] The ones that fail have probably been modified on the Unix side + after the port was done, so they may need some minor updates. diff --git a/regress/regress/all-non-root-2tape-tests b/regress/regress/all-non-root-2tape-tests new file mode 100755 index 0000000000..9491417f1b --- /dev/null +++ b/regress/regress/all-non-root-2tape-tests @@ -0,0 +1,10 @@ +#!/bin/sh +# +# Run all tape tests +# +echo "Start two tape tests" +echo "Start two tape tests" >>test.out +nice tests/two-volume-tape +nice tests/incremental-2tape +echo "End two tape tests" +echo "End two tape tests" >>test.out diff --git a/regress/regress/all-non-root-tape-tests b/regress/regress/all-non-root-tape-tests new file mode 100755 index 0000000000..708aa8389d --- /dev/null +++ b/regress/regress/all-non-root-tape-tests @@ -0,0 +1,29 @@ +#!/bin/sh +# +# Run all tape tests +# +. ./config.out +if test ! x$AUTOCHANGER = x/dev/null ; then + mtx -f $AUTOCHANGER load 1 >/dev/null &2>/dev/null +fi +echo " " +echo " " >>test.out +echo "Start all non-root tape tests" +echo "Start all non-root tape tests" >>test.out +nice tests/ansi-label-tape +nice tests/backup-bacula-tape +nice tests/btape-fill-tape +nice tests/fixed-block-size-tape +nice tests/four-concurrent-jobs-tape +nice tests/four-jobs-tape +nice tests/incremental-tape +nice tests/relabel-tape +nice tests/restore-by-file-tape +nice tests/small-file-size-tape +nice tests/truncate-bug-tape +nice tests/two-pool-tape +nice tests/2drive-incremental-2tape +nice tests/bscan-tape +nice tests/verify-vol-tape +echo "End all non-root tape tests" +echo "End all non-root tape tests" >>test.out diff --git a/regress/regress/all-non-root-tests b/regress/regress/all-non-root-tests new file mode 100755 index 0000000000..831e232728 --- /dev/null +++ b/regress/regress/all-non-root-tests @@ -0,0 +1,76 @@ +#!/bin/sh +# +# Run all tests +# +echo " " +echo " " >>test.out +echo "Start non-root disk tests" +echo "Start non-root disk tests" >>test.out +nice tests/auto-label-test +nice tests/backup-bacula-test +nice tests/bextract-test +nice tests/big-vol-test +nice tests/bscan-test +nice tests/bsr-opt-test +nice tests/compressed-test +nice tests/compress-encrypt-test +nice tests/concurrent-jobs-test +nice tests/data-encrypt-test +nice tests/encrypt-bug-test +nice tests/fifo-test +nice tests/backup-to-null +nice tests/regexwhere-test +# The following two can uses *lots* of disk space +# so they are normally turned off, but if you have +# at least two GB free, you can run them +#nice tests/sparse-encrypt-test +#nice tests/gigaslam-sparse-test +nice tests/differential-test +nice tests/four-concurrent-jobs-test +nice tests/four-jobs-test +nice tests/incremental-test +nice tests/query-test +nice tests/recycle-test +nice tests/restore2-by-file-test +nice tests/restore-by-file-test +nice tests/restore-disk-seek-test +#nice tests/runscript-test +nice tests/six-vol-test +nice tests/span-vol-test +nice tests/maxvol-test +nice tests/sparse-compressed-test +nice tests/sparse-test +nice tests/two-jobs-test +nice tests/two-vol-test +nice tests/verify-cat-test +nice tests/verify-vol-test +nice tests/weird-files2-test +nice tests/weird-files-test +nice tests/migration-job-test +nice tests/migration-jobspan-test +nice tests/migration-volume-test +nice tests/migration-time-test +nice tests/hardlink-test +nice tests/tls-test +echo "End non-root disk tests" +echo "End non-root disk tests" >>test.out + +# +# The following are Virtual Disk Autochanger tests +echo " " +echo " " >>test.out +echo "Start non-root virtual disk autochanger tests" +echo "Start non-root virtual disk autochangertests" >>test.out +#nice tests/three-pool-recycle-test +nice tests/two-pool-test +nice tests/fast-two-pool-test +nice tests/two-volume-test +nice tests/incremental-2disk +nice tests/2drive-incremental-2disk +nice tests/scratch-pool-test +nice tests/2drive-concurrent-test +nice tests/incremental-2media +nice tests/three-pool-test +nice tests/2drive-3pool-test +echo "End non-root virtual disk autochanger tests" +echo "End non-root virtual disk autochangertests" >>test.out diff --git a/regress/regress/all-root-tests b/regress/regress/all-root-tests new file mode 100755 index 0000000000..1ba54d9f4a --- /dev/null +++ b/regress/regress/all-root-tests @@ -0,0 +1,14 @@ +#!/bin/sh +# +# Run all root tests +# +echo " " +echo " " >>test.out +echo "Start root tests" +echo "Start root tests" >>test.out +tests/dev-test-root +tests/etc-test-root +tests/lib-test-root +tests/usr-tape-root +echo "End root tests" +echo "End root tests" >>test.out diff --git a/regress/regress/all-tape-and-file-tests b/regress/regress/all-tape-and-file-tests new file mode 100755 index 0000000000..9bc3e7676c --- /dev/null +++ b/regress/regress/all-tape-and-file-tests @@ -0,0 +1,6 @@ +#!/bin/sh +# +# Run all tests +# +./all-non-root-tests +./all-non-root-tape-tests diff --git a/regress/regress/all-tests b/regress/regress/all-tests new file mode 100755 index 0000000000..e3dc688c87 --- /dev/null +++ b/regress/regress/all-tests @@ -0,0 +1,6 @@ +#!/bin/sh +# +# Run all tests +# +./all-non-root-tests +./all-root-tests diff --git a/regress/regress/do_all b/regress/regress/do_all new file mode 100755 index 0000000000..5dfc97fad5 --- /dev/null +++ b/regress/regress/do_all @@ -0,0 +1,3 @@ +#!/bin/sh +nice make setup +./do_all_tests diff --git a/regress/regress/do_all_tapes b/regress/regress/do_all_tapes new file mode 100755 index 0000000000..dd07d2ec99 --- /dev/null +++ b/regress/regress/do_all_tapes @@ -0,0 +1,3 @@ +#!/bin/sh +make setup +./all-non-root-tape-tests diff --git a/regress/regress/do_all_tests b/regress/regress/do_all_tests new file mode 100755 index 0000000000..76d4bc3c71 --- /dev/null +++ b/regress/regress/do_all_tests @@ -0,0 +1,20 @@ +#!/bin/sh +./starttime +if [ ! -f bin/tape_options ] ; then + touch bin/tape_options +fi +echo " " >test.out +cat build/config.out >>test.out +echo " " >>test.out +echo "Test results" >>test.out +echo " " >>test.out +./starttime +nice ./all-non-root-tests +nice ./all-non-root-tape-tests +nice ./all-non-root-2tape-tests +echo " " +echo "End do_all tests" +echo "End do_all tests" >>test.out +scripts/cleanup +cat test.out +./endtime diff --git a/regress/regress/do_file b/regress/regress/do_file new file mode 100755 index 0000000000..0ac4aa8bf3 --- /dev/null +++ b/regress/regress/do_file @@ -0,0 +1,16 @@ +#!/bin/sh +# /home/kern/bacula/bin/startmysql +nice make setup +echo " " >test.out +cat build/config.out >>test.out +echo " " >>test.out +echo "Test results" >>test.out +echo " " >>test.out +./starttime +nice ./all-non-root-tests +echo " " +echo "End do_file tests" +echo "End do_file tests" >>test.out +scripts/cleanup +cat test.out +./endtime diff --git a/regress/regress/encrypt-bug.jpg b/regress/regress/encrypt-bug.jpg new file mode 100644 index 0000000000..18825f97ba Binary files /dev/null and b/regress/regress/encrypt-bug.jpg differ diff --git a/regress/regress/encrypt-bug.txt b/regress/regress/encrypt-bug.txt new file mode 100644 index 0000000000..6a68dd8c7b --- /dev/null +++ b/regress/regress/encrypt-bug.txt @@ -0,0 +1,49 @@ +-----BEGIN PGP MESSAGE----- +Charset: ISO-8859-1 +Version: GnuPG v1.4.2 (FreeBSD) +Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org + +hQIOA/nlxaDbIWjjEAf/dEGV3MNkQk92dZIzRIgKx3MuKElsIcQmc053MT8Wc7V3 ++FmwbqsfhirEdBU+qEINRT+3UQ+RLY1NXKlbL2JxeMdJTWx81x6wTbR+wPgi8HeE +jhPvEx1633IWS8+Au3Flmry3SxjEf4uI5N4r+hFWuvYxdalXtXtkTOvTbfmtoQPG +y9mQ7eCdpAQr/kKOpaC2wWeVrlfEUuURENATlYfdLxKGuGDqD83TmWpO5zlgJ2pL +ChpZAVBCcapC0FFDbqIYxtqbFsA8HwmNiVIeiF4Pebcq+tDBuvEt/NUCt5Piyt// +kHg9wux6q8B5a1r+95CMToQwAxwhIm6aDKiMeqnGUwgApk1MjY2jfThc4oO76Cya +am5926qs7NhiqOIGCgytVxAbnqgN2nlXaFCiGsvoY7BWQHu5/hEBUV/rZsyg2I5s +bw62sMRqMckvqGqdxhQRtlj+nSvRtBdj/Udtn91DMNVzNwzfGYUfQPWPCyuBpzNd +47xDorDvEyBf8EDMSeWtvsZXZ3DBf6TY2DPiesnBHcQjOv/zqnL9xudvD7wlhVFh +UMpMQIsltBoofrK19sm4l3yzH89PmIp4pOzYyjysEMIOz5SXisO2OBidny5eRF7/ +u7JaaiD3X6vOQSHFohbdZqQdhvMx2mps/I61rg1rRHLs5sT6rFqQIpsr3CR9cn5z +0YUEDgOkhzrPQwAHpxAP/2Frok8LvLFU0q7566b1vqbmlBEMUt01+dYvKo/PKM+x +eXA9bol4CRzTOUH8156DHzSLppqU5ZhM4kH++ub+q6FMzUsm/A6NZ1rQGjh6EsiT +dwsxYQd29nmfIuZC8liKRBVemcn6ByetnwhElkOadkDxgUF0nSU/fkt83rixL5Ak +m/wSQ9t5AYzJ5BdhwjaCjFiMGSmVRl4+rYIbxn4tfTmdpuIUEKsRmj/DbszGdBcx +jEWmmlSln0vJQhT6ZHynRW7kIsOBJUMXcOMVWL//1puWYqsTVrFpio7xHz9tj817 +P7E73S9gu30zdJRVowNt1/m7uy4BQZyhA4x057CdDRFlHHqXyJYY+cynewlkjFVJ +8hXl9X+PIJFmhmMJUkvgagJU7YPHEe3HGWq8wtul0FNieOIPsLPHZLIUDzj0uv9P +bbZHJ9PzfK+Vyy/MHgNKVL6itXYprGMFC/m2pTy7XlMRoWaQFjZ1KpynzyjS155e +9V9vmqTxDHp++P5iWyaPGyYJnFt9dypEOq0bUOz/z5wdKEYOSYb72+RqqEhDFrr7 +Z9YYabL0b+FPkzA/DP5TdtOenqxQGighTXbOp8KBsS4hJsyMLtr42GyEBg8Ob1nf +diIs8IlkCxj5jdkYZMlFK1wemLCoJ7X/egJJVHKFc1ageF6KZ9SC4y6YDT3CkVmm +D/43YEH+ezx7V3cafDi+H22Kl688gQw4oTu12v9znAc2ikQ6OQEmOFsrjiM9yK6U +Uaim1cmgo2j8DMCKoYt20P5iJhIEVrC4FgW0BeprFaADuqQ2Jl+BHjpz1A0Di7D5 +YMeVfNm0a+URk/99EsPmWbKbXRJTWNRjNGRgbNuwp3urImEZ7JSrZTZaeU41+95J +yXxHKPy3qnV9hfQ/Y2pT5TxxHpSJRmiF92ruz4lny6POdNf44jd1t3IetT4QyK2e +u/S/1aJ0NE+XRhi94D4nUGC0puL3J4wiKWuu+l/2fcqnSW8HhoepIQ+G8I46y0wq +cPoH7hC29ojoYe7hFR93/3yDJRGF+I/9Ot+EmoObkxM2ForYzVlLkov7wmfgAZEk +hNAV7UeCNgPJgVu8uWGEkXQURUq+w4/RFwOpmIVO/ZnmxXEnA6lRq7Yb6eBkCpWX +HBG/G8pB6kUSuJ1XwNo8gct38OunjYZgEo+y3q0IFhjjDe8bHk+80DDN9qtK4Kep +LeEnLKEG+J5AJZoOXNU6tqX6VTzGdbl1QYLOZFnGlXu7pLRNnr639Iuo6L99Tgoz +V2w7IND/AdtgSchZWQPz5mKYSEz9arEC42CCufDXrDlvna622GbP1YKkrMuhZmsb +qyHkC4gkJ3VWMzKNi3Hu5oQ8rSLY9tnjIoSNYTU6DYxWpdLA0wEGN1WfVcZfqwgj +ooFwtERXyub50dBVKjms3PwYQ9E9vtfQ7ABOk4LnyEprJ/zOokEuG2cGwHr7EGMc +5xx7bWLbtxORLl4TffVvseZJD7Rjejdu+P0nV9I85dCFhhUrno+TvP2BJhLvT/x0 +tiRqTMtFrEsvfDFg6j3zbmi6U/nqtRl2Iamb6ACaBVGXeXcSZqLcizaEdxq7aXqX +GIUWMeXTvWtYE9et/3NJrRm6Eo2IOQO6J0OnUvsuBc+i0pZaIi7WVnDBDMgojXXa +yRNRgm4jtwT+5KWi8QA6owXgDhjWH+dILSWTE8Q7V7grlRp4C42STtvtXmwuIDws +sb72EmQs3IkKylS7Nk6mZwhDK8Wjo6olUjS8PceWDVWLOII+hcHiuGSZXZyy7Bwg +mfswd8sqIaWPDkYwlsBq82yRS4YV224pBBxqiT3o14LqCQ56Er3ZaogGfKiL0mpJ +Lu3fpivt/HslXbumQeggeFfhn6Z/Otbr1EGrvcslPEPLehpEfks/2syF9vfqLaFp ++spDOiRKBUg= +=W5Nc +-----END PGP MESSAGE----- \ No newline at end of file diff --git a/regress/regress/encrypt-bug2.txt b/regress/regress/encrypt-bug2.txt new file mode 100644 index 0000000000..ef110a6c95 --- /dev/null +++ b/regress/regress/encrypt-bug2.txt @@ -0,0 +1,75 @@ +From: "Michel Meyers" +To: "bacula-users" +Subject: [Bacula-users] Script for pushing new clients to Windows boxes +Date: Mon, 2 Feb 2004 16:10:48 +0100 + +Hello, + +Some of you may remember my document on how to remotely push a Win32 bacula +client onto a WinNT/2k/XP box. Well, I've written a script to do it for me +and thought I'd share it with you: +- ---------------------------------------------------------------- +#!/bin/bash +# +# Remote Win32 client upgrade script +# written by Michel Meyers (last update 2006-09-25 11:34) +# +# WARNING: Make sure that no bacula-fd.conf exists in the source directory! +# You will destroy/overwrite all your client's configs if you don't +# be careful with this. +# +# The upgrade function does the following: +# - Shutdown Bacula service on remote machine +# - Wait 30 seconds (to allow proper shutdown) +# - Mount C: drive of remote box +# - Copy new client to remote machine +# - Unmount C; +# - Startup the new Bacula service +# +# To upgrade a machine append the following at the bottom of this file: +# +# SERVERNAME= +# USERNAME= +# PASSWORD= +# upgrade + +upgrade() { +net rpc -S $SERVERNAME -U $USERNAME%"$PASSWORD" service stop bacula +sleep 30 +smbmount //$SERVERNAME/c$ /mnt -o username=$USERNAME,password="$PASSWORD" +cp /home/michel/winbacula/bin/* /mnt/bacula/bin +umount /mnt +net rpc -S $SERVERNAME -U $USERNAME%"$PASSWORD" service start bacula +} + +SERVERNAME=xerxes +USERNAME=administrator +PASSWORD=secret +upgrade + +SERVERNAME=shodan +USERNAME=teh_one +PASSWORD="" +upgrade +- ---------------------------------------------------------------- + +It should be pretty self-explanatory. I'm not good at shell programming and +I don't know whether there's any notion of arrays or 'for' loops that could +make it cleaner so I simply wrote a function which references some variables +and then call that repeatedly (once per machine). You can of course change +the values according to your system and liking (if 30 secs seem to much for +you, just reduce the value after sleep, make sure to check on the paths and +mountpoint /mnt may not be usable on your system, ...) + +Note: The requirements are the same as described in my other document +(Samba-TNG clients among others, otherwise you'll be missing rpcclient). + +Update 2006-09-25: Samba-TNG is no longer required, the 'net' command from +Samba 3 works for starting and stopping services. Paths may need to be +updated with quotation marks as the new Bacula Win32 Installer no longer +installs into C:\bacula but into 'C:\Program Files\bacula' (on English +Windows versions). + + +Enjoy! + diff --git a/regress/regress/endtime b/regress/regress/endtime new file mode 100755 index 0000000000..0502fec376 --- /dev/null +++ b/regress/regress/endtime @@ -0,0 +1,12 @@ +#!/usr/bin/env python +from time import time as now + +t = now() +fn = open('time.out', 'r') +s = fn.readline() +fn.close() +diff = t - float(s) +h = int(diff / 3600) +m = int((diff - h * 3600) / 60) +sec = diff - h * 3600 - m * 60 +print 'Total time = %d:%02d:%02d or %d secs' % (h, m, sec, t - float(s)) diff --git a/regress/regress/file b/regress/regress/file new file mode 100755 index 0000000000..8f2089051b --- /dev/null +++ b/regress/regress/file @@ -0,0 +1,2 @@ +#!/bin/sh +./all-non-root-tests diff --git a/regress/regress/freebsd.conf b/regress/regress/freebsd.conf new file mode 100644 index 0000000000..c1bbf96866 --- /dev/null +++ b/regress/regress/freebsd.conf @@ -0,0 +1,38 @@ +# Where to get the source to be tested +# BACULA_SOURCE="${HOME}/bacula/branch-1.36.2" +BACULA_SOURCE="${HOME}/bacula/k" + +# Where to send email !!!!! Change me !!!!!!! +EMAIL=xxxx@domain.com +SMTP_HOST="machine.domain.com" + +# Full "default" path where to find sqlite (no quotes!) +SQLITE3_DIR=${HOME}/bacula/depkgs/sqlite3 +SQLITE_DIR=${HOME}/bacula/depkgs/sqlite + +TAPE_DRIVE="/dev/nsa0" +# if you don't have an autochanger set AUTOCHANGER to /dev/null +AUTOCHANGER="/dev/sg0" +# For two drive tests -- set to /dev/null if you do not have it +TAPE_DRIVE1="/dev/null" + +# This must be the path to the autochanger including its name +AUTOCHANGER_PATH="/usr/local/sbin/mtx" + +# Set your database here +#WHICHDB="--with-sqlite=${SQLITE_DIR}" +#WHICHDB="--with-sqlite3=${SQLITE3_DIR}" +WHICHDB="--with-mysql" +#WHICHDB="--with-postgresql" + +# Set this to "--with-tcp-wrappers" or "--without-tcp-wrappers" +TCPWRAPPERS="--with-tcp-wrappers" + +# Set this to "" to disable OpenSSL support, "--with-openssl=yes" +# to enable it, or provide the path to the OpenSSL installation, +# eg "--with-openssl=/usr/local" +# +# Note, you can also add any other (as many as you want) special +# Bacula configuration options here, such as --disable-batch-insert +# +OPENSSL="" diff --git a/regress/regress/kern.conf b/regress/regress/kern.conf new file mode 100644 index 0000000000..d7c6ef4a4d --- /dev/null +++ b/regress/regress/kern.conf @@ -0,0 +1,51 @@ +# Where to get the source to be tested +#BACULA_SOURCE="${HOME}/bacula/bacula/branch-2.0" +BACULA_SOURCE="${HOME}/bacula/k" + +# Where to send email !!!!! Change me !!!!!!! +EMAIL=xxxx@omally +SMTP_HOST="localhost" + +# Full "default" path where to find sqlite (no quotes!) +SQLITE3_DIR=${HOME}/bacula/depkgs/sqlite3 +SQLITE_DIR=${HOME}/bacula/depkgs/sqlite + +TAPE_DRIVE="/dev/nst0" +# if you don't have an autochanger set AUTOCHANGER to /dev/null +AUTOCHANGER="/dev/sg0" +# For two drive tests -- set to /dev/null if you do not have it +TAPE_DRIVE1="/dev/null" + +# This must be the path to the autochanger including its name +AUTOCHANGER_PATH="/usr/sbin/mtx" + +# Set your database here +#WHICHDB="--with-sqlite=${SQLITE_DIR}" +#WHICHDB="--with-sqlite3=${SQLITE3_DIR}" +WHICHDB="--with-mysql" +#WHICHDB="--with-postgresql" + +# Set this to "--with-tcp-wrappers" or "--without-tcp-wrappers" +TCPWRAPPERS="--with-tcp-wrappers" + +# Set this to "" to disable OpenSSL support, "--with-openssl=yes" +# to enable it, or provide the path to the OpenSSL installation, +# eg "--with-openssl=/usr/local" +# +# Note, you can also add any other (as many as you want) special +# Bacula configuration options here, such as --disable-batch-insert +# +OPENSSL="--with-openssl" + +# You may put your real host name here, but localhost is valid also +# and it has the advantage that it works on a non-newtworked machine +HOST="localhost" + +# see --with-base-port at +# http://www.bacula.org/rel-manual/Installing_Bacula.html +# You only need to change this if you want to run more than one instance +# of regression testing on the same box. You'll need to set BASEPORT +# to values that do not overlap. BASEPORT is the first of three ports +# required by each instance, one for each of Dir, SD, and the FD. +# +BASEPORT=8101 diff --git a/regress/regress/misc-tests b/regress/regress/misc-tests new file mode 100644 index 0000000000..dd2734c56b --- /dev/null +++ b/regress/regress/misc-tests @@ -0,0 +1,2 @@ +tests/btape-fill-full-tape +tests/eot-fail-tape diff --git a/regress/regress/prototype.conf b/regress/regress/prototype.conf new file mode 100644 index 0000000000..6fef8cb904 --- /dev/null +++ b/regress/regress/prototype.conf @@ -0,0 +1,50 @@ +# Where to get the source to be tested +BACULA_SOURCE="${HOME}/bacula/bacula" + +# Where to send email !!!!! Change me !!!!!!! +EMAIL=my-name@domain.com +SMTP_HOST="localhost" + +# Full "default" path where to find sqlite (no quotes!) +SQLITE3_DIR=${HOME}/bacula/depkgs/sqlite3 +SQLITE_DIR=${HOME}/bacula/depkgs/sqlite + +TAPE_DRIVE="/dev/nst0" +# if you don't have an autochanger set AUTOCHANGER to /dev/null +AUTOCHANGER="/dev/sg0" +# For two drive tests -- set to /dev/null if you do not have it +TAPE_DRIVE1="/dev/null" + +# This must be the path to the autochanger including its name +AUTOCHANGER_PATH="/usr/sbin/mtx" + +# Set your database here +#WHICHDB="--with-sqlite=${SQLITE_DIR}" +#WHICHDB="--with-sqlite3=${SQLITE3_DIR}" +#WHICHDB="--with-postgresql" +WHICHDB="--with-mysql" + +# Set this to "--with-tcp-wrappers" or "--without-tcp-wrappers" +TCPWRAPPERS="--with-tcp-wrappers" + +# Set this to "" to disable OpenSSL support, "--with-openssl=yes" +# to enable it, or provide the path to the OpenSSL installation, +# eg "--with-openssl=/usr/local" +# +# Note, you can also add any other (as many as you want) special +# Bacula configuration options here, such as --disable-batch-insert +# +OPENSSL="--with-openssl" + +# You may put your real host name here, but localhost is valid also +# and it has the advantage that it works on a non-newtworked machine +HOST="localhost" + +# see --with-base-port at +# http://www.bacula.org/rel-manual/Installing_Bacula.html +# You only need to change this if you want to run more than one instance +# of regression testing on the same box. You'll need to set BASEPORT +# to values that do not overlap. BASEPORT is the first of three ports +# required by each instance, one for each of Dir, SD, and the FD. +# +BASEPORT=8101 diff --git a/regress/regress/run b/regress/regress/run new file mode 100755 index 0000000000..d48e2623c6 --- /dev/null +++ b/regress/regress/run @@ -0,0 +1,3 @@ +#!/bin/sh +bin/bacula start +bin/bconsole -c bin/bconsole.conf diff --git a/regress/regress/scripts/ansi-sd-tape.conf.in b/regress/regress/scripts/ansi-sd-tape.conf.in new file mode 100644 index 0000000000..5993e12456 --- /dev/null +++ b/regress/regress/scripts/ansi-sd-tape.conf.in @@ -0,0 +1,55 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 2.2 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# + +Device { + Name = DDS-4 # + Media Type = DDS-4 + Archive Device = @tape_drive@ + AutomaticMount = yes; # when device opened, read it + AlwaysOpen = yes; + RemovableMedia = yes; + @@sbindir@/tape_options +# Maximum File Size = 1000000 +# MaximumVolumeSize = 400M + Label Type = ansi +} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-dir-2d.conf.in b/regress/regress/scripts/bacula-dir-2d.conf.in new file mode 100644 index 0000000000..41f3b61443 --- /dev/null +++ b/regress/regress/scripts/bacula-dir-2d.conf.in @@ -0,0 +1,179 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 2.1.x +# +# Special conf for testing two tape drives with two different +# Media. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + Maximum Concurrent Jobs = 4 + Password = "dir-pw" + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = <@tmpdir@/file-list + } +} + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Full 1st sun at 1:05 + Run = Differential 2nd-5th sun at 1:05 + Run = Incremental mon-sat at 1:05 +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "client-pw" + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definition of DDS tape storage device +Storage { + Name = DDS-4 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "storage-pw" + Device = DDS-4 # must be same as Device in Storage daemon + Media Type = DDS-4 # must be same as MediaType in Storage daemon + Maximum Concurrent Jobs = 4 + Autochanger = yes +} + + +# Definition of DLT tape storage device +Storage { + Name = DLT80 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "storage-pw" + Device = DLT80 # must be same as Device in Storage daemon + Media Type = DLT8000 # must be same as MediaType in Storage daemon + Maximum Concurrent Jobs = 4 +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Full + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Inc + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Scratch + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year + Recycle Pool = Scratch # recycle back here +} diff --git a/regress/regress/scripts/bacula-dir-fifo.conf.in b/regress/regress/scripts/bacula-dir-fifo.conf.in new file mode 100644 index 0000000000..fdfd628a27 --- /dev/null +++ b/regress/regress/scripts/bacula-dir-fifo.conf.in @@ -0,0 +1,226 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.33 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = Dummy + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + +Job { + Name = "NightlySave1" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = Dummy + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no + Client Run Before Job = "/bin/sleep 120" +} + +Job { + Name = "NightlySave2" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = Dummy + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + +Job { + Name = "VerifyTape" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Verify Set" + Storage = Dummy + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + + + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = Dummy + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "Verify Set" + Include { + Options { + signature=MD5 + verify=pins1 + } + File = "<@tmpdir@/file-list" + } +} + + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Full 1st sun at 1:05 + Run = Differential 2nd-5th sun at 1:05 + Run = Incremental mon-sat at 1:05 +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definition of DDS tape storage device +Storage { + Name = Dummy + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon + Device = Dummy # must be same as Device in Storage daemon + Media Type = Dummy # must be same as MediaType in Storage daemon + Maximum Concurrent Jobs = 4 +# Autochanger = yes +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula Regression Job %j\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula Regression Job %j\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Full + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Inc + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Scratch + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/bacula-dir-migration.conf.in b/regress/regress/scripts/bacula-dir-migration.conf.in new file mode 100644 index 0000000000..36fcfbff33 --- /dev/null +++ b/regress/regress/scripts/bacula-dir-migration.conf.in @@ -0,0 +1,229 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + +Job { + Name = "migrate-job" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratejob.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = Job + Selection Pattern = ".*Save" +} + +Job { + Name = "migrate-volume" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratevol.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = Volume + Selection Pattern = "File*" +} + +Job { + Name = "migrate-occupancy" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratejob.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = PoolOccupancy +} + +Job { + Name = "migrate-time" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratejob.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = PoolTime +} + + + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = <@tmpdir@/file-list + } +} + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Full 1st sun at 1:05 + Run = Differential 2nd-5th sun at 1:05 + Run = Incremental mon-sat at 1:05 +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definition of DDS Virtual tape disk storage device +Storage { + Name = DiskChanger + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon + Device = DiskChanger # must be same as Device in Storage daemon + Media Type = DiskChangerMedia # must be same as MediaType in Storage daemon + Maximum Concurrent Jobs = 4 + Autochanger = yes +} + +# Definition of file storage device +Storage { + Name = File + Address = @hostname@ + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 5 +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year + NextPool = Full + Storage = File + Migration High Bytes = 40M + Migration Low Bytes = 20M + Migration Time = 60 +} + +Pool { + Name = Full + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year + Storage = DiskChanger +} diff --git a/regress/regress/scripts/bacula-dir-tape.conf.in b/regress/regress/scripts/bacula-dir-tape.conf.in new file mode 100644 index 0000000000..de1c3f2c1f --- /dev/null +++ b/regress/regress/scripts/bacula-dir-tape.conf.in @@ -0,0 +1,240 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.33 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + +Job { + Name = "NightlySave1" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no + Client Run Before Job = "/bin/sleep 120" +} + +Job { + Name = "NightlySave2" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + +Job { + Name = "VerifyTape" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Verify Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + + + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "Verify Set" + Include { + Options { + signature=MD5 + verify=pins1 + } + File = <@tmpdir@/file-list + } +} + + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Full 1st sun at 1:05 + Run = Differential 2nd-5th sun at 1:05 + Run = Incremental mon-sat at 1:05 +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definition of DDS tape storage device +Storage { + Name = DDS-4 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon + Device = DDS-4 # must be same as Device in Storage daemon + Media Type = DDS-4 # must be same as MediaType in Storage daemon + Maximum Concurrent Jobs = 4 +# Autochanger = yes +} + + +# Definition of File storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon + Device = FileStorage # must be same as Device in Storage daemon + Media Type = FileMedia # must be same as MediaType in Storage daemon + Maximum Concurrent Jobs = 4 +} + + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Full + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Inc + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = Scratch + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year + Recycle Pool = Scratch # recycle back here +} diff --git a/regress/regress/scripts/bacula-dir-win32-tape.conf.in b/regress/regress/scripts/bacula-dir-win32-tape.conf.in new file mode 100644 index 0000000000..c91eff7f69 --- /dev/null +++ b/regress/regress/scripts/bacula-dir-win32-tape.conf.in @@ -0,0 +1,144 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.33 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=Tibs + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +} + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=Tibs + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Enable VSS = yes + Include { Options { signature=MD5 } + File = "c:" + } +} + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Full 1st sun at 1:05 + Run = Differential 2nd-5th sun at 1:05 + Run = Incremental mon-sat at 1:05 +} + +# Client (File Services) to backup +Client { + Name = Tibs + Address = tibs + FDPort = 9102 + Catalog = MyCatalog + Password = "xBzFq+a9llZyGyfMaNO9e3outP86/1AUAT8P34RoT62G" + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definition of DDS tape storage device +Storage { + Name = DDS-4 + Address = 192.168.68.112 # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon + Device = DDS-4 # must be same as Device in Storage daemon + Media Type = DDS-4 # must be same as MediaType in Storage daemon + AutoChanger = yes + Maximum Concurrent Jobs = 4 +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression Job %j\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/bacula-dir.conf.errors.in b/regress/regress/scripts/bacula-dir.conf.errors.in new file mode 100644 index 0000000000..23d080a1ff --- /dev/null +++ b/regress/regress/scripts/bacula-dir.conf.errors.in @@ -0,0 +1,223 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39.27 (24 October 2006) -- debian testing/unstable +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard + fdconnecttimeout = 20 + sdconnecttimeout = 20 +} + +JobDefs { + Name = "DefaultJob" + Type = Backup + Level = Incremental + client=@hostname@-fd + Storage = File + Messages = Standard + Pool = Default + Priority = 10 + Maximum Concurrent Jobs = 16 +} + +Job { + Name = "LOCAL_INC_ERR" + JobDefs = DefaultJob + FileSet = FS_LOCAL_INC_ERR + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} + +FileSet { + Name = FS_TEST + Include { + File=<@tmpdir@/file-list + } +} + +FileSet { + Name = FS_REMOTE_INC_ERR + Include { + File="\<@tmpdir@/path/to/nowhere" + } +} + +Job { + Name = "REMOTE_INC_ERR" + JobDefs = DefaultJob + FileSet = FS_REMOTE_INC_ERR + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} + +FileSet { + Name = FS_LOCAL_INC_ERR + Include { File=<@tmpdir@/path/to/nowhere } +} + +FileSet { + Name = FS_LOCAL_EXCL_ERR + Include { File=<@tmpdir@/file-list } + Exclude { + File=<@tmpdir@/path/to/nowhere + } +} + +Job { + Name = "LOCAL_EXCL_ERR" + JobDefs = DefaultJob + FileSet = FS_LOCAL_EXCL_ERR + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} + + +FileSet { + Name = FS_REMOTE_EXCL_ERR + Include { File=<@tmpdir@/file-list } + Exclude { + File="\<@tmpdir@/path/to/nowhere" + } +} + +Job { + Name = "REMOTE_EXCL_ERR" + JobDefs = DefaultJob + FileSet = FS_REMOTE_EXCL_ERR + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} +Job { + Name = "REMOTE_RUNSCRIPT_ERR" + JobDefs = DefaultJob + FileSet = FS_TEST + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/false" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} +Job { + Name = "LOCAL_RUNSCRIPT_ERR" + JobDefs = DefaultJob + FileSet = FS_TEST + RunBeforeJob = "/bin/false" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} +Job { + Name = "CLIENT_CONNECT_TIMEOUT" + JobDefs = DefaultJob + Client = @hostname@2-fd + FileSet = FS_TEST + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} +Job { + Name = "SD_CONNECT_TIMEOUT" + JobDefs = DefaultJob + Client = @hostname@-fd + FileSet = FS_TEST + Storage = File2 + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Client (File Services) to backup +Client { + Name = @hostname@2-fd + Address = @hostname@ + FDPort = 7102 + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 4 +} + +# Definiton of file storage device not responding +Storage { + Name = File2 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = 7103 + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File2 + Maximum Concurrent Jobs = 4 +} + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + + +Messages { + Name = Standard + console = all, !skipped, !saved +} + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/bacula-dir.conf.maxtime.in b/regress/regress/scripts/bacula-dir.conf.maxtime.in new file mode 100644 index 0000000000..9b3fc2a9fb --- /dev/null +++ b/regress/regress/scripts/bacula-dir.conf.maxtime.in @@ -0,0 +1,136 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39.27 (24 October 2006) -- debian testing/unstable +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 1 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + +JobDefs { + Name = "DefaultJob" + Type = Backup + Level = Incremental + Client = @hostname@-fd + FileSet = FS_TESTJOB + Storage = File + Messages = Standard + Pool = Default + Priority = 10 + Maximum Concurrent Jobs = 16 +} + +FileSet { + Name = FS_TESTJOB + Include { + File=<@tmpdir@/file-list + } +} + +FileSet { + Name = FS_FIFO + Include { + Options { + read fifo = yes + } + # wait 60s per fifo + File=@tmpdir@/fifo + File=@tmpdir@/fifo2 + File=@tmpdir@/fifo3 + } +} + +Job { + Name = "RUN_MAXWAITTIME" + JobDefs = DefaultJob + FileSet = FS_TESTJOB + MaxWaitTime = 2min +} + +Job { + Name = "RUN_MAXSTARTDELAY" + JobDefs = DefaultJob + FileSet = FS_TESTJOB + MaxStartDelay = 30sec + Pool = PoolA + Runbeforejob = "/bin/echo NEVER start this" +} + +Job { + Name = "RUN_MAXRUNTIME" + JobDefs = DefaultJob + FileSet = FS_FIFO + MaxRunTime = 1min +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 4 +} + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + + +Messages { + Name = Standard + console = all, !skipped, !saved +} + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + + +# Default pool definition +Pool { + Name = PoolA + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/bacula-dir.conf.regexwhere.in b/regress/regress/scripts/bacula-dir.conf.regexwhere.in new file mode 100644 index 0000000000..d2e79e634d --- /dev/null +++ b/regress/regress/scripts/bacula-dir.conf.regexwhere.in @@ -0,0 +1,136 @@ +# TODO +# Orphaned buffer: localhost-dir 40 bytes buf=80e9a70 allocated at dird_conf.c:1338 +# bacula-dir: dird.c:656 Hey something is wrong. p=0x135174768 + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + +Job { + Name = "backup" + Type = Backup + Level = Full + Client = @hostname@-fd + FileSet = FS_TESTJOB + Storage = File + Messages = Standard + Pool = Default + Priority = 10 + Maximum Concurrent Jobs = 16 +} + +FileSet { + Name = FS_TESTJOB + Include { + File=<@tmpdir@/file-list + } +} + +JobDefs { + Name = "DefaultRestore" + Type = Restore + Storage = File + Client=@hostname@-fd + FileSet="FS_TESTJOB" + Messages = Standard + Pool = Default + Replace = Always +} + +Job { + Name = JobA + JobDefs = DefaultRestore + RegexWhere = !po$!old.po! +} + +Job { + Name = JobB + JobDefs = DefaultRestore + add prefix = @tmpdir@/bacula-restore + add suffix = .old + strip prefix = /build +} + +Job { + Name = JobC + JobDefs = DefaultRestore + Where = @tmpdir@/bacula-restore +} + +Job { + Name = JobD + JobDefs = DefaultRestore + RegexWhere = "doesnt work" +} + +Job { + Name = JobE + JobDefs = DefaultRestore + RegexWhere = "/BUILD/tmp/i,!po/!!" +} + +Job { + Name = JobF + JobDefs = DefaultRestore + RegexWhere = "/something witch doesn't match/tmp/i" +} + +Job { + Name = JobG + JobDefs = DefaultRestore + Where = @tmpdir@/bacula-restore +} + + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 4 +} + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + + +Messages { + Name = Standard + console = all, !skipped, !saved +} + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/bacula-dir.conf.testrunscript.in b/regress/regress/scripts/bacula-dir.conf.testrunscript.in new file mode 100644 index 0000000000..abd107053c --- /dev/null +++ b/regress/regress/scripts/bacula-dir.conf.testrunscript.in @@ -0,0 +1,221 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39.27 (24 October 2006) -- debian testing/unstable +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + +JobDefs { + Name = "DefaultJob" + Type = Backup + Level = Incremental + Client = @hostname@-fd + FileSet = FS_TESTJOB + Storage = File + Messages = Standard + Pool = Default + Priority = 10 + Maximum Concurrent Jobs = 16 +} + +FileSet { + Name = FS_TESTJOB + Include { + File=<@tmpdir@/file-list + } +} + +#dir: BeforeJob: run command "/bin/echo RunBeforeJob" +#fd: ClientRunBeforeJob: ClientRunBeforeJob +#fd: ClientAfterJob: run command "/bin/echo ClientRunAfterJob" +#dir: AfterJob: run command "/bin/echo RunAfterJob" + +Job { + Name = "RUN_ALL_OK" + JobDefs = DefaultJob + FileSet = FS_TESTJOB + RunBeforeJob = "/bin/echo RunBeforeJob" + ClientRunBeforeJob = "/bin/echo ClientRunBeforeJob" + Run After Job = "/bin/echo RunAfterJob" + ClientRunAfterJob = "/bin/echo ClientRunAfterJob" +} + +#After job are after before job +Job { + Name = "RUN_DIR_FAILED_BUG" + FileSet = FS_TESTJOB + JobDefs = DefaultJob + Run After Failed Job = "/bin/echo RunAfterFailedJob" + RunBeforeJob = "/bin/false" +} + +#@hostname@-dir: BeforeJob: run command "/bin/false" +#@hostname@-dir: BeforeJob: RunAfterFailedJob +Job { + Name = "RUN_DIR_FAILED" + FileSet = FS_TESTJOB + JobDefs = DefaultJob + RunBeforeJob = "/bin/false RUN_DIR_FAILED" + Run After Failed Job = "/bin/echo RunAfterFailedJob" +} + +#@hostname@-fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED1" +#@hostname@-fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED2" +#@hostname@-dir: AfterJob: run command "/bin/echo RunAfterFailedJob" +Job { + Name = "RUN_FD_FAILED" + FileSet = FS_TESTJOB + JobDefs = DefaultJob + RunScript { + Command = "/bin/false RUN_FD_FAILED1" + failjobonerror = no + RunsWhen = Before + } + RunScript { + Command = "/bin/false RUN_FD_FAILED2" + failjobonerror = yes + RunsWhen = Before + } + + Run After Failed Job = "/bin/echo RunAfterFailedJob" + RunScript { + Command = "/bin/echo touching @tmpdir@/RUN_FD_FAILED" + RunsWhen = after + RunsOnFailure = yes + } + RunScript { + Command = "/bin/touch @tmpdir@/RUN_FD_FAILED" + RunsWhen = after + RunsOnFailure = yes + } +} + +#@hostname@-fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED1" +#we dont execute FAILED2 +#@hostname@-dir: AfterJob: run command "/bin/echo RunAfterFailedJob" +Job { + Name = "RUN_FD_FAILED2" + FileSet = FS_TESTJOB + JobDefs = DefaultJob + RunScript { + Command = "/bin/false RUN_FD_FAILED1" + failjobonerror = yes + RunsWhen = Before + } + RunScript { + Command = "/bin/false RUN_FD_FAILED2" + failjobonerror = yes + RunsWhen = Before + } + RunScript { + Command = "/bin/false RUN_FD_FAILED3" + failjobonerror = yes + RunsOnFailure = yes + RunsWhen = Before + } + + Run After Failed Job = "/bin/echo RunAfterFailedJob" +} + +#@hostname@-fd: ClientBeforeJob: run command "/bin/false RUN_FD_WARNING" +#Backup OK -- with warnings +Job { + Name = "RUN_FD_WARNING" + FileSet = FS_TESTJOB + JobDefs = DefaultJob + RunScript { + Command = "/bin/false RUN_FD_WARNING" + failjobonerror = no + RunsWhen = Before + } + Run After Failed Job = "/bin/echo RunAfterFailedJob" +} + +FileSet { + Name = FS_FIFO + Include { + Options { readfifo = yes } + File=<@tmpdir@/file-list + } +} + +Job { + Name = BUG_897 + JobDefs = DefaultJob + FileSet = FS_FIFO + + RunScript { + Command = "/bin/echo touching @tmpdir@/RUN_BUG_897" + RunsWhen = after + RunsOnFailure = yes + } + RunScript { + Command = "/bin/touch @tmpdir@/RUN_BUG_897" + RunsWhen = after + RunsOnFailure = yes + } +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 4 +} + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + + +Messages { + Name = Standard + console = all, !skipped, !saved +} + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/bacula-fd-2d.conf.in b/regress/regress/scripts/bacula-fd-2d.conf.in new file mode 100644 index 0000000000..c98affced2 --- /dev/null +++ b/regress/regress/scripts/bacula-fd-2d.conf.in @@ -0,0 +1,33 @@ +# +# Default Bacula File Daemon Configuration file +# +# For Bacula release 2.1.29 (31 July 2007) -- suse 10.2 +# +# There is not much to change here except perhaps the +# File daemon Name to +# + +# +# List Directors who are permitted to contact this File daemon +# +Director { + Name = @hostname@-dir + Password = "client-pw" +} + +# +# "Global" File daemon configuration specifications +# +FileDaemon { # this is me + Name = @hostname@-fd + FDPort = @fdport@ # where we listen for the director + WorkingDirectory = @working_dir@ + Pid Directory = @piddir@ + Maximum Concurrent Jobs = 20 +} + +# Send all messages except skipped files back to Director +Messages { + Name = Standard + director = @hostname@-dir = all, !skipped, !restored +} diff --git a/regress/regress/scripts/bacula-sd-2d.conf.in b/regress/regress/scripts/bacula-sd-2d.conf.in new file mode 100644 index 0000000000..466b68fcc6 --- /dev/null +++ b/regress/regress/scripts/bacula-sd-2d.conf.in @@ -0,0 +1,70 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 2.1.x +# +# Special configuration for testing two different tape drives +# with different Media +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "storage-pw" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# +Autochanger { + Name = DDS-4 + Changer Device = @autochanger@ + Changer Command ="@scriptdir@/mtx-changer %c %o %S %a %d" + Device = Drive-0 +} + +Device { + Name = Drive-0 + Media Type = DDS-4 + Archive Device = @tape_drive@ + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 0 + AlwaysOpen = yes; + RemovableMedia = yes; + @@sbindir@/tape_options +# Maximum File Size = 1000000 +} + +Device { + Name = DLT80 + Media Type = DLT8000 + Archive Device = @tape_drive1@ + AutomaticMount = yes; # when device opened, read it + AlwaysOpen = yes; + RemovableMedia = yes; + @@sbindir@/tape_options +# Maximum File Size = 1000000 +} + + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd-2disk-drive.conf.in b/regress/regress/scripts/bacula-sd-2disk-drive.conf.in new file mode 100644 index 0000000000..10754d9e94 --- /dev/null +++ b/regress/regress/scripts/bacula-sd-2disk-drive.conf.in @@ -0,0 +1,75 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.39 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# +Autochanger { + Name = DDS-4 + Changer Device = @disk_drive@/conf + Changer Command ="@scriptdir@/disk-changer %c %o %S %a %d" + Device = Drive-0, Drive-1 +} + +Device { + Name = Drive-0 + Device Type = File + Media Type = DDS-4 + Archive Device = @disk_drive@/drive0 + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 0 + AlwaysOpen = yes; + RemovableMedia = yes; +# Maximum File Size = 1000000 +} + +Device { + Name = Drive-1 + Device Type = File + Media Type = DDS-4 + Archive Device = @disk_drive@/drive1 + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 1 + AlwaysOpen = yes; + RemovableMedia = yes; +# Maximum File Size = 1000000 +} + + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd-2disk.conf.in b/regress/regress/scripts/bacula-sd-2disk.conf.in new file mode 100644 index 0000000000..fd5f973f1a --- /dev/null +++ b/regress/regress/scripts/bacula-sd-2disk.conf.in @@ -0,0 +1,73 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.39 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# +Autochanger { + Name = DDS-4 + Changer Device = @disk_drive@/conf + Changer Command ="@scriptdir@/disk-changer %c %o %S %a %d" + Device = Drive-0 +} + +Device { + Name = Drive-0 # + Device Type = File + Media Type = DDS-4 + Archive Device = @disk_drive@/drive0 + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 0 + AlwaysOpen = yes; + RemovableMedia = yes; +# Maximum File Size = 1000000 +} + +Device { + Name = FileStorage + Media Type = FileMedia + Archive Device = @tmpdir@ + LabelMedia = yes; # lets Bacula label unlabeled media + Random Access = Yes; + AutomaticMount = yes; # when device opened, read it + RemovableMedia = no; + AlwaysOpen = no; +} + + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd-2drive.conf.in b/regress/regress/scripts/bacula-sd-2drive.conf.in new file mode 100644 index 0000000000..8ee4dbd629 --- /dev/null +++ b/regress/regress/scripts/bacula-sd-2drive.conf.in @@ -0,0 +1,75 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.33 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# +Autochanger { + Name = DDS-4 + Changer Device = @autochanger@ + Changer Command ="@scriptdir@/mtx-changer %c %o %S %a %d" + Device = Drive-0, Drive-1 +} + +Device { + Name = Drive-0 + Media Type = DDS-4 + Archive Device = @tape_drive@ + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 0 + AlwaysOpen = yes; + RemovableMedia = yes; + @@sbindir@/tape_options +# Maximum File Size = 1000000 +} + +Device { + Name = Drive-1 + Media Type = DDS-4 + Archive Device = @tape_drive1@ + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 1 + AlwaysOpen = yes; + RemovableMedia = yes; + @@sbindir@/tape_options +# Maximum File Size = 1000000 +} + + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd-2tape.conf.in b/regress/regress/scripts/bacula-sd-2tape.conf.in new file mode 100644 index 0000000000..4abd813945 --- /dev/null +++ b/regress/regress/scripts/bacula-sd-2tape.conf.in @@ -0,0 +1,61 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.33 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# +Autochanger { + Name = DDS-4 + Changer Device = @autochanger@ + Changer Command ="@scriptdir@/mtx-changer %c %o %S %a %d" + Device = Drive-0 +} + +Device { + Name = Drive-0 # + Media Type = DDS-4 + Archive Device = @tape_drive@ + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 0 + AlwaysOpen = yes; + RemovableMedia = yes; + @@sbindir@/tape_options +# Maximum File Size = 1000000 +} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd-fifo.conf.in b/regress/regress/scripts/bacula-sd-fifo.conf.in new file mode 100644 index 0000000000..b2a521ec96 --- /dev/null +++ b/regress/regress/scripts/bacula-sd-fifo.conf.in @@ -0,0 +1,49 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.33 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +Device { + Name = Dummy + Media Type = Dummy + Device Type = Fifo + Archive Device = /dev/null + LabelMedia = yes + Random Access = no + AutomaticMount = no + RemovableMedia = no + MaximumOpenWait = 60 + AlwaysOpen = no +} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd-migration.conf.in b/regress/regress/scripts/bacula-sd-migration.conf.in new file mode 100644 index 0000000000..d4b691ee7c --- /dev/null +++ b/regress/regress/scripts/bacula-sd-migration.conf.in @@ -0,0 +1,72 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.39 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# +Autochanger { + Name = DiskChanger + Changer Device = @disk_drive@/conf + Changer Command ="@scriptdir@/disk-changer %c %o %S %a %d" + Device = Drive-0 +} + +Device { + Name = Drive-0 # + Device Type = File + Media Type = DiskChangerMedia + Archive Device = @disk_drive@/drive0 + AutomaticMount = yes; # when device opened, read it + Autochanger = yes + Drive Index = 0 + AlwaysOpen = yes; + RemovableMedia = yes; +# Maximum File Size = 1000000 +} + +Device { + Name = FileStorage + Media Type = File + Archive Device = @tmpdir@ + LabelMedia = yes; # lets Bacula label unlabeled media + Random Access = Yes; + AutomaticMount = yes; # when device opened, read it + RemovableMedia = no; + AlwaysOpen = no; +} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd-tape.conf.in b/regress/regress/scripts/bacula-sd-tape.conf.in new file mode 100644 index 0000000000..4d710efd35 --- /dev/null +++ b/regress/regress/scripts/bacula-sd-tape.conf.in @@ -0,0 +1,54 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.33 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# + +Device { + Name = DDS-4 # + Media Type = DDS-4 + Archive Device = @tape_drive@ + AutomaticMount = yes; # when device opened, read it + AlwaysOpen = yes; + RemovableMedia = yes; + @@sbindir@/tape_options +# Maximum File Size = 1000000 +# MaximumVolumeSize = 400M +} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/bacula-sd.conf.in b/regress/regress/scripts/bacula-sd.conf.in new file mode 100644 index 0000000000..025400c2b1 --- /dev/null +++ b/regress/regress/scripts/bacula-sd.conf.in @@ -0,0 +1,74 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.33 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = rufus-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "/home/kern/bacula/regress/working" + Pid Directory = "/home/kern/bacula/regress/working" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = rufus-dir + Password = "BzlEl8haeFmnv/Lv8V6zDzUBgFFQNsUtny6VkmccQpOy" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# + +Device { + Name = FileStorage + Media Type = File + Archive Device = @tmpdir@ + LabelMedia = yes; # lets Bacula label unlabeled media + Random Access = Yes; + AutomaticMount = yes; # when device opened, read it + RemovableMedia = no; + AlwaysOpen = no; +} + +#Device { +# Name = DDS-4 # +# Media Type = DDS-4 +# Archive Device = /dev/nst0 +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = yes; +# RemovableMedia = yes; +#} + +# +# A very old Exabyte with no end of media detection +# +#Device { +# Name = "Exabyte 8mm" +# Media Type = "8mm" +# Archive Device = /dev/nst0 +# Hardware end of medium = No; +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = Yes; +# RemovableMedia = yes; +#} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = rufus-dir = all, !terminate +} diff --git a/regress/regress/scripts/bconsole-2d.conf.in b/regress/regress/scripts/bconsole-2d.conf.in new file mode 100644 index 0000000000..00bcfb6f7b --- /dev/null +++ b/regress/regress/scripts/bconsole-2d.conf.in @@ -0,0 +1,10 @@ +# +# Bacula User Agent (or Console) Configuration File +# + +Director { + Name = @hostname@-dir + DIRPort = @dirport@ + address = @hostname@ + Password = "dir-pw" +} diff --git a/regress/regress/scripts/check_for_zombie_jobs b/regress/regress/scripts/check_for_zombie_jobs new file mode 100755 index 0000000000..d35a5ffc37 --- /dev/null +++ b/regress/regress/scripts/check_for_zombie_jobs @@ -0,0 +1,84 @@ +#!/bin/sh +# +# Check for zombie jobs (not terminated). +# Also scan logs for ERROR messages +# + +# check_for_zombie_jobs storage=STORAGE [client=localhost-fd] + +if [ $# = 2 ] ; then + client="$2" +else + client="client" +fi + +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +@output tmp/dir.out +status dir +@output tmp/fd.out +status $client +@output tmp/sd.out +status $1 +@output +quit +END_OF_DATA + +export zstat +grep "No Jobs running." tmp/dir.out 2>&1 >/dev/null +if [ $? != 0 ] ; then + echo " " + echo " !!!! Zombie Jobs in Director !!!!" + echo " !!!! Zombie Jobs in Director !!!!" >>test.out + echo " " + zstat=1 + exit 1 +fi +grep "No Jobs running." tmp/fd.out 2>&1 >/dev/null +if [ $? != 0 ] ; then + echo " " + echo " !!!! Zombie Jobs in File daemon !!!!" + echo " !!!! Zombie Jobs in File daemon !!!!" >>test.out + echo " " + zstat=1 + exit 1 +fi +grep "No Jobs running." tmp/sd.out 2>&1 >/dev/null +if [ $? != 0 ] ; then + echo " " + echo " !!!! Zombie Jobs in Storage daemon !!!!" + echo " !!!! Zombie Jobs in Storage daemon !!!!" >>test.out + echo " " + zstat=1 + exit 1 +fi +grep "ERROR" tmp/log*.out 2>&1 >/dev/null +if [ $? = 0 ] ; then + echo " " + echo " !!!! ERROR in log output !!!!" + echo " !!!! ERROR in log output !!!!" >>test.out + grep "ERROR" tmp/log*.out + echo " " + zstat=1 + exit 1 +fi +grep "Fatal Error" tmp/log*.out 2>&1 >/dev/null +if [ $? = 0 ] ; then + echo " " + echo " !!!! Fatal Error in log output !!!!" + echo " !!!! Fatal Error in log output !!!!" >>test.out + grep "Fatal Error" tmp/log*.out + echo " " + zstat=1 + exit 1 +fi + +grep "glibc detected" tmp/log*.out 2>&1 >/dev/null +if [ $? = 0 ] ; then + echo " " + echo " !!!! glibc detected Error in log output !!!!" + echo " !!!! glibc detected Error in log output !!!!" >>test.out + grep "glibc detected" tmp/log*.out + echo " " + zstat=1 + exit 1 +fi diff --git a/regress/regress/scripts/cleanup b/regress/regress/scripts/cleanup new file mode 100755 index 0000000000..e301244bb1 --- /dev/null +++ b/regress/regress/scripts/cleanup @@ -0,0 +1,25 @@ +#!/bin/sh +# +# Cleanup left over files -- both before and after test run +# +cwd=`pwd` +rm -rf ${cwd}/tmp/FileVolume* +rm -rf ${cwd}/tmp/TestVolume001 ${cwd}/tmp/bacula-restores ${cwd}/tmp/Small* +rm -rf ${cwd}/tmp/sed_tmp ${cwd}/tmp/file-list +rm -rf tmp/* +rm -rf working/log tmp/TEST-* +rm -rf working/*.bsr +rm -rf ${cwd}/tmp/disk-changer +find . -name "gigaslam.gif" -exec rm -f {} \; + + +# bin directory does not always exist +if [ -d bin ] +then + bin/bacula stop 2>&1 >/dev/null + cd bin + ./drop_bacula_tables >/dev/null 2>&1 + ./make_bacula_tables >/dev/null 2>&1 + ./grant_bacula_privileges >/dev/null 2>&1 + cd .. +fi diff --git a/regress/regress/scripts/cleanup-2drive.in b/regress/regress/scripts/cleanup-2drive.in new file mode 100755 index 0000000000..32b27c019e --- /dev/null +++ b/regress/regress/scripts/cleanup-2drive.in @@ -0,0 +1,44 @@ +#!/bin/sh +# +# Cleanup left over files -- both before and after test run +# +scripts/cleanup + +if test x@autochanger@ != x/dev/null; then + slot=`bin/mtx-changer @autochanger@ loaded 0 @tape_drive1@ 1` + echo "Slot $slot in drive 1" + if test x$slot != x0 ; then + echo "unload slot $slot in drive 1" + bin/mtx-changer @autochanger@ unload $slot @tape_drive1@ 1 + fi + slot=`bin/mtx-changer @autochanger@ loaded 0 @tape_drive@ 0` + echo "Slot $slot in drive 0" + if test x$slot != x0 ; then + echo "unload slot $slot in drive 0" + bin/mtx-changer @autochanger@ unload $slot @tape_drive@ 0 + fi + + + slot=`bin/mtx-changer @autochanger@ loaded 0 @tape_drive1@ 1` + if test x$slot != x2; then + echo "load slot 2 in drive 1" + bin/mtx-changer @autochanger@ load 2 @tape_drive1@ 1 + fi + echo "WEOF drive 1" + mt -f @tape_drive1@ rewind + mt -f @tape_drive1@ weof + echo "unload slot 2 in drive 1" + bin/mtx-changer @autochanger@ unload 2 @tape_drive1@ 1 + + slot=`bin/mtx-changer @autochanger@ loaded 0 @tape_drive@ 0` + echo "Slot $slot in drive 0" + if test x$slot != x1; then + echo "load slot 1 in drive 0" + bin/mtx-changer @autochanger@ load 1 @tape_drive@ 0 + fi + echo "WEOF drive 0" + mt -f @tape_drive@ rewind + mt -f @tape_drive@ weof + echo "unload slot 1 from drive 0" + bin/mtx-changer @autochanger@ unload 1 @tape_drive@ 0 +fi diff --git a/regress/regress/scripts/cleanup-2tape.in b/regress/regress/scripts/cleanup-2tape.in new file mode 100755 index 0000000000..0f33ec95c7 --- /dev/null +++ b/regress/regress/scripts/cleanup-2tape.in @@ -0,0 +1,30 @@ +#!/bin/sh +# +# Cleanup left over files -- both before and after test run +# +scripts/cleanup + +if test x@autochanger@ != x/dev/null; then + drive=`bin/mtx-changer @autochanger@ loaded 0 dummy 0` + if test x${drive} != x2; then + bin/mtx-changer @autochanger@ unload 0 @tape_drive@ 0 + bin/mtx-changer @autochanger@ load 2 @tape_drive@ 0 + fi + mt -f @tape_drive@ rewind + mt -f @tape_drive@ weof +fi + + +# +# If we have an autochanger always load tape in slot 1 +# +if test x@autochanger@ != x/dev/null; then + drive=`bin/mtx-changer @autochanger@ loaded 0 dummy 0` + if test x${drive} != x1; then + bin/mtx-changer @autochanger@ unload 0 @tape_drive@ 0 + bin/mtx-changer @autochanger@ load 1 @tape_drive@ 0 + fi +fi + +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof diff --git a/regress/regress/scripts/cleanup-tape.in b/regress/regress/scripts/cleanup-tape.in new file mode 100755 index 0000000000..98ed537766 --- /dev/null +++ b/regress/regress/scripts/cleanup-tape.in @@ -0,0 +1,8 @@ +#!/bin/sh +# +# Cleanup left over files -- both before and after test run +# +scripts/cleanup + +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof diff --git a/regress/regress/scripts/copy-2disk-confs b/regress/regress/scripts/copy-2disk-confs new file mode 100755 index 0000000000..87790955f0 --- /dev/null +++ b/regress/regress/scripts/copy-2disk-confs @@ -0,0 +1,12 @@ +#!/bin/sh +# +# Setup for using the Virtual Disk Changer (simulates tape changer) +# +/bin/cp -f scripts/bacula-dir-tape.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-2disk.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf +outf="tmp/sed_tmp" +echo "s%# Autochanger = yes% Autochanger = yes%g" >${outf} +cp bin/bacula-dir.conf tmp/1 +sed -f ${outf} tmp/1 >bin/bacula-dir.conf diff --git a/regress/regress/scripts/copy-2disk-drive-confs b/regress/regress/scripts/copy-2disk-drive-confs new file mode 100755 index 0000000000..7a5dcd30ea --- /dev/null +++ b/regress/regress/scripts/copy-2disk-drive-confs @@ -0,0 +1,10 @@ +#!/bin/sh +/bin/cp -f scripts/bacula-dir-tape.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-2disk-drive.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf +outf="tmp/sed_tmp" +echo "s%# Autochanger = yes% Autochanger = yes%g" >${outf} +cp bin/bacula-dir.conf tmp/1 +sed -f ${outf} tmp/1 >bin/bacula-dir.conf + diff --git a/regress/regress/scripts/copy-2drive-confs b/regress/regress/scripts/copy-2drive-confs new file mode 100755 index 0000000000..0388c4c175 --- /dev/null +++ b/regress/regress/scripts/copy-2drive-confs @@ -0,0 +1,15 @@ +#!/bin/sh +/bin/cp -f scripts/bacula-dir-tape.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-2drive.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf +outf="tmp/sed_tmp" +echo "s%# Autochanger = yes% Autochanger = yes%g" >${outf} +cp bin/bacula-dir.conf tmp/1 +sed -f ${outf} tmp/1 >bin/bacula-dir.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/copy-2tape-confs b/regress/regress/scripts/copy-2tape-confs new file mode 100755 index 0000000000..e23adc5c82 --- /dev/null +++ b/regress/regress/scripts/copy-2tape-confs @@ -0,0 +1,15 @@ +#!/bin/sh +/bin/cp -f scripts/bacula-dir-tape.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-2tape.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf +outf="tmp/sed_tmp" +echo "s%# Autochanger = yes% Autochanger = yes%g" >${outf} +cp bin/bacula-dir.conf tmp/1 +sed -f ${outf} tmp/1 >bin/bacula-dir.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/copy-confs b/regress/regress/scripts/copy-confs new file mode 100755 index 0000000000..c12a20a359 --- /dev/null +++ b/regress/regress/scripts/copy-confs @@ -0,0 +1,11 @@ +#!/bin/sh +/bin/cp -f scripts/bacula-dir.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd.conf bin/bacula-sd.conf +/bin/cp -f scripts/bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/bconsole.conf bin/bconsole.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/copy-crypto-confs b/regress/regress/scripts/copy-crypto-confs new file mode 100755 index 0000000000..c981df30fb --- /dev/null +++ b/regress/regress/scripts/copy-crypto-confs @@ -0,0 +1,7 @@ +#!/bin/sh +/bin/cp -f scripts/new-test-bacula-dir.conf bin/bacula-dir.conf +/bin/cp -f scripts/test-bacula-sd.conf bin/bacula-sd.conf +/bin/cp -f scripts/crypto-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf +/bin/cp -f scripts/cryptokeypair.pem bin/cryptokeypair.pem +/bin/cp -f scripts/master2048.cert bin/master2048.cert diff --git a/regress/regress/scripts/copy-fifo-confs b/regress/regress/scripts/copy-fifo-confs new file mode 100755 index 0000000000..812b731967 --- /dev/null +++ b/regress/regress/scripts/copy-fifo-confs @@ -0,0 +1,11 @@ +#!/bin/sh +/bin/cp -f scripts/bacula-dir-fifo.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-fifo.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/copy-migration-confs b/regress/regress/scripts/copy-migration-confs new file mode 100755 index 0000000000..c7680bc40e --- /dev/null +++ b/regress/regress/scripts/copy-migration-confs @@ -0,0 +1,8 @@ +#!/bin/sh +# +# Setup for using the Virtual Disk Changer (simulates tape changer) +# +/bin/cp -f scripts/bacula-dir-migration.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-migration.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf diff --git a/regress/regress/scripts/copy-tape-confs b/regress/regress/scripts/copy-tape-confs new file mode 100755 index 0000000000..c8dae32c4a --- /dev/null +++ b/regress/regress/scripts/copy-tape-confs @@ -0,0 +1,11 @@ +#!/bin/sh +/bin/cp -f scripts/bacula-dir-tape.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-tape.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/copy-test-confs b/regress/regress/scripts/copy-test-confs new file mode 100755 index 0000000000..5552c77116 --- /dev/null +++ b/regress/regress/scripts/copy-test-confs @@ -0,0 +1,11 @@ +#!/bin/sh +/bin/cp -f scripts/new-test-bacula-dir.conf bin/bacula-dir.conf +/bin/cp -f scripts/test-bacula-sd.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/copy-testa-confs b/regress/regress/scripts/copy-testa-confs new file mode 100755 index 0000000000..46116b9f90 --- /dev/null +++ b/regress/regress/scripts/copy-testa-confs @@ -0,0 +1,11 @@ +#!/bin/sh +/bin/cp -f scripts/testa-bacula-dir.conf bin/bacula-dir.conf +/bin/cp -f scripts/test-bacula-sd.conf bin/bacula-sd.conf +/bin/cp -f scripts/test-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/copy-tls-confs b/regress/regress/scripts/copy-tls-confs new file mode 100755 index 0000000000..af61e453cd --- /dev/null +++ b/regress/regress/scripts/copy-tls-confs @@ -0,0 +1,8 @@ +#!/bin/sh + +/bin/cp -f scripts/tls-bacula-dir.conf bin/bacula-dir.conf +/bin/cp -f scripts/tls-bacula-sd.conf bin/bacula-sd.conf +/bin/cp -f scripts/tls-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf +/bin/cp -f scripts/tls-CA.pem bin/tls-CA.pem +/bin/cp -f scripts/tls-cert.pem bin/tls-cert.pem diff --git a/regress/regress/scripts/copy-win32-confs b/regress/regress/scripts/copy-win32-confs new file mode 100755 index 0000000000..7cda59aabc --- /dev/null +++ b/regress/regress/scripts/copy-win32-confs @@ -0,0 +1,11 @@ +#!/bin/sh +/bin/cp -f scripts/win32-bacula-dir-tape.conf bin/bacula-dir.conf +/bin/cp -f scripts/win32-bacula-sd-tape.conf bin/bacula-sd.conf +/bin/cp -f scripts/win32-bacula-fd.conf bin/bacula-fd.conf +/bin/cp -f scripts/test-console.conf bin/bconsole.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi diff --git a/regress/regress/scripts/crypto-bacula-fd.conf.in b/regress/regress/scripts/crypto-bacula-fd.conf.in new file mode 100644 index 0000000000..540bc107bf --- /dev/null +++ b/regress/regress/scripts/crypto-bacula-fd.conf.in @@ -0,0 +1,37 @@ +# +# Default Bacula File Daemon Configuration file +# +# For Bacula release 2.0 +# +# There is not much to change here except perhaps the +# File daemon Name to +# + +# +# List Directors who are permitted to contact this File daemon +# +Director { + Name = @hostname@-dir + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" +} + +# +# "Global" File daemon configuration specifications +# +FileDaemon { # this is me + Name = @hostname@-fd + FDPort = @fdport@ # where we listen for the director + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + SubSys Directory = "@subsysdir@" + PKI Signatures = Yes + PKI Encryption = Yes + PKI Keypair = "@scriptdir@/cryptokeypair.pem" + PKI Master Key = "@scriptdir@/master2048.cert" +} + +# Send all messages except skipped files back to Director +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/cryptokeypair.pem b/regress/regress/scripts/cryptokeypair.pem new file mode 100644 index 0000000000..440dcce4f0 --- /dev/null +++ b/regress/regress/scripts/cryptokeypair.pem @@ -0,0 +1,23 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIBOgIBAAJBAKIc649Amif6weq+c8rVtS7jyn7E9oZ9Irrl9WviQZi0+J2OLgCi +PNaj/FzPhTIgBBRFEP0ZU5DfVv6CoXKbpr8CAwEAAQJAQbvUUFvzpi5pnxPmw+Jv ++zlmjIy1Icdv47UHFN3Dl3V0+X05g12xUlnyNKzo2jlSwkBi1w8AJCMV6/TnnLiI +AQIhAM4SH9cb01DUH+1O5gk90GgNYW1Aq2vL1vygm02kppi/AiEAyWQ9eAILPXhX +H3a7mEj8z1bCTBiVrhe73NUjim4QcgECIEC3hHRj8ruBwv0eODRSy27CNQTAuJVE +ESKJtfxuZzu1AiEAotXYFbahW/x3hUs9d25ca1EdHOYr8G3kSjRT3lQMHAECIHBl +uX+Ywc1jjWhc+vN2ZrLWkKMVbrd+SWOPUQGroM0j +-----END RSA PRIVATE KEY----- +-----BEGIN CERTIFICATE----- +MIICKzCCAdWgAwIBAgIJAO4x/m+tHX8HMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV +BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX +aWRnaXRzIFB0eSBMdGQwHhcNMDYxMjA0MDMxMzUwWhcNMDcwMTAzMDMxMzUwWjBF +MQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50 +ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKIc +649Amif6weq+c8rVtS7jyn7E9oZ9Irrl9WviQZi0+J2OLgCiPNaj/FzPhTIgBBRF +EP0ZU5DfVv6CoXKbpr8CAwEAAaOBpzCBpDAdBgNVHQ4EFgQUiGz2I+bks0nCHyCI +IwuV3DpDPMwwdQYDVR0jBG4wbIAUiGz2I+bks0nCHyCIIwuV3DpDPMyhSaRHMEUx +CzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRl +cm5ldCBXaWRnaXRzIFB0eSBMdGSCCQDuMf5vrR1/BzAMBgNVHRMEBTADAQH/MA0G +CSqGSIb3DQEBBQUAA0EAkjFYcs9rrpdURlBaNlbud68VlA5rU+Bv4keYx41DUmqo +sXtkQZENR9iYYYhOUso1/1dwQgrt3egjTZTtq7o5zw== +-----END CERTIFICATE----- diff --git a/regress/regress/scripts/do_sed b/regress/regress/scripts/do_sed new file mode 100755 index 0000000000..31368c720f --- /dev/null +++ b/regress/regress/scripts/do_sed @@ -0,0 +1,102 @@ +#!/bin/sh +# +cwd=`pwd` +. ${cwd}/config +mkdir -p ${cwd}/bin +out="${cwd}/tmp/sed_tmp" + +# set the ports used by these tests +dirport=${BASEPORT} +fdport=`expr ${BASEPORT} '+' 1` +sdport=`expr ${BASEPORT} '+' 2` + +# Create sed command script +echo "s%@sbindir@%${cwd}/bin%g" >${out} +echo "s%@scriptdir@%${cwd}/bin%g" >>${out} +echo "s%@working_dir@%${cwd}/working%g" >>${out} +echo "s%@piddir@%${cwd}/working%g" >>${out} +echo "s%@subsysdir@%${cwd}/working%g" >>${out} +echo "s%@job_email@%${EMAIL}%g" >>${out} +echo "s%@tape_drive@%${TAPE_DRIVE}%g" >>${out} +echo "s%@autochanger@%${AUTOCHANGER}%g" >>${out} +echo "s%@tmpdir@%${cwd}/tmp%g" >>${out} +echo "s%@hostname@%${HOST}%g" >>${out} +echo "s%@changer_path@%${AUTOCHANGER_PATH}%g" >>${out} +echo "s%@tape_drive1@%${TAPE_DRIVE1}%g" >>${out} +echo "s%@smtp_host@%${SMTP_HOST}%g" >>${out} +echo "s%@disk_drive@%${cwd}/tmp/disk-changer%g" >>${out} +echo "s%@hostname@%${hostname}%g" >>${out} +echo "s%@hostname1@%${hostname1}%g" >>${out} +echo "s%@hostname2@%${hostname2}%g" >>${out} +echo "s%@hostname3@%${hostname3}%g" >>${out} +echo "s%@hostname1_files@%${hostname1_files}%g" >>${out} +echo "s%@hostname_files@%${hostname_files}%g" >>${out} +echo "s%@hostname2_files@%${hostname2_files}%g" >>${out} +echo "s%@hostname3_files@%${hostname3_files}%g" >>${out} +echo "s%@hostname1_password@%${hostname1_password}%g" >>${out} +echo "s%@hostname2_password@%${hostname2_password}%g" >>${out} +echo "s%@hostname3_password@%${hostname3_password}%g" >>${out} +echo "s%@dirport@%${dirport}%g" >>${out} +echo "s%@sdport@%${sdport}%g" >>${out} +echo "s%@fdport@%${fdport}%g" >>${out} + +# process .in files with sed script +sed -f ${out} ${cwd}/scripts/bacula-dir.conf.errors.in >${cwd}/scripts/bacula-dir.conf.errors +sed -f ${out} ${cwd}/scripts/test-bacula-dir.conf.in >${cwd}/scripts/test-bacula-dir.conf +sed -f ${out} ${cwd}/scripts/multi-client-bacula-dir.conf.in >${cwd}/scripts/multi-client-bacula-dir.conf +sed -f ${out} ${cwd}/scripts/bacula-dir.conf.regexwhere.in >${cwd}/scripts/bacula-dir.conf.regexwhere +sed -f ${out} ${cwd}/scripts/bacula-dir.conf.maxtime.in >${cwd}/scripts/bacula-dir.conf.maxtime +sed -f ${out} ${cwd}/scripts/new-test-bacula-dir.conf.in >${cwd}/scripts/new-test-bacula-dir.conf +sed -f ${out} ${cwd}/scripts/testa-bacula-dir.conf.in >${cwd}/scripts/testa-bacula-dir.conf +sed -f ${out} ${cwd}/scripts/testb-bacula-dir.conf.in >${cwd}/scripts/testb-bacula-dir.conf +sed -f ${out} ${cwd}/scripts/test-bacula-fd.conf.in >${cwd}/scripts/test-bacula-fd.conf +sed -f ${out} ${cwd}/scripts/test-bacula-sd.conf.in >${cwd}/scripts/test-bacula-sd.conf +sed -f ${out} ${cwd}/scripts/test-console.conf.in >${cwd}/scripts/test-console.conf +sed -f ${out} ${cwd}/scripts/crypto-bacula-fd.conf.in >${cwd}/scripts/crypto-bacula-fd.conf +sed -f ${out} ${cwd}/scripts/bacula-dir-tape.conf.in >${cwd}/scripts/bacula-dir-tape.conf +sed -f ${out} ${cwd}/scripts/bacula-dir-fifo.conf.in >${cwd}/scripts/bacula-dir-fifo.conf +sed -f ${out} ${cwd}/scripts/bacula-dir-migration.conf.in >${cwd}/scripts/bacula-dir-migration.conf +sed -f ${out} ${cwd}/scripts/win32-bacula-dir-tape.conf.in >${cwd}/scripts/win32-bacula-dir-tape.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-tape.conf.in >${cwd}/scripts/bacula-sd-tape.conf +sed -f ${out} ${cwd}/scripts/ansi-sd-tape.conf.in >${cwd}/scripts/ansi-sd-tape.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-fifo.conf.in >${cwd}/scripts/bacula-sd-fifo.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-2tape.conf.in >${cwd}/scripts/bacula-sd-2tape.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-migration.conf.in >${cwd}/scripts/bacula-sd-migration.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-2disk.conf.in >${cwd}/scripts/bacula-sd-2disk.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-2drive.conf.in >${cwd}/scripts/bacula-sd-2drive.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-2disk-drive.conf.in >${cwd}/scripts/bacula-sd-2disk-drive.conf +sed -f ${out} ${cwd}/scripts/cleanup-tape.in >${cwd}/scripts/cleanup-tape +sed -f ${out} ${cwd}/scripts/cleanup-2tape.in >${cwd}/scripts/cleanup-2tape +sed -f ${out} ${cwd}/scripts/cleanup-2drive.in >${cwd}/scripts/cleanup-2drive +sed -f ${out} ${cwd}/scripts/prepare-two-tapes.in >${cwd}/scripts/prepare-two-tapes +sed -f ${out} ${cwd}/scripts/bacula-dir.conf.testrunscript.in >${cwd}/scripts/bacula-dir.conf.testrunscript + +sed -f ${out} ${cwd}/scripts/tls-bacula-fd.conf.in >${cwd}/scripts/tls-bacula-fd.conf +sed -f ${out} ${cwd}/scripts/tls-bacula-sd.conf.in >${cwd}/scripts/tls-bacula-sd.conf +sed -f ${out} ${cwd}/scripts/tls-bacula-dir.conf.in >${cwd}/scripts/tls-bacula-dir.conf + +sed -f ${out} ${cwd}/scripts/bacula-fd-2d.conf.in >${cwd}/scripts/bacula-fd-2d.conf +sed -f ${out} ${cwd}/scripts/bacula-sd-2d.conf.in >${cwd}/scripts/bacula-sd-2d.conf +sed -f ${out} ${cwd}/scripts/bacula-dir-2d.conf.in >${cwd}/scripts/bacula-dir-2d.conf +sed -f ${out} ${cwd}/scripts/bconsole-2d.conf.in >${cwd}/scripts/bconsole-2d.conf + +# These files have no fancy sed stuff, so we just copy them over +cp scripts/win32-bacula-sd-tape.conf.in scripts/win32-bacula-sd-tape.conf +cp scripts/win32-bacula-fd.conf.in scripts/win32-bacula-fd.conf + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/bac$$ +sed s%/tmp%${cwd}/tmp%g ${cwd}/tmp/bac$$ >${cwd}/bin/bacula-sd.conf +chmod 777 ${cwd}/scripts/cleanup-*tape ${cwd}/scripts/cleanup-*drive ${cwd}/scripts/prepare-two-tapes +rm -f ${cwd}/tmp/bac$$ +cp ${cwd}/bin/mtx-changer ${cwd}/tmp/bac$$ +sed "s%^MTX.*$%MTX=${AUTOCHANGER_PATH}%g" ${cwd}/tmp/bac$$ >${cwd}/bin/mtx-changer +chmod 777 ${cwd}/bin/mtx-changer + +# get proper SD tape definitions +cp -f ${cwd}/scripts/linux_tape_options ${cwd}/bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f ${cwd}/scripts/freebsd_tape_options ${cwd}/bin/tape_options +fi + +rm -f ${out} +rm -f ${cwd}/tmp/bac$$ diff --git a/regress/regress/scripts/exclude-dev-test b/regress/regress/scripts/exclude-dev-test new file mode 100644 index 0000000000..4165ea1ae7 --- /dev/null +++ b/regress/regress/scripts/exclude-dev-test @@ -0,0 +1,5 @@ +dev/ptmx +dev/pts +dev/rd/c5d2 +dev/rd +dev/shm diff --git a/regress/regress/scripts/exclude-etc-test b/regress/regress/scripts/exclude-etc-test new file mode 100644 index 0000000000..f59ca8df2a --- /dev/null +++ b/regress/regress/scripts/exclude-etc-test @@ -0,0 +1 @@ +etc/mail/statistics diff --git a/regress/regress/scripts/exclude-lib-test b/regress/regress/scripts/exclude-lib-test new file mode 100644 index 0000000000..5be32f443b --- /dev/null +++ b/regress/regress/scripts/exclude-lib-test @@ -0,0 +1,5 @@ +lib/ld-2.2.5.so +lib/libtermcap.so.2.0.8 +lib/libc-2.2.5.so +lib/libnsl-2.2.5.so +lib/libnss_files-2.2.5.so diff --git a/regress/regress/scripts/flist b/regress/regress/scripts/flist new file mode 100644 index 0000000000..d33e45a88b --- /dev/null +++ b/regress/regress/scripts/flist @@ -0,0 +1,23 @@ +/build/configure +/build/src/stored/bextract +/build/src/tools/testfind +/build/Makefile.in +/build/src/dird/bacula-dir +/build/src/console/bconsole +/build/src/filed/bacula-fd +/build/src/findlib/find_one.c +/build/src/jcr.h +/build/platforms/Makefile.in +/build/platforms/redhat/Makefile.in +/build/scripts/Makefile.in +/build/src/win32/filed/service.cpp +/build/src/filed/restore.c +/build/autoconf/configure.in +/build/examples/afs-bacula +/build/src/win32/Makefile.inc.in +/build/src/win32/installer/winbacula.nsi +/build/autoconf/configure.in +/build/src/version.h +/build/src/lib/message.c +/build/src/lib/bnet_server.c +/build/src/lib/libbac.a diff --git a/regress/regress/scripts/freebsd_tape_options b/regress/regress/scripts/freebsd_tape_options new file mode 100644 index 0000000000..05be3449c4 --- /dev/null +++ b/regress/regress/scripts/freebsd_tape_options @@ -0,0 +1,8 @@ +# +# FreeBSD tape drive options +# +Hardware End of Medium = no +Fast Forward Space File = no +BSF at EOM = yes +Backward Space Record = no +TWO EOF = yes diff --git a/regress/regress/scripts/functions b/regress/regress/scripts/functions new file mode 100644 index 0000000000..798bc0a786 --- /dev/null +++ b/regress/regress/scripts/functions @@ -0,0 +1,204 @@ +# +# A set of useful functions to be sourced in each test +# + +start_test() +{ + echo " " + echo " " + echo " === Starting $TestName at `date +%R:%S` ===" + echo " === Starting $TestName at `date +%R:%S` ===" >>working/log + echo " " + export zstat +} + +require_root() +{ +MUID=`/usr/bin/id | awk -F= '{print $2}' | awk -F\( '{print $1}'` +if [ $MUID != 0 ] ; then + echo " " + echo "You must be root to run this test." + echo " ===== !!!! $TestName not run at `date +%R:%S` ===" + echo " ===== !!!! $TestName not run at `date +%R:%S` !!!! ===== " >>test.out + echo " " + exit 1 +fi +} + + +set_debug() +{ + debug=$1 + if test "$debug" -eq 1 ; then + out="tee" + else + out="output" + fi +} + +run_bacula() +{ + debug_wait + zstat=0 + if test "$debug" -eq 1 ; then + bin/bacula-ctl-sd start + bin/bacula-ctl-fd start + bin/bacula-ctl-dir start + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf + else + bin/bacula start 2>&1 >/dev/null + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null + fi +} + +run_bconsole() +{ + if test "$debug" -eq 1 ; then + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf + else + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null + fi +} + +run_btape() +{ + if test "$debug" -eq 1 ; then + cat tmp/bconcmds | bin/btape -c bin/bacula-sd.conf DDS-4 | tee tmp/log1.out + else + cat tmp/bconcmds | bin/btape -c bin/bacula-sd.conf DDS-4 2>&1 >tmp/log1.out + fi +} + +run_bscan() +{ + if test "$debug" -eq 1 ; then + bin/bscan $* | tee tmp/log.out + else + bin/bscan $* 2>&1 >/dev/null + fi +} + + +stop_bacula() +{ + bin/bacula stop 2>&1 >/dev/null +} + +check_for_zombie_jobs() +{ + scripts/check_for_zombie_jobs $* +} + +change_jobname() +{ + if test $# -eq 1; then + oldname=NightlySave + newname=$1 + else + oldname=$1 + newname=$2 + fi + rm -f bin/1 + mv bin/bacula-dir.conf bin/1 + echo "s%${oldname}%${newname}%g" >tmp/1 + sed -f tmp/1 bin/1 >bin/bacula-dir.conf +# echo "Job ${oldname} changed to ${newname}" +} + +check_two_logs() +{ + grep "^ Termination: *Backup OK" tmp/log1.out 2>&1 >/dev/null + bstat=$? + grep "^ Termination: .*Backup Error" tmp/log1.out 2>&1 >/dev/null + if test $? -eq 0; then + bstat=2 + fi + grep "^ Termination: *Restore OK" tmp/log2.out 2>&1 >/dev/null + rstat=$? + grep "^ Termination: *Restore OK -- warning file count mismatch" tmp/log2.out 2>&1 >/dev/null + if test $? -eq 0; then + rstat=2 + fi + grep "^ Termination: .*Verify Differences" tmp/log2.out 2>&1 >/dev/null + if test $? -eq 0; then + rstat=3 + fi +} + +check_restore_diff() +{ + diff -r build tmp/bacula-restores${cwd}/build 2>&1 >/dev/null + dstat=$? +} + +check_restore_tmp_build_diff() +{ + diff -r tmp/build tmp/bacula-restores${cwd}/tmp/build 2>&1 >/dev/null + dstat=$? +} + +end_test() +{ + if [ $zstat != 0 ] ; then + echo " " + echo " !!!!! $TestName failed!!! `date +%R:%S` !!!!! " + echo " !!!!! $TestName failed!!! `date +%R:%S` !!!!! " >>test.out + echo " Status: zombie=$zstat backup=$bstat restore=$rstat diff=$dstat" >>test.out + echo " " + exit 1 + fi + if [ $dstat != 0 -o $bstat != 0 -o $rstat != 0 ] ; then + echo " " + echo " " + echo " !!!!! $TestName failed!!! `date +%R:%S` !!!!! " + echo " !!!!! $TestName failed!!! `date +%R:%S` !!!!! " >>test.out + if [ $bstat != 0 -o $rstat != 0 ] ; then + echo " !!!!! Bad termination status !!!!! " + echo " !!!!! Bad termination status !!!!! " >>test.out + else + echo " !!!!! Restored files differ !!!!! " + echo " !!!!! Restored files differ !!!!! " >>test.out + fi + echo " Status: backup=$bstat restore=$rstat diff=$dstat" + echo " Status: backup=$bstat restore=$rstat diff=$dstat" >>test.out + echo " " + exit 1 + else + echo " ===== $TestName OK `date +%R:%S` ===== " + echo " ===== $TestName OK `date +%R:%S` ===== " >>test.out + if test "$debug" -eq 0 ; then + scripts/cleanup + fi + fi +} + +copy_tape_confs() +{ + scripts/copy-tape-confs + scripts/cleanup-tape +} + +copy_test_confs() +{ + scripts/copy-test-confs + scripts/cleanup +} + +debug_wait() +{ + if test "x${REGRESS_WAIT}" = "x1"; then + echo "Start Bacula under debugger and enter anything when ready ..." + read a + fi +} + +# Save current directory +cwd=`pwd` +if test "x${REGRESS_DEBUG}" = "x1"; then + set_debug 1 +else + set_debug 0 +fi + +# Source the configuration variables +. ${cwd}/config diff --git a/regress/regress/scripts/linux_osst_tape_options b/regress/regress/scripts/linux_osst_tape_options new file mode 100644 index 0000000000..5def0c08cb --- /dev/null +++ b/regress/regress/scripts/linux_osst_tape_options @@ -0,0 +1,7 @@ + Minimum Block Size = 32768 + Maximum Block Size = 32768 + Hardware End of Medium = yes + BSF at EOM = yes + Fast Forward Space File = yes + Two EOF = no + diff --git a/regress/regress/scripts/linux_tape_options b/regress/regress/scripts/linux_tape_options new file mode 100644 index 0000000000..601eb82aa5 --- /dev/null +++ b/regress/regress/scripts/linux_tape_options @@ -0,0 +1 @@ +# nothing needed for Linux diff --git a/regress/regress/scripts/master2048.cert b/regress/regress/scripts/master2048.cert new file mode 100644 index 0000000000..1927c2ee21 --- /dev/null +++ b/regress/regress/scripts/master2048.cert @@ -0,0 +1,28 @@ +-----BEGIN CERTIFICATE----- +MIIExzCCA6+gAwIBAgIJANItYfYlLjH/MA0GCSqGSIb3DQEBBQUAMIGdMQswCQYD +VQQGEwJVUzELMAkGA1UECBMCTlkxEzARBgNVBAcTCkJpbmdoYW10b24xJTAjBgNV +BAoTHEdpYW50IE1hcmtldCBCaW5naGFtdG9uIEluYy4xHTAbBgNVBAMTFEJhY3Vs +YSBCYWNrdXAgU3lzdGVtMSYwJAYJKoZIhvcNAQkBFhdiYWNrdXBAZ2lhbnRtYXJr +ZXRzLmNvbTAeFw0wNzA0MjUyMDMxNTFaFw0wNzA1MjUyMDMxNTFaMIGdMQswCQYD +VQQGEwJVUzELMAkGA1UECBMCTlkxEzARBgNVBAcTCkJpbmdoYW10b24xJTAjBgNV +BAoTHEdpYW50IE1hcmtldCBCaW5naGFtdG9uIEluYy4xHTAbBgNVBAMTFEJhY3Vs +YSBCYWNrdXAgU3lzdGVtMSYwJAYJKoZIhvcNAQkBFhdiYWNrdXBAZ2lhbnRtYXJr +ZXRzLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAPbvxVmZErPu +LsvVe2zi31Mygq4pbEVTUi2K6T9kNTC1mmPhPxZJF3vCLQ6/tMKXoc6Wy0cLEs9o +JM9dFu1oVexkLK0oi7nWlYlwg0ua4dADUS0iUIsxPh8f/jXGaaPFcof5f/bwHCwK +Y6GPAdE7oBaPrDip5WCsdhA9lLGcmZBKeabemDfHyrfaLmrzRt3ZXH3dMa2ROC2A +YIo0ReFaklNCJDxLojbG0BezW6F4IbfsQSelr6g72io88oBEAa0aysOGRKdaQ4Da +18aVsFfbLQ6z/DAAu66HgQJG9X5bWsew3aUVThKIICtXoI8FMSgk+yZHKpzj+K6o +KiZ+bMcRemsCAwEAAaOCAQYwggECMB0GA1UdDgQWBBSi7vn39ZcGIbzV3y6zvR0V +T2zK/DCB0gYDVR0jBIHKMIHHgBSi7vn39ZcGIbzV3y6zvR0VT2zK/KGBo6SBoDCB +nTELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAk5ZMRMwEQYDVQQHEwpCaW5naGFtdG9u +MSUwIwYDVQQKExxHaWFudCBNYXJrZXQgQmluZ2hhbXRvbiBJbmMuMR0wGwYDVQQD +ExRCYWN1bGEgQmFja3VwIFN5c3RlbTEmMCQGCSqGSIb3DQEJARYXYmFja3VwQGdp +YW50bWFya2V0cy5jb22CCQDSLWH2JS4x/zAMBgNVHRMEBTADAQH/MA0GCSqGSIb3 +DQEBBQUAA4IBAQAnek7pGLAehonnbSIkB8XD27l2EU73sYEMCm6YI5U5fyCsYN40 +KkYm32jhZu15xR+uuiYZWJqzZqz0O5xrK4Rxc36KAD5FMeYEoIDjdK1hXnrA2Jvo +w7wlhQJ/JDp/gGV0yDCZe2jURlVDR/YT1ECnIUZ9jr2GX6w2Uwk1iJedvbKRlHyc +PxEHpTGXl6YrmlVIpcNIuuHn4dY1FBul2VSC4RAhwmXvNSQDnQoQodX5QaJN1uc8 +tsU3lBtsSsKzerBFyKujwi8I0qcOtzHqy/zYbr3F4uHTSVheCja4FWskrRWCMQzc +ySn09DurGBHU+iixlOsLy9xKwytntJPZqXV6 +-----END CERTIFICATE----- \ No newline at end of file diff --git a/regress/regress/scripts/multi-client-bacula-dir.conf.in b/regress/regress/scripts/multi-client-bacula-dir.conf.in new file mode 100644 index 0000000000..a8a2efec2e --- /dev/null +++ b/regress/regress/scripts/multi-client-bacula-dir.conf.in @@ -0,0 +1,376 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 2.2.2 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 10 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 10 +} + +Job { + Name = @hostname1@ + Type = Backup + Client = @hostname1@-fd + FileSet = "@hostname1@-FileSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 10 +} + +Job { + Name = @hostname2@ + Type = Backup + Client = @hostname2@-fd + FileSet = "@hostname2@-FileSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 10 +} + +Job { + Name = @hostname3@ + Type = Backup + Client = @hostname3@-fd + FileSet = "@hostname3@-FileSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 10 +} + + + +Job { + Name = "MonsterSave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File1 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "SparseTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "CompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="CompressedSet" + Storage = File + Messages = Standard + Pool = Default + Maximum Concurrent Jobs = 10 + Write Bootstrap = "@working_dir@/NightlySave.bsr" +# Max Run Time = 15 seconds +} + +Job { + Name = "SparseCompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseCompressedSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +# Backup the catalog database (after the nightly save) +Job { + Name = "BackupCatalog" + Type = Backup + Client=@hostname@-fd + FileSet="Catalog" +# Schedule = "WeeklyCycleAfterBackup" + Storage = File + Messages = Standard + Pool = Default + # This creates an ASCII copy of the catalog + RunBeforeJob = "@sbindir@/make_catalog_backup -u regress" + # This deletes the copy of the catalog + RunAfterJob = "@sbindir@/delete_catalog_backup" + Write Bootstrap = "@working_dir@/BackupCatalog.bsr" +} + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = @hostname_files@ + } +} + +FileSet { + Name = "@hostname1@-FileSet" + Include { Options { signature=MD5 } + File = @hostname1_files@ + } +} + +FileSet { + Name = "@hostname2@-FileSet" + Include { Options { signature=MD5 } + File = @hostname2_files@ + } +} + +FileSet { + Name = "@hostname3@-FileSet" + Include { Options { signature=MD5 } + File = @hostname3_files@ + } +} + +FileSet { + Name = "SparseSet" + Include { Options { signature=MD5; sparse=yes } + File=<@tmpdir@/file-list + } +} + +FileSet { + Name = "CompressedSet" + Include { + Options { signature=MD5; compression=GZIP } + File =<@tmpdir@/file-list + } +} + +FileSet { + Name = "SparseCompressedSet" + Include { + Options { + signature=MD5; compression=GZIP + } + File= <@tmpdir@/file-list + } +} + + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Level=Full 1st sun at 1:05 + Run = Level=Differential 2nd-5th sun at 1:05 + Run = Level=Incremental mon-sat at 1:05 +} + +# This schedule does the catalog. It starts after the WeeklyCycle +Schedule { + Name = "WeeklyCycleAfterBackup" + Run = Level=Full sun-sat at 1:10 +} + +# This is the backup of the catalog +FileSet { + Name = "Catalog" + Include { Options { signature=MD5 } + File=/home/kern/bacula/regress/bin/working/bacula.sql + } +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 10 +} + +Client { + Name = @hostname1@-fd + Address = @hostname1@ + FDPort = 9102 + Catalog = MyCatalog + Password = "@hostname1_password@" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 10 +} + +Client { + Name = @hostname2@-fd + Address = @hostname2@ + FDPort = 9102 + Catalog = MyCatalog + Password = "@hostname2_password@" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 10 +} + +Client { + Name = @hostname3@-fd + Address = @hostname3@ + FDPort = 9102 + Catalog = MyCatalog + Password = "@hostname3_password@" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 10 +} + + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 10 +} + +Storage { + Name = File1 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage1 + Media Type = File1 + Maximum Concurrent Jobs = 10 +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +Messages { + Name = NoEmail + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + console = all, !skipped, !terminate +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/new-test-bacula-dir.conf.in b/regress/regress/scripts/new-test-bacula-dir.conf.in new file mode 100644 index 0000000000..f10344215f --- /dev/null +++ b/regress/regress/scripts/new-test-bacula-dir.conf.in @@ -0,0 +1,368 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39 or later +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData=yes +} + +Job { + Name = "MonsterSave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File1 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "SparseTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "CompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="CompressedSet" + Storage = File + Messages = Standard + Pool = Default + Maximum Concurrent Jobs = 4 + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "SparseCompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseCompressedSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "FIFOTest" + Type = Backup + Client=@hostname@-fd + FileSet="FIFOSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + ClientRunBeforeJob = "/bin/sleep 60" +} + + + +# Backup the catalog database (after the nightly save) +Job { + Name = "BackupCatalog" + Type = Backup + Client=@hostname@-fd + FileSet="Catalog" +# Schedule = "WeeklyCycleAfterBackup" + Storage = File + Messages = Standard + Pool = Default + # This creates an ASCII copy of the catalog + RunBeforeJob = "@sbindir@/make_catalog_backup -u regress" + # This deletes the copy of the catalog + RunAfterJob = "@sbindir@/delete_catalog_backup" + Write Bootstrap = "@working_dir@/BackupCatalog.bsr" +} + +JobDefs { + Name = "BackupJob" + Type = Backup + Pool = Default + Storage = File + Messages = Standard + Priority = 10 +} + +Job { + JobDefs = "BackupJob" + Name = "bug621-job-1" + Client = @hostname@-fd + FileSet="Full Set" + ClientRunBeforeJob = "/bin/sleep 60" +} + +Job { + JobDefs = "BackupJob" + Name = "bug621-job-2" + Client = @hostname@-fd + FileSet = "Full Set" + Max Run Time = 30 + Priority = 15 +} + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "SparseSet" + Include { + Options { + signature=MD5 + sparse=yes + } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "CompressedSet" + Include { + Options { + signature=MD5 + compression=GZIP + } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "FIFOSet" + Include { + Options { + readfifo = yes + signature=MD5 + } + File = <@tmpdir@/file-list + } +} + + +FileSet { + Name = "SparseCompressedSet" + Include { + Options { + signature=MD5 + compression=GZIP + sparse=yes + } + File = <@tmpdir@/file-list + } +} + + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Level=Full 1st sun at 1:05 + Run = Level=Differential 2nd-5th sun at 1:05 + Run = Level=Incremental mon-sat at 1:05 +} + +# This schedule does the catalog. It starts after the WeeklyCycle +Schedule { + Name = "WeeklyCycleAfterBackup" + Run = Level=Full sun-sat at 1:10 +} + +# This is the backup of the catalog +FileSet { + Name = "Catalog" + Include { + Options { + signature=MD5 + } + File = /home/kern/bacula/regress/bin/working/bacula.sql + } +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 4 +} + +Storage { + Name = File1 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage1 + Media Type = File1 + Maximum Concurrent Jobs = 4 +} + + +# Definition of DLT tape storage device +#Storage { +# Name = DLTDrive +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon +# Device = "HP DLT 80" # must be same as Device in Storage daemon +# Media Type = DLT8000 # must be same as MediaType in Storage daemon +#} + +# Definition of DDS tape storage device +#Storage { +# Name = SDT-10000 +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon +# Device = SDT-10000 # must be same as Device in Storage daemon +# Media Type = DDS-4 # must be same as MediaType in Storage daemon +#} + +# Definition of 8mm tape storage device +#Storage { +# Name = "8mmDrive" +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +# Device = "Exabyte 8mm" +# MediaType = "8mm" +#} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +Messages { + Name = NoEmail + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + console = all, !skipped, !terminate +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +# Label Format = "TEST-${Year}-${Month:p/2/0/r}-${Day:p/2/0/r}:${NumVols}" +# Maximum Volume Jobs = 1 +} diff --git a/regress/regress/scripts/prepare-two-disks b/regress/regress/scripts/prepare-two-disks new file mode 100755 index 0000000000..959daa4201 --- /dev/null +++ b/regress/regress/scripts/prepare-two-disks @@ -0,0 +1,6 @@ +#!/bin/sh +# +# Create fresh virtual disk changer directory +# +rm -rf tmp/disk-changer +mkdir tmp/disk-changer diff --git a/regress/regress/scripts/prepare-two-tapes.in b/regress/regress/scripts/prepare-two-tapes.in new file mode 100755 index 0000000000..611fb906f7 --- /dev/null +++ b/regress/regress/scripts/prepare-two-tapes.in @@ -0,0 +1,41 @@ +#!/bin/sh +# +# Create two blank tapes +# +OS=`uname` +case ${OS} in + SunOS) + ready="No Additional Sense" + ;; + FreeBSD) + ready="Current Driver State: at rest." + ;; + *) + ready="ONLINE" + ;; +esac +wait_for_drive() { + i=0 + while [ $i -le 300 ]; do # Wait max 300 seconds + if mt -f $1 status | grep ${ready} >/dev/null 2>&1; then + break + fi +# debug "Device $1 - not ready, retrying..." + sleep 1 + i=`expr $i + 1` + done +} + +# +# mt -f @tape_drive@ offline +@changer_path@ -f @autochanger@ unload +@changer_path@ -f @autochanger@ load 1 +wait_for_drive @tape_drive@ +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof +@changer_path@ -f @autochanger@ unload +@changer_path@ -f @autochanger@ load 2 +wait_for_drive @tape_drive@ +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof +#@changer_path@ -f @autochanger@ unload diff --git a/regress/regress/scripts/regress-config b/regress/regress/scripts/regress-config new file mode 100755 index 0000000000..8d3abd6f9d --- /dev/null +++ b/regress/regress/scripts/regress-config @@ -0,0 +1,29 @@ +#!/bin/sh +# +# This is the configuration script for regression testing +# + +. ${1}/config + +CFLAGS="-g -O2 -Wall" \ + ./configure \ + --sbindir=${1}/bin \ + --archivedir=${1}/tmp \ + --sysconfdir=${1}/bin \ + --mandir=${1}/bin \ + --with-pid-dir=${1}/working \ + --with-subsys-dir=${1}/working \ + --enable-smartalloc \ + --disable-readline \ + --with-working-dir=${1}/working \ + --with-dump-email=${EMAIL} \ + --with-job-email=${EMAIL} \ + --with-smtp-host=${SMTP_HOST} \ + --with-db-name=regress \ + --with-db-user=regress \ + ${OPENSSL} \ + ${TCPWRAPPERS} \ + ${WHICHDB} \ + --with-baseport=8101 + +exit 0 diff --git a/regress/regress/scripts/setup b/regress/regress/scripts/setup new file mode 100755 index 0000000000..e452fa1f01 --- /dev/null +++ b/regress/regress/scripts/setup @@ -0,0 +1,60 @@ +#!/bin/sh +# +# Script to setup running Bacula regression tests +# + +check_exit_code() +{ + if [ $? != 0 ] ; then + echo "Bad exit code giving up" + exit 1 + fi +} + +. ./config + +cwd=`pwd` +if [ ! -d ${BACULA_SOURCE} ] ; then + echo "The BACULA_SOURCE environment variable must be a Bacula release directory, but is not." + echo " " + exit 1 +fi +rm -rf build bin +# Copy new source +echo "Copying source from ${BACULA_SOURCE}" +cp -rp ${BACULA_SOURCE} build +cp scripts/regress-config build +cd build +rm -f Makefile config.cache +# Run Bacula configuration, make, install +./regress-config ${cwd} +check_exit_code +# Cleanup any win32 build in source +cd src/win32 +make clean +cd ../.. +make +check_exit_code +make install +check_exit_code +cp src/tools/testls ../bin +check_exit_code + +cd ${cwd} +bin/bacula stop + +mkdir -p working +cd bin +echo "Running database creation scripts" +./create_bacula_database +./drop_bacula_tables +./make_bacula_tables +./grant_bacula_privileges +cd ${cwd} +# Start and stop Bacula to ensure conf files are OK +bin/bacula start +bin/bacula stop +# +# Save Bacula default conf files for later use +# +cp -f bin/*.conf scripts diff --git a/regress/regress/scripts/test-bacula-dir.conf.in b/regress/regress/scripts/test-bacula-dir.conf.in new file mode 100644 index 0000000000..6a6defeca2 --- /dev/null +++ b/regress/regress/scripts/test-bacula-dir.conf.in @@ -0,0 +1,312 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 2.2.2 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData=yes +} + +Job { + Name = "MonsterSave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File1 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "SparseTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "CompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="CompressedSet" + Storage = File + Messages = Standard + Pool = Default + Maximum Concurrent Jobs = 4 + Write Bootstrap = "@working_dir@/NightlySave.bsr" +# Max Run Time = 15 seconds +} + +Job { + Name = "SparseCompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseCompressedSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +# Backup the catalog database (after the nightly save) +Job { + Name = "BackupCatalog" + Type = Backup + Client=@hostname@-fd + FileSet="Catalog" +# Schedule = "WeeklyCycleAfterBackup" + Storage = File + Messages = Standard + Pool = Default + # This creates an ASCII copy of the catalog + RunBeforeJob = "@sbindir@/make_catalog_backup -u regress" + # This deletes the copy of the catalog + RunAfterJob = "@sbindir@/delete_catalog_backup" + Write Bootstrap = "@working_dir@/BackupCatalog.bsr" +} + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "SparseSet" + Include { Options { signature=MD5; sparse=yes } + File=<@tmpdir@/file-list + } +} + +FileSet { + Name = "CompressedSet" + Include { + Options { signature=MD5; compression=GZIP } + File =<@tmpdir@/file-list + } +} + +FileSet { + Name = "SparseCompressedSet" + Include { + Options { + signature=MD5; compression=GZIP + } + File= <@tmpdir@/file-list + } +} + + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Level=Full 1st sun at 1:05 + Run = Level=Differential 2nd-5th sun at 1:05 + Run = Level=Incremental mon-sat at 1:05 +} + +# This schedule does the catalog. It starts after the WeeklyCycle +Schedule { + Name = "WeeklyCycleAfterBackup" + Run = Level=Full sun-sat at 1:10 +} + +# This is the backup of the catalog +FileSet { + Name = "Catalog" + Include { Options { signature=MD5 } + File=/home/kern/bacula/regress/bin/working/bacula.sql + } +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 4 +} + +Storage { + Name = File1 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage1 + Media Type = File1 + Maximum Concurrent Jobs = 4 +} + + +# Definition of DLT tape storage device +#Storage { +# Name = DLTDrive +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon +# Device = "HP DLT 80" # must be same as Device in Storage daemon +# Media Type = DLT8000 # must be same as MediaType in Storage daemon +#} + +# Definition of DDS tape storage device +#Storage { +# Name = SDT-10000 +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon +# Device = SDT-10000 # must be same as Device in Storage daemon +# Media Type = DDS-4 # must be same as MediaType in Storage daemon +#} + +# Definition of 8mm tape storage device +#Storage { +# Name = "8mmDrive" +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +# Device = "Exabyte 8mm" +# MediaType = "8mm" +#} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +Messages { + Name = NoEmail + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + console = all, !skipped, !terminate +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/test-bacula-fd.conf.in b/regress/regress/scripts/test-bacula-fd.conf.in new file mode 100644 index 0000000000..47c44998da --- /dev/null +++ b/regress/regress/scripts/test-bacula-fd.conf.in @@ -0,0 +1,33 @@ +# +# Default Bacula File Daemon Configuration file +# +# For Bacula release 1.33 +# +# There is not much to change here except perhaps the +# File daemon Name to +# + +# +# List Directors who are permitted to contact this File daemon +# +Director { + Name = @hostname@-dir + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" +} + +# +# "Global" File daemon configuration specifications +# +FileDaemon { # this is me + Name = @hostname@-fd + FDPort = @fdport@ # where we listen for the director + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + SubSys Directory = "@subsysdir@" +} + +# Send all messages except skipped files back to Director +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/test-bacula-sd.conf.in b/regress/regress/scripts/test-bacula-sd.conf.in new file mode 100644 index 0000000000..7bb3b89dbe --- /dev/null +++ b/regress/regress/scripts/test-bacula-sd.conf.in @@ -0,0 +1,107 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.33 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# + +Device { + Name = FileStorage + Media Type = File + Archive Device = @tmpdir@ + LabelMedia = yes; # lets Bacula label unlabelled media + Random Access = Yes; + AutomaticMount = yes; # when device opened, read it + RemovableMedia = no; + AlwaysOpen = no; +# Maximum File Size = 10KB +} + +Device { + Name = FileStorage1 + Media Type = File1 + Archive Device = @tmpdir@ + LabelMedia = yes; # lets Bacula label unlabelled media + Random Access = Yes; + AutomaticMount = yes; # when device opened, read it + RemovableMedia = no; + AlwaysOpen = no; +} + + +#Device { +# Name = "HP DLT 80" +# Media Type = DLT8000 +# Archive Device = /dev/nst0 +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = yes; +# RemovableMedia = yes; +#} + +#Device { +# Name = SDT-7000 # +# Media Type = DDS-2 +# Archive Device = /dev/nst0 +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = yes; +# RemovableMedia = yes; +#} + +#Device { +# Name = Floppy +# Media Type = Floppy +# Archive Device = /mnt/floppy +# RemovableMedia = yes; +# Random Access = Yes; +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = no; +#} + +# +# A very old Exabyte with no end of media detection +# +#Device { +# Name = "Exabyte 8mm" +# Media Type = "8mm" +# Archive Device = /dev/nst0 +# Hardware end of medium = No; +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = Yes; +# RemovableMedia = yes; +#} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/test-console.conf.in b/regress/regress/scripts/test-console.conf.in new file mode 100644 index 0000000000..4211bcf138 --- /dev/null +++ b/regress/regress/scripts/test-console.conf.in @@ -0,0 +1,10 @@ +# +# Bacula User Agent (or Console) Configuration File +# + +Director { + Name = @hostname@-dir + DIRPort = @dirport@ + address = @hostname@ + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" +} diff --git a/regress/regress/scripts/testa-bacula-dir.conf.in b/regress/regress/scripts/testa-bacula-dir.conf.in new file mode 100644 index 0000000000..ea19edc90d --- /dev/null +++ b/regress/regress/scripts/testa-bacula-dir.conf.in @@ -0,0 +1,147 @@ +# +# TestA Bacula Director Configuration file +# +# For Bacula release 1.30 (12 April 2003) -- redhat 7.3 +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 1 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + + +Job { + Name = "MultiVol" + Type = Backup + Client=@hostname@-fd + Level = Full + FileSet="Full Set" + Storage = File + Messages = Standard + Write Bootstrap = "@working_dir@/SmallVols.bsr" + Pool = SmallVols + SpoolData = yes +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=SHA1 } + File =<@tmpdir@/file-list + } +} + + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File +} + +Storage { + Name = File1 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage1 + Media Type = File1 +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate + + append = "@working_dir@/log" = all, !skipped +} + +Messages { + Name = NoEmail + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + console = all, !skipped, !terminate, !restored + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = SmallVols + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year + Maximum Volumes = 10 + MaximumVolumeBytes = 10M + LabelFormat = Small +} diff --git a/regress/regress/scripts/testb-bacula-dir.conf.in b/regress/regress/scripts/testb-bacula-dir.conf.in new file mode 100644 index 0000000000..fd046d6922 --- /dev/null +++ b/regress/regress/scripts/testb-bacula-dir.conf.in @@ -0,0 +1,151 @@ +# +# TestA Bacula Director Configuration file +# +# For Bacula release 2.2.x +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 20 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + + +Job { + Name = "MultiVol" + Type = Backup + Client=@hostname@-fd + Level = Full + FileSet="Full Set" + Storage = File + Messages = Standard + Write Bootstrap = "@working_dir@/SmallVols.bsr" + Pool = SmallVols + SpoolData = yes + Maximum Concurrent Jobs = 20 +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=SHA1 } + File =<@tmpdir@/file-list + } +} + + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 20 +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 20 +} + +Storage { + Name = File1 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage1 + Media Type = File1 + Maximum Concurrent Jobs = 20 +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate + + append = "@working_dir@/log" = all, !skipped +} + +Messages { + Name = NoEmail + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + console = all, !skipped, !terminate, !restored + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} + +Pool { + Name = SmallVols + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year + Maximum Volumes = 100 + MaximumVolumeBytes = 10M + LabelFormat = Small +} diff --git a/regress/regress/scripts/tls-CA.pem b/regress/regress/scripts/tls-CA.pem new file mode 100644 index 0000000000..dc8d89a319 --- /dev/null +++ b/regress/regress/scripts/tls-CA.pem @@ -0,0 +1,37 @@ +-----BEGIN CERTIFICATE----- +MIIGgDCCBGigAwIBAgIJAPstWIUjVRIaMA0GCSqGSIb3DQEBBQUAMGQxCzAJBgNV +BAYTAlVTMQswCQYDVQQIEwJNQTENMAsGA1UEBxMETm9uZTEPMA0GA1UEChMGQmFj +dWxhMQ8wDQYDVQQLEwZCYWN1bGExFzAVBgNVBAMTDkJhY3VsYSBUZXN0IENBMB4X +DTA3MDYyMjE5NDUwMFoXDTE3MDYxOTE5NDUwMFowZDELMAkGA1UEBhMCVVMxCzAJ +BgNVBAgTAk1BMQ0wCwYDVQQHEwROb25lMQ8wDQYDVQQKEwZCYWN1bGExDzANBgNV +BAsTBkJhY3VsYTEXMBUGA1UEAxMOQmFjdWxhIFRlc3QgQ0EwggIiMA0GCSqGSIb3 +DQEBAQUAA4ICDwAwggIKAoICAQC+AK26CEgZqYBx/IwyUTnKm+Tk1s+BdLNWsMul +dtzWmkdOQ0GRaduMwLKZmbRuj66d9wgJe86eNIFQrXCjX7bzM8fcI+D7Y+AQzb7E +yDM8VbJUZaKQ2+lxmEYnzMydwAY2kh0REDnZWH5bxC6Qmj6YNqp47o6Zy2xjtaUB +VwKvYyZBhYUIm8OFU4Uz5FCpuZiDFF+sKLW/nt+vwbUT5n2fKGCbt9/gxQWWn/mK +437u7FYZoIc9+6aG+U5hMo3ke/29gvdJGaZcRYnmJJCGv5wq2OMKiC2DITVSjLsd +zpj/vyuBsMOSX367REXxeH0D93OpGiZCIveb+/T/xHt2gswhJ8Ol0i1AS1ZHtI4S +8Ab5DmzPXDF4Mb4N+f4fbsIgfKwNnjpK+P7cMerdkpN2TSDq6rPJtdv5HUm96bIg +TTF5LPA+nqFiIg0s8ajhKYjIt7TDhNi6p6x3BI7xdftIBJsiq3t9ysP5FWvqN6bG +kRHJ26SfFBYYNlkrofu2foWEKpvaZ77BVr6m+ipFaXFz9lNkSpiCBRHTVRssucqx +tP7V2Rs+z/EpG86YHOU7USVtH+StAa2DCoRAfnMajtONgMKLmlzIM1uJGFMODIky +dHyCSPW1fFg7pMmrCD45LBP73mkRQlglz6yj7GVSTtuNjXoqZqDhTwxJgySGSIFF +1aZTkwIDAQABo4IBMzCCAS8wHQYDVR0OBBYEFLsxDK6LGoRTryLHNTFrjgyg+sqW +MIGWBgNVHSMEgY4wgYuAFLsxDK6LGoRTryLHNTFrjgyg+sqWoWikZjBkMQswCQYD +VQQGEwJVUzELMAkGA1UECBMCTUExDTALBgNVBAcTBE5vbmUxDzANBgNVBAoTBkJh +Y3VsYTEPMA0GA1UECxMGQmFjdWxhMRcwFQYDVQQDEw5CYWN1bGEgVGVzdCBDQYIJ +APstWIUjVRIaMA8GA1UdEwEB/wQFMAMBAf8wEQYJYIZIAYb4QgEBBAQDAgAHMAkG +A1UdEgQCMAAwKwYJYIZIAYb4QgENBB4WHFRpbnlDQSBHZW5lcmF0ZWQgQ2VydGlm +aWNhdGUwCQYDVR0RBAIwADAOBgNVHQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQAD +ggIBAKdXd3w5fz3tjYyPUK4wWRsd4qUbgsmkYEPXmND8tDjPfS3OFCon0YGqjr5I +7kArgr8Mzea4a58qB8ELqZn4w50rSXXShhSe6GKsdpBwztsPolJ2b4La2YKOBuhb +bSYJANWiftv3R6Kkdq9uJoQ6rXUy0o7yj8JBcxAsa1U/o6FpzY4EyHxyOc89U8nR +QJ4/EfiDejTugNvLi1cPvhevuQKUpELiRmYgsA4LPTmxPwNlhYDyHkHov2MyU211 +Vt5eW5hCOOcqC9YE/VfhnFguKizlfkvsMnNW2Wt58PYK11sPmoVEXykGuQL3Eec9 ++H7NZ3ryIG1j8IJpqfE4Q/H1h2I5kY7TQhp2wiJGB6ixYyDvobqOAH8nEqpUYw5s +8W+jbYkLtJzQIp7MZO4Y81HKEEFlpYpFEaTbk7jzb7QMbBU7R5NpKXKqPP+olGV3 +2timrxrqT2erB9CTGFfub5KU2LmVbG3XBh/+lrLZLa0Vfy9wEEGEjfx9AnBYc7jL +F0nL5EcNEi+JNimL5aV0Xrv9+OjDzggNSqPuNKPtmgHmBNkLPDgjvcKR9BdDbtak +stFwSGJksIexIyNp4+E40q/+n3Zy3aAYaU5JRl8bgVQUNhCv7E6RWAxvEAPECNQg +W+F1zG+wllHGaJh8c0QprjBuf+dY6a0QSr0+922pXTYWsYta +-----END CERTIFICATE----- diff --git a/regress/regress/scripts/tls-bacula-dir.conf.in b/regress/regress/scripts/tls-bacula-dir.conf.in new file mode 100644 index 0000000000..451f8166e2 --- /dev/null +++ b/regress/regress/scripts/tls-bacula-dir.conf.in @@ -0,0 +1,379 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39 or later +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData=yes +} + +Job { + Name = "MonsterSave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File1 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "SparseTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "CompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="CompressedSet" + Storage = File + Messages = Standard + Pool = Default + Maximum Concurrent Jobs = 4 + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "SparseCompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseCompressedSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "FIFOTest" + Type = Backup + Client=@hostname@-fd + FileSet="FIFOSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + ClientRunBeforeJob = "/bin/sleep 60" +} + + + +# Backup the catalog database (after the nightly save) +Job { + Name = "BackupCatalog" + Type = Backup + Client=@hostname@-fd + FileSet="Catalog" +# Schedule = "WeeklyCycleAfterBackup" + Storage = File + Messages = Standard + Pool = Default + # This creates an ASCII copy of the catalog + RunBeforeJob = "@sbindir@/make_catalog_backup -u regress" + # This deletes the copy of the catalog + RunAfterJob = "@sbindir@/delete_catalog_backup" + Write Bootstrap = "@working_dir@/BackupCatalog.bsr" +} + +JobDefs { + Name = "BackupJob" + Type = Backup + Pool = Default + Storage = File + Messages = Standard + Priority = 10 +} + +Job { + JobDefs = "BackupJob" + Name = "bug621-job-1" + Client = @hostname@-fd + FileSet="Full Set" + ClientRunBeforeJob = "/bin/sleep 60" +} + +Job { + JobDefs = "BackupJob" + Name = "bug621-job-2" + Client = @hostname@-fd + FileSet = "Full Set" + Max Run Time = 30 + Priority = 15 +} + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "SparseSet" + Include { + Options { + signature=MD5 + sparse=yes + } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "CompressedSet" + Include { + Options { + signature=MD5 + compression=GZIP + } + File = <@tmpdir@/file-list + } +} + +FileSet { + Name = "FIFOSet" + Include { + Options { + readfifo = yes + signature=MD5 + } + File = <@tmpdir@/file-list + } +} + + +FileSet { + Name = "SparseCompressedSet" + Include { + Options { + signature=MD5 + compression=GZIP + sparse=yes + } + File = <@tmpdir@/file-list + } +} + + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Level=Full 1st sun at 1:05 + Run = Level=Differential 2nd-5th sun at 1:05 + Run = Level=Incremental mon-sat at 1:05 +} + +# This schedule does the catalog. It starts after the WeeklyCycle +Schedule { + Name = "WeeklyCycleAfterBackup" + Run = Level=Full sun-sat at 1:10 +} + +# This is the backup of the catalog +FileSet { + Name = "Catalog" + Include { + Options { + signature=MD5 + } + File = /home/kern/bacula/regress/bin/working/bacula.sql + } +} + +# Client (File Services) to backup +Client { + Name = @hostname@-fd + Address = @hostname@ + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" # password for FileDaemon + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 + TLS Require = yes + TLS Certificate = "@scriptdir@/tls-cert.pem" + TLS Key = "@scriptdir@/tls-cert.pem" + TLS CA Certificate File = "@scriptdir@/tls-CA.pem" +} + +# Definiton of file storage device +Storage { + Name = File + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage + Media Type = File + Maximum Concurrent Jobs = 4 + TLS Require = yes + TLS Certificate = "@scriptdir@/tls-cert.pem" + TLS Key = "@scriptdir@/tls-cert.pem" + TLS CA Certificate File = "@scriptdir@/tls-CA.pem" +} + +Storage { + Name = File1 + Address = @hostname@ # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + Device = FileStorage1 + Media Type = File1 + Maximum Concurrent Jobs = 4 + TLS Require = yes + TLS Certificate = "@scriptdir@/tls-cert.pem" + TLS Key = "@scriptdir@/tls-cert.pem" + TLS CA Certificate File = "@scriptdir@/tls-CA.pem" +} + + +# Definition of DLT tape storage device +#Storage { +# Name = DLTDrive +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon +# Device = "HP DLT 80" # must be same as Device in Storage daemon +# Media Type = DLT8000 # must be same as MediaType in Storage daemon +#} + +# Definition of DDS tape storage device +#Storage { +# Name = SDT-10000 +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon +# Device = SDT-10000 # must be same as Device in Storage daemon +# Media Type = DDS-4 # must be same as MediaType in Storage daemon +#} + +# Definition of 8mm tape storage device +#Storage { +# Name = "8mmDrive" +# Address = @hostname@ # N.B. Use a fully qualified name here +# SDPort = @sdport@ +# Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +# Device = "Exabyte 8mm" +# MediaType = "8mm" +#} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +Messages { + Name = NoEmail + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + console = all, !skipped, !terminate +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +# Label Format = "TEST-${Year}-${Month:p/2/0/r}-${Day:p/2/0/r}:${NumVols}" +} diff --git a/regress/regress/scripts/tls-bacula-fd.conf.in b/regress/regress/scripts/tls-bacula-fd.conf.in new file mode 100644 index 0000000000..c489a0e536 --- /dev/null +++ b/regress/regress/scripts/tls-bacula-fd.conf.in @@ -0,0 +1,41 @@ +# +# Default Bacula File Daemon Configuration file +# +# For Bacula release 2.0 +# +# There is not much to change here except perhaps the +# File daemon Name to +# + +# +# List Directors who are permitted to contact this File daemon +# +Director { + Name = @hostname@-dir + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" + TLS Require = yes + TLS Certificate = "@scriptdir@/tls-cert.pem" + TLS Key = "@scriptdir@/tls-cert.pem" + TLS CA Certificate File = "@scriptdir@/tls-CA.pem" +} + +# +# "Global" File daemon configuration specifications +# +FileDaemon { # this is me + Name = @hostname@-fd + FDPort = @fdport@ # where we listen for the director + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + SubSys Directory = "@subsysdir@" + TLS Require = yes + TLS Certificate = "@scriptdir@/tls-cert.pem" + TLS Key = "@scriptdir@/tls-cert.pem" + TLS CA Certificate File = "@scriptdir@/tls-CA.pem" +} + +# Send all messages except skipped files back to Director +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/tls-bacula-sd.conf.in b/regress/regress/scripts/tls-bacula-sd.conf.in new file mode 100644 index 0000000000..c7fe86d621 --- /dev/null +++ b/regress/regress/scripts/tls-bacula-sd.conf.in @@ -0,0 +1,115 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.33 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = @hostname@-sd + SDPort = @sdport@ # Director's port + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + Subsys Directory = "@subsysdir@" + TLS Require = yes + TLS Certificate = "@scriptdir@/tls-cert.pem" + TLS Key = "@scriptdir@/tls-cert.pem" + TLS CA Certificate File = "@scriptdir@/tls-CA.pem" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = @hostname@-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" + TLS Require = yes + TLS Certificate = "@scriptdir@/tls-cert.pem" + TLS Key = "@scriptdir@/tls-cert.pem" + TLS CA Certificate File = "@scriptdir@/tls-CA.pem" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# + +Device { + Name = FileStorage + Media Type = File + Archive Device = @tmpdir@ + LabelMedia = yes; # lets Bacula label unlabelled media + Random Access = Yes; + AutomaticMount = yes; # when device opened, read it + RemovableMedia = no; + AlwaysOpen = no; +# Maximum File Size = 10KB +} + +Device { + Name = FileStorage1 + Media Type = File1 + Archive Device = @tmpdir@ + LabelMedia = yes; # lets Bacula label unlabelled media + Random Access = Yes; + AutomaticMount = yes; # when device opened, read it + RemovableMedia = no; + AlwaysOpen = no; +} + + +#Device { +# Name = "HP DLT 80" +# Media Type = DLT8000 +# Archive Device = /dev/nst0 +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = yes; +# RemovableMedia = yes; +#} + +#Device { +# Name = SDT-7000 # +# Media Type = DDS-2 +# Archive Device = /dev/nst0 +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = yes; +# RemovableMedia = yes; +#} + +#Device { +# Name = Floppy +# Media Type = Floppy +# Archive Device = /mnt/floppy +# RemovableMedia = yes; +# Random Access = Yes; +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = no; +#} + +# +# A very old Exabyte with no end of media detection +# +#Device { +# Name = "Exabyte 8mm" +# Media Type = "8mm" +# Archive Device = /dev/nst0 +# Hardware end of medium = No; +# AutomaticMount = yes; # when device opened, read it +# AlwaysOpen = Yes; +# RemovableMedia = yes; +#} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/scripts/tls-cert.pem b/regress/regress/scripts/tls-cert.pem new file mode 100644 index 0000000000..18c7ce6376 --- /dev/null +++ b/regress/regress/scripts/tls-cert.pem @@ -0,0 +1,357 @@ +Certificate: + Data: + Version: 3 (0x2) + Serial Number: 1 (0x1) + Signature Algorithm: sha1WithRSAEncryption + Issuer: C=US, ST=MA, L=None, O=Bacula, OU=Bacula, CN=Bacula Test CA + Validity + Not Before: Jun 22 19:47:20 2007 GMT + Not After : Jun 19 19:47:20 2017 GMT + Subject: C=US, ST=MA, L=None, O=Bacula, OU=Bacula, CN=localhost + Subject Public Key Info: + Public Key Algorithm: rsaEncryption + RSA Public Key: (4096 bit) + Modulus (4096 bit): + 00:a5:f2:48:4b:63:fa:be:37:59:46:14:58:82:32: + fd:af:25:64:58:55:93:c8:0e:b5:45:c5:72:05:14: + 07:80:4d:da:d9:73:66:b1:e8:6c:f0:cf:d6:55:dd: + a1:2d:2e:bb:c8:99:af:6a:99:bd:8d:cd:aa:f6:ca: + b5:64:5c:58:c6:c3:c2:dc:a1:86:7c:b3:b0:ee:da: + f2:a1:3a:c2:a7:1d:83:7b:d7:9a:a8:30:97:fc:c0: + 66:2d:0e:b9:c6:38:d9:91:ff:d9:be:5f:0d:5c:90: + 1c:78:82:bc:65:5b:3a:12:8d:ac:95:a5:cc:f8:f7: + 74:99:0b:95:1b:34:7d:7f:81:ac:75:f2:e7:af:d4: + e6:29:fd:51:2f:c1:42:cc:95:ef:df:79:7b:c8:66: + 30:aa:c9:ba:70:38:cf:b9:68:cf:e6:45:ec:1d:8d: + 6b:a1:a8:f5:93:a7:fb:ae:e9:b0:f6:0f:99:46:27: + aa:d5:7f:24:0f:a9:ac:85:d4:b8:e2:63:e2:dc:4f: + a3:3b:86:f8:3b:61:42:de:58:03:d6:8c:06:e2:f7: + 18:cb:e7:c5:ce:97:88:ac:08:5b:0a:fc:54:af:6a: + a6:dd:9a:94:da:85:bd:06:e9:ec:fe:73:36:9a:bf: + 1d:fb:6e:1b:2a:de:f7:09:33:f8:a8:3d:58:29:44: + f9:a9:1c:0f:58:85:3b:fb:62:aa:be:fc:97:17:82: + 25:c7:5a:d4:71:d6:7f:30:3d:c8:8b:f6:f8:5f:05: + c6:b6:d0:31:ac:a4:ae:47:3c:0e:4d:b4:28:6b:4b: + 3c:a2:01:df:37:bb:18:8c:3b:15:53:fd:d9:0a:a9: + bd:12:59:9c:59:b0:c9:d9:af:1f:2f:19:cf:dd:63: + 42:09:83:fc:98:5c:76:68:bd:af:f5:71:b2:b7:63: + 34:47:ed:89:74:73:fd:e2:33:4e:e6:1d:7e:cb:27: + d2:2a:94:a7:07:d1:5d:e2:b8:73:78:4a:6f:5f:9f: + 9c:9a:d3:fa:4f:4b:b0:19:82:0a:b9:39:62:81:ef: + 7d:9b:0e:ab:69:18:70:33:80:f1:91:87:ba:4a:23: + ba:1b:2a:8b:d0:34:cc:11:e9:b0:d2:73:1d:12:7d: + 3d:a3:3e:86:3c:9c:15:7c:40:92:3f:20:b4:61:d9: + 39:65:a5:c9:e3:6e:de:fe:fe:0e:61:42:2f:cf:93: + 9e:fa:05:06:75:2e:53:11:8e:e4:1c:5f:ad:89:4d: + 60:e3:98:2c:c0:60:83:9d:b2:02:06:62:ff:fe:7b: + de:62:9e:65:f7:e1:ab:03:36:c9:8c:b1:4f:50:6d: + ab:20:78:63:f5:1e:be:db:88:b7:82:bb:34:de:da: + 37:23:8f + Exponent: 65537 (0x10001) + X509v3 extensions: + X509v3 Basic Constraints: + CA:FALSE + Netscape Cert Type: + SSL Client, SSL Server + Netscape Comment: + TinyCA Generated Certificate + X509v3 Subject Key Identifier: + EC:89:89:35:40:56:8B:D7:59:A6:6B:EA:FF:23:16:3A:C4:15:AA:48 + X509v3 Authority Key Identifier: + keyid:BB:31:0C:AE:8B:1A:84:53:AF:22:C7:35:31:6B:8E:0C:A0:FA:CA:96 + DirName:/C=US/ST=MA/L=None/O=Bacula/OU=Bacula/CN=Bacula Test CA + serial:FB:2D:58:85:23:55:12:1A + + X509v3 Issuer Alternative Name: + + + X509v3 Subject Alternative Name: + + + Signature Algorithm: sha1WithRSAEncryption + 22:f3:34:b8:be:3e:d4:6b:9a:6e:86:d2:e1:bd:72:a8:51:45: + ed:f9:d3:1a:b7:41:81:d1:fa:e8:42:c3:a9:6c:95:7b:1f:3f: + e3:e8:fa:43:25:ee:38:78:52:e0:29:61:50:57:ff:89:32:b8: + e8:83:5d:63:ea:33:f2:7e:d5:8d:42:0d:0f:06:ae:b4:1d:77: + 4c:44:47:17:48:ac:f9:59:0e:4b:d4:e3:28:ca:67:4e:5d:e8: + 76:dd:a6:fc:50:43:46:76:d8:60:fb:84:98:d0:59:99:e7:29: + 2f:c1:8f:4b:4a:32:da:e1:d8:0a:ec:39:62:1f:39:4c:99:8f: + 74:e4:b7:b8:df:c4:0f:5c:5c:8e:3a:2c:0e:72:c2:fd:68:7c: + 44:eb:87:fe:c1:55:2b:b6:ac:8b:f5:45:8c:07:fa:da:80:b5: + 66:51:1c:1b:c9:54:13:45:b5:a9:15:01:c3:16:44:e5:f8:d4: + 58:d6:e8:44:68:ba:4f:c5:fa:ac:cf:06:e0:fc:9b:5f:25:96: + ce:d3:1e:29:5d:97:ce:48:92:3c:e9:93:5a:6c:12:11:63:5d: + f0:78:08:60:06:12:c9:47:cc:77:bb:e6:13:8e:3a:ac:b0:39: + 39:e8:79:ca:fa:14:85:1a:f3:8e:a6:02:17:fb:12:29:d6:d8: + e7:19:dc:35:47:c9:b9:e3:f6:00:a3:04:f9:b0:e4:83:fb:ea: + b5:17:cd:bc:ab:db:bf:88:aa:a7:90:ea:e4:1c:3b:bd:47:ff: + 2d:8b:9b:36:ee:e6:a6:77:95:52:ae:95:02:84:ff:ca:57:f2: + c7:52:d4:68:76:46:44:6d:51:4f:5f:2e:05:d7:fc:8c:6d:8c: + b2:6c:aa:fc:ca:c8:6f:3c:23:b5:fa:a3:11:2b:62:1a:65:a3: + 9d:46:ed:40:5e:e3:a8:3a:85:a8:65:62:05:8d:1c:07:47:6a: + 51:0c:f7:cd:cc:54:6e:4e:74:e0:0b:a7:56:63:fa:8e:bf:5d: + 95:4e:4b:c0:61:64:ee:10:82:75:69:2e:66:81:cc:e3:ec:c9: + aa:e2:5f:03:d6:5b:16:c6:66:20:a4:90:6a:4b:49:04:c3:ec: + 53:03:18:51:17:d7:48:b5:f9:db:8e:1a:e7:7b:7f:0e:83:79: + 5c:36:76:0d:04:54:a7:f2:e9:8f:2e:51:de:79:81:aa:3b:e4: + 48:00:65:33:cf:af:ce:dd:63:81:fa:63:cf:79:0c:6b:45:a3: + 21:0e:ee:4a:ed:27:a8:6a:21:3f:b1:6f:e1:f0:ae:81:6c:dc: + 38:53:9f:2c:b7:d1:65:86:0a:5d:7b:14:38:6c:e2:89:2d:5d: + 22:05:91:41:89:0e:bd:2c +-----BEGIN CERTIFICATE----- +MIIGXTCCBEWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJVUzEL +MAkGA1UECBMCTUExDTALBgNVBAcTBE5vbmUxDzANBgNVBAoTBkJhY3VsYTEPMA0G +A1UECxMGQmFjdWxhMRcwFQYDVQQDEw5CYWN1bGEgVGVzdCBDQTAeFw0wNzA2MjIx +OTQ3MjBaFw0xNzA2MTkxOTQ3MjBaMF8xCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJN +QTENMAsGA1UEBxMETm9uZTEPMA0GA1UEChMGQmFjdWxhMQ8wDQYDVQQLEwZCYWN1 +bGExEjAQBgNVBAMTCWxvY2FsaG9zdDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCC +AgoCggIBAKXySEtj+r43WUYUWIIy/a8lZFhVk8gOtUXFcgUUB4BN2tlzZrHobPDP +1lXdoS0uu8iZr2qZvY3NqvbKtWRcWMbDwtyhhnyzsO7a8qE6wqcdg3vXmqgwl/zA +Zi0OucY42ZH/2b5fDVyQHHiCvGVbOhKNrJWlzPj3dJkLlRs0fX+BrHXy56/U5in9 +US/BQsyV7995e8hmMKrJunA4z7loz+ZF7B2Na6Go9ZOn+67psPYPmUYnqtV/JA+p +rIXUuOJj4txPozuG+DthQt5YA9aMBuL3GMvnxc6XiKwIWwr8VK9qpt2alNqFvQbp +7P5zNpq/HftuGyre9wkz+Kg9WClE+akcD1iFO/tiqr78lxeCJcda1HHWfzA9yIv2 ++F8FxrbQMaykrkc8Dk20KGtLPKIB3ze7GIw7FVP92QqpvRJZnFmwydmvHy8Zz91j +QgmD/Jhcdmi9r/VxsrdjNEftiXRz/eIzTuYdfssn0iqUpwfRXeK4c3hKb1+fnJrT ++k9LsBmCCrk5YoHvfZsOq2kYcDOA8ZGHukojuhsqi9A0zBHpsNJzHRJ9PaM+hjyc +FXxAkj8gtGHZOWWlyeNu3v7+DmFCL8+TnvoFBnUuUxGO5BxfrYlNYOOYLMBgg52y +AgZi//573mKeZffhqwM2yYyxT1BtqyB4Y/UevtuIt4K7NN7aNyOPAgMBAAGjggEd +MIIBGTAJBgNVHRMEAjAAMBEGCWCGSAGG+EIBAQQEAwIGwDArBglghkgBhvhCAQ0E +HhYcVGlueUNBIEdlbmVyYXRlZCBDZXJ0aWZpY2F0ZTAdBgNVHQ4EFgQU7ImJNUBW +i9dZpmvq/yMWOsQVqkgwgZYGA1UdIwSBjjCBi4AUuzEMrosahFOvIsc1MWuODKD6 +ypahaKRmMGQxCzAJBgNVBAYTAlVTMQswCQYDVQQIEwJNQTENMAsGA1UEBxMETm9u +ZTEPMA0GA1UEChMGQmFjdWxhMQ8wDQYDVQQLEwZCYWN1bGExFzAVBgNVBAMTDkJh +Y3VsYSBUZXN0IENBggkA+y1YhSNVEhowCQYDVR0SBAIwADAJBgNVHREEAjAAMA0G +CSqGSIb3DQEBBQUAA4ICAQAi8zS4vj7Ua5puhtLhvXKoUUXt+dMat0GB0froQsOp +bJV7Hz/j6PpDJe44eFLgKWFQV/+JMrjog11j6jPyftWNQg0PBq60HXdMREcXSKz5 +WQ5L1OMoymdOXeh23ab8UENGdthg+4SY0FmZ5ykvwY9LSjLa4dgK7DliHzlMmY90 +5Le438QPXFyOOiwOcsL9aHxE64f+wVUrtqyL9UWMB/ragLVmURwbyVQTRbWpFQHD +FkTl+NRY1uhEaLpPxfqszwbg/JtfJZbO0x4pXZfOSJI86ZNabBIRY13weAhgBhLJ +R8x3u+YTjjqssDk56HnK+hSFGvOOpgIX+xIp1tjnGdw1R8m54/YAowT5sOSD++q1 +F828q9u/iKqnkOrkHDu9R/8ti5s27uamd5VSrpUChP/KV/LHUtRodkZEbVFPXy4F +1/yMbYyybKr8yshvPCO1+qMRK2IaZaOdRu1AXuOoOoWoZWIFjRwHR2pRDPfNzFRu +TnTgC6dWY/qOv12VTkvAYWTuEIJ1aS5mgczj7Mmq4l8D1lsWxmYgpJBqS0kEw+xT +AxhRF9dItfnbjhrne38Og3lcNnYNBFSn8umPLlHeeYGqO+RIAGUzz6/O3WOB+mPP +eQxrRaMhDu5K7SeoaiE/sW/h8K6BbNw4U58st9FlhgpdexQ4bOKJLV0iBZFBiQ69 +LA== +-----END CERTIFICATE----- +Private-Key: (4096 bit) +modulus: + 00:a5:f2:48:4b:63:fa:be:37:59:46:14:58:82:32: + fd:af:25:64:58:55:93:c8:0e:b5:45:c5:72:05:14: + 07:80:4d:da:d9:73:66:b1:e8:6c:f0:cf:d6:55:dd: + a1:2d:2e:bb:c8:99:af:6a:99:bd:8d:cd:aa:f6:ca: + b5:64:5c:58:c6:c3:c2:dc:a1:86:7c:b3:b0:ee:da: + f2:a1:3a:c2:a7:1d:83:7b:d7:9a:a8:30:97:fc:c0: + 66:2d:0e:b9:c6:38:d9:91:ff:d9:be:5f:0d:5c:90: + 1c:78:82:bc:65:5b:3a:12:8d:ac:95:a5:cc:f8:f7: + 74:99:0b:95:1b:34:7d:7f:81:ac:75:f2:e7:af:d4: + e6:29:fd:51:2f:c1:42:cc:95:ef:df:79:7b:c8:66: + 30:aa:c9:ba:70:38:cf:b9:68:cf:e6:45:ec:1d:8d: + 6b:a1:a8:f5:93:a7:fb:ae:e9:b0:f6:0f:99:46:27: + aa:d5:7f:24:0f:a9:ac:85:d4:b8:e2:63:e2:dc:4f: + a3:3b:86:f8:3b:61:42:de:58:03:d6:8c:06:e2:f7: + 18:cb:e7:c5:ce:97:88:ac:08:5b:0a:fc:54:af:6a: + a6:dd:9a:94:da:85:bd:06:e9:ec:fe:73:36:9a:bf: + 1d:fb:6e:1b:2a:de:f7:09:33:f8:a8:3d:58:29:44: + f9:a9:1c:0f:58:85:3b:fb:62:aa:be:fc:97:17:82: + 25:c7:5a:d4:71:d6:7f:30:3d:c8:8b:f6:f8:5f:05: + c6:b6:d0:31:ac:a4:ae:47:3c:0e:4d:b4:28:6b:4b: + 3c:a2:01:df:37:bb:18:8c:3b:15:53:fd:d9:0a:a9: + bd:12:59:9c:59:b0:c9:d9:af:1f:2f:19:cf:dd:63: + 42:09:83:fc:98:5c:76:68:bd:af:f5:71:b2:b7:63: + 34:47:ed:89:74:73:fd:e2:33:4e:e6:1d:7e:cb:27: + d2:2a:94:a7:07:d1:5d:e2:b8:73:78:4a:6f:5f:9f: + 9c:9a:d3:fa:4f:4b:b0:19:82:0a:b9:39:62:81:ef: + 7d:9b:0e:ab:69:18:70:33:80:f1:91:87:ba:4a:23: + ba:1b:2a:8b:d0:34:cc:11:e9:b0:d2:73:1d:12:7d: + 3d:a3:3e:86:3c:9c:15:7c:40:92:3f:20:b4:61:d9: + 39:65:a5:c9:e3:6e:de:fe:fe:0e:61:42:2f:cf:93: + 9e:fa:05:06:75:2e:53:11:8e:e4:1c:5f:ad:89:4d: + 60:e3:98:2c:c0:60:83:9d:b2:02:06:62:ff:fe:7b: + de:62:9e:65:f7:e1:ab:03:36:c9:8c:b1:4f:50:6d: + ab:20:78:63:f5:1e:be:db:88:b7:82:bb:34:de:da: + 37:23:8f +publicExponent: 65537 (0x10001) +privateExponent: + 21:ff:a0:86:29:a6:ae:a0:02:5f:54:3d:c9:f7:0e: + 78:7a:cd:b3:37:5d:3e:a8:9c:c4:fd:ad:dd:92:7b: + f2:f2:80:7a:fa:a4:b8:a0:68:e9:71:7b:75:3e:22: + 0e:72:bb:b0:5e:a4:4c:cf:d0:c1:23:b8:fa:35:0f: + b2:cf:24:b5:1c:58:69:01:82:df:3b:a5:6d:5a:58: + 49:66:13:89:4f:87:a7:b0:c5:93:dd:d8:d5:c4:c9: + 6a:43:d1:15:e6:81:d4:e2:b9:46:c2:8c:a7:41:33: + 44:11:6c:ed:cb:21:fb:b9:20:f9:cb:ed:51:b8:c9: + 1f:ad:fa:cf:87:12:8b:34:13:14:5b:3e:d2:8c:68: + d7:83:79:c5:b1:ef:b0:a0:ab:73:7a:9d:3c:b2:8b: + 18:02:9a:7a:f1:78:c5:80:ce:cf:5b:d6:03:3b:fd: + 28:32:c8:95:86:de:0e:b8:fc:33:7d:80:a6:99:eb: + eb:2f:d0:40:91:3f:b2:6f:a1:ad:68:4f:8b:59:99: + 94:d1:93:3b:ff:32:47:01:7b:4f:d2:82:7a:af:ab: + 59:e3:53:68:7f:2d:56:29:a4:15:7d:1b:10:91:66: + 3c:92:b6:1a:8b:39:ee:17:b1:21:74:93:64:62:f1: + 8e:98:c1:62:28:2a:2e:ad:82:2d:5d:dc:19:20:73: + 91:b8:97:f4:d2:4f:43:bb:6c:19:ef:2b:f9:21:27: + 1d:3f:c8:93:35:84:1c:43:fb:c2:2f:3b:67:ea:71: + 84:a5:f5:12:9e:e0:fd:2f:c4:5f:6c:51:07:15:77: + 92:1d:89:77:2b:8c:44:20:d5:cb:22:d9:c2:09:02: + 80:44:0f:c1:74:f2:6e:a8:0f:09:30:78:03:f5:87: + 04:93:c1:64:81:ef:c6:78:39:64:de:06:fb:55:d9: + a0:b8:29:bb:09:19:cc:56:45:18:b6:d2:38:9b:9e: + d6:da:eb:1c:9e:5a:e2:92:d8:ae:da:32:0f:71:21: + 38:af:a6:c7:d4:44:69:af:3d:b9:1e:64:c1:55:eb: + fb:ed:4c:37:0e:ff:4b:75:36:cd:66:23:e8:6a:11: + 20:02:15:30:c4:cd:46:3d:ec:95:e3:6c:a8:ee:ac: + 74:e3:11:18:6d:2f:d9:b1:81:a1:5f:69:e2:af:92: + cc:80:ea:a2:41:35:3b:d4:1c:c6:5c:77:3e:ff:51: + 8b:17:9b:65:25:22:a2:0a:12:4e:fc:b3:b6:67:1b: + 28:88:e5:33:f7:f5:b4:36:a1:46:1e:b7:e4:c4:88: + 2f:e8:ba:17:9b:06:59:bd:51:e2:4c:06:40:ea:09: + 0e:6b:8a:bb:bc:60:ca:70:05:ea:db:e5:30:7e:3d: + 92:91 +prime1: + 00:d5:26:49:52:d4:04:b6:43:66:da:7e:e1:16:a5: + 01:7b:38:18:08:ac:fe:ac:07:50:06:33:66:19:a3: + 90:47:d6:84:09:ab:f2:e3:00:45:40:d5:31:ab:17: + cc:52:28:71:f9:12:53:f2:42:03:cc:6b:e6:32:fe: + 37:7c:0d:36:d9:e3:90:5c:0d:43:67:01:4d:fd:c1: + 66:29:17:e9:b0:a3:d6:09:b7:5f:c1:14:7e:44:8f: + 9d:c0:04:a3:f9:db:25:e4:41:f6:64:31:5b:29:f9: + 16:bc:ec:72:b3:0b:36:28:fe:53:26:71:6d:16:f1: + 81:86:2a:b5:a1:64:05:b4:9e:d4:20:71:81:df:26: + de:79:d6:96:a6:9d:ed:99:cc:a6:25:c0:18:ed:74: + f7:14:0b:93:4f:d8:99:0b:26:10:e2:f2:85:71:1d: + 89:2d:b3:70:ad:48:4e:a3:92:f6:5c:a3:c0:ed:4b: + c7:67:15:8a:fd:80:36:9e:ef:14:be:90:6f:a9:b8: + 34:11:1e:60:50:3c:aa:be:3d:84:a5:0b:86:51:d8: + 85:e3:e0:f8:52:4a:bf:2d:f5:c3:01:d7:a4:5e:0d: + 7b:9b:3b:e7:71:b3:12:76:bc:4e:20:75:7d:74:83: + 2d:56:8a:aa:5c:d1:5c:8f:3d:61:52:8c:a6:99:f9: + 9c:97 +prime2: + 00:c7:4e:b1:4f:7f:d0:7d:77:5a:5b:d4:10:92:47: + 5b:7c:9f:84:12:5b:82:f5:e8:8b:8f:80:8f:7d:6e: + 75:af:94:8e:35:9f:8c:06:81:d6:2d:e0:be:ad:9c: + 71:ae:ce:88:cd:af:35:62:6e:c2:67:d2:e6:72:46: + 1a:b4:fc:73:74:d8:4c:ab:b6:c7:ba:f1:b5:b5:7c: + 2c:b6:16:3a:e0:70:82:31:1a:ac:50:34:30:99:b2: + 3f:7c:f5:60:68:f5:d8:81:96:1d:f5:ea:2b:df:1f: + bf:0f:7f:69:07:60:7a:b0:4d:b4:01:41:5a:53:6c: + 5b:1f:56:8a:69:55:a1:5f:e1:11:6c:7d:c5:27:e5: + fb:9b:bf:e6:58:74:ef:9e:89:23:57:bb:a5:1d:74: + 71:43:6a:b2:30:5b:44:56:a9:57:75:d8:37:87:9b: + de:35:16:60:5b:51:f9:bf:2d:2d:b5:d6:35:52:b4: + 3f:34:bf:d6:cb:f1:9c:17:f4:ca:a6:8f:1f:1d:ce: + db:48:e9:b0:13:00:03:c5:c1:e4:e8:82:f3:77:5b: + 25:ef:5e:20:28:1e:be:d2:57:c9:e4:06:dc:dd:07: + c9:01:07:65:51:37:3e:86:e6:1b:ec:ae:7c:f5:f4: + 19:b5:e4:d2:5a:6d:56:62:ec:b8:43:58:0a:1f:37: + 77:c9 +exponent1: + 7d:0b:13:f2:ea:7c:c5:2c:2f:77:b8:fd:75:9a:61: + 8f:16:ee:4a:90:aa:6a:e3:73:57:df:e9:62:db:28: + b6:6c:2b:53:bd:33:25:66:b0:3a:03:98:3a:c6:20: + 50:86:77:ae:65:c9:27:93:00:c5:78:fb:38:29:19: + 05:c6:7e:ca:3e:8d:1e:e3:8d:0a:2d:a2:c2:5e:25: + ff:af:8e:a1:d8:cb:a5:31:95:94:20:e0:9e:7a:1e: + 52:5a:a6:93:da:b3:94:ff:f9:7a:f7:d5:82:7f:25: + 8e:b9:ab:e4:4b:8c:7f:6a:0b:ff:be:84:ff:f3:b8: + 47:ac:60:97:88:a5:2c:3c:0d:37:e7:3f:08:59:b6: + 24:85:f6:25:52:fa:e3:c2:42:2a:5d:52:82:63:9e: + db:7c:9a:f4:39:9e:37:03:22:de:f0:e5:c5:e1:4c: + eb:a9:9c:4d:9b:e0:be:67:65:ee:1d:06:fe:6e:f9: + 51:09:3b:5b:d2:4e:b8:d8:8b:33:ec:6a:05:88:11: + cb:85:25:7d:8c:c9:a2:07:56:fc:b8:11:19:8c:cb: + a7:4f:00:7e:ce:68:ef:9e:80:c3:60:ed:85:5b:a5: + 8b:01:0e:9b:0e:31:a3:c4:7e:94:de:38:36:15:0a: + 90:fd:92:4a:17:6c:94:7f:ae:cb:8d:c5:e3:08:a3: + 8b +exponent2: + 02:a4:8b:7b:57:61:87:58:5e:cd:5a:e9:81:57:0a: + e2:83:26:f8:2b:58:78:34:46:2d:77:f1:ef:22:d8: + d2:a4:30:a2:8b:64:0a:ee:0b:cd:fd:ed:e9:55:6a: + b8:7b:aa:9a:b7:99:08:9e:19:5b:d1:13:17:2e:d0: + c9:d7:93:1c:58:85:e3:bc:ff:b6:fd:df:7f:f1:8e: + 92:37:87:3e:54:9f:95:51:1a:39:d2:07:56:f2:63: + 1f:20:0d:d0:36:7a:51:75:91:1e:22:a5:c4:46:a2: + 7c:ed:1e:92:67:78:19:00:5e:c3:a9:7f:2e:1e:00: + b3:50:ad:73:2a:1c:82:ad:f4:52:30:f4:bd:4b:b2: + 63:65:4f:03:9b:41:56:23:d1:61:27:6e:d0:0e:2c: + 36:4d:a2:e1:3b:44:93:b5:99:20:49:e6:aa:98:a9: + 80:a0:b4:54:61:a8:e3:1d:11:3f:19:01:0a:00:b3: + d9:da:35:59:ec:f1:39:ec:18:07:cf:5c:05:44:29: + ea:34:97:0e:19:70:f3:5d:57:d0:b1:73:d3:00:55: + 67:70:23:13:05:1d:58:a2:ab:5d:a7:ad:a4:0c:a7: + 60:a9:1d:71:cf:3e:b8:01:33:1b:97:50:b6:de:2e: + bd:17:b4:a6:58:4e:cd:ee:ff:9e:7c:fb:5d:60:99: + e9 +coefficient: + 71:03:d0:58:4f:25:8f:54:77:12:49:91:80:b4:e0: + ac:ae:c2:c4:8e:fb:69:64:bb:13:6e:5a:22:72:be: + 04:dc:ab:7b:a8:79:fb:e7:60:ea:0c:6b:40:1c:50: + 29:28:32:8f:e8:d5:fb:27:9b:c3:77:ba:2b:39:02: + 1a:a1:7a:d1:2d:4e:ab:76:4f:52:63:79:ba:43:64: + 61:7d:25:2a:33:1e:58:25:cc:79:35:8b:6a:84:d4: + 09:6d:d3:1e:73:79:54:23:14:72:1f:12:d8:c5:e2: + 2b:88:0a:28:f0:73:8c:b3:05:25:c4:04:fc:75:ee: + 8c:59:11:4d:33:02:d5:45:e2:17:d0:bb:20:78:fe: + a0:db:90:87:f8:f4:50:be:05:16:0a:6c:a8:85:21: + b9:3d:d6:a9:2c:2e:dd:91:c6:83:c6:b6:76:c8:e0: + 30:59:fe:a7:c8:76:e9:fa:dc:5e:4c:4e:db:ed:c6: + f3:13:f5:60:d9:86:62:69:e7:77:86:e7:59:d2:c5: + 1d:79:bd:a8:55:a3:69:22:ac:61:dd:ae:0e:f5:80: + e1:79:2d:a8:90:81:35:65:2f:e9:50:70:6d:92:fc: + 58:fa:82:3f:67:16:0d:d5:15:ea:22:d1:8a:1f:28: + 64:cb:fd:9d:f1:fb:2e:3c:10:06:bf:a3:9e:7f:c5: + b6 +-----BEGIN RSA PRIVATE KEY----- +MIIJJwIBAAKCAgEApfJIS2P6vjdZRhRYgjL9ryVkWFWTyA61RcVyBRQHgE3a2XNm +sehs8M/WVd2hLS67yJmvapm9jc2q9sq1ZFxYxsPC3KGGfLOw7tryoTrCpx2De9ea +qDCX/MBmLQ65xjjZkf/Zvl8NXJAceIK8ZVs6Eo2slaXM+Pd0mQuVGzR9f4GsdfLn +r9TmKf1RL8FCzJXv33l7yGYwqsm6cDjPuWjP5kXsHY1roaj1k6f7rumw9g+ZRieq +1X8kD6mshdS44mPi3E+jO4b4O2FC3lgD1owG4vcYy+fFzpeIrAhbCvxUr2qm3ZqU +2oW9Buns/nM2mr8d+24bKt73CTP4qD1YKUT5qRwPWIU7+2KqvvyXF4Ilx1rUcdZ/ +MD3Ii/b4XwXGttAxrKSuRzwOTbQoa0s8ogHfN7sYjDsVU/3ZCqm9ElmcWbDJ2a8f +LxnP3WNCCYP8mFx2aL2v9XGyt2M0R+2JdHP94jNO5h1+yyfSKpSnB9Fd4rhzeEpv +X5+cmtP6T0uwGYIKuTlige99mw6raRhwM4DxkYe6SiO6GyqL0DTMEemw0nMdEn09 +oz6GPJwVfECSPyC0Ydk5ZaXJ427e/v4OYUIvz5Oe+gUGdS5TEY7kHF+tiU1g45gs +wGCDnbICBmL//nveYp5l9+GrAzbJjLFPUG2rIHhj9R6+24i3grs03to3I48CAwEA +AQKCAgAh/6CGKaauoAJfVD3J9w54es2zN10+qJzE/a3dknvy8oB6+qS4oGjpcXt1 +PiIOcruwXqRMz9DBI7j6NQ+yzyS1HFhpAYLfO6VtWlhJZhOJT4ensMWT3djVxMlq +Q9EV5oHU4rlGwoynQTNEEWztyyH7uSD5y+1RuMkfrfrPhxKLNBMUWz7SjGjXg3nF +se+woKtzep08sosYApp68XjFgM7PW9YDO/0oMsiVht4OuPwzfYCmmevrL9BAkT+y +b6GtaE+LWZmU0ZM7/zJHAXtP0oJ6r6tZ41Nofy1WKaQVfRsQkWY8krYaiznuF7Eh +dJNkYvGOmMFiKCourYItXdwZIHORuJf00k9Du2wZ7yv5IScdP8iTNYQcQ/vCLztn +6nGEpfUSnuD9L8RfbFEHFXeSHYl3K4xEINXLItnCCQKARA/BdPJuqA8JMHgD9YcE +k8Fkge/GeDlk3gb7VdmguCm7CRnMVkUYttI4m57W2uscnlriktiu2jIPcSE4r6bH +1ERprz25HmTBVev77Uw3Dv9LdTbNZiPoahEgAhUwxM1GPeyV42yo7qx04xEYbS/Z +sYGhX2nir5LMgOqiQTU71BzGXHc+/1GLF5tlJSKiChJO/LO2ZxsoiOUz9/W0NqFG +HrfkxIgv6LoXmwZZvVHiTAZA6gkOa4q7vGDKcAXq2+Uwfj2SkQKCAQEA1SZJUtQE +tkNm2n7hFqUBezgYCKz+rAdQBjNmGaOQR9aECavy4wBFQNUxqxfMUihx+RJT8kID +zGvmMv43fA022eOQXA1DZwFN/cFmKRfpsKPWCbdfwRR+RI+dwASj+dsl5EH2ZDFb +KfkWvOxysws2KP5TJnFtFvGBhiq1oWQFtJ7UIHGB3ybeedaWpp3tmcymJcAY7XT3 +FAuTT9iZCyYQ4vKFcR2JLbNwrUhOo5L2XKPA7UvHZxWK/YA2nu8UvpBvqbg0ER5g +UDyqvj2EpQuGUdiF4+D4Ukq/LfXDAdekXg17mzvncbMSdrxOIHV9dIMtVoqqXNFc +jz1hUoymmfmclwKCAQEAx06xT3/QfXdaW9QQkkdbfJ+EEluC9eiLj4CPfW51r5SO +NZ+MBoHWLeC+rZxxrs6Iza81Ym7CZ9LmckYatPxzdNhMq7bHuvG1tXwsthY64HCC +MRqsUDQwmbI/fPVgaPXYgZYd9eor3x+/D39pB2B6sE20AUFaU2xbH1aKaVWhX+ER +bH3FJ+X7m7/mWHTvnokjV7ulHXRxQ2qyMFtEVqlXddg3h5veNRZgW1H5vy0ttdY1 +UrQ/NL/Wy/GcF/TKpo8fHc7bSOmwEwADxcHk6ILzd1sl714gKB6+0lfJ5Abc3QfJ +AQdlUTc+huYb7K589fQZteTSWm1WYuy4Q1gKHzd3yQKCAQB9CxPy6nzFLC93uP11 +mmGPFu5KkKpq43NX3+li2yi2bCtTvTMlZrA6A5g6xiBQhneuZcknkwDFePs4KRkF +xn7KPo0e440KLaLCXiX/r46h2MulMZWUIOCeeh5SWqaT2rOU//l699WCfyWOuavk +S4x/agv/voT/87hHrGCXiKUsPA035z8IWbYkhfYlUvrjwkIqXVKCY57bfJr0OZ43 +AyLe8OXF4UzrqZxNm+C+Z2XuHQb+bvlRCTtb0k642Isz7GoFiBHLhSV9jMmiB1b8 +uBEZjMunTwB+zmjvnoDDYO2FW6WLAQ6bDjGjxH6U3jg2FQqQ/ZJKF2yUf67LjcXj +CKOLAoIBAAKki3tXYYdYXs1a6YFXCuKDJvgrWHg0Ri138e8i2NKkMKKLZAruC839 +7elVarh7qpq3mQieGVvRExcu0MnXkxxYheO8/7b933/xjpI3hz5Un5VRGjnSB1by +Yx8gDdA2elF1kR4ipcRGonztHpJneBkAXsOpfy4eALNQrXMqHIKt9FIw9L1LsmNl +TwObQVYj0WEnbtAOLDZNouE7RJO1mSBJ5qqYqYCgtFRhqOMdET8ZAQoAs9naNVns +8TnsGAfPXAVEKeo0lw4ZcPNdV9Cxc9MAVWdwIxMFHViiq12nraQMp2CpHXHPPrgB +MxuXULbeLr0XtKZYTs3u/558+11gmekCggEAcQPQWE8lj1R3EkmRgLTgrK7CxI77 +aWS7E25aInK+BNyre6h5++dg6gxrQBxQKSgyj+jV+yebw3e6KzkCGqF60S1Oq3ZP +UmN5ukNkYX0lKjMeWCXMeTWLaoTUCW3THnN5VCMUch8S2MXiK4gKKPBzjLMFJcQE +/HXujFkRTTMC1UXiF9C7IHj+oNuQh/j0UL4FFgpsqIUhuT3WqSwu3ZHGg8a2dsjg +MFn+p8h26frcXkxO2+3G8xP1YNmGYmnnd4bnWdLFHXm9qFWjaSKsYd2uDvWA4Xkt +qJCBNWUv6VBwbZL8WPqCP2cWDdUV6iLRih8oZMv9nfH7LjwQBr+jnn/Ftg== +-----END RSA PRIVATE KEY----- diff --git a/regress/regress/scripts/win32-bacula-dir-tape.conf.in b/regress/regress/scripts/win32-bacula-dir-tape.conf.in new file mode 100644 index 0000000000..f14bb8e18e --- /dev/null +++ b/regress/regress/scripts/win32-bacula-dir-tape.conf.in @@ -0,0 +1,159 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39.23 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = localhost-dir + DIRPort = @dirport@ # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in @tmpdir@ +Job { + Name = "NightlySave" + Type = Backup + Client=Tibs + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +} + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=Tibs + FileSet="Full Set" + Storage = DDS-4 + Messages = Standard + Pool = Default + Where = @tmpdir@/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Enable VSS = yes + Include { Options { signature=MD5; portable=no + compression=GZIP } +# File = "c:/cygwin" # big + File = "c:/cygwin/home/kern/bacula/k" + } +} + + +# +# When to do the backups, full backup on first sunday of the month, +# differential (i.e. incremental since full) every other sunday, +# and incremental backups other days +Schedule { + Name = "WeeklyCycle" + Run = Full 1st sun at 1:05 + Run = Differential 2nd-5th sun at 1:05 + Run = Incremental mon-sat at 1:05 +} + +# Client (File Services) to backup +Client { + Name = Tibs + Address = tibs + FDPort = 9102 + Catalog = MyCatalog + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + +Client { + Name = localhost-fd + Address = localhost + FDPort = @fdport@ + Catalog = MyCatalog + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" + File Retention = 30d # 30 days + Job Retention = 180d # six months + AutoPrune = yes # Prune expired Jobs/Files + Maximum Concurrent Jobs = 4 +} + + +# Definition of DDS tape storage device +Storage { + Name = DDS-4 + Address = 192.168.68.112 # N.B. Use a fully qualified name here + SDPort = @sdport@ + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" # password for Storage daemon + Device = DDS-4 # must be same as Device in Storage daemon + Media Type = DDS-4 # must be same as MediaType in Storage daemon + AutoChanger = yes + Maximum Concurrent Jobs = 4 +} + + +# Generic catalog service +Catalog { + Name = MyCatalog + dbname = regress; user = regress; password = "" +} + +# Reasonable message delivery -- send most everything to email address +# and to the console +Messages { + Name = Standard + mailcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: %t %e of %c %l\" %r" + operatorcommand = "@sbindir@/bsmtp -h localhost -f \"\(Bacula regression\) %r\" -s \"Regression: Intervention needed for %j\" %r" + MailOnError = @job_email@ = all, !terminate + operator = @job_email@ = mount + console = all, !skipped, !terminate, !restored +# +# WARNING! the following will create a file that you must cycle from +# time to time as it will grow indefinitely. However, it will +# also keep all your messages if the scroll off the console. +# + append = "@working_dir@/log" = all, !skipped +} + +# +# Message delivery for daemon messages (no job). +Messages { + Name = Daemon + mailcommand = "@sbindir@/bsmtp -h @smtp_host@ -f \"\(Bacula regression\) %r\" -s \"Regression daemon message\" %r" + mail = @job_email@ = all, !skipped + console = all, !skipped, !saved + append = "@working_dir@/log" = all, !skipped +} + + +# Default pool definition +Pool { + Name = Default + Pool Type = Backup + Recycle = yes # Bacula can automatically recycle Volumes + AutoPrune = yes # Prune expired volumes + Volume Retention = 365d # one year +} diff --git a/regress/regress/scripts/win32-bacula-fd.conf.in b/regress/regress/scripts/win32-bacula-fd.conf.in new file mode 100644 index 0000000000..115b83d0e7 --- /dev/null +++ b/regress/regress/scripts/win32-bacula-fd.conf.in @@ -0,0 +1,33 @@ +# +# Default Bacula File Daemon Configuration file +# +# For Bacula release 1.33 +# +# There is not much to change here except perhaps the +# File daemon Name to +# + +# +# List Directors who are permitted to contact this File daemon +# +Director { + Name = rufus-dir + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" +} + +# +# "Global" File daemon configuration specifications +# +FileDaemon { # this is me + Name = localhost-fd + FDport = 8102 # where we listen for the director + WorkingDirectory = "/home/kern/bacula/regress/working" + Pid Directory = "/home/kern/bacula/regress/working" + SubSys Directory = "/home/kern/bacula/regress/working" +} + +# Send all messages except skipped files back to Director +Messages { + Name = Standard + director = rufus-dir = all, !terminate +} diff --git a/regress/regress/scripts/win32-bacula-sd-tape.conf.in b/regress/regress/scripts/win32-bacula-sd-tape.conf.in new file mode 100644 index 0000000000..638b402cd8 --- /dev/null +++ b/regress/regress/scripts/win32-bacula-sd-tape.conf.in @@ -0,0 +1,54 @@ +# +# Default Bacula Storage Daemon Configuration file +# +# For Bacula release 1.39.23 +# +# You may need to change the name of your tape drive +# on the "Archive Device" directive in the Device +# resource. If you change the Name and/or the +# "Media Type" in the Device resource, please ensure +# that dird.conf has corresponding changes. +# + +Storage { # definition of myself + Name = localhost-sd + SDPort = 8103 # Director's port + WorkingDirectory = "/home/kern/bacula/regress/working" + Pid Directory = "/home/kern/bacula/regress/working" + Subsys Directory = "/home/kern/bacula/regress/working" +} + +# +# List Directors who are permitted to contact Storage daemon +# +Director { + Name = localhost-dir + Password = "ccV3lVTsQRsdIUGyab0N4sMDavui2hOBkmpBU0aQKOr9" +} + +# +# Devices supported by this Storage daemon +# To connect, the Director's bacula-dir.conf must have the +# same Name and MediaType. +# + +Device { + Name = DDS-4 # + Media Type = DDS-4 + Archive Device = /dev/nst0 + AutomaticMount = yes; # when device opened, read it + AlwaysOpen = yes; + RemovableMedia = yes; + @/home/kern/bacula/regress/bin/tape_options +# Maximum File Size = 1000000 +# MaximumVolumeSize = 100M +} + +# +# Send all messages to the Director, +# mount messages also are sent to the email address +# +Messages { + Name = Standard + director = rufus-dir = all, !terminate +} diff --git a/regress/regress/starttime b/regress/regress/starttime new file mode 100755 index 0000000000..e6aa3ea6a9 --- /dev/null +++ b/regress/regress/starttime @@ -0,0 +1,6 @@ +#!/usr/bin/env python +from time import time as now + +fn = open('time.out', 'w+') +fn.write('%s' % now()) +fn.close() diff --git a/regress/regress/tape b/regress/regress/tape new file mode 100755 index 0000000000..718cefe7d5 --- /dev/null +++ b/regress/regress/tape @@ -0,0 +1,2 @@ +#!/bin/sh +./all-non-root-tape-tests diff --git a/regress/regress/tests/2drive-3pool-test b/regress/regress/tests/2drive-3pool-test new file mode 100755 index 0000000000..3cb13a578d --- /dev/null +++ b/regress/regress/tests/2drive-3pool-test @@ -0,0 +1,83 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory. Create three +# tapes, each in a different pool, then run some jobs asking for the +# volume on drive three. It should find it without moving the +# volume. +# +# This script uses the virtual disk autochanger and two drives +# +TestName="2drive-3pool-disk" +JobName="2dr3pooldisk" +. scripts/functions + +scripts/cleanup +scripts/copy-2disk-drive-confs +scripts/prepare-two-disks + +echo "${cwd}/build" >${cwd}/tmp/file-list +change_jobname NightlySave $JobName +start_test + +# Turn off Prefer Mounted Volumes so we use 2 drives +# outf="tmp/sed_tmp" +# echo "s%# Prefer Mounted Volumes% Prefer Mounted Volumes%g" >${outf} +# cp ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +# Comment the next line out to write everything to one drive +# otherwise, it writes the two jobs to different drives +# sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +setdebug level=51 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Full drive=1 +@#label storage=DDS-4 volume=TestVolume003 slot=3 Pool=Inc drive=2 +status storage=DDS-4 +@#run job=$JobName level=Full Pool=Inc yes +run job=$JobName level=Full Pool=Full yes +run job=$JobName level=Full Pool=Default yes +setdebug level=200 storage=DDS-4 +run job=$JobName level=Full Pool=Default yes +run job=$JobName level=Full Pool=Default yes +@sleep 10 +status storage=DDS-4 +list volumes +wait +list volumes +list jobs +status storage=DDS-4 +messages +quit +END_OF_DATA + +# exit + +run_bacula +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole + +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff + +end_test diff --git a/regress/regress/tests/2drive-concurrent-test b/regress/regress/tests/2drive-concurrent-test new file mode 100755 index 0000000000..c888a0c40e --- /dev/null +++ b/regress/regress/tests/2drive-concurrent-test @@ -0,0 +1,93 @@ +#!/bin/sh +# +# Run four jobs at the same time, with two Volumes. +# Set max Vol bytes of first volume +# to less than total backup to force Bacula to use the second +# Volume. +# +TestName="2drive-concurrent-test" +JobName=Four-concurrent-jobs +. scripts/functions + +scripts/cleanup +scripts/copy-2disk-drive-confs +scripts/prepare-two-disks +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label pool=Default storage=DDS-4 volume=TestVolume001 slot=1 drive=0 +label pool=Default storage=DDS-4 volume=TestVolume002 slot=2 drive=1 +update Volume=TestVolume001 MaxVolBytes=100000000 +@#50000000 +@#12 +setdebug level=001 Storage=DDS-4 +status storage=DDS-4 +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=$JobName level=Full Storage=DDS-4 +yes +reload +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=$JobName level=Full Storage=DDS-4 +yes +reload +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=$JobName level=Full Storage=DDS-4 +yes +reload +llist volume=TestVolume001 +llist volume=TestVolume002 +status storage=DDS-4 +run job=$JobName level=Full Storage=DDS-4 +yes +status storage=DDS-4 +reload +reload +reload +reload +@sleep 2 +status dir +status storage=DDS-4 +llist volume=TestVolume001 +llist volume=TestVolume002 +reload +@sleep 5 +messages +reload +reload +wait +status storage=DDS-4 +reload +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +reload +reload +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/2drive-incremental-2disk b/regress/regress/tests/2drive-incremental-2disk new file mode 100755 index 0000000000..353ff267fb --- /dev/null +++ b/regress/regress/tests/2drive-incremental-2disk @@ -0,0 +1,114 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +# This script uses the virtual disk autochanger and two drives +# +TestName="2drive-incremental-2disk" +JobName="2drive2disk" +. scripts/functions + +scripts/cleanup +scripts/copy-2disk-drive-confs +scripts/prepare-two-disks + +change_jobname localhost-fd $JobName +start_test + +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +if test ! -d ${cwd}/tmp/build ; then + mkdir ${cwd}/tmp/build +fi +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +# Turn off Prefer Mounted Volumes so we use 2 drives +outf="${cwd}/tmp/sed_tmp" +echo "s%# Prefer Mounted Volumes% Prefer Mounted Volumes%g" >${outf} +cp ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +# Comment the next line out to write everything to one drive +# otherwise, it writes the two jobs to different drives +sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +setdebug level=3 dir +setdebug level=3 storage=DDS-4 +setdebug level=3 client +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Default drive=1 +status storage=DDS-4 +@#setdebug level=120 storage=DDS-4 +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +@sleep 3 +status storage=DDS-4 +wait +list volumes +list jobs +status storage=DDS-4 +messages +quit +END_OF_DATA + +run_bacula +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +status storage=DDS-4 +@#setdebug level=120 storage=DDS-4 +run level=Incremental job=NightlySave yes +wait +list volumes +status storage=DDS-4 +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +# The restore should read from TestVolume002, which was on drive 1 +grep TestVolume002 ${cwd}/tmp/log2.out >/dev/null 2>&1 +# Note rstat may already be set, so we don't just store into it +if [ $? != 0 ] ; then + rstat=$? +fi + +# +# Delete .c files because we will only restored the txt files +# +rm -f ${cwd}/tmp/build/*.c +check_restore_tmp_build_diff + +end_test diff --git a/regress/regress/tests/2drive-incremental-2tape b/regress/regress/tests/2drive-incremental-2tape new file mode 100755 index 0000000000..bdf03186a5 --- /dev/null +++ b/regress/regress/tests/2drive-incremental-2tape @@ -0,0 +1,110 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +# This script uses the autochanger and two tapes +# +TestName="2drive-incremental-2tape" +JobName="2drive2tape" +. scripts/functions + +if test x${TAPE_DRIVE1} = x/dev/null ; then + echo "Skipping 2drive-incremental-2tape test. No second drive." + exit +fi + + +scripts/copy-2drive-confs +scripts/cleanup-2drive + +change_jobname localhost-fd $JobName + +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +if test ! -d ${cwd}/tmp/build ; then + mkdir ${cwd}/tmp/build +fi +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +# Turn off Prefer Mounted Volumes so we use 2 drives +outf="${cwd}/tmp/sed_tmp" +echo "s%# Prefer Mounted Volumes% Prefer Mounted Volumes%g" >${outf} +cp ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +# Comment the next line out to write everything to one drive +# otherwise, it writes the two jobs to different drives +sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + +start_test + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Default drive=1 +@#setdebug level=100 storage=DDS-4 +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +@sleep 3 +status storage=DDS-4 +wait +list volumes +list jobs +status storage=DDS-4 +messages +quit +END_OF_DATA + +run_bacula + +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +status storage=DDS-4 +@#setdebug level=400 storage=DDS-4 +run level=Incremental job=NightlySave yes +wait +list volumes +status storage=DDS-4 +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +# +# Delete .c files because we will only restored the txt files +# +rm -f ${cwd}/tmp/build/*.c +check_restore_tmp_build_diff + +end_test diff --git a/regress/regress/tests/ansi-label-tape b/regress/regress/tests/ansi-label-tape new file mode 100755 index 0000000000..17d83d8ccd --- /dev/null +++ b/regress/regress/tests/ansi-label-tape @@ -0,0 +1,91 @@ +#!/bin/sh +# +# Test of ANSI labeled tapes +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# We also use the purge and the relabel commands as +# well as a pile of status storage commands. +# +TestName="ansi-label-tape" +JobName=backuptape +. scripts/functions + +scripts/copy-tape-confs +/bin/cp -f scripts/ansi-sd-tape.conf bin/bacula-sd.conf +scripts/cleanup-tape + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=200 storage=DDS-4 +label storage=DDS-4 volume=Vol001 slot=0 pool=Default +purge volume=Vol001 +relabel pool=Default storage=DDS-4 oldVolume=Vol001 volume=Vol002 slot=0 +purge volume=Vol002 +relabel pool=Default storage=DDS-4 oldVolume=Vol002 volume=Vol001 slot=0 +run job=$JobName yes +status storage=DDS-4 +@sleep 1 +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +list volumes +messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +# +# Now do a second backup after making a few changes +# +touch ${cwd}/build/src/dird/*.c +echo "test test" > ${cwd}/build/src/dird/xxx + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +list volumes +@#setdebug level=300 storage=DDS-4 +run job=$JobName yes +wait +list volumes +messages +@# +@# now do a second restore +@# +@$out ${cwd}/tmp/log2.out +list volumes +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +list volumes +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/auto-label-test b/regress/regress/tests/auto-label-test new file mode 100755 index 0000000000..0b85a90fa0 --- /dev/null +++ b/regress/regress/tests/auto-label-test @@ -0,0 +1,64 @@ +#!/bin/sh +# +# Test if Bacula can automatically create a Volume label. +# + +TestName="auto-label-test" +JobName=AutoLabel +. scripts/functions + +copy_test_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +sed "s%# Label Format% Label Format%" ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +status all +status all +list pools +messages +@#setdebug level=110 storage=File +run job=$JobName storage=File yes +list pools +list volumes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +count +ls * +dir * +find Makefile +pwd +lsmark +estimate +? +help +done +yes +wait +messages +@$out +quit +END_OF_SCRIPT + +run_bacula +check_for_zombie_jobs storage=File || exit 1 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/backup-bacula-tape b/regress/regress/tests/backup-bacula-tape new file mode 100755 index 0000000000..4c984d57f8 --- /dev/null +++ b/regress/regress/tests/backup-bacula-tape @@ -0,0 +1,116 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# We also use the purge and the relabel commands as +# well as a pile of status storage commands. +# +TestName="backup-bacula-tape" +JobName=backuptape +. scripts/functions + +scripts/copy-tape-confs +scripts/cleanup-tape + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=200 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +purge volume=TestVolume001 +relabel pool=Default storage=DDS-4 oldVolume=TestVolume001 volume=TestVolume002 slot=0 +purge volume=TestVolume002 +relabel pool=Default storage=DDS-4 oldVolume=TestVolume002 volume=TestVolume001 slot=0 +run job=$JobName yes +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +list volumes +messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +# +# Now do a second backup after making a few changes +# +touch ${cwd}/build/src/dird/*.c +echo "test test" > ${cwd}/build/src/dird/xxx + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +list volumes +run job=$JobName yes +wait +list volumes +messages +@# +@# now do a second restore +@# +@$out ${cwd}/tmp/log2.out +list volumes +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +list volumes +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/backup-bacula-test b/regress/regress/tests/backup-bacula-test new file mode 100755 index 0000000000..0815c38316 --- /dev/null +++ b/regress/regress/tests/backup-bacula-test @@ -0,0 +1,92 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="backup-bacula-test" +JobName=backup +. scripts/functions + +scripts/cleanup +scripts/copy-confs + +change_jobname Client1 $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label volume=TestVolume001 storage=File pool=Default +@#setdebug level=100 storage=File +run job=$JobName yes +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +@sleep 1 +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +@sleep 1 +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=100 storage=File +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +messages +@$out +quit +END_OF_DATA + +# +# Now do a second backup after making a few changes +# +touch ${cwd}/build/src/dird/*.c +echo "test test" > ${cwd}/build/src/dird/xxx +# + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/backup-to-null b/regress/regress/tests/backup-to-null new file mode 100755 index 0000000000..a8b2af2f39 --- /dev/null +++ b/regress/regress/tests/backup-to-null @@ -0,0 +1,74 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# We also use the purge and the relabel commands as +# well as a pile of status storage commands. +# +TestName="backup-to-null" +JobName=backuptonull +. scripts/functions + +scripts/cleanup +scripts/copy-fifo-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +rm -f ${cwd}/tmp/log1.out ${cwd}/tmp/log2.out +start_test + + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=200 storage=Dummy +label storage=Dummy volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +status storage=Dummy +@sleep 1 +wait +@sleep 3 +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=Dummy +stop_bacula + +# +# Now do a second backup after making a few changes +# +touch ${cwd}/build/src/dird/*.c +echo "test test" > ${cwd}/build/src/dird/xxx + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log2.out +list volumes +run job=$JobName yes +wait +list volumes +@sleep 3 +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=Dummy +stop_bacula + +grep "^ Termination: *Backup OK" ${cwd}/tmp/log1.out 2>&1 >/dev/null +bstat=$? +grep "^ Termination: *Backup OK" ${cwd}/tmp/log2.out 2>&1 >/dev/null +dstat=$? + +# not yet implemented +rstat=0 + +end_test diff --git a/regress/regress/tests/backup-win32-tape b/regress/regress/tests/backup-win32-tape new file mode 100755 index 0000000000..2c67ddce85 --- /dev/null +++ b/regress/regress/tests/backup-win32-tape @@ -0,0 +1,48 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# +TestName="backup-win32-tape" +JobName=backupwintape +. scripts/functions + +scripts/cleanup-tape +scripts/copy-win32-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=NightlySave yes +@sleep 10 +status storage=DDS-4 +@sleep 30 +messages +wait +messages +@# +@# now do a restore +@# +@$outt ${cwd}/tmp/log2.out +@#restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +@#yes +@#wait +@#messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/bextract-test b/regress/regress/tests/bextract-test new file mode 100755 index 0000000000..80085b3265 --- /dev/null +++ b/regress/regress/tests/bextract-test @@ -0,0 +1,56 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory but +# split the archive into two volumes, then build a BSR with +# the restore command and use bextract to restore the files. +# +TestName="bextract-test" +JobName="bextract" +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File1 volume=TestVolume001 +label storage=File1 volume=TestVolume002 +update Volume=TestVolume001 MaxVolBytes=3000000 +@#setdebug level=400 dir +@#setdebug level=400 storage=File1 +run job=$JobName storage=File1 yes +wait +messages +@# +@# now build the bsr file but do not restore +@# +@$out ${cwd}/tmp/log2.out +restore bootstrap=${cwd}/working/restore.bsr where=${cwd}/tmp/bacula-restores select all storage=File1 done +no +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +mkdir -p ${cwd}/tmp/bacula-restores +if test "$debug" -eq 1 ; then + bin/bextract -v -b working/restore.bsr -c bin/bacula-sd.conf ${cwd}/tmp ${cwd}/tmp/bacula-restores +else + bin/bextract -b working/restore.bsr -c bin/bacula-sd.conf ${cwd}/tmp ${cwd}/tmp/bacula-restores 2>&1 >/dev/null +fi +rstat=$? +grep "^ Termination: *Backup OK" ${cwd}/tmp/log1.out 2>&1 >/dev/null +bstat=$? +check_restore_diff +end_test diff --git a/regress/regress/tests/big-vol-test b/regress/regress/tests/big-vol-test new file mode 100755 index 0000000000..21e4167737 --- /dev/null +++ b/regress/regress/tests/big-vol-test @@ -0,0 +1,82 @@ +#!/bin/sh +# +# Create a big Volume > 5 GB and backup to it to test disk +# seeking on big volumes. We cheat and artifically grow +# the volume. +# +TestName="big-vol-test" +JobName=bigvol +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +cwd=`pwd` +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=100 storage=File +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File + +# +# Now increase the size of the Volume using gigaslam +# +cd ${cwd}/tmp +# make big file +size=5200000000 +${cwd}/build/src/tools/grow TestVolume001 ${size} +if [ $? != 0 ]; then + echo "Execute of ${cwd}/build/src/tools/grow failed." + exit 1 +fi +cd ${cwd} + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +sql +UPDATE Media SET Volbytes=${size} WHERE VolumeName='TestVolume001'; + +llist volume=TestVolume001 +@# Now do another full save with big Volume +run level=Full job=$JobName yes +wait +messages +@# +@# now do a restore +@# +sql +SELECT * FROM JobMedia; + +@output ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File select all done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test +# Get rid of big files +rm -f ${cwd}/tmp/TestVolume001 diff --git a/regress/regress/tests/bscan-fast-tape b/regress/regress/tests/bscan-fast-tape new file mode 100755 index 0000000000..7e2b38e329 --- /dev/null +++ b/regress/regress/tests/bscan-fast-tape @@ -0,0 +1,88 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then +# do a bscan and restore. +# It should require at least 4 different bsrs. +# +TestName="bscan-tape" +JobName=bscantape +. scripts/functions + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +# sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +setdebug level=2 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +echo "Starting Bacula tape writing" +#bin/btape -c bin/bacula-sd.conf /dev/nst0 </dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +echo "Begin attempt to read tape that crashes the system" +echo "volume=TestVolume001" >tmp/bscan.bsr +strace -o strace.new bin/bscan -d200 -w working -u regress -n regress -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf DDS-4 +exit +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log2.out +@# +@# now do a restore +@# +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula +rm -f ${cwd}/build/src/lib/dummy + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/bscan-tape b/regress/regress/tests/bscan-tape new file mode 100755 index 0000000000..cfca352c91 --- /dev/null +++ b/regress/regress/tests/bscan-tape @@ -0,0 +1,145 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then +# do a bscan and restore. +# It should require at least 4 different bsrs. +# +TestName="bscan-tape" +JobName=bscantape +. scripts/functions + +copy_tape_confs + +echo "${cwd}/build" >tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +estimate job=$JobName listing +estimate job=$JobName listing +estimate job=$JobName listing +messages +@$out tmp/log1.out +setdebug level=2 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +run job=$JobName level=Full yes +wait +run job=$JobName level=Full yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 + +echo "Backup 1 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/dird/*.c ${cwd}/build/src/dird/*.o +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o + +# +# run a second job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA + +run_bacula +scripts/check_for_zombie_jobs storage=DDS-4 + +echo "Backup 2 done" +touch ${cwd}/build/src/dird/*.c +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a third job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA + +run_bacula +scripts/check_for_zombie_jobs storage=DDS-4 + +echo "Backup 3 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +#echo "abc" > ${cwd}/build/src/lib/dummy +# +# run a fourth job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA + +run_bacula + +scripts/check_for_zombie_jobs storage=DDS-4 +stop_bacula + +echo "Backup 4 done" +# +# now drop and recreate the database +# +cd bin +./drop_bacula_tables >/dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +echo "volume=TestVolume001" >tmp/bscan.bsr +if test "$debug" -eq 1 ; then + bin/bscan -w working -u regress -n regress -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf DDS-4 +else + bin/bscan -w working -u regress -n regress -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf DDS-4 2>&1 >/dev/null +fi + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log2.out +@# +@# now do a restore +@# +restore where=tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula +rm -f ${cwd}/build/src/lib/dummy + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/bscan-test b/regress/regress/tests/bscan-test new file mode 100755 index 0000000000..fd71ef336d --- /dev/null +++ b/regress/regress/tests/bscan-test @@ -0,0 +1,89 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory but +# split the archive into two volumes then bscan it +# into the catalog after the backup. It also to a limited +# extent tests the purge volume and delete volume commands. +# + +TestName="bscan-test" +JobName=bscan +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=File1 +TestVolume001 +label storage=File1 +TestVolume002 +update Volume=TestVolume001 MaxVolBytes=3000000 +run job=$JobName storage=File1 +yes +wait +list volumes +list files jobid=1 +sql +select * from JobMedia; + + +messages +@$out /dev/null +@# +@# now purge the Volume +@# +purge volume=TestVolume001 +purge volume=TestVolume002 +delete volume=TestVolume001 +yes +delete volume=TestVolume002 +yes +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +echo "volume=TestVolume001" >tmp/bscan.bsr +echo "volume=TestVolume002" >>tmp/bscan.bsr + +if test "$debug" -eq 1 ; then + bin/bscan -w working -u regress -n regress -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf ${cwd}/tmp +else + bin/bscan -w working -u regress -n regress -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf ${cwd}/tmp 2>&1 >tmp/log3.out +fi + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log2.out +@# +@# now do a restore +@# +@#setdebug level=400 storage=File1 +restore bootstrap=tmp/kern.bsr where=tmp/bacula-restores select all storage=File1 done +yes +wait +messages +@$out +quit +END_OF_DATA + +# now run restore +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/bsr-opt-test b/regress/regress/tests/bsr-opt-test new file mode 100755 index 0000000000..9413a8c081 --- /dev/null +++ b/regress/regress/tests/bsr-opt-test @@ -0,0 +1,80 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory but +# split the archive into two volumes, then restore +# files on only one of the volumes and ensure that +# the other volume is not used. I.e. bsr optimization +# works. +# +TestName="bsr-opt-test" +JobName=bsr-opt +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File1 volume=TestVolume001 +label storage=File1 volume=TestVolume002 +update Volume=TestVolume001 MaxVolBytes=3000000 +run job=$JobName storage=File1 yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore bootstrap=${cwd}/working/restore.bsr where=${cwd}/tmp/bacula-restores select storage=File1 +unmark * +cd ${cwd}/build/src/cats +mark * +ls +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula +# +# This test is not really reliable. What we want to do is +# to select files on only one Volume, then insure here +# that only one Volume is chosen. +# +grep TestVolume002 working/restore.bsr 2>&1 >/dev/null +bsrstat=$? +check_two_logs + +diff -r build/src/cats ${cwd}/tmp/bacula-restores${cwd}/build/src/cats 2>&1 >/dev/null +if [ $? != 0 -o $bsrstat != 0 -o $bstat != 0 -o $rstat != 0 ] ; then + echo " " + echo " " + echo " !!!!! bsr-opt-test Bacula source failed!!! !!!!! " + echo " !!!!! bsr-opt-test failed!!! !!!!! " >>test.out + if [ $bstat != 0 -o $rstat != 0 ] ; then + echo " !!!!! Bad Job termination status !!!!! " + echo " !!!!! Bad Job termination status !!!!! " >>test.out + elif [ $bsrstat != 0 ] ; then + echo " !!!!! Volume selection error !!!!! " + echo " !!!!! Volume selection error !!!!! " >>test.out + else + echo " !!!!! Restored files differ !!!!! " + echo " !!!!! Restored files differ !!!!! " >>test.out + fi + echo " " +else + echo " ===== bsr-opt-test Bacula source OK `date +%R:%S` ===== " + echo " ===== bsr-opt-test OK `date +%R:%S` ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/tests/btape-fill-full-tape b/regress/regress/tests/btape-fill-full-tape new file mode 100755 index 0000000000..7c32d04cda --- /dev/null +++ b/regress/regress/tests/btape-fill-full-tape @@ -0,0 +1,34 @@ +#!/bin/sh +# +# Test the fill command in btape +# +TestName="btape-fill-full-tape" +JobName=AutoLabel +. scripts/functions + +scripts/copy-tape-confs +scripts/cleanup-tape + +change_jobname $JobName +start_test + +bin/btape -c bin/bacula-sd.conf DDS-4 <&1 >${cwd}/tmp/log1.out +fill +s + +quit +END_OF_DATA + + +grep "^The last block on the tape matches\. Test succeeded\." ${cwd}/tmp/log1.out 2>&1 >/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " !!!!! btape fill test failed!!! !!!!! " + echo " !!!!! btape fill test failed!!! !!!!! " >>test.out + echo " " +else + echo " ===== btape fill test OK ===== " + echo " ===== btape fill test OK ===== " >>test.out +# scripts/cleanup +fi diff --git a/regress/regress/tests/btape-fill-tape b/regress/regress/tests/btape-fill-tape new file mode 100755 index 0000000000..bca41b964d --- /dev/null +++ b/regress/regress/tests/btape-fill-tape @@ -0,0 +1,37 @@ +#!/bin/sh +# +# Test the fill command in btape +# +TestName="btape-fill-tape" +JobName=filltape +. scripts/functions + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# MaximumVolumeSize% MaximumVolumeSize%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +start_test + +cat <${cwd}/tmp/bconcmds +fill +s +quit +END_OF_DATA + +run_btape DDS-4 + +grep "^The last block on the tape matches\. Test succeeded\." ${cwd}/tmp/log1.out 2>&1 >/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " !!!!! btape fill test failed!!! !!!!! " + echo " !!!!! btape fill test failed!!! !!!!! " >>test.out + echo " " +else + echo " ===== btape fill test OK ===== " + echo " ===== btape fill test OK ===== " >>test.out +# scripts/cleanup +fi diff --git a/regress/regress/tests/bug-897 b/regress/regress/tests/bug-897 new file mode 100755 index 0000000000..67d0c2f2bb --- /dev/null +++ b/regress/regress/tests/bug-897 @@ -0,0 +1,105 @@ +#!/bin/sh +# +# Test bug 897 +# + +TestName="bug-897" +JobName=backup + +. scripts/functions +copy_test_confs + +rm -f bin/bacula-dir.conf +rm -f ${cwd}/tmp/RUN*log +rm -f ${cwd}/tmp/fifo +rm -f ${cwd}/tmp/RUN_BUG_897 +rm -f ${cwd}/tmp/RUN_FD_FAILED + +/bin/cp -f scripts/bacula-dir.conf.testrunscript bin/bacula-dir.conf + +echo "${cwd}/build/po" >${cwd}/tmp/file-list +echo "${cwd}/tmp/fifo" >> ${cwd}/tmp/file-list +mkfifo "${cwd}/tmp/fifo" + +# use this to be able to cancel a running job +( + cat > ${cwd}/tmp/fifo < /dev/zero + cat > ${cwd}/tmp/fifo < /dev/zero +) & + +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +label volume=TestVolume001 +@$out ${cwd}/tmp/RUN_FD_FAILED.log +run job=RUN_FD_FAILED yes +wait +messages +@sleep 1 +@$out ${cwd}/tmp/RUN_BUG_897.log +setdebug level=200 client +run job=BUG_897 yes +@sleep 2 +cancel +yes +wait +messages +st dir +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +dstat=0 +bstat=0 +rstat=0 +export dstat +export bstat +export rstat + +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED1"' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +a=$? +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED2"' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +b=$? +grep 'dir: AfterJob: run command "/bin/echo RunAfterFailedJob"' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +c=$? +grep 'touching' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +d=$? +grep '*** Backup Error ***' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +e=$? +if [ $a = 0 -a $b = 0 -a $c = 0 -a $d = 0 -a $e = 0 ] +then + [ "$debug" = 1 ] && echo RUN_FD_FAILED ok +else + echo "RUN_FD_FAILED in error" + rstat=1 +fi +if test -f ${cwd}/tmp/RUN_FD_FAILED +then + echo "The ${cwd}/tmp/RUN_FD_FAILED have been created, but nothing could be found" + echo "in the log" +fi + + +grep 'touching' ${cwd}/tmp/RUN_BUG_897.log >/dev/null 2>&1 +d=$? +if [ $d = 0 ] +then + [ "$debug" = 1 ] && echo RUN_FD_FAILED ok +else + echo "RUN_BUG_897 in error" + rstat=1 +fi +if test -f ${cwd}/tmp/RUN_BUG_897 +then + echo "The ${cwd}/tmp/RUN_BUG_897 have been created, but nothing could be found" + echo "in the log" +fi + + + +end_test diff --git a/regress/regress/tests/bug-fatal-test b/regress/regress/tests/bug-fatal-test new file mode 100755 index 0000000000..249858d6fb --- /dev/null +++ b/regress/regress/tests/bug-fatal-test @@ -0,0 +1,45 @@ +#!/bin/sh +# +# Test RunScript +# + +TestName="bug-fatal-test" +JobName=backup + +. scripts/functions + +copy_test_confs + +rm -f bin/bacula-dir.conf +rm -f ${cwd}/tmp/RUN*log +/bin/cp -f scripts/bacula-dir.conf.testrunscript bin/bacula-dir.conf + +rm -f ${cwd}/tmp/file-list +# ${cwd}/tmp/file-list doesn't exists +# echo "${cwd}/build/po" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +label volume=TestVolume001 +@$out ${cwd}/tmp/RUN_BUG_FATAL.log +run job=BUG_FATAL yes +wait +messages +@sleep 1 +st dir +quit +END_OF_DATA + + +bin/bacula start +cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf > /dev/null +stop_bacula + +export dstat=0 +export bstat=0 +export rstat=0 + +end_test diff --git a/regress/regress/tests/compress-encrypt-test b/regress/regress/tests/compress-encrypt-test new file mode 100755 index 0000000000..d4eb0cae52 --- /dev/null +++ b/regress/regress/tests/compress-encrypt-test @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup with encryption and compression of the Bacula build directory +# then verify the signatures. +# +TestName="compressed-encrypt-test" +JobName=CompressedTest +. scripts/functions + +scripts/cleanup +scripts/copy-crypto-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +setdebug level=10 fd +run job=$JobName yes +wait +messages +list volumes +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +@# setdebug level=0 fd +restore where=${cwd}/tmp/bacula-restores storage=File +5 +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +sleep 2 +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/compressed-test b/regress/regress/tests/compressed-test new file mode 100755 index 0000000000..47fc8e4362 --- /dev/null +++ b/regress/regress/tests/compressed-test @@ -0,0 +1,54 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then restore it. +# +TestName="compressed-test" +JobName=compressed +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output +messages +@$out ${cwd}/tmp/log1.out +status all +status all +messages +label storage=File volume=TestVolume001 +run job=$JobName storage=File yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +grep " Software Compression" ${cwd}/tmp/log1.out | grep "%" 2>&1 1>/dev/null +if [ $? != 0 ] ; then + echo " !!!!! No compression !!!!!" + bstat=1 +fi +end_test diff --git a/regress/regress/tests/concurrent-jobs-test b/regress/regress/tests/concurrent-jobs-test new file mode 100755 index 0000000000..37c69bd801 --- /dev/null +++ b/regress/regress/tests/concurrent-jobs-test @@ -0,0 +1,66 @@ +#!/bin/sh +# +# Run two jobs at the same time +# + +TestName="concurrent-jobs-test" +JobName=concurrent-jobs +. scripts/functions + +copy_test_confs + +echo "${cwd}/tmp/largefile" >${cwd}/tmp/file-list +if test -c /dev/urandom ; then +# Create 56MB file with random data + echo "Creating a 56MB file with random data ..." + dd if=/dev/urandom of=${cwd}/tmp/largefile bs=1024 count=55000 +else + echo "Creating a 56MB file with bacula-dir data ..." + dd if=bin/bacula-dir of=${cwd}/tmp/1 bs=1024 count=1000 + cat ${cwd}/tmp/1 ${cwd}/tmp/1 ${cwd}/tmp/1 ${cwd}/tmp/1 ${cwd}/tmp/1 >${cwd}/tmp/2 + rm -f ${cwd}/tmp/1 + cat ${cwd}/tmp/2 ${cwd}/tmp/2 ${cwd}/tmp/2 ${cwd}/tmp/2 ${cwd}/tmp/2 >>${cwd}/tmp/3 + rm -f ${cwd}/tmp/2 + cat ${cwd}/tmp/3 ${cwd}/tmp/3 ${cwd}/tmp/3 ${cwd}/tmp/3 ${cwd}/tmp/3 >${cwd}/tmp/largefile + rm -f ${cwd}/tmp/3 +fi + +echo "largefile created" + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +run job=$JobName level=Full yes +run job=$JobName level=Full yes +run job=$JobName level=Full yes +run job=$JobName level=Full yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +diff ${cwd}/tmp/largefile ${cwd}/tmp/bacula-restores${cwd}/tmp/largefile 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/tests/data-encrypt-test b/regress/regress/tests/data-encrypt-test new file mode 100755 index 0000000000..581b8a219c --- /dev/null +++ b/regress/regress/tests/data-encrypt-test @@ -0,0 +1,53 @@ +#!/bin/sh +# +# Run a simple backup with encryption and no other options +# (i.e. no compression and no sparse handling) of the +# Bacula build directory. +# +TestName="data-encrypt-test" +JobName=Crypto +. scripts/functions + +scripts/cleanup +scripts/copy-crypto-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +@#setdebug level=10 fd +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +@#setdebug level=10 fd +restore where=${cwd}/tmp/bacula-restores storage=File +5 +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +sleep 2 +check_for_zombie_jobs storage=File +stop_bacula + +du -s build +du -s ${cwd}/tmp/bacula-restores/ + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/dev-test-root b/regress/regress/tests/dev-test-root new file mode 100755 index 0000000000..0d005e56b7 --- /dev/null +++ b/regress/regress/tests/dev-test-root @@ -0,0 +1,79 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# + +TestName="dev-test-root" +. scripts/functions + +require_root + +scripts/cleanup +scripts/copy-test-confs +echo "/dev" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@output ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +run job=NightlySave yes +wait +messages +@# +@# now do a restore +@# +@output ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +# More cleanup needed below + +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test dev >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test dev >${cwd}/tmp/restored +cd ${cwd}/tmp +# +# Use sed to cut out parts that *always* change +# +cat >sed.scr <1 +sed -f sed.scr 1 | sort >original +# +mv -f restored 1 +sed -f sed.scr 1 | sort >restored +rm -f sed.scr +# +cd ${cwd} +diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 1>/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! dev-test-root failed !!!! ===== " + echo " ===== !!!! dev-test-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== dev-test-root OK ===== " + echo " ===== dev-test-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/tests/differential-test b/regress/regress/tests/differential-test new file mode 100755 index 0000000000..7ef57dc220 --- /dev/null +++ b/regress/regress/tests/differential-test @@ -0,0 +1,87 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do a differential and restore those two files. +# +TestName="differential-test" +JobName=differential +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +mkdir ${cwd}/tmp/build +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume002 +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula + +scripts/check_for_zombie_jobs storage=File +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force differential on the second Volume +update volume=TestVolume002 VolStatus=Used +run level=differential job=$JobName yes +wait +messages +@$out +END_OF_DATA + +run_bconsole + +scripts/check_for_zombie_jobs storage=File +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=incremental job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File file=<${cwd}/tmp/restore-list +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole +scripts/check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +# +# Delete .c files because we will only restore the txt files +# +rm -f ${cwd}/tmp/build/*.c +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/tests/eighty-simultaneous-jobs-tape b/regress/regress/tests/eighty-simultaneous-jobs-tape new file mode 100755 index 0000000000..3fe631fceb --- /dev/null +++ b/regress/regress/tests/eighty-simultaneous-jobs-tape @@ -0,0 +1,133 @@ +#!/bin/sh +# +# Run eighty jobs at the same time +# +TestName="eighty-simultaneous-jobs-tape" +JobName=EightySimultaneousJobs +. scripts/functions + +scripts/cleanup-tape +scripts/copy-tape-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +@sleep 2 +status dir +@sleep 5 +status dir +status storage=DDS-4 +messages +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +exit + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/encrypt-bug-test b/regress/regress/tests/encrypt-bug-test new file mode 100755 index 0000000000..93f2b2ef35 --- /dev/null +++ b/regress/regress/tests/encrypt-bug-test @@ -0,0 +1,64 @@ +#!/bin/sh +# +# Run a simple backup of untitled15.jpg that fails to +# restore properly in bug #763 +# +TestName="encrypt-bug-test" +JobName=Crypto-bug +. scripts/functions + +scripts/cleanup +scripts/copy-crypto-confs +echo "${cwd}/encrypt-bug.jpg" >${cwd}/tmp/file-list +echo "${cwd}/encrypt-bug.jpg" >${cwd}/tmp/restore-list +echo "${cwd}/encrypt-bug.txt" >>${cwd}/tmp/file-list +echo "${cwd}/encrypt-bug.txt" >>${cwd}/tmp/restore-list +echo "${cwd}/encrypt-bug2.txt" >>${cwd}/tmp/file-list +echo "${cwd}/encrypt-bug2.txt" >>${cwd}/tmp/restore-list +files="encrypt-bug.jpg encrypt-bug.txt encrypt-bug2.txt" +mkdir -p ${cwd}/tmp/build +for i in ${files}; do + cp -p ${cwd}/encrypt-bug*.* ${cwd}/tmp/build +done + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +setdebug level=100 fd +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +setdebug level=100 fd +restore where=${cwd}/tmp/bacula-restores storage=File +5 +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +sleep 2 +check_for_zombie_jobs storage=File +stop_bacula + +du -s build +du -s ${cwd}/tmp/bacula-restores/ + + +check_two_logs +diff ${cwd}/tmp/build ${cwd}/tmp/bacula-restores/${cwd} 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/tests/eot-fail-tape b/regress/regress/tests/eot-fail-tape new file mode 100755 index 0000000000..33bf4035b1 --- /dev/null +++ b/regress/regress/tests/eot-fail-tape @@ -0,0 +1,50 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to two tapes where the maximum tape file size is set to 1M +# +TestName="eot-fail-tape" +JobName=eotfailtape +. scripts/functions + +scripts/cleanup-tape +scripts/copy-tape-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +out="${cwd}/tmp/sed_tmp" +echo "s%# Maximum File Size% Maximum File Size%g" >${out} +cp -f ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed -f ${out} ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +update Volume=TestVolume001 MaxVolBytes=3000000 +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@tee +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/errors-test b/regress/regress/tests/errors-test new file mode 100755 index 0000000000..5bd40fcb49 --- /dev/null +++ b/regress/regress/tests/errors-test @@ -0,0 +1,79 @@ +#!/bin/sh +# +# Test errors +# + +TestName="errors-test" +JobName=backup + +. scripts/functions + +scripts/cleanup +copy_test_confs + +rm -f ${cwd}/tmp/*.log +/bin/cp -f scripts/bacula-dir.conf.errors bin/bacula-dir.conf +echo "${cwd}/build/po" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@output ${cwd}/tmp/LOCAL_INC_ERR.log +label storage=File volume=TestVolume001 +add storage=File2 +1 +File2 +1 +run job=LOCAL_INC_ERR yes +wait +messages +@output ${cwd}/tmp/REMOTE_INC_ERR.log +run job=REMOTE_INC_ERR yes +wait +messages +@output ${cwd}/tmp/LOCAL_EXCL_ERR.log +run job=LOCAL_EXCL_ERR yes +wait +messages +@$out ${cwd}/tmp/REMOTE_EXCL_ERR.log +run job=REMOTE_EXCL_ERR yes +wait +messages +@$out ${cwd}/tmp/REMOTE_RUNSCRIPT_ERR.log +run job=REMOTE_RUNSCRIPT_ERR yes +wait +messages +@$out ${cwd}/tmp/LOCAL_RUNSCRIPT_ERR.log +run job=LOCAL_RUNSCRIPT_ERR yes +wait +messages +@$out ${cwd}/tmp/CLIENT_CONNECT_TIMEOUT.log +run job=CLIENT_CONNECT_TIMEOUT yes +wait +messages +@$out ${cwd}/tmp/SD_CONNECT_TIMEOUT.log +run job=SD_CONNECT_TIMEOUT yes +wait +messages +status dir +status storage=File +quit +END_OF_DATA + +run_bacula +touch ${cwd}/tmp/log1.out +client=$(grep client= bin/bacula-dir.conf) +check_for_zombie_jobs storage=File $client +stop_bacula + +dstat=0 +bstat=0 +rstat=0 +export dstat +export bstat +export rstat + + +end_test diff --git a/regress/regress/tests/etc-test-root b/regress/regress/tests/etc-test-root new file mode 100755 index 0000000000..50a45f2cbf --- /dev/null +++ b/regress/regress/tests/etc-test-root @@ -0,0 +1,65 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="etc-test-root" +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "/etc" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@output ${cwd}/tmp/log1.out +label storage=File +TestVolume001 +run job=NightlySave +yes +wait +messages +@# +@# now do a restore +@# +@output ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +# more cleanup needed below + +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test etc >${cwd}/tmp/1 +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test etc >${cwd}/tmp/2 +sort <${cwd}/tmp/1 >${cwd}/tmp/original +sort <${cwd}/tmp/2 >${cwd}/tmp/restored +rm -f ${cwd}/tmp/1 ${cwd}/tmp/2 +cd ${cwd} +diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 1>/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! etc-test-root failed !!!! ===== " + echo " ===== !!!! etc-test-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== etc-test-root OK ===== " + echo " ===== etc-test-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/tests/fast-two-pool-test b/regress/regress/tests/fast-two-pool-test new file mode 100755 index 0000000000..51efc8b945 --- /dev/null +++ b/regress/regress/tests/fast-two-pool-test @@ -0,0 +1,70 @@ +#!/bin/sh +# +# This is Arno's test. It uses two pools, two tapes, and +# an autochanger. Note, the Director has three Pools in its +# conf: Default, Full, and Inc. Default is used in the +# NightlySave job by default. What is backed up is what +# is in ${cwd}/tmp/file-list, which is by default the Bacula +# source code (i.e. the build directory). +# +# Note, we use the virtual disk autochanger. +# +TestName="fast-two-pool-test" +JobName=Fast-two-pool +. scripts/functions + +scripts/cleanup +scripts/copy-2disk-confs +scripts/prepare-two-disks + +# Make a relatively large backup set 5 x source code directory +# Reduced to 1 for portable +echo "${cwd}/build" >${cwd}/tmp/file-list +echo "${cwd}/build" >${cwd}/tmp/file-list +echo "${cwd}/build" >${cwd}/tmp/file-list +echo "${cwd}/build" >${cwd}/tmp/file-list + +start_test + +# Write out bconsole commands to a file +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=150 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Full drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +list volumes +@# Start job with Client run before and sleep +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +@# wait between starting jobs +@sleep 10 +@#setdebug level=100 storage=DDS-4 +run job=NightlySave1 level=Full pool=Full yes +run job=NightlySave1 level=Full pool=Full yes +status storage=DDS-4 +messages +wait +list volumes +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +# exit +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/fifo-test b/regress/regress/tests/fifo-test new file mode 100755 index 0000000000..e994caeafc --- /dev/null +++ b/regress/regress/tests/fifo-test @@ -0,0 +1,61 @@ +#!/bin/sh +# +# Attempt to backup from a fifo and restore to a fifo +# +TestName="fifo-test" +JobName=FIFOTest +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/tmp/bfifo" >${cwd}/tmp/file-list + +rm -f ${cwd}/tmp/bfifo +mkfifo ${cwd}/tmp/bfifo +# send a file into the fifo +file=encrypt-bug.jpg +cat ${file} >${cwd}/tmp/bfifo& + +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File1 volume=TestVolume001 +run job=$JobName storage=File1 yes +wait +messages +quit +END_OF_DATA + + +run_bacula + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +@#setdebug level=50 client +restore where=/ select all storage=File1 done +yes +wait +messages +@$out +quit +END_OF_DATA + +cat <${cwd}/tmp/bfifo >${cwd}/tmp/${file}& + +run_bconsole + +check_for_zombie_jobs storage=File1 +stop_bacula + +check_two_logs +diff ${file} ${cwd}/tmp/${file} +dstat=$? +end_test diff --git a/regress/regress/tests/fixed-block-size-tape b/regress/regress/tests/fixed-block-size-tape new file mode 100755 index 0000000000..6799b543b2 --- /dev/null +++ b/regress/regress/tests/fixed-block-size-tape @@ -0,0 +1,62 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape where we set the minimum and maximum block +# sizes. +# +TestName="fixed-block-size-tape" +JobName=fixedblocksize +. scripts/functions + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +echo "s%# Maximum Block Size% Maximum Block Size%" >${cwd}/tmp/2 +echo "s%# Minimum Block Size% Minimum Block Size%" >>${cwd}/tmp/2 +sed -f ${cwd}/tmp/2 ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf +if [ $? != 0 ] ; then + echo " " + echo " " + echo "!!!! sed problem in Fixed Block Size test !!!!!" + echo " " + exit 1 +fi +rm -f ${cwd}/tmp/1 ${cwd}/tmp/2 + +change_jobname NightlySave $JobName +start_test + + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +setdebug level=51 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/four-concurrent-jobs-tape b/regress/regress/tests/four-concurrent-jobs-tape new file mode 100755 index 0000000000..9461a217b9 --- /dev/null +++ b/regress/regress/tests/four-concurrent-jobs-tape @@ -0,0 +1,55 @@ +#!/bin/sh +# +# Run four jobs at the same time +# +TestName="four-concurrent-jobs-tape" +JobName=FourConcurrentJobs +. scripts/functions + +scripts/cleanup-tape +scripts/copy-tape-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +@sleep 2 +status dir +@sleep 5 +status dir +status storage=DDS-4 +messages +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/four-concurrent-jobs-test b/regress/regress/tests/four-concurrent-jobs-test new file mode 100755 index 0000000000..5190dfce6d --- /dev/null +++ b/regress/regress/tests/four-concurrent-jobs-test @@ -0,0 +1,94 @@ +#!/bin/sh +# +# Run four jobs at the same time, with two Volumes. +# Set max Vol bytes of first volume +# to less than total backup to force Bacula to use the second +# Volume. +# +TestName="four-concurrent-jobs-test" +JobName=Four-concurrent-jobs +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File1 +TestVolume001 +label storage=File1 +TestVolume002 +update Volume=TestVolume001 MaxVolBytes=100000000 +@#50000000 +@#12 +setdebug level=51 Storage=File1 +status storage=File1 +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=$JobName level=Full Storage=File1 +yes +reload +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=$JobName level=Full Storage=File1 +yes +reload +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=$JobName level=Full Storage=File1 +yes +reload +llist volume=TestVolume001 +llist volume=TestVolume002 +status storage=File1 +run job=$JobName level=Full Storage=File1 +yes +status storage=File1 +reload +reload +reload +reload +@sleep 2 +status dir +status storage=File1 +llist volume=TestVolume001 +llist volume=TestVolume002 +reload +@sleep 5 +messages +reload +reload +wait +status storage=File1 +reload +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File1 +unmark * +mark * +done +yes +wait +reload +reload +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/four-jobs-tape b/regress/regress/tests/four-jobs-tape new file mode 100755 index 0000000000..6d07d53171 --- /dev/null +++ b/regress/regress/tests/four-jobs-tape @@ -0,0 +1,152 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then finally restore. +# It should require at least 4 different bsrs. +# +TestName="four-jobs-tape" +JobName=fourjobstape +. scripts/functions + +scripts/cleanup-tape +scripts/copy-tape-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +estimate job=$JobName listing +estimate job=$JobName listing +estimate job=$JobName listing +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 1 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/dird/*.c ${cwd}/build/src/dird/*.o +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o + +# +# run a second job +# +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 2 done" +touch ${cwd}/build/src/dird/*.c +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a third job +# +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 3 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a fourth job +# +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 4 done" +# +# now do several restores to ensure we cleanup between jobs +# +cat <${cwd}/tmp/bconcmds +@$out /dev/null +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +@$out ${cwd}/tmp/log2.out +@# +@# now unmount the tape and start two restores +@# at the same time +@# +unmount storage=DDS-4 +restore where=${cwd}/tmp/bacula-restores select all done +yes +restore where=${cwd}/tmp/bacula-restores select +unmark * +mark * +done +yes +mount storage=DDS-4 +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/four-jobs-test b/regress/regress/tests/four-jobs-test new file mode 100755 index 0000000000..9af909d8b8 --- /dev/null +++ b/regress/regress/tests/four-jobs-test @@ -0,0 +1,123 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then finally restore. +# It should require at least 4 different bsrs. +# +TestName="four-jobs-test" +JobName=SpanVol +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +estimate job=$JobName listing +estimate job=$JobName listing +estimate job=$JobName listing +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +echo "Backup 1 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/dird/*.c ${cwd}/build/src/dird/*.o +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o + +# +# run a second job +# +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File + +echo "Backup 2 done" +touch ${cwd}/build/src/dird/*.c +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a third job +# +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@output ${cwd}/tmp/log1.out +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File + +echo "Backup 3 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a fourth job +# +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@output ${cwd}/tmp/log1.out +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File + +echo "Backup 4 done" +# +# now do several restores to ensure we cleanup between jobs +# +cat <${cwd}/tmp/bconcmds +@output /dev/null +restore where=${cwd}/tmp/bacula-restores select all storage=File done +yes +wait +restore where=${cwd}/tmp/bacula-restores select all storage=File done +yes +wait +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/gigaslam-sparse-test b/regress/regress/tests/gigaslam-sparse-test new file mode 100755 index 0000000000..f3b560af07 --- /dev/null +++ b/regress/regress/tests/gigaslam-sparse-test @@ -0,0 +1,62 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the Sparse option +# then restore it. +# +TestName="gigaslam-sparse-test" +JobName=SparseTest +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list +cd ${cwd}/build/src/tools +./gigaslam +if [ $? != 0 ]; then + echo "Execute of ${cwd}/build/src/tools/gigaslam failed." + rm -f ${cwd}/build/src/tools/gigaslam.gif + exit 1 +fi +cd ${cwd} + +start_test + +cat >${cwd}/tmp/bconcmds <${cwd}/tmp/file-list +echo "${cwd}/weird-files" >>${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File +TestVolume001 +run job=$JobName +yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File +5 +cd ${cwd}/weird-files/subdir +mark another-hardlink +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +diff ${cwd}/weird-files/subdir/another-hardlink \ + ${cwd}/tmp/bacula-restores/${cwd}/weird-files/subdir/another-hardlink 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/tests/incremental-2disk b/regress/regress/tests/incremental-2disk new file mode 100755 index 0000000000..63098bcd9b --- /dev/null +++ b/regress/regress/tests/incremental-2disk @@ -0,0 +1,104 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +# This script uses the virtual disk autochanger +# +TestName="incremental-2disk" +JobName=Inc2disk +. scripts/functions + + +stop_bacula +cd bin +./drop_bacula_tables >/dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +scripts/copy-2disk-confs +scripts/prepare-two-disks + +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +if test ! -d ${cwd}/tmp/build ; then + mkdir ${cwd}/tmp/build +fi +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +change_jobname $JobName +start_test + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Default drive=0 +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula + +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +run level=Incremental job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole + +check_for_zombie_jobs storage=File +stop_bacula +# +# Delete .c files because we will only restored the txt files +# +rm -f ${cwd}/tmp/build/*.c + +check_two_logs +check_restore_tmp_build_diff + +# +# This script seems to more or less randomly fail, so we +# add extra code here to produce a "dump" in the event of +# an error. +# +if [ $dstat != 0 -o $bstat != 0 -o $rstat != 0 ] ; then + cat ${cwd}/tmp/log1.out + echo " " + cat ${cwd}/tmp/log2.out + echo " " + diff -r ${cwd}/tmp/build ${cwd}/tmp/bacula-restores${cwd}/tmp/build +fi + +end_test diff --git a/regress/regress/tests/incremental-2media b/regress/regress/tests/incremental-2media new file mode 100755 index 0000000000..902f1df5a0 --- /dev/null +++ b/regress/regress/tests/incremental-2media @@ -0,0 +1,73 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental onto a different medium +# and then restore everything. +# +# This script uses the virtual disk autochanger +# +TestName="incremental-2media" +JobName=Inc2media +. scripts/functions + + +scripts/cleanup +scripts/copy-2disk-confs +scripts/prepare-two-disks +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=File volume=TestVolume002 Pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula + +echo "Backup 1 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/dird/*.c ${cwd}/build/src/dird/*.o +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +setdebug level=51 storage=File +run level=Incremental job=$JobName storage=File yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +setdebug level=51 storage=DDS-4 +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole + +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff + +end_test diff --git a/regress/regress/tests/incremental-2media-tape b/regress/regress/tests/incremental-2media-tape new file mode 100755 index 0000000000..65014880f8 --- /dev/null +++ b/regress/regress/tests/incremental-2media-tape @@ -0,0 +1,89 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental onto a different medium +# and then restore everything. +# +# This script uses the two different tape drives. +# +TestName="incremental-2media-tape" +JobName=Inc2mediaTape +. scripts/functions + + +scripts/cleanup +# Get conf files +/bin/cp -f scripts/bacula-dir-2d.conf bin/bacula-dir.conf +/bin/cp -f scripts/bacula-sd-2d.conf bin/bacula-sd.conf +/bin/cp -f scripts/bacula-fd-2d.conf bin/bacula-fd.conf +/bin/cp -f scripts/bconsole-2d.conf bin/bconsole.conf + +# get proper SD tape definitions +cp -f scripts/linux_tape_options bin/tape_options +if test x`uname` = xFreeBSD ; then + cp -f scripts/freebsd_tape_options bin/tape_options +fi + +mt -f /dev/nst0 rewind +mt -f /dev/nst0 weof +mt -f /dev/nst1 rewind +mt -f /dev/nst1 weof + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DLT80 volume=TestVolume002 Pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula + +echo "Backup 1 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/dird/*.c ${cwd}/build/src/dird/*.o +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +setdebug level=51 storage=DLT80 +run level=Incremental job=$JobName storage=DLT80 yes +wait +list volumes +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +setdebug level=51 storage=DDS-4 +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole + +check_for_zombie_jobs storage=DLT80 +stop_bacula + +check_two_logs +check_restore_diff + +end_test diff --git a/regress/regress/tests/incremental-2tape b/regress/regress/tests/incremental-2tape new file mode 100755 index 0000000000..67d4211a20 --- /dev/null +++ b/regress/regress/tests/incremental-2tape @@ -0,0 +1,110 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +# This script uses the autochanger and two tapes +# +. scripts/functions +if test x${AUTOCHANGER} = x/dev/null ; then + echo "incremental-2tape test skipped. No autochanger." + exit +fi +debug=0 +if test "$debug" -eq 1 ; then + out="tee" +else + out="output" +fi +cwd=`pwd` +bin/bacula stop 2>&1 >/dev/null +cd bin +./drop_bacula_tables >/dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +scripts/copy-2tape-confs +scripts/cleanup-2tape +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +if test ! -d ${cwd}/tmp/build ; then + mkdir ${cwd}/tmp/build +fi +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +echo " " +echo " " +echo " === Starting incremental-2tape test ===" +echo " === Starting incremental-2tape test ===" >>working/log +echo " " + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Default drive=0 +run job=NightlySave yes +wait +messages +quit +END_OF_DATA + +if test "$debug" -eq 1 ; then + bin/bacula start + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +grep "^ Termination: *Backup OK" ${cwd}/tmp/log1.out 2>&1 >/dev/null +bstat=$? +grep "^ Termination: *Restore OK" ${cwd}/tmp/log2.out 2>&1 >/dev/null +rstat=$? +# +# Delete .c files because we will only restored the txt files +# +rm -f ${cwd}/tmp/build/*.c +diff -r ${cwd}/tmp/build ${cwd}/tmp/bacula-restores${cwd}/tmp/build 2>&1 >/dev/null +if [ $? != 0 -o $bstat != 0 -o $rstat != 0 ] ; then + echo " " + echo " " + echo " !!!!! incremental-2tape test Bacula source failed!!! !!!!! " + echo " !!!!! incremental-2tape test failed!!! !!!!! " >>test.out + echo " " +else + echo " ===== incremental-2tape test Bacula source OK ===== " + echo " ===== incremental-2tape test OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/tests/incremental-tape b/regress/regress/tests/incremental-tape new file mode 100755 index 0000000000..bd9141e19d --- /dev/null +++ b/regress/regress/tests/incremental-tape @@ -0,0 +1,75 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +TestName="incremental-tape" +JobName=IncTape +. scripts/functions + +copy_tape_confs + +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +if test ! -d ${cwd}/tmp/build ; then + mkdir ${cwd}/tmp/build +fi +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 + +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=Incremental job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=DDS-4 +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@output +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +# +# Delete .c files because we will only restored the txt files +# +rm -f ${cwd}/tmp/build/*.c + +check_two_logs +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/tests/incremental-test b/regress/regress/tests/incremental-test new file mode 100755 index 0000000000..a5149051f6 --- /dev/null +++ b/regress/regress/tests/incremental-test @@ -0,0 +1,170 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +TestName="incremental-test" +JobName=Incremental +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +mkdir ${cwd}/tmp/build +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=100 storage=File +label storage=File volume=TestVolume001 +label storage=File volume=TestVolume002 +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +# +# Now create two new files to be restored later +# +sleep 1 +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +cp -f ${cwd}/tmp/build/dird.c ${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +run level=Differential job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole + +sleep 1 +touch ${cwd}/tmp/build/ficheriro1.txt +touch ${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=Incremental job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole + +sleep 1 +cd ${cwd}/tmp/build +cp -f ficheriro2.txt 1 +sed "s%a%b%g" 1 >ficheriro2.txt +rm -f 1 +cd ${cwd} +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=Differential job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole + +sleep 1 +touch ${cwd}/tmp/build/ficheriro1.txt +touch ${cwd}/tmp/build/ficheriro2.txt +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=Incremental job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole + +sleep 1 +touch ${cwd}/tmp/build/ficheriro1.txt +touch ${cwd}/tmp/build/ficheriro2.txt +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=Incremental job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole + +sleep 1 +touch ${cwd}/tmp/build/ficheriro1.txt +touch ${cwd}/tmp/build/ficheriro2.txt +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=Incremental job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole +sleep 1 +touch ${cwd}/tmp/build/ficheriro1.txt +touch ${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=Incremental job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@output ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File file=<${cwd}/tmp/restore-list +yes +wait +messages +@output +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +# +# Delete .c files because we will only restored the txt files +# +rm -f ${cwd}/tmp/build/*.c +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/tests/lib-tape-root b/regress/regress/tests/lib-tape-root new file mode 100755 index 0000000000..b02c15284f --- /dev/null +++ b/regress/regress/tests/lib-tape-root @@ -0,0 +1,68 @@ +#!/bin/sh +# +# Run a simple backup of the /lib directory +# then restore it. +# +cwd=`pwd` +. scripts/functions +bin/bacula stop 2>&1 >/dev/null +cd bin +./drop_bacula_tables >/dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +scripts/cleanup-tape +scripts/copy-tape-confs +echo "/lib" >${cwd}/tmp/file-list +echo " " +echo " " +echo " === Starting lib-tape-root test ===" +echo " " +echo " " +bin/bacula start 2>&1 >/dev/null +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/restored +cd ${cwd}/tmp +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% original >1 +sort <1 >original +# +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% restored >1 +sort <1 >restored +rm -f 1 +# +cd ${cwd} +diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 1>/dev/nul +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== lib-tape-root failed!!! ===== " + echo " ===== lib-tape-root failed!!! ===== " >>test.out + echo " " +else + echo " ===== lib-tape-root OK ===== " + echo " ===== lib-tape-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/tests/lib-test-root b/regress/regress/tests/lib-test-root new file mode 100755 index 0000000000..54da62c7d4 --- /dev/null +++ b/regress/regress/tests/lib-test-root @@ -0,0 +1,73 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="lib-test-root" +. scripts/functions + +require_root + + +scripts/cleanup +scripts/copy-test-confs +echo "/lib" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@output ${cwd}/tmp/log1.out +label storage=File +TestVolume001 +run job=NightlySave +yes +wait +messages +@# +@# now do a restore +@# +@output ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +# more cleanup to be done below + +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-lib-test lib >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-lib-test lib >${cwd}/tmp/restored +cd ${cwd}/tmp +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% original >1 +sort <1 >original +# +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% restored >1 +sort <1 >restored +rm -f 1 +# +cd ${cwd} +diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 1>/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! lib-test-root failed !!!! ===== " + echo " ===== !!!! lib-test-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== lib-test-root OK ===== " + echo " ===== lib-test-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/tests/maxtime-test b/regress/regress/tests/maxtime-test new file mode 100755 index 0000000000..0452a867c4 --- /dev/null +++ b/regress/regress/tests/maxtime-test @@ -0,0 +1,80 @@ +#!/bin/sh +# +# Test RunScript +# + +TestName="maxtime-test" +JobName=backup + +. scripts/functions + +copy_test_confs + +rm -f bin/bacula-dir.conf +rm -f ${cwd}/tmp/RUN*log +/bin/cp -f scripts/bacula-dir.conf.maxtime bin/bacula-dir.conf +WHEN=$(date '+%Y-%m-%d %H:%M:%S') + +echo "${cwd}/build/po" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +label volume=TestVolume001 pool=PoolA +@$out ${cwd}/tmp/RUN_MAXTIME.log +@# no media => have to wait +run job=RUN_MAXWAITTIME pool=Default yes +@sleep 2 +@# storage is used by RUN_MAXWAITTIME => have to wait +run job=RUN_MAXSTARTDELAY pool=PoolA when="$WHEN" yes +wait +messages +run job=RUN_MAXRUNTIME pool=PoolA yes +wait +messages +st dir +quit +END_OF_DATA + +(mkfifo ${cwd}/tmp/fifo + mkfifo ${cwd}/tmp/fifo2 + mkfifo ${cwd}/tmp/fifo3) 2> /dev/null + +bin/bacula start +cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf > /dev/null +stop_bacula + +rm ${cwd}/tmp/fifo ${cwd}/tmp/fifo2 ${cwd}/tmp/fifo3 + +export dstat=0 +export bstat=0 +export rstat=0 + +if grep -e 'RUN_MAXWAITTIME.* Fatal error: Max wait time exceeded. Job canceled.' ${cwd}/tmp/RUN_MAXTIME.log >/dev/null 2>&1 +then + [ "$debug" = 1 ] && echo MAXWAITTIME ok +else + echo "MAXWAITTIME in error" + rstat=1 +fi + +if grep -e 'RUN_MAXSTARTDELAY.* Fatal error: Job canceled because max start delay time exceeded.' ${cwd}/tmp/RUN_MAXTIME.log && + ! grep -e 'NEVER start this' ${cwd}/tmp/RUN_MAXTIME.log >/dev/null 2>&1 +then + [ "$debug" = 1 ] && echo MAXSTARTDELAY ok +else + echo "MAXSTARTDELAY in error" + rstat=1 +fi + +if grep -e 'RUN_MAXRUNTIME.* Fatal error: Max run time exceeded. Job canceled.' ${cwd}/tmp/RUN_MAXTIME.log >/dev/null 2>&1 +then + [ "$debug" = 1 ] && echo MAXRUNTIME ok +else + echo "MAXRUNTIME in error" + rstat=1 +fi + +end_test diff --git a/regress/regress/tests/maxvol-test b/regress/regress/tests/maxvol-test new file mode 100755 index 0000000000..1e29f85f38 --- /dev/null +++ b/regress/regress/tests/maxvol-test @@ -0,0 +1,64 @@ +#!/bin/sh +# +# Run four jobs at the same time, with four Volumes, but set +# Maximum Job Volumes = 1 on each of the Volumes. Note, +# Volume 2 will probably have two jobs on it. Something to +# be fixed in a later version. +# +TestName="maxvol-test" +JobName=maxvol +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp -f ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +sed "s%# Maximum Volume Jobs% Maximum Volume Jobs%" ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File1 volume=TestVolume001 +label storage=File1 volume=TestVolume002 +label storage=File1 volume=TestVolume003 +label storage=File1 volume=TestVolume004 +update Volume=TestVolume001 MaxVolBytes=100000000 +@#50000000 +@#12 +setdebug level=100 Storage=File1 +run job=$JobName level=Full Storage=File1 yes +run job=$JobName level=Full Storage=File1 yes +run job=$JobName level=Full Storage=File1 yes +wait +list volumes +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File1 +unmark * +mark * +done +yes +wait +reload +reload +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/memory-bug-tape b/regress/regress/tests/memory-bug-tape new file mode 100755 index 0000000000..6ae57fed6e --- /dev/null +++ b/regress/regress/tests/memory-bug-tape @@ -0,0 +1,20058 @@ +#!/bin/sh +# +# Do a whole lot of select commands. This test is one where the +# Director should be run under valgrind. This exercises SQL a bit +# and helps detect orphaned buffers (the SQL engine library code is not +# protected by smartall. +# +TestName="four-concurrent-jobs-tape" +JobName=FourConcurrentJobs +. scripts/functions + +scripts/cleanup-tape +scripts/copy-tape-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full Storage=DDS-4 yes +sql +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * from File; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +SELECT * FROM Media; +@sleep 2 +status dir +@sleep 5 +status dir +status storage=DDS-4 +messages +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/migration-job-test b/regress/regress/tests/migration-job-test new file mode 100755 index 0000000000..69cbe43dc3 --- /dev/null +++ b/regress/regress/tests/migration-job-test @@ -0,0 +1,84 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then migrate it +# to another device. +# +# This script uses the virtual disk autochanger +# +TestName="migration-job-test" +JobName=MigrationJobSave +. scripts/functions + + +scripts/cleanup +scripts/copy-migration-confs +scripts/prepare-two-disks +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +# +# Note, we first backup into Pool Default, +# then Migrate into Pool Full. +# Pool Default uses Storage=File +# Pool Full uses Storage=DiskChanger + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=100 storage=File +label storage=File volume=FileVolume001 Pool=Default +label storage=DiskChanger volume=ChangerVolume001 slot=1 Pool=Full drive=0 +label storage=DiskChanger volume=ChangerVolume002 slot=2 Pool=Full drive=0 +@# run two jobs (both will be migrated) +run job=$JobName yes +run job=$JobName yes +wait +list jobs +list volumes +@#setdebug level=100 dir +@# should migrate two jobs +@#setdebug level=51 storage=DiskChanger +run job=migrate-job yes +wait +messages +@# purge volume=FileVolume001 +list jobs +list volumes +wait +@# +@# Now do another backup, but level Incremental +@# +run job=$JobName level=Incremental yes +wait +messages +@# +@# This final job that runs should be Incremental and +@# not upgraded to full. +list jobs +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +list volumes +restore where=${cwd}/tmp/bacula-restores select storage=DiskChanger +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/migration-jobspan-test b/regress/regress/tests/migration-jobspan-test new file mode 100755 index 0000000000..6910dde4bd --- /dev/null +++ b/regress/regress/tests/migration-jobspan-test @@ -0,0 +1,81 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then migrate it +# to another device. +# +# Test migrating a job that spans two Volumes +# +# This script uses the virtual disk autochanger +# +TestName="migration-jobspan-test" +JobName=MigrationJobSpanSave +. scripts/functions + + +scripts/cleanup +scripts/copy-migration-confs +scripts/prepare-two-disks +echo "${cwd}/build" >${cwd}/tmp/file-list +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + + +change_jobname NightlySave $JobName +start_test + +# +# Note, we first backup into Pool Default, +# then Migrate into Pool Full. +# Pool Default uses Storage=File +# Pool Full uses Storage=DiskChanger + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=10 dir +@#setdebug level=100 storage=File +label storage=File volume=FileVolume001 Pool=Default +label storage=File volume=FileVolume002 Pool=Default +update Volume=FileVolume001 MaxVolBytes=3000000 pool=Default +label storage=DiskChanger volume=ChangerVolume001 slot=1 Pool=Full drive=0 +label storage=DiskChanger volume=ChangerVolume002 slot=2 Pool=Full drive=0 +list volumes +@# +run job=$JobName yes +@#run job=$JobName yes +wait +list volumes +@#setdebug level=200 dir +@# should migrate both Volumes +run job=migrate-job yes +wait +purge volume=FileVolume001 +purge volume=FileVolume002 +list volumes +list jobs +messages +wait +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DiskChanger +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/migration-occupancy-test b/regress/regress/tests/migration-occupancy-test new file mode 100755 index 0000000000..5f19481677 --- /dev/null +++ b/regress/regress/tests/migration-occupancy-test @@ -0,0 +1,70 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then migrate it +# to another device. +# +# This script uses the virtual disk autochanger +# +TestName="migration-occupancy-test" +JobName=MigrationJobSave +. scripts/functions + + +scripts/cleanup +scripts/copy-migration-confs +scripts/prepare-two-disks +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +# +# Note, we first backup into Pool Default, +# then Migrate into Pool Full. +# Pool Default uses Storage=File +# Pool Full uses Storage=DiskChanger + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=FileVolume001 Pool=Default +label storage=DiskChanger volume=ChangerVolume001 slot=1 Pool=Full drive=0 +label storage=DiskChanger volume=ChangerVolume002 slot=2 Pool=Full drive=0 +list volumes +@# run two jobs (both will be migrated) +run job=$JobName yes +run job=$JobName yes +wait +update volume=FileVolume001 VolStatus=Used +list volumes +@# should migrate two jobs +run job=migrate-occupancy yes +list volumes +wait +messages +purge volume=FileVolume001 +wait +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DiskChanger +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/migration-time-test b/regress/regress/tests/migration-time-test new file mode 100755 index 0000000000..99de021cf2 --- /dev/null +++ b/regress/regress/tests/migration-time-test @@ -0,0 +1,77 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then migrate it +# to another device. +# +# This script uses the virtual disk autochanger +# +TestName="migration-time-test" +JobName=MigrationJobSave +. scripts/functions + + +scripts/cleanup +scripts/copy-migration-confs +scripts/prepare-two-disks +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +# +# Note, we first backup into Pool Default, +# then Migrate into Pool Full. +# Pool Default uses Storage=File +# Pool Full uses Storage=DiskChanger + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=FileVolume001 Pool=Default +label storage=DiskChanger volume=ChangerVolume001 slot=1 Pool=Full drive=0 +label storage=DiskChanger volume=ChangerVolume002 slot=2 Pool=Full drive=0 +list volumes +@# run three jobs +run job=$JobName level=Full yes +run job=$JobName level=Full yes +run job=$JobName level=Full yes +wait +update volume=FileVolume001 VolStatus=Used +sql +update Job SET RealEndTime='2004-01-01 12:01:01' WHERE JobId IN (2,3); + +llist jobid=2,3 +list jobs +list volumes +@# should migrate only jobid=2 and 3 +run job=migrate-time yes +wait +messages +wait +purge volume=FileVolume001 +list jobs +list volumes +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DiskChanger +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/migration-volume-test b/regress/regress/tests/migration-volume-test new file mode 100755 index 0000000000..2d5e57885c --- /dev/null +++ b/regress/regress/tests/migration-volume-test @@ -0,0 +1,102 @@ +#!/bin/sh +# +# Run a backup of the Bacula build directory on two Volumes +# then migrate it to another device. +# +# This script uses the virtual disk autochanger +# +TestName="migration-volume-test" +JobName=MigVolBackup +. scripts/functions + + +scripts/cleanup +scripts/copy-migration-confs +scripts/prepare-two-disks +echo "${cwd}/build" >${cwd}/tmp/file-list +#cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +#sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +# +# Note, we first backup into Pool Default, +# then Migrate into Pool Full. +# Pool Default uses Storage=File +# Pool Full uses Storage=DiskChanger + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=FileVolume001 Pool=Default +label storage=File volume=FileVolume002 Pool=Default +update Volume=FileVolume001 MaxVolBytes=3000000 pool=Default +label storage=DiskChanger volume=ChangerVolume001 slot=1 Pool=Full drive=0 +label storage=DiskChanger volume=ChangerVolume002 slot=2 Pool=Full drive=0 +@# +run job=$JobName yes +wait +run job=$JobName yes +wait +update volume=FileVolume001 VolStatus=Used +update volume=FileVolume002 VolStatus=Used +@#list volumes +@#list jobs +@# should migrate two jobs +@# setdebug level=11 dir +@echo "Run migrate-volume Job" +@#setdebug level=100 dir +run job=migrate-volume yes +@sleep 5 +list jobs +llist jobid=1 +llist jobid=2 +llist jobid=3 +llist jobid=4 +llist jobid=5 +status storage=DiskChanger +wait +list volumes +list jobs +llist jobid=1 +llist jobid=2 +llist jobid=3 +llist jobid=4 +llist jobid=5 +sql +select * from JobMedia where JobId=1; + +@# Now run a second Migration job, which should do nothing +run job=migrate-volume yes +wait +list jobs +@# ensure we don't pickup old backup by purging volume +@# purge volume=FileVolume001 +@# purge volume=FileVolume002 +@echo "Now do a restore" +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DiskChanger +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/multi-client-test b/regress/regress/tests/multi-client-test new file mode 100755 index 0000000000..fb61105d19 --- /dev/null +++ b/regress/regress/tests/multi-client-test @@ -0,0 +1,79 @@ +#!/bin/sh +# +# Run four jobs at the same time, with two Volumes. +# Set max Vol bytes of first volume +# to less than total backup to force Bacula to use the second +# Volume. +# +TestName="multi-client-test" +JobName=Multi-client +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +/bin/cp -f scripts/multi-client-bacula-dir.conf bin/bacula-dir.conf + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Make sure we can contact all clients +@#setdebug level=100 dir +status client=${HOST}-fd +status client=${hostname1}-fd +status client=${hostname2}-fd +status client=${hostname3}-fd +setdebug level=1 dir +label storage=File1 +TestVolume001 +label storage=File1 +TestVolume002 +update Volume=TestVolume001 MaxVolBytes=900000000 +status storage=File1 +@#llist volume=TestVolume001 +@#llist volume=TestVolume002 +run job=${hostname1} level=Full Storage=File1 yes +run job=${hostname2} level=Full Storage=File1 yes +@# run job=${hostname3} level=Full Storage=File1 yes +status storage=File1 +run job=$JobName level=Full Storage=File1 yes +@sleep 2 +status dir +status storage=File1 +@sleep 5 +messages +wait +status storage=File1 +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores client=${hostname}-fd select storage=File1 +unmark * +mark * +done +yes +wait +messages +@output +status dir +status storage=File1 +quit +END_OF_DATA + +run_bacula +stop_bacula + +check_two_logs +#if test "$debug" -eq 1 ; then +# diff -r ${hostname_files} ${cwd}/tmp/bacula-restores/${hostname_files} +#else +# diff -r ${hostname_files} ${cwd}/tmp/bacula-restores/${hostname_files} 2>&1 >/dev/null +#fi +#dstat=$? +dstat=0 +end_test diff --git a/regress/regress/tests/query-test b/regress/regress/tests/query-test new file mode 100755 index 0000000000..a4d365e1fe --- /dev/null +++ b/regress/regress/tests/query-test @@ -0,0 +1,120 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do a Differental then a bunch of query commands +# and finally restore the two files. +# +TestName="query-test" +JobName=query +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +mkdir ${cwd}/tmp/build +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +label storage=File volume=TestVolume002 +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@# Force differental on the second Volume +update volume=TestVolume001 VolStatus=Used +run level=differental job=$JobName yes +wait +messages +@output +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run level=incremental job=$JobName yes +wait +messages +@# +@# Now do the queries +@# +query +1 +ficheriro1.txt +query +2 +${cwd}/tmp/build/ +ficheriro1.txt +localhost-fd +query +6 +TestVolume001 +query +7 +1 +query +8 +localhost-fd +query +9 +Default +query +10 +query +11 +query +12 +1 +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File file=<${cwd}/tmp/restore-list +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +# +# Delete .c files because we will only restored the txt files +# +rm -f ${cwd}/tmp/build/*.c + +check_two_logs +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/tests/recycle-test b/regress/regress/tests/recycle-test new file mode 100755 index 0000000000..a42151517f --- /dev/null +++ b/regress/regress/tests/recycle-test @@ -0,0 +1,79 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory but +# create three volumes and do six backups causing the +# volumes to be recycled, and cycling through the volumes +# twice. Tests maxvoljobs and volretention. +# +TestName="recycle-test" +JobName=Recycle +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File1 volume=TestVolume001 +label storage=File1 volume=TestVolume002 +label storage=File1 volume=TestVolume003 +update Volume=TestVolume001 volretention=10s +update Volume=TestVolume001 maxvoljobs=1 +update Volume=TestVolume002 volretention=10s +update Volume=TestVolume002 maxvoljobs=1 +update Volume=TestVolume003 volretention=10s +update Volume=TestVolume003 maxvoljobs=1 +list volumes +run job=$JobName storage=File1 level=full yes +wait +messages +list volumes +run job=$JobName storage=File1 level=full yes +wait +messages +list volumes +run job=$JobName storage=File1 level=full yes +wait +messages +list volumes +@sleep 10 +run job=$JobName storage=File1 level=full yes +wait +messages +list volumes +run job=$JobName storage=File1 level=full yes +wait +messages +list volumes +run job=$JobName storage=File1 level=full yes +wait +messages +list volumes +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File1 +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/regexwhere-test b/regress/regress/tests/regexwhere-test new file mode 100755 index 0000000000..692bd60b36 --- /dev/null +++ b/regress/regress/tests/regexwhere-test @@ -0,0 +1,291 @@ +#!/bin/sh +# +# Test file relocation feature +# + +TestName="regexwhere-test" +JobName=backup + +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs + +/bin/cp -f scripts/bacula-dir.conf.regexwhere bin/bacula-dir.conf + +echo "${cwd}/build/po" >tmp/file-list + +start_test + +cat <tmp/bconcmds +@$out tmp/RUN_backup +messages +label volume=TestVolume001 +run job=backup yes +wait +messages +@################################## +@$out tmp/RUN_JobA +restore +5 +cd ${cwd}/build/po +m *.po +done +1 +yes +wait +messages +@################################## +@$out tmp/RUN_JobB +restore +5 +cd ${cwd}/build/po +m *.po +done +2 +yes +wait +messages +@################################## +@$out tmp/RUN_JobC +restore +5 +cd ${cwd}/build/po +m *.po +done +3 +yes +wait +messages +@################################## +@$out tmp/RUN_JobD +restore +5 +cd ${cwd}/build/po +m *.po +done +4 +yes +wait +messages +@################################## +@$out tmp/RUN_JobE +restore +5 +cd ${cwd}/build/po +m *.po +done +5 +yes +wait +messages +@################################## +@$out tmp/RUN_JobF +restore +5 +cd ${cwd}/build/po +m *.po +done +6 +yes +wait +messages +@################################## +@$out tmp/RUN_JobG +restore strip_prefix="${cwd}" add_prefix="/tmp/bacula-restore" +5 +cd ${cwd}/build/po +m *.po +done +7 +yes +wait +messages +@################################## +@$out tmp/RUN_JobH +restore add_suffix=.old +5 +cd ${cwd}/build/po +m *.po +done +7 +yes +wait +messages +@################################## +@$out tmp/RUN_JobI +restore regexwhere="!Po!old!i,!old!po!,!\$!.old!" +5 +cd ${cwd}/build/po +m *.po +done +7 +yes +wait +messages +@################################## +@$out tmp/RUN_JobJ +restore +5 +cd ${cwd}/build/po +m *.po +done +7 +mod +@## File Relocation -> add suffix -> test -> accept +10 +3 +.old +5 +/etc/passwd +. +6 +@## Where +m +9 +tmp/bacula-restore-it +m +@## use add suffix +10 +3 +.old +6 +yes +wait +messages +@sleep 1 +quit +END_OF_DATA + +run_bacula + +stop_bacula + + +dstat=0 +bstat=0 +rstat=0 +export dstat +export bstat +export rstat + +J=JobA +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "${cwd}/build/po/fr.old.po" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobB +# $cwd begins with / +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "tmp/bacula-restore${cwd}/po/fr.po.old" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobC +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "tmp/bacula-restore${cwd}/build/po/fr.po" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobD +if grep -q "Restore Error" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobE +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "${cwd}/tmp/fr.po" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobF +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "${cwd}/build/po/fr.po" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobG +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "tmp/bacula-restore/build/po/fr.po" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobH +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "${cwd}/build/po/fr.po.old" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +J=JobI +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "${cwd}/build/po/fr.po.old" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + + +J=JobJ +if grep -q "Restore OK" tmp/RUN_$J && + grep -q "/etc/passwd.old" tmp/RUN_$J && + grep -q -e "Where: *tmp/bacula-restore-it" tmp/RUN_$J && + grep -q "${cwd}/build/po/fr.po.old" tmp/RUN_$J +then + [ "$debug" = 1 ] && echo $J ok +else + echo "$J in error" + rstat=1 +fi + +# test with bregtest + +find ${cwd}/build > tmp/list +# thanks to BSD like system for that... +sed -e 's/[Rr][Ee][Aa][Dd][Mm][Ee]/readme/' -e 's/\([ch]\)$/.old.\1/' tmp/list > tmp/list.sed +./build/src/tools/bregtest -s -f tmp/list -e '/readme/readme/i,/([ch])$/.old.$1/' > tmp/list.bsed + +if diff tmp/list.bsed tmp/list.sed >/dev/null 2>&1 +then + [ "$debug" = 1 ] && echo bregtest ok +else + echo "bregtest test in error" + rstat=1 + +fi + +end_test diff --git a/regress/regress/tests/relabel-tape b/regress/regress/tests/relabel-tape new file mode 100755 index 0000000000..15b22c66a1 --- /dev/null +++ b/regress/regress/tests/relabel-tape @@ -0,0 +1,94 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then finally restore. +# It should require at least 4 different bsrs. +# +TestName="relabel-tape" +JobName=Relabeltape +. scripts/functions + +scripts/cleanup-tape +scripts/copy-tape-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full yes +wait +messages +add pool=Default storage=DDS-4 +0 +TestVolume002 +@# set status to append +update volume=TestVolume001 +1 +. +run job=$JobName level=Full yes +wait +unmount storage=DDS-4 +unmount storage=DDS-4 +@#setdebug level=150 storage=DDS-4 +purge volume=TestVolume001 +relabel oldvolume=TestVolume001 volume=TestVolume003 slot=0 pool=Default storage=DDS-4 +list volumes +mount storage=DDS-4 +messages +wait +run job=$JobName level=Full yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 + + +echo "Backup done" +# +# now do several restores to ensure we cleanup between jobs +# +cat <${cwd}/tmp/bconcmds +@$out /dev/null +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +@$out ${cwd}/tmp/log2.out +@# +@# now unmount the tape and start two restores +@# at the same time +@# +unmount storage=DDS-4 +restore where=${cwd}/tmp/bacula-restores select all done +yes +restore where=${cwd}/tmp/bacula-restores select +unmark * +mark * +done +yes +mount storage=DDS-4 +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole + +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/restore-by-file-tape b/regress/regress/tests/restore-by-file-tape new file mode 100755 index 0000000000..2eb84d8150 --- /dev/null +++ b/regress/regress/tests/restore-by-file-tape @@ -0,0 +1,100 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape where the maximum tape file size is set to 1M +# then restore a few files from it. Note, by setting the maximum +# file size to 1M, it runs very slow. There are about 64 files that +# are created during each of the two backups. +# +TestName="restore-by-file-tape" +JobName=restorebyfile +. scripts/functions +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list +sed s%\^%${cwd}% ${cwd}/scripts/flist | sort | uniq >${cwd}/tmp/restore2-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=DDS-4 file=<${cwd}/tmp/restore2-list +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +dstat=0 +# +# We need to stop and start Bacula to +# test appending to a previously written tape +# +for i in `cat ${cwd}/tmp/restore2-list`; do + diff $i ${cwd}/tmp/bacula-restores$i + if [ $? != 0 ] ; then + dstat=1 + fi +done + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +run job=$JobName level=Full yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores +7 +<${cwd}/tmp/restore2-list + +yes +wait +messages +@output +quit +END_OF_DATA + +# +# Bacula was stopped, but we must restart it to +# test appending to a previously written tape +# +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs + +scripts/check_for_zombie_jobs storage=DDS-4 +bin/bacula stop 2>&1 >/dev/null +for i in `cat ${cwd}/tmp/restore2-list`; do + diff $i ${cwd}/tmp/bacula-restores$i + if [ $? != 0 ] ; then + dstat=1 + fi +done + +end_test diff --git a/regress/regress/tests/restore-by-file-test b/regress/regress/tests/restore-by-file-test new file mode 100755 index 0000000000..ec5a70fc22 --- /dev/null +++ b/regress/regress/tests/restore-by-file-test @@ -0,0 +1,55 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then restore it. +# + +TestName="restore-by-file-test" +JobName=restorebyfile +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +mkdir ${cwd}/tmp/build +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp/build +ls >../1 +cd .. +sed s%\^%${cwd}/tmp/build/% 1 | sort | uniq >restore-list +rm -f 1 +cd ${cwd} + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/tests/restore-disk-seek-test b/regress/regress/tests/restore-disk-seek-test new file mode 100755 index 0000000000..38fc0f7b7b --- /dev/null +++ b/regress/regress/tests/restore-disk-seek-test @@ -0,0 +1,93 @@ +#!/bin/sh +# +# Run a backup of the full bacula build directory, but with the +# Maximum File Size set. Then do a restore of a few files to kick in +# disk seeking (not yet enabled), and ensure that the restored files +# match. Even though disk seeking is not yet enabled, this is a good test, +# and once it is enabled, this will test it. +# +TestName="restore-disk-seek-test" +JobName=restore-disk-seek +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +rm -rf ${cwd}/tmp/build +mkdir ${cwd}/tmp/build +# Copy only the .c files (to be restored) +# set files to "*.c" for all c files +files="ua_tree.c ua_update.c" +# files="*.c" +for i in ${files}; do + cp -p ${cwd}/build/src/dird/${i} ${cwd}/tmp/build +done +cd ${cwd}/tmp/build +ls >../1 +cd .. +sed s%\^%${cwd}/tmp/build/% 1 | sort | uniq >restore-list +# +# At this point restore-list contains the list +# of files we will restore +# +rm -f 1 +cd ${cwd} +# +# Now arrange to backup *everything* +# +rm -rf ${cwd}/tmp/build +mkdir ${cwd}/tmp/build +cp -fp ${cwd}/build/src/dird/* ${cwd}/tmp/build +# +# Enable MaximumFileSize to ensure lots of JobMedia records and thus +# lots of seeking +# +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +setdebug level=30 fd +setdebug level=11 storage=File +sql +@# print the JobMedia records +select * from JobMedia; + +restore bootstrap=${cwd}/tmp/kern.bsr where=${cwd}/tmp/bacula-restores storage=File +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +# Now setup a control directory of only what we *should* restore +rm -rf ${cwd}/tmp/build +mkdir ${cwd}/tmp/build +for i in ${files}; do + cp -p ${cwd}/build/src/dird/${i} ${cwd}/tmp/build +done + +check_two_logs +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/tests/restore-seek-tape b/regress/regress/tests/restore-seek-tape new file mode 100755 index 0000000000..aa394beb60 --- /dev/null +++ b/regress/regress/tests/restore-seek-tape @@ -0,0 +1,92 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape where the maximum tape file size is set to 1M +# then restore a few files from it. Note, by setting the maximum +# file size to 1M, it runs very slow. This tests the +# seeking capability +# +TestName="restore-seek-tape" +JobName=restore-tape-seek +. scripts/functions + +copy_tape_confs +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +rm -rf ${cwd}/tmp/build +mkdir ${cwd}/tmp/build +# Copy only the .c files (to be restored) +# set files to "*.c" for all c files +files="ua_tree.c ua_update.c" +# files="*.c" +for i in ${files}; do + cp -p ${cwd}/build/src/dird/${i} ${cwd}/tmp/build +done +cd ${cwd}/tmp/build +ls >../1 +cd .. +sed s%\^%${cwd}/tmp/build/% 1 | sort | uniq >restore-list +# +# At this point restore-list contains the list +# of files we will restore +# +rm -f 1 +cd ${cwd} +# +# Now arrange to backup *everything* +# +rm -rf ${cwd}/tmp/build +mkdir ${cwd}/tmp/build +cp -fp ${cwd}/build/src/dird/* ${cwd}/tmp/build +# +# Enable MaximumFileSize to ensure lots of JobMedia records and thus +# lots of seeking +# +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size = 1000000% Maximum File Size = 10KB%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 pool=Default +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +setdebug level=30 fd +setdebug level=10 storage=DDS-4 +sql +@# print the JobMedia records +select * from JobMedia; + +restore bootstrap=${cwd}/tmp/kern.bsr where=${cwd}/tmp/bacula-restores storage=DDS-4 +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +# Now setup a control directory of only what we *should* restore +rm -rf ${cwd}/tmp/build +mkdir ${cwd}/tmp/build +for i in ${files}; do + cp -p ${cwd}/build/src/dird/${i} ${cwd}/tmp/build +done + +check_two_logs +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/tests/restore2-by-file-test b/regress/regress/tests/restore2-by-file-test new file mode 100755 index 0000000000..1a4553ab14 --- /dev/null +++ b/regress/regress/tests/restore2-by-file-test @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then restore a few selected files. +# +TestName="restore2-by-file-test" +JobName=restore2byfile +. scripts/functions +copy_test_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list +sed s%\^%${cwd}% ${cwd}/scripts/flist | sort | uniq >${cwd}/tmp/restore2-list + +change_jobname CompressedTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File file=<${cwd}/tmp/restore2-list +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +dstat=0 +for i in `cat ${cwd}/tmp/restore2-list`; do + diff $i ${cwd}/tmp/bacula-restores$i + if [ $? != 0 ] ; then + dstat=1 + fi +done +end_test diff --git a/regress/regress/tests/runscript-test b/regress/regress/tests/runscript-test new file mode 100755 index 0000000000..2dceb5d36d --- /dev/null +++ b/regress/regress/tests/runscript-test @@ -0,0 +1,145 @@ +#!/bin/sh +# +# Test RunScript +# + +TestName="runscript-test" +JobName=backup + +. scripts/functions +copy_test_confs + +rm -f bin/bacula-dir.conf +rm -f ${cwd}/tmp/RUN*log +rm -f ${cwd}/tmp/RUN_FD_FAILED + +touch ${cwd}/tmp/log1.out +/bin/cp -f scripts/bacula-dir.conf.testrunscript bin/bacula-dir.conf + +echo "${cwd}/build/po" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +label volume=TestVolume001 +@$out ${cwd}/tmp/RUN_FD_WARNING.log +run job=RUN_FD_WARNING yes +wait +messages +@sleep 1 +@$out ${cwd}/tmp/RUN_ALL_OK.log +run job=RUN_ALL_OK yes +wait +messages +@sleep 1 +@$out ${cwd}/tmp/RUN_FD_FAILED.log +run job=RUN_FD_FAILED yes +wait +messages +@sleep 1 +@$out ${cwd}/tmp/RUN_DIR_FAILED.log +run job=RUN_DIR_FAILED yes +wait +messages +@sleep 1 +@$out ${cwd}/tmp/RUN_FD_FAILED2.log +run job=RUN_FD_FAILED2 yes +wait +messages +st dir +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +dstat=0 +bstat=0 +rstat=0 +export dstat +export bstat +export rstat + +grep 'dir: BeforeJob: run command "/bin/echo RunBeforeJob"' ${cwd}/tmp/RUN_ALL_OK.log >/dev/null 2>&1 +a=$? +grep 'fd: ClientRunBeforeJob: ClientRunBeforeJob' ${cwd}/tmp/RUN_ALL_OK.log >/dev/null 2>&1 +b=$? +grep 'fd: ClientAfterJob: run command "/bin/echo ClientRunAfterJob' ${cwd}/tmp/RUN_ALL_OK.log >/dev/null 2>&1 +c=$? +grep 'dir: AfterJob: run command "/bin/echo RunAfterJob' ${cwd}/tmp/RUN_ALL_OK.log >/dev/null 2>&1 +d=$? +if [ $a = 0 -a $b = 0 -a $c = 0 -a $d = 0 ] +then + [ "$debug" = 1 ] && echo RUN_ALL_OK ok +else + echo "RUN_ALL_OK in error" + rstat=1 +fi + +grep 'dir: BeforeJob: run command "/bin/false RUN_DIR_FAILED"' ${cwd}/tmp/RUN_DIR_FAILED.log >/dev/null 2>&1 +a=$? +grep 'dir: AfterJob: RunAfterFailedJob' ${cwd}/tmp/RUN_DIR_FAILED.log >/dev/null 2>&1 +b=$? +if [ $a = 0 -a $b = 0 ] +then + [ "$debug" = 1 ] && echo RUN_DIR_FAILED ok +else + echo "RUN_DIR_FAILED in error" + rstat=1 +fi + +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED1"' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +a=$? +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED2"' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +b=$? +grep 'dir: AfterJob: run command "/bin/echo RunAfterFailedJob"' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +c=$? +#grep 'touching' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +test -f ${cwd}/tmp/RUN_FD_FAILED +d=$? +grep '*** Backup Error ***' ${cwd}/tmp/RUN_FD_FAILED.log >/dev/null 2>&1 +e=$? +if [ $a = 0 -a $b = 0 -a $c = 0 -a $d = 0 -a $e = 0 ] +then + [ "$debug" = 1 ] && echo RUN_FD_FAILED ok +else + echo "RUN_FD_FAILED in error" + rstat=1 +fi + +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED1"' ${cwd}/tmp/RUN_FD_FAILED2.log >/dev/null 2>&1 +a=$? +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED2"' ${cwd}/tmp/RUN_FD_FAILED2.log >/dev/null 2>&1 +b=$? +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED3"' ${cwd}/tmp/RUN_FD_FAILED2.log >/dev/null 2>&1 +c=$? +grep 'dir: AfterJob: run command "/bin/echo RunAfterFailedJob"' ${cwd}/tmp/RUN_FD_FAILED2.log >/dev/null 2>&1 +d=$? +grep '*** Backup Error ***' ${cwd}/tmp/RUN_FD_FAILED2.log >/dev/null 2>&1 +e=$? +if [ $a = 0 -a $b != 0 -a $c = 0 -a $d = 0 -a $e = 0 ] +then + [ "$debug" = 1 ] && echo RUN_FD_FAILED ok +else + echo "RUN_FD_FAILED2 in error" + rstat=1 +fi + +grep 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_WARNING"' ${cwd}/tmp/RUN_FD_WARNING.log >/dev/null 2>&1 +a=$? +grep 'RunAfterFailedJob' ${cwd}/tmp/RUN_FD_WARNING.log >/dev/null 2>&1 +b=$? +grep 'Backup OK -- with warnings' ${cwd}/tmp/RUN_FD_WARNING.log >/dev/null 2>&1 +c=$? +if [ $a = 0 -a $b != 0 -a $c = 0 ] +then + [ "$debug" = 1 ] && echo RUN_FD_WARNING ok +else + echo "RUN_FD_WARNING in error" + rstat=1 +fi + +end_test diff --git a/regress/regress/tests/scratch-pool-test b/regress/regress/tests/scratch-pool-test new file mode 100755 index 0000000000..47a8cb96e8 --- /dev/null +++ b/regress/regress/tests/scratch-pool-test @@ -0,0 +1,72 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to two tapes where the maximum tape file size is set to 1M +# Note, this test simulates the tape filling and writing to +# the next tape. One minor wrinkle: we create the two tapes +# in the Scratch pool, so they should be switched to the Default +# Pool automatically. +# We set TestVolume001 to not in the changer, so the algorithm +# should find TestVolume002 and use it rather than blocking. +# +# Note we use the viritual disk autochanger +# +TestName="scratch-pool-test" +JobName=scratch-pool +. scripts/functions + +if test x${AUTOCHANGER} = x/dev/null ; then + echo "two-volume-test skipped. No autochanger." + exit +fi +cwd=`pwd` +scripts/cleanup +scripts/copy-2disk-confs +scripts/prepare-two-disks + +echo "${cwd}/build" >${cwd}/tmp/file-list + +outf="${cwd}/tmp/sed_tmp" +echo "s%# Maximum File Size% Maximum File Size%g" >${outf} +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Scratch drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Scratch drive=0 +update Volume=TestVolume001 MaxVolBytes=2000000 pool=Scratch drive=0 +update Volume=TestVolume001 inchanger=no pool=Scratch drive=0 +@#setdebug level=200 storage=DDS-4 +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=$JobName yes +wait +messages +list volumes +llist volume=TestVolume001 +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/six-vol-test b/regress/regress/tests/six-vol-test new file mode 100755 index 0000000000..9b4571fee1 --- /dev/null +++ b/regress/regress/tests/six-vol-test @@ -0,0 +1,69 @@ +#!/bin/sh +# +# Create a 60MB file with random bytes. Back it up to 6 Volumes +# each constrained to 10MB using the automatic labeling feature. +# +TestName="six-vol-test" +JobName=SixVol +. scripts/functions + +if test ! -c /dev/urandom ; then + echo "No random device. Test skipped.\n" + exit 0 +fi + +scripts/cleanup +scripts/copy-testa-confs +# copy special conf file +/bin/cp -f scripts/testb-bacula-dir.conf bin/bacula-dir.conf + +echo "${cwd}/tmp/largefile" >${cwd}/tmp/file-list +# Create 56MB file with random data +echo "Creating a 56MB file with random data ..." +dd if=/dev/urandom of=${cwd}/tmp/largefile bs=1024 count=55000 +echo "largefile created" + +change_jobname MultiVol $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=50 storage=File +run job=$JobName storage=File yes +run job=$JobName storage=File yes +run job=$JobName storage=File yes +run job=$JobName storage=File yes +run job=$JobName storage=File yes +wait +list volumes +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +sql +select * from JobMedia where JobId=4; +select * from JobMedia where JobId=5; + +@#setdebug level=50 storage=File +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +diff ${cwd}/tmp/largefile ${cwd}/tmp/bacula-restores${cwd}/tmp/largefile 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/tests/small-file-size-tape b/regress/regress/tests/small-file-size-tape new file mode 100755 index 0000000000..d6e8163a9a --- /dev/null +++ b/regress/regress/tests/small-file-size-tape @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape where the maximum tape file size is set to 1M +# +TestName="small-file-size-tape" +JobName=smallfilesize +. scripts/functions + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +setdebug level=2 storage=DDS-4 +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/span-vol-test b/regress/regress/tests/span-vol-test new file mode 100755 index 0000000000..d687c7d526 --- /dev/null +++ b/regress/regress/tests/span-vol-test @@ -0,0 +1,55 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory but +# split the archive into four volumes, two of which are +# totally full. I.e. make sure that bsr selects all tapes +# including those fully spanned. +# +TestName="span-vol-test" +JobName=SpanVol +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File1 volume=TestVolume004 +label storage=File1 volume=TestVolume003 +label storage=File1 volume=TestVolume002 +label storage=File1 volume=TestVolume001 +update Volume=TestVolume004 MaxVolBytes=3000000 +update Volume=TestVolume003 MaxVolBytes=3000000 +update Volume=TestVolume002 MaxVolBytes=3000000 +run job=$JobName storage=File1 yes +wait +list volumes +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File1 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/sparse-compressed-test b/regress/regress/tests/sparse-compressed-test new file mode 100755 index 0000000000..47e05e41c1 --- /dev/null +++ b/regress/regress/tests/sparse-compressed-test @@ -0,0 +1,43 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the Sparse option +# then restore it. +# +TestName="sparse-compressed-test" +JobName=Sparse-conpressed +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +start_test + +cat >${cwd}/tmp/bconcmds <${cwd}/tmp/file-list +cd ${cwd}/build/src/tools +./gigaslam +if [ $? != 0 ]; then + echo "Execute of ${cwd}/build/src/tools/gigaslam failed." + rm -f ${cwd}/build/src/tools/gigaslam.gif + exit 1 +fi +cd ${cwd} + +change_jobname SparseTest $JobName +start_test + +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@$out ${cwd}/tmp/log1.out +label storage=File volume=TestVolume001 +setdebug level=10 fd +run job=$JobName yes +wait +messages +list volumes +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +@# setdebug level=0 fd +restore where=${cwd}/tmp/bacula-restores storage=File +5 +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +sleep 2 +check_for_zombie_jobs storage=File +stop_bacula + +if [ ! -f ${cwd}/tmp/bacula-restores/${cwd}/build/src/tools/gigaslam.gif ]; then + echo "============= file gigaslam.gif was not restored =======" + size=0 +else + size=`du ${cwd}/tmp/bacula-restores/${cwd}/build/src/tools/gigaslam.gif | cut -f 1` + if [ $size -gt 120 ]; then + echo "========== restored sparse file: gigaslam.gif too big =========" + echo " size is ${size}K it should be 120K" + fi +fi + +check_two_logs +check_restore_diff +end_test +rm -f ${cwd}/build/src/tools/gigaslam.gif +rm -f ${cwd}/build/gigaslam.gif diff --git a/regress/regress/tests/sparse-test b/regress/regress/tests/sparse-test new file mode 100755 index 0000000000..38d12fd998 --- /dev/null +++ b/regress/regress/tests/sparse-test @@ -0,0 +1,45 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the Sparse option +# then restore it. +# +TestName="sparse-test" +JobName=SparseTest +. scripts/functions + +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +start_test + +cat >${cwd}/tmp/bconcmds <test.out +rm -f bin/working/* diff --git a/regress/regress/tests/three-pool-recycle-test b/regress/regress/tests/three-pool-recycle-test new file mode 100755 index 0000000000..57790ce9e6 --- /dev/null +++ b/regress/regress/tests/three-pool-recycle-test @@ -0,0 +1,106 @@ +#!/bin/sh +# +# This is Arno's test. It uses three pools, three tapes, and +# an autochanger. Note, the Director has four Pools in its +# conf: Default, Full, Inc, and Scratch. Default is used in the +# NightlySave job by default. What is backed up is what +# is in ${cwd}/tmp/file-list, which is by default the Bacula +# source code (i.e. the build directory). +# +# Note, we use the virtual disk autochanger. +# +TestName="three-pool-recycle-test" +JobName=Three-pool-recycle +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-2disk-confs +scripts/prepare-two-disks + +# remove Client Run Before Job +cp ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +sed "s%Client Run Before Job%#Client Run Before Job%" ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + +echo "${cwd}/build" >${cwd}/tmp/file-list + +start_test + +# Write out bconsole commands to a file +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=150 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Full drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +label storage=DDS-4 volume=TestVolume003 slot=3 pool=Scratch drive=0 +update Volume=TestVolume001 maxvoljobs=1 +update Volume=TestVolume002 maxvoljobs=1 +update Volume=TestVolume003 volretention=7s +update Volume=TestVolume003 maxvoljobs=1 +list volumes +llist volume=TestVolume003 +@# should pull Scratch volume +run job=NightlySave1 level=Full pool=Inc yes +wait +update Volume=TestVolume003 volretention=7s +update Volume=TestVolume003 maxvoljobs=1 +messages +list volumes +llist volume=TestVolume003 +run job=NightlySave1 level=Full pool=Default yes +wait +messages +list volumes +llist volume=TestVolume003 +run job=NightlySave1 level=Full pool=Full yes +wait +@sleep 10 +messages +list volumes +llist volume=TestVolume003 +@# should recycle Scratch pool +run job=NightlySave2 level=Full pool=Inc yes +wait +update Volume=TestVolume003 volretention=7s +update Volume=TestVolume003 maxvoljobs=1 +@sleep 10 +messages +list volumes +@# should recycle Scratch pool +llist volume=TestVolume003 +@#setdebug level=50 dir +run job=NightlySave2 level=Full pool=Default yes +wait +update Volume=TestVolume003 volretention=7s +update Volume=TestVolume003 maxvoljobs=1 +@sleep 10 +messages +list volumes +@# should recycle Scratch pool +run job=NightlySave2 level=Full pool=Full yes +status storage=DDS-4 +messages +wait +list volumes +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/three-pool-test b/regress/regress/tests/three-pool-test new file mode 100755 index 0000000000..92ff97f656 --- /dev/null +++ b/regress/regress/tests/three-pool-test @@ -0,0 +1,83 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory. Create three +# tapes, each in a different pool, then run two jobs both of which +# want the tape that is not loaded. Note, they both have +# prefers non-mounted tapes. This should expose bug #801 +# +# This script uses the virtual disk autochanger and two drives +# +TestName="three-pool-disk" +JobName="threepooldisk" +. scripts/functions + +scripts/cleanup +scripts/copy-2disk-drive-confs +scripts/prepare-two-disks + +echo "${cwd}/build" >${cwd}/tmp/file-list +change_jobname NightlySave $JobName +start_test + +# Turn off Prefer Mounted Volumes so we use 2 drives +outf="${cwd}/tmp/sed_tmp" +echo "s%# Prefer Mounted Volumes% Prefer Mounted Volumes%g" >${outf} +cp ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +# Comment the next line out to write everything to one drive +# otherwise, it writes the two jobs to different drives +sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + +# Write out bconsole commands +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +@$out ${cwd}/tmp/log1.out +@#setdebug level=200 storage=DDS-4 +@#setdebug level=200 client +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Full drive=0 +label storage=DDS-4 volume=TestVolume003 slot=3 Pool=Inc drive=1 +status storage=DDS-4 +run job=$JobName level=Full Pool=Default yes +run job=$JobName level=Full Pool=Default yes +run job=$JobName level=Full Pool=Default yes +run job=$JobName level=Full Pool=Default yes +run job=$JobName level=Full Pool=Default yes +@sleep 10 +status storage=DDS-4 +list volumes +wait +list volumes +list jobs +status storage=DDS-4 +messages +quit +END_OF_DATA + +# exit + +run_bacula +cat <${cwd}/tmp/bconcmds +@$out /dev/null +messages +@# +@# now do a restore +@# +@$out ${cwd}/tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole + +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff + +end_test diff --git a/regress/regress/tests/tls-test b/regress/regress/tests/tls-test new file mode 100755 index 0000000000..8e8899408e --- /dev/null +++ b/regress/regress/tests/tls-test @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory with TLS +# communications code enabled then restore it. +# +TestName="tls-test" +JobName=tls +. scripts/functions + +scripts/cleanup +scripts/copy-tls-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname CompressedTest $JobName +start_test + +cat <tmp/bconcmds +@output +messages +@$out tmp/log1.out +status all +status all +messages +label storage=File volume=TestVolume001 pool=Default +run job=$JobName storage=File yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/truncate-bug-tape b/regress/regress/tests/truncate-bug-tape new file mode 100755 index 0000000000..98c0b8387e --- /dev/null +++ b/regress/regress/tests/truncate-bug-tape @@ -0,0 +1,86 @@ +#!/bin/sh +# +# Test for a tape truncation bug. +# +TestName="truncate-bug-tape" +JobName=truncatebug +. scripts/functions + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +@# do a bunch of saves so we have 12 files on the tape +run job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +@#setdebug level=100 storage=DDS-4 +wait +messages +quit +END_OF_DATA + +run_bacula +scripts/check_for_zombie_jobs storage=DDS-4 + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log2.out +@# +@# now do a restore +@# +restore where=${cwd}/tmp/bacula-restores storage=DDS-4 +3 +@# select JobId=4 (i.e. file five on the tape) +4 +cd ${cwd}/build +@# mark a single file +mark configure +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bconsole +scripts/check_for_zombie_jobs storage=DDS-4 + +# Now write to tape one more time +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log3.out +run level=Full job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +grep "^ Termination: *Backup OK" tmp/log3.out 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/tests/two-jobs-test b/regress/regress/tests/two-jobs-test new file mode 100755 index 0000000000..4f1fdabdcd --- /dev/null +++ b/regress/regress/tests/two-jobs-test @@ -0,0 +1,79 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup a second time and finally restore it +# +TestName="two-jobs-test" +JobName=Two-Jobs +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname CompressedTest $JobName +start_test + +cat >tmp/bconcmds <tmp/bconcmds <${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list + +start_test + +# Write out bconsole commands to a file +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Full drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +list volumes +@# Start job with Client run before and sleep +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +@# wait between starting jobs +@sleep 60 +@#setdebug level=100 storage=DDS-4 +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +@sleep 10 +messages +@sleep 10 +messages +@sleep 10 +status storage=DDS-4 +messages +wait +list volumes +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/two-pool-test b/regress/regress/tests/two-pool-test new file mode 100755 index 0000000000..e6d729acc6 --- /dev/null +++ b/regress/regress/tests/two-pool-test @@ -0,0 +1,77 @@ +#!/bin/sh +# +# This is Arno's test. It uses two pools, two tapes, and +# an autochanger. Note, the Director has three Pools in its +# conf: Default, Full, and Inc. Default is used in the +# NightlySave job by default. What is backed up is what +# is in ${cwd}/tmp/file-list, which is by default the Bacula +# source code (i.e. the build directory). +# +# Note, we use the virtual disk autochanger. +# +TestName="two-pool-test" +JobName=Two-pool +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-2disk-confs +scripts/prepare-two-disks + +# Make a relatively large backup set 5 x source code directory +# Reduced to 1 for portable +echo "${cwd}/build" >${cwd}/tmp/file-list +echo "${cwd}/build" >${cwd}/tmp/file-list +echo "${cwd}/build" >${cwd}/tmp/file-list +echo "${cwd}/build" >${cwd}/tmp/file-list + +start_test + +# Write out bconsole commands to a file +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +@#setdebug level=150 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Full drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +list volumes +@# Start job with Client run before and sleep +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +@# wait between starting jobs +@sleep 30 +@#setdebug level=100 storage=DDS-4 +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +@sleep 10 +messages +@sleep 10 +messages +@sleep 10 +status storage=DDS-4 +messages +wait +list volumes +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/two-vol-test b/regress/regress/tests/two-vol-test new file mode 100755 index 0000000000..15f48ee5b2 --- /dev/null +++ b/regress/regress/tests/two-vol-test @@ -0,0 +1,46 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory but +# split the archive into two volumes +# +TestName="two-vol-test" +JobName=TwoVol +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=File1 volume=TestVolume002 +label storage=File1 volume=TestVolume001 +update Volume=TestVolume002 MaxVolBytes=3000000 +run job=$JobName storage=File1 yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=File1 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File1 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/two-volume-tape b/regress/regress/tests/two-volume-tape new file mode 100755 index 0000000000..e6c5312e24 --- /dev/null +++ b/regress/regress/tests/two-volume-tape @@ -0,0 +1,84 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to two tapes where the maximum tape file size is set to 1M +# Note, this test simulates the tape filling and writing to +# the next tape. +# +TestName="two-volume-tape" +JobName=twovoltape +. scripts/functions + +if test x${AUTOCHANGER} = x/dev/null ; then + echo "two-volume-tape test skipped. No autochanger." + exit +fi + +scripts/cleanup +scripts/copy-2tape-confs +scripts/prepare-two-tapes + +echo "${cwd}/build" >${cwd}/tmp/file-list + +outf="tmp/sed_tmp" +echo "s%# Maximum File Size% Maximum File Size%g" >${outf} +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname $JobName +start_test + +# Write out bconsole commands +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +update Volume=TestVolume001 MaxVolBytes=3000000 pool=Default drive=0 +sql +select * from Storage; +select VolumeName,InChanger,Slot,StorageId from Media; + +@#setdebug level=1000 client +@#setdebug level=250 storage=DDS-4 +run job=$JobName yes +wait +sql +select * from Storage; +select VolumeName,InChanger,Slot,StorageId from Media; + +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +mt -f ${TAPE_DRIVE} rewind +mtx -f ${AUTOCHANGER} unload +sleep 15 + +cat <tmp/bconcmds +@$out /dev/null +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/two-volume-test b/regress/regress/tests/two-volume-test new file mode 100755 index 0000000000..1266e75d76 --- /dev/null +++ b/regress/regress/tests/two-volume-test @@ -0,0 +1,68 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to two tapes where the maximum tape file size is set to 1M +# Note, this test simulates the tape filling and writing to +# the next tape. +# +# Note we use the viritual disk autochanger +# +TestName="two-volume-test" +JobName=TwoVolume +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-2disk-confs +scripts/prepare-two-disks + +echo "${cwd}/build" >${cwd}/tmp/file-list + +outf="tmp/sed_tmp" +echo "s%# Maximum File Size% Maximum File Size%g" >${outf} +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +# Write out bconsole commands +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +update Volume=TestVolume001 MaxVolBytes=3000000 pool=Default drive=0 +sql +select * from Storage; +select VolumeName,InChanger,StorageId from Media; + +@#setdebug level=1000 client +run job=$JobName yes +wait +update slots scan storage=DDS-4 +sql +select * from Storage; +select VolumeName,InChanger,StorageId from Media; + +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/tests/usr-tape-root b/regress/regress/tests/usr-tape-root new file mode 100755 index 0000000000..dbc0ed9daf --- /dev/null +++ b/regress/regress/tests/usr-tape-root @@ -0,0 +1,63 @@ +#!/bin/sh +# +# Run a simple backup of the /usr directory +# then restore it. +# +cwd=`pwd` +. scripts/functions +scripts/copy-tape-confs +scripts/cleanup-tape +echo "/usr" >${cwd}/tmp/file-list + +echo " " +echo " " +echo " === Starting usr-tape-root test ===" +echo " " +echo " " + +bin/bacula start 2>&1 >/dev/null +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/restored +cd ${cwd}/tmp +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% original >1 +sort <1 >original +# +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% restored >1 +sort <1 >restored +rm -f 1 +# +cd ${cwd} +diff tmp/original tmp/restored 2>&1 1>/dev/nul +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! usr-tape-root failed !!!! ===== " + echo " ===== !!!! usr-tape-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== usr-tape-root OK ===== " + echo " ===== usr-tape-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/tests/verify-cat-test b/regress/regress/tests/verify-cat-test new file mode 100755 index 0000000000..909dfedc32 --- /dev/null +++ b/regress/regress/tests/verify-cat-test @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple Verify InitCatalog, then Verify Catalog +# +TestName="verify-cat-test" +JobName=VerifyCatalog +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list +#echo "${cwd}/do_all" >${cwd}/tmp/file-list +#echo "${cwd}/do_all_tapes" >>${cwd}/tmp/file-list +#echo "${cwd}/do_file" >>${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=VerifyVolume level=InitCatalog yes +wait +messages +@# +@# now do a verify Catalog +@# +@$out ${cwd}/tmp/original +run job=VerifyVolume level=Catalog yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula + +sleep 2 +check_for_zombie_jobs storage=File +stop_bacula + +grep "^ Termination: *Verify OK" tmp/log1.out 2>&1 >/dev/null +bstat=$? +grep "^ Termination: *Verify OK" ${cwd}/tmp/original 2>&1 >/dev/null +rstat=$? +dstat=0 +end_test diff --git a/regress/regress/tests/verify-vol-tape b/regress/regress/tests/verify-vol-tape new file mode 100755 index 0000000000..9927adee7b --- /dev/null +++ b/regress/regress/tests/verify-vol-tape @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then verify the catalog. +# +TestName="verify-vol-tape" +JobName=VerifyVol +. scripts/functions + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +setdebug level=1 storage=DDS-4 sd +label storage=DDS-4 volume=TestVolume001 pool=Default +run job=$JobName yes +wait +messages +@# +@# now do a verify volume +@# +@$out ${cwd}/tmp/original +run job=VerifyTape pool=Default +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula + +sleep 2 +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +grep "^ Termination: *Backup OK" tmp/log1.out 2>&1 >/dev/null +bstat=$? +grep "^ Termination: *Verify OK" ${cwd}/tmp/original 2>&1 >/dev/null +rstat=$? +dstat=0 +end_test diff --git a/regress/regress/tests/verify-vol-test b/regress/regress/tests/verify-vol-test new file mode 100755 index 0000000000..88e875ac66 --- /dev/null +++ b/regress/regress/tests/verify-vol-test @@ -0,0 +1,51 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then verify the catalog. +# +TestName="verify-vol-test" +JobName=VerifyVol +. scripts/functions + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +setdebug level=1 storage=File sd +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +@# +@# now do a verify volume +@# +@$out ${cwd}/tmp/original +setdebug level=12 dir +run job=VerifyVolume +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula + +sleep 2 +check_for_zombie_jobs storage=File +stop_bacula + +grep "^ Termination: *Backup OK" tmp/log1.out 2>&1 >/dev/null +bstat=$? +grep "^ Termination: *Verify OK" ${cwd}/tmp/original 2>&1 >/dev/null +rstat=$? +dstat=0 +end_test diff --git a/regress/regress/tests/weird-files-test b/regress/regress/tests/weird-files-test new file mode 100755 index 0000000000..1c1c34d294 --- /dev/null +++ b/regress/regress/tests/weird-files-test @@ -0,0 +1,79 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="weird-files-test" +JobName=wierd-files +. scripts/functions + +if test ! -d weird-files ; then + echo " " + echo "Weird files not configured. Test not run." + exit 0 +fi + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +change_jobname NightlySave $JobName +# +# Note, we save the weird-files directory twice on purpose +# because this causes problems with hard linked files +# that are only saved once. In 1.33, Bacula now deals +# with this situation. +# +echo "${cwd}/weird-files" >${cwd}/tmp/file-list +echo "${cwd}/weird-files" >>${cwd}/tmp/file-list + +# Create a Unix domain socket (sock-file) +cd weird-files +perl socket.pl +cd .. + +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=File +TestVolume001 +run job=$JobName +yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula +# Note, the Unix domain socket (sock-file) is not restored +# by Bacula so we delete it for the diffs +rm -f weird-files/sock-file +touch weird-files tmp/bacula-restores${cwd}/weird-files + +${cwd}/bin/testls weird-files | sort >${cwd}/tmp/original +cd tmp/bacula-restores${cwd} +${cwd}/bin/testls weird-files | sort >${cwd}/tmp/restored +cd ${cwd} + +check_two_logs +#diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 >/dev/null +diff ${cwd}/tmp/original ${cwd}/tmp/restored + +dstat=$? +end_test diff --git a/regress/regress/tests/weird-files2-test b/regress/regress/tests/weird-files2-test new file mode 100755 index 0000000000..ae3aad6954 --- /dev/null +++ b/regress/regress/tests/weird-files2-test @@ -0,0 +1,83 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="weird-files2-test" +JobName=weird-files2 +. scripts/functions + +if test ! -d weird-files ; then + echo " " + echo "weird files not configured. Test not run." + exit 0 +fi +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +rm -rf weird-files2 +cp -Rp weird-files weird-files2 +echo "${cwd}/weird-files2" >${cwd}/tmp/file-list +cd weird-files2 +perl socket.pl +cd .. + +change_jobname NightlySave $JobName +start_test + +bin/testls weird-files2 | grep -v sock-file >${cwd}/tmp/original + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +# +# Now mess up the a hard link, and a soft link +# +cd weird-files2 +rm -f hard-file2 +ln hard-file3 hard-file2 +rm -f soft-file2 +ln -s soft-file3 soft-file2 +cd ${cwd} +cat <tmp/bconcmds +@$out /dev/null +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where= storage=File +5 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File +stop_bacula + +bin/testls weird-files2 >${cwd}/tmp/restored + +check_two_logs +#diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 >/dev/null +diff ${cwd}/tmp/original ${cwd}/tmp/restored +dstat=$? + +end_test diff --git a/regress/regress/tests/win32-backup-tape b/regress/regress/tests/win32-backup-tape new file mode 100755 index 0000000000..299fdd4873 --- /dev/null +++ b/regress/regress/tests/win32-backup-tape @@ -0,0 +1,48 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# +TestName="win32-backup-tape" +JobName=win32tape +. scripts/functions + +scripts/copy-win32-confs +scripts/cleanup-tape + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default drive=0 +run job=$JobName yes +@sleep 10 +status storage=DDS-4 +@sleep 30 +messages +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +# no diff for now +dstat=0 +end_test diff --git a/regress/regress/tests/win32-to-linux-tape b/regress/regress/tests/win32-to-linux-tape new file mode 100755 index 0000000000..05abd85716 --- /dev/null +++ b/regress/regress/tests/win32-to-linux-tape @@ -0,0 +1,48 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# +TestName="win32-to-linux-tape" +JobName=AutoLabel +. scripts/functions + +scripts/copy-win32-confs +scripts/cleanup-tape + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_job $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default drive=0 +run job=NightlySave yes +@sleep 10 +status storage=DDS-4 +@sleep 30 +messages +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores client=Tibs select all storage=DDS-4 done +yes +wait +messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +# No diff for the moment +dstat=0 +end_test diff --git a/regress/regress/weird-files.tar.gz b/regress/regress/weird-files.tar.gz new file mode 100644 index 0000000000..09d1ebd486 Binary files /dev/null and b/regress/regress/weird-files.tar.gz differ diff --git a/regress/regress/win32/all-non-root-2tape-tests.cmd b/regress/regress/win32/all-non-root-2tape-tests.cmd new file mode 100644 index 0000000000..28ba14eb59 --- /dev/null +++ b/regress/regress/win32/all-non-root-2tape-tests.cmd @@ -0,0 +1,11 @@ +REM +REM Run all tape tests +REM +CALL tests\test0 +CALL tests\two-volume-tape +CALL tests\incremental-2tape +ECHO. +ECHO. +echo 2 Tape Test results +TYPE test.out +CALL scripts\cleanup diff --git a/regress/regress/win32/all-non-root-tape-tests.cmd b/regress/regress/win32/all-non-root-tape-tests.cmd new file mode 100644 index 0000000000..5eec40d7bb --- /dev/null +++ b/regress/regress/win32/all-non-root-tape-tests.cmd @@ -0,0 +1,26 @@ +REM +REM Run all tape tests +REM +CALL config_var +IF NOT "%AUTOCHANGER%" == "nul" mtx -f %AUTOCHANGER% load 1 >nul 2>&1 +COPY test.out test1.out +CALL tests\test0 +CALL tests\backup-bacula-tape +CALL tests\btape-fill-tape +CALL tests\fixed-block-size-tape +CALL tests\four-concurrent-jobs-tape +CALL tests\four-jobs-tape +CALL tests\incremental-tape +CALL tests\relabel-tape +CALL tests\restore-by-file-tape +CALL tests\small-file-size-tape +CALL tests\truncate-bug-tape +CALL tests\two-pool-tape +CALL tests\2drive-incremental-2tape +CALL tests\bscan-tape +CALL tests\verify-vol-tape +ECHO. +ECHO. +ECHO Test results +TYPE test.out +CALL scripts\cleanup diff --git a/regress/regress/win32/all-non-root-tests.cmd b/regress/regress/win32/all-non-root-tests.cmd new file mode 100644 index 0000000000..faeb4699ae --- /dev/null +++ b/regress/regress/win32/all-non-root-tests.cmd @@ -0,0 +1,48 @@ +REM +REM Run all tests +REM +DEL test1.out +CALL tests\test0 +ECHO. +CALL tests\auto-label-test +CALL tests\backup-bacula-test +CALL tests\bextract-test +CALL tests\bscan-test +CALL tests\bsr-opt-test +CALL tests\compressed-test +CALL tests\concurrent-jobs-test +CALL tests\data-encrypt-test +CALL tests\differential-test +CALL tests\four-concurrent-jobs-test +CALL tests\four-jobs-test +CALL tests\incremental-test +CALL tests\query-test +CALL tests\recycle-test +CALL tests\restore2-by-file-test +CALL tests\restore-by-file-test +CALL tests\restore-disk-seek-test +CALL tests\six-vol-test +CALL tests\span-vol-test +CALL tests\sparse-compressed-test +CALL tests\sparse-test +CALL tests\two-jobs-test +CALL tests\two-vol-test +CALL tests\verify-vol-test +REM CALL tests\weird-files2-test +REM CALL tests\weird-files-test +CALL tests\migration-job-test +CALL tests\migration-jobspan-test +CALL tests\migration-volume-test +CALL tests\migration-time-test +REM CALL tests\hardlink-test +REM +REM The following are Virtual Disk Autochanger tests +CALL tests\two-pool-test +CALL tests\two-volume-test +CALL tests\incremental-2disk +CALL tests\2drive-incremental-2disk +CALL tests\scratch-pool-test +ECHO. +ECHO Test results +TYPE test.out +CALL scripts\cleanup diff --git a/regress/regress/win32/all-root-tests.cmd b/regress/regress/win32/all-root-tests.cmd new file mode 100644 index 0000000000..20061b1768 --- /dev/null +++ b/regress/regress/win32/all-root-tests.cmd @@ -0,0 +1,10 @@ +REM +REM Run all root tests +REM +DEL test.out +CALL tests\dev-test-root +CALL tests\etc-test-root +CALL tests\lib-test-root +CALL tests\usr-tape-root +TYPE test.out +CALL scripts\cleanup diff --git a/regress/regress/win32/all-tape-and-file-tests.cmd b/regress/regress/win32/all-tape-and-file-tests.cmd new file mode 100644 index 0000000000..cbbebf2c2d --- /dev/null +++ b/regress/regress/win32/all-tape-and-file-tests.cmd @@ -0,0 +1,5 @@ +REM +REM Run all tests +REM +CALL all-non-root-tests +CALL all-non-root-tape-tests diff --git a/regress/regress/win32/all-tests.cmd b/regress/regress/win32/all-tests.cmd new file mode 100644 index 0000000000..62ffa6e940 --- /dev/null +++ b/regress/regress/win32/all-tests.cmd @@ -0,0 +1,7 @@ +REM +REM Run all tests +REM +CALL all-non-root-tests +CALL all-root-tests +TYPE test.out +CALL scripts\cleanup diff --git a/regress/regress/win32/config.cmd b/regress/regress/win32/config.cmd new file mode 100644 index 0000000000..95a4113b1d --- /dev/null +++ b/regress/regress/win32/config.cmd @@ -0,0 +1,10 @@ +@ECHO off +REM +REM First argument is expected to be a user's configuration file +REM +IF "%1" == "" ( + ECHO Arg1 must specify a config file ^(e.g. prototype.conf^) + EXIT /b 1 +) + +COPY %1 config_var.cmd diff --git a/regress/regress/win32/make.cmd b/regress/regress/win32/make.cmd new file mode 100644 index 0000000000..eaf74b1a4e --- /dev/null +++ b/regress/regress/win32/make.cmd @@ -0,0 +1,111 @@ +@ECHO off +REM +REM Makefile for Bacula regression testing +REM +REM Note, Makefile is built from Makefile.in, which you should not really +REM need to change, by invoking: +REM +REM config +REM +REM e.g. +REM config kern.conf +REM + +SETLOCAL + +IF EXIST config_var.cmd GOTO :already_configured +ECHO You must run config first and supply the name of your conf file. +ECHO Use prototype.conf as a template. +EXIT /B 1 + +:already_configured + +SET PATH=%PATH%;%CD%\bin;%CD%\tools + +REM suck in user's configuration +CALL config_var.cmd + +IF EXIST "%BACULA_SOURCE%\configure" GOTO :source_ok +ECHO Unable to access the Bacula source in %BACULA_SOURCE%. Update +ECHO BACULA_SOURCE in your configuration file and rerun config. +EXIT /B 1 + +:source_ok +IF "%1" == "setup" GOTO :setup +IF "%1" == "bacula" GOTO :bacula +IF "%1" == "sed" GOTO :sed +IF "%1" == "test" GOTO :test +IF "%1" == "full_test" GOTO :full_test +IF "%1" == "root_test" GOTO :root_test +IF "%1" == "clean" GOTO :clean +IF "%1" == "reset" GOTO :reset +IF "%1" == "distclean" GOTO :distclean + +IF EXIST "%1" ( + %1 +) ELSE IF EXIST "%1.cmd" ( + %1 +) ELSE IF EXIST tests\%1 ( + tests\%1 +) ELSE IF EXIST tests\%1.cmd ( + tests\%1 +) ELSE ( + ECHO Unsupported option: %1 + ECHO Valid options are: + ECHO setup, bacula, sed, test, full_test, root_test, clean, reset, distclean + EXIT /b 1 +) + +:setup +CALL :bacula %2 +CALL :sed +GOTO :EOF + +:bacula +RD /s /q build bin weird-files tmp working 2>nul +MKDIR tmp working +SET BUILD_TYPE=%1 +IF "%BUILD_TYPE%"=="" SET BUILD_TYPE=release +ECHO Doing: scripts\setup "%BACULA_SOURCE%" %BUILD_TYPE% %EMAIL% %SMTP_HOST% %TAPE_DRIVE% %AUTOCHANGER% %AUTOCHANGER_PATH% %TAPE_DRIVE1% +CALL scripts\setup "%BACULA_SOURCE%" %BUILD_TYPE% %EMAIL% %SMTP_HOST% %TAPE_DRIVE% %AUTOCHANGER% %AUTOCHANGER_PATH% %TAPE_DRIVE1% +GOTO :EOF + +:sed +ECHO Doing: scripts\do_sed %EMAIL% %SMTP_HOST% %TAPE_DRIVE% %AUTOCHANGER% %AUTOCHANGER_PATH% %TAPE_DRIVE1% +CALL scripts\do_sed %EMAIL% %SMTP_HOST% %TAPE_DRIVE% %AUTOCHANGER% %AUTOCHANGER_PATH% %TAPE_DRIVE1% +GOTO :EOF + +:test +REM Run all non-root userid tests +CALL all-non-root-tests +GOTO :EOF + +:full_test +REM run all file and tape tests +CALL all-tape-and-file-tests +GOTO :EOF + +:root_test +REM These tests require you to run as root +CALL all-root-tests +GOTO :EOF + +:clean +CALL scripts\cleanup +DEL \tmp\file-list tmp\* working\* test.out diff >nul 2>&1 +DEL 1 2 3 scripts\1 scripts\2 scripts\3 tests\1 tests\2 tests\3 >nul 2>&1 +DEL .#* /s >nul 2>&1 +GOTO :EOF + +:reset +REM Reset our userid after running as root +CALL scripts\cleanup +DEL \tmp\file-list tmp\file-list +DEL tmp\* working\* +GOTO :EOF + +:distclean +RD /s /q bin build weird-files weird-files weird-files2 tmp working 2>nul +DEL scripts\*.conf +CALL :clean +GOTO :EOF diff --git a/regress/regress/win32/prototype.conf b/regress/regress/win32/prototype.conf new file mode 100644 index 0000000000..e6658feeda --- /dev/null +++ b/regress/regress/win32/prototype.conf @@ -0,0 +1,31 @@ +REM +REM Prototype personal configuration file for the regression +REM scripts. Either edit this file directly, or better copy +REM it elsewhere so it won't get overwritten. +REM + +REM +REM Put the full path to the Bacula source code to be tested +REM +SET BACULA_SOURCE= + +REM Where to send email messages +REM +SET EMAIL= +SET SMTP_HOST=localhost + +REM +REM The device name of your tape drive if you have one +REM +SET TAPE_DRIVE=tape0 +SET TAPE_DRIVE1=nul + +REM +REM if you don't have an autochanger set AUTOCHANGER to nul +REM +SET AUTOCHANGER=changer0 + +REM +REM This must be the path to the autochanger including its name +REM +SET AUTOCHANGER_PATH=%CD%\bin\mtx diff --git a/regress/regress/win32/scripts/bacula-dir-migration.conf.in b/regress/regress/win32/scripts/bacula-dir-migration.conf.in new file mode 100644 index 0000000000..312feb5205 --- /dev/null +++ b/regress/regress/win32/scripts/bacula-dir-migration.conf.in @@ -0,0 +1,229 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRport = 8101 # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in /tmp +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData = yes +# Prefer Mounted Volumes = no +} + +Job { + Name = "migrate-job" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratejob.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = Job + Selection Pattern = ".*Save" +} + +Job { + Name = "migrate-volume" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratevol.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = Volume + Selection Pattern = "File*" +} + +Job { + Name = "migrate-occupancy" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratejob.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = PoolOccupancy +} + +Job { + Name = "migrate-time" + Type = Migrate + Level = Full + Client=@hostname@-fd + FileSet="Full Set" + Messages = Standard + Storage = DiskChanger + Write Bootstrap = "@working_dir@/migratejob.bsr" + Pool = Default + Maximum Concurrent Jobs = 4 + Selection Type = PoolTime +} + + + + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = /tmp/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = tmp\bconcmds +CALL scripts\functions run_bconsole +grep "No Jobs running." tmp\dir.out >nul 2>&1 +IF %ERRORLEVEL% NEQ 0 ( + ECHO. + ECHO !!!! Zombie Jobs in Director !!!! + ECHO !!!! Zombie Jobs in Director !!!! >>test.out + ECHO. +) +grep "No Jobs running." tmp\fd.out >nul 2>&1 +IF %ERRORLEVEL% NEQ 0 ( + ECHO. + ECHO !!!! Zombie Jobs in File daemon !!!! + ECHO !!!! Zombie Jobs in File daemon !!!! >>test.out + ECHO. +) +grep "No Jobs running." tmp\sd.out >nul 2>&1 +IF %ERRORLEVEL% NEQ 0 ( + ECHO. + ECHO !!!! Zombie Jobs in Storage daemon !!!! + ECHO !!!! Zombie Jobs in Storage daemon !!!! >>test.out + ECHO. +) +grep "ERROR" tmp/log*.out >nul 2>&1 +IF %ERRORLEVEL% EQU 0 ( + ECHO. + ECHO !!!! ERROR in log output !!!! + ECHO !!!! ERROR in log output !!!! >>test.out + ECHO. +) +grep "Fatal Error" tmp\log*.out >nul 2>&1 +IF %ERRORLEVEL% EQU 0 ( + ECHO. + ECHO !!!! Fatal Error in log output !!!! + ECHO !!!! Fatal Error in log output !!!! >>test.out + ECHO. +) diff --git a/regress/regress/win32/scripts/cleanup-2drive.cmd.in b/regress/regress/win32/scripts/cleanup-2drive.cmd.in new file mode 100644 index 0000000000..c49d6dbacc --- /dev/null +++ b/regress/regress/win32/scripts/cleanup-2drive.cmd.in @@ -0,0 +1,43 @@ +REM +REM Cleanup left over files -- both before and after test run +REM +CALL scripts\cleanup + +IF NOT "@autochanger@" == "nul" ( + SET slot=0 + FOR /f %%i in ( 'bin\mtx-changer @autochanger@ loaded 0 @tape_drive1@ 1' ) DO SET slot=%%i + ECHO Slot %slot% in drive 1 + IF !slot! NEQ 0 ( + ECHO unload slot !slot! in drive 1 + bin\mtx-changer @autochanger@ unload !slot! @tape_drive1@ 1 + ) + FOR /f %%i in ( 'bin\mtx-changer @autochanger@ loaded 0 @tape_drive@ 0' ) DO SET slot=%%i + ECHO Slot !slot! in drive 0 + IF !slot! NEQ 0 ( + echo "unload slot !slot! in drive 0" + bin\mtx-changer @autochanger@ unload !slot! @tape_drive@ 0 + ) + + FOR /f %%i in ( 'bin\mtx-changer @autochanger@ loaded 0 @tape_drive1@ 1' ) DO SET slot=%%i + IF !slot! NEQ 2 ( + ECHO load slot 2 in drive 1 + bin\mtx-changer @autochanger@ load 2 @tape_drive1@ 1 + ) + ECHO WEOF drive 1 + mt -f @tape_drive1@ rewind + mt -f @tape_drive1@ weof + ECHO unload slot 2 in drive 1 + bin\mtx-changer @autochanger@ unload 2 @tape_drive1@ 1 + + FOR /f %%i in ( 'bin\mtx-changer @autochanger@ loaded 0 @tape_drive@ 0' ) DO SET slot=%%i + ECHO Slot !slot! in drive 0 + IF !slot! NEQ 1 ( + ECHO load slot 1 in drive 0 + bin\mtx-changer @autochanger@ load 1 @tape_drive@ 0 + ) + ECHO WEOF drive 0 + mt -f @tape_drive@ rewind + mt -f @tape_drive@ weof + ECHO unload slot 1 from drive 0 + bin\mtx-changer @autochanger@ unload 1 @tape_drive@ 0 +) diff --git a/regress/regress/win32/scripts/cleanup-2tape.cmd.in b/regress/regress/win32/scripts/cleanup-2tape.cmd.in new file mode 100644 index 0000000000..a572d7f5a5 --- /dev/null +++ b/regress/regress/win32/scripts/cleanup-2tape.cmd.in @@ -0,0 +1,29 @@ +REM +REM Cleanup left over files -- both before and after test run +REM + +setlocal ENABLEDELAYEDEXPANSION + +CALL scripts\cleanup + +IF NOT "@autochanger@" == "nul" ( + SET slot=0 + FOR /f %%i in ( 'bin\mtx-changer @autochanger@ loaded 0 dummy 0' ) DO SET slot=%%i + IF !slot! NEQ 2 ( + bin\mtx-changer @autochanger@ unload 0 @tape_drive@ 0 + bin\mtx-changer @autochanger@ load 2 @tape_drive@ 0 + ) + mt -f @tape_drive@ rewind + mt -f @tape_drive@ weof + + REM + REM If we have an autochanger always load tape in slot 1 + REM + FOR /f %%i in ( 'bin\mtx-changer @autochanger@ loaded 0 dummy 0' ) DO SET slot=%%i + IF !slot! NEQ 1 ( + bin\mtx-changer @autochanger@ unload 0 @tape_drive@ 0 + bin\mtx-changer @autochanger@ load 1 @tape_drive@ 0 + ) +) +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof diff --git a/regress/regress/win32/scripts/cleanup-tape.cmd.in b/regress/regress/win32/scripts/cleanup-tape.cmd.in new file mode 100644 index 0000000000..46ce41a6d5 --- /dev/null +++ b/regress/regress/win32/scripts/cleanup-tape.cmd.in @@ -0,0 +1,7 @@ +REM +REM Cleanup left over files -- both before and after test run +REM +CALL scripts\cleanup + +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof diff --git a/regress/regress/win32/scripts/cleanup.cmd b/regress/regress/win32/scripts/cleanup.cmd new file mode 100644 index 0000000000..0125175548 --- /dev/null +++ b/regress/regress/win32/scripts/cleanup.cmd @@ -0,0 +1,23 @@ +@ECHO off +REM +REM Cleanup left over files -- both before and after test run +REM + +CALL scripts\bacula stop >nul 2>&1 + +DEL /q /f \tmp\FileVolume* tmp\FileVolume* >nul 2>&1 +DEL /q /f \tmp\TestVolume001 \tmp\Small* >nul 2>&1 +RD /s /q \tmp\bacula-restores tmp\bacula-restores >nul 2>&1 +DEL /q /f tmp\original tmp\Small* tmp\TestVolume* >nul 2>&1 +DEL /q /f tmp\restored tmp\largefile tmp\bscan.bsr tmp\log*.out >nul 2>&1 +DEL /q /f \tmp\sed_tmp \tmp\file-list >nul 2>&1 +RD /s /q tmp\build >nul 2>&1 +DEL /q /f tmp\restore-list tmp\restore2-list >nul 2>&1 +DEL /q /f tmp\fd.out tmp\dir.out tmp\sd.out >nul 2>&1 +DEL /q /f working\log tmp\TEST-* >nul 2>&1 +DEL /q /f working\*.bsr >nul 2>&1 +DEL /q /f tmp\disk-changer.cmd \tmp\disk-changer.cmd >nul 2>&1 + +CALL bin\drop_bacula_tables >nul 2>&1 +CALL bin\make_bacula_tables >nul 2>&1 +CALL bin\grant_bacula_privileges >nul 2>&1 diff --git a/regress/regress/win32/scripts/copy-2disk-confs.cmd b/regress/regress/win32/scripts/copy-2disk-confs.cmd new file mode 100644 index 0000000000..e759a41413 --- /dev/null +++ b/regress/regress/win32/scripts/copy-2disk-confs.cmd @@ -0,0 +1,9 @@ +REM +REM Setup for using the Virtual Disk Changer (simulates tape changer) +REM +COPY scripts\bacula-dir-tape.conf bin\bacula-dir.conf +COPY scripts\bacula-sd-2disk.conf bin\bacula-sd.conf +COPY scripts\test-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf +COPY bin\bacula-dir.conf tmp\1 +bin\sed -e "s;# Autochanger = yes; Autochanger = yes;g" tmp\1 >bin\bacula-dir.conf diff --git a/regress/regress/win32/scripts/copy-2disk-drive-confs.cmd b/regress/regress/win32/scripts/copy-2disk-drive-confs.cmd new file mode 100644 index 0000000000..173eec2df0 --- /dev/null +++ b/regress/regress/win32/scripts/copy-2disk-drive-confs.cmd @@ -0,0 +1,6 @@ +COPY scripts\bacula-dir-tape.conf bin\bacula-dir.conf +COPY scripts\bacula-sd-2disk-drive.conf bin\bacula-sd.conf +COPY scripts\test-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf +COPY bin\bacula-dir.conf tmp\1 +bin\sed -e "s;# Autochanger = yes; Autochanger = yes;g" tmp\1 >bin\bacula-dir.conf diff --git a/regress/regress/win32/scripts/copy-2drive-confs.cmd b/regress/regress/win32/scripts/copy-2drive-confs.cmd new file mode 100644 index 0000000000..d20bf19ca9 --- /dev/null +++ b/regress/regress/win32/scripts/copy-2drive-confs.cmd @@ -0,0 +1,10 @@ +COPY scripts\bacula-dir-tape.conf bin\bacula-dir.conf +COPY scripts\bacula-sd-2drive.conf bin\bacula-sd.conf +COPY scripts\test-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf + +COPY bin\bacula-dir.conf tmp\1 +bin\sed -e "s;# Autochanger = yes; Autochanger = yes;g" >bin\bacula-dir.conf + +REM get proper SD tape definitions +COPY scripts\win32_tape_options bin\tape_options diff --git a/regress/regress/win32/scripts/copy-2tape-confs.cmd b/regress/regress/win32/scripts/copy-2tape-confs.cmd new file mode 100644 index 0000000000..3e5af7aa12 --- /dev/null +++ b/regress/regress/win32/scripts/copy-2tape-confs.cmd @@ -0,0 +1,10 @@ +COPY scripts\bacula-dir-tape.conf bin\bacula-dir.conf +COPY scripts\bacula-sd-2tape.conf bin\bacula-sd.conf +COPY scripts\test-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf + +COPY bin\bacula-dir.conf tmp\1 +bin\sed -e "s;# Autochanger = yes; Autochanger = yes;g" tmp\1 >bin\bacula-dir.conf + +REM get proper SD tape definitions +COPY scripts\win32_tape_options bin\tape_options diff --git a/regress/regress/win32/scripts/copy-confs.cmd b/regress/regress/win32/scripts/copy-confs.cmd new file mode 100644 index 0000000000..359839c6d8 --- /dev/null +++ b/regress/regress/win32/scripts/copy-confs.cmd @@ -0,0 +1,7 @@ +COPY scripts\bacula-dir.conf bin\bacula-dir.conf +COPY scripts\bacula-sd.conf bin\bacula-sd.conf +COPY scripts\bacula-fd.conf bin\bacula-fd.conf +COPY scripts\bconsole.conf bin\bconsole.conf + +REM get proper SD tape definitions +COPY scripts\win32_tape_options bin\tape_options diff --git a/regress/regress/win32/scripts/copy-crypto-confs.cmd b/regress/regress/win32/scripts/copy-crypto-confs.cmd new file mode 100644 index 0000000000..7166399d97 --- /dev/null +++ b/regress/regress/win32/scripts/copy-crypto-confs.cmd @@ -0,0 +1,5 @@ +COPY scripts\new-test-bacula-dir.conf bin\bacula-dir.conf +COPY scripts\test-bacula-sd.conf bin\bacula-sd.conf +COPY scripts\crypto-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf +COPY scripts\cryptokeypair.pem bin\cryptokeypair.pem diff --git a/regress/regress/win32/scripts/copy-migration-confs.cmd b/regress/regress/win32/scripts/copy-migration-confs.cmd new file mode 100644 index 0000000000..7bf12ddbd8 --- /dev/null +++ b/regress/regress/win32/scripts/copy-migration-confs.cmd @@ -0,0 +1,7 @@ +REM +REM Setup for migration tests +REM +COPY scripts\bacula-dir-migration.conf bin\bacula-dir.conf +COPY scripts\bacula-sd-migration.conf bin\bacula-sd.conf +COPY scripts\test-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf diff --git a/regress/regress/win32/scripts/copy-tape-confs.cmd b/regress/regress/win32/scripts/copy-tape-confs.cmd new file mode 100644 index 0000000000..0a7a50a811 --- /dev/null +++ b/regress/regress/win32/scripts/copy-tape-confs.cmd @@ -0,0 +1,7 @@ +copy scripts\bacula-dir-tape.conf bin\bacula-dir.conf +copy scripts\bacula-sd-tape.conf bin\bacula-sd.conf +copy scripts\test-bacula-fd.conf bin\bacula-fd.conf +copy scripts\test-console.conf bin\bconsole.conf + +REM get proper SD tape definitions +copy scripts\win32_tape_options bin\tape_options diff --git a/regress/regress/win32/scripts/copy-test-confs.cmd b/regress/regress/win32/scripts/copy-test-confs.cmd new file mode 100644 index 0000000000..c07c5d6204 --- /dev/null +++ b/regress/regress/win32/scripts/copy-test-confs.cmd @@ -0,0 +1,7 @@ +COPY scripts\new-test-bacula-dir.conf bin\bacula-dir.conf +COPY scripts\test-bacula-sd.conf bin\bacula-sd.conf +COPY scripts\test-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf + +REM get proper SD tape definitions +COPY scripts\win32_tape_options bin\tape_options diff --git a/regress/regress/win32/scripts/copy-testa-confs.cmd b/regress/regress/win32/scripts/copy-testa-confs.cmd new file mode 100644 index 0000000000..4cc89ff02d --- /dev/null +++ b/regress/regress/win32/scripts/copy-testa-confs.cmd @@ -0,0 +1,7 @@ +COPY scripts\testa-bacula-dir.conf bin\bacula-dir.conf +COPY scripts\test-bacula-sd.conf bin\bacula-sd.conf +COPY scripts\test-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf + +REM get proper SD tape definitions +COPY scripts\win32_tape_options bin\tape_options diff --git a/regress/regress/win32/scripts/copy-win32-confs.cmd b/regress/regress/win32/scripts/copy-win32-confs.cmd new file mode 100644 index 0000000000..b9f0ab72f6 --- /dev/null +++ b/regress/regress/win32/scripts/copy-win32-confs.cmd @@ -0,0 +1,7 @@ +COPY scripts\win32-bacula-dir-tape.conf bin\bacula-dir.conf +COPY scripts\win32-bacula-sd-tape.conf bin\bacula-sd.conf +COPY scripts\win32-bacula-fd.conf bin\bacula-fd.conf +COPY scripts\test-console.conf bin\bconsole.conf + +REM get proper SD tape definitions +COPY scripts\win32_tape_options bin\tape_options diff --git a/regress/regress/win32/scripts/crypto-bacula-fd.conf.in b/regress/regress/win32/scripts/crypto-bacula-fd.conf.in new file mode 100644 index 0000000000..ec4152d2b8 --- /dev/null +++ b/regress/regress/win32/scripts/crypto-bacula-fd.conf.in @@ -0,0 +1,36 @@ +# +# Default Bacula File Daemon Configuration file +# +# For Bacula release 1.33 +# +# There is not much to change here except perhaps the +# File daemon Name to +# + +# +# List Directors who are permitted to contact this File daemon +# +Director { + Name = @hostname@-dir + Password = "xevrjURYoCHhn26RaJoWbeWXEY/a3VqGKp/37tgWiuHc" +} + +# +# "Global" File daemon configuration specifications +# +FileDaemon { # this is me + Name = @hostname@-fd + FDport = 8102 # where we listen for the director + WorkingDirectory = "@working_dir@" + Pid Directory = "@piddir@" + SubSys Directory = "@subsysdir@" + PKI Signatures = Yes + PKI Encryption = Yes + PKI Keypair = "@scriptdir@/cryptokeypair.pem" +} + +# Send all messages except skipped files back to Director +Messages { + Name = Standard + director = @hostname@-dir = all, !terminate +} diff --git a/regress/regress/win32/scripts/cryptokeypair.pem b/regress/regress/win32/scripts/cryptokeypair.pem new file mode 100644 index 0000000000..440dcce4f0 --- /dev/null +++ b/regress/regress/win32/scripts/cryptokeypair.pem @@ -0,0 +1,23 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIBOgIBAAJBAKIc649Amif6weq+c8rVtS7jyn7E9oZ9Irrl9WviQZi0+J2OLgCi +PNaj/FzPhTIgBBRFEP0ZU5DfVv6CoXKbpr8CAwEAAQJAQbvUUFvzpi5pnxPmw+Jv ++zlmjIy1Icdv47UHFN3Dl3V0+X05g12xUlnyNKzo2jlSwkBi1w8AJCMV6/TnnLiI +AQIhAM4SH9cb01DUH+1O5gk90GgNYW1Aq2vL1vygm02kppi/AiEAyWQ9eAILPXhX +H3a7mEj8z1bCTBiVrhe73NUjim4QcgECIEC3hHRj8ruBwv0eODRSy27CNQTAuJVE +ESKJtfxuZzu1AiEAotXYFbahW/x3hUs9d25ca1EdHOYr8G3kSjRT3lQMHAECIHBl +uX+Ywc1jjWhc+vN2ZrLWkKMVbrd+SWOPUQGroM0j +-----END RSA PRIVATE KEY----- +-----BEGIN CERTIFICATE----- +MIICKzCCAdWgAwIBAgIJAO4x/m+tHX8HMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV +BAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRlcm5ldCBX +aWRnaXRzIFB0eSBMdGQwHhcNMDYxMjA0MDMxMzUwWhcNMDcwMTAzMDMxMzUwWjBF +MQswCQYDVQQGEwJBVTETMBEGA1UECBMKU29tZS1TdGF0ZTEhMB8GA1UEChMYSW50 +ZXJuZXQgV2lkZ2l0cyBQdHkgTHRkMFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAKIc +649Amif6weq+c8rVtS7jyn7E9oZ9Irrl9WviQZi0+J2OLgCiPNaj/FzPhTIgBBRF +EP0ZU5DfVv6CoXKbpr8CAwEAAaOBpzCBpDAdBgNVHQ4EFgQUiGz2I+bks0nCHyCI +IwuV3DpDPMwwdQYDVR0jBG4wbIAUiGz2I+bks0nCHyCIIwuV3DpDPMyhSaRHMEUx +CzAJBgNVBAYTAkFVMRMwEQYDVQQIEwpTb21lLVN0YXRlMSEwHwYDVQQKExhJbnRl +cm5ldCBXaWRnaXRzIFB0eSBMdGSCCQDuMf5vrR1/BzAMBgNVHRMEBTADAQH/MA0G +CSqGSIb3DQEBBQUAA0EAkjFYcs9rrpdURlBaNlbud68VlA5rU+Bv4keYx41DUmqo +sXtkQZENR9iYYYhOUso1/1dwQgrt3egjTZTtq7o5zw== +-----END CERTIFICATE----- diff --git a/regress/regress/win32/scripts/disk-changer.cmd b/regress/regress/win32/scripts/disk-changer.cmd new file mode 100644 index 0000000000..3efb1933ce --- /dev/null +++ b/regress/regress/win32/scripts/disk-changer.cmd @@ -0,0 +1,201 @@ +@ECHO off +setlocal ENABLEDELAYEDEXPANSION +REM +REM +REM Bacula interface to virtual autoloader using disk storage +REM +REM $Id$ +REM +REM If you set in your Device resource +REM +REM Changer Command = "disk-changer %c %o %S %a %d" +REM you will have the following input to this script: +REM +REM So Bacula will always call with all the following arguments, even though +REM in some cases, not all are used. +REM +REM disk-changer "changer-device" "command" "slot" "archive-device" "drive-index" +REM %1 %2 %3 %4 %5 +REM +REM By default the autochanger has 10 Volumes and 1 Drive. +REM +REM Note: For this script to work, you *must" specify +REM Device Type = File +REM in each of the Devices associated with your AutoChanger resource. +REM +REM changer-device is the name of a file that overrides the default +REM volumes and drives. It may have: +REM maxslot=n where n is one based (default 10) +REM maxdrive=m where m is zero based (default 1 -- i.e. 2 drives) +REM +REM This code can also simulate barcodes. You simply put +REM a list of the slots and barcodes in the "base" directory/barcodes. +REM See below for the base directory definition. Example of a +REM barcodes file: +REM C:\TEMP\bacula\barcodes +REM 1:Vol001 +REM 2:Vol002 +REM ... +REM +REM archive-device is the name of the base directory where you want the +REM Volumes stored appended with \drive0 for the first drive; \drive1 +REM for the second drive, ... For example, you might use +REM C:\Temp\bacula\drive0 Note: you must not have a trailing slash, and +REM the string (e.g. \drive0) must be unique, and it must not match +REM any other part of the directory name. These restrictions could be +REM easily removed by any clever script jockey. +REM +REM Full example: disk-changer C:\Temp\bacula\conf load 1 C:\Temp\bacula\drive0 0 +REM +REM The Volumes will be created with names slot1, slot2, slot3, ... maxslot in the +REM base directory. In the above example the base directory is C:\Temp\bacula. +REM However, as with tapes, their Bacula Volume names will be stored inside the +REM Volume label. In addition to the Volumes (e.g. C:\Temp\bacula\slot1, +REM C:\Temp\bacula\slot3, ...) this script will create a C:\Temp\bacula\loadedn +REM file to keep track of what Slot is loaded. You should not change this file. +REM + +SET dbgfile=%CD%\disk-changer.log + +REM to turn on logging, uncomment the following line +IF NOT EXIST %dbgfile% COPY nul %dbgfile% >nul + +REM +REM check parameter count on commandline +REM +REM Check for special cases where only 2 arguments are needed, +REM all others are a minimum of 5 +REM +IF "%1" EQU "" goto :param_count_invalid +IF "%2" EQU "" goto :param_count_invalid +IF "%2" EQU "list" goto :param_count_valid +IF "%2" EQU "slots" goto :param_count_valid +IF "%3" EQU "" goto :param_count_invalid +IF "%4" EQU "" goto :param_count_invalid +IF "%5" EQU "" goto :param_count_invalid +GOTO :param_count_valid + +:param_count_invalid + echo Insufficient number of arguments given. + IF "%2" EQU "" ( + echo At least two arguments must be specified. + ) else echo Command expected 5 arguments. +:usage + ECHO. + ECHO usage: disk-changer ctl-device command [slot archive-device drive-index] + ECHO Valid commands are: unload, load, list, loaded, and slots. + EXIT /B 1 + +:param_count_valid + +REM Setup arguments +SET ctl=%1 +SET cmd=%2 +SET slot=%3 +SET device=%4 +SET drive=%5 + +REM set defaults +SET maxdrive=1 +SET maxslot=10 + +SET ctl=%ctl:/=\% +SET ctl=%ctl:\\=\% + +SET device=%device:/=\% +SET device=%device:\\=\% + +REM Pull in conf file +IF EXIST %ctl% CALL %ctl% + +FOR %%i IN ( %ctl% ) DO SET dirname=%%~dpi +IF NOT EXIST %dirname%nul ( + ECHO ERROR: Autochanger directory "%dirname%" does not exist. + ECHO You must create it. + EXIT /b 1 +) + +CALL :debug "Parms: %ctl% %cmd% %slot% %device% %drive%" +IF "%cmd%" EQU "unload" GOTO :cmdUnload +IF "%cmd%" EQU "load" GOTO :cmdLoad +IF "%cmd%" EQU "list" GOTO :cmdList +IF "%cmd%" EQU "loaded" GOTO :cmdLoaded +IF "%cmd%" EQU "slots" GOTO :cmdSlots +GOTO :cmdUnknown + +:cmdUnload + CALL :debug "Doing disk -f %ctl% unload %slot% %device% %drive%" + IF NOT EXIST %dirname%loaded%drive% ECHO 0 >%dirname%loaded%drive% + FOR /f %%i IN ( %dirname%loaded%drive% ) DO SET ld=%%i + + IF "%slot%" EQU "%ld%" ( + CALL :debug "Unloaded slot %ld% from drive %drive%" + ECHO 0 >%dirname%loaded%drive% + DEL %dirname%%device% >nul 2>nul + SET rtn=0 + ) ELSE ( + ECHO Storage Element %slot% is Already Full + CALL :debug "Storage Element %slot% is Already Full" + SET rtn=1 + ) + GOTO :cmdExit + +:cmdLoad + CALL :debug "Doing disk -f %ctl% load %slot% %device% %drive%" + SET ld=0 + IF NOT EXIST %dirname%loaded%drive% ECHO 0 >%dirname%loaded%drive% + FOR /f %%i IN ( %dirname%loaded%drive% ) DO SET ld=%%i + IF %ld% EQU 0 ( + IF NOT EXIST %dirname%slot%slot% COPY nul %dirname%slot%slot% >nul + DEL %device% + fsutil hardlink create %device% %dirname%slot%slot% >nul 2>&1 + SET rtn=%ERRORLEVEL% + IF !rtn! EQU 0 ( + ECHO %slot% >%dirname%loaded%drive% + CALL :debug "Loaded slot %slot% into drive %drive%" + ) ELSE ( + CALL :debug "Create hardlink failed, return = !rtn!" + ) + ) ELSE ( + ECHO Drive %drive% Full - Storage element %ld% loaded + CALL :debug "Drive %drive% Full - Storage element %ld% loaded" + ) + GOTO :cmdExit + +:cmdList + CALL :debug "Doing disk -f %ctl% -- to list volumes" + IF EXIST %dirname%barcodes ( + TYPE %dirname%barcodes + ) ELSE ( + FOR /l %%i IN ( 1, 1, %maxslot% ) DO ECHO %%i: + ) + SET rtn=0 + GOTO :cmdExit + +:cmdLoaded + CALL :debug "Doing disk -f %ctl% %drive% -- to find what is loaded" + IF EXIST %dirname%loaded%drive% ( TYPE %dirname%loaded%drive% ) ELSE ECHO 0 + SET rtn=0 + GOTO :cmdExit + +:cmdSlots + CALL :debug "Doing disk -f %ctl% -- to get count of slots" + ECHO %maxslot% + SET rtn=0 + GOTO :cmdExit + +:cmdExit + EXIT /b %rtn% + +:cmdUnknown + ECHO '%cmd%' is an invalid command. + GOTO :usage + +REM +REM log whats done +REM +:debug + IF NOT EXIST %dbgfile% GOTO :EOF + FOR /f "usebackq tokens=2-4,5-7 delims=/:. " %%i IN ( '%DATE% %TIME%' ) do SET TIMESTAMP=%%k%%i%%j-%%l:%%m:%%n + ECHO %TIMESTAMP% %* >> %dbgfile% + GOTO :EOF diff --git a/regress/regress/win32/scripts/do_sed.cmd b/regress/regress/win32/scripts/do_sed.cmd new file mode 100644 index 0000000000..a533a303f8 --- /dev/null +++ b/regress/regress/win32/scripts/do_sed.cmd @@ -0,0 +1,73 @@ +IF "%1" == "" GOTO :usage +IF "%2" == "" GOTO :usage +IF "%3" == "" GOTO :usage +IF "%4" == "" GOTO :usage +IF "%5" == "" GOTO :usage +IF "%6" == "" GOTO :usage +GOTO :args_ok + +:usage +ECHO First arg must be email name +ECHO and the second must be the smtp or email host +ECHO and the third must be a tape drive +ECHO and the fourth must be a tape control name or nul +ECHO and the fifth must be the full path to the mtx program +ECHO and the sixth must be tape drive 1 or nul +EXIT /b 1 + +:args_ok +SET out=tmp\sed_tmp + +REM Create sed command script + +ECHO s;@sbindir@;%CD:\=/%/bin;g >%out% +ECHO s;@scriptdir@;%CD:\=/%/scripts;g >>%out% +ECHO s;@working_dir@;%CD:\=/%/working;g >>%out% +ECHO s;@piddir@;%CD:\=/%/working;g >>%out% +ECHO s;@subsysdir@;%CD:\=/%/working;g >>%out% +ECHO s;@job_email@;%1;g >>%out% +ECHO s;@smtp_host@;%2;g >>%out% +ECHO s;@tape_drive@;%3;g >>%out% +ECHO s;@autochanger@;%4;g >>%out% +ECHO s;@tmpdir@;%CD:\=/%/tmp;g >>%out% +ECHO s;@hostname@;localhost;g >>%out% +ECHO s;@changer_path@;%5;g >>%out% +ECHO s;@tape_drive1@;%6;g >>%out% +ECHO s;@disk_drive@;%CD:\=/%/tmp/disk-changer;g >>%out% +ECHO s;@smtp_program@;%CD:\=/%/bin/bsmtp;g >>%out% + +ECHO SET AUTOCHANGER=%4 >config_out.cmd +ECHO SET AUTOCHANGER_PATH=%5 >>config_out.cmd +ECHO SET TAPE_DRIVE1=%6 >>config_out.cmd + +REM process .in files with sed script +sed -f %out% %CD%\scripts\test-bacula-dir.conf.in >%CD%\scripts\test-bacula-dir.conf +sed -f %out% %CD%\scripts\new-test-bacula-dir.conf.in >%CD%\scripts\new-test-bacula-dir.conf +sed -f %out% %CD%\scripts\testa-bacula-dir.conf.in >%CD%\scripts\testa-bacula-dir.conf +sed -f %out% %CD%\scripts\test-bacula-fd.conf.in >%CD%\scripts\test-bacula-fd.conf +sed -f %out% %CD%\scripts\test-bacula-sd.conf.in >%CD%\scripts\test-bacula-sd.conf +sed -f %out% %CD%\scripts\test-console.conf.in >%CD%\scripts\test-console.conf +sed -f %out% %CD%\scripts\crypto-bacula-fd.conf.in >%CD%\scripts\crypto-bacula-fd.conf +sed -f %out% %CD%\scripts\bacula-dir-tape.conf.in >%CD%\scripts\bacula-dir-tape.conf +sed -f %out% %CD%\scripts\bacula-dir-migration.conf.in >%CD%\scripts\bacula-dir-migration.conf +sed -f %out% %CD%\scripts\win32-bacula-dir-tape.conf.in >%CD%\scripts\win32-bacula-dir-tape.conf +sed -f %out% %CD%\scripts\bacula-sd-tape.conf.in >%CD%\scripts\bacula-sd-tape.conf +sed -f %out% %CD%\scripts\bacula-sd-2tape.conf.in >%CD%\scripts\bacula-sd-2tape.conf +sed -f %out% %CD%\scripts\bacula-sd-migration.conf.in >%CD%\scripts\bacula-sd-migration.conf +sed -f %out% %CD%\scripts\bacula-sd-2disk.conf.in >%CD%\scripts\bacula-sd-2disk.conf +sed -f %out% %CD%\scripts\bacula-sd-2drive.conf.in >%CD%\scripts\bacula-sd-2drive.conf +sed -f %out% %CD%\scripts\bacula-sd-2disk-drive.conf.in >%CD%\scripts\bacula-sd-2disk-drive.conf +sed -f %out% %CD%\scripts\cleanup-tape.cmd.in >%CD%\scripts\cleanup-tape.cmd +sed -f %out% %CD%\scripts\cleanup-2tape.cmd.in >%CD%\scripts\cleanup-2tape.cmd +sed -f %out% %CD%\scripts\cleanup-2drive.cmd.in >%CD%\scripts\cleanup-2drive.cmd +sed -f %out% %CD%\scripts\prepare-two-tapes.cmd.in >%CD%\scripts\prepare-two-tapes.cmd +sed -f %out% %CD%\scripts\bacula-dir.conf.testrunscript.in >%CD%\scripts\bacula-dir.conf.testrunscript + +COPY %CD%\bin\bacula-sd.conf tmp\bacula-sd.tmp >nul +sed -e "s;C:\\Temp;%CD:\=/%/tmp;g" tmp\bacula-sd.tmp >%CD%\bin\bacula-sd.conf + +REM get proper SD tape definitions +COPY %CD%\scripts\win32_tape_options %CD%\bin\tape_options >nul + +DEL %out% +DEL tmp\*.tmp diff --git a/regress/regress/win32/scripts/exclude-dev-test b/regress/regress/win32/scripts/exclude-dev-test new file mode 100644 index 0000000000..4165ea1ae7 --- /dev/null +++ b/regress/regress/win32/scripts/exclude-dev-test @@ -0,0 +1,5 @@ +dev/ptmx +dev/pts +dev/rd/c5d2 +dev/rd +dev/shm diff --git a/regress/regress/win32/scripts/exclude-etc-test b/regress/regress/win32/scripts/exclude-etc-test new file mode 100644 index 0000000000..f59ca8df2a --- /dev/null +++ b/regress/regress/win32/scripts/exclude-etc-test @@ -0,0 +1 @@ +etc/mail/statistics diff --git a/regress/regress/win32/scripts/exclude-lib-test b/regress/regress/win32/scripts/exclude-lib-test new file mode 100644 index 0000000000..5be32f443b --- /dev/null +++ b/regress/regress/win32/scripts/exclude-lib-test @@ -0,0 +1,5 @@ +lib/ld-2.2.5.so +lib/libtermcap.so.2.0.8 +lib/libc-2.2.5.so +lib/libnsl-2.2.5.so +lib/libnss_files-2.2.5.so diff --git a/regress/regress/win32/scripts/flist b/regress/regress/win32/scripts/flist new file mode 100644 index 0000000000..87f103defe --- /dev/null +++ b/regress/regress/win32/scripts/flist @@ -0,0 +1,23 @@ +/build/configure +/build/src/stored/bextract +/build/src/tools/testfind +/build/Makefile.in +/build/src/dird/bacula-dir +/build/src/console/bconsole +/build/src/filed/bacula-fd +/build/src/findlib/find_one.c +/build/src/jcr.h +/build/platforms/Makefile.in +/build/platforms/redhat/Makefile.in +/build/scripts/Makefile.in +/build/src/win32/filed/winservice.cpp +/build/src/filed/restore.c +/build/autoconf/configure.in +/build/examples/afs-bacula +/build/src/win32/Makefile.inc.in +/build/src/win32/installer/winbacula.nsi +/build/autoconf/configure.in +/build/src/version.h +/build/src/lib/message.c +/build/src/lib/bnet_server.c +/build/src/lib/libbac.a diff --git a/regress/regress/win32/scripts/functions.cmd b/regress/regress/win32/scripts/functions.cmd new file mode 100644 index 0000000000..1a03141c14 --- /dev/null +++ b/regress/regress/win32/scripts/functions.cmd @@ -0,0 +1,131 @@ +REM +REM A set of useful functions to be sourced in each test +REM + +SET routine=%1 +SHIFT + +GOTO %routine% + +:start_test + ECHO. + ECHO. + ECHO === Starting %TestName% at %TIME% === + ECHO === Starting %TestName% at %TIME% === >>working\log + ECHO. + GOTO :EOF + +:set_debug + SET debug=%1 + IF "%debug%" EQU 1 ( + SET out=tee + ) ELSE ( + SET out=output + ) + GOTO :EOF + +:run_bacula + IF %debug% EQU 1 ( + CALL scripts\bacula start + bin\bconsole -c bin\bconsole.conf nul 2>&1 + bin\bconsole -c bin\bconsole.conf nul 2>&1 + ) + GOTO :EOF + +:run_bconsole + IF %debug% EQU 1 ( + bin\bconsole -c bin\bconsole.conf nul 2>&1 + ) + GOTO :EOF + +:run_btape + IF %debug% EQU 1 ( + bin\btape -c bin\bacula-sd.conf DDS-4 tmp\log1.out 2>&1 + ) + GOTO :EOF + +:run_bscan + IF %debug% EQU 1 ( + bin\bscan %1 %2 %3 %4 %5 %6 %7 %8 %9 | tools\tee tmp\log.out + ) ELSE ( + bin\bscan %1 %2 %3 %4 %5 %6 %7 %8 %9 >nul 2>&1 + ) + GOTO :EOF + +:stop_bacula + CALL scripts\bacula stop >nul 2>&1 + GOTO :EOF + +:check_for_zombie_jobs + CALL scripts\check_for_zombie_jobs %1 %2 + GOTO :EOF + +:change_jobname + IF "%2" == "" ( + SET oldname=NightlySave + SET newname=%1 + ) ELSE ( + SET oldname=%1 + SET newname=%2 + ) + IF EXIST bin\1 DEL /f bin\1 + REN bin\bacula-dir.conf 1 + bin\sed -e "s;%oldname%;%newname%;g" bin\1 >bin\bacula-dir.conf +REM ECHO Job %oldname% changed to %newname% + GOTO :EOF + +:check_two_logs + tools\grep "^ Termination: *Backup OK" tmp\log1.out >nul 2>&1 + SET bstat=%ERRORLEVEL% + tools\grep "^ Termination: *Restore OK" tmp\log2.out >nul 2>&1 + SET rstat=%ERRORLEVEL% + GOTO :EOF + +:check_restore_diff + tools\diff -r build tmp\bacula-restores\%CD::=%\build >nul 2>&1 + SET dstat=%ERRORLEVEL% + GOTO :EOF + +:check_restore_tmp_build_diff + tools\diff -r tmp\build tmp\bacula-restores\%CD::=%\tmp\build >nul 2>&1 + SET dstat=%ERRORLEVEL% + GOTO :EOF + +:end_test + SET /a errcount=%bstat% + %rstat% + %dstat% + IF %errcount% NEQ 0 ( + ECHO. + ECHO. + ECHO !!!!! %TestName% Bacula source failed!!! !!!!! + ECHO !!!!! %TestName% failed!!! !!!!! >>test.out + IF %dstat% NEQ 0 ( + ECHO !!!!! Restored files differ !!!!! + ECHO !!!!! Restored files differ !!!!! >>test.out + ) ELSE ( + ECHO !!!!! Bad Job termination status !!!!! + ECHO !!!!! Bad Job termination status !!!!! >>test.out + ) + ECHO. + ) ELSE ( + ECHO ===== %TestName% Bacula source OK %TIME% ===== + ECHO ===== %TestName% OK %TIME% ===== >>test.out + IF %debug% EQU 0 scripts\cleanup + ) + SET errcount= + GOTO :EOF + +:copy_tape_confs + CALL scripts\copy-tape-confs >nul 2>&1 + CALL scripts\cleanup-tape + GOTO :EOF + +:copy_test_confs + CALL scripts\copy-test-confs >nul 2>&1 + CALL scripts\cleanup + GOTO :EOF diff --git a/regress/regress/win32/scripts/install_bacula.cmd b/regress/regress/win32/scripts/install_bacula.cmd new file mode 100644 index 0000000000..a799e3d25d --- /dev/null +++ b/regress/regress/win32/scripts/install_bacula.cmd @@ -0,0 +1,76 @@ +REM Arguments: +REM 1 = Debug or Release +REM 2 = email address +REM 3 = mail server +REM 4 = tape device +REM 5 = changer device or nul +REM 6 = tape1 device or nul + +SETLOCAL ENABLEDELAYEDEXPANSION + +SET CATS=create_sqlite3_database.cmd drop_sqlite3_database.cmd drop_sqlite3_tables.cmd grant_sqlite3_privileges.cmd make_sqlite3_catalog_backup.cmd make_sqlite3_tables.cmd + +SET CONFS=bacula-dir.conf.in bacula-fd.conf.in bacula-sd.conf.in bconsole.conf.in + +CALL scripts\bacula stop + +IF NOT EXIST bin MKDIR bin + +COPY build\src\win32\installer\%1\*.exe bin >nul +COPY build\src\win32\installer\%1\*.dll bin >nul +COPY build\src\win32\installer\%1\*.manifest bin >nul +COPY build\src\win32\%1\*.pdb bin >nul +COPY build\src\win32\installer\%1\query.sql bin >nul + +COPY bin\cats_sqlite3.dll bin\bacula_cats3.dll >nul + +FOR /f %%i IN ( 'cmd /c openssl.exe rand -base64 33 2^>nul' ) DO SET CLIENT_PASSWORD=%%i +FOR /f %%i IN ( 'cmd /c openssl.exe rand -base64 33 2^>nul' ) DO SET STORAGE_PASSWORD=%%i +FOR /f %%i IN ( 'cmd /c openssl.exe rand -base64 33 2^>nul' ) DO SET DIRECTOR_PASSWORD=%%i +FOR /f %%i IN ( 'cmd /c openssl.exe rand -base64 33 2^>nul' ) DO SET MONITOR_PASSWORD=%%i + +ECHO s;@director_name@;localhost-dir;g >install.sed +ECHO s;@director_port@;8101;g >>install.sed +ECHO s;@storage_name@;localhost-sd;g >>install.sed +ECHO s;@storage_port@;8103;g >>install.sed +ECHO s;@client_name@;localhost-fd;g >>install.sed +ECHO s;@client_port@;8102;g >>install.sed + +REM ECHO s;@DISTVER@;$R2; + +ECHO s;@working_dir@;%CD:\=\\\\%\\\\working;g >>install.sed +ECHO s;@working_dir_cmd@;%CD:\=\\%\\working;g >>install.sed +ECHO s;@bin_dir@;%CD:\=\\\\%\\\\bin;g >>install.sed; +ECHO s;@bin_dir_cmd@;%CD:\=\\%\\bin;g >>install.sed +ECHO s;@BUILD_DIR@;%CD:\=/%/build;g >>install.sed +ECHO s;@director_address@;localhost;g >>install.sed +ECHO s;@client_address@;localhost;g >>install.sed +ECHO s;@storage_address@;localhost;g >>install.sed +ECHO s;@client_maxjobs@;2;g >>install.sed +ECHO s;@client_password@;%CLIENT_PASSWORD%;g >>install.sed +ECHO s;@storage_maxjobs@;10;g >>install.sed +ECHO s;@storage_password@;%STORAGE_PASSWORD%;g >>install.sed +ECHO s;@director_maxjobs@;1;g >>install.sed +ECHO s;@director_password@;%DIRECTOR_PASSWORD%;g >>install.sed +ECHO s;@job_email@;%2;g >>install.sed +ECHO s;@smtp_host@;%3;g >>install.sed +ECHO s;@monitor_name@;localhost-mon;g >>install.sed +ECHO s;@monitor_password@;%MONITOR_PASSWORD%;g >>install.sed +ECHO s;@tape_drive@;%4;g >>install.sed +ECHO s;@autochanger@;%5;g >>install.sed +ECHO s;@changer_path@;%6;g >>install.sed +ECHO s;@tape_drive1@;%7;g >>install.sed + +FOR %%i in ( %CATS% ) DO ( + SET NAME=%%i + SET TARGET=bin\!NAME:sqlite3=bacula! + tools\sed -f install.sed build\src\win32\installer\%1\!NAME! > !TARGET! +) + +FOR %%i in ( %CONFS% ) DO tools\sed -f install.sed build\src\win32\installer\%%i > bin\%%~ni + +tools\sed -f install.sed build\src\win32\installer\%1\make_sqlite3_tables.sql > bin\make_sqlite3_tables.sql +tools\sed -f install.sed build\src\win32\installer\%1\mtx-changer.cmd > bin\mtx-changer.cmd + +CALL scripts\bacula uninstall +CALL scripts\bacula install %CD%\bin diff --git a/regress/regress/win32/scripts/new-test-bacula-dir.conf.in b/regress/regress/win32/scripts/new-test-bacula-dir.conf.in new file mode 100644 index 0000000000..7302f0c73d --- /dev/null +++ b/regress/regress/win32/scripts/new-test-bacula-dir.conf.in @@ -0,0 +1,326 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.39 or later +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRport = 8101 # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Standard +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in /tmp +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData=yes +} + +Job { + Name = "Crypto" + Type = Backup + Client=@hostname@-fd + FileSet="SparseCompressedSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData=yes +} + + +Job { + Name = "MonsterSave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File1 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "SparseTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "CompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="CompressedSet" + Storage = File + Messages = Standard + Pool = Default + Maximum Concurrent Jobs = 4 + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "SparseCompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseCompressedSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +# Backup the catalog database (after the nightly save) +Job { + Name = "BackupCatalog" + Type = Backup + Client=@hostname@-fd + FileSet="Catalog" +# Schedule = "WeeklyCycleAfterBackup" + Storage = File + Messages = Standard + Pool = Default + # This creates an ASCII copy of the catalog + RunBeforeJob = "@sbindir@/make_catalog_backup -u bacula" + # This deletes the copy of the catalog + RunAfterJob = "@sbindir@/delete_catalog_backup" + Write Bootstrap = "@working_dir@/BackupCatalog.bsr" +} + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = /tmp/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = nul 2>&1 +MKDIR tmp\disk-changer diff --git a/regress/regress/win32/scripts/prepare-two-tapes.cmd.in b/regress/regress/win32/scripts/prepare-two-tapes.cmd.in new file mode 100644 index 0000000000..1bcd81898b --- /dev/null +++ b/regress/regress/win32/scripts/prepare-two-tapes.cmd.in @@ -0,0 +1,13 @@ +REM +REM Create two blank tapes +REM +REM mt -f @tape_drive@ offline +@changer_path@ -f @autochanger@ unload +@changer_path@ -f @autochanger@ load 1 +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof +@changer_path@ -f @autochanger@ unload +@changer_path@ -f @autochanger@ load 2 +mt -f @tape_drive@ rewind +mt -f @tape_drive@ weof +REM @changer_path@ -f @autochanger@ unload diff --git a/regress/regress/win32/scripts/setup.cmd b/regress/regress/win32/scripts/setup.cmd new file mode 100644 index 0000000000..53df74dcfd --- /dev/null +++ b/regress/regress/win32/scripts/setup.cmd @@ -0,0 +1,55 @@ +REM +REM Script to setup running Bacula regression tests +REM + +IF "%1" == "" GOTO :usage +IF "%2" == "" GOTO :usage +IF "%3" == "" GOTO :usage +IF "%4" == "" GOTO :usage +IF "%5" == "" GOTO :usage +IF "%6" == "" GOTO :usage +IF "%7" == "" GOTO :usage +GOTO :param_count_ok + +:usage +ECHO Incorrect number of arguments. +ECHO setup bacula-src build-type email-address smtp-host tape-device changer-device tape1-device +ECHO. +EXIT /b 1 + +:param_count_ok +RD /s /q build bin tmp working >nul 2>&1 +MKDIR tmp + +REM Copy new source +ECHO Copying source from %1 +SET SRC=%1 +FOR /r %1 %%i in ( debug release ) do IF EXIST %%i ECHO %%i | sed -e "s;%SRC:\=\\%\\;;" -e "/installer\\%2/d" -e "/win32\\%2/d" >>tmp\exclude_list +ECHO .bsc >>tmp\exclude_list +ECHO .ncb >>tmp\exclude_list + +XCOPY %1 build\ /EXCLUDE:tmp\exclude_list /e /q + +DEL build\src\win32\%2\winbacula*.exe + +CALL scripts\install_bacula %2 %3 %4 %5 %6 %7 + +CALL scripts\bacula stop >nul 2>&1 + +IF NOT EXIST working MKDIR working +ECHO Running database creation scripts +CALL bin\create_bacula_database +CALL bin\drop_bacula_tables +CALL bin\make_bacula_tables +CALL bin\grant_bacula_privileges + +REM Start and stop Bacula to ensure conf files are OK + +CALL scripts\bacula start +CALL scripts\bacula stop >nul 2>&1 + +REM +REM Save Bacula default conf files for later use +REM +COPY bin\*.conf scripts >nul +GOTO :EOF diff --git a/regress/regress/win32/scripts/test-bacula-dir.conf.in b/regress/regress/win32/scripts/test-bacula-dir.conf.in new file mode 100644 index 0000000000..93008cca82 --- /dev/null +++ b/regress/regress/win32/scripts/test-bacula-dir.conf.in @@ -0,0 +1,312 @@ +# +# Default Bacula Director Configuration file +# +# The only thing that MUST be changed is to add one or more +# file or directory names in the Include directive of the +# FileSet resource. +# +# For Bacula release 1.33 +# +# You might also want to change the default email address +# from root to your address. See the "mail" and "operator" +# directives in the Messages resource. +# + +Director { # define myself + Name = @hostname@-dir + DIRport = 8101 # where we listen for UA connections + QueryFile = "@scriptdir@/query.sql" + WorkingDirectory = "@working_dir@" + PidDirectory = "@piddir@" + SubSysDirectory = "@subsysdir@" + Maximum Concurrent Jobs = 4 + Password = "pNvX1WiXnwv2C/F7E52LGvw6rKjbbPvu2kyuPa9pVaL3" # Console password + Messages = Daemon +} + +# +# Define the main nightly save backup job +# By default, this job will back up to disk in /tmp +Job { + Name = "NightlySave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" + Maximum Concurrent Jobs = 4 + SpoolData=yes +} + +Job { + Name = "MonsterSave" + Type = Backup + Client=@hostname@-fd + FileSet="Full Set" + Storage = File1 + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "VerifyVolume" + Type = Verify + Level = VolumeToCatalog + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +Job { + Name = "SparseTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + +Job { + Name = "CompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="CompressedSet" + Storage = File + Messages = Standard + Pool = Default + Maximum Concurrent Jobs = 4 + Write Bootstrap = "@working_dir@/NightlySave.bsr" +# Max Run Time = 15 seconds +} + +Job { + Name = "SparseCompressedTest" + Type = Backup + Client=@hostname@-fd + FileSet="SparseCompressedSet" + Storage = File + Messages = Standard + Pool = Default + Write Bootstrap = "@working_dir@/NightlySave.bsr" +} + + +# Backup the catalog database (after the nightly save) +Job { + Name = "BackupCatalog" + Type = Backup + Client=@hostname@-fd + FileSet="Catalog" +# Schedule = "WeeklyCycleAfterBackup" + Storage = File + Messages = Standard + Pool = Default + # This creates an ASCII copy of the catalog + RunBeforeJob = "@sbindir@/make_catalog_backup -u bacula" + # This deletes the copy of the catalog + RunAfterJob = "@sbindir@/delete_catalog_backup" + Write Bootstrap = "@working_dir@/BackupCatalog.bsr" +} + +# Standard Restore template, to be changed by Console program +Job { + Name = "RestoreFiles" + Type = Restore + Client=@hostname@-fd + FileSet="Full Set" + Storage = File + Messages = Standard + Pool = Default + Where = /tmp/bacula-restores +} + + +# List of files to be backed up +FileSet { + Name = "Full Set" + Include { Options { signature=MD5 } + File = nul 2>&1 +CALL scripts\prepare-two-disks + +CALL scripts\functions change_jobname localhost-fd %JobName% +CALL scripts\functions start_test + +ECHO %CD:\=/%/tmp/build >\tmp\file-list +IF NOT EXIST tmp\build MKDIR tmp\build +COPY build\src\dird\*.c tmp\build >nul 2>&1 + +ECHO %CD:\=/%/tmp/build/ficheriro1.txt>tmp\restore-list +ECHO %CD:\=/%/tmp/build/ficheriro2.txt>>tmp\restore-list + +REM Turn off Prefer Mounted Volumes so we use2 drives +COPY bin\bacula-dir.conf tmp\1 >nul 2>&1 +REM Comment the next line out to write everything to one drive +REM otherwise, it writes the two jobs to different drives +sed -e "s;# Prefer Mounted Volumes; Prefer Mounted Volumes;g" tmp\1 >bin\bacula-dir.conf + +REM Write out bconsole commands +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\2drive-incremental-2disk.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +ECHO ficheriro1.txt >tmp\build\ficheriro1.txt +ECHO ficheriro2.txt >tmp\build\ficheriro2.txt + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\2drive-incremental-2disk.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=DDS-4 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +REM The restore should read from TestVolume002, which was on drive 1 +grep TestVolume002 tmp\log2.out >nul 2>&1 +IF %ERRORLEVEL% NEQ 0 SET rstat=%ERRORLEVEL% + +REM +REM Delete .c files because we will only restored the txt files +REM +DEL tmp\build\*.c +CALL scripts\functions check_restore_tmp_build_diff + +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/2drive-incremental-2tape b/regress/regress/win32/tests/2drive-incremental-2tape new file mode 100644 index 0000000000..25889acec6 --- /dev/null +++ b/regress/regress/win32/tests/2drive-incremental-2tape @@ -0,0 +1,112 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +# This script uses the autochanger and two tapes +# +. config.out +if test x${TAPE_DRIVE1} = x/dev/null ; then + echo "Skipping 2drive-incremenatal-2tape test. No second drive." + exit +fi +TestName="2drive-incremental-2tape" +JobName="2drive2tape" +. scripts/functions +set_debug 0 + +cwd=`pwd` + +scripts/copy-2drive-confs +scripts/cleanup-2drive + +change_jobname localhost-fd $JobName + +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +if test ! -d ${cwd}/tmp/build ; then + mkdir ${cwd}/tmp/build +fi +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +# Turn off Prefer Mounted Volumes so we use 2 drives +outf="tmp/sed_tmp" +echo "s%# Prefer Mounted Volumes% Prefer Mounted Volumes%g" >${outf} +cp ${cwd}/bin/bacula-dir.conf ${cwd}/tmp/1 +# Comment the next line out to write everything to one drive +# otherwise, it writes the two jobs to different drives +sed -f ${outf} ${cwd}/tmp/1 >${cwd}/bin/bacula-dir.conf + +start_test + +# Write out bconsole commands +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Default drive=1 +@#setdebug level=100 storage=DDS-4 +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +run job=NightlySave yes +@sleep 3 +status storage=DDS-4 +wait +list volumes +list jobs +status storage=DDS-4 +messages +quit +END_OF_DATA + +run_bacula + +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +status storage=DDS-4 +@#setdebug level=400 storage=DDS-4 +run level=Incremental job=NightlySave yes +wait +list volumes +status storage=DDS-4 +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +# +# Delete .c files because we will only restored the txt files +# +rm -f tmp/build/*.c +check_restore_tmp_build_diff + +end_test diff --git a/regress/regress/win32/tests/auto-label-test.bscr b/regress/regress/win32/tests/auto-label-test.bscr new file mode 100644 index 0000000000..c33c0a6a42 --- /dev/null +++ b/regress/regress/win32/tests/auto-label-test.bscr @@ -0,0 +1,35 @@ +@output nul +messages +@@out@ tmp/log1.out +status all +status all +list pools +messages +@#setdebug level=110 storage=File +run job=@JobName@ storage=File yes +list pools +list volumes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File +unmark * +mark * +count +ls * +dir * +find Makefile +pwd +lsmark +estimate +? +help +done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/auto-label-test.cmd b/regress/regress/win32/tests/auto-label-test.cmd new file mode 100644 index 0000000000..218ded6d07 --- /dev/null +++ b/regress/regress/win32/tests/auto-label-test.cmd @@ -0,0 +1,27 @@ +REM +REM Test if Bacula can automatically create a Volume label. +REM + +SET TestName=auto-label-test +SET JobName=AutoLabel + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +COPY bin\bacula-dir.conf tmp\1 +sed -e "s;# Label Format; Label Format;" tmp\1 >bin\bacula-dir.conf + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\auto-label-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/backup-bacula-tape b/regress/regress/win32/tests/backup-bacula-tape new file mode 100644 index 0000000000..b4d72a0138 --- /dev/null +++ b/regress/regress/win32/tests/backup-bacula-tape @@ -0,0 +1,117 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# We also use the purge and the relabel commands as +# well as a pile of status storage commands. +# +TestName="backup-bacula-tape" +JobName=backuptape +. scripts/functions +set_debug 0 + +scripts/copy-tape-confs +scripts/cleanup-tape + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + + +# Write out bconsole commands +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +@#setdebug level=200 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +purge volume=TestVolume001 +relabel pool=Default storage=DDS-4 oldVolume=TestVolume001 volume=TestVolume002 slot=0 +purge volume=TestVolume002 +relabel pool=Default storage=DDS-4 oldVolume=TestVolume002 volume=TestVolume001 slot=0 +run job=$JobName yes +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +@sleep 1 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +status storage=DDS-4 +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +list volumes +messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +# +# Now do a second backup after making a few changes +# +touch ${cwd}/build/src/dird/*.c +echo "test test" > ${cwd}/build/src/dird/xxx + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +list volumes +run job=$JobName yes +wait +list volumes +messages +@# +@# now do a second restore +@# +@$out tmp/log2.out +list volumes +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +list volumes +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/backup-bacula-test.bscr b/regress/regress/win32/tests/backup-bacula-test.bscr new file mode 100644 index 0000000000..c6c22e9dae --- /dev/null +++ b/regress/regress/win32/tests/backup-bacula-test.bscr @@ -0,0 +1,36 @@ +@output nul +messages +@@out@ tmp/log1.out +label volume=TestVolume001 +@#setdebug level=100 storage=File +run job=@JobName@ yes +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +@sleep 1 +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +@sleep 1 +status storage=File +status storage=File +status storage=File +status storage=File +status storage=File +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select all done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/backup-bacula-test.cmd b/regress/regress/win32/tests/backup-bacula-test.cmd new file mode 100644 index 0000000000..dafec1d622 --- /dev/null +++ b/regress/regress/win32/tests/backup-bacula-test.cmd @@ -0,0 +1,24 @@ +REM +REM Run a simple backup of the Bacula build directory +REM then restore it. +REM + +SET TestName=backup-bacula-test +SET JobName=backup +CALL scripts\functions set_debug 0 + +CALL scripts\cleanup +CALL scripts\copy-confs >nul 2>&1 + +CALL scripts\functions change_jobname Client1 %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\backup-bacula-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/backup-win32-tape b/regress/regress/win32/tests/backup-win32-tape new file mode 100644 index 0000000000..a5631c17e6 --- /dev/null +++ b/regress/regress/win32/tests/backup-win32-tape @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# +TestName="backup-win32-tape" +JobName=backupwintape +. scripts/functions +set_debug 0 + +scripts/cleanup-tape +scripts/copy-win32-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=NightlySave yes +@sleep 10 +status storage=DDS-4 +@sleep 30 +messages +wait +messages +@# +@# now do a restore +@# +@$outt tmp/log2.out +@#restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +@#yes +@#wait +@#messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/bextract-test.bscr b/regress/regress/win32/tests/bextract-test.bscr new file mode 100644 index 0000000000..090d518da0 --- /dev/null +++ b/regress/regress/win32/tests/bextract-test.bscr @@ -0,0 +1,21 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File1 volume=TestVolume001 +label storage=File1 volume=TestVolume002 +update Volume=TestVolume001 MaxVolBytes=3000000 +@#setdebug level=400 dir +@#setdebug level=400 storage=File1 +run job=@JobName@ storage=File1 yes +wait +messages +@# +@# now build the bsr file +@# +@@out@ tmp/log2.out +restore bootstrap=@topdir@/working/restore.bsr where=@topdir@/tmp/bacula-restores select all storage=File1 done +no +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/bextract-test.cmd b/regress/regress/win32/tests/bextract-test.cmd new file mode 100644 index 0000000000..c119764c5e --- /dev/null +++ b/regress/regress/win32/tests/bextract-test.cmd @@ -0,0 +1,29 @@ +REM +REM Run a simple backup of the Bacula build directory but +REM split the archive into two volumes, then build a BSR with +REM the restore command and use bextract to restore the files. +REM +SET TestName=bextract-test +SET JobName=bextract + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\bextract-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula + +MKDIR %CD%\tmp\bacula-restores +bin\bextract -b working/restore.bsr -c bin/bacula-sd.conf %CD:\=/%/tmp %CD:\=/%/tmp/bacula-restores 2>&1 >nul +SET rstat=%ERRORLEVEL% +grep "^ Termination: *Backup OK" tmp\log1.out 2>&1 >nul +SET bstat=%ERRORLEVEL% +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/bscan-fast-tape b/regress/regress/win32/tests/bscan-fast-tape new file mode 100644 index 0000000000..24e39105f9 --- /dev/null +++ b/regress/regress/win32/tests/bscan-fast-tape @@ -0,0 +1,89 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then +# do a bscan and restore. +# It should require at least 4 different bsrs. +# +TestName="bscan-tape" +JobName=bscantape +. scripts/functions +set_debug 1 + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +# sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +setdebug level=2 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +echo "Starting Bacula tape writing" +#bin/btape -c bin/bacula-sd.conf /dev/nst0 </dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +echo "Begin attempt to read tape that crashes the system" +echo "volume=TestVolume001" >tmp/bscan.bsr +strace -o strace.new bin/bscan -d200 -w working -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf DDS-4 +exit +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log2.out +@# +@# now do a restore +@# +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula +rm -f ${cwd}/build/src/lib/dummy + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/bscan-tape b/regress/regress/win32/tests/bscan-tape new file mode 100644 index 0000000000..b477760078 --- /dev/null +++ b/regress/regress/win32/tests/bscan-tape @@ -0,0 +1,142 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then +# do a bscan and restore. +# It should require at least 4 different bsrs. +# +TestName="bscan-tape" +JobName=bscantape +. scripts/functions +set_debug 0 + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +estimate job=$JobName listing +estimate job=$JobName listing +estimate job=$JobName listing +messages +@$out tmp/log1.out +setdebug level=2 storage=DDS-4 +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +run job=$JobName level=Full yes +wait +run job=$JobName level=Full yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 + +echo "Backup 1 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/dird/*.c ${cwd}/build/src/dird/*.o +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o + +# +# run a second job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA + +run_bacula +scripts/check_for_zombie_jobs storage=DDS-4 + +echo "Backup 2 done" +touch ${cwd}/build/src/dird/*.c +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a third job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA + +run_bacula +scripts/check_for_zombie_jobs storage=DDS-4 + +echo "Backup 3 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +#echo "abc" > ${cwd}/build/src/lib/dummy +# +# run a fourth job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA + +run_bacula + +scripts/check_for_zombie_jobs storage=DDS-4 +stop_bacula + +echo "Backup 4 done" +# +# now drop and recreate the database +# +cd bin +./drop_bacula_tables >/dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +echo "volume=TestVolume001" >tmp/bscan.bsr +bin/bscan -w working -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf DDS-4 2>&1 >/dev/null + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log2.out +@# +@# now do a restore +@# +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula +rm -f ${cwd}/build/src/lib/dummy + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/bscan-test.1.bscr b/regress/regress/win32/tests/bscan-test.1.bscr new file mode 100644 index 0000000000..2ed6803e27 --- /dev/null +++ b/regress/regress/win32/tests/bscan-test.1.bscr @@ -0,0 +1,24 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=File1 +TestVolume001 +label storage=File1 +TestVolume002 +update Volume=TestVolume001 MaxVolBytes=3000000 +run job=@JobName@ storage=File1 +yes +wait +messages +@@out@ nul +@# +@# now purge the Volume +@# +purge volume=TestVolume001 +purge volume=TestVolume002 +delete volume=TestVolume001 +yes +delete volume=TestVolume002 +yes +messages +quit diff --git a/regress/regress/win32/tests/bscan-test.2.bscr b/regress/regress/win32/tests/bscan-test.2.bscr new file mode 100644 index 0000000000..9e80679312 --- /dev/null +++ b/regress/regress/win32/tests/bscan-test.2.bscr @@ -0,0 +1,13 @@ +@@out@ nul +messages +@@out@ tmp/log2.out +@# +@# now do a restore +@# +@#setdebug level=400 storage=File1 +restore bootstrap=@topdir@/tmp/bscan.bsr where=@topdir@/tmp/bacula-restores select all storage=File1 done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/bscan-test.cmd b/regress/regress/win32/tests/bscan-test.cmd new file mode 100644 index 0000000000..5b71db8c1a --- /dev/null +++ b/regress/regress/win32/tests/bscan-test.cmd @@ -0,0 +1,42 @@ +REM +REM Run a simple backup of the Bacula build directory but +REM split the archive into two volumes then bscan it +REM into the catalog after the backup. It also to a limited +REM extent tests the purge volume and delete volume commands. +REM + +SET TestName=bscan-test +SET JobName=bscan + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\bscan-test.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula + +ECHO volume=TestVolume001^|TestVolume002 >tmp\bscan.bsr + +IF %debug% EQU 1 ( + bin\bscan -w working -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf %CD:\=/%/tmp | tools\tee tmp\log.out +) ELSE ( + bin\bscan -w working -m -s -v -b tmp/bscan.bsr -c bin/bacula-sd.conf %CD:\=/%/tmp >nul 2>&1 +) + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\bscan-test.2.bscr >tmp\bconcmds + +REM now run restore +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/bsr-opt-test.bscr b/regress/regress/win32/tests/bsr-opt-test.bscr new file mode 100644 index 0000000000..1f0576b930 --- /dev/null +++ b/regress/regress/win32/tests/bsr-opt-test.bscr @@ -0,0 +1,24 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=File1 volume=TestVolume001 +label storage=File1 volume=TestVolume002 +update Volume=TestVolume001 MaxVolBytes=3000000 +run job=@JobName@ storage=File1 yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore bootstrap=@topdir@/working/restore.bsr where=@topdir@/tmp/bacula-restores select storage=File1 +unmark * +cd @topdir@/build/src/cats +mark * +ls +done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/bsr-opt-test.cmd b/regress/regress/win32/tests/bsr-opt-test.cmd new file mode 100644 index 0000000000..9f816ab084 --- /dev/null +++ b/regress/regress/win32/tests/bsr-opt-test.cmd @@ -0,0 +1,57 @@ +REM +REM Run a simple backup of the Bacula build directory but +REM split the archive into two volumes, then restore +REM files on only one of the volumes and ensure that +REM the other volume is not used. I.e. bsr optimization +REM works. +REM +SET TestName=bsr-opt-test +SET JobName=bsr-opt + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\bsr-opt-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula +REM +REM This test is not really reliable. What we want to do is +REM to select files on only one Volume, then insure here +REM that only one Volume is chosen. +REM +grep TestVolume002 working\restore.bsr >nul 2>&1 +SET bsrstat=%ERRORLEVEL% +CALL scripts\functions check_two_logs + +diff -r build\src\cats tmp\bacula-restores\%CD::=%\build\src\cats >nul 2>&1 +SET /A errcount = %bsrstat% + %bstat% + %rstat% +IF %errcount% NEQ 0 ( + ECHO. + ECHO. + ECHO !!!!! bsr-opt-test Bacula source failed!!! !!!!! + ECHO !!!!! bsr-opt-test failed!!! !!!!! >>test.out + + SET /A errcount = %bstat% + %rstat% + IF %errcount% NEQ 0 ( + ECHO !!!!! Bad Job termination status !!!!! + ECHO !!!!! Bad Job termination status !!!!! >>test.out + ) ELSE IF %bsrstat% NEQ 0 ( + ECHO !!!!! Volume selection error !!!!! + ECHO !!!!! Volume selection error !!!!! >>test.out + ) ELSE ( + ECHO !!!!! Restored files differ !!!!! + ECHO !!!!! Restored files differ !!!!! >>test.out + ) + ECHO. +) ELSE ( + ECHO ===== bsr-opt-test Bacula source OK %TIME% ===== + ECHO ===== bsr-opt-test OK %TIME% ===== >>test.out + CALL scripts\cleanup +) diff --git a/regress/regress/win32/tests/btape-fill-full-tape b/regress/regress/win32/tests/btape-fill-full-tape new file mode 100644 index 0000000000..f4ba59fb5b --- /dev/null +++ b/regress/regress/win32/tests/btape-fill-full-tape @@ -0,0 +1,35 @@ +#!/bin/sh +# +# Test the fill command in btape +# +TestName="btape-fill-full-tape" +JobName=AutoLabel +. scripts/functions +set_debug 0 + +scripts/copy-tape-confs +scripts/cleanup-tape + +change_jobname $JobName +start_test + +bin/btape -c bin/bacula-sd.conf DDS-4 <&1 >tmp/log1.out +fill +s + +quit +END_OF_DATA + + +grep "^The last block on the tape matches\. Test succeeded\." tmp/log1.out 2>&1 >/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " !!!!! btape fill test failed!!! !!!!! " + echo " !!!!! btape fill test failed!!! !!!!! " >>test.out + echo " " +else + echo " ===== btape fill test OK ===== " + echo " ===== btape fill test OK ===== " >>test.out +# scripts/cleanup +fi diff --git a/regress/regress/win32/tests/btape-fill-tape b/regress/regress/win32/tests/btape-fill-tape new file mode 100644 index 0000000000..43c9ce35b5 --- /dev/null +++ b/regress/regress/win32/tests/btape-fill-tape @@ -0,0 +1,38 @@ +#!/bin/sh +# +# Test the fill command in btape +# +TestName="btape-fill-tape" +JobName=filltape +. scripts/functions +set_debug 0 + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# MaximumVolumeSize% MaximumVolumeSize%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +start_test + +cat <tmp/bconcmds +fill +s +quit +END_OF_DATA + +run_btape DDS-4 + +grep "^The last block on the tape matches\. Test succeeded\." tmp/log1.out 2>&1 >/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " !!!!! btape fill test failed!!! !!!!! " + echo " !!!!! btape fill test failed!!! !!!!! " >>test.out + echo " " +else + echo " ===== btape fill test OK ===== " + echo " ===== btape fill test OK ===== " >>test.out +# scripts/cleanup +fi diff --git a/regress/regress/win32/tests/compressed-test.bscr b/regress/regress/win32/tests/compressed-test.bscr new file mode 100644 index 0000000000..d46459f878 --- /dev/null +++ b/regress/regress/win32/tests/compressed-test.bscr @@ -0,0 +1,23 @@ +@output +messages +@@out@ tmp/log1.out +status all +status all +messages +label storage=File volume=TestVolume001 +run job=@JobName@ storage=File yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/compressed-test.cmd b/regress/regress/win32/tests/compressed-test.cmd new file mode 100644 index 0000000000..2097c6124f --- /dev/null +++ b/regress/regress/win32/tests/compressed-test.cmd @@ -0,0 +1,24 @@ +REM +REM Run a simple backup of the Bacula build directory using the compressed option +REM then restore it. +REM +SET TestName=compressed-test +SET JobName=compressed + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\compressed-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/concurrent-jobs-test.bscr b/regress/regress/win32/tests/concurrent-jobs-test.bscr new file mode 100644 index 0000000000..1799fd6e0b --- /dev/null +++ b/regress/regress/win32/tests/concurrent-jobs-test.bscr @@ -0,0 +1,23 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ level=Full yes +run job=@JobName@ level=Full yes +run job=@JobName@ level=Full yes +run job=@JobName@ level=Full yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/concurrent-jobs-test.cmd b/regress/regress/win32/tests/concurrent-jobs-test.cmd new file mode 100644 index 0000000000..9c36b48c7e --- /dev/null +++ b/regress/regress/win32/tests/concurrent-jobs-test.cmd @@ -0,0 +1,35 @@ +REM +REM Run two jobs at the same time +REM + +SET TestName=concurrent-jobs-test +SET JobName=concurrent-jobs + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/tmp/largefile >\tmp\file-list +ECHO Creating a 50MB file with bacula-dir data ... +tools\dd if=bin/bacula-dir.exe of=%CD:\=/%/tmp/1 bs=1024 count=512 >nul 2>&1 +COPY /b %CD%\tmp\1+%CD%\tmp\1+%CD%\tmp\1+%CD%\tmp\1 %CD%\tmp\2 >nul 2>&1 +DEL %CD%\tmp\1 +COPY /b %CD%\tmp\2+%CD%\tmp\2+%CD%\tmp\2+%CD%\tmp\2+%CD%\tmp\2 %CD%\tmp\3 >nul 2>&1 +DEL %CD%\tmp\2 +COPY /b %CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3 %CD%\tmp\largefile >nul 2>&1 +DEL %CD%\tmp\3 + +ECHO largefile created + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\concurrent-jobs-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +diff tmp\largefile tmp\bacula-restores\%CD::=%\tmp\largefile >nul 2>&1 +SET dstat=%ERRORLEVEL% +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/dev-test-root b/regress/regress/win32/tests/dev-test-root new file mode 100644 index 0000000000..40a9bb2402 --- /dev/null +++ b/regress/regress/win32/tests/dev-test-root @@ -0,0 +1,85 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +MUID=`/usr/bin/id -u` +if [ $MUID != 0 ] ; then + echo " " + echo "You must be root to run this test." + echo " ===== !!!! dev-test-root not run !!!! ===== " + echo " ===== !!!! dev-test-root not run !!!! ===== " >>test.out + echo " " + exit 1 +fi +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "/dev" >${cwd}/tmp/file-list + +echo " " +echo " " +echo " === Starting dev-test-root test ===" +echo " " +echo " === Note, this test can fail for trivial ===" +echo " === reasons on non-Linux systems. ===" +echo " " +echo " " + +bin/bacula start 2>&1 >/dev/null +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test dev >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test dev >${cwd}/tmp/restored +cd ${cwd}/tmp +# +# Use sed to cut out parts that *always* change +# +cat >sed.scr <1 +sed -f sed.scr 1 | sort >original +# +mv -f restored 1 +sed -f sed.scr 1 | sort >restored +rm -f sed.scr +# +cd ${cwd} +diff tmp/original tmp/restored 2>&1 1>/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! dev-test-root failed !!!! ===== " + echo " ===== !!!! dev-test-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== dev-test-root OK ===== " + echo " ===== dev-test-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/win32/tests/differential-test.1.bscr b/regress/regress/win32/tests/differential-test.1.bscr new file mode 100644 index 0000000000..5b23122bdc --- /dev/null +++ b/regress/regress/win32/tests/differential-test.1.bscr @@ -0,0 +1,9 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume002 +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/differential-test.2.bscr b/regress/regress/win32/tests/differential-test.2.bscr new file mode 100644 index 0000000000..c8ddb49849 --- /dev/null +++ b/regress/regress/win32/tests/differential-test.2.bscr @@ -0,0 +1,9 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +@# Force differential on the second Volume +update volume=TestVolume002 VolStatus=Used +run level=differential job=@JobName@ yes +wait +messages +@@out@ diff --git a/regress/regress/win32/tests/differential-test.3.bscr b/regress/regress/win32/tests/differential-test.3.bscr new file mode 100644 index 0000000000..3d2b98e26b --- /dev/null +++ b/regress/regress/win32/tests/differential-test.3.bscr @@ -0,0 +1,16 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +run level=incremental job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores storage=File file=<@topdir@/tmp/restore-list +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/differential-test.cmd b/regress/regress/win32/tests/differential-test.cmd new file mode 100644 index 0000000000..6ffdff055c --- /dev/null +++ b/regress/regress/win32/tests/differential-test.cmd @@ -0,0 +1,48 @@ +REM +REM Run a simple backup of the Bacula build directory then create some +REM new files, do a differential and restore those two files. +REM +SET TestName=differential-test +SET JobName=differential + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/tmp/build >\tmp\file-list +MKDIR tmp\build +COPY build\src\dird\*.c tmp\build >nul 2>&1 + +ECHO %CD:\=/%/tmp/build/ficheriro1.txt>tmp\restore-list +ECHO %CD:\=/%/tmp/build/ficheriro2.txt>>tmp\restore-list + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\differential-test.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO ficheriro1.txt >tmp\build\ficheriro1.txt +ECHO ficheriro2.txt >tmp\build\ficheriro2.txt + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\differential-test.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole + +CALL scripts\functions check_for_zombie_jobs storage=File +ECHO ficheriro2.txt >tmp\build\ficheriro2.txt + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\differential-test.3.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +REM +REM Delete .c files because we will only restore the txt files +REM +DEL tmp\build\*.c +CALL scripts\functions check_restore_tmp_build_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/eot-fail-tape b/regress/regress/win32/tests/eot-fail-tape new file mode 100644 index 0000000000..aff28cd4dd --- /dev/null +++ b/regress/regress/win32/tests/eot-fail-tape @@ -0,0 +1,51 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to two tapes where the maximum tape file size is set to 1M +# +TestName="eot-fail-tape" +JobName=eotfailtape +. scripts/functions +set_debug 0 + +scripts/cleanup-tape +scripts/copy-tape-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +out="tmp/sed_tmp" +echo "s%# Maximum File Size% Maximum File Size%g" >${out} +cp -f ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed -f ${out} ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +update Volume=TestVolume001 MaxVolBytes=3000000 +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@tee +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/etc-test-root b/regress/regress/win32/tests/etc-test-root new file mode 100644 index 0000000000..c9c9ac6aec --- /dev/null +++ b/regress/regress/win32/tests/etc-test-root @@ -0,0 +1,70 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +MUID=`/usr/bin/id -u` +if [ $MUID != 0 ] ; then + echo " " + echo "You must be root to run this test." + echo " ===== !!!! etc-test-root not run !!!! ===== " + echo " ===== !!!! etc-test-root not run !!!! ===== " >>test.out + echo " " + exit 1 +fi +echo " " +echo " " +echo " === Starting /etc save/restore test ===" +echo " " +echo " " +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "/etc" >${cwd}/tmp/file-list + +bin/bacula start 2>&1 >/dev/null +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test etc >${cwd}/tmp/1 +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-etc-test etc >${cwd}/tmp/2 +sort <${cwd}/tmp/1 >${cwd}/tmp/original +sort <${cwd}/tmp/2 >${cwd}/tmp/restored +rm -f ${cwd}/tmp/1 ${cwd}/tmp/2 +cd ${cwd} +diff tmp/original tmp/restored 2>&1 1>/dev/null +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! etc-test-root failed !!!! ===== " + echo " ===== !!!! etc-test-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== etc-test-root OK ===== " + echo " ===== etc-test-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/win32/tests/fixed-block-size-tape b/regress/regress/win32/tests/fixed-block-size-tape new file mode 100644 index 0000000000..e3cfb4d5a8 --- /dev/null +++ b/regress/regress/win32/tests/fixed-block-size-tape @@ -0,0 +1,62 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape where we set the minimum and maximum block +# sizes. +# +TestName="fixed-block-size-tape" +JobName=fixedblocksize +. scripts/functions +set_debug 0 + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +echo "s%# Maximum Block Size% Maximum Block Size%" >${cwd}/tmp/2 +echo "s%# Minimum Block Size% Minimum Block Size%" >>${cwd}/tmp/2 +sed -f ${cwd}/tmp/2 ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf +if [ $? != 0 ] ; then + echo " " + echo " " + echo "!!!! sed problem in Fixed Block Size test !!!!!" + echo " " + exit 1 +fi +rm -f ${cwd}/tmp/1 ${cwd}/tmp/2 + +change_jobname NightlySave $JobName +start_test + + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/four-concurrent-jobs-tape b/regress/regress/win32/tests/four-concurrent-jobs-tape new file mode 100644 index 0000000000..ada9d45587 --- /dev/null +++ b/regress/regress/win32/tests/four-concurrent-jobs-tape @@ -0,0 +1,56 @@ +#!/bin/sh +# +# Run four jobs at the same time +# +TestName="four-concurrent-jobs-tape" +JobName=FourConcurrentJobs +. scripts/functions +set_debug 0 + +scripts/cleanup-tape +scripts/copy-tape-confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +run job=$JobName level=Full Storage=DDS-4 yes +@sleep 2 +status dir +@sleep 5 +status dir +status storage=DDS-4 +messages +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/four-concurrent-jobs-test.bscr b/regress/regress/win32/tests/four-concurrent-jobs-test.bscr new file mode 100644 index 0000000000..cdae631049 --- /dev/null +++ b/regress/regress/win32/tests/four-concurrent-jobs-test.bscr @@ -0,0 +1,50 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File1 +TestVolume001 +label storage=File1 +TestVolume002 +update Volume=TestVolume001 MaxVolBytes=100000000 +@#50000000 +@#12 +run job=@JobName@ level=Full Storage=File1 +yes +reload +run job=@JobName@ level=Full Storage=File1 +yes +reload +run job=@JobName@ level=Full Storage=File1 +yes +reload +run job=@JobName@ level=Full Storage=File1 +yes +reload +reload +reload +reload +@sleep 2 +status dir +reload +@sleep 5 +messages +reload +reload +wait +reload +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File1 +unmark * +mark * +done +yes +wait +reload +reload +messages +@output +quit diff --git a/regress/regress/win32/tests/four-concurrent-jobs-test.cmd b/regress/regress/win32/tests/four-concurrent-jobs-test.cmd new file mode 100644 index 0000000000..0530baa8f0 --- /dev/null +++ b/regress/regress/win32/tests/four-concurrent-jobs-test.cmd @@ -0,0 +1,23 @@ +REM +REM Run two jobs at the same time +REM +SET TestName=four-concurrent-jobs-test +SET JobName=Four-concurrent-jobs + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\four-concurrent-jobs-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/four-jobs-tape b/regress/regress/win32/tests/four-jobs-tape new file mode 100644 index 0000000000..cf2c0afb3b --- /dev/null +++ b/regress/regress/win32/tests/four-jobs-tape @@ -0,0 +1,153 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then finally restore. +# It should require at least 4 different bsrs. +# +TestName="four-jobs-tape" +JobName=fourjobstape +. scripts/functions +set_debug 0 + +scripts/cleanup-tape +scripts/copy-tape-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <tmp/bconcmds +@$out /dev/null +estimate job=$JobName listing +estimate job=$JobName listing +estimate job=$JobName listing +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 1 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/dird/*.c ${cwd}/build/src/dird/*.o +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o + +# +# run a second job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 2 done" +touch ${cwd}/build/src/dird/*.c +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a third job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 3 done" +# make some files for the incremental to pick up +touch ${cwd}/build/src/lib/*.c ${cwd}/build/src/lib/*.o +# +# run a fourth job +# +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Incremental yes +wait +messages +quit +END_OF_DATA +if test "$debug" -eq 1 ; then + bin/bacula start + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf +else + bin/bacula start 2>&1 >/dev/null + cat tmp/bconcmds | bin/bconsole -c bin/bconsole.conf 2>&1 >/dev/null +fi + +scripts/check_for_zombie_jobs storage=DDS-4 +echo "Backup 4 done" +# +# now do several restores to ensure we cleanup between jobs +# +cat <tmp/bconcmds +@$out /dev/null +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +@$out tmp/log2.out +@# +@# now unmount the tape and start two restores +@# at the same time +@# +unmount storage=DDS-4 +restore where=${cwd}/tmp/bacula-restores select all done +yes +restore where=${cwd}/tmp/bacula-restores select +unmark * +mark * +done +yes +mount storage=DDS-4 +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/four-jobs-test.1.bscr b/regress/regress/win32/tests/four-jobs-test.1.bscr new file mode 100644 index 0000000000..462c2545f8 --- /dev/null +++ b/regress/regress/win32/tests/four-jobs-test.1.bscr @@ -0,0 +1,11 @@ +@output nul +estimate job=@JobName@ listing +estimate job=@JobName@ listing +estimate job=@JobName@ listing +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/four-jobs-test.2.bscr b/regress/regress/win32/tests/four-jobs-test.2.bscr new file mode 100644 index 0000000000..02fdc49786 --- /dev/null +++ b/regress/regress/win32/tests/four-jobs-test.2.bscr @@ -0,0 +1,8 @@ +@output nul +messages +@@out@ tmp/log1.out +run job=@JobName@ +yes +wait +messages +quit diff --git a/regress/regress/win32/tests/four-jobs-test.3.bscr b/regress/regress/win32/tests/four-jobs-test.3.bscr new file mode 100644 index 0000000000..6da93295f1 --- /dev/null +++ b/regress/regress/win32/tests/four-jobs-test.3.bscr @@ -0,0 +1,8 @@ +@output nul +messages +@output tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/four-jobs-test.4.bscr b/regress/regress/win32/tests/four-jobs-test.4.bscr new file mode 100644 index 0000000000..6da93295f1 --- /dev/null +++ b/regress/regress/win32/tests/four-jobs-test.4.bscr @@ -0,0 +1,8 @@ +@output nul +messages +@output tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/four-jobs-test.5.bscr b/regress/regress/win32/tests/four-jobs-test.5.bscr new file mode 100644 index 0000000000..30bf4a7053 --- /dev/null +++ b/regress/regress/win32/tests/four-jobs-test.5.bscr @@ -0,0 +1,17 @@ +@output nul +restore where=@topdir@/tmp/bacula-restores select all storage=File done +yes +wait +restore where=@topdir@/tmp/bacula-restores select all storage=File done +yes +wait +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/four-jobs-test.cmd b/regress/regress/win32/tests/four-jobs-test.cmd new file mode 100644 index 0000000000..72b00e0210 --- /dev/null +++ b/regress/regress/win32/tests/four-jobs-test.cmd @@ -0,0 +1,74 @@ +REM +REM Run a simple backup of the Bacula build directory using the compressed option +REM then backup four times, each with incremental then finally restore. +REM It should require at least 4 different bsrs. +REM +SET TestName=four-jobs-test +SET JobName=SpanVol + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >${cwd}/tmp/file-list + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\four-jobs-test.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO Backup 1 done + +REM make some files for the incremental to pick up +tools\touch %CD:\=/%/build/src/dird/*.c +tools\touch %CD:\=/%/build/src/lib/*.c + +REM +REM run a second job +REM +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\four-jobs-test.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO Backup 2 done + +tools\touch %CD:\=/%/build/src/dird/*.c +tools\touch %CD:\=/%/build/src/lib/*.c + +REM +REM run a third job +REM +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\four-jobs-test.3.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO Backup 3 done + +REM make some files for the incremental to pick up +tools\touch %CD:\=/%/build/src/lib/*.c + +REM +REM run a fourth job +REM +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\four-jobs-test.4.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO Backup 4 done +REM +REM now do several restores to ensure we cleanup between jobs +REM +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\four-jobs-test.5.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/hardlink-test b/regress/regress/win32/tests/hardlink-test new file mode 100644 index 0000000000..05233e2f84 --- /dev/null +++ b/regress/regress/win32/tests/hardlink-test @@ -0,0 +1,66 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="hardlink-test" +JobName=hardlink +. scripts/functions +set_debug 0 + +if test ! -d weird-files ; then + echo " " + echo "Weird files not configured. Test not run." + exit 0 +fi + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +change_jobname NightlySave $JobName +# +# Note, we save the weird-files directory twice on purpose +# because this causes problems with hard linked files +# that are only saved once. In 1.33, Bacula now deals +# with this situation. +# +echo "${cwd}/weird-files" >${cwd}/tmp/file-list +echo "${cwd}/weird-files" >>${cwd}/tmp/file-list + +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=File +TestVolume001 +run job=$JobName +yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=File +5 +cd ${cwd}/weird-files/subdir +mark another-hardlink +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +check_two_logs +diff ${cwd}/weird-files/subdir/another-hardlink \ + ${cwd}/tmp/bacula-restores/${cwd}/weird-files/subdir/another-hardlink 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/win32/tests/incremental-2disk.1.bscr b/regress/regress/win32/tests/incremental-2disk.1.bscr new file mode 100644 index 0000000000..fdbc4a7615 --- /dev/null +++ b/regress/regress/win32/tests/incremental-2disk.1.bscr @@ -0,0 +1,9 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Default drive=0 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/incremental-2disk.2.bscr b/regress/regress/win32/tests/incremental-2disk.2.bscr new file mode 100644 index 0000000000..76032d1a1d --- /dev/null +++ b/regress/regress/win32/tests/incremental-2disk.2.bscr @@ -0,0 +1,21 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +run level=Incremental job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores +7 +<@topdir@/tmp/restore-list + +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/incremental-2disk.cmd b/regress/regress/win32/tests/incremental-2disk.cmd new file mode 100644 index 0000000000..a51fc8ad05 --- /dev/null +++ b/regress/regress/win32/tests/incremental-2disk.cmd @@ -0,0 +1,55 @@ +REM +REM Run a simple backup of the Bacula build directory then create some +REM new files, do an Incremental and restore those two files. +REM +REM This script uses the virtual disk autochanger +REM +SET TestName=incremental-2disk +SET JobName=Inc2disk + +CALL scripts\functions set_debug 0 + +CALL config_out + +CALL scripts\functions stop_bacula + +CALL bin\drop_bacula_tables >nul 2>&1 +CALL bin\make_bacula_tables >nul 2>&1 +CALL bin\grant_bacula_privileges >nul 2>&1 + +CALL scripts\copy-2disk-confs >nul 2>&1 +CALL scripts\prepare-two-disks + +ECHO %CD:\=/%/tmp/build >\tmp\file-list +IF NOT EXIST tmp\build MKDIR tmp\build + +COPY build\src\dird\*.c tmp\build >nul 2>&1 +ECHO %CD:\=/%/tmp/build/ficheriro1.txt>tmp\restore-list +ECHO %CD:\=/%/tmp/build/ficheriro2.txt>>tmp\restore-list + +CALL scripts\functions change_jobname %JobName% +CALL scripts\functions start_test + +REM Write out bconsole commands +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-2disk.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula + +ECHO ficheriro1.txt >tmp\build\ficheriro1.txt +ECHO ficheriro2.txt >tmp\build\ficheriro2.txt + + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-2disk.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole + +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula +REM +REM Delete .c files because we will only restored the txt files +REM +DEL tmp\build\*.c + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_tmp_build_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/incremental-2tape.1.bscr b/regress/regress/win32/tests/incremental-2tape.1.bscr new file mode 100644 index 0000000000..b5fa189e47 --- /dev/null +++ b/regress/regress/win32/tests/incremental-2tape.1.bscr @@ -0,0 +1,9 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 Pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 Pool=Default drive=0 +run job=NightlySave yes +wait +messages +quit diff --git a/regress/regress/win32/tests/incremental-2tape.2.bscr b/regress/regress/win32/tests/incremental-2tape.2.bscr new file mode 100644 index 0000000000..f57357f747 --- /dev/null +++ b/regress/regress/win32/tests/incremental-2tape.2.bscr @@ -0,0 +1,21 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +run level=Incremental job=NightlySave yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores +7 +<@topdir@/tmp/restore-list + +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/incremental-2tape.cmd b/regress/regress/win32/tests/incremental-2tape.cmd new file mode 100644 index 0000000000..2a646a0edd --- /dev/null +++ b/regress/regress/win32/tests/incremental-2tape.cmd @@ -0,0 +1,48 @@ +REM +REM Run a simple backup of the Bacula build directory then create some +REM new files, do an Incremental and restore those two files. +REM +REM This script uses the autochanger and two tapes +REM +SET TestName=incremental-2tape +SET JobName=inctwotape +CALL scripts\functions set_debug 0 + +CALL config_out +IF "%AUTOCHANGER%" == "nul" ( + ECHO incremental-2tape test skipped. No autochanger. + EXIT +) + +CALL scripts\functions stop_bacula +CALL drop_bacula_tables >nul 2>&1 +CALL make_bacula_tables >nul 2>&1 +CALL grant_bacula_privileges >nul 2>&1 + +CALL scripts\copy-2tape-confs +CALL scripts\cleanup-2tape +ECHO %CD:\=/%/tmp/build >\tmp\file-list +IF NOT EXIST tmp\build MKDIR tmp\build +COPY build\src\dird\*.c tmp\build +ECHO %CD:\=/%/tmp/build/ficheriro1.txt>tmp\restore-list +ECHO %CD:\=/%/tmp/build/ficheriro2.txt>>tmp\restore-list + +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-2tape.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula + +ECHO ficheriro1.txt >tmp\build\ficheriro1.txt +ECHO ficheriro2.txt >tmp\build\ficheriro2.txt + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-2tape.2.bscr >tmp\bconcmds +CALL scripts\functions run_bconsole +CALL scripts\bacula stop_bacula +CALL scripts\bacula check_two_logs +REM +REM Delete .c files because we will only restore the txt files +REM +DEL tmp\build\*.c +CALL scripts\bacula check_restore_tmp_build_diff +CALL scripts\bacula end_test diff --git a/regress/regress/win32/tests/incremental-tape b/regress/regress/win32/tests/incremental-tape new file mode 100644 index 0000000000..11cb02c357 --- /dev/null +++ b/regress/regress/win32/tests/incremental-tape @@ -0,0 +1,76 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory then create some +# new files, do an Incremental and restore those two files. +# +TestName="incremental-tape" +JobName=IncTape +. scripts/functions +set_debug 0 + +copy_tape_confs + +echo "${cwd}/tmp/build" >${cwd}/tmp/file-list +if test ! -d ${cwd}/tmp/build ; then + mkdir ${cwd}/tmp/build +fi +cp -p ${cwd}/build/src/dird/*.c ${cwd}/tmp/build +cd ${cwd}/tmp +echo "${cwd}/tmp/build/ficheriro1.txt" >restore-list +echo "${cwd}/tmp/build/ficheriro2.txt" >>restore-list +cd ${cwd} + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 + +echo "ficheriro1.txt" >${cwd}/tmp/build/ficheriro1.txt +echo "ficheriro2.txt" >${cwd}/tmp/build/ficheriro2.txt + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +run level=Incremental job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=DDS-4 +7 +<${cwd}/tmp/restore-list + +yes +wait +messages +@output +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +# +# Delete .c files because we will only restored the txt files +# +rm -f tmp/build/*.c + +check_two_logs +check_restore_tmp_build_diff +end_test diff --git a/regress/regress/win32/tests/incremental-test.1.bscr b/regress/regress/win32/tests/incremental-test.1.bscr new file mode 100644 index 0000000000..9ab38bffe0 --- /dev/null +++ b/regress/regress/win32/tests/incremental-test.1.bscr @@ -0,0 +1,9 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +label storage=File volume=TestVolume002 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/incremental-test.2.bscr b/regress/regress/win32/tests/incremental-test.2.bscr new file mode 100644 index 0000000000..f716a022c8 --- /dev/null +++ b/regress/regress/win32/tests/incremental-test.2.bscr @@ -0,0 +1,9 @@ +@output nul +messages +@@out@ tmp/log1.out +@# Force Incremental on the second Volume +update volume=TestVolume001 VolStatus=Used +run level=Differential job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/incremental-test.3.bscr b/regress/regress/win32/tests/incremental-test.3.bscr new file mode 100644 index 0000000000..c4239dd0a3 --- /dev/null +++ b/regress/regress/win32/tests/incremental-test.3.bscr @@ -0,0 +1,7 @@ +@output nul +messages +@@out@ tmp/log1.out +run level=Incremental job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/incremental-test.4.bscr b/regress/regress/win32/tests/incremental-test.4.bscr new file mode 100644 index 0000000000..700afcb8d4 --- /dev/null +++ b/regress/regress/win32/tests/incremental-test.4.bscr @@ -0,0 +1,7 @@ +@output nul +messages +@@out@ tmp/log1.out +run level=Differential job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/incremental-test.5.bscr b/regress/regress/win32/tests/incremental-test.5.bscr new file mode 100644 index 0000000000..1f093f18ef --- /dev/null +++ b/regress/regress/win32/tests/incremental-test.5.bscr @@ -0,0 +1,16 @@ +@output nul +messages +@@out@ tmp/log1.out +run level=Incremental job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@output tmp/log2.out +restore where=@topdir@/tmp/bacula-restores storage=File file=<@topdir@/tmp/restore-list +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/incremental-test.cmd b/regress/regress/win32/tests/incremental-test.cmd new file mode 100644 index 0000000000..baf5bd3729 --- /dev/null +++ b/regress/regress/win32/tests/incremental-test.cmd @@ -0,0 +1,91 @@ +REM +REM Run a simple backup of the Bacula build directory then create some +REM new files, do an Incremental and restore those two files. +REM +SET TestName=incremental-test +SET JobName=Incremental + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/tmp/build>${cwd}/tmp/file-list + +MKDIR tmp\build +COPY build\src\dird\*.c tmp\build >nul 2>&1 + +ECHO %CD:\=/%/tmp/build/ficheriro1.txt>tmp\restore-list +ECHO %CD:\=/%/tmp/build/ficheriro2.txt>>tmp\restore-list + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +REM +REM Now create two new files to be restored later +REM +bin\bsleep 1 +ECHO ficheriro1.txt >tmp\build\ficheriro1.txt +COPY tmp\build\dird.c tmp\build\ficheriro2.txt >nul 2>&1 + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole + +bin\bsleep 1 +touch tmp\build\ficheriro1.txt +touch tmp\build\ficheriro2.txt + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.3.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole + +bin\bsleep 1 + +COPY tmp\build\ficheriro2.txt tmp\build\1 >nul 2>&1 +sed -e "s;a;b;g" tmp\build\1 >tmp\build\ficheriro2.txt +DEL tmp\build\1 + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.4.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole + +bin\bsleep 1 +touch tmp\build\ficheriro1.txt +touch tmp\build\ficheriro2.txt +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.3.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole + +bin\bsleep 1 +touch tmp\build\ficheriro1.txt +touch tmp\build\ficheriro2.txt +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.3.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole + +bin\bsleep 1 +touch tmp\build\ficheriro1.txt +touch tmp\build\ficheriro2.txt +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.3.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +bin\bsleep 1 +touch tmp\build\ficheriro1.txt +touch tmp\build\ficheriro2.txt + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\incremental-test.5.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +REM +REM Delete .c files because we will only restored the txt files +REM +DEL tmp\build\*.c +CALL scripts\functions check_restore_tmp_build_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/lib-tape-root b/regress/regress/win32/tests/lib-tape-root new file mode 100644 index 0000000000..f65d28a8b1 --- /dev/null +++ b/regress/regress/win32/tests/lib-tape-root @@ -0,0 +1,67 @@ +#!/bin/sh +# +# Run a simple backup of the /lib directory +# then restore it. +# +cwd=`pwd` +bin/bacula stop 2>&1 >/dev/null +cd bin +./drop_bacula_tables >/dev/null 2>&1 +./make_bacula_tables >/dev/null 2>&1 +./grant_bacula_privileges 2>&1 >/dev/null +cd .. + +scripts/cleanup-tape +scripts/copy-tape-confs +echo "/lib" >${cwd}/tmp/file-list +echo " " +echo " " +echo " === Starting lib-tape-root test ===" +echo " " +echo " " +bin/bacula start 2>&1 >/dev/null +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/restored +cd ${cwd}/tmp +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% original >1 +sort <1 >original +# +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% restored >1 +sort <1 >restored +rm -f 1 +# +cd ${cwd} +diff tmp/original tmp/restored 2>&1 1>/dev/nul +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== lib-tape-root failed!!! ===== " + echo " ===== lib-tape-root failed!!! ===== " >>test.out + echo " " +else + echo " ===== lib-tape-root OK ===== " + echo " ===== lib-tape-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/win32/tests/lib-test-root b/regress/regress/win32/tests/lib-test-root new file mode 100644 index 0000000000..43b71d0b58 --- /dev/null +++ b/regress/regress/win32/tests/lib-test-root @@ -0,0 +1,76 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +MUID=`/usr/bin/id -u` +if [ $MUID != 0 ] ; then + echo " " + echo "You must be root to run this test." + echo " ===== !!!! lib-test-root not run !!!! ===== " + echo " ===== !!!! lib-test-root not run !!!! ===== " >>test.out + echo " " + exit 1 +fi +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +echo "/lib" >${cwd}/tmp/file-list + +echo " " +echo " " +echo " === Starting /lib save/restore test ===" +echo " " +echo " " + +bin/bacula start 2>&1 >/dev/null +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-lib-test lib >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-lib-test lib >${cwd}/tmp/restored +cd ${cwd}/tmp +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% original >1 +sort <1 >original +# +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% restored >1 +sort <1 >restored +rm -f 1 +# +cd ${cwd} +diff tmp/original tmp/restored 2>&1 1>/dev/nul +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! lib-test-root failed !!!! ===== " + echo " ===== !!!! lib-test-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== lib-test-root OK ===== " + echo " ===== lib-test-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/win32/tests/migration-job-test.cmd b/regress/regress/win32/tests/migration-job-test.cmd new file mode 100644 index 0000000000..d851fdeea6 --- /dev/null +++ b/regress/regress/win32/tests/migration-job-test.cmd @@ -0,0 +1,37 @@ +REM +REM Run a simple backup of the Bacula build directory then migrate it +REM to another device. +REM +REM This script uses the virtual disk autochanger +REM +SET TestName=migration-job-test +SET JobName=MigrationJobSave + +CALL scripts\functions set_debug 0 + +CALL config_out + +CALL scripts\cleanup +CALL scripts\copy-migration-confs +CALL scripts\prepare-two-disks +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +REM +REM Note, we first backup into Pool Default, +REM then Migrate into Pool Full. +REM Pool Default uses Storage=File +REM Pool Full uses Storage=DiskChanger + +REM Write out bconsole commands +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\migration-job-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/migration-jobspan-test.cmd b/regress/regress/win32/tests/migration-jobspan-test.cmd new file mode 100644 index 0000000000..e21a19aaf2 --- /dev/null +++ b/regress/regress/win32/tests/migration-jobspan-test.cmd @@ -0,0 +1,42 @@ +REM +REM Run a simple backup of the Bacula build directory then migrate it +REM to another device. +REM +REM Test migrating a job that spans two Volumes +REM +REM This script uses the virtual disk autochanger +REM +SET TestName=migration-jobspan-test +SET JobName=MigrationJobSpanSave + +CALL scripts\functions set_debug 0 + +CALL config_out + +CALL scripts\cleanup +CALL scripts\copy-migration-confs +CALL scripts\prepare-two-disks + +ECHO %CD:\=/%/build >\tmp\file-list + +COPY bin\bacula-sd.conf tmp\1 +sed "s;# Maximum File Size; Maximum File Size;" %CD%\tmp\1 >%CD%\bin\bacula-sd.conf + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +REM +REM Note, we first backup into Pool Default, +REM then Migrate into Pool Full. +REM Pool Default uses Storage=File +REM Pool Full uses Storage=DiskChanger + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\migration-jobspan-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/migration-occupancy-test.cmd b/regress/regress/win32/tests/migration-occupancy-test.cmd new file mode 100644 index 0000000000..d68dac563d --- /dev/null +++ b/regress/regress/win32/tests/migration-occupancy-test.cmd @@ -0,0 +1,36 @@ +REM +REM Run a simple backup of the Bacula build directory then migrate it +REM to another device. +REM +REM This script uses the virtual disk autochanger +REM +SET TestName=migration-occupancy-test +SET JobName=MigrationJobSave + +CALL scripts\functions set_debug 0 + +CALL config_out + +CALL scripts\cleanup +CALL scripts\copy-migration-confs +CALL scripts\prepare-two-disks +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +REM +REM Note, we first backup into Pool Default, +REM then Migrate into Pool Full. +REM Pool Default uses Storage=File +REM Pool Full uses Storage=DiskChanger + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\migration-occupancy-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/migration-time-test.cmd b/regress/regress/win32/tests/migration-time-test.cmd new file mode 100644 index 0000000000..473ebe6b5e --- /dev/null +++ b/regress/regress/win32/tests/migration-time-test.cmd @@ -0,0 +1,37 @@ +REM +REM Run a simple backup of the Bacula build directory then migrate it +REM to another device. +REM +REM This script uses the virtual disk autochanger +REM +SET TestName=migration-time-test +SET JobName=MigrationJobSave + +CALL scripts\functions set_debug 0 + +CALL config_out + +CALL scripts\cleanup +CALL scripts\copy-migration-confs +CALL scripts\prepare-two-disks + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +REM +REM Note, we first backup into Pool Default, +REM then Migrate into Pool Full. +REM Pool Default uses Storage=File +REM Pool Full uses Storage=DiskChanger + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\migration-time-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/migration-volume-test.cmd b/regress/regress/win32/tests/migration-volume-test.cmd new file mode 100644 index 0000000000..86505d46a6 --- /dev/null +++ b/regress/regress/win32/tests/migration-volume-test.cmd @@ -0,0 +1,40 @@ +REM +REM Run a backup of the Bacula build directory on two Volumes +REM then migrate it to another device. +REM +REM This script uses the virtual disk autochanger +REM +SET TestName=migration-volume-test +SET JobName=MigVolBackup + +CALL scripts\functions set_debug 0 + +CALL config_out + +CALL scripts\cleanup +CALL scripts\copy-migration-confs +CALL scripts\prepare-two-disks + +ECHO %CD:\=/%/build >\tmp\file-list + +REM COPY bin\bacula-sd.conf tmp\1 +REM sed "s;# Maximum File Size; Maximum File Size;" tmp\1 >bin\bacula-sd.conf + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +REM +REM Note, we first backup into Pool Default, +REM then Migrate into Pool Full. +REM Pool Default uses Storage=File +REM Pool Full uses Storage=DiskChanger + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\migration-volume-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/query-test.1.bscr b/regress/regress/win32/tests/query-test.1.bscr new file mode 100644 index 0000000000..9ab38bffe0 --- /dev/null +++ b/regress/regress/win32/tests/query-test.1.bscr @@ -0,0 +1,9 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +label storage=File volume=TestVolume002 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/query-test.2.bscr b/regress/regress/win32/tests/query-test.2.bscr new file mode 100644 index 0000000000..9e1afb7dfb --- /dev/null +++ b/regress/regress/win32/tests/query-test.2.bscr @@ -0,0 +1,9 @@ +@output nul +messages +@@out@ tmp/log1.out +@# Force differental on the second Volume +update volume=TestVolume001 VolStatus=Used +run level=differental job=@JobName@ yes +wait +messages +@output diff --git a/regress/regress/win32/tests/query-test.3.bscr b/regress/regress/win32/tests/query-test.3.bscr new file mode 100644 index 0000000000..266f6a4ff7 --- /dev/null +++ b/regress/regress/win32/tests/query-test.3.bscr @@ -0,0 +1,46 @@ +@output nul +messages +@@out@ tmp/log1.out +run level=incremental job=@JobName@ yes +wait +messages +@# +@# Now do the queries +@# +query +1 +ficheriro1.txt +query +2 +@topdir@/tmp/build/ +ficheriro1.txt +localhost-fd +query +6 +TestVolume001 +query +7 +1 +query +8 +localhost-fd +query +9 +Default +query +10 +query +11 +query +12 +1 +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores storage=File file=<@topdir@/tmp/restore-list +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/query-test.cmd b/regress/regress/win32/tests/query-test.cmd new file mode 100644 index 0000000000..d919bbea87 --- /dev/null +++ b/regress/regress/win32/tests/query-test.cmd @@ -0,0 +1,48 @@ +REM +REM Run a simple backup of the Bacula build directory then create some +REM new files, do a Differental then a bunch of query commands +REM and finally restore the two files. +REM +SET TestName=query-test +SET JobName=query + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/tmp/build >\tmp\file-list +MKDIR tmp\build +COPY build\src\dird\*.c tmp\build >nul 2>&1 +ECHO %CD:\=/%/tmp/build/ficheriro1.txt>tmp\restore-list +ECHO %CD:\=/%/tmp/build/ficheriro2.txt>>tmp\restore-list + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\query-test.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO ficheriro1.txt >tmp\build\ficheriro1.txt +ECHO ficheriro2.txt >tmp\build\ficheriro2.txt + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\query-test.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO ficheriro2.txt >tmp\build\ficheriro2.txt +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\query-test.3.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +REM +REM Delete .c files because we will only restored the txt files +REM +DEL tmp\build\*.c + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_tmp_build_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/recycle-test.bscr b/regress/regress/win32/tests/recycle-test.bscr new file mode 100644 index 0000000000..734cc7e9d3 --- /dev/null +++ b/regress/regress/win32/tests/recycle-test.bscr @@ -0,0 +1,51 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File1 volume=TestVolume001 +label storage=File1 volume=TestVolume002 +label storage=File1 volume=TestVolume003 +update Volume=TestVolume001 volretention=10s +update Volume=TestVolume001 maxvoljobs=1 +update Volume=TestVolume002 volretention=10s +update Volume=TestVolume002 maxvoljobs=1 +update Volume=TestVolume003 volretention=10s +update Volume=TestVolume003 maxvoljobs=1 +list volumes +run job=@JobName@ storage=File1 level=full yes +wait +messages +list volumes +run job=@JobName@ storage=File1 level=full yes +wait +messages +list volumes +run job=@JobName@ storage=File1 level=full yes +wait +messages +list volumes +@sleep 10 +run job=@JobName@ storage=File1 level=full yes +wait +messages +list volumes +run job=@JobName@ storage=File1 level=full yes +wait +messages +list volumes +run job=@JobName@ storage=File1 level=full yes +wait +messages +list volumes +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File1 +unmark * +mark * +done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/recycle-test.cmd b/regress/regress/win32/tests/recycle-test.cmd new file mode 100644 index 0000000000..b006fe482f --- /dev/null +++ b/regress/regress/win32/tests/recycle-test.cmd @@ -0,0 +1,26 @@ +REM +REM Run a simple backup of the Bacula build directory but +REM create three volumes and do six backups causing the +REM volumes to be recycled, and cycling through the volumes +REM twice. Tests maxvoljobs and volretention. +REM +SET TestName=recycle-test +SET JobName=Recycle + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\recycle-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/relabel-tape b/regress/regress/win32/tests/relabel-tape new file mode 100644 index 0000000000..46b971a9fd --- /dev/null +++ b/regress/regress/win32/tests/relabel-tape @@ -0,0 +1,94 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory using the compressed option +# then backup four times, each with incremental then finally restore. +# It should require at least 4 different bsrs. +# +TestName="relabel-tape" +JobName=Relabeltape +. scripts/functions +set_debug 0 + +scripts/cleanup-tape +scripts/copy-tape-confs +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full yes +wait +messages +add pool=Default +0 +TestVolume002 +@# set status to append +update volume=TestVolume001 +1 +. +run job=NightlySave level=Full yes +@sleep 20 +unmount +unmount +purge volume=TestVolume001 +relabel oldvolume=TestVolume001 volume=TestVolume003 slot=0 pool=Default +list volumes +mount +messages +wait +run job=$JobName level=Full yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 + + +echo "Backup done" +# +# now do several restores to ensure we cleanup between jobs +# +cat <tmp/bconcmds +@$out /dev/null +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +restore where=${cwd}/tmp/bacula-restores select all done +yes +wait +@$out tmp/log2.out +@# +@# now unmount the tape and start two restores +@# at the same time +@# +unmount storage=DDS-4 +restore where=${cwd}/tmp/bacula-restores select all done +yes +restore where=${cwd}/tmp/bacula-restores select +unmark * +mark * +done +yes +mount storage=DDS-4 +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole + +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/restore-by-file-tape b/regress/regress/win32/tests/restore-by-file-tape new file mode 100644 index 0000000000..adc01c421f --- /dev/null +++ b/regress/regress/win32/tests/restore-by-file-tape @@ -0,0 +1,101 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape where the maximum tape file size is set to 1M +# then restore a few files from it. Note, by setting the maximum +# file size to 1M, it runs very slow. There are about 64 files that +# are created during each of the two backups. +# +TestName="restore-by-file-tape" +JobName=restorebyfile +. scripts/functions +set_debug 0 +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list +sed s%\^%${cwd}% ${cwd}/scripts/flist >${cwd}/tmp/restore2-list + +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +run job=$JobName level=Full yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores storage=DDS-4 file=<${cwd}/tmp/restore2-list +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +dstat=0 +# +# We need to stop and start Bacula to +# test appending to a previously written tape +# +for i in `cat ${cwd}/tmp/restore2-list`; do + diff $i ${cwd}/tmp/bacula-restores$i + if [ $? != 0 ] ; then + dstat=1 + fi +done + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +run job=$JobName level=Full yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores +7 +<${cwd}/tmp/restore2-list + +yes +wait +messages +@output +quit +END_OF_DATA + +# +# Bacula was stopped, but we must restart it to +# test appending to a previously written tape +# +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs + +scripts/check_for_zombie_jobs storage=DDS-4 +bin/bacula stop 2>&1 >/dev/null +for i in `cat ${cwd}/tmp/restore2-list`; do + diff $i ${cwd}/tmp/bacula-restores$i + if [ $? != 0 ] ; then + dstat=1 + fi +done + +end_test diff --git a/regress/regress/win32/tests/restore-by-file-test.bscr b/regress/regress/win32/tests/restore-by-file-test.bscr new file mode 100644 index 0000000000..ad4053aed4 --- /dev/null +++ b/regress/regress/win32/tests/restore-by-file-test.bscr @@ -0,0 +1,20 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores storage=File +7 +<@topdir@/tmp/restore-list + +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/restore-by-file-test.cmd b/regress/regress/win32/tests/restore-by-file-test.cmd new file mode 100644 index 0000000000..669196648a --- /dev/null +++ b/regress/regress/win32/tests/restore-by-file-test.cmd @@ -0,0 +1,30 @@ +REM +REM Run a simple backup of the Bacula build directory using the compressed option +REM then restore it. +REM + +SET TestName=restore-by-file-test +SET JobName=restorebyfile + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/tmp/build >\tmp\file-list +MKDIR tmp\build +COPY build\src\dird\*.c tmp\build >nul 2>&1 +DIR /b tmp\build >tmp\1 +sed -e "s;^;%CD:\=/%/tmp/build/;" tmp\1 >tmp\restore-list +DEL tmp\1 + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\restore-by-file-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_tmp_build_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/restore-disk-seek-test.bscr b/regress/regress/win32/tests/restore-disk-seek-test.bscr new file mode 100644 index 0000000000..a6f4ef68a6 --- /dev/null +++ b/regress/regress/win32/tests/restore-disk-seek-test.bscr @@ -0,0 +1,23 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +sql +select * from JobMedia; + +restore bootstrap=@topdir@/tmp/rbn.bsr where=@topdir@/tmp/bacula-restores storage=File +7 +<@topdir@/tmp/restore-list + +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/restore-disk-seek-test.cmd b/regress/regress/win32/tests/restore-disk-seek-test.cmd new file mode 100644 index 0000000000..6fdfdbd60f --- /dev/null +++ b/regress/regress/win32/tests/restore-disk-seek-test.cmd @@ -0,0 +1,55 @@ +REM +REM Run a backup of the full bacula build directory, but with the +REM Maximum File Size set. Then do a restore of a few files to kick in +REM disk seeking (not yet enabled), and ensure that the restored files +REM match. Even though disk seeking is not yet enabled, this is a good test, +REM and once it is enabled, this will test it. +REM +SET TestName=restore-disk-seek-test +SET JobName=restore-disk-seek + +CALL scripts\functions set_debug 1 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/tmp/build >\tmp\file-list + +IF EXIST tmp\build RD /s /q tmp\build +MKDIR tmp\build + +REM Copy only the .c files (to be restored) +REM set files to "*.c" for all c files +SET files=ua_tree.c ua_update.c +REM SET files=*.c +FOR %%i in ( %files% ) DO COPY build\src\dird\%%i tmp\build >nul 2>&1 +DIR /b tmp\build >tmp\1 +sed -e "s;^;%CD:\=/%/tmp/build/;" tmp\1 >tmp\restore-list + +REM At this point restore-list contains the list +REM of files we will restore +DEL tmp\1 + +REM Now backup *everything* +IF EXIST tmp\build RD /s /q tmp\build +MKDIR tmp\build +COPY build\src\dird\* tmp\build >nul 2>&1 +REM Enable MaximumFileSize +COPY bin\bacula-sd.conf tmp\1 >nul 2>&1 +sed "s;# Maximum File Size; Maximum File Size;" tmp\1 >bin\bacula-sd.conf + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\restore-disk-seek-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +REM Now setup a control directory of only what we *should* restore +RD /s /q tmp\build +MKDIR tmp\build +FOR %%i in ( %files% ) DO COPY build\src\dird\%%i tmp\build >nul 2>&1 + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_tmp_build_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/restore2-by-file-test.bscr b/regress/regress/win32/tests/restore2-by-file-test.bscr new file mode 100644 index 0000000000..12d2d8fd4b --- /dev/null +++ b/regress/regress/win32/tests/restore2-by-file-test.bscr @@ -0,0 +1,17 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores storage=File file=<@topdir@/tmp/restore2-list +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/restore2-by-file-test.cmd b/regress/regress/win32/tests/restore2-by-file-test.cmd new file mode 100644 index 0000000000..cba7ea35b1 --- /dev/null +++ b/regress/regress/win32/tests/restore2-by-file-test.cmd @@ -0,0 +1,31 @@ +REM +REM Run a simple backup of the Bacula build directory using the compressed option +REM then restore a few selected files. +REM +SETLOCAL ENABLEDELAYEDEXPANSION +SET TestName=restore2-by-file-test +SET JobName=restore2byfile + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list +sed -e "s;^;%CD:\=/%;" scripts/flist >tmp\restore2-list + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\restore2-by-file-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +SET dstat=0 +FOR /f %%i IN ( tmp\restore2-list ) DO ( + SET SUBDIR=%%i + diff %%i tmp/bacula-restores/!SUBDIR::=! + IF %ERRORLEVEL% NEQ 0 SET dstat=1 +) +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/runscript-test b/regress/regress/win32/tests/runscript-test new file mode 100644 index 0000000000..ef3c8b8d10 --- /dev/null +++ b/regress/regress/win32/tests/runscript-test @@ -0,0 +1,90 @@ +#!/bin/sh +# +# Test if Bacula can automatically create a Volume label. +# + +TestName="runscript-test" + +. scripts/functions +set_debug 0 +copy_test_confs + +rm -f bin/bacula-dir.conf +/bin/cp -f scripts/bacula-dir.conf.testrunscript bin/bacula-dir.conf + +echo "${cwd}/build" >${cwd}/tmp/file-list + +start_test + +cat <${cwd}/tmp/bconcmds +@output /dev/null +messages +label volume=TestVolume001 +@#setdebug level=100 storage=File +@output ${cwd}/tmp/log.RUN2.out +run job=RUN_FD_WARNING yes +wait +@sleep 5 +messages +run job=RUN_ALL_OK yes +wait +@sleep 5 +messages +run job=RUN_FD_FAILED yes +wait +@sleep 5 +messages +run job=RUN_DIR_FAILED yes +wait +@sleep 5 +messages +st dir +quit +END_OF_DATA + + +bin/bacula start +cat ${cwd}/tmp/bconcmds | bin/bconsole -c bin/bconsole.conf &> ${cwd}/tmp/log.RUN1.out + +stop_bacula + +if grep -q 'dir: BeforeJob: run command "/bin/echo RunBeforeJob"' ${cwd}/tmp/log.RUN1.out && + grep -q 'fd: ClientRunBeforeJob: ClientRunBeforeJob' ${cwd}/tmp/log.RUN1.out && + grep -q 'fd: ClientAfterJob: run command "/bin/echo ClientRunAfterJob' ${cwd}/tmp/log.RUN1.out && + grep -q 'dir: AfterJob: run command "/bin/echo RunAfterJob' ${cwd}/tmp/log.RUN1.out +then + [ "$debug" -eq 1 ] && echo RUN_ALL_OK ok +else + echo "RUN_ALL_OK in error" + rstat=1 +fi + +if grep -q 'dir: BeforeJob: run command "/bin/false RUN_DIR_FAILED"' ${cwd}/tmp/log.RUN1.out && + grep -q 'dir: BeforeJob: RunAfterFailedJob' ${cwd}/tmp/log.RUN1.out && + true # grep -q 'Backup OK -- with warnings' ${cwd}/tmp/log.RUN1.out +then + [ "$debug" -eq 1 ] && echo RUN_DIR_FAILED ok +else + echo "RUN_DIR_FAILED in error" + rstat=1 +fi + +if grep -q 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED1"' ${cwd}/tmp/log.RUN1.out && + grep -q 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_FAILED2"' ${cwd}/tmp/log.RUN1.out && + grep -q 'dir: AfterJob: run command "/bin/echo RunAfterFailedJob"' ${cwd}/tmp/log.RUN1.out +then + [ "$debug" -eq 1 ] && echo RUN_FD_FAILED ok +else + echo "RUN_FD_FAILED in error" + rstat=1 +fi + +if grep -q 'fd: ClientBeforeJob: run command "/bin/false RUN_FD_WARNING"' ${cwd}/tmp/log.RUN1.out && + grep -q 'Backup OK -- with warnings' ${cwd}/tmp/log.RUN1.out +then + [ "$debug" -eq 1 ] && echo RUN_FD_WARNING ok +else + echo "RUN_FD_WARNING in error" + rstat=1 +fi + diff --git a/regress/regress/win32/tests/scratch-pool-test.bscr b/regress/regress/win32/tests/scratch-pool-test.bscr new file mode 100644 index 0000000000..9170fb7c60 --- /dev/null +++ b/regress/regress/win32/tests/scratch-pool-test.bscr @@ -0,0 +1,25 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Scratch drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Scratch drive=0 +update Volume=TestVolume001 MaxVolBytes=2000000 pool=Scratch drive=0 +update Volume=TestVolume001 inchanger=no pool=Scratch drive=0 +@#setdebug level=200 storage=DDS-4 +llist volume=TestVolume001 +llist volume=TestVolume002 +run job=@JobName@ yes +wait +messages +list volumes +llist volume=TestVolume001 +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/scratch-pool-test.cmd b/regress/regress/win32/tests/scratch-pool-test.cmd new file mode 100644 index 0000000000..d8e88f400c --- /dev/null +++ b/regress/regress/win32/tests/scratch-pool-test.cmd @@ -0,0 +1,45 @@ +REM +REM Run a simple backup of the Bacula build directory +REM to two tapes where the maximum tape file size is set to 1M +REM Note, this test simulates the tape filling and writing to +REM the next tape. One minor wrinkle: we create the two tapes +REM in the Scratch pool, so they should be switched to the Default +REM Pool automatically. +REM We set TestVolume001 to not in the changer, so the algorithm +REM should find TestVolume002 and use it rather than blocking. +REM +REM Note we use the viritual disk autochanger +REM +SET TestName=scratch-pool-test +SET JobName=scratch-pool + +CALL scripts\functions set_debug 0 + +CALL config_out +IF "%AUTOCHANGER%" == "nul" ( + ECHO two-volume-test skipped. No autochanger. + EXIT /b 1 +) + +CALL scripts\cleanup +CALL scripts\copy-2disk-confs >nul 2>&1 +CALL scripts\prepare-two-disks + +ECHO %CD:\=/%/build >\tmp\file-list + +COPY bin\bacula-sd.conf tmp\1 >nul 2>&1 +sed -e "s;# Maximum File Size; Maximum File Size;g" tmp\1 >bin\bacula-sd.conf + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +REM Write out bconsole commands +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\scratch-pool-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=DDS-4 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/six-vol-test.bscr b/regress/regress/win32/tests/six-vol-test.bscr new file mode 100644 index 0000000000..e6698df335 --- /dev/null +++ b/regress/regress/win32/tests/six-vol-test.bscr @@ -0,0 +1,19 @@ +@output nul +messages +@@out@ tmp/log1.out +run job=@JobName@ storage=File yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/six-vol-test.cmd b/regress/regress/win32/tests/six-vol-test.cmd new file mode 100644 index 0000000000..ab3ca0559b --- /dev/null +++ b/regress/regress/win32/tests/six-vol-test.cmd @@ -0,0 +1,36 @@ +REM +REM Create a 60MB file with random bytes. Back it up to 6 Volumes +REM each constrained to 10MB using the automatic labeling feature. +REM +SET TestName=six-vol-test +SET JobName=SixVol + +CALL scripts\functions set_debug 0 + +CALL scripts\cleanup +CALL scripts\copy-testa-confs >nul 2>&1 +ECHO %CD:\=/%/tmp/largefile >\tmp\file-list + +ECHO Creating a 60MB file with bacula-dir data ... +tools\dd if=bin/bacula-dir.exe of=%CD:\=/%/tmp/1 bs=1024 count=500 >nul 2>&1 +COPY /b %CD%\tmp\1+%CD%\tmp\1+%CD%\tmp\1+%CD%\tmp\1+%CD%\tmp\1 %CD%\tmp\2 >nul 2>&1 +DEL %CD%\tmp\1 +COPY /b %CD%\tmp\2+%CD%\tmp\2 %CD%\tmp\3 >nul 2>&1 +DEL %CD%\tmp\2 +COPY /b %CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3 %CD%\tmp\4 >nul 2>&1 +COPY /b %CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\3+%CD%\tmp\4 %CD%\tmp\largefile >nul 2>&1 +DEL %CD%\tmp\3 %CD%\tmp\4 + +CALL scripts\functions change_jobname MultiVol %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\six-vol-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +diff tmp\largefile tmp\bacula-restores\%CD::=%\tmp\largefile >nul 2>&1 +SET dstat=%ERRORLEVEL% +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/small-file-size-tape b/regress/regress/win32/tests/small-file-size-tape new file mode 100644 index 0000000000..14516b3bbb --- /dev/null +++ b/regress/regress/win32/tests/small-file-size-tape @@ -0,0 +1,50 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape where the maximum tape file size is set to 1M +# +TestName="small-file-size-tape" +JobName=smallfilesize +. scripts/functions +set_debug 0 + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list +cp ${cwd}/bin/bacula-sd.conf ${cwd}/tmp/1 +sed "s%# Maximum File Size% Maximum File Size%" ${cwd}/tmp/1 >${cwd}/bin/bacula-sd.conf + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +setdebug level=2 storage=DDS-4 +run job=$JobName yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=DDS-4 +unmark * +mark * +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/span-vol-test.bscr b/regress/regress/win32/tests/span-vol-test.bscr new file mode 100644 index 0000000000..6ec7c37eae --- /dev/null +++ b/regress/regress/win32/tests/span-vol-test.bscr @@ -0,0 +1,27 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File1 volume=TestVolume004 +label storage=File1 volume=TestVolume003 +label storage=File1 volume=TestVolume002 +label storage=File1 volume=TestVolume001 +update Volume=TestVolume004 MaxVolBytes=3000000 +update Volume=TestVolume003 MaxVolBytes=3000000 +update Volume=TestVolume002 MaxVolBytes=3000000 +run job=@JobName@ storage=File1 yes +wait +list volumes +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File1 +unmark * +mark * +done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/span-vol-test.cmd b/regress/regress/win32/tests/span-vol-test.cmd new file mode 100644 index 0000000000..52cbaffb77 --- /dev/null +++ b/regress/regress/win32/tests/span-vol-test.cmd @@ -0,0 +1,26 @@ +REM +REM Run a simple backup of the Bacula build directory but +REM split the archive into four volumes, two of which are +REM totally full. I.e. make sure that bsr selects all tapes +REM including those fully spanned. +REM +SET TestName=span-vol-test +SET JobName=SpanVol + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\span-vol-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/sparse-compressed-test.bscr b/regress/regress/win32/tests/sparse-compressed-test.bscr new file mode 100644 index 0000000000..e4d1040296 --- /dev/null +++ b/regress/regress/win32/tests/sparse-compressed-test.bscr @@ -0,0 +1,17 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=SparseCompressedTest yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select all storage=File done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/sparse-compressed-test.cmd b/regress/regress/win32/tests/sparse-compressed-test.cmd new file mode 100644 index 0000000000..e8b701dcf1 --- /dev/null +++ b/regress/regress/win32/tests/sparse-compressed-test.cmd @@ -0,0 +1,23 @@ +REM +REM Run a simple backup of the Bacula build directory using the Sparse option +REM then restore it. +REM +SET TestName=sparse-compressed-test +SET JobName=Sparse-conpressed + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\sparse-compressed-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/sparse-test.bscr b/regress/regress/win32/tests/sparse-test.bscr new file mode 100644 index 0000000000..b7438e9dfb --- /dev/null +++ b/regress/regress/win32/tests/sparse-test.bscr @@ -0,0 +1,20 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/sparse-test.cmd b/regress/regress/win32/tests/sparse-test.cmd new file mode 100644 index 0000000000..a8ba5d1680 --- /dev/null +++ b/regress/regress/win32/tests/sparse-test.cmd @@ -0,0 +1,23 @@ +REM +REM Run a simple backup of the Bacula build directory using the Sparse option +REM then restore it. +REM +SET TestName=sparse-test +SET JobName=SparseTest + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\sparse-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/test0.cmd b/regress/regress/win32/tests/test0.cmd new file mode 100644 index 0000000000..e1824b12b7 --- /dev/null +++ b/regress/regress/win32/tests/test0.cmd @@ -0,0 +1,2 @@ +COPY nul test.out >nul 2>&1 +DEL bin\working\* 2>&1 diff --git a/regress/regress/win32/tests/truncate-bug-tape b/regress/regress/win32/tests/truncate-bug-tape new file mode 100644 index 0000000000..1b47d9e137 --- /dev/null +++ b/regress/regress/win32/tests/truncate-bug-tape @@ -0,0 +1,87 @@ +#!/bin/sh +# +# Test for a tape truncation bug. +# +TestName="truncate-bug-tape" +JobName=truncatebug +. scripts/functions + +set_debug 0 +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default +@# do a bunch of saves so we have 12 files on the tape +run job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +run level=Full job=$JobName yes +@#setdebug level=100 storage=DDS-4 +wait +messages +quit +END_OF_DATA + +run_bacula +scripts/check_for_zombie_jobs storage=DDS-4 + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log2.out +@# +@# now do a restore +@# +restore where=${cwd}/tmp/bacula-restores storage=DDS-4 +3 +@# select JobId=4 (i.e. file five on the tape) +4 +cd ${cwd}/build +@# mark a single file +mark configure +done +yes +wait +messages +@output +quit +END_OF_DATA + +run_bconsole +scripts/check_for_zombie_jobs storage=DDS-4 + +# Now write to tape one more time +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log3.out +run level=Full job=$JobName yes +wait +messages +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +grep "^ Termination: *Backup OK" tmp/log3.out 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/win32/tests/two-jobs-test.1.bscr b/regress/regress/win32/tests/two-jobs-test.1.bscr new file mode 100644 index 0000000000..745a2e1011 --- /dev/null +++ b/regress/regress/win32/tests/two-jobs-test.1.bscr @@ -0,0 +1,14 @@ +setdebug level=15 storage=File +@output nul +messages +@output nul +estimate job=@JobName@ listing +estimate job=@JobName@ listing +estimate job=@JobName@ listing +messages +@@out@ tmp/log1.out +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/two-jobs-test.2.bscr b/regress/regress/win32/tests/two-jobs-test.2.bscr new file mode 100644 index 0000000000..144ac5f997 --- /dev/null +++ b/regress/regress/win32/tests/two-jobs-test.2.bscr @@ -0,0 +1,27 @@ +@output nul +messages +@@out@ tmp/log1.out +run job=@JobName@ +yes +wait +messages +@# +@# now do several restores to ensure we cleanup between jobs +@# +@output nul +restore where=@topdir@/tmp/bacula-restores select all storage=File done +yes +wait +restore where=@topdir@/tmp/bacula-restores select all storage=File done +yes +wait +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@output +quit diff --git a/regress/regress/win32/tests/two-jobs-test.cmd b/regress/regress/win32/tests/two-jobs-test.cmd new file mode 100644 index 0000000000..3964e90d16 --- /dev/null +++ b/regress/regress/win32/tests/two-jobs-test.cmd @@ -0,0 +1,35 @@ +REM +REM Run a simple backup of the Bacula build directory using the compressed option +REM then backup a second time and finally restore it +REM +SET TestName=two-jobs-test +SET JobName=Two-Jobs + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname CompressedTest %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\two-jobs-test.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File + +ECHO Backup 1 done +tools\touch build\src\dird\*.c + +REM +REM run a second job +REM +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\two-jobs-test.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bconsole +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/two-pool-tape b/regress/regress/win32/tests/two-pool-tape new file mode 100644 index 0000000000..18fba8b087 --- /dev/null +++ b/regress/regress/win32/tests/two-pool-tape @@ -0,0 +1,82 @@ +#!/bin/sh +# +# This is Arno's test. It uses two pools, two tapes, and +# an autochanger. Note, the Director has three Pools in its +# conf: Default, Full, and Inc. Default is used in the +# NightlySave job by default. What is backed up is what +# is in ${cwd}/tmp/file-list, which is by default the Bacula +# source code (i.e. the build directory). +# +TestName="two-pool-tape" +JobName=twopooltape +. scripts/functions +set_debug 0 + +. config.out +if test x${AUTOCHANGER} = x/dev/null ; then + echo "two-pool-tape test skipped. No autochanger." + exit +fi + +scripts/cleanup +scripts/copy-2tape-confs +echo "Prepare two tapes" +scripts/prepare-two-tapes +echo "Done prepare two tapes" + +# Make a relatively large backup set 5 x source code directory +echo "${cwd}/build" >${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list +echo "${cwd}/build" >>${cwd}/tmp/file-list + +start_test + +# Write out bconsole commands to a file +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Full drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +list volumes +@# Start job with Client run before and sleep +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +@# wait between starting jobs +@sleep 60 +@#setdebug level=100 storage=DDS-4 +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +@sleep 10 +messages +@sleep 10 +messages +@sleep 10 +status storage=DDS-4 +messages +wait +list volumes +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +check_restore_diff +end_test diff --git a/regress/regress/win32/tests/two-pool-test.bscr b/regress/regress/win32/tests/two-pool-test.bscr new file mode 100644 index 0000000000..57b3903e6a --- /dev/null +++ b/regress/regress/win32/tests/two-pool-test.bscr @@ -0,0 +1,36 @@ +@output nul +messages +@@out@ tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Full drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +list volumes +@# Start job with Client run before and sleep +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +run job=NightlySave1 level=Full pool=Default yes +@# wait between starting jobs +@sleep 60 +@#setdebug level=100 storage=DDS-4 +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +run job=NightlySave2 level=Full pool=Full yes +@sleep 10 +messages +@sleep 10 +messages +@sleep 10 +status storage=DDS-4 +messages +wait +list volumes +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/two-pool-test.cmd b/regress/regress/win32/tests/two-pool-test.cmd new file mode 100644 index 0000000000..2bf0028546 --- /dev/null +++ b/regress/regress/win32/tests/two-pool-test.cmd @@ -0,0 +1,37 @@ +REM +REM This is Arno's test. It uses two pools, two tapes, and +REM an autochanger. Note, the Director has three Pools in its +REM conf: Default, Full, and Inc. Default is used in the +REM NightlySave job by default. What is backed up is what +REM is in ${cwd}/tmp/file-list, which is by default the Bacula +REM source code (i.e. the build directory). +REM +REM Note, we use the virtual disk autochanger. +REM +SET TestName=two-pool-test +SET JobName=Two-pool + +CALL scripts\functions set_debug 0 + +CALL config_out + +CALL scripts\cleanup +CALL scripts\copy-2disk-confs >nul 2>&1 +CALL scripts\prepare-two-disks + +REM Make a relatively large backup set 5 x source code directory +REM Reduced to 1 for portable +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions start_test + +REM Write out bconsole commands to a file +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\two-pool-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=DDS-4 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/two-vol-test.bscr b/regress/regress/win32/tests/two-vol-test.bscr new file mode 100644 index 0000000000..8de06c5d64 --- /dev/null +++ b/regress/regress/win32/tests/two-vol-test.bscr @@ -0,0 +1,19 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=File1 volume=TestVolume002 +label storage=File1 volume=TestVolume001 +update Volume=TestVolume002 MaxVolBytes=3000000 +run job=@JobName@ storage=File1 yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select all storage=File1 done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/two-vol-test.cmd b/regress/regress/win32/tests/two-vol-test.cmd new file mode 100644 index 0000000000..ce59794572 --- /dev/null +++ b/regress/regress/win32/tests/two-vol-test.cmd @@ -0,0 +1,24 @@ +REM +REM Run a simple backup of the Bacula build directory but +REM split the archive into two volumes +REM +SET TestName=two-vol-test +SET JobName=TwoVol + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\two-vol-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=File1 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/two-volume-tape.1.bscr b/regress/regress/win32/tests/two-volume-tape.1.bscr new file mode 100644 index 0000000000..30ebdf96bf --- /dev/null +++ b/regress/regress/win32/tests/two-volume-tape.1.bscr @@ -0,0 +1,11 @@ +@@out@ nul +messages +@@out@ @topdir@/tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +update Volume=TestVolume001 MaxVolBytes=3000000 pool=Default drive=0 +@#setdebug level=1000 client +run job=@JobName@ yes +wait +messages +quit diff --git a/regress/regress/win32/tests/two-volume-tape.2.bscr b/regress/regress/win32/tests/two-volume-tape.2.bscr new file mode 100644 index 0000000000..6af471c6b7 --- /dev/null +++ b/regress/regress/win32/tests/two-volume-tape.2.bscr @@ -0,0 +1,12 @@ +@@out@ nul +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/two-volume-tape.cmd b/regress/regress/win32/tests/two-volume-tape.cmd new file mode 100644 index 0000000000..62e80ecaa9 --- /dev/null +++ b/regress/regress/win32/tests/two-volume-tape.cmd @@ -0,0 +1,48 @@ +REM +REM Run a simple backup of the Bacula build directory +REM to two tapes where the maximum tape file size is set to 1M +REM Note, this test simulates the tape filling and writing to +REM the next tape. +REM +SET TestName=two-volume-tape +SET JobName=twovoltape +CALL scripts\functions set_debug 0 + +CALL config_out +IF "%AUTOCHANGER%" == "nul" ( + ECHO two-volume-tape test skipped. No autochanger. + EXIT /b 1 +) + +CALL scripts\cleanup +CALL scripts\copy-2tape-confs +CALL scripts\prepare-two-tapes + +ECHO %CD:\=/%/build >\tmp\file-list + +COPY bin\bacula-sd.conf tmp\1 +sed -e "s%# Maximum File Size% Maximum File Size%g" >bin\bacula-sd.conf + +CALL scripts\functions change_jobname %JobName% +CALL scripts\functions start_test + +REM Write out bconsole commands +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\two-volume-tape.1.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=DDS-4 +CALL scripts\functions stop_bacula + +mt -f %TAPE_DRIVE% rewind +mtx -f %AUTOCHANGER% unload +bin\bsleep 15 + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\two-volume-tape.2.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=DDS-4 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/two-volume-test.bscr b/regress/regress/win32/tests/two-volume-test.bscr new file mode 100644 index 0000000000..bd08ef35e1 --- /dev/null +++ b/regress/regress/win32/tests/two-volume-test.bscr @@ -0,0 +1,21 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=1 pool=Default drive=0 +label storage=DDS-4 volume=TestVolume002 slot=2 pool=Default drive=0 +update Volume=TestVolume001 MaxVolBytes=3000000 pool=Default drive=0 +@#setdebug level=1000 client +run job=@JobName@ yes +wait +messages +@# +@# now do a restore +@# +@@out@ tmp/log2.out +restore where=@topdir@/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +@@out@ +quit + diff --git a/regress/regress/win32/tests/two-volume-test.cmd b/regress/regress/win32/tests/two-volume-test.cmd new file mode 100644 index 0000000000..9bfe9c88da --- /dev/null +++ b/regress/regress/win32/tests/two-volume-test.cmd @@ -0,0 +1,35 @@ +REM +REM Run a simple backup of the Bacula build directory +REM to two tapes where the maximum tape file size is set to 1M +REM Note, this test simulates the tape filling and writing to +REM the next tape. +REM +REM Note we use the viritual disk autochanger +REM +SET TestName=two-volume-test +SET JobName=TwoVolume +CALL scripts\functions set_debug 1 +CALL config_out + +CALL scripts\cleanup +CALL scripts\copy-2disk-confs >nul 2>&1 +CALL scripts\prepare-two-disks + +ECHO %CD:\=/%/build >\tmp\file-list + +COPY bin\bacula-sd.conf tmp\1 +sed -e "s;# Maximum File Size; Maximum File Size;g" tmp\1 >bin\bacula-sd.conf + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +REM Write out bconsole commands +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\two-volume-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula +CALL scripts\functions check_for_zombie_jobs storage=DDS-4 +CALL scripts\functions stop_bacula + +CALL scripts\functions check_two_logs +CALL scripts\functions check_restore_diff +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/usr-tape-root b/regress/regress/win32/tests/usr-tape-root new file mode 100644 index 0000000000..d888ca2324 --- /dev/null +++ b/regress/regress/win32/tests/usr-tape-root @@ -0,0 +1,62 @@ +#!/bin/sh +# +# Run a simple backup of the /usr directory +# then restore it. +# +cwd=`pwd` +scripts/copy-tape-confs +scripts/cleanup-tape +echo "/usr" >${cwd}/tmp/file-list + +echo " " +echo " " +echo " === Starting usr-tape-root test ===" +echo " " +echo " " + +bin/bacula start 2>&1 >/dev/null +bin/bconsole -c bin/bconsole.conf <&1 >/dev/null +cd / +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/original +cd ${cwd}/tmp/bacula-restores +${cwd}/bin/testls -e ${cwd}/scripts/exclude-usr-test lib >${cwd}/tmp/restored +cd ${cwd}/tmp +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% original >1 +sort <1 >original +# +sed s%.*lib/kbd/consolefonts$%lib/kbd/consolefonts% restored >1 +sort <1 >restored +rm -f 1 +# +cd ${cwd} +diff tmp/original tmp/restored 2>&1 1>/dev/nul +if [ $? != 0 ] ; then + echo " " + echo " " + echo " ===== !!!! usr-tape-root failed !!!! ===== " + echo " ===== !!!! usr-tape-root failed !!!! ===== " >>test.out + echo " " +else + echo " ===== usr-tape-root OK ===== " + echo " ===== usr-tape-root OK ===== " >>test.out + scripts/cleanup +fi diff --git a/regress/regress/win32/tests/verify-vol-tape b/regress/regress/win32/tests/verify-vol-tape new file mode 100644 index 0000000000..b9f5a24b0a --- /dev/null +++ b/regress/regress/win32/tests/verify-vol-tape @@ -0,0 +1,50 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then verify the catalog. +# +TestName="verify-vol-tape" +JobName=VerifyVol +. scripts/functions +set_debug 0 + +copy_tape_confs + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +setdebug level=1 storage=DDS-4 sd +label storage=DDS-4 volume=TestVolume001 pool=Default +run job=$JobName yes +wait +messages +@# +@# now do a verify volume +@# +@$out ${cwd}/tmp/original +run job=VerifyTape pool=Default +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula + +sleep 2 +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +grep "^ Termination: *Backup OK" tmp/log1.out 2>&1 >/dev/null +bstat=$? +grep "^ Termination: *Verify OK" ${cwd}/tmp/original 2>&1 >/dev/null +rstat=$? +dstat=0 +end_test diff --git a/regress/regress/win32/tests/verify-vol-test.bscr b/regress/regress/win32/tests/verify-vol-test.bscr new file mode 100644 index 0000000000..8c73bbc59f --- /dev/null +++ b/regress/regress/win32/tests/verify-vol-test.bscr @@ -0,0 +1,18 @@ +@@out@ nul +messages +@@out@ tmp/log1.out +setdebug level=1 storage=File sd +label storage=File volume=TestVolume001 +run job=@JobName@ yes +wait +messages +@# +@# now do a verify volume +@# +@@out@ @topdir@/tmp/original +run job=VerifyVolume +yes +wait +messages +@@out@ +quit diff --git a/regress/regress/win32/tests/verify-vol-test.cmd b/regress/regress/win32/tests/verify-vol-test.cmd new file mode 100644 index 0000000000..377fb3428f --- /dev/null +++ b/regress/regress/win32/tests/verify-vol-test.cmd @@ -0,0 +1,29 @@ +REM +REM Run a simple backup of the Bacula build directory +REM then verify the catalog. +REM +SET TestName=verify-vol-test +SET JobName=VerifyVol + +CALL scripts\functions set_debug 0 +CALL scripts\functions copy_test_confs + +ECHO %CD:\=/%/build >\tmp\file-list + +CALL scripts\functions change_jobname NightlySave %JobName% +CALL scripts\functions start_test + +sed -e "s;@JobName@;%JobName%;g" -e "s;@out@;%out%;g" -e "s;@topdir@;%CD:\=/%;g" tests\verify-vol-test.bscr >tmp\bconcmds + +CALL scripts\functions run_bacula + +bin\bsleep 2 +CALL scripts\functions check_for_zombie_jobs storage=File +CALL scripts\functions stop_bacula + +grep "^ Termination: *Backup OK" tmp\log1.out 2>&1 >nul +SET bstat=%ERRORLEVEL% +grep "^ Termination: *Verify OK" tmp\original 2>&1 >nul +SET rstat=%ERRORLEVEL% +SET dstat=0 +CALL scripts\functions end_test diff --git a/regress/regress/win32/tests/weird-files-test b/regress/regress/win32/tests/weird-files-test new file mode 100644 index 0000000000..7a6cff9ea4 --- /dev/null +++ b/regress/regress/win32/tests/weird-files-test @@ -0,0 +1,69 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="weird-files-test" +JobName=wierd-files +. scripts/functions +set_debug 0 + +if test ! -d weird-files ; then + echo " " + echo "Weird files not configured. Test not run." + exit 0 +fi + +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +change_jobname NightlySave $JobName +# +# Note, we save the weird-files directory twice on purpose +# because this causes problems with hard linked files +# that are only saved once. In 1.33, Bacula now deals +# with this situation. +# +echo "${cwd}/weird-files" >${cwd}/tmp/file-list +echo "${cwd}/weird-files" >>${cwd}/tmp/file-list + +start_test + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=File +TestVolume001 +run job=$JobName +yes +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select storage=File +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +stop_bacula + +${cwd}/bin/testls weird-files | sort >${cwd}/tmp/original +cd tmp/bacula-restores${cwd} +${cwd}/bin/testls weird-files | sort >${cwd}/tmp/restored +cd ${cwd} + +check_two_logs +diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 >/dev/null +dstat=$? +end_test diff --git a/regress/regress/win32/tests/weird-files2-test b/regress/regress/win32/tests/weird-files2-test new file mode 100644 index 0000000000..56495ee98e --- /dev/null +++ b/regress/regress/win32/tests/weird-files2-test @@ -0,0 +1,80 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# then restore it. +# +TestName="weird-files2-test" +JobName=weird-files2 +. scripts/functions +set_debug 0 + +if test ! -d weird-files ; then + echo " " + echo "weird files not configured. Test not run." + exit 0 +fi +cwd=`pwd` +scripts/cleanup +scripts/copy-test-confs +rm -rf weird-files2 +cp -Rp weird-files weird-files2 +echo "${cwd}/weird-files2" >${cwd}/tmp/file-list + +change_jobname NightlySave $JobName +start_test + +bin/testls weird-files2 >${cwd}/tmp/original + +cat <tmp/bconcmds +@$out /dev/null +messages +@$out tmp/log1.out +label storage=File volume=TestVolume001 +run job=$JobName yes +wait +messages +@$out +quit +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=File +# +# Now mess up the a hard link, and a soft link +# +cd weird-files2 +rm -f hard-file2 +ln hard-file3 hard-file2 +rm -f soft-file2 +ln -s soft-file3 soft-file2 +cd ${cwd} +cat <tmp/bconcmds +@$out /dev/null +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where= storage=File +5 +unmark * +mark * +done +yes +wait +messages +@$out +quit +END_OF_DATA + +run_bconsole +check_for_zombie_jobs storage=File +stop_bacula + +bin/testls weird-files2 >${cwd}/tmp/restored + +check_two_logs +diff ${cwd}/tmp/original ${cwd}/tmp/restored 2>&1 >/dev/null +dstat=$? + +end_test diff --git a/regress/regress/win32/tests/win32-backup-tape b/regress/regress/win32/tests/win32-backup-tape new file mode 100644 index 0000000000..55d780e82e --- /dev/null +++ b/regress/regress/win32/tests/win32-backup-tape @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# +TestName="win32-backup-tape" +JobName=win32tape +. scripts/functions +set_debug 0 + +scripts/copy-win32-confs +scripts/cleanup-tape + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_jobname $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default drive=0 +run job=$JobName yes +@sleep 10 +status storage=DDS-4 +@sleep 30 +messages +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores select all storage=DDS-4 done +yes +wait +messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +# no diff for now +dstat=0 +end_test diff --git a/regress/regress/win32/tests/win32-to-linux-tape b/regress/regress/win32/tests/win32-to-linux-tape new file mode 100644 index 0000000000..751ec733f1 --- /dev/null +++ b/regress/regress/win32/tests/win32-to-linux-tape @@ -0,0 +1,49 @@ +#!/bin/sh +# +# Run a simple backup of the Bacula build directory +# to a tape then restore it, we do that twice to ensure that +# we can correctly append to a tape. +# +TestName="win32-to-linux-tape" +JobName=AutoLabel +. scripts/functions +set_debug 1 + +scripts/copy-win32-confs +scripts/cleanup-tape + +echo "${cwd}/build" >${cwd}/tmp/file-list + +change_job $JobName +start_test + +cat <tmp/bconcmds +@output /dev/null +messages +@$out tmp/log1.out +label storage=DDS-4 volume=TestVolume001 slot=0 pool=Default drive=0 +run job=NightlySave yes +@sleep 10 +status storage=DDS-4 +@sleep 30 +messages +wait +messages +@# +@# now do a restore +@# +@$out tmp/log2.out +restore where=${cwd}/tmp/bacula-restores client=Tibs select all storage=DDS-4 done +yes +wait +messages +END_OF_DATA + +run_bacula +check_for_zombie_jobs storage=DDS-4 +stop_bacula + +check_two_logs +# No diff for the moment +dstat=0 +end_test