Another alternative if you are listening on a socket is to create the socket at the beginning of startup but not begin processing it until you are ready.

Daemon != Server because you can daemonise many things not just servers. The most usual place to find non server daemons is repeatative processes such as scheduling or long running processes like batch jobs. I often have batch processing that will run for upto 3 hours if these are not detached an error in the terminal could cause the process to error.

Just a few ideas.
UnderMine

Does the server open it's socket at the end of initialization (i.e. when it's ready to process requests?) If so, you could write a very simple script that just tries to open the socket.

If it gets "connection refused" it waits a second, if not, it exits - since the server is now ready to talk to your real client.

If it opens the socket much before it's ready to talk, does it give any other indication when it's ready? If not, perhaps you could write a very simple client (just enough to open a connection, perform the simplest operation and close the connection) - and start the real client once the simple one succeeds.

I thought about this too (long ago), but this approach has two problems:
1. As during development happens, the server may crash, leaving an open socket. Only the server has the detection routine to clean up a left socket after its unsuccessfull predecessor-instance.
2. You speak of a sleep-replacement, which means polling. I don't like polling. :-)

Bye
 PetaMem     All Perl:   MT, NLP, NLU

Well, the only non-polling way I can think of is for the server to call the client. Which is kinda backwards, isn't it?

I don't like polling in general either, but one has to have a sense of proportion. A process that polls once per second for, say 10 seconds (doing sleep 1 each time), is going to create much less engine load than a process that polls in a tight, milisecond loop.

But you don't need a tight loop - if the server runs for an extra second before the first client starts, nothing bad will happen.

On the other hand if you insist on creating a complicated solution just to avoid polling, you will needlessly complicate the server and spend much, much more of your time than you will save with the automated startup script.

It sounds like you're pretty sure your server will eventually start and you just want to make sure that it's ready before the client starts so that your bash script doesn't fail.

That's not so easy. How about this, make sure that your client returns a proper status to the shell based on success or failure.

#!/bin/bash

SRV=/full/path/to/server
SRV_ARG="-nodb -co /full/path/to/server.conf"

CLT=/full/path/to/client
CLT_ARG="-user=admin -p=23000"

$SRV $SRV_ARG  $@ &
sleep 3

if ! $CLT $CLT_ARG ; then
        sleep 3
        if ! $CLT $CLT_ARG ; then
                sleep 6
                if ! $CLT $CLT_ARG ; then
                        echo Server must be broken!
                        exit 1
                fi
        fi
fi
[download]

You'll probably need to work with more than a single status from the client. Maybe you'll have RC_OK, RC_NOSVR, RC_BADARG, ... and your script will have to check for RC_NOSRV and try again.

defined(my $pid = open(KID_TO_READ, "-|"))    or die "Can't fork: $!";
if ($pid == 0) {
  # child
      sleep(5); # Do initialization here
  print "Done with Init\n";
  close(STDOUT);
  open STDOUT, ">&STDERR";
  # Now serve connections
  # blah blah blah
} else {
  # parent waits for child to init
  $_  = <KID_TO_READ>; # wait for line or close
}
[download]

The following code almost works. See the note at the end to get it to really work.

#!perl -w
use IO::Socket::INET;
use Getopt::Std;
use Proc::Daemon;
use strict;

my %opt;
getopts("p:", \%opt);
my $port = $opt{p} || 1923;

my $listensock = IO::Socket::INET->new(LocalPort => $port, Listen => 5
+)
     or die "Socket: $!\n";

print STDERR "Process listening on port $port\n";
Proc::Daemon::Init();   # WARNING SEE NOTE

while (my $client = $listensock->accept) {
  print $client "The time is ", scalar(localtime), "\r\n";
  close($client);
}

# NOTE: This does not work because Proc::Daemon::Init closes ALL file
# descriptors
# If you delete this line from Daemon.pm    
#  foreach $i (0 .. OpenMax) { POSIX::close($i); }
# then it will work.  Or you can just create your own function
# which does everything that Init() does except that line
[download]

Hm. I think I have a Server I need to background itself when initialization is done. It is not that good if this process would chdir to "/", but right now it doesn't matter.