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
  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                         memset(request,0,256);
  60                         strcpy(request, last_request);
  61                         printf("%s\n", request);
  62                 } else {
  63                         free(last_request);
  64                         last_request = strdup(request);
  65                 }
  66
  67                 if( !strcmp(request, "help") || !strcmp(request,"?"))
  68                         print_help();
  69                 else
  70                         parse_request( request );
  71
  72                 printf(prompt);
  73                 memset(request, 0, 300);
  74         }
  75
  76         fprintf(stderr, "Exiting...\n[Ignore Segfault]\n");
  77
  78         config_reader_free();
  79         log_free();
  80
  81         return 0;
  82 }
  83
  84
  85 int parse_error( char* words[] ) {
  86
  87         if( ! words )
  88                 return 0;
  89
  90         int i = 0;
  91         char* current;
  92         char buffer[256];
  93         memset(buffer, 0, 256);
  94         while( (current=words[i++]) ) {
  95                 strcat(buffer, current);
  96                 strcat(buffer, " ");
  97         }
  98         if( ! buffer || strlen(buffer) < 1 )
  99                 printf("\n");
 100
 101         fprintf( stderr, "Command Incomplete or Not Recognized: %s\n", buffer );
 102         return 0;
 103
 104 }
 105
 106
 107 int parse_request( char* request ) {
 108
 109         if( request == NULL )
 110                 return 0;
 111
 112         int ret_val = 0;
 113         int i = 0;
 114         char* words[COMMAND_BUFSIZE];
 115         memset(words,0,COMMAND_BUFSIZE);
 116         //char* req = strdup(request);
 117         char* req = request;
 118
 119         char* cur_tok = strtok( req, " " );
 120
 121         if( cur_tok == NULL )
 122                 return 0;
 123
 124         while(cur_tok != NULL) {
 125                 words[i++] = cur_tok;
 126                 cur_tok = strtok( NULL, " " );
 127         }
 128
 129         //free(req);
 130
 131         // not sure why (strtok?), but this is necessary
 132         memset( words + i, 0, COMMAND_BUFSIZE - i );
 133
 134         /* pass off to the top level command */
 135         if( !strcmp(words[0],"router") )
 136                 ret_val = handle_router( words );
 137
 138         else if( !strcmp(words[0],"time") )
 139                 ret_val = handle_time( words );
 140
 141         else if (!strcmp(words[0],"request"))
 142                 ret_val = handle_request( words );
 143
 144         if(!ret_val)
 145                 return parse_error( words );
 146
 147         return 1;
 148
 149 }
 150
 151
 152 int handle_router( char* words[] ) {
 153
 154         if(!client)
 155                 return 1;
 156
 157         int i;
 158
 159         if( words[1] ) {
 160                 if( !strcmp(words[1],"query") ) {
 161
 162                         if( words[2] && !strcmp(words[2],"servers") ) {
 163                                 for(i=3; i < COMMAND_BUFSIZE - 3 && words[i]; i++ ) {
 164                                         router_query_servers( words[i] );
 165                                 }
 166                                 return 1;
 167                         }
 168                         return 0;
 169                 }
 170                 return 0;
 171         }
 172         return 0;
 173 }
 174
 175 int handle_request( char* words[] ) {
 176
 177         if(!client)
 178                 return 1;
 179
 180         if(words[1]) {
 181                 char* server = words[1];
 182                 char* method = words[2];
 183                 int i;
 184                 growing_buffer* buffer = buffer_init(128);
 185
 186                 for(i = 3; words[i] != NULL; i++ ) {
 187                         buffer_add( buffer, words[i] );
 188                         buffer_add(buffer, " ");
 189                 }
 190
 191                 return send_request( server, method, buffer );
 192         }
 193
 194         return 0;
 195 }
 196
 197 int send_request( char* server, char* method, growing_buffer* buffer ) {
 198         if( server == NULL || method == NULL )
 199                 return 0;
 200
 201         json* params = NULL;
 202         if( buffer != NULL && buffer->n_used > 0 )
 203                 params = json_tokener_parse(buffer->buf);
 204
 205         osrf_app_session* session = osrf_app_client_session_init(server);
 206         int req_id = osrf_app_session_make_request( session, params, method, 1 );
 207
 208         osrf_message* omsg = osrf_app_session_request_recv( session, req_id, 5 );
 209
 210         if(!omsg)
 211                 printf("Received no data from server\n");
 212
 213
 214         while(omsg) {
 215                 if(omsg->result_content)
 216                         printf( "Received Data: %s\n",json_object_to_json_string(omsg->result_content) );
 217                 omsg = osrf_app_session_request_recv( session, req_id, 5 );
 218         }
 219
 220
 221         if( osrf_app_session_request_complete( session, req_id ))
 222                 printf("[Request Completed Successfully]\n");
 223
 224         return 1;
 225
 226
 227 }
 228
 229 int handle_time( char* words[] ) {
 230
 231         if( ! words[1] ) {
 232
 233                 char buf[36];
 234                 memset(buf,0,36);
 235                 get_timestamp(buf);
 236                 printf( "%s\n", buf );
 237                 return 1;
 238         }
 239
 240         if( words[1] ) {
 241                 time_t epoch = (time_t)atoi( words[1] );
 242                 char* localtime = strdup( ctime( &epoch ) );
 243                 printf( "%s => %s", words[1], localtime );
 244                 free(localtime);
 245                 return 1;
 246         }
 247
 248         return 0;
 249
 250 }
 251
 252
 253
 254 int router_query_servers( char* router_server ) {
 255
 256         if( ! router_server || strlen(router_server) == 0 )
 257                 return 0;
 258
 259         char rbuf[256];
 260         memset(rbuf,0,256);
 261         sprintf(rbuf,"router@%s/router", router_server );
 262
 263         transport_message* send =
 264                 message_init( "servers", NULL, NULL, rbuf, NULL );
 265         message_set_router_info( send, NULL, NULL, NULL, "query", 0 );
 266
 267         client_send_message( client, send );
 268         message_free( send );
 269
 270         transport_message* recv = client_recv( client, -1 );
 271         if( recv == NULL )
 272                 fprintf(stderr, "NULL message received from router\n");
 273
 274         printf(
 275                         "---------------------------------------------------------------------------------\n"
 276                         "Received from 'server' query on %s\n"
 277                         "---------------------------------------------------------------------------------\n"
 278                         "original reg time | latest reg time | last used time | class | server\n"
 279                         "---------------------------------------------------------------------------------\n"
 280                         "%s"
 281                         "---------------------------------------------------------------------------------\n"
 282                         , router_server, recv->body );
 283
 284         message_free( recv );
 285
 286         return 1;
 287 }
 288
 289 void print_help() {
 290
 291         printf(
 292                         "---------------------------------------------------------------------------------\n"
 293                         "Commands:\n"
 294                         "---------------------------------------------------------------------------------\n"
 295                         "help                   - Display this message\n"
 296                         "last                   - Re-performs the last command\n"
 297                         "time                   - Prints the current time\n"
 298                         "time <timestamp>       - Formats seconds since epoch into readable format\n"
 299                         "---------------------------------------------------------------------------------\n"
 300                         "router query servers <server1 [, server2, ...]>\n"
 301                         "reqeust <service> <method> [ <json formatted string of params as an array> ]\n"
 302                         "---------------------------------------------------------------------------------\n"
 303                         );
 304
 305 }