1 /* This file is part of the Zebra server.
2 Copyright (C) 2004-2013 Index Data
4 Zebra is free software; you can redistribute it and/or modify it under
5 the terms of the GNU General Public License as published by the Free
6 Software Foundation; either version 2, or (at your option) any later
9 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 zebrash.c - command-line interface to zebra API
35 #if HAVE_READLINE_READLINE_H
36 #include <readline/readline.h>
38 #if HAVE_READLINE_HISTORY_H
39 #include <readline/history.h>
42 #include <idzebra/api.h>
44 #include <yaz/proto.h>
45 #include <yaz/sortspec.h>
46 #include <yaz/options.h>
47 #include <yaz/wrbuf.h>
48 #include <yaz/oid_db.h>
50 #define MAX_NO_ARGS 32
51 #define MAX_OUT_BUFF 4096
52 #define MAX_ARG_LEN 1024
53 #define PROMPT "ZebraSh>"
54 #define DEFAULTCONFIG "./zebra.cfg"
55 #define DEFAULTDATABASE "Default"
56 #define DEFAULTRESULTSET "MyResultSet"
59 /**************************************
60 * Global variables (yuck!)
63 ZebraService zs=0; /* our global handle to zebra */
64 ZebraHandle zh=0; /* the current session */
65 /* time being, only one session works */
66 int nextrecno=1; /* record number to show next */
67 static char *default_config = DEFAULTCONFIG;
68 static int log_level=0;
71 /**************************************
76 static int split_args( char *line, char** args )
77 { /* splits line into individual null-terminated strings,
78 * returns pointers to them in args */
79 /* FIXME - do we need to handle quoted args ?? */
83 args[0]=0; /* by default */
84 while (*p==' ' || *p=='\t' || *p=='\n')
88 while (*p==' ' || *p=='\t' || *p=='\n')
90 if (*p=='#') /* skip comments */
94 while (*p && *p!=' ' && *p!='\t' && *p!='\n' && *p!='#')
104 static char *defarg( char *arg, char *def )
112 static int defargint( char *arg, int def )
115 char *a=defarg(arg,0);
121 static char *restargs( char *args[], int n)
122 { /* Returns the rest of the arguments, starting at the nth, */
123 /* to the end of the command line. Assumes args[0] contains */
124 /* the original line, minus the command itself */
125 int skiplen= args[n]-args[1];
126 if (skiplen > strlen(args[0]))
128 return args[0]+skiplen;
131 int onecommand( char *line, WRBUF outbuff, const char *prevout);
133 /**************************************
134 * Simple support commands
137 int cmd_echo( char *args[], WRBUF outbuff)
139 wrbuf_printf(outbuff,"%s\n",restargs(args,1));
143 int cmd_quit( char *args[], WRBUF outbuff)
147 onecommand("zebra_close",outbuff,"");
152 onecommand("zebra_stop",outbuff,"");
155 wrbuf_puts(outbuff, "bye");
156 return -99; /* special stop signal */
159 /**************************************
160 * Tests for starting and stopping zebra, etc
163 static int cmd_help( char *args[], WRBUF outbuff);
165 static int cmd_zebra_start( char *args[], WRBUF outbuff)
168 if (!conf || !*conf) {
169 wrbuf_puts(outbuff,"no config file specified, using ");
170 wrbuf_puts(outbuff, default_config);
171 wrbuf_puts(outbuff, "\n");
174 zs=zebra_start(conf);
176 wrbuf_puts(outbuff, "zebra_start failed" );
182 static int cmd_zebra_stop( char *args[], WRBUF outbuff)
185 wrbuf_puts(outbuff,"zebra seems not to have been started, "
186 "stopping anyway\n");
192 static int cmd_zebra_open( char *args[], WRBUF outbuff)
195 wrbuf_puts(outbuff,"zebra seems not to have been started, "
197 zh = zebra_open(zs, 0);
201 static int cmd_zebra_close( char *args[], WRBUF outbuff)
204 wrbuf_puts(outbuff,"Seems like you have not called zebra_open,"
210 static int cmd_quickstart( char *args[], WRBUF outbuff)
215 rc=onecommand("yaz_log_file zebrash.log",outbuff,"");
217 rc=onecommand("yaz_log_prefix ZebraSh", outbuff,"");
218 sprintf(tmp, "yaz_log_level 0x%x", YLOG_DEFAULT_LEVEL | log_level );
220 rc=onecommand(tmp,outbuff,"");
221 yaz_log(log_level,"quickstart");
224 rc=onecommand("zebra_start",outbuff,"");
227 rc=onecommand("zebra_open",outbuff,"");
229 rc=onecommand("select_database Default",outbuff,"");
233 /**************************************
237 static int cmd_yaz_log_file( char *args[], WRBUF outbuff)
239 char *fn = defarg(args[1],0);
240 wrbuf_printf(outbuff, "sending yaz-log to %s\n",fn);
241 yaz_log_init_file(fn);
245 static int cmd_yaz_log_level( char *args[], WRBUF outbuff)
247 int lev = defargint(args[1],YLOG_DEFAULT_LEVEL);
248 wrbuf_printf(outbuff, "setting yaz-log to level %d (ox%x)\n",lev,lev);
249 yaz_log_init_level(lev);
253 static int cmd_yaz_log_prefix( char *args[], WRBUF outbuff)
255 char *pref = defarg(args[1],"ZebraSh");
256 wrbuf_printf(outbuff, "setting yaz-log prefix to %s\n",pref);
257 yaz_log_init_prefix(pref);
261 static int cmd_logf( char *args[], WRBUF outbuff)
263 int lev = defargint(args[1],0);
268 lev=YLOG_LOG; /* this is in the default set!*/
269 yaz_log( lev, "%s", restargs(args,i));
276 static int cmd_err ( char *args[], WRBUF outbuff)
278 wrbuf_printf(outbuff, "errCode: %d \nerrStr: %s\nerrAdd: %s \n",
280 zebra_errString (zh),
284 static int cmd_errcode ( char *args[], WRBUF outbuff)
286 wrbuf_printf(outbuff, "errCode: %d \n",
290 static int cmd_errstr ( char *args[], WRBUF outbuff)
292 wrbuf_printf(outbuff, "errStr: %s\n",
293 zebra_errString (zh));
296 static int cmd_erradd ( char *args[], WRBUF outbuff)
298 wrbuf_printf(outbuff, "errAdd: %s \n",
303 /**************************************
307 static int cmd_init ( char *args[], WRBUF outbuff)
313 static int cmd_select_database ( char *args[], WRBUF outbuff)
315 char *db=defarg(args[1],DEFAULTDATABASE);
316 wrbuf_printf(outbuff,"Selecting database '%s'\n",db);
317 return zebra_select_database(zh, db);
320 static int cmd_create_database( char *args[], WRBUF outbuff)
322 char *db=defarg(args[1],DEFAULTDATABASE);
323 wrbuf_printf(outbuff,"Creating database '%s'\n",db);
325 return zebra_create_database(zh, db);
328 static int cmd_drop_database( char *args[], WRBUF outbuff)
333 wrbuf_printf(outbuff,"Dropping database '%s'\n",db);
334 return zebra_drop_database(zh, db);
337 static int cmd_begin_trans( char *args[], WRBUF outbuff)
340 if (args[1] && ( (args[1][0]=='1') || (args[1][0]=='w') ))
342 return zebra_begin_trans(zh,rw);
345 static int cmd_end_trans( char *args[], WRBUF outbuff)
347 return zebra_end_trans(zh);
349 /*************************************
350 * Inserting and deleting
353 static int cmd_record_insert( char *args[], WRBUF outbuff)
357 char *rec=restargs(args,1);
359 rc = zebra_update_record(zh,
369 wrbuf_printf(outbuff,"ok sysno=" ZINT_FORMAT "\n",sysno);
375 static int cmd_exchange_record( char *args[], WRBUF outbuff)
378 char *action = args[2];
380 char *rec=restargs(args,3);
381 if (!(id && action && args[4] ))
383 wrbuf_puts(outbuff,"Missing arguments!\n");
384 onecommand("help exchange_record", outbuff, "");
388 rc = zebra_update_record(zh, action_update, 0 /* record_type */,
396 /**********************************
397 * Searching and retrieving
400 static int cmd_search_pqf(char *args[], WRBUF outbuff)
404 char *qry = restargs(args,2);
406 rc = zebra_search_PQF(zh, qry, set, &hits);
408 wrbuf_printf(outbuff, ZINT_FORMAT " hits found\n", hits);
412 static int cmd_find( char *args[], WRBUF outbuff)
414 char *setname=DEFAULTRESULTSET;
417 WRBUF qry = wrbuf_alloc();
418 if (0==strstr(args[0],"@attr"))
419 wrbuf_puts(qry, "@attr 1=/ ");
420 wrbuf_puts(qry,restargs(args,1));
422 onecommand("quickstart", outbuff, "");
423 wrbuf_printf(outbuff, "find %s\n",wrbuf_cstr(qry));
424 rc = zebra_search_PQF(zh, wrbuf_cstr(qry), setname, &hits);
427 wrbuf_printf(outbuff, ZINT_FORMAT " hits found\n", hits);
434 static int cmd_show( char *args[], WRBUF outbuff)
436 int start=defargint(args[1], nextrecno);
437 int nrecs=defargint(args[2],1);
438 char *setname=defarg(args[3],DEFAULTRESULTSET);
440 ZebraRetrievalRecord *recs;
442 Z_RecordComposition *pcomp=0;
445 odr = odr_createmem(ODR_ENCODE);
446 recs= odr_malloc(odr,sizeof(ZebraRetrievalRecord)*nrecs);
447 rc =z_RecordComposition(odr, &pcomp, 0,"recordComposition");
449 for (i=0;i<nrecs;i++)
450 recs[i].position=start+i;
452 rc = zebra_records_retrieve(zh, odr, setname,
453 pcomp, yaz_oid_recsyn_xml, nrecs,recs);
456 for (i=0;i<nrecs;i++)
458 printf("Err %d: %d\n",i,recs[i].errCode);
461 wrbuf_printf(outbuff,"Record %d\n", recs[i].position);
462 wrbuf_write(outbuff, recs[i].buf, recs[i].len);
463 wrbuf_puts(outbuff, "\n");
465 wrbuf_printf(outbuff,"NO Record %d\n", recs[i].position);
467 nextrecno=start+nrecs;
473 static int cmd_sort( char *args[], WRBUF outbuff)
478 Z_SortKeySpecList *spec=0;
479 const char * inpsets[]={ DEFAULTRESULTSET, 0};
480 /* FIXME - allow the user to specify result sets in/out */
482 odr=odr_createmem(ODR_ENCODE);
483 spec=yaz_sort_spec (odr, restargs(args,1));
487 rc=zebra_sort(zh, odr,
493 wrbuf_printf(outbuff, "sort returned status %d\n",sortstatus);
500 * int bend_sort (void *handle, bend_sort_rr *rr)
502 * ZebraHandle zh = (ZebraHandle) handle;
504 * zebra_sort (zh, rr->stream,
505 * rr->num_input_setnames, (const char **)
506 * rr->input_setnames,
507 * rr->output_setname,
510 * zebra_result (zh, &rr->errcode,
517 /**************************************)
518 * Command table, parser, and help
526 int (*testfunc)(char *args[], WRBUF outbuff);
530 struct cmdstruct cmds[] = {
532 * if text is 0, does not list the command
533 * if cmd is "", adds the args (and newline) in command listing
535 { "", "Starting and stopping:", "", 0 },
538 "starts the zebra service. You need to call this first\n"
539 "if no configfile is given, assumes " DEFAULTCONFIG,
542 "stops the zebra service",
545 "starts a zebra session. Once you have called zebra_start\n"
546 "you can call zebra_open to start working",
549 "closes a zebra session",
551 { "quickstart", "[configfile]",
552 "Does a zebra_start, zebra_open, and sets up the log",
555 { "", "Log file:","", 0},
558 "Directs the log to filename (or stderr)",
562 "Sets the logging level (or returns to default)",
566 "Sets the log prefix",
570 "writes an entry in the log",
573 { "", "Error handling:","", 0},
575 "Displays zebra's error status (code, str, add)",
578 "Displays zebra's error code",
581 "Displays zebra's error string",
584 "Displays zebra's additional error message",
587 { "", "Admin:","", 0},
589 "Initializes the zebra database, destroying all data in it",
591 { "select_database", "basename",
592 "Selects a database",
593 cmd_select_database},
594 { "create_database", "basename",
596 cmd_create_database},
597 { "drop_database", "basename",
600 { "begin_trans", "[rw]",
601 "Begins a transaction. rw=1 means write, otherwise read-only",
604 "Ends a transaction",
607 { "","Updating:","",0},
608 { "record_insert","record",
609 "inserts an sgml record into Default",
611 { "exchange_record","database record-id action record",
612 "inserts (1), updates (2), or deletes (3) a record \n"
613 "record-id must be a unique identifier for the record",
614 cmd_exchange_record},
616 { "","Searching and retrieving:","",0},
617 { "search_pqf","setname query",
626 { "show","[start] [numrecs] [resultset]",
629 { "s","[start] [numrecs] [resultset]",
633 "sorts a result set. (example spec: 1=4 >)",
636 { "", "Misc:","", 0},
646 { "help", "[command]",
647 "Gives help on command, or lists them all",
649 { "", "help [command] gives more info on command", "",0 },
651 {0,0,0,0} /* end marker */
655 char *line, /* input line */
656 WRBUF outbuff, /* output goes here */
657 const char *prevout) /* prev output, for 'expect' */
660 char *args[MAX_NO_ARGS];
662 char argbuf[MAX_ARG_LEN];
663 yaz_log(log_level,"%s",line);
664 strncpy(argbuf,line, MAX_ARG_LEN-1);
665 argbuf[MAX_ARG_LEN-1]='\0'; /* just to be sure */
666 /*memset(args,'\0',MAX_NO_ARGS*sizeof(char *));*/
667 nargs=split_args(argbuf, args);
670 for (i = 0; i <= n; i++)
672 const char *cp = args[i];
673 printf ("args %d :%s:\n", i, cp ? cp : "<null>");
677 return -90; /* no command on line, too bad */
679 if (0==strcmp(args[0],"expect"))
682 if (nargs>1) /* args[0] is not yet set, can't use restargs */
683 rest= line + (args[1]-argbuf); /* rest of the line */
685 return -1; /* need something to expect */
686 if (0==strstr(prevout,rest))
688 printf( "Failed expectation, '%s' not found\n", rest);
693 for (i=0;cmds[i].cmd;i++)
694 if (0==strcmp(cmds[i].cmd, args[0]))
697 args[0]= line + (args[1]-argbuf); /* rest of the line */
700 return ((cmds[i].testfunc)(args,outbuff));
702 wrbuf_printf(outbuff, "Unknown command '%s'. Try help\n",args[0]);
703 yaz_log(log_level,"Unknown command");
707 static int cmd_help( char *args[], WRBUF outbuff)
712 { /* help for a single command */
713 for (i=0;cmds[i].cmd;i++)
714 if (0==strcmp(cmds[i].cmd, args[1]))
716 wrbuf_printf(outbuff,"%s %s\n%s\n",
717 cmds[i].cmd, cmds[i].args,
718 cmds[i].explanation);
721 wrbuf_printf(outbuff, "Unknown command '%s'", args[1]);
724 { /* list all commands */
726 for (i=0;cmds[i].cmd;i++)
729 { /* ordinary command */
732 wrbuf_puts(outbuff,"\n ");
735 linelen += strlen(cmds[i].cmd) + 2;
736 wrbuf_printf(outbuff,"%s ", cmds[i].cmd);
739 wrbuf_printf(outbuff,"\n%s\n ",cmds[i].args);
743 wrbuf_puts(outbuff,"\n");
748 /* If Zebra reports an error after an operation,
749 * append it to the outbuff and log it */
750 static void Zerrors (WRBUF outbuff)
755 ec=zebra_errCode (zh);
758 yaz_log(log_level, " Zebra error %d: %s, (%s)",
759 ec, zebra_errString (zh),
761 wrbuf_printf(outbuff, " Zebra error %d: %s, (%s)\n",
762 ec, zebra_errString (zh),
767 /**************************************
774 WRBUF outbuff=wrbuf_alloc();
775 char prevout[MAX_OUT_BUFF]=""; /* previous output for 'expect' */
776 wrbuf_puts(outbuff,"Zebrash at your service");
780 char buf[MAX_ARG_LEN];
782 #if HAVE_READLINE_READLINE_H
784 line_in=readline(PROMPT);
787 #if HAVE_READLINE_HISTORY_H
789 add_history(line_in);
793 /* line_in != NULL if readine is present and input is a tty */
799 if(strlen(line_in) > MAX_ARG_LEN-1) {
800 fprintf(stderr,"Input line too long\n");
808 if (!fgets (buf, MAX_ARG_LEN-1, stdin))
812 /* get rid of \n in line */
813 if ((nl_cp = strchr(buf, '\n')))
815 strncpy(prevout, wrbuf_cstr(outbuff), MAX_OUT_BUFF);
816 wrbuf_rewind(outbuff);
817 rc=onecommand(buf, outbuff, prevout);
820 wrbuf_puts(outbuff, " OK\n");
821 yaz_log(log_level, "OK");
825 wrbuf_printf(outbuff, " command returned %d\n",rc);
828 printf("%s\n", wrbuf_cstr(outbuff));
830 wrbuf_destroy(outbuff);
834 static void usage(void)
837 printf ("zebrash [-c config]\n");
840 /**************************************
844 int main (int argc, char ** argv)
848 while ((ret = options ("c:h", argv, argc, &arg)) != -2)
853 default_config = arg;
857 /* FIXME - handle -v */
859 fprintf(stderr, "bad option %s\n", arg);
863 log_level=yaz_log_module_level("zebrash");
871 * c-file-style: "Stroustrup"
872 * indent-tabs-mode: nil
874 * vim: shiftwidth=4 tabstop=8 expandtab