Product Knowledge Base

Space shortcuts

Page tree

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 2 Next »

Scope

  • A job should monitor the size of a file, e.g. a log file.
  • If the file size is not steady after some predefined timeout then an error should be raised or a predefined order state should be set.
  • File size monitoring is implemented by a Monitor script that can be used by any job.

Download and Installation

  • Download: file_size_monitor.zip
  • Unzip the archive to the ./config/live folder of your JobScheduler Master.

Implementation

Configuration

  • The File Size Monitor can be configured from job or order parameters.

  • The following parameters are used:

    ParameterRequiredDefaultDescription
    monitor_file_change_locationyes The full path of a file that should be monitored.
    monitor_file_change_timeoutyes The max. duration in seconds that repeated checks for steady file size are performed.
    monitor_file_change_intervalno1Specifies the number of seconds that the monitor sleeps between repeated checks of the file size.
    monitor_file_change_exit_codeno Optionally sets the exit code of the current job to the specified value if the monitored files is not being found steady. This works for shell jobs exclusively.
    monitor_file_change_error_stateno Optionally sets the order to the specified state if the monitored file is not being found steady

Explanations

  • s

    Monitor implementation 
    function spooler_process_before() {
    var rc = true;
    // merge parameters from task and order
    var params = spooler_task.params;
    params.merge( spooler_task.order.params );
    // required parameters
    var monitorLocation = params.value( 'monitor_file_change_location' );
    var monitorTimeout = params.value( 'monitor_file_change_timeout' );
    // optional parameters
    var monitorInterval = params.value( 'monitor_file_change_interval' );
    var monitorExitCode = params.value( 'monitor_file_change_exit_code' );
    var monitorErrorState = params.value( 'monitor_file_change_error_state' );
 
    if ( !monitorLocation ) {
        spooler_log.error( '.. parameter missing: monitor_file_change_location' );
        return false;
    }
    if ( !monitorTimeout ) {
        spooler_log.error( '.. parameter missing: monitor_file_change_timeout' );
        return false;
    } else {
        monitorTimeout = parseInt( monitorTimeout );
    }
    if ( !monitorInterval ) {
        monitorInterval = 1;
    } else {
        monitorInterval = parseInt( monitorInterval );
    }
    if ( !monitorExitCode ) {
        monitorExitCode = 1;
    } else {
        monitorExitCode = parseInt( monitorExitCode );
    }
    // let's use a Java package for file operations
    var monitorFile = new java.io.File( monitorLocation );
    if ( !monitorFile.isFile() ) {
        spooler_log.error( 'file does not exist: ' + monitorLocation );
        return false;
    } else {
        spooler_log.info( '.. monitoring file for max. ' + monitorTimeout + ' seconds: ' + monitorLocation );
    }
    var currentDuration = 0;
    var fileSize = 0;
    var lastFileSize = 0;
    do {
        lastFileSize = monitorFile.length();
        spooler_log.info( '.. current file size: ' + lastFileSize + ' bytes' );
        java.lang.Thread.sleep( monitorInterval * 1000 );
        fileSize = monitorFile.length();
        currentDuration = currentDuration + monitorInterval;
       } while ( (fileSize != lastFileSize) && (currentDuration < monitorTimeout) )
    if ( fileSize === lastFileSize ) {
        spooler_log.info( '.. file size is steady after ' + currentDuration + ' seconds (' + fileSize + ' bytes): ' + monitorLocation );
    } else {
        spooler_log.info( '.. giving up as file size is not steady after ' + currentDuration + ' seconds (' + fileSize + ' bytes): ' + monitorLocation );
        rc = false;
        if ( monitorExitCode ) {
            spooler_log.info( '.. setting task exit code: ' + monitorExitCode );
            spooler_task.exit_code = monitorExitCode;
        }
        if ( monitorErrorState ) {
            spooler_log.info( '.. moving order to error state: ' + monitorErrorState );
            spooler_task.order.state = monitorErrorState;
        }
    }
    return rc;
}
  • x

 

 

  • No labels