use Fcntl ':flock';
my $file = 'file.lck';
open my $lfh, ">>$file" or die "Can't access $file : $!\n";
if (flock $lfh, LOCK_EX){
  sleep 1 while (time - (stat $file)[9] < 1);
  #
  # Send your Amazon requests here
  #
  utime time, time, $file;
}else{
  print "Can't lock $file: $!";
}
close $lfh;
[download]

That's what I was looking for. I didn't even consider locking a file. Thanks for the help perlplexer.

With that in mind, it may be worth your looking at merlyn's Highlander - allow only one invocation at a time of an expensive CGI script which allows only a single simultaneous invocation of a CGI script. If you combine this with a sleep function within your script such that execution time is greater than a second, this will effectively achieve your goal.

 

perl -e 'print+unpack("N",pack("B32","00000000000000000000000111101100")),"\n"'

use LWP::Simple;
use Time::HiRes qw( time sleep );
while (1) {
    my $time = time;
    print "Time is $time\n";
    # the get will generally take > 1 sec but comment out to demo time
+ loop
    # get('http://foo.com');
    sleep 0.001 while time < $time + 1;
}
__DATA__
Time is 1038429003.031
Time is 1038429004.031
Time is 1038429005.031
Time is 1038429006.031
[download]

Alternatively without Time::HiRes or any accuracy....

use LWP::Simple;
while (1) {
    get('http://foo.com');
    sleep 1;
}
[download]

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

Makeshifts last the longest.

IPC::Shareable and IPC::ShareLite looks like a possibility.

An example of what I meant in the first post is as follows. Take two users. Both of whom click on a link that gets XML data from Amazon.com at the exact same time. What happens when it goes to get the data? The script will make two calls to the Amazon servers at the same time which is more than the (1) request per second. This is what I am trying to prevent and why I was going to try the database route. I may be wrong though. Would the system actually do the above and run the same script within one second of each other? Or would there be enough time (1 second) between executions that I do not even need to worry about 2 or more requests occurring at the same time?

In that case look at lockfiles - merlyn wrote a good article - "The poor man's load balancer" in the very late Web Techniques, which he has very kindly kept online here.

.02

cLive ;-)

Your main problem is going to be with race conditions. What if two different processes are started at the exact same time? Simply telling each one to sleep, as others have suggested, will not help. They will both sleep the same amount of time, then both execute at the same time.

You need a way to implement some sort of mutual exclusion lock (or semaphore). Each process would attempt to get the lock. Once a process obtains the lock, it would be the responsibility of that process to make sure it held the lock for at least one second. Each process is only allowed to execute requests while it is holding the lock.

Using IPC::Shareable or IPC::ShareLite might also be cleaner.

--
I'm not belgian but I play one on TV.

At the risk of stating the obvious, how about sleep 1 each time through the loop?

Images are unlikely to be of interest when fetching some data to a script. A redirect is obviously useless since it doesn't get the data to the script. The cache must be synchronized not to update faster than once per second also, so whether you're using a cache or not does not automatically ensure strict compliance to the demand under any circumstance. If you already have some sort of serializing mechanism though, adding caching to it is a an excellent proposal.

Makeshifts last the longest.