|
Code |
Text |
|
There is an error such as the start time set in the begin="(1)" attribute is later than the end time set in end="(2)"
- Example -
An error results from, for example
See
|
|
|
Unknown command: <(1)>
See XML commands. |
|
|
Unknown command for task: (1) |
|
|
Missing script |
|
|
Unknown task state: (1) |
|
|
Unexpected XML tag: (1) |
|
|
Missing XML configuration file, option -config=FILENAME.XML |
|
|
XML configuration contains no <config spooler_id=(1)> element |
|
|
Cannot use different scripting languages in the same scripting engine |
|
|
There is no security level "(1)" |
|
|
Script has reported an error: (1) |
|
|
The security settings do not allow this operation |
|
|
Task terminated |
|
|
task.wait_until_terminated() cannot be called in its own thread. Deadlock. |
|
|
Job (1) has already been defined |
|
|
No history |
|
|
Operation is not possible when using a plain text file for history |
|
|
Task logged error: (1) |
|
|
History has been suppressed for job (1) (history=no) |
|
|
Relative database file path cannot be used with need_db=yes and log_dir=*stderr |
|
|
Task cannot start because it has no start time and no valid <run_time> |
|
|
<script> com_class= and language= cannot be combined |
|
|
Missing script |
|
|
(1) cannot accept orders because it has not been declared with <job order="yes"> |
|
|
'(1)' has been initialized already and cannot be modified |
|
|
There is no job in job chain "(1)" for the state "(2)" |
|
|
The state "(1)" has already assigned a job in job chain (2) |
|
|
Job chain is not in use (missing add_job_chain() or job chain is to be removed) |
|
|
Job "(1)" is not in job chain "(2)" |
|
|
'(1)' is not in state '(2)' |
|
|
A temporary job cannot accept orders |
|
|
(1) is not in (2) |
|
|
(1) is not in a job chain |
|
|
Id and priority of an order placed in an order queue cannot be changed |
|
|
There is already a (1) '(2)' |
|
|
There is no (1) '(2)' |
|
|
There is no order (1) in job chain "(2)" |
|
|
(1) is not in an order queue |
|
|
<show_... what="(1)">: invalid value for attribute what= |
|
|
<script> java_class= and language= cannot be combined |
|
|
A program source cannot be set with <script> com_class= or java_class= |
|
|
com_class= and java_class= cannot be combined in <script> |
|
|
This kind of script (scripting engine, Perl, COM or Java) is not possible here |
|
|
Missing script |
|
|
Method "(1)" is missing in class "(2)" |
|
|
Java is not available (see error message when Scheduler started) |
|
|
<process> task did not terminate. pid=(1) |
|
|
Unexpected XML element <(1)> |
|
|
Scheduler cannot start because spooler_init() in '(1)' returned false |
|
|
Scheduler database cannot be accessed due to a database problem |
|
|
(1) is already in job chain (2) |
|
|
Order.setback(): An order can only be set back when it is being executed by a task |
|
|
Order.setback() and Order.state= cannot be combined |
|
|
separate_process: Unexpected state (2) in (1) |
|
|
A separate process is only possible with use_engine="task" |
|
|
process_class and separate_process cannot be combined |
|
|
use_engine="(1)" is deprecated |
|
|
Module::java_method_id((1)): unknown Java class |
|
|
Missing variable name |
|
|
Module instance has been closed |
|
|
Remote instance has been closed |
|
|
Missing working directory when calling Java compiler |
|
|
Connection to task has been lost, state=(1): (2) |
|
|
Module instance in the server has been closed |
|
|
Job "(1)" is in error state. (2) |
|
|
No database given (entry db= in factory.ini) |
|
|
With need_db=(1), only "yes", "no" and "strict" are allowed |
|
|
Task (1) is unknown (and not noted in the history) |
|
|
Only a date without a time is allowed |
|
|
Too many objects for Microsoft Windows MsgWaitForMultipleObjects(). MAXIMUM_WAIT_OBJECTS-1=(1) has been reached. Operation is not executable |
|
|
Too many processes. The number of processes is limited to (1) |
|
|
Missing entry [spooler] html_dir= in file factory.ini |
|
|
Error in HTTP header: expecting (1) |
|
|
Forbidden path in HTTP request |
|
|
Unknown or terminated task (1) |
|
|
(1) is being processed by (2) |
|
|
Subprocess pid=(2) has been terminated with exit code=(1). Command=(3) |
|
|
Subprocess pid=(2) has been terminated with signal (1). Command=(3) |
|
|
<run_time (1)> cannot be carried out for an order |
|
|
<day day="(1)">: only the days from (2) to (3) are possible |
|
|
This command <(1)> is only executable by way of a TCP connection |
|
|
Supervisor has reported an error: (1) |
|
|
Supervisor has closed the connection |
|
|
start_new_file() is only applicable for the main protocol |
|
|
Order has not been processed because the task has been terminated before the processing step (spooler_process()) |
|
|
Scheduler script has logged an error: (1) |
|
|
Job "(1)" is to be removed - it is not longer usable |
|
|
Missing attribute (2) in XML element <(1)> |
|
|
Attribute <(1) (2)="(3)"> is not allowed here |
|
|
The <job (1)="..."> attribute cannot be overwritten |
|
|
Unknown web service: "(1)" |
|
|
Web service "(1)" has already been declared |
|
|
XSLT stylesheet "(1)" does not deliver a result |
|
|
Web service or alias for url_path="(1)" has already been declared |
|
|
XML root element <(1)> expected |
|
|
Order has not been assigned to a web service |
|
|
Task has not been assigned to a web service |
|
|
forward_xslt_stylesheet (1) does not deliver <service_request> |
|
|
Property (1) is fixed and is no longer modifiable |
|
|
Element <content> is missing or empty |
|
|
Element <content> has more than one child element |
|
|
Order does not belong to a web service operation |
|
|
HTTP response has already been sent
|
|
|
web_service_operation has finished and is not longer valid |
|
|
Order id cannot be represented as a character string: (1) |
|
|
Order state cannot be represented as a character string: (1) |
|
|
Order payload cannot be represented as character string: (1) |
|
|
Invalid url path - it has to begin with '/': (1) |
|
|
(1) tasks did not terminate in spite of kill (2) seconds ago. Extending deadline for (3)s |
|
|
(1) tasks did not terminate in spite of kill (2) seconds ago. Scheduler is aborting |
|
|
Deadline for terminating Scheduler has been reached, but (1) tasks are still running |
|
|
Job is being removed now |
|
|
Job will be removed after all its tasks have terminated |
|
|
Java did not start. Scheduler is starting without Java |
|
|
Error in Scheduler Skript, spooler_exit(): (1) Error in Scheduler script, spooler_exit(): (1) |
|
|
Nothing done, event=(1), operations=(2) |
|
|
Kill signal ((1)) received. Scheduler is terminating |
|
|
Kill signal ((1)) #(2) received. (3) |
|
|
SCHEDULER IS TERMINATING AFTER SERIOUS ERROR |
|
|
SCHEDULER IS ABORTING DUE TO A PROBLEM WITH THE DATABASE: (1) |
|
|
Error when writing the history: (1) |
|
|
Error when storing the log in table (1): (2) |
|
|
Log of task (1) is not readable from database: (2) |
|
|
Error when closing the job history: (1) |
|
|
Cannot open history: (1) |
|
|
Task is being terminated in favour of job (1) |
|
|
Terminating task after reaching deadline <job timeout="(1)"> |
|
|
Killing subprocess (1) |
|
|
Error when killing subprocess (1): (2) |
|
|
Deadline reached, killing subprocess (1) |
|
|
Could not kill task |
|
|
<period> ended, terminating task |
|
|
Process terminated with signal (1) ((2)) |
|
|
Process terminated with exit code (1) (0x(2)) |
|
|
Killing process |
|
|
Error when loading task (1) from database: (2) |
|
|
Ignoring cmd='(1)' because job is to be removed |
|
|
Max. (1) history records are being read |
|
|
More than (1) communication channels. Connection denied |
|
|
TCP connection not allowed |
|
|
-reuse-port (SO_REUSEADDR): using (1), but another application can use it too |
|
|
(1) is blocked. Trying a further (2) seconds before giving up |
|
|
Timeout: No job started to execute (1), cancelling order and HTTP operation
|
|
|
Error when removing protocol file: (1) |
|
|
Missing from, to, subject or body. Suppressing email |
|
|
Waiting for closing module instance ... |
|
|
Java class (1) could not be loaded. Java source is being recompiled before retrying |
|
|
Error when loading order (1) from database: (2) |
|
|
Order's <run_time> does not have a next start time |
|
|
Order has been carried out without web_service_operation.send(), operation cancelled |
|
|
Ignoring job=(1) because order is removed from job chain |
|
|
Removing process (1) after error |
|
|
Monitoring of directory (1) has ended after error: (2) |
|
|
UDP message from (1) is not allowed |
|
|
Error sending e-mail: (1) |
|
|
Problem with database: (1) |
|
|
Error when reading next id (column "(2)"): (1) |
|
|
Error when inserting into table (1): (2) |
|
|
Error when updating table (1): (2) |
|
|
Not writing history record because of already existing database problem |
|
|
Ignoring cancel() because response has already been sent |
|
|
Error when opening database: (1) |
|
|
Error when closing the database: (1) |
|
|
Error when processing HTTP request (1): (2) |
|
|
Variable "(1)" (vt=(2)) cannot be converted to Text: (3) |
|
|
Cannot store order in database: (1) |
|
|
Cannot open database. Scheduler is aborting immediately because of need_db=(1) |
|
|
<web_service name="(1)"/>: attributes job_chain=/timeout= and request/response/forward_xslt_stylesheet= cannot be combined |
|
|
Option -env=NAME=VALUE: missing '=' between name and value: -env="(1)" |
|
|
XML-Element <(1)> is not possible here |
|
|
Could not send mail |
|
|
Mail has been sent, but an error occurred when processing the mail queue: (1) |
|
|
min_tasks=(1) is greater than max_tasks=(2)
See
|
|
|
exit_code is available only when task module is loaded
See
|
|
|
Invalid value for attribute exit_code="" in <commands>
See
|
|
|
Attribute exit_code is not applicable here
See
|
|
|
<commands on_exit_code="">: <commands> for exit code (2) is already defined
See
|
|
|
Last error occurred when executing command: (1)
See
|
|
|
Executing <commands on_exit_code="(1)">:
See
|
|
|
<copy_params from=""/>: requested parameters are not available
|
|
|
(1) could not be initialized:(2) |
|
|
Scheduler is terminating after error (see last error line) |
|
|
Error in (1) while switching to state=(2): (3) |
|
|
"now+SECONDS" expected in "(1)" |
|
|
Error when building mail: (1) |
|
|
Only "yes", "no" and a number are allowed with (1)="(2)": (3) |
|
|
Only "yes", "no" and a list of signal names are allowed with (1)="(2)": (3) |
|
|
Signal (1) is unknown on this operating system and is ignored |
|
|
Order.payload is not a Variable_set |
|
|
File does not exist and can therefore neither be moved nor removed: (1) |
|
|
File still exists. Order has been set on the blacklist |
|
|
There is no job between order source and order sink in (1) |
|
|
This is no file order: (1) |
|
|
order.id has more than (2) characters: (1) |
|
|
order.id has more than (2) characters, the limit of your database column (3) is: (1) |
|
|
Due to previous error the path will be ignored: (1) |
|
|
Path has been removed from the blacklist: (1) |
|
|
Database doesn't deliver width of column (1).(2) |
|
|
Database column (1).(2) could not be expanded |
|
|
Width of database column (1).(2) is unknown. We assume (3) |
|
|
<modify_order_... setback="(1)">: Invalid value for attribute setback= |
|
|
No immediate response from command <(1)> |
|
|
Scheduler Java classes (sos.spooler.jar (1) expected) are not up to date: (2) |
|
|
SQL update statement changed more than one record, (1): (2) |
|
|
This is a member of a cluster (option -exclusive or -distributed-orders), and therefore needs a database |
|
|
This is a member of a cluster (option -exclusive or -distributed-orders), and therefore needs a database. need_db=(1) is not allowed |
|
|
For an exclusive or distributed Scheduler, the database (1) is not supported |
|
|
Error when accessing database table (1) |
|
|
No database |
|
|
Scheduler is aborting because it has become inactive |
|
|
Error when creating SQL table (1): (2) |
|
|
Illegal character in -id=(1) |
|
|
Scheduler is aborting because it has lost its exclusivity |
|
|
Option (1) needs (2) |
|
|
Option (1) conflicts with (2) |
|
|
Operation can only be performed on a distributed orders Scheduler |
|
|
DATABASE INTEGRITY IS BROKEN |
|
|
Exclusivity has been stolen by Scheduler member '(1)' |
|
|
UNEXPECTED DEACTIVATION BY SCHEDULER MEMBER (1) |
|
|
In (1), state '(2)' has no job |
|
|
Order is distributed and therefore does not support operation '(1)' |
|
|
After own late heart beat, Scheduler member '(1)' has taken exclusiveness |
|
|
After own late heart beat, this Scheduler has been deactivated and the occupied orders have been freed by Scheduler member '(1)' |
|
|
(1) is occupied by Scheduler member '(2)' |
|
|
job_chain orders_recoverable="no" cannot be combined with distributed="yes", in (1) |
|
|
Scheduler is not yet active and cannot execute the operation |
|
|
(1) is distributed and therefore does not support operation '(2)' |
|
|
Deletion of order in database has failed |
|
|
Last heart beat was (1), (2) seconds ago. Something is delaying Scheduler execution, the Scheduler is aborted immediately |
|
|
This order stored in database is distributed and cannot be used in a non-distributed job chain |
|
|
More than (1) nested includes in (2) |
|
|
Invalid value '(2)' for setting '(1)'. Allowed values are: (3) |
|
|
heart_beat_warn_timeout=(1) seconds has to be lower than heart_beat_own_timeout=(2), which has to be lower than heart_beat_warn_timeout=(3) seconds |
|
|
Error when calling <run_time> function '(1)': (2) |
|
|
<run_time>-Function '(1)' returned start time (2) which is earlier than the requested beginning (3) |
|
|
Job has not yet reached state '(1)' for operation (2) |
|
|
A distributed order does not support (1) |
|
|
After last error, next_start_function='(1)' will no longer be executed for this <run_time> |
|
|
Error in (1):(2) |
|
|
Unknown '(1)' |
|
|
There is no valid state for job chain node state='(1)', action='next_state' (circular next_state) |
|
|
action='(1)' is not possible on a distributed job chain |
|
|
Setting state='(1)' is not possible while job chain has state '(2)' |
|
|
Error in job chain node state='(1)': (2) |
|
|
Attribute (1) is empty |
|
|
<(1) (2)=...> cannot be changed |
|
|
XML tag <(1)> expected, instead of <(2)> |
|
|
Job chains can only be nested once |
|
|
Nested job chains cannot be combined with distributed orders |
|
|
There is a circular nesting of job chains: (1) |
|
|
Error when trying to continue in next job chain: (1) |
|
|
'(1)' is already known |
|
|
Invalid name: '(1)' |
|
|
New Process_class.max_processes=(1) is below current number of processes=(2) |
|
|
Negative value is not allowed for (1) |
|
|
'(1)' has already been added |
|
|
There is no supervisor |
|
|
'(1)' is being removed before '(2)' |
|
|
'(2)' and '(3)' cannot be combined, because of duplicate order id '(1)' |
|
|
Invalid MD5 hexadecimal coded password for HTTP user '(1)' |
|
|
Error when reading base file '(1)' ((2)):(3) |
|
|
Current name of '(1)' is fixed and cannot be changed to '(2)' |
|
|
'(1) (2)' is unknown |
|
|
Error when processing configuration directory:(1) |
|
|
(1) has no name |
|
|
'(1)' is not in any folder and cannot be replaced or removed |
|
|
Error when closing '(1)':(2) |
|
|
Standing order filename has not expected syntax jobchain,orderid.order.xml: (1) |
|
|
Order id in <order> is different from order id in configuration filename |
|
|
Attribute job_chain="(1)" is not empty and differs from Job_chain '(2)' in configuration filename |
|
|
Invalid Job_chain_node for add_order() with state='(1)' |
|
|
Error when removing after base file '(1)' has been removed:(3) |
|
|
Definition of (1) is incomplete |
|
|
Invalid value in <(1) (2)="(3)"> |
|
|
Attribute (1) cannot be combined with (2) |
|
|
<month month="(1)"> has been defined already |
|
|
Invalid weekday '(1)' |
|
|
<weekday day="(1)" which="(2)" has been defined already |
|
|
Error in (1): (2) |
|
|
File '(1)' cannot be read, because it is bigger than (2)MB |
|
|
Syntax error in order parameters file (1): Missing '=' after variable name |
|
|
Java file '(1)' could not be deleted |
|
|
Database check failed, database is not useable. (1) |
|
|
Database does not correctly store test values:(1) (written value)(2) (read value) |
|
|
Database does not respect rollback command |
|
|
Remote configuration directories '(1)' and '(2)' refer to the same IP number |
|
|
No configuration directory for '(1)' |
|
|
Invalid response from supervisor |
|
|
Remote scheduler '(1)' has not been registered |
|
|
Error in dependant after '(1)' has been loaded:(2) |
|
|
(1) is centrally defined and cannot be locally overwritten |
|
|
Path reaches beyond root (too many '..'): (1) |
|
|
Attribute live_file= is not possible here. Use attribute file= |
|
|
(1): substituted '(2)' is a substitute |
|
|
(1): valid_from=""> is not before valid_to="" |
|
|
'(1)' overlaps (2) |
|
|
'(1)' is a substitute for another schedule and cannot be used directly |
|
|
Attribute '(1)' is only valid with attribute '(2)' |
|
|
Using this call is not possible in this context |
|
|
try_hold_lock() or try_hold_lock_non_exclusive() has failed and call_me_again_when_locks_available() has not been called |
|
|
Path is not absolute: (1) |
|
|
Not supported character for encoding '(1)' |
|
|
Scheduler (1) is starting with (2), pid=(3) |
|
|
state=(1) |
|
|
Tasks have (1) seconds to terminate |
|
|
Restarting Scheduler: (1) |
|
|
Opening database: (1) |
|
|
Column (2) is being added to database table (1): (3) |
|
|
Creating database table (1) |
|
|
New history file opened: (1) |
|
|
add_pid((1)), process deadline is (2) |
|
|
Previous history has been archived under (1) |
|
|
end() called, task will terminate |
|
|
Process event |
|
|
idle_timeout is over, terminating task |
|
|
Enqueued task has been loaded from database: id=(1) start_at=(2) |
|
|
state=(1) (2) |
|
|
Task (1) enqueued |
|
|
Reading script again (processing again <include>) |
|
|
Next period is (1), Schedule '(2)' |
|
|
No further period |
|
|
Repeating at (1) due to delay_after_error |
|
|
First start at the start of the period: (1) |
|
|
Next start at (2) due to spooler_job.repeat=(1) |
|
|
Next start at (2) due to <period repeat="(1)"> |
|
|
Next start time will be determined at beginning of the next period. This is at (1) |
|
|
Next single_start at (1) |
|
|
Task (1) started - cause: (2) |
|
|
state=(1) |
|
|
TCP connection accepted |
|
|
Compiling Java source: (1) |
|
|
(1) orders read from database |
|
|
Replacing (1) now |
|
|
Removing (1) now |
|
|
Order will be processed at (1) |
|
|
Replacing order with same id: (1) |
|
|
Removing order from job chain |
|
|
Removing order from job chain. Order is still being executed by (1) |
|
|
add_or_replace_order(): order delayed until (1) has executed (2) |
|
|
setback() called (1) times. Setting order to error state |
|
|
End state reached - order will be repeated at (2) with state=(1) |
|
|
No further job in job chain - order has been carried out |
|
|
setback(): order has been set back (1) times, until (2) |
|
|
setback(): order has been set back (1) times. This is more than (2) - the maximum for this job |
|
|
Process (1) started |
|
|
Job will be executed when a process of process class '(1)' becomes available |
|
|
Scheduler has been registered |
|
|
Daylight saving time has begun |
|
|
Daylight saving time has ended, now it's standard time |
|
|
Still sleeping (1) seconds ... |
|
|
XSLT stylesheet (1)="(2)" returns: |
|
|
UDP message from (1): (2) |
|
|
Scheduler expects commands from (1) port (2) |
|
|
Closing database |
|
|
Waiting (1) seconds before reopening the database |
|
|
Switching history from database to plain files |
|
|
Windows service handler: control=(1) event=(2) |
|
|
Protocol starts in (1) |
|
|
Protocol ends in (1) |
|
|
Copying protocol file to (1) |
|
|
New (1)
The web service has created a new order and handed it over to the job chain. |
|
|
Executing command (1) |
|
|
Command answer: (1) |
|
|
start_new_file(): protocol file is being closed now |
|
|
start_new_file(): intermediate protocol file is: (1) |
|
|
Less than min_tasks=(1) are running. New tasks will be started. Reason: (2) |
|
|
(1) ended immediately after start, so min_tasks=(2) doesn't lead to new tasks |
|
|
Still waiting until (1) ((2)) ... |
|
|
Killed task does not stop the job because of ignore_signals="..." |
|
|
Last error does not stop the job if the task aborts (after kill or crash) with any signal listed in ignore_signals="". In this case, expect warning SCHEDULER-279 |
|
|
This file path with ';' will not be included in changed_directory: (1) |
|
|
This directory path with ';' will not be included in triggered_files: (1) |
|
|
Job is not stopping because of <job stop_on_error="no">. Task error was: (1) |
|
|
Job is stopping because of <job stop_on_error="yes">. Task error was: (1) |
|
|
Removing file (1) |
|
|
Moving file (1) to (2) |
|
|
File on blacklist has been removed |
|
|
File has been removed, so the file order is being removed too |
|
|
New file, (2): Added (1) |
|
|
Recovered from previous error in directory (1) |
|
|
(1) more file orders will be added later, after previous orders have been processed |
|
|
Continuing reading buffered directory (as of (1)) |
|
|
Starting process: (1) |
|
|
(1) cannot be removed now, it will be done later |
|
|
Adding (1) |
|
|
Order has been suspended |
|
|
Order ist not longer suspended, next start (1) |
|
|
No heart beat for (2) seconds ((1)), expecting heart beat within (3) seconds |
|
|
No heart beat for (2) seconds ((1)), ignored for (3) seconds because of recent database reconnect |
|
|
No heart beat for (2) seconds ((1)) - Scheduler seems to be dead |
|
|
Making up an extra heart beat |
|
|
Scheduler has been terminated properly |
|
|
No Scheduler is active |
|
|
This Scheduler is active and exclusive now |
|
|
Using database product (1) |
|
|
Dead scheduler record has been removed |
|
|
Executing command read from database: (1) |
|
|
Just before processing, order record in database has been occupied or removed |
|
|
Order is occupied by Scheduler '(1)' |
|
|
Inactive Scheduler '(2)' has the higher backup precedence (1) ((3)) |
|
|
Task should end but it has just been started with an order attached, so one step will be done |
|
|
Unable to release occupation in database |
|
|
Missing order record in database |
|
|
Scheduler becomes active |
|
|
Watching heart beat of that Scheduler |
|
|
Scheduler member '(1)' seems to be active, claiming its last heart beat was (2)s ago (pid=(4), (3)) |
|
|
Scheduler member '(1)' seems to be exclusive, claiming its last heart beat was (2)s ago (pid=(4), (3)) |
|
|
Dead Scheduler member '(1)' has resurrected |
|
|
No exclusive Scheduler is running |
|
|
That Scheduler has terminated |
|
|
Own heart beat is late: next_heart_beat has been announced for (1) (this is (2) seconds late) |
|
|
Releasing occupied order (1):(2) |
|
|
Because all Scheduler tasks have been killed, the order in database has not been updated. Only the occupation has been released |
|
|
Waiting (1)s for start of non-backup Scheduler |
|
|
This is a backup Scheduler, waiting for a non-backup Scheduler |
|
|
Watching heart beat of that exclusive Scheduler, standing by to take over operation |
|
|
Active Scheduler has terminated properly |
|
|
This Scheduler is becoming exclusive now |
|
|
Deactivating that dead Scheduler |
|
|
Taking exclusiveness from that Scheduler |
|
|
(1). heart beat detected |
|
|
This order has been replaced |
|
|
It has been requested that the exclusive operation will not be continued |
|
|
Task is going to process (1), state=(2), on Scheduler (3) |
|
|
Task has ended processing of (1), state=(2), on Scheduler (3) |
|
|
Scheduler script is not yet active. Operation is executed without the call of function '(1)' |
|
|
Task ended without processing the order. The order remains in job's order queue in the same state |
|
|
After task exception and due to stop_on_error='no', the order has been moved to error_state='(1)' |
|
|
Please use new name '(1)' instead of old '(2)' |
|
|
Task pid=(1) started for remote scheduler |
|
|
Timeout is not possible for a subprocess running on a remote host (it cannot be killed), pid=(1) |
|
|
After lost connection to remote scheduler, process (1) is going to be killed |
|
|
After possibly volatile error (number (1)), the statement which caused the error will be repeated: (2) |
|
|
Order not found in database |
|
|
Order in database could not be updated or deleted. |
|
|
Closing lock (1) while held by (2) |
|
|
Task is now holding (1) (2) |
|
|
(1) has been released |
|
|
(1) has been released, (2) non-exclusive holders remaining |
|
|
Not longer waiting for lock (1) |
|
|
Due to action='next_state' the state '(2)' has been skipped. Next state is '(1)' |
|
|
Waiting for '(1)', (2), on place (3) ((4)) |
|
|
'(1)' has been removed |
|
|
Continuing in '(1)' |
|
|
Continuing from '(1)' |
|
|
Closing process class before (1) |
|
|
New '(1)' shares order IDs with (2) |
|
|
Job_chains (2) share order IDs because '(1)' has been removed |
|
|
Order_id_space has been closed |
|
|
Order_id_space has been closed because '(1)' has been removed |
|
|
Temporary files cannot be deleted. Still trying ..., (1) |
|
|
Temporary files have been deleted now |
|
|
Temporary files cannot be deleted: (1) |
|
|
Deactivating old cluster member with same ID |
|
|
Error when creating database index is ignored |
|
|
Error when reading stdout file is ignored: (1), (2) |
|
|
Configuration directory '(1)' has been removed:(2) |
|
|
Configuration directory has been deleted |
|
|
Task ends because '(1)' is being removed |
|
|
Lock will be removed later, it is held by '(1)' |
|
|
More lock holders than new max_non_exclusive=(1): (2) |
|
|
(1) cannot be replaced now, it will be done later |
|
|
These filenames yield the same object name: '(1)' and '(2)'. The second is ignored |
|
|
(2) is going to be removed because its configuration file '(1)' has been removed |
|
|
Configuration file '(1)' ((2)) is going to be be loaded into this new (3) |
|
|
This (3) is going to be replaced due to changed configuration file '(1)' ((2)) |
|
|
(1) is '(2)' now |
|
|
'(1)' will be removed later, it is used by (2) |
|
|
Configuration directory '(1)' does not exist, it will be ignored |
|
|
Error in replacement ignored::(2) |
|
|
Folder is going to be removed because its configuration directory has been removed |
|
|
Scheduler has no UDP port, so updated configuration files on supervisor will not be noticed |
|
|
Replicating '(1)' |
|
|
Removing '(1)' |
|
|
Local configuration file is ignored, the central configuration file is used instead |
|
|
Order has reached its end_state='(1)' |
|
|
Substitute '(1)' is valid now |
|
|
Standard '(1)' is valid now |
|
|
Creating configuration directory '(1)' |
|
|
Adding '(1)' |
|
|
Killing descendant pid=(1) ((2)) |
|
|
Delayed command <scheduler_log.log_categories.reset> has been executed |
|
|
Step has run for (2)s, which is shorter than the expected duration of (1) |
|
|
Step runs longer than the expected duration of (1) |
|
Code |
Text |
|
Separate process: (1) |
|
|
Separate process: pid=(1): Connection lost |
|
|
Separate process: Unknown proxy id (1) |
|
|
Separate process: Not a registered object: (1) |
|
|
Separate process: Invalid session id (1) |
|
|
Separate process: Unknown session command, failure in communication |
|
|
Separate process: Unknown session class, failure in communication |
|
|
Separate process pid=(1): Invalid response |
|
|
Separate process: Variant type (1) is not transmittable |
|
|
Separate process: Failure in communication (message is too short) |
|
|
Separate process: Thread (1) tries to use connection owned by thread (2) |
|
|
Separate process: Program did not fetch operation's result: (1) |
|
|
Separate process: pop_operation with different method "(2)" ("(1)" expected) or different object |
|
|
Separate process: Program did not fetch result of an finished operation, method=(1) |
|
|
Separate process pid=(1): Message length (2) too big or invalid |
|
|
Separate process pid=(1): No response from new process within (2)s |
|
|
Separate process: Two operations on the same connection. First: (1), second: (2) |
|
|
Separate process: Unknown object id (1) |
|
|
Separate process: pop_operation() on empty stack, method=(1) |
|
|
Separate process pid=(1): Caller has killed process |
|
|
Separate process pid=(1): Process lost |
|
|
Separate process: Named arguments not implemented |
|
|
Separate process: DISPID (1) unknown |
|
|
Separate process: Default proxy for (1) has no properties |
|
|
Separate process: More data as announced received. Failure in communication |
|
|
Separate process: v.vt is not the value of SafeArrayGetVartype() |
|
|
Separate process: Blocking invocation on asynchronous connection rejected. Object=(1), dispid=(2) |
|
Code |
Text |
|
Unknown character encoding: (1) |
|
|
Missing character encoding |