///////////////////////////////////////////////////////////////////////////////
//
// @@@ START COPYRIGHT @@@
//
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.
//
// @@@ END COPYRIGHT @@@
//
///////////////////////////////////////////////////////////////////////////////

#ifndef MSGDEF_H_
#define MSGDEF_H_

#include <mpi.h>
#include "trafconf/trafconfig.h"

// HP_MPI supports both 32bit and 64bit modes

// Compile options
//#define DEBUGGING
#define NO_OPEN_CLOSE_NOTICES
#define EXCHANGE_CPU_SCHEDULING_DATA

#define SERVICE_TAG      1
#define INTERNAL_TAG     2
#define NOTICE_TAG       3
#define SYNC_TAG         4
#define CHKPNT_TAG       5
#define EVENT_TAG        6
#define UNSOLICITED_TAG  7
#define REPLY_TAG        8
#define CLOSE_TAG        9
#define WAKE_TAG         10

#define MON_BASE_NICE    0
#define TSE_BASE_NICE    1
#define DTM_BASE_NICE    1
#define APP_BASE_NICE    1

#define BCAST_PID -255

#define WATCHDOG_TICKS   250
#define MAX_ARGS         60
#define MAX_ARG_SIZE     256

#define MAX_CORES        256   // Current logic supports Linux limit of 1024
                               // NOTE: Increase with caution as this number
                               //  is also used to gather local CPU statistics
                               //  and a large number may degrade performance
#define MAX_NODES TC_NODES_MAX // This can be higher when needed and will
                               // have performance implications
                               // NOTE: Must increment by 64 to match node state
                               //       bitmask. See trafconfig.h TC_NODES_MAX in
                               //       Trafodion Configuration API
#define MAX_LNODES_PER_NODE 1  // The 1 is a per physical node limit 
                               // (it can be more, but it is not currently used)
#define MAX_LNODES       (MAX_NODES*MAX_LNODES_PER_NODE)  
#define MAX_NODE_BITMASK  64   // A 64 bit mask, each bit represent pnid state
                               // 0 = down, 1 = up
#define MAX_NODE_MASKS   (MAX_NODES/MAX_NODE_BITMASK) // Node bit mask array size

#define MAX_FAULT_ZONES  16 
#define MAX_FILE_NAME    1024
#define MAX_KEY_NAME     64
#define MAX_KEY_LIST     32
#define MAX_NODE_LIST    64
#define MAX_OPEN_LIST    256
#define MAX_OPEN_CONTEXT 5
#define MAX_PID_VALUE    0x00FFD1C9        // 16,765,385
#define MAX_PERSIST_KEY_STR   51
#define MAX_PERSIST_VALUE_STR 51
#define MAX_PRIMITIVES   1    // SQWatchog (WDG) is last to exit on shutdown
#define MAX_PROC_LIST    256
#define MAX_PROCINFO_LIST 64
#define MAX_PROC_CONTEXT 5
#define MAX_PROCESS_NAME MAX_KEY_NAME
#define MAX_PROCESS_NAME_STR 13
#define MAX_PROCESS_PATH 256
#define MAX_PROCESSOR_NAME 128
#define MAX_RECONN_PING_WAIT_TIMEOUT 5
#define MAX_RECONN_PING_RETRY_COUNT  3
#define MAX_REASON_TEXT  256
#define MAX_ROLEBUF_SIZE 84
#define MAX_SEARCH_PATH  BUFSIZ
#define MAX_SEQ_VALUE    0x7FFFFFFF
#define MAX_STFSD_DATA   32767
#define MAX_SYNC_DATA    4096
#define MAX_SYNC_SIZE    65536
#define MAX_TM_SYNCS     200
#define MAX_TM_HANDLES   0x00FFFFFF
#define MAX_VALUE_SIZE   512
#define MAX_VALUE_SIZE_INT 4096

// Connect default 64 seconds
#define CONNECT_WAIT_TIMEOUT_MSEC    1000
#define CONNECT_WAIT_TIMEOUT_SEC        1
#define CONNECT_RETRY_COUNT            64
#define CONNECT_RETRY_COUNT_MAX       180
// IO default 64 seconds
#define EPOLL_IO_WAIT_TIMEOUT_MSEC   1000
#define EPOLL_IO_WAIT_TIMEOUT_SEC       1
#define EPOLL_IO_RETRY_COUNT           64
#define EPOLL_IO_RETRY_COUNT_MAX      180

// The following defines specify the default values for the HA
// timers if the timer related environment variables are not defined.
// Defaults to 60 second Watchdog process timer expiration
#define WDT_KEEPALIVETIMERDEFAULT 60

// Use STRCPY when the size of the source string is variable and unknown.
// Safe strcpy - checks that destination has enough capacity to hold
// source string.  If not, source string is truncated.
#define STRCPY(dest,src) \
{ \
    unsigned int dlen = (unsigned int) (sizeof(dest) - 1); \
    if (strlen(src) <= dlen) \
    { \
        strcpy(dest, src); \
    } \
    else \
    { \
        memcpy(dest, src, dlen); \
        dest[dlen] = '\0'; \
    } \
}

typedef int Verifier_t;                  // Process verifier typedef

typedef struct { int nid; int id; } strId_t;

typedef long long _TM_Native_Type;          // Native Data Type for Transaction ID

typedef union {                             // External Extended Transaction ID
    _TM_Native_Type txid[4];
} _TM_Txid_External;

typedef enum {
    SMS_Undefined=1100,     // Invalid
    SMS_Exit                // Monitor Event to exit the SMService process 
} SMServiceEvent_t;

typedef enum {
    Watchdog_Start=1000,    // Monitor Event to start the Watchdog Process timer
    Watchdog_Refresh,       // Monitor Event to restart the Watchdog Process timer
    Watchdog_Expire,        // Monitor Event to expire the Watchdog Process timer
    Watchdog_Stop,          // Monitor Event to stop the Watchdog Process timer
    Watchdog_Shutdown,      // Monitor Event to shutdown the Watchdog Process timer
    Watchdog_Exit           // Monitor Event to exit the Watchdog process 
} WatchdogEvent_t;

typedef enum {
    PStartD_StartPersist=2000,  // Event to PSD to start persistent processes
                                // that do not require DTM
    PStartD_StartPersistDTM     // Event to PSD to start persistent processes
                                // that require DTM
} PStartDEvent_t;

typedef enum {
    AgentType_Undefined=0,
    AgentType_Ambari,
    AgentType_CM,
    AgentType_MPI
} AgentType_t;

typedef enum {
    ConfigType_Undefined=0,                 // Invalid
    ConfigType_Cluster,                     // Gobal to cluster configuration data
    ConfigType_Node,                        // Local to node configuration data
    ConfigType_Process                      // Gobal to process configuration data
} ConfigType;

typedef enum {
    CommType_Undefined=0,
    CommType_InfiniBand,
    CommType_Sockets
} CommType_t;

typedef enum 
{
    State_UnMounted =0,                     // Device not mounted
    State_Mounted                           // Device mounted
} DEVICESTATE;

typedef enum {
    State_Unknown=0,                        // Invalid
    State_Up,                               // Object is available for use
    State_Down,                             // Object has failed and is unavailable
    State_Stopped,                          // Object has terminated and is unavailable
    State_Shutdown,                         // Object is in the process of terminating
    State_Unlinked,
    State_Initializing,                     // Object not yet ready for use
    State_Joining,                          // Node is ready for Join Phase
    State_Merging,                          // Node is merged to MPI collective
    State_Merged,                           // Node merge with MPI collective is in use by cluster
    State_Takeover                          // Node is in takeover state
} STATE;

typedef enum {
    Dump_Unknown=0,                         // Invalid
    Dump_Ready,                             // ProcessObject can be dumped
    Dump_Pending,                           // ProcessObject dump requested
    Dump_InProgress,                        // ProcessObject dump in process
    Dump_Complete                           // ProcessObject dump complete
} DUMPSTATE;
typedef enum {
    Dump_Success=0,                         // Success
    Dump_Failed                             // Failed
} DUMPSTATUS;

// Node Re-integration phases
typedef enum {
    JoiningPhase_Unknown=0,                 // Invalid
    JoiningPhase_1,                         // Join initiated
    JoiningPhase_2,                         // Join in progress
    JoiningPhase_3,                         // Join completing
    JoiningPhase_Invalid                    // Invalid
} JOINING_PHASE;

typedef enum {
    RoleType_Undefined   = 0x0000,          // Maps to ZoneType_Any
    RoleType_Connection  = 0x0001,          // Maps to ZoneType_Edge, Frontend or Any
    RoleType_Aggregation = 0x0002,          // Maps to ZoneType_Aggregation, Backend or Any
    RoleType_Storage     = 0x0004           // Maps to ZoneType_Storage, Backend or Any
} RoleType;

typedef TcZoneType_t ZoneType;

// Service Request types
// note: other data structures depend on the ordering of the REQTYPE elements.
//       if the ordering changes corresponding changes must be made to 
//       SQ_LocalIOToClient::serviceRequestSize and CReqQueue::svcReqType.
typedef enum {
    ReqType_Close=1,                        // process closing server request
    ReqType_DelProcessNs,                   // delete process
    ReqType_Dump,                           // dump process
    ReqType_Event,                          // send target processes an Event notice
    ReqType_Exit,                           // process is exiting
    ReqType_Get,                            // retrieve information from the registry
    ReqType_InstanceId,                     // get Cluster Id and Instance Id
    ReqType_Kill,                           // stop and cleanup the identified process
    ReqType_MonStats,                       // get monitor statistics
    ReqType_Mount,                          // mount device associated with process    
    ReqType_NameServerAdd,                  // add nameserver to configuration database
    ReqType_NameServerDelete,               // delete nameserver from configuration database
    ReqType_NameServerStart,                // start the identified nameserver
    ReqType_NameServerStop,                 // stop the identified nameserver
    ReqType_NewProcess,                     // process is request server to be spawned
    ReqType_NewProcessNs,                   // new process
    ReqType_NodeAdd,                        // add node to configuration database
    ReqType_NodeDelete,                     // delete node from configuration database
    ReqType_NodeDown,                       // take down the identified node
    ReqType_NodeInfo,                       // node operational status information request 
    ReqType_NodeName,                       // change node name in configuration database
    ReqType_NodeUp,                         // bring up the identified node
    ReqType_Notice,                         // this is a informational message only
    ReqType_Notify,                         // register process to receive death notifications
    ReqType_Open,                           // process opening server request
    ReqType_OpenInfo,                       // request open information for process
    ReqType_PersistAdd,                     // add persist template to configuration database
    ReqType_PersistDelete,                  // delete persist template from configuration database
    ReqType_PNodeInfo,                      // physical node information request 
    ReqType_ProcessInfo,                    // process information request
    ReqType_ProcessInfoCont,                // process information request (continuation)
    ReqType_ProcessInfoNs,                  // process information request (monitor)
    ReqType_Set,                            // add configuration information to the registry 
    ReqType_Shutdown,                       // request cluster shutdown
    ReqType_ShutdownNs,                     // request nameserver shutdown
    ReqType_Startup,                        // process startup notification
    ReqType_TmLeader,                       // request to become the TM leader
    ReqType_TmReady,                        // request to indicate TM ready for transactions
    ReqType_ZoneInfo,                       // zone information request 

    ReqType_Invalid                         // marks the end of the request
                                            // types, add any new request types 
                                            // before this one
} REQTYPE;

// Reply types
// note: other data structures depend on the ordering of the REPLYTYPE elements.
//       if the ordering changes corresponding changes must be made to 
//       SQ_LocalIOToClient::serviceReplySize.
typedef enum {
    ReplyType_Generic=100,                  // general reply across message types
    ReplyType_DelProcessNs,                 // reply with results
    ReplyType_Dump,                         // reply with dump info
    ReplyType_Get,                          // reply with configuration key/value pairs
    ReplyType_InstanceId,                   // reply with Cluster Id and Instance Id
    ReplyType_MonStats,                     // reply with monitor statistics
    ReplyType_Mount,                        // reply with mount info
    ReplyType_NewProcess,                   // reply with new process information
    ReplyType_NewProcessNs,                 // reply with new process information
    ReplyType_NodeInfo,                     // reply with info on list of nodes
    ReplyType_NodeName,                     // reply with results
    ReplyType_Open,                         // reply with open server information
    ReplyType_OpenInfo,                     // reply with list of opens for a process
    ReplyType_PNodeInfo,                    // reply with info on list of physical nodes
    ReplyType_ProcessInfo,                  // reply with info on list of processes
    ReplyType_ProcessInfoNs,                // reply with info of process
    ReplyType_Startup,                      // reply with startup info
    ReplyType_ZoneInfo,                     // reply with info on list of zones

    ReplyType_Invalid                       // marks the end of the reply types,
                                            // add any new reply types before
                                            // this one
} REPLYTYPE;

// Request types
// note: other data structures depend on the ordering of the MSGTYPE elements.
//       if the ordering changes corresponding changes must be made to 
//       SQ_LocalIOToClient::requestSize
typedef enum {
    MsgType_Change=1,                       // registry information has changed notification
    MsgType_Close,                          // process close notification
    MsgType_Event,                          // generic event notification
    MsgType_NodeAdded,                      // node added to configuration notification
    MsgType_NodeChanged,                    // node configuration changed notification
    MsgType_NodeDeleted,                    // node deleted from configuration notification
    MsgType_NodeDown,                       // node is down notification
    MsgType_NodeJoining,                    // node is joining notification
    MsgType_NodeQuiesce,                    // node quiesce notification (always followed by node down)
    MsgType_NodeUp,                         // node is up notification
    MsgType_Open,                           // process open notification
    MsgType_ProcessCreated,                 // process creation completed notification
    MsgType_ProcessDeath,                   // process death notification
    MsgType_ReintegrationError,             // Problem during node reintegration
    MsgType_Service,                        // request a service from the monitor
    MsgType_Shutdown,                       // system shutdown notification
    MsgType_SpareUp,                        // spare node is up notification

    MsgType_Invalid                         // marks the end of the message
                                            // types, add any new message types 
                                            // before this one
} MSGTYPE;

typedef TcProcessType_t PROCESSTYPE;

typedef enum {
    ShutdownLevel_Undefined=-1,
    ShutdownLevel_Normal=0,                 // Wait for all transactions and processes to end
    ShutdownLevel_Immediate,                // Abort transactions and wait for processes to end
    ShutdownLevel_Abrupt                    // just kill all processes and stop
} ShutdownLevel;

struct Change_def
{
    ConfigType type;                        // type of group that has changed 
    char group[MAX_KEY_NAME];               // name of the group that has changed 
    char key[MAX_KEY_NAME];                 // name of the configured item that has changed
    char value[MAX_VALUE_SIZE];             // value currently assigned to the name
};

struct Close_def
{
    int  nid;                              // requesting process's node id
    int  pid;                              // requesting process's id
    Verifier_t verifier;                   // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];   // requesting process's name
    int  aborted;                          // Non-zero if close because of process abort
    int  mon;                              // Non-zero if monitor close
};

struct DelProcessNs_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
    int  target_nid;                        // Node id of processes to delete
    int  target_pid;                        // Process id of process to delete
    Verifier_t target_verifier;             // Process verifier of processes to delete
    char target_process_name[MAX_PROCESS_NAME];    // Name of process to delete
    bool target_abended;                    // True if process aborted
};

struct DelProcessNs_reply_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
    int  return_code;                       // mpi error code of error
};

struct Dump_def
{
    int  nid;                              // requesting process's node id
    int  pid;                              // requesting process's id
    Verifier_t verifier;                   // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];   // requesting process's name
    char path[MAX_PROCESS_PATH];           // path for dump-file
    int  target_nid;                       // Nid of process to dump ( -1 if using name )
    int  target_pid;                       // Pid of process to dump ( -1 if using name )
    Verifier_t target_verifier;            // Verifier of process to dump ( -1 if using name )
    char target_process_name[MAX_PROCESS_NAME];   // Name of process to dump
};

struct Dump_reply_def
{
    int nid;                                // target process's node id
    int pid;                                // target process's process id
    Verifier_t verifier;                    // target process's verifier
    char process_name[MAX_PROCESS_NAME];    // target process's name
    char core_file[MAX_PROCESS_PATH];       // name of core-file
    int return_code;                        // error returned to sender
};

struct Event_def
{
    int  nid;                  // requesting process's node id
    int  pid;                  // requesting process id
    Verifier_t verifier;       // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];   // requesting process's name
    int  target_nid;           // Node id of processes to receive event (-1 for all all nodes)
    int  target_pid;           // Process id of processes to receive event (-1 for all in node)
    Verifier_t target_verifier; // Process verifier of processes to receive event (-1 for all in node)
    char target_process_name[MAX_PROCESS_NAME];    // Name of target process
    PROCESSTYPE type;          // Process type of processes to receive event 
                               //   (ProcessType_Undefined for not type filtering)
    int  event_id;             // Non-Zero user defined event id to be pass in event notice
    int  length;               // The length in bytes used the data buffer
    char data[MAX_SYNC_DATA];  // Data buffer to be sent to selected processes
};

struct Event_Notice_def
{
    int  event_id;             // Non-Zero user defined event id to be pass in event notice
    int  length;               // The length in bytes used the data buffer
    char data[MAX_SYNC_DATA];  // Data buffer to be sent to selected processes
};

struct Exit_def
{                                               
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
};

struct Generic_reply_def
{
    int nid;                                // target process's node id
    int pid;                                // target process's process id
    Verifier_t verifier;                    // target process's verifier
    char process_name[MAX_PROCESS_NAME];    // target process's name
    int return_code;                        // error returned to sender
};

struct Get_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
    ConfigType type;                        // type of group being requested
    bool next;                              // if true, get key list starting after key 
                                            // else start new list
    char group[MAX_KEY_NAME];               // name of group, if NULL and type=ConfigNode assume local node 
    char key[MAX_KEY_NAME];                 // name of the item to be returned, Null for all in group
};

struct Get_reply_def
{
    ConfigType type;                        // type of group being returned 
    char group[MAX_KEY_NAME];               // name of the group of items returned 
    int num_keys;                           // Number of keys in request set
    int num_returned;                       // Number of keys returned
    struct
    {
        char key[MAX_KEY_NAME];             // name of the configured item
        char value[MAX_VALUE_SIZE];         // value currently assigned to the name
    } list[MAX_KEY_LIST];
};

struct InstanceId_def
{
    int nid;                                // requesting process's node id
    int pid;                                // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
};

struct InstanceId_reply_def
{
    int cluster_id;                         // this instance's cluster id
    int instance_id;                        // this instance's instance id
};

struct Kill_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
    int  target_nid;                        // Node id of processes to kill (-1 for all)
    int  target_pid;                        // Process id of process to kill (-1 for all)
    Verifier_t target_verifier;             // Process verifier of processes to kill (-1 if process name only)
    char target_process_name[MAX_PROCESS_NAME];    // Name of process to kill
    bool persistent_abort;                  // when true, persistent process is not restarted
                                            // otherwise, it is ignored
};

struct MonStats_def
{
    int placeholder;
};

struct MonStats_reply_def
{
    int acquiredMax;
    int availMin;
    int bufMisses;
};

struct Mount_def                            // to mount device associated with process
{                                               
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
};

struct Mount_reply_def
{
    DEVICESTATE  primary_state;             // State of primary device
    DEVICESTATE  mirror_state;              // State of mirror device
    int          return_code;               // mpi error code of spawn operation
}; 

struct NameServerAdd_def
{
    int  nid;                               // node id of requesting process
    int  pid;                               // process id of requesting process
    char node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
};

struct NameServerDelete_def
{
    int  nid;                               // node id of requesting process
    int  pid;                               // process id of requesting process
    char node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
};

struct NameServerStart_def
{
    int  nid;                               // node id of requesting process
    int  pid;                               // process id of requesting process
    char node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
};

struct NameServerStop_def
{
    int  nid;                               // node id of requesting process
    int  pid;                               // process id of requesting process
    char node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
};

struct NewProcess_def
{
    int  nid;                               // zone or node id if TM type to start process on, 
                                            // if -1 then will assign node
    PROCESSTYPE type;                       // Identifies the process handling catagory
    int  priority;                          // Linux system priority
    int  debug;                             // if non-zero, starts processing using GDB
    int  backup;                            // if non-zero, starts process as backup
    bool unhooked;                          // if hooked, parent process dies will trigger child process exits
    bool nowait;                            // reply after local node initiates new process and send notice on completion
    long long tag;                          // user defined tag to be sent in completion notice
    char path[MAX_SEARCH_PATH];             // process's object lookup path to program
    char ldpath[MAX_SEARCH_PATH];           // process's library load path for program
    char program[MAX_PROCESS_PATH];         // full path to object file
    char process_name[MAX_PROCESS_NAME];    // process name
    int  argc;                              // number of additional command line argument
    char argv[MAX_ARGS][MAX_ARG_SIZE];      // array of additional command line arguments
    char infile[MAX_PROCESS_PATH];          // if null then use monitor's infile
    char outfile[MAX_PROCESS_PATH];         // if null then use monitor's outfile
    int  fill1;                             // filler to fill out struct
};

struct NewProcessNs_def
{
    int  nid;                               // node id
    int  pid;                               // process id
    Verifier_t verifier;                    // process verifier
    char process_name[MAX_PROCESS_NAME];    // process name
    PROCESSTYPE type;                       // Identifies the process handling catagory
    int  parent_nid;                        // parent's node id
    int  parent_pid;                        // parent's process id
    Verifier_t parent_verifier;             // parent's process verifier
    int  pair_parent_nid;                   // node id of real process pair parent process
    int  pair_parent_pid;                   // process id of real process pair parent process
    Verifier_t pair_parent_verifier;        // process id of real process pair parent process
    int  priority;                          // Linux system priority
    int  debug;                             // if non-zero, starts processing using GDB
    int  backup;                            // if non-zero, starts process as backup
    bool unhooked;                          // if hooked, parent process dies will trigger child process exits
    bool nowait;                            // reply after local node initiates new process and send notice on completion
    bool event_messages;                    // true if want event messages
    bool system_messages;                   // true if want system messages
    long long tag;                          // user defined tag to be sent in completion notice
//    strId_t pathStrId;                      // program lookup path (string id)
//    strId_t ldpathStrId;                    // library load path (string id)
//    strId_t programStrId;                   // full path to object file (string id)
    char path[MAX_SEARCH_PATH];             // process's object lookup path to program
    char ldpath[MAX_SEARCH_PATH];           // process's library load path for program
    char program[MAX_PROCESS_PATH];         // full path to object file
    char port_name[MPI_MAX_PORT_NAME];      // mpi port name from MPI_Open_port
    int  argc;                              // number of additional command line argument
    char argv[MAX_ARGS][MAX_ARG_SIZE];      // array of additional command line arguments
    char infile[MAX_PROCESS_PATH];          // if null then use monitor's infile
    char outfile[MAX_PROCESS_PATH];         // if null then use monitor's outfile
    struct timespec creation_time;          // creation time
    int  fill1;                             // filler to fill out struct
};

struct NewProcess_reply_def
{
    int  nid;                               // node id of started process
    int  pid;                               // internal process id of started process
    Verifier_t verifier;                    // Process verifier
    char process_name[MAX_PROCESS_NAME];    // process names assigned to started process
    int  return_code;                       // mpi error code of spawn operation
};

struct NewProcessNs_reply_def
{
    int  nid;                               // node id of started process
    int  pid;                               // internal process id of started process
    Verifier_t verifier;                    // Process verifier
    char process_name[MAX_PROCESS_NAME];    // process names assigned to started process
    int  return_code;                       // mpi error code of spawn operation
};

struct NewProcess_Notice_def 
{
    int  nid;                               // node id of started process
    int  pid;                               // internal process id of started process
    Verifier_t verifier;                    // Process verifier
    long long tag;                          // user tag sent with original request
    char port[MPI_MAX_PORT_NAME];           // mpi port to started process
    char process_name[MAX_PROCESS_NAME];    // process names assigned to started process
    int  return_code;                       // mpi error code of spawn operation
};

struct NodeAdd_def
{
    int      nid;                               // node id of requesting process
    int      pid;                               // process id of requesting process
    char     node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
    int      first_core;                        // First or only core assigned
    int      last_core;                         // Last core assigned or -1
    int      processors;                        // Number of processors in logical node
    int      roles;                             // Role assigment
};

struct NodeAdded_def                            // Node added to configuration notice
{
    int  nid;
    int  zid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
};

struct NodeChanged_def                          // Node configuration changed notice
{
    int      nid;                               // node id 
    int      zid;                               // zone id
    int      pnid;                              // physical node id
    char     node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
    int      first_core;                        // First or only core assigned
    int      last_core;                         // Last core assigned or -1
    int      processors;                        // Number of processors in logical node
    int      roles;                             // Role assigment
};

struct NodeDelete_def
{
    int      nid;                                      // node id of requesting process
    int      pid;                                      // process id of requesting process
    int      target_pnid;                              // Target physical node id
    char     target_node_name[MPI_MAX_PROCESSOR_NAME]; // Target node name
};

struct NodeDeleted_def                          // Node deleted from configuration notice
{
    int  nid;
    int  zid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
};

struct NodeDown_def
{
    int  nid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
    int  takeover;                          // true if Spare Node activation
#ifdef USE_SEQUENCE_NUM
    long long seqnum;                       // sequence number
#endif
    char reason[MAX_REASON_TEXT];           // text describing reason for down node
};

struct NodeInfo_def
{
    int nid;                                // node id of requesting process
    int pid;                                // process id of requesting process
    int target_nid;                         // get information on node id (-1 for all)
    int last_nid;                           // Last Logical Node ID returned
    int last_pnid;                          // Last Physical Node ID returned
    bool continuation;                      // true if continuation of earlier request
};

struct NodeInfo_reply_def
{
    int num_nodes;                          // Number of logical nodes in the cluster
    int num_pnodes;                         // Number of physical nodes in the cluster
    int num_spares;                         // Number of spare nodes in the cluster
    int num_available_spares;               // Number of currenly available spare nodes in the cluster
    int num_returned;                       // Number of nodes returned
    struct
    {
        int      nid;                       // Node's ID 
        STATE    state;                     // Node's state (i.e. UP, DOWN, STOPPING)
        ZoneType type;                      // Node's fault zone type (service,compute,storge,any,frontend,backend)
        int      processors;                // Number of processors in logical node
        int      process_count;             // Number of processes in executing on the node
        int      pnid;                      // Node's Physical ID 
        STATE    pstate;                    // Physical Node's state (i.e. UP, DOWN, STOPPING)
        bool     spare_node;                // True when physical node is spare
        unsigned int memory_total;          // Node's total memory
        unsigned int memory_free;           // Node's current free memory
        unsigned int swap_free;             // Node's current free swap
        unsigned int cache_free;            // Node's current free buffer/cache
        unsigned int memory_active;         // Node's memory in active use
        unsigned int memory_inactive;       // Node's memory available for reclamation
        unsigned int memory_dirty;          // Node's memory waiting to be written to disk
        unsigned int memory_writeback;      // Node's memory being written to disk
        unsigned int memory_VMallocUsed;    // Node's amount of used virtual memory
        long long    cpu_user;              // Time in user mode
        long long    cpu_nice;              // Time in user mode, low priority
        long long    cpu_system;            // Time in system mode
        long long    cpu_idle;              // Time in idle task
        long long    cpu_iowait;            // Time waiting for i/o
        long long    cpu_irq;               // Time in hardware long longerrupt
        long long    cpu_soft_irq;          // Time in software interrupt
        unsigned int btime;                 // Boot time (secs since 1/1/1970)
        char     node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
        int      cores;                     // Number of processors in physical node
    } node[MAX_NODE_LIST];
    int return_code;                        // error returned to sender
    int last_nid;                           // Last Logical Node ID returned
    int last_pnid;                          // Last Physical Node ID returned
    bool continuation;                      // true if continuation of earlier request
};

struct NodeName_def
{
    int nid;                                    // node id of requesting process
    int pid;                                    // process id of requesting process
    char new_name[MPI_MAX_PROCESSOR_NAME];      // get information on node id (-1 for all)
    char current_name[MPI_MAX_PROCESSOR_NAME];  // current name of node (validation)
};

struct NodeName_reply_def
{
    int return_code;                        // error returned to sender
};

struct NodeJoining_def
{
    int  pnid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
    JOINING_PHASE  phase;
};

struct NodePrepare_def
{
    int  nid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
    int  takeover;                          // true if Spare Node activation
};

struct NodeQuiesce_def
{
    int  nid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
};

struct NodeReInt_def 
{
    char msg[200];
};

struct NodeUp_def
{
    int  nid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
    int  takeover;                          // true if Spare Node activation
#ifdef USE_SEQUENCE_NUM
    long long seqnum;                       // sequence number
#endif
};

struct Notify_def                           // Register for death notification
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
    int  cancel;                            // Zero to set notice else cancel current notice
    int  target_nid;                        // Nid of process to be monitored, if -1 cancel all associated with trans_id
    int  target_pid;                        // Pid of process to be monitored, if -1 cancel all associated with trans_id
    Verifier_t target_verifier;             // Verifier of process to be monitored, if -1 cancel all associated with trans_id
    char target_process_name[MAX_PROCESS_NAME];    // monitored process's name
    int  fill1;                             // filler to trans_id
    _TM_Txid_External trans_id;             // associated transaction id, zero for none.
};                                          // note: cancel=0, target_nid or target_pid = -1 is invalid

struct Open_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name (if notification)
    int  target_nid;                        // Process to open node id
    int  target_pid;                        // Process to open id
    Verifier_t target_verifier;             // Process to open verifier
    char target_process_name[MAX_PROCESS_NAME]; // Process to open name
    int  death_notification;                // true if death notice needed on process failure
};

struct Open_reply_def
{
    int  nid;                               // opened process's node id 
    int  pid;                               // opened process's process id
    Verifier_t verifier;                    // opened process's process verifier
    char process_name[MAX_PROCESS_NAME];    // opened process's name
    char port[MPI_MAX_PORT_NAME];           // opened process's mpi port used in MPI_Comm_connect
    PROCESSTYPE type;                       // opened process's process type
    int  return_code;                       // mpi error code
};

struct Close_reply_def
{
    int  nid;                               // Close requesting process's node id
    int  pid;                               // Close requesting process's process id
    Verifier_t verifier;                    // Close requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // Close requesting process's name
    int  return_code;                       // mpi error code
};

struct OpenInfo_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    int  target_nid;                        // Nid of process to list opens ( -1 if using name )
    int  target_pid;                        // Pid of process to list opens ( -1 if using name )
    char process_name[MAX_PROCESS_NAME];    // Name of process to list opens
    bool who_opened;                        // false for list of processes opened by this process
                                            // true for list of who has this process opened
    bool continuation;                      // true if continuation of earlier request
    struct                                  // last few process ids returned
    {                                       //    previously
        int  nid;                           // node id
        int  pid;                           // process id
    } context[MAX_OPEN_CONTEXT];
};

struct OpenInfo_reply_def
{
    int  num_opens;                         // number of opens returned
    struct 
    {
        int  nid;                           // opened process's node id
        int  pid;                           // opened process's process id
        char process_name[MAX_PROCESS_NAME];// opened process's name
        bool stale;                         // true if open to terminated process
    } opens[MAX_OPEN_LIST];
    int  return_code;                       // error returned to sender
};

struct PNodeInfo_def
{
    int  nid;                               // node id of requesting process
    int  pid;                               // process id of requesting process
    int  target_pnid;                       // get information on pnode id (-1 for all when node_name is null string)
    char target_name[MPI_MAX_PROCESSOR_NAME]; // get information on pnode by node name
    int  last_pnid;                         // Last Physical Node ID returned
    bool continuation;                      // true if continuation of earlier request
};

struct PNodeInfo_reply_def
{
    int num_nodes;                          // Number of logical nodes in the cluster
    int num_pnodes;                         // Number of physical nodes in the cluster
    int num_spares;                         // Number of spare nodes in the cluster
    int num_available_spares;               // Number of currenly available spare nodes in the cluster
    int num_returned;                       // Number of nodes returned
    struct
    {
        int      pnid;                      // Node's Physical ID
        char     node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
        STATE    pstate;                    // Physical Node's state (i.e. UP, DOWN, STOPPING)
        int      lnode_count;               // Number of logical nodes
        int      process_count;             // Number of processes in executing on the node
        bool     spare_node;                // True when physical node is spare
        unsigned int memory_total;          // Node's total memory
        unsigned int memory_free;           // Node's current free memory
        unsigned int swap_free;             // Node's current free swap
        unsigned int cache_free;            // Node's current free buffer/cache
        unsigned int memory_active;         // Node's memory in active use
        unsigned int memory_inactive;       // Node's memory available for reclamation
        unsigned int memory_dirty;          // Node's memory waiting to be written to disk
        unsigned int memory_writeback;      // Node's memory being written to disk
        unsigned int memory_VMallocUsed;    // Node's amount of used virtual memory
        unsigned int btime;                 // Boot time (secs since 1/1/1970)
        int      cores;                     // Number of processors in physical node
    } node[MAX_NODE_LIST];
    int return_code;                        // error returned to sender
    int last_pnid;                          // Last Physical Node ID returned
    bool integrating;                       // true if re-integration in progress in local monitor
    bool continuation;                      // true if continuation of earlier request
};

struct ProcessDeath_def
{
    int nid;                                // dead process's node id
    int pid;                                // dead process's process id
    Verifier_t verifier;                    // dead process's verifier
    _TM_Txid_External trans_id;
    int aborted;                            // Non-zero indicates abnormal termination
    char process_name[MAX_PROCESS_NAME];    // dead process's name
    PROCESSTYPE type;                       // Process type
#ifdef USE_SEQUENCE_NUM
    long long seqnum;                       // sequence number
#endif
};

struct ProcessInfo_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process' verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process' name
    int  target_nid;                        // Node id of processes for status request (-1 for all)
    int  target_pid;                        // Process id of process for status request (-1 for all)
    Verifier_t target_verifier;             // Verifier of process for status request (-1 for if not used)
    char target_process_name[MAX_PROCESS_NAME]; // Name of process for status request (NULL if not used)
    char target_process_pattern[MAX_PROCESS_NAME]; // Name of process pattern for status request (NULL if not used)
    PROCESSTYPE type;                       // Return only processes of this type (ProcessType_Undefined for all)
};

typedef
struct ProcessInfoState
{
    int   nid;                              // process's node id
    int   pid;                              // process's process id
    Verifier_t verifier;                    // process's process verifier
    PROCESSTYPE type;                       // process handling catagory
    char  process_name[MAX_PROCESS_NAME];   // process's Name
    int   os_pid;                           // process's OS based process id
    int   priority;                         // process's OS based priority
    int   parent_nid;                       // process's parent's node id
    int   parent_pid;                       // process's parent's process id
    Verifier_t parent_verifier;             // process's parent's process verifier
    char  parent_name[MAX_PROCESS_NAME];    // process's Name
    char  program[MAX_PROCESS_PATH];        // process's object file name
    STATE state;                            // process's current state
    bool  event_messages;                   // true if receiving system notices
    bool  system_messages;                  // true if receiving system notices
    bool  paired;                           // true if functional copy of like process on another node
    bool  pending_delete;                   // true if process being deleted from cluster
    bool  pending_replication;              // true if process pending replication to cluster
    bool  waiting_startup;                  // true if process has not sent startup message
    bool  opened;                           // true if process is currently opened by another process
    bool  backup;                           // true if process is a backup to the parent process
    bool  unhooked;                         // false if parent process dies will trigger child process exit
    struct timespec creation_time;          // creation time
} ProcessInfoState;

struct ProcessInfo_reply_def
{
    int  num_processes;                     // number of process returned
    ProcessInfoState process[MAX_PROCINFO_LIST];
    int  return_code;                       // error returned to sender
    bool more_data;                         // true if have additional process data
};

struct ProcessInfoNs_reply_def
{
    int  nid;                               // node id
    int  pid;                               // process id
    Verifier_t verifier;                    // process verifier
    char process_name[MAX_PROCESS_NAME];    // process name
    PROCESSTYPE type;                       // Identifies the process handling catagory
    int   parent_nid;                       // parent's node id
    int   parent_pid;                       // parent's process id
    Verifier_t parent_verifier;             // parent's process verifier
    int  pair_parent_nid;                   // node id of real process pair parent process
    int  pair_parent_pid;                   // process id of real process pair parent process
    Verifier_t pair_parent_verifier;        // process id of real process pair parent process
    int  priority;                          // Linux system priority
    int  backup;                            // if non-zero, starts process as backup
    STATE state;                            // process's current state
    bool unhooked;                          // if hooked, parent process dies will trigger child process exits
    bool event_messages;                    // true if want event messages
    bool system_messages;                   // true if want system messages
    long long tag;                          // user defined tag to be sent in completion notice
//    strId_t pathStrId;                      // program lookup path (string id)
//    strId_t ldpathStrId;                    // library load path (string id)
//    strId_t programStrId;                   // full path to object file (string id)
    char path[MAX_SEARCH_PATH];             // process's object lookup path to program
    char ldpath[MAX_SEARCH_PATH];           // process's library load path for program
    char program[MAX_PROCESS_PATH];         // program file name
    char port_name[MPI_MAX_PORT_NAME];      // mpi port name from MPI_Open_port
    int  argc;                              // number of additional command line argument
    char argv[MAX_ARGS][MAX_ARG_SIZE];      // array of additional command line arguments
    char infile[MAX_PROCESS_PATH];          // if null then use monitor's infile
    char outfile[MAX_PROCESS_PATH];         // if null then use monitor's outfile
    struct timespec creation_time;          // creation time
    int  return_code;                       // mpi error code of error
};

struct ProcessInfoCont_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    struct                                  // last few process ids returned
    {                                       //    previously
        int  nid;                           // node id
        int  pid;                           // process id
    } context[MAX_PROC_CONTEXT];
    PROCESSTYPE type;                       // Return only processes of this type
    bool allNodes;                          // true if requesting process info on all nodes
};


struct Set_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    Verifier_t verifier;                    // requesting process's verifier
    char process_name[MAX_PROCESS_NAME];    // requesting process's name
    ConfigType type;                        // type of group being set
    char group[MAX_KEY_NAME];               // name of group, if NULL and type=ConfigNode assume local node 
    char key[MAX_KEY_NAME];                 // key name of the item being set
    char value[MAX_VALUE_SIZE];             // value of key
};

struct Shutdown_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    ShutdownLevel level;                    // 0=normal, 1=fast or 2=crash
};

struct ShutdownNs_def
{
    int  nid;                               // requesting process's node id
    int  pid;                               // requesting process id
    ShutdownLevel level;                    // 0=normal, 1=fast or 2=crash
};

struct SpareUp_def
{
    int  pnid;
    char node_name[MPI_MAX_PROCESSOR_NAME];
};

struct Startup_def
{
    int   nid;                              // process's node id argv[3] or -1 for attach
    int   pid;                              // process's process id argv[4] or -1 for attach
    int   os_pid;                           // process's native OS process id
    char  process_name[MAX_PROCESS_NAME];   // process's name argv[5] or assign for attach, "" will autogenerate name
    char  port_name[MPI_MAX_PORT_NAME];     // mpi port name from MPI_Open_port
    char  program[MAX_PROCESS_PATH];        // process's object filename
    bool  event_messages;                   // true if want event messages
    bool  system_messages;                  // true if want system messages
    bool  paired;                           // true if should pair with name process
    Verifier_t  verifier;                   // process's verifier
    int   startup_size;                     // size of this struct
};

struct Startup_reply_def
{
    int nid;                                // target process's node id
    int pid;                                // target process's process id
    Verifier_t  verifier;                   // process's verifier
    int   startup_size;                     // size of this struct
    int return_code;                        // error returned to sender
    char process_name[MAX_PROCESS_NAME];    // Name of target process
    char fifo_stdin  [MAX_PROCESS_PATH];
    char fifo_stdout [MAX_PROCESS_PATH];
    char fifo_stderr [MAX_PROCESS_PATH];
};

struct TmLeader_def
{
    int nid;                                // Requesting TM's node id
    int pid;                                // Requesting TM's process id
};

struct TmReady_def
{
    int nid;                                // Requesting TM's node id
    int pid;                                // Requesting TM's process id
};

struct ZoneInfo_def
{
    int nid;                                // node id of requesting process
    int pid;                                // process id of requesting process
    int target_nid;                         // get zone information via node id (-1 for all)
    int target_zid;                         // get zone information via zone id (-1 for all)
    int last_nid;                           // Last Logical Node ID returned
    int last_pnid;                          // Last Physical Node ID returned
    bool continuation;                      // true if continuation of earlier request
};

struct ZoneInfo_reply_def
{
    int num_nodes;                          // Number of logical nodes in the cluster
    int num_returned;                       // Number of node entries returned
    struct
    {
        int      nid;                       // Logical Node's ID 
        int      zid;                       // Logical Node's Zone ID 
        int      pnid;                      // Node's Physical ID 
        STATE    pstate;                    // Physical Node's state (i.e. UP, DOWN, STOPPING)
        char     node_name[MPI_MAX_PROCESSOR_NAME]; // Node's name
    } node[MAX_NODE_LIST];
    int return_code;                        // error returned to sender
    int last_nid;                           // Last Logical Node ID returned
    int last_pnid;                          // Last Physical Node ID returned
    bool continuation;                      // true if continuation of earlier request
};

struct request_def
{
    REQTYPE type;
    union
    {
        struct Change_def            change;
        struct Close_def             close;
        struct ProcessDeath_def      death;
        struct DelProcessNs_def      del_process_ns;
        struct NodeDown_def          down;
        struct Dump_def              dump;
        struct Event_def             event;
        struct Event_Notice_def      event_notice;
        struct Exit_def              exit;
        struct Get_def               get;
        struct InstanceId_def        instance_id;
        struct Mount_def             mount;
        struct Kill_def              kill;
        struct NameServerAdd_def     nameserver_add;
        struct NameServerDelete_def  nameserver_delete;
        struct NameServerStart_def   nameserver_start;
        struct NameServerStop_def    nameserver_stop;
        struct NewProcess_def        new_process;
        struct NewProcessNs_def      new_process_ns;
        struct NodeAdd_def           node_add;
        struct NodeAdded_def         node_added;
        struct NodeChanged_def       node_changed;
        struct NodeDelete_def        node_delete;
        struct NodeDeleted_def       node_deleted;
        struct NodeInfo_def          node_info;
        struct NodeName_def          nodename;
        struct Notify_def            notify;
        struct Open_def              open;
        struct OpenInfo_def          open_info;
        struct NewProcess_Notice_def process_created;
        struct ProcessInfo_def       process_info;
        struct ProcessInfoCont_def   process_info_cont;
        struct Set_def               set;
        struct Shutdown_def          shutdown;
        struct ShutdownNs_def        shutdown_ns;
        struct Startup_def           startup;
        struct TmLeader_def          leader;
        struct TmReady_def           tm_ready;
        struct NodeUp_def            up;
        struct NodeQuiesce_def       quiesce;
        struct NodePrepare_def       prepare;
        struct ZoneInfo_def          zone_info;
        struct NodeJoining_def       joining;
        struct PNodeInfo_def         pnode_info;
        struct SpareUp_def           spare_up;
        struct NodeReInt_def         reintegrate;
    } u;
};

struct reply_def
{
    REPLYTYPE type;
    union
    {
        struct DelProcessNs_reply_def  del_process_ns;
        struct Dump_reply_def          dump;
        struct Generic_reply_def       generic;
        struct Get_reply_def           get;
        struct InstanceId_reply_def    instance_id;
        struct Mount_reply_def         mount;
        struct NewProcess_reply_def    new_process;
        struct NewProcessNs_reply_def  new_process_ns;
        struct NodeInfo_reply_def      node_info;
        struct Open_reply_def          open;
        struct OpenInfo_reply_def      open_info;
        struct PNodeInfo_reply_def     pnode_info;
        struct ProcessInfo_reply_def   process_info;
        struct ProcessInfoNs_reply_def process_info_ns;
        struct Startup_reply_def       startup_info;
        int                            tm_seqnum;
        struct Close_reply_def         close;
        struct MonStats_reply_def      mon_info;
        struct ZoneInfo_reply_def      zone_info;
        struct NodeName_reply_def      nodename;
    } u;
};

struct message_def
{
    MSGTYPE type;
    bool noreply; // true if the receiving process is not to send reply.
    int reply_tag;
    union
    {
        struct request_def  request;
        struct reply_def    reply;
    } u;
};

#endif /*MSGDEF_H_*/