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 #include <signal.h>
   8
   9 #include <stdio.h>
  10 #include <readline/readline.h>
  11 #include <readline/history.h>
  12
  13
  14 #define SRFSH_PORT 5222
  15 #define COMMAND_BUFSIZE 12
  16
  17 /* shell prompt */
  18 char* prompt = "srfsh# ";
  19
  20 int child_dead = 0;
  21
  22 /* our jabber connection */
  23 transport_client* client = NULL;
  24
  25 /* the last result we received */
  26 osrf_message* last_result = NULL;
  27
  28 /* functions */
  29 int parse_request( char* request );
  30 int handle_router( char* words[] );
  31 int handle_time( char* words[] );
  32 int handle_request( char* words[], int relay );
  33 int handle_exec(char* words[]);
  34 int send_request( char* server,
  35                 char* method, growing_buffer* buffer, int relay );
  36 int parse_error( char* words[] );
  37 int router_query_servers( char* server );
  38 int srfsh_client_connect();
  39 int print_help();
  40 char* json_printer( json* object );
  41 char* tabs(int count);
  42 /* --------- */
  43 void sig_child_handler( int s );
  44
  45
  46
  47
  48 int main( int argc, char* argv[] ) {
  49
  50
  51         if( argc < 2 ) {
  52
  53                 /* see if they have a .srfsh.xml in their home directory */
  54                 char* home = getenv("HOME");
  55                 int l = strlen(home) + 36;
  56                 char fbuf[l];
  57                 memset(fbuf, 0, l);
  58                 sprintf(fbuf,"%s/.srfsh.xml",home);
  59
  60                 if(!access(fbuf, F_OK)) {
  61                         if( ! osrf_system_bootstrap_client(fbuf) )
  62                                 fatal_handler( "Unable to bootstrap client for requests");
  63
  64                 } else {
  65                         fatal_handler( "No Config file found at %s and none specified. "
  66                                         "\nusage: %s <config_file>", fbuf, argv[0] );
  67                 }
  68
  69         } else {
  70                 if( ! osrf_system_bootstrap_client(argv[1]) )
  71                         fatal_handler( "Unable to bootstrap client for requests");
  72         }
  73
  74         client = osrf_system_get_transport_client();
  75
  76
  77         /* main process loop */
  78         char* request;
  79         while((request=readline(prompt))) {
  80
  81                 if( !strcmp(request, "exit") || !strcmp(request,"quit"))
  82                         break;
  83
  84                 char* req_copy = strdup(request);
  85
  86                 if(parse_request( req_copy ) )
  87                         add_history(request);
  88
  89                 free(request);
  90                 free(req_copy);
  91         }
  92
  93         free(request);
  94         client_disconnect( client );
  95         client_free( client );
  96         config_reader_free();
  97         log_free();
  98
  99         return 0;
 100 }
 101
 102 void sig_child_handler( int s ) {
 103         child_dead = 1;
 104 }
 105
 106 int parse_error( char* words[] ) {
 107
 108         if( ! words )
 109                 return 0;
 110
 111         int i = 0;
 112         char* current;
 113         char buffer[256];
 114         memset(buffer, 0, 256);
 115         while( (current=words[i++]) ) {
 116                 strcat(buffer, current);
 117                 strcat(buffer, " ");
 118         }
 119         if( ! buffer || strlen(buffer) < 1 )
 120                 printf("\n");
 121
 122         fprintf( stderr, "Command Incomplete or Not Recognized: %s\n", buffer );
 123         return 0;
 124
 125 }
 126
 127
 128 int parse_request( char* request ) {
 129
 130         if( request == NULL )
 131                 return 0;
 132
 133         int ret_val = 0;
 134         int i = 0;
 135         char* words[COMMAND_BUFSIZE];
 136         memset(words,0,COMMAND_BUFSIZE);
 137         char* req = request;
 138
 139         char* cur_tok = strtok( req, " " );
 140
 141         if( cur_tok == NULL )
 142                 return 0;
 143
 144         while(cur_tok != NULL) {
 145                 words[i++] = cur_tok;
 146                 cur_tok = strtok( NULL, " " );
 147         }
 148
 149
 150         // not sure why (strtok?), but this is necessary
 151         memset( words + i, 0, COMMAND_BUFSIZE - i );
 152
 153         /* pass off to the top level command */
 154         if( !strcmp(words[0],"router") )
 155                 ret_val = handle_router( words );
 156
 157         else if( !strcmp(words[0],"time") )
 158                 ret_val = handle_time( words );
 159
 160         else if (!strcmp(words[0],"request"))
 161                 ret_val = handle_request( words, 0 );
 162
 163         else if (!strcmp(words[0],"relay"))
 164                 ret_val = handle_request( words, 1 );
 165
 166         else if (!strcmp(words[0],"help"))
 167                 ret_val = print_help();
 168
 169         else if (words[0][0] == '!')
 170                 ret_val = handle_exec( words );
 171
 172         if(!ret_val)
 173                 return parse_error( words );
 174
 175         return 1;
 176
 177 }
 178
 179
 180 int handle_router( char* words[] ) {
 181
 182         if(!client)
 183                 return 1;
 184
 185         int i;
 186
 187         if( words[1] ) {
 188                 if( !strcmp(words[1],"query") ) {
 189
 190                         if( words[2] && !strcmp(words[2],"servers") ) {
 191                                 for(i=3; i < COMMAND_BUFSIZE - 3 && words[i]; i++ ) {
 192                                         router_query_servers( words[i] );
 193                                 }
 194                                 return 1;
 195                         }
 196                         return 0;
 197                 }
 198                 return 0;
 199         }
 200         return 0;
 201 }
 202
 203
 204 int handle_exec(char* words[]) {
 205
 206         int len = strlen(words[0]);
 207         char command[len];
 208         memset(command,0,len);
 209
 210         int i; /* chop out the ! */
 211         for( i=1; i!= len; i++) {
 212                 command[i-1] = words[0][i];
 213         }
 214
 215         free(words[0]);
 216         words[0] = strdup(command);
 217         signal(SIGCHLD,sig_child_handler);
 218         if(fork()) {
 219                 while(1) {
 220                         sleep(100);
 221                         if(child_dead) {
 222                                 signal(SIGCHLD,sig_child_handler);
 223                                 child_dead = 0;
 224                                 break;
 225                         }
 226                 }
 227         } else {
 228                 execvp( words[0], words );
 229         }
 230         return 1;
 231 }
 232
 233
 234 int handle_request( char* words[], int relay ) {
 235
 236         if(!client)
 237                 return 1;
 238
 239         if(words[1]) {
 240                 char* server = words[1];
 241                 char* method = words[2];
 242                 int i;
 243                 growing_buffer* buffer = NULL;
 244                 if(!relay) {
 245                         buffer = buffer_init(128);
 246                         buffer_add(buffer, "[");
 247                         for(i = 3; words[i] != NULL; i++ ) {
 248                                 buffer_add( buffer, words[i] );
 249                                 buffer_add(buffer, " ");
 250                         }
 251                         buffer_add(buffer, "]");
 252                 }
 253
 254                 return send_request( server, method, buffer, relay );
 255         }
 256
 257         return 0;
 258 }
 259
 260 int send_request( char* server,
 261                 char* method, growing_buffer* buffer, int relay ) {
 262         if( server == NULL || method == NULL )
 263                 return 0;
 264
 265         json* params = NULL;
 266         if( !relay ) {
 267                 if( buffer != NULL && buffer->n_used > 0 )
 268                         params = json_tokener_parse(buffer->buf);
 269         } else {
 270                 if(!last_result->result_content)
 271                         warning_handler("Calling 'relay' on empty result");
 272                 else
 273                         params = last_result->result_content;
 274         }
 275
 276         osrf_app_session* session = osrf_app_client_session_init(server);
 277         double start = get_timestamp_millis();
 278
 279         if(!osrf_app_session_connect(session)) {
 280                 warning_handler( "Unable to connect to remote service %s\n", server );
 281                 return 1;
 282         }
 283
 284         //char* string2 = json_printer( params );
 285         //json* object = json_tokener_parse( string2 );
 286         //free(string2);
 287
 288         int req_id = osrf_app_session_make_request( session, params, method, 1 );
 289
 290         osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 8 );
 291
 292         if(!omsg)
 293                 printf("\nReceived no data from server\n");
 294
 295
 296         while(omsg) {
 297                 if(omsg->result_content) {
 298                         osrf_message_free(last_result);
 299                         last_result = omsg;
 300
 301                         char* content = json_printer( omsg->result_content );
 302                         printf( "\nReceived Data: %s\n",content );
 303                         free(content);
 304                 }
 305                 else {
 306                         printf( "\nReceived Exception:\nName: %s\nStatus: "
 307                                         "%s\nStatusCode %d\n", omsg->status_name,
 308                                         omsg->status_text, omsg->status_code );
 309                 }
 310
 311                 omsg = osrf_app_session_request_recv( session, req_id, 5 );
 312         }
 313
 314         double end = get_timestamp_millis();
 315
 316         printf("\n------------------------------------\n");
 317         if( osrf_app_session_request_complete( session, req_id ))
 318                 printf("Request Completed Successfully\n");
 319
 320
 321         printf("Request Time in seconds: %f\n", end - start );
 322         printf("------------------------------------\n");
 323
 324         osrf_app_session_request_finish( session, req_id );
 325         osrf_app_session_disconnect( session );
 326         osrf_app_session_destroy( session );
 327
 328         return 1;
 329
 330
 331 }
 332
 333 int handle_time( char* words[] ) {
 334
 335         if( ! words[1] ) {
 336
 337                 char buf[36];
 338                 memset(buf,0,36);
 339                 get_timestamp(buf);
 340                 printf( "%s\n", buf );
 341                 return 1;
 342         }
 343
 344         if( words[1] ) {
 345                 time_t epoch = (time_t)atoi( words[1] );
 346                 char* localtime = strdup( ctime( &epoch ) );
 347                 printf( "%s => %s", words[1], localtime );
 348                 free(localtime);
 349                 return 1;
 350         }
 351
 352         return 0;
 353
 354 }
 355
 356
 357
 358 int router_query_servers( char* router_server ) {
 359
 360         if( ! router_server || strlen(router_server) == 0 )
 361                 return 0;
 362
 363         char rbuf[256];
 364         memset(rbuf,0,256);
 365         sprintf(rbuf,"router@%s/router", router_server );
 366
 367         transport_message* send =
 368                 message_init( "servers", NULL, NULL, rbuf, NULL );
 369         message_set_router_info( send, NULL, NULL, NULL, "query", 0 );
 370
 371         client_send_message( client, send );
 372         message_free( send );
 373
 374         transport_message* recv = client_recv( client, -1 );
 375         if( recv == NULL ) {
 376                 fprintf(stderr, "NULL message received from router\n");
 377                 return 1;
 378         }
 379
 380         printf(
 381                         "---------------------------------------------------------------------------------\n"
 382                         "Received from 'server' query on %s\n"
 383                         "---------------------------------------------------------------------------------\n"
 384                         "original reg time | latest reg time | last used time | class | server\n"
 385                         "---------------------------------------------------------------------------------\n"
 386                         "%s"
 387                         "---------------------------------------------------------------------------------\n"
 388                         , router_server, recv->body );
 389
 390         message_free( recv );
 391
 392         return 1;
 393 }
 394
 395 int print_help() {
 396
 397         printf(
 398                         "---------------------------------------------------------------------------------\n"
 399                         "Commands:\n"
 400                         "---------------------------------------------------------------------------------\n"
 401                         "help                   - Display this message\n"
 402                         "!<command> [args] - Forks and runs the given command in the shell\n"
 403                         "time                   - Prints the current time\n"
 404                         "time <timestamp>       - Formats seconds since epoch into readable format\n"
 405                         "---------------------------------------------------------------------------------\n"
 406                         "router query servers <server1 [, server2, ...]>\n"
 407                         "       - Returns stats on connected services\n"
 408                         "\n"
 409                         "reqeust <service> <method> [ <json formatted string of params> ]\n"
 410                         "       - Anything passed in will be wrapped in a json array,\n"
 411                         "               so add commas if there is more than one param\n"
 412                         "---------------------------------------------------------------------------------\n"
 413                         );
 414
 415         return 1;
 416 }
 417
 418
 419
 420 char* tabs(int count) {
 421         growing_buffer* buf = buffer_init(24);
 422         int i;
 423         for(i=0;i!=count;i++)
 424                 buffer_add(buf, "   ");
 425
 426         char* final = buffer_data( buf );
 427         buffer_free( buf );
 428         return final;
 429 }
 430
 431 char* json_printer( json* object ) {
 432
 433         if(object == NULL)
 434                 return NULL;
 435         char* string = json_object_to_json_string(object);
 436
 437         growing_buffer* buf = buffer_init(64);
 438         int i;
 439         int tab_var = 0;
 440         for(i=0; i!= strlen(string); i++) {
 441
 442                 if( string[i] == '{' ) {
 443
 444                         buffer_add(buf, "\n");
 445                         char* tab = tabs(tab_var);
 446                         buffer_add(buf, tab);
 447                         free(tab);
 448                         buffer_add( buf, "{");
 449                         tab_var++;
 450                         buffer_add( buf, "\n" );
 451                         tab = tabs(tab_var);
 452                         buffer_add( buf, tab );
 453                         free(tab);
 454
 455                 } else if( string[i] == '[' ) {
 456
 457                         buffer_add(buf, "\n");
 458                         char* tab = tabs(tab_var);
 459                         buffer_add(buf, tab);
 460                         free(tab);
 461                         buffer_add( buf, "[");
 462                         tab_var++;
 463                         buffer_add( buf, "\n" );
 464                         tab = tabs(tab_var);
 465                         buffer_add( buf, tab );
 466                         free(tab);
 467
 468                 } else if( string[i] == '}' ) {
 469
 470                         tab_var--;
 471                         buffer_add(buf, "\n");
 472                         char* tab = tabs(tab_var);
 473                         buffer_add(buf, tab);
 474                         free(tab);
 475                         buffer_add( buf, "}");
 476                         buffer_add( buf, "\n" );
 477                         tab = tabs(tab_var);
 478                         buffer_add( buf, tab );
 479                         free(tab);
 480
 481                 } else if( string[i] == ']' ) {
 482
 483                         tab_var--;
 484                         buffer_add(buf, "\n");
 485                         char* tab = tabs(tab_var);
 486                         buffer_add(buf, tab);
 487                         free(tab);
 488                         buffer_add( buf, "]");
 489                         buffer_add( buf, "\n" );
 490                         tab = tabs(tab_var);
 491                         buffer_add( buf, tab );
 492                         free(tab);
 493
 494                 } else {
 495                         char b[2];
 496                         b[0] = string[i];
 497                         b[1] = '\0';
 498                         buffer_add( buf, b );
 499                 }
 500
 501         }
 502
 503         char* result = buffer_data(buf);
 504         buffer_free(buf);
 505         return result;
 506
 507 }