I prefer incron, as its easier to manage. Essentially it's a service that leverages inotify and you can setup configurations to take action based on file change operations.

Ex:

<directory> <file change mask> <command or action>  options

/var/www/html IN_CREATE /root/scripts/backup.sh

You can see a full example here:
http://www.cyberciti.biz/faq/linux-inotify-examples-to-replicate-directories/

I just cooked up this, and see no huge problems with it, other than a tiny chance of missing files in between checks.

while true

do

       touch  ./lastwatch

       sleep 10

       find /YOUR/WATCH/PATH -cnewer ./lastwatch -exec SOMECOMMAND {} ;

done

If your file processing doesn't take too long, you should not miss any new file. You could also background the activities...
It's not bullet proof, but it serves some purposes without external tools like inotify.

I am assuming the target folder (I'll call it isempty just for convenience) is empty and you are waiting for one or more files to be dropped there.

You can use the following command:

ls -1A isempty | wc -l

just to check if the folder is still empty, in fact it will return a 0 if there is no new file (hence the isempty folder is still empty) or, on the other hand, it will return a value greater than 0 (actually the number of files currently in the folder).

That said a silly if/then test can make the rest of the work:

if [ $(ls -1A isempty | wc -l) -gt 0 ] ; then do_something ; fi

Of course the do_something function will have to manipulate the file(s) within the isempty folder and then remove it(them) from the folder itself after processing.

Adding a line like the following in your crontab will run the check once a minute and will trigger the do_something action if the folder is not empty of course:

* * * * *     if [ $(ls -1A isempty | wc -l) -gt 0 ] ; then do_something ; fi

You can use watch in your script

watch -n 0.1 ls <your_folder>

Monitors your folder and lists you everything in it every 0.1 seconds

Drawback

Is not real time, so if a file was created and deleted in less than 0.1 second, then this would not work, watch only supports minimum of 0.1 seconds.

If you want to detect new files, then process them and at the end delete proceeded files you can use systemd.path. This method bases on inotify. There is an option DirectoryNotEmpty, so systemd can run your script always when it detects any files in directory. You have to remember it will work only if you can delete proceeded files and script leaves directory empty.

First prepare mymonitor.service file

[Unit]

Description=Start the script



[Service]

Type=oneshot

ExecStart=/path/to/your/script

next go to mymonitor.path to define the path

[Unit]

Description= Triggers the service



[Path]

DirectoryNotEmpty=/path/to/monitor



[Install]

WantedBy=multi-user.target

If the name of the .path file is the same as the name of the service there is no need to specify the service name in .path file.

It bases on Monitoring File Access for Dummies

Bash cannot do this easily. You'd have to basically get a list of all the files in the folder and periodically get a new list and compare them to see whats changed.

What you're looking for is called inotify. Its built into the linux kernel and you can basically sit there waiting for something to happen at which point inotify comes back and says 'hey, theres a new file called foobar'

To accomplish what you want you'd have to switch to something like perl and use Linux::Inotify2 (python probably supports inotify as well, but I'm a perl person).

entr

Using entr is the new way to do this (it's cross platform). Note entr doesn't use polling giving it a huge advantage over many of the alternatives.

Uses kqueue(2) or inotify(7) to avoid polling. entr was written to make rapid feedback and automated testing natural and completely ordinary.

On BSD it uses pledge(2)

You can install it with

apt-get install entr

dnf install entr

You can track a directory for new additions using

while $(true); do

  # echo ./my_watch_dir | entr -dnr echo "Running trigger..."

  echo ./my_watch_dir | entr -dnr ##MY COMMAND##

done;

Options explained (from the docs),

• 
  -d Track the directories of regular files provided as input and exit if a new file is added. This option also enables directories to be specified explicitly. Files with names beginning with ‘.’ are ignored.


• 
  -n Run in non-interactive mode. In this mode entr does not attempt to read from the TTY or change its properties.


• 
  -r Reload a persistent child process. As with the standard mode of operation, a utility which terminates is not executed again until a file system or keyboard event is processed. SIGTERM is used to terminate the utility before it is restarted. A process group is created to prevent shell scripts from masking signals. entr waits for the utility to exit to ensure that resources such as sockets have been closed. Control of the TTY is not transferred the child process.

This works in cygwin and Linux. Some of the previous solutions which write a file will cause the disk to thrash. This scipt does not have that problem:

SIG=1

SIG0=$SIG

while [ $SIG != 0 ] ; do

 while [ $SIG = $SIG0 ] ; do

   SIG=`ls -1 | md5sum | cut -c1-32`

   sleep 10

 done

 SIG0=$SIG

 ls -lrt | tail -n 1

done

Below is an abridged version of example on stackoverflow that I've tested and incorporated into one of my projects that requires monitoring of specific directories.

Var_dir="${1:-/tmp}"

Var_diff_sleep="${2:-120}"

Var_diff_opts="--suppress-common-lines"

Func_parse_diff(){

    _added="$(grep -E '>' <<<"${@}")"

    if [ "${#_added}" != "0" ]; then

        mapfile -t _added_list <<<"${_added//> /}"

        _let _index=0

        until [ "${#_added_list[@]}" = "${_index}" ]; do

            _path_to_check="${Var_dir}/${_added_list[${_index}]}"

            if [ -f "${_path_to_check}" ]; then

                echo "# File: ${_path_to_check}"

            elif [ -d "${_path_to_check}" ]; then

                echo "# Directory: ${_path_to_check}"

            if [ -p "${_path_to_check}" ]; then

                echo "# Pipe: ${_path_to_check}"

            fi

            let _index++

        done

        unset _index

    fi

}

Func_watch_bulk_dir(){

    _current_listing=""

    while [ -d "${Var_dir}" ]; do

        _new_listing="$(ls "${Var_dir}")"

        _diff_listing="$(diff ${Var_dec_diff_opts} <(${Var_echo} "${_current_listing}") <(${Var_echo} "${_new_listing}"))"

        if [ "${_diff_listing}" != "0" ]; then

            Func_parse_diff "${_diff_listing}"

        fi

        _current_listing="${_new_listing}"

        sleep ${Var_diff_sleep}

    done

}

Here's a link to a script that uses a modified version of above to automatically decrypt files or directories found in its sshfs mount point; the afore mentioned project.