src/srfsh/srfsh.c

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