source: tmcsimulator/branches/LinuxBasicFEPClient/fep_client.cpp @ 154

#include "fep.h"
#include <stdio.h>
#include <stdlib.h>
#include "time.h"
#include "network_factory.h"
#include "DataPacker.h"
/* Author: John A. Torres
   The fep_program_32 function creates a new RPC Client which
   sends an fep_reply structure to the ATMS Server. After the
   reply is sent, the ATMS Sends a response and the RPC Client
   is destroyed.
 */

/* Handles the ATMS's response to RPC Call */
void handle_ATMS_response(CLIENT *clnt, void *response)
{
        /* If ATMS reply call fails */
        if (response == NULL)
        {
                clnt_perror(clnt, "RPC call failed");
        }
        /* If ATMS reply is successful */
        else
        {
                printf("Successful RPC call to ATMS...\n");
        }
}

void xfer_replys(CLIENT *clnt, FEP_LINE *lines, int lines_size, STATION *ldsMap)
{
        int i, j; // i == line_index, j == lds_index
        void *rv;

        // Send one reply for every "line" in the FEP
        for (i = 0; i < lines_size; i++)
        {
                fep_reply  fepReply;
                
                // populate reply
                fepReply.reply = SHORTPOLL;
                fepReply.schedule = lines[i].schedule;
                fepReply.lineinfo = lines[i].lineInfo;
                fepReply.kind = (enum polltype) 0;
                fepReply.flag = (enum replykind) 0;
                
                /***********************************
                         This is an update to an extern, this should happen on the Java driver side?? 
                lines[i].schedleSeq += 1;
                lines[i].globalSeq += 51;
                */

                fepReply.schedule_sequence = lines[i].schedleSeq;
                fepReply.global_sequence = lines[i].globalSeq;
                /************************************
                         Need to find out what appropriate schedule time is: look at uci_unix_simulation_time src code          
                fepReply.schedule_time = 
                        uci_unix_simulation_time(uci_simulation_time());        // GMT time
                */
                fepReply.schedule_time = time(NULL);

                fepReply.user_info1 = lines[i].lineNum;
                fepReply.user_info2 = lines[i].lineNum;
                fepReply.system_key = lines[i].systemKey;

                fepReply.answers.size = 1;
                fepReply.answers.fep_answer_list_u.shortp.count = 1;
                
                /* for each LDS in the Line.... (constructs the short_answer message) */
                for (j = 0; j < lines[i].lds.size(); j++)
                {
                        fep_shortanswer fsa;
                        int index = lines[i].ldsIndex[j];

                        // msg: oa, od, ldsMap[index].dataPack, od, ff
                        fsa.msg.message_len = ldsMap[index].length + 2;
                        fsa.msg.message[0] = 0x0d;
                        fsa.msg.message[1] = 0x0a;
                        for (int k = 0; k < ldsMap[index].length; k++)
                                fsa.msg.message[2 + k]  = ldsMap[index].dataPack[k];
                        int aa = ldsMap[index].length;
                        fsa.msg.message[2 + aa] = 0x0d;
                        fsa.msg.message[3 + aa] = 0xff; //????????????? warning ?????

                        // info
                        fsa.info.poll_error_count = 0; 
                        /***************************************
                                 Need to find out polltime uci time function src code
                        fsa.info.poll_time = uci_unix_simulation_time(uci_simulation_time()); 
                        */
                        fsa.info.poll_user_info1 = ldsMap[index].drop;  // drop number
                        fsa.info.poll_user_info2 = 1;   //always 1
                        fsa.info.retries = 0;
                        fsa.info.status = (enum replystatus) 1;
                        
                        //fepReply.answers.fep_answer_list_u.shortp.answers[j] = fsa;   
                        fepReply.answers.fep_answer_list_u.shortp.answers[0] = fsa;     
                        
                        // send out data
                        printf("Transferring line=%d, lds_drop_no=%d...\n", lines[i].lineNum, ldsMap[index].drop);
                        rv = fep_reply_xfer_32(&fepReply, clnt);

                        /* Handle ATMS response to RPC Call */
                        printf("Handling ATMS response...\n");
                        handle_ATMS_response(clnt, rv);
                }
        }               
}

/* Creates an RPC Client which communicates with the ATMS through RPC Calls */
CLIENT * create_client(char *host)
{
        CLIENT *clnt;
        
        /* Create RPC Client to communicate with ATMS */
        printf("Preparing to create RPC client...\n");
        clnt = clnt_create(host, /*100090,*/ 103121, 32, "tcp");

        /* Check if client creation failed */ 
        if (clnt == (CLIENT *) NULL)
        {
                fprintf(stderr, "Can't create client to %s\n", host);
                exit(1);
        }
        
        return clnt;
}

/* update_ATMS transfers fep_replys to the ATMS Server. 
        It creates an RPC client, loads data from line_atms.txt and lds_atms.txt,
        updates the ATMS with the fep_reply data, and destroys the RPC client.
 */
void update_ATMS(char *host)
{
        CLIENT *clnt = create_client(host);
        
        /* Load data to be xfered to ATMS */
        int lines_size = 0;
        printf("Loading lines\n");
        
        NetworkFactory nf;
        FEP_LINE *lines = nf.load_lines(&lines_size, "./lines_atms.txt");
        printf("Loading ldsMap...\n");
        STATION *ldsMap = nf.load_lds("./lds_atms.txt");

        /* Transfer data to ATMS */
        printf("Transferring data to ATMS...\n");
        xfer_replys(clnt, lines, lines_size, ldsMap);

        /* Free allocated memory */
        printf("Freeing lines and ldsMap...\n");
        free(lines);
        free(ldsMap);

        /* Destroy client */
        printf("Destroying client...\n");
        clnt_destroy(clnt);
        printf("Returning to main...\n");
}

/* Main driver function to create an RPC Client, make a single RPC Call to the
   ATMS Server */
int main(int argc, char *argv[]) {
        char *host;

        if (argc < 2)
        {
                printf("usage:  %s server_host\n", argv[0]);
                exit(1);
        }

        /* Create RPC Client to send an fep_reply to ATMS */
        host = argv[1];
        update_ATMS(host);

        return 0;
}