If this is any help: you have my pity. ;-))


OK, but in this case error reporting is a MUST. Suppose there are some 1000 files to move. As the script works on the 457th of them something goes wrong. How would you find out? And how would you correct that? Or, another scenario, the 457th of them and any following fails (because, say, the disk being full). How are you going to correct that?

As a general advice: it doesn't matter that an automated procedure fails from time to time, but it should do so with a traceable, intelligible error message. Compare could not move /source/fileA to /target/B because disk is full. Aborting... to error in line 153. Exit. and ask yourself which supports prospective error correction attempts better.

If you do not want to program complex reporting features into your program you might want to sit and watch it run so that you can react immediately.

My sketch of a script attempts that (see commented version below). I was under the impression that every filename can only be there once per run of the script, therefore only provisions for one additional copy per run are in place. It should be trivial to add additional code to cover for that.


My script expects a file "/path/to/list.of.filemasks" (see last line) to contain search criteria, one per line. An asterisk is prepended and appended to every criteria to create a wildcard expression A possible content would look like:

Code:

foo.jpg
bar.gif
baz

which would process all filea "*foo.jpg*", then "*bar.gif*", then "*baz*", etc..

As said above, yes.

First, you copy it and save it as a simple text file. The name and extension does not matter, take whatever you like. I suggest you explicitly state that a certain shell is to execute it, therefore add such a line as the first line:

Code:

#! /path/to/some/shell

If you do not know which shell to use: issue "echo $SHELL" at the command line and take its output. Here is an example of one of my systems, yours might look different:

Code:

$ echo $SHELL
/usr/bin/ksh

$ cat template.ksh 
#! /usr/bin/ksh
# ----------------------------------------------------------------------
# template.ksh                               template for ksh scripts/functions
# ----------------------------------------------------------------------
...

Notice that everything after "#" is treated as a comment, but the first line (also called "shebang") has to be exactly as it is. I.e. inserting a space before "#!" would make it stop to work.

Now you need to make this file executable: execute

Code:

chmod 754 /your/filename

This sets read, write and execute rights for you (7), read and execute for members of your group (5) and read only for all other users (4). After this you can execute the file. Notice, though, that the current directory is NOT automatically in the path, unlike in Windoze. To execute a file in your current directory issue "./filename", not "filename".

Here is a commented version of my script, i have put echo-statements in place of the processing parts, so that you can try it out and see the inner workings:

Code:

while read FILEMASK ; do
     echo $FILEMASK
done < /path/to/list.of.filemasks

Read the file /path/to/list.of.filemasks and put each lines content into variable FILEMASK.

Code:

while read FILEMASK ; do
     find /path/to/sourcedir -type f -name "*${FILEMASK}*" |\
          while read MOVEFILE ; do
               echo $MOVEFILE
          done
done < /path/to/list.of.filemasks

"find" searches a complete directory hierarchy and produces a list of filenames. As you see it filters for "*FILEMASK*". This is where the content of your list of filemasks comes into play. Every filename found this way is fed to another while-loop and read into a variable "MOVEFILE". The content of this might be "/path/to/sourcedir/sub1/foo.FILEMASK.bar". If the wildcard delivers false positives then tinker withe the argument to "-name". Instead of "*${FILEMASK}*" you might want to try "*${FILEMASK}" (this will find "foo.FILEMASK" but not "FILEMASK.bar"), etc..

Code:

while read FILEMASK ; do
     find /path/to/sourcedir -type f -name "*${FILEMASK}*" |\
          while read MOVEFILE ; do
               echo "BEFORE: $MOVEFILE"
               FNAME="${MOVEFILE##*/}"
               echo "AFTER: $FNAME"
          done
done < /path/to/list.of.filemasks

This part just strips all the path information from the filename and assigns the stripped part to a variable "FNAME", like this:

MOVEFILE: "/path/to/sourcedir/sub1/some.FILEMASK.bla"
FNAME: "some.FILEMASK.bla"

Code:

               if [ -f "/path/to/targetdir/$FNAME" ] ; then
                    mv "$MOVEFILE" "/path/to/targetdir/${FNAME}.$$"
               else
                    mv "$MOVEFILE" "/path/to/targetdir"
               fi

This innermost part checks if the filename already exists at the prospective target place. If yes, the file is moved to a name with the current process-number ("$$") appended, else (if no such target exists), the original name is used.

To cover for multiple instances replace this part with the following:

Code:

               if [ -f "/path/to/targetdir/$FNAME" ] ; then
                    (( IDX = 1 ))
                    while [ -f "/path/to/targetdir/${FNAME}.${IDX}" ] ; do
                         (( IDX += 1 ))
                    done
                    mv "$MOVEFILE" "/path/to/targetdir/${FNAME}.${IDX}"
               else
                    mv "$MOVEFILE" "/path/to/targetdir"
               fi

If a file doesn't exist it is simply copied (the else-part). If such a file already exists, a counter is initialized with "1" and incremented each time such a file was found. The "while [ -f ...]" tests for "file.1", then "file.2", etc., until it finds a name that is not taken already. This is then used to move the file.

I hope this helps.

bakunin