OpenSRF/src/srfsh/srfsh.c

   1 #include "opensrf/transport_client.h"
   2 #include "opensrf/generic_utils.h"
   3 #include "opensrf/osrf_message.h"
   4 #include "opensrf/osrf_app_session.h"
   5 #include <time.h>
   6
   7 #define SRFSH_PORT 5222
   8 #define COMMAND_BUFSIZE 12
   9
  10
  11 char* prompt = "srfsh# ";
  12 char* last_request;
  13 transport_client* client = NULL;
  14
  15 int parse_request( char* request );
  16 int handle_router( char* words[] );
  17 int handle_time( char* words[] );
  18 int handle_request( char* words[] );
  19 int send_request( char* server, char* method, growing_buffer* buffer );
  20 int parse_error( char* words[] );
  21 int router_query_servers( char* server );
  22 int srfsh_client_connect();
  23 void print_help();
  24 char* json_printer( json* object );
  25 char* tabs(int count);
  26
  27 int main( int argc, char* argv[] ) {
  28
  29
  30         if( argc < 2 )
  31                 fatal_handler( "usage: %s <config_file>", argv[0] );
  32
  33         config_reader_init( "opensrf", argv[1] );
  34
  35         char request[256];
  36         memset(request, 0, 256);
  37         printf(prompt);
  38
  39         if( ! osrf_system_bootstrap_client("srfsh.xml") )
  40                 fprintf( stderr, "Unable to bootstrap client for requests\n");
  41
  42
  43         client = osrf_system_get_transport_client();
  44
  45         while( fgets( request, 255, stdin) ) {
  46
  47                 // remove newline
  48                 request[strlen(request)-1] = '\0';
  49
  50                 if( !strcmp(request, "exit") || !strcmp(request,"quit")) {
  51                         client_disconnect( client );
  52                         client_free( client );
  53                         break;
  54                 }
  55
  56                 if(!strcmp(request,"last")) {
  57                         if(last_request) {
  58                                 memset(request,0,256);
  59                                 strcpy(request, last_request);
  60                                 printf("%s\n", request);
  61                         } else {
  62                                 printf(prompt);
  63                                 continue;
  64                         }
  65                 }
  66
  67                 char* req_copy = strdup(request);
  68
  69                 if( !strcmp(request, "help") || !strcmp(request,"?"))
  70                         print_help();
  71                 else {
  72                         if(parse_request( req_copy ) && strcmp(request,"last") ) {
  73                                 free(last_request);
  74                                 last_request = strdup(request);
  75                         }
  76                 }
  77
  78
  79                 printf(prompt);
  80                 memset(request, 0, 300);
  81                 free(req_copy);
  82         }
  83
  84         fprintf(stderr, "Exiting...\n[Ignore Segfault :)]\n");
  85
  86         config_reader_free();
  87         log_free();
  88
  89         return 0;
  90 }
  91
  92
  93 int parse_error( char* words[] ) {
  94
  95         if( ! words )
  96                 return 0;
  97
  98         int i = 0;
  99         char* current;
 100         char buffer[256];
 101         memset(buffer, 0, 256);
 102         while( (current=words[i++]) ) {
 103                 strcat(buffer, current);
 104                 strcat(buffer, " ");
 105         }
 106         if( ! buffer || strlen(buffer) < 1 )
 107                 printf("\n");
 108
 109         fprintf( stderr, "Command Incomplete or Not Recognized: %s\n", buffer );
 110         return 0;
 111
 112 }
 113
 114
 115 int parse_request( char* request ) {
 116
 117         if( request == NULL )
 118                 return 0;
 119
 120         int ret_val = 0;
 121         int i = 0;
 122         char* words[COMMAND_BUFSIZE];
 123         memset(words,0,COMMAND_BUFSIZE);
 124         //char* req = strdup(request);
 125         char* req = request;
 126
 127         char* cur_tok = strtok( req, " " );
 128
 129         if( cur_tok == NULL )
 130                 return 0;
 131
 132         while(cur_tok != NULL) {
 133                 words[i++] = cur_tok;
 134                 cur_tok = strtok( NULL, " " );
 135         }
 136
 137         //free(req);
 138
 139         // not sure why (strtok?), but this is necessary
 140         memset( words + i, 0, COMMAND_BUFSIZE - i );
 141
 142         /* pass off to the top level command */
 143         if( !strcmp(words[0],"router") )
 144                 ret_val = handle_router( words );
 145
 146         else if( !strcmp(words[0],"time") )
 147                 ret_val = handle_time( words );
 148
 149         else if (!strcmp(words[0],"request"))
 150                 ret_val = handle_request( words );
 151
 152         if(!ret_val)
 153                 return parse_error( words );
 154
 155         return 1;
 156
 157 }
 158
 159
 160 int handle_router( char* words[] ) {
 161
 162         if(!client)
 163                 return 1;
 164
 165         int i;
 166
 167         if( words[1] ) {
 168                 if( !strcmp(words[1],"query") ) {
 169
 170                         if( words[2] && !strcmp(words[2],"servers") ) {
 171                                 for(i=3; i < COMMAND_BUFSIZE - 3 && words[i]; i++ ) {
 172                                         router_query_servers( words[i] );
 173                                 }
 174                                 return 1;
 175                         }
 176                         return 0;
 177                 }
 178                 return 0;
 179         }
 180         return 0;
 181 }
 182
 183 int handle_request( char* words[] ) {
 184
 185         if(!client)
 186                 return 1;
 187
 188         if(words[1]) {
 189                 char* server = words[1];
 190                 char* method = words[2];
 191                 int i;
 192                 growing_buffer* buffer = buffer_init(128);
 193
 194                 buffer_add(buffer, "[");
 195                 for(i = 3; words[i] != NULL; i++ ) {
 196                         buffer_add( buffer, words[i] );
 197                         buffer_add(buffer, " ");
 198                 }
 199                 buffer_add(buffer, "]");
 200
 201                 return send_request( server, method, buffer );
 202         }
 203
 204         return 0;
 205 }
 206
 207 int send_request( char* server, char* method, growing_buffer* buffer ) {
 208         if( server == NULL || method == NULL )
 209                 return 0;
 210
 211         json* params = NULL;
 212         if( buffer != NULL && buffer->n_used > 0 )
 213                 params = json_tokener_parse(buffer->buf);
 214
 215         osrf_app_session* session = osrf_app_client_session_init(server);
 216         double start = get_timestamp_millis();
 217
 218         if(!osrf_app_session_connect(session)) {
 219                 warning_handler( "Unable to connect to remote service %s\n", server );
 220                 return 1;
 221         }
 222
 223         int req_id = osrf_app_session_make_request( session, params, method, 1 );
 224
 225         osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 8 );
 226
 227         if(!omsg)
 228                 printf("Received no data from server\n");
 229
 230
 231         while(omsg) {
 232                 if(omsg->result_content) {
 233                         char* content = json_printer( omsg->result_content );
 234                         printf( "Received Data: %s\n",content );
 235                         free(content);
 236                 }
 237                 else
 238                         printf( "Received Message but no result data\n");
 239
 240                 osrf_message_free(omsg);
 241                 omsg = osrf_app_session_request_recv( session, req_id, 5 );
 242         }
 243
 244
 245         if( osrf_app_session_request_complete( session, req_id ))
 246                 printf("[Request Completed Successfully]\n");
 247
 248         double end = get_timestamp_millis();
 249
 250         printf("Request Time in seconds: %f\n", end - start );
 251
 252         osrf_app_session_disconnect( session );
 253
 254         return 1;
 255
 256
 257 }
 258
 259 int handle_time( char* words[] ) {
 260
 261         if( ! words[1] ) {
 262
 263                 char buf[36];
 264                 memset(buf,0,36);
 265                 get_timestamp(buf);
 266                 printf( "%s\n", buf );
 267                 return 1;
 268         }
 269
 270         if( words[1] ) {
 271                 time_t epoch = (time_t)atoi( words[1] );
 272                 char* localtime = strdup( ctime( &epoch ) );
 273                 printf( "%s => %s", words[1], localtime );
 274                 free(localtime);
 275                 return 1;
 276         }
 277
 278         return 0;
 279
 280 }
 281
 282
 283
 284 int router_query_servers( char* router_server ) {
 285
 286         if( ! router_server || strlen(router_server) == 0 )
 287                 return 0;
 288
 289         char rbuf[256];
 290         memset(rbuf,0,256);
 291         sprintf(rbuf,"router@%s/router", router_server );
 292
 293         transport_message* send =
 294                 message_init( "servers", NULL, NULL, rbuf, NULL );
 295         message_set_router_info( send, NULL, NULL, NULL, "query", 0 );
 296
 297         client_send_message( client, send );
 298         message_free( send );
 299
 300         transport_message* recv = client_recv( client, -1 );
 301         if( recv == NULL )
 302                 fprintf(stderr, "NULL message received from router\n");
 303
 304         printf(
 305                         "---------------------------------------------------------------------------------\n"
 306                         "Received from 'server' query on %s\n"
 307                         "---------------------------------------------------------------------------------\n"
 308                         "original reg time | latest reg time | last used time | class | server\n"
 309                         "---------------------------------------------------------------------------------\n"
 310                         "%s"
 311                         "---------------------------------------------------------------------------------\n"
 312                         , router_server, recv->body );
 313
 314         message_free( recv );
 315
 316         return 1;
 317 }
 318
 319 void print_help() {
 320
 321         printf(
 322                         "---------------------------------------------------------------------------------\n"
 323                         "Commands:\n"
 324                         "---------------------------------------------------------------------------------\n"
 325                         "help                   - Display this message\n"
 326                         "last                   - Re-performs the last command\n"
 327                         "time                   - Prints the current time\n"
 328                         "time <timestamp>       - Formats seconds since epoch into readable format\n"
 329                         "---------------------------------------------------------------------------------\n"
 330                         "router query servers <server1 [, server2, ...]>\n"
 331                         "       - Returns stats on connected services\n"
 332                         "reqeust <service> <method> [ <json formatted string of params> ]\n"
 333                         "       - Anything passed in will be wrapped in a json array\n"
 334                         "---------------------------------------------------------------------------------\n"
 335                         );
 336
 337 }
 338
 339
 340
 341 char* tabs(int count) {
 342         growing_buffer* buf = buffer_init(24);
 343         int i;
 344         for(i=0;i!=count;i++)
 345                 buffer_add(buf, "   ");
 346
 347         char* final = buffer_data( buf );
 348         buffer_free( buf );
 349         return final;
 350 }
 351
 352 char* json_printer( json* object ) {
 353
 354         if(object == NULL)
 355                 return NULL;
 356         char* string = json_object_to_json_string(object);
 357
 358         growing_buffer* buf = buffer_init(64);
 359         int i;
 360         int tab_var = 0;
 361         for(i=0; i!= strlen(string); i++) {
 362
 363                 if( string[i] == '{' ) {
 364
 365                         buffer_add(buf, "\n");
 366                         char* tab = tabs(tab_var);
 367                         buffer_add(buf, tab);
 368                         free(tab);
 369                         buffer_add( buf, "{");
 370                         tab_var++;
 371                         buffer_add( buf, "\n" );
 372                         tab = tabs(tab_var);
 373                         buffer_add( buf, tab );
 374                         free(tab);
 375
 376                 } else if( string[i] == '[' ) {
 377
 378                         buffer_add(buf, "\n");
 379                         char* tab = tabs(tab_var);
 380                         buffer_add(buf, tab);
 381                         free(tab);
 382                         buffer_add( buf, "[");
 383                         tab_var++;
 384                         buffer_add( buf, "\n" );
 385                         tab = tabs(tab_var);
 386                         buffer_add( buf, tab );
 387                         free(tab);
 388
 389                 } else if( string[i] == '}' ) {
 390
 391                         tab_var--;
 392                         buffer_add(buf, "\n");
 393                         char* tab = tabs(tab_var);
 394                         buffer_add(buf, tab);
 395                         free(tab);
 396                         buffer_add( buf, "}");
 397                         buffer_add( buf, "\n" );
 398                         tab = tabs(tab_var);
 399                         buffer_add( buf, tab );
 400                         free(tab);
 401
 402                 } else if( string[i] == ']' ) {
 403
 404                         tab_var--;
 405                         buffer_add(buf, "\n");
 406                         char* tab = tabs(tab_var);
 407                         buffer_add(buf, tab);
 408                         free(tab);
 409                         buffer_add( buf, "]");
 410                         buffer_add( buf, "\n" );
 411                         tab = tabs(tab_var);
 412                         buffer_add( buf, tab );
 413                         free(tab);
 414
 415                 } else {
 416                         char b[2];
 417                         b[0] = string[i];
 418                         b[1] = '\0';
 419                         buffer_add( buf, b );
 420                 }
 421
 422         }
 423
 424         char* result = buffer_data(buf);
 425         buffer_free(buf);
 426         return result;
 427
 428 }