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
  25 int main( int argc, char* argv[] ) {
  26
  27
  28         if( argc < 5 )
  29                 fatal_handler( "usage: %s <jabbersever> <username> <password> <config_file>", argv[0] );
  30
  31         config_reader_init( "opensrf", argv[4] );
  32
  33         char request[256];
  34         memset(request, 0, 256);
  35         printf(prompt);
  36
  37         client = client_init( argv[1], SRFSH_PORT, 0 );
  38         if( ! client_connect( client, argv[2], argv[3], "srfsh", 5, AUTH_DIGEST ) ) {
  39                 fprintf(stderr, "Unable to connect to jabber server '%s' as '%s'\n", argv[1], argv[2]);
  40                 fprintf(stderr, "Most queries will be futile...\n" );
  41         }
  42
  43         if( ! osrf_system_bootstrap_client("srfsh.xml") )
  44                 fprintf( stderr, "Unable to bootstrap client for requests\n");
  45
  46
  47         while( fgets( request, 255, stdin) ) {
  48
  49                 // remove newline
  50                 request[strlen(request)-1] = '\0';
  51
  52                 if( !strcmp(request, "exit") || !strcmp(request,"quit")) {
  53                         client_disconnect( client );
  54                         client_free( client );
  55                         break;
  56                 }
  57
  58                 if(!strcmp(request,"last")) {
  59                         if(last_request) {
  60                                 memset(request,0,256);
  61                                 strcpy(request, last_request);
  62                                 printf("%s\n", request);
  63                         } else {
  64                                 printf(prompt);
  65                                 continue;
  66                         }
  67                 }
  68
  69                 char* req_copy = strdup(request);
  70
  71                 if( !strcmp(request, "help") || !strcmp(request,"?"))
  72                         print_help();
  73                 else {
  74                         if(parse_request( req_copy ) && strcmp(request,"last") ) {
  75                                 free(last_request);
  76                                 last_request = strdup(request);
  77                         }
  78                 }
  79
  80
  81                 printf(prompt);
  82                 memset(request, 0, 300);
  83                 free(req_copy);
  84         }
  85
  86         fprintf(stderr, "Exiting...\n[Ignore Segfault]\n");
  87
  88         config_reader_free();
  89         log_free();
  90
  91         return 0;
  92 }
  93
  94
  95 int parse_error( char* words[] ) {
  96
  97         if( ! words )
  98                 return 0;
  99
 100         int i = 0;
 101         char* current;
 102         char buffer[256];
 103         memset(buffer, 0, 256);
 104         while( (current=words[i++]) ) {
 105                 strcat(buffer, current);
 106                 strcat(buffer, " ");
 107         }
 108         if( ! buffer || strlen(buffer) < 1 )
 109                 printf("\n");
 110
 111         fprintf( stderr, "Command Incomplete or Not Recognized: %s\n", buffer );
 112         return 0;
 113
 114 }
 115
 116
 117 int parse_request( char* request ) {
 118
 119         if( request == NULL )
 120                 return 0;
 121
 122         int ret_val = 0;
 123         int i = 0;
 124         char* words[COMMAND_BUFSIZE];
 125         memset(words,0,COMMAND_BUFSIZE);
 126         //char* req = strdup(request);
 127         char* req = request;
 128
 129         char* cur_tok = strtok( req, " " );
 130
 131         if( cur_tok == NULL )
 132                 return 0;
 133
 134         while(cur_tok != NULL) {
 135                 words[i++] = cur_tok;
 136                 cur_tok = strtok( NULL, " " );
 137         }
 138
 139         //free(req);
 140
 141         // not sure why (strtok?), but this is necessary
 142         memset( words + i, 0, COMMAND_BUFSIZE - i );
 143
 144         /* pass off to the top level command */
 145         if( !strcmp(words[0],"router") )
 146                 ret_val = handle_router( words );
 147
 148         else if( !strcmp(words[0],"time") )
 149                 ret_val = handle_time( words );
 150
 151         else if (!strcmp(words[0],"request"))
 152                 ret_val = handle_request( words );
 153
 154         if(!ret_val)
 155                 return parse_error( words );
 156
 157         return 1;
 158
 159 }
 160
 161
 162 int handle_router( char* words[] ) {
 163
 164         if(!client)
 165                 return 1;
 166
 167         int i;
 168
 169         if( words[1] ) {
 170                 if( !strcmp(words[1],"query") ) {
 171
 172                         if( words[2] && !strcmp(words[2],"servers") ) {
 173                                 for(i=3; i < COMMAND_BUFSIZE - 3 && words[i]; i++ ) {
 174                                         router_query_servers( words[i] );
 175                                 }
 176                                 return 1;
 177                         }
 178                         return 0;
 179                 }
 180                 return 0;
 181         }
 182         return 0;
 183 }
 184
 185 int handle_request( char* words[] ) {
 186
 187         if(!client)
 188                 return 1;
 189
 190         if(words[1]) {
 191                 char* server = words[1];
 192                 char* method = words[2];
 193                 int i;
 194                 growing_buffer* buffer = buffer_init(128);
 195
 196                 buffer_add(buffer, "[");
 197                 for(i = 3; words[i] != NULL; i++ ) {
 198                         buffer_add( buffer, words[i] );
 199                         buffer_add(buffer, " ");
 200                 }
 201                 buffer_add(buffer, "]");
 202
 203                 return send_request( server, method, buffer );
 204         }
 205
 206         return 0;
 207 }
 208
 209 int send_request( char* server, char* method, growing_buffer* buffer ) {
 210         if( server == NULL || method == NULL )
 211                 return 0;
 212
 213         json* params = NULL;
 214         if( buffer != NULL && buffer->n_used > 0 )
 215                 params = json_tokener_parse(buffer->buf);
 216
 217         osrf_app_session* session = osrf_app_client_session_init(server);
 218         double start = get_timestamp_millis();
 219
 220         if(!osrf_app_session_connect(session)) {
 221                 warning_handler( "Unable to connect to remote service %s\n", server );
 222                 return 1;
 223         }
 224
 225         int req_id = osrf_app_session_make_request( session, params, method, 1 );
 226
 227         osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 8 );
 228
 229         if(!omsg)
 230                 printf("Received no data from server\n");
 231
 232
 233         while(omsg) {
 234                 if(omsg->result_content)
 235                         printf( "Received Data: %s\n",json_object_to_json_string(omsg->result_content) );
 236                 else
 237                         printf( "Received Message but no result data\n");
 238
 239                 osrf_message_free(omsg);
 240                 omsg = osrf_app_session_request_recv( session, req_id, 5 );
 241         }
 242
 243
 244         if( osrf_app_session_request_complete( session, req_id ))
 245                 printf("[Request Completed Successfully]\n");
 246
 247         double end = get_timestamp_millis();
 248
 249         printf("Request Time in seconds: %f\n", end - start );
 250
 251         osrf_app_session_disconnect( session );
 252
 253         return 1;
 254
 255
 256 }
 257
 258 int handle_time( char* words[] ) {
 259
 260         if( ! words[1] ) {
 261
 262                 char buf[36];
 263                 memset(buf,0,36);
 264                 get_timestamp(buf);
 265                 printf( "%s\n", buf );
 266                 return 1;
 267         }
 268
 269         if( words[1] ) {
 270                 time_t epoch = (time_t)atoi( words[1] );
 271                 char* localtime = strdup( ctime( &epoch ) );
 272                 printf( "%s => %s", words[1], localtime );
 273                 free(localtime);
 274                 return 1;
 275         }
 276
 277         return 0;
 278
 279 }
 280
 281
 282
 283 int router_query_servers( char* router_server ) {
 284
 285         if( ! router_server || strlen(router_server) == 0 )
 286                 return 0;
 287
 288         char rbuf[256];
 289         memset(rbuf,0,256);
 290         sprintf(rbuf,"router@%s/router", router_server );
 291
 292         transport_message* send =
 293                 message_init( "servers", NULL, NULL, rbuf, NULL );
 294         message_set_router_info( send, NULL, NULL, NULL, "query", 0 );
 295
 296         client_send_message( client, send );
 297         message_free( send );
 298
 299         transport_message* recv = client_recv( client, -1 );
 300         if( recv == NULL )
 301                 fprintf(stderr, "NULL message received from router\n");
 302
 303         printf(
 304                         "---------------------------------------------------------------------------------\n"
 305                         "Received from 'server' query on %s\n"
 306                         "---------------------------------------------------------------------------------\n"
 307                         "original reg time | latest reg time | last used time | class | server\n"
 308                         "---------------------------------------------------------------------------------\n"
 309                         "%s"
 310                         "---------------------------------------------------------------------------------\n"
 311                         , router_server, recv->body );
 312
 313         message_free( recv );
 314
 315         return 1;
 316 }
 317
 318 void print_help() {
 319
 320         printf(
 321                         "---------------------------------------------------------------------------------\n"
 322                         "Commands:\n"
 323                         "---------------------------------------------------------------------------------\n"
 324                         "help                   - Display this message\n"
 325                         "last                   - Re-performs the last command\n"
 326                         "time                   - Prints the current time\n"
 327                         "time <timestamp>       - Formats seconds since epoch into readable format\n"
 328                         "---------------------------------------------------------------------------------\n"
 329                         "router query servers <server1 [, server2, ...]>\n"
 330                         "       - Returns stats on connected services\n"
 331                         "reqeust <service> <method> [ <json formatted string of params> ]\n"
 332                         "       - Anything passed in will be wrapped in a json array\n"
 333                         "---------------------------------------------------------------------------------\n"
 334                         );
 335
 336 }