user_ionizer_app/user_ionizer_app.cpp

/*
    This example shows how to integrate all of the functions available in the
    trek_ionizer_api into a user program.  The API allows a program to register
    for a series of callbacks that are triggered based on ION log file and
    process changes.
 */
#include "trek_ionizer_api.h"
 
#ifdef _WIN32
#include <Windows.h>
#endif
 
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <time.h>
#include <sys/timeb.h>
 
/*
 *  Defined a callback for each message log 'type'.  For each callback,
 *  print the time the message occured, the type, and the actual message.
 */
void MyInfoCallback(const struct tm *occur_time, const char *msg)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Info: %s\n", occur_time->tm_year,
                                                       occur_time->tm_mon, 
                                                       occur_time->tm_mday, 
                                                       occur_time->tm_hour, 
                                                       occur_time->tm_min, 
                                                       occur_time->tm_sec, 
                                                       msg );
}
 
void MyWarningCallback(const struct tm *occur_time, const char *msg)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Warn: %s\n", occur_time->tm_year,
                                                       occur_time->tm_mon, 
                                                       occur_time->tm_mday, 
                                                       occur_time->tm_hour, 
                                                       occur_time->tm_min, 
                                                       occur_time->tm_sec, 
                                                       msg );
}
 
void MyDiagnosticCallback(const struct tm *occur_time, const char *msg)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Diag: %s\n", occur_time->tm_year,
                                                       occur_time->tm_mon, 
                                                       occur_time->tm_mday, 
                                                       occur_time->tm_hour, 
                                                       occur_time->tm_min, 
                                                       occur_time->tm_sec, 
                                                       msg );
}
 
void MyBundleStatusReportCallback(const struct tm *occur_time, const char *msg)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Bund: %s\n", occur_time->tm_year,
                                                       occur_time->tm_mon, 
                                                       occur_time->tm_mday, 
                                                       occur_time->tm_hour, 
                                                       occur_time->tm_min, 
                                                       occur_time->tm_sec, 
                                                       msg );
}
 
void MyCommStatsCallback
(
    const struct tm *occur_time, 
    const struct ion_comm_statistics *ion_stats
)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Comm:\n", occur_time->tm_year,
                                                    occur_time->tm_mon, 
                                                    occur_time->tm_mday, 
                                                    occur_time->tm_hour, 
                                                    occur_time->tm_min, 
                                                    occur_time->tm_sec );
    printf("src %u %u %u %u %u %u %u %u\n", ion_stats->src.firstCount, 
                                      ion_stats->src.firstBytes, 
                                      ion_stats->src.secondCount, 
                                      ion_stats->src.secondBytes, 
                                      ion_stats->src.thirdCount, 
                                      ion_stats->src.thirdBytes, 
                                      ion_stats->src.totalCount,
                                      ion_stats->src.totalBytes );
    printf("fwd %u %u %u %u %u %u %u %u\n", ion_stats->fwd.firstCount, 
                                      ion_stats->fwd.firstBytes, 
                                      ion_stats->fwd.secondCount, 
                                      ion_stats->fwd.secondBytes, 
                                      ion_stats->fwd.thirdCount, 
                                      ion_stats->fwd.thirdBytes, 
                                      ion_stats->fwd.totalCount,
                                      ion_stats->fwd.totalBytes );
    printf("xmt %u %u %u %u %u %u %u %u\n", ion_stats->xmt.firstCount, 
                                      ion_stats->xmt.firstBytes, 
                                      ion_stats->xmt.secondCount, 
                                      ion_stats->xmt.secondBytes, 
                                      ion_stats->xmt.thirdCount, 
                                      ion_stats->xmt.thirdBytes, 
                                      ion_stats->xmt.totalCount,
                                      ion_stats->xmt.totalBytes );
    printf("rcv %u %u %u %u %u %u %u %u\n", ion_stats->rcv.firstCount, 
                                      ion_stats->rcv.firstBytes, 
                                      ion_stats->rcv.secondCount, 
                                      ion_stats->rcv.secondBytes, 
                                      ion_stats->rcv.thirdCount, 
                                      ion_stats->rcv.thirdBytes, 
                                      ion_stats->rcv.totalCount,
                                      ion_stats->rcv.totalBytes );
    printf("dlv %u %u %u %u %u %u %u %u\n", ion_stats->dlv.firstCount, 
                                      ion_stats->dlv.firstBytes, 
                                      ion_stats->dlv.secondCount, 
                                      ion_stats->dlv.secondBytes, 
                                      ion_stats->dlv.thirdCount, 
                                      ion_stats->dlv.thirdBytes, 
                                      ion_stats->dlv.totalCount,
                                      ion_stats->dlv.totalBytes );
    printf("ctr %u %u %u %u %u %u %u %u\n", ion_stats->ctr.firstCount, 
                                      ion_stats->ctr.firstBytes, 
                                      ion_stats->ctr.secondCount, 
                                      ion_stats->ctr.secondBytes, 
                                      ion_stats->ctr.thirdCount, 
                                      ion_stats->ctr.thirdBytes, 
                                      ion_stats->ctr.totalCount,
                                      ion_stats->ctr.totalBytes );
    printf("rfw %u %u %u %u %u %u %u %u\n", ion_stats->rfw.firstCount, 
                                      ion_stats->rfw.firstBytes, 
                                      ion_stats->rfw.secondCount, 
                                      ion_stats->rfw.secondBytes, 
                                      ion_stats->rfw.thirdCount, 
                                      ion_stats->rfw.thirdBytes, 
                                      ion_stats->rfw.totalCount,
                                      ion_stats->rfw.totalBytes );
    printf("exp %u %u %u %u %u %u %u %u\n", ion_stats->exp.firstCount, 
                                      ion_stats->exp.firstBytes, 
                                      ion_stats->exp.secondCount, 
                                      ion_stats->exp.secondBytes, 
                                      ion_stats->exp.thirdCount, 
                                      ion_stats->exp.thirdBytes, 
                                      ion_stats->exp.totalCount,
                                      ion_stats->exp.totalBytes );
}
 
void MyFreeFormCallback(const struct tm *occur_time, const char *msg)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Free: %s\n", occur_time->tm_year,
                                                       occur_time->tm_mon, 
                                                       occur_time->tm_mday, 
                                                       occur_time->tm_hour, 
                                                       occur_time->tm_min, 
                                                       occur_time->tm_sec, 
                                                       msg );
}
 
void MyReadErrorCallback(const struct tm *occur_time, const char *msg)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Read: %s\n", occur_time->tm_year,
                                                       occur_time->tm_mon, 
                                                       occur_time->tm_mday, 
                                                       occur_time->tm_hour, 
                                                       occur_time->tm_min, 
                                                       occur_time->tm_sec, 
                                                       msg );
}
 
/*
 *  For missing processes, print the process name, the number of processes found
 *  by the monitor, and the number of expected processes.
 */
void MyMissingProcessCallback
(
    const struct tm *occur_time,
    const char *process, 
    unsigned int number_expected, 
    unsigned int number_found
)
{
    printf("%04u-%02u-%02u %02u:%02u:%02u Missing process...\n", 
                                                       occur_time->tm_year,
                                                       occur_time->tm_mon, 
                                                       occur_time->tm_mday, 
                                                       occur_time->tm_hour, 
                                                       occur_time->tm_min, 
                                                       occur_time->tm_sec );
    printf("Found %u of %u for %s\n", number_found, number_expected, process );
}
 
int main()
{
    int ret_value;
    
    // Register for each of the log message callbacks
    RegisterInfoCallback( MyInfoCallback );
    RegisterWarningCallback( MyWarningCallback );
    RegisterDiagnosticCallback( MyDiagnosticCallback );
    RegisterBundleStatusReportCallback( MyBundleStatusReportCallback );
    RegisterCommunicationStatisticsCallback( MyCommStatsCallback );
    RegisterFreeFormCallback( MyFreeFormCallback );
    RegisterReadErrorCallback( MyReadErrorCallback );
 
    // TODO:  Replace the ion_dir_path variable with the path to the ION
    // configuration files used to start ION.
    const char *ion_dir_path = "d:/two_node_shutdown/node_1";
    ret_value = WatchIonLog( ion_dir_path );
 
    if( ret_value )
    {
        printf("Error %d:  WatchIonLog function failed.\n", ret_value );
        return 1;
    }
 
    // Register for missing callbacks
    RegisterMissingProcessCallback( MyMissingProcessCallback );
    ret_value = WatchIonProcesses( ion_dir_path );
 
    if( ret_value )
    {
        printf("Error %d:  RegisterMissingProcessCallback function failed.\n", ret_value );
        return 1;
    }
 
    //  Allow process to continue until monitoring is no longer desired.  This
    //  example just waits for the user to enter something on the command line.
    char buf[1000];
    scanf( "%s", buf );
    return 0;
 
    //  Stop the monitoring functions for both the log and processes.
    ret_value = StopIonLogWatch();
 
    if( ret_value )
    {
        printf("Error %d:  StopIonLogWatch failed.\n", ret_value);
    }
 
    ret_value = StopIonProcessWatch();
 
    if( ret_value )
    {
        printf("Error %d:  StopIonProcessWatch failed.\n", ret_value);
    }
 
    return 0;
}