Hi John,
in most cases this behaviour is pretty harmless.
There's one exception though, which I'll cover later in this answer.
Let me explain the concept and the mechanism first.
It is crucial that the scheduling server is the only one that writes on the schedulix schema.
On the other hand, the scheduling server can be started on any host that can connect to the database engine.
Hence in order to guarantee that the currently starting/running server is indeed the only one, we use a table called REPOSITORY_LOCK.
If no server is running, this table is usually empty, unless the last shutdown of the scheduling server was ungraceful.
At startup time the server will attempt to insert a row with two timestamps, one is the startup time, the other the current time.
The third column is called LOCKID and is used as primary key (which implies a uniqueness constraint).
This LOCKID is always 1 (hardcoded). We call this row a ticket.
If the insert fails, there are two possible causes.
Either the DBMS engine has a severe problem, which is then not ours, or we receive a duplicate key error, which means that the repostory is already locked by some other server.
The other server can be alive or not.
In order to detect if the other server is still running, the starting server will first read the current values in the table, wait some time and read the values again.
If the two values differ, there must be someone that changed them, IOW another server must be active.
The server will terminate with exit code 1 (I think, but I'm too lazy to check), scrolllog will restart it and the procedure starts anew.
That'll make that server a warm standby server, that'll take over as soon as the running server dies unexpectedly.
If the two values are equal, they must be a leftover of some ungraceful shutdown (could be anything).
In that case the row will be deleted and a new ticket will be inserted.
Then the startup procedure can continue.
At runtime, the validity of the ticket is checked with every writing transaction and the current timestamp within the ticket is updated.
Additionally the Renew Ticket Thread will update the current timestamp every 30 seconds or so.
In your case, there's no delay between detecting the presence of a ticket and deleting it.
This means that you have the configuration parameter SingleServer set to true (you can find that parameter in the server.conf file).
That is a good idea if there is indeed only one server. It saves you the waiting time until the ticket is deleted.
But if there are potentially two servers, one main server and a second one that'll take over if the main server dies for some reason, and both run with the same configuration (i.e. have SingleServer set to true), you're in trouble.
What then happens is that one server is running and a second server starts.
The second server will then delete the ticket and start loading the data.
The first server detects this with the next writing transaction and aborts.
The scrolllog process finds that its child has terminated with an exit code unequal zero and restarts the first server.
Since the first server also thinks it is the only one, it will delete the ticket of the second server and lock the repository for itself.
I won't tell this story to an end because this ping pong game will continue untill someone kills at least one of the servers and its parent (the scrolllog process).
My guess is that you've tried to start the server twice and both servers are now playing ping pong.
Hence, kill all schedulix processes (well, the Java and scrolllog processes I mean) and then try to start the server again.
You'll still find that message in your log file (kill -9 is not a graceful shutdown), but the server will then manage to startup and start working again.
Hope that helps.
Best regards,
Ronald