use LWP::Simple;
my $url="http://cpan.org";
if (! head($url)) {
  die "The Server is DOWN!!!!" 
}
[download]

if (! get($url)) {
[download]

There is a whole continuum of remote server "up" detection - from mere connectivity, through to accurate and timely responses. A machine may be in several states and conditions, and depending on quite what you are looking for, some of which can be:

• single-user
• multi-user
• port 80 accepting
• http://domain responding
• http://domain/file responding
• http://domain/file responding quickly enough
It may also be that the site content is unpredictable, so a specific URL may not be something you want to check.

Then there is a question of whether one of the unacceptable conditions might change if you retry. For example, instantaneous loads may indicate a very poor response time, but with a perfectly acceptable average.

Hi I use the head as you mentioned, but it always says the server being down with the successful URL.

 require LWP::UserAgent;
 
 my $ua = LWP::UserAgent->new;
 $ua->timeout(10);
 
 my $response = $ua->get('http://search.cpan.org/');
 
 if ($response->is_success) {
     print $response->content;  # or whatever
 }
 else {
     die $response->status_line;
 }
[download]

As an FYI a ping is a special sort of request sent to a machine in order to determine if it is accepting network connections. It's very often used in port scanning, and many people will turn off ping response in order to make their machines appear to be down to the casual ping scanner. Lack of a ping response doesn't mean a machine is down, and existence of a ping response doesn't mean that the machine is accepting HTTP requests.

Hope that this helps. :)

Abigail

use WWW::Mechanize;
    my $mech = WWW::Mechanize->new();
    $mech->get( $url );
[download]

I have previously used Test::Simple to build a set of tests that excercise various parts of a website. Example tests include:

• Get the homepage - as the user would see it. This tests a load balancer if present.
• Get pages from servers directly (without a load balancer)
• Login and retrieve the appropriate session cookies.
• Get pages that are only returned for logged in users.
• Submit a search to the search engine and verify that an acceptable number of results were returned.

Typically you try and test individual pieces of functionality so that you can pin-point the failure. This is especially important where a website relies on multiple hardware and software components performing together.

Well probably the simplest thing (I can think of) would be to just request the page's headers. As I'm not very familiar with any of the HTTP related modules, I'll just drop that Idea and leave implementation to you, or perhaps another friendly monk.

thank you all for the extremely helpful pointers! :) Anev

So it will only tell me if the server is there, but won't let me know if I can access the content for that URL

Besides all of the suggestions where LWP::Simple are implemented you can also take a sniglet out of one of my scripts. This won't check the content itself but will check to see if the server in question is serving pages at all:

use Socket;
:
: 
# skip a few lines of a very large script
:
:
sub portCheck {
  my ($host,$port)=@_;
  my ($iaddr,$paddr,$proto,$line);
                                                                      
+          
  $iaddr=inet_aton($host) or die "Could not aton!";
  $paddr=sockaddr_in($port,$iaddr);
  $proto= getprotobyname('TCP');
  socket(SOCK, PF_INET, SOCK_STREAM, $proto)  || die "socket: $!";
  my $res=connect(SOCK, $paddr);
                                                                      
+          
  return 1 if $res;
  return 0;
                                                                      
+          
                                                                      
+          
}
[download]

:
:
: 
portCheck("www.mysite.com",80) or die "Server not serving!";
:
:
[download]

If you want to check the content itself to make sure it hasn't been hacked or otherwise horribly modified then you might want to use LWP::Simple and friends runnng it one time when you know that A) the site is up and B) the page itelf is intact, generate an MD5 sum or some other fingerprint of your choosing and store that someplace for later comparison.

The sniglet above comes out of a very old script that I deployed a long time ago and it runs against several sites that I have interest in (clubs I belong to, my own web site, former customers of mine, etc.) and pages me if the site is unreachable so I can make the proper notifications.

I plan on overhauling it though given I have learned many better ways of doing things that the script does now which is why it hasn't been posted here in its entirety.

As many have told you already, a ping isn't really the right tool, as some network interfaces have ping disabed (for security reasons and also to prevent DOS attackes); also, a ping won't tell you if the web server is running. If I can stretch a metaphor here, pinging is like calling someone's house and getting the (plugged into the wall) answering machine. What you really want to do is make sure the web server is returning valid content, or inside my metaphor, reach one of the folks in the house and speak to them. They are not quite the same thing.

From the *nix command line, you can use LWP::Simple and do a one-line script, or you can even use GET to get one (or more) of the pages from the site.

Finally, I can highly recommend Nagios as a monitoring tool if you want to jump up a level to an industrial strength method.

you can use this link to check
http://www.viewmypageinfo.com