Example #1
0
int main(int argc, char **argv)
{
    ZOOM_connection z;
    ZOOM_resultset r;
    ZOOM_query q = ZOOM_query_create();
    int error;
    const char *errmsg, *addinfo;
    int ccl_error_code, ccl_error_pos;
    const char *ccl_error_string;

    if (argc != 3)
    {
        fprintf (stderr, "usage:\n%s target cclquery\n", *argv);
        fprintf (stderr, " eg.  bagel.indexdata.dk/gils \"ti=utah\"\n");
        exit (1);
    }

    if (ZOOM_query_ccl2rpn(q, argv[2], 
                           "term t=l,r s=al\n" "ti u=4 s=pw\n",
                           &ccl_error_code, &ccl_error_string, &ccl_error_pos))
    {
        printf("CCL Error %d: %s\n", ccl_error_code, ccl_error_string);
        if (ccl_error_pos >= 0)
            printf("%s\n%*s^\n", argv[2], ccl_error_pos, "");
        ZOOM_query_destroy(q);
    }
    else
    {
        z = ZOOM_connection_new (argv[1], 0);
        
        if ((error = ZOOM_connection_error(z, &errmsg, &addinfo)))
        {
            fprintf (stderr, "Error: %s (%d) %s\n", errmsg, error, addinfo);
            exit (2);
        }
        
        r = ZOOM_connection_search (z, q);
        ZOOM_query_destroy(q);
        if ((error = ZOOM_connection_error(z, &errmsg, &addinfo)))
            fprintf (stderr, "Error: %s (%d) %s\n", errmsg, error, addinfo);
        else
            printf ("Result count: %ld\n", (long) ZOOM_resultset_size(r));
        ZOOM_resultset_destroy (r);
        ZOOM_connection_destroy (z);
    }
    exit (0);
}
Example #2
0
    resultSet::resultSet(connection &c, const query &q) : owner(c) {
        ZOOM_connection yazc = c._getYazConnection();
        rs = ZOOM_connection_search(yazc, q._getYazQuery());
        int errcode;
        const char *errmsg;     // unused: carries same info as `errcode'
        const char *addinfo;

        if ((errcode = ZOOM_connection_error(yazc, &errmsg, &addinfo)) != 0) {
            ZOOM_resultset_destroy(rs);
            throw bib1Exception(errcode, addinfo);
        }
    }
Example #3
0
File: zoom-ka.c Project: nla/yaz
int main(int argc, char **argv)
{
    ZOOM_connection z;
    ZOOM_options o = ZOOM_options_create ();
    const char *errmsg, *addinfo;

    if (argc != 4)
    {
        fprintf (stderr, "usage:\nzoom-ka sleepinterval target query\n");
        exit(1);
    }
    /* async mode */
    ZOOM_options_set (o, "async", "1");

    z = ZOOM_connection_create(o);

    while(1)
    {
        int i, error;
        ZOOM_resultset rset;
        ZOOM_connection_connect (z, argv[2], 0);
        rset = ZOOM_connection_search_pqf(z, argv[3]);

        while ((i = ZOOM_event(1, &z)))
        {
            printf ("no = %d event = %d\n", i-1,
                    ZOOM_connection_last_event(z));
        }
        if ((error = ZOOM_connection_error(z, &errmsg, &addinfo)))
        {
            fprintf(stderr, "%s error: %s (%d) %s\n",
                    ZOOM_connection_option_get(z, "host"),
                    errmsg, error, addinfo);
        }
        ZOOM_resultset_destroy(rset);
        sleep(atoi(argv[1]));
    }
    ZOOM_connection_destroy (z);
    ZOOM_options_destroy(o);
}
Example #4
0
void connection_continue(struct connection *co)
{
    int r = ZOOM_connection_exec_task(co->link);
    if (!r)
    {
        const char *error, *addinfo;
        int err;
        if ((err = ZOOM_connection_error(co->link, &error, &addinfo)))
        {
            if (co->client)
            {
                yaz_log(YLOG_LOG, "Error %s from %s",
                        error, client_get_id(co->client));
                client_set_diagnostic(co->client, err, addinfo);
                client_set_state_nb(co->client, Client_Error);
            }
        }
    }
    else
    {
        iochan_setflags(co->iochan, ZOOM_connection_get_mask(co->link));
        iochan_setfd(co->iochan, ZOOM_connection_get_socket(co->link));
    }
}
Example #5
0
File: zoomtst8.c Project: nla/yaz
int main(int argc, char **argv)
{
    int i;
    int no = argc-2;
    ZOOM_connection z[500]; /* allow at most 500 connections */
    ZOOM_scanset s[500];  /* and scan sets .. */
    ZOOM_options o = ZOOM_options_create ();

    if (argc < 3)
    {
        fprintf (stderr, "usage:\n%s target1 target2 ... targetN scan\n",
                 *argv);
        exit (1);
    }
    if (no > 500)
        no = 500;

    /* async mode */
    ZOOM_options_set (o, "async", "1");

    /* connect to all */
    for (i = 0; i<no; i++)
    {
        /* create connection - pass options (they are the same for all) */
        z[i] = ZOOM_connection_create (o);

        /* connect and init */
        ZOOM_connection_connect (z[i], argv[1+i], 0);

    }
    /* scan all */
    for (i = 0; i<no; i++)
    {
        /* set number of scan terms to be returned. */
        ZOOM_connection_option_set (z[i], "number", "7");
        /* and perform scan */
        s[i] = ZOOM_connection_scan(z[i], argv[argc-1]);
    }

    /* network I/O. pass number of connections and array of connections */
    while (ZOOM_event (no, z))
        ;

    for (i = 0; i<no; i++)
    {
        int error;
        const char *errmsg, *addinfo;
        if ((error = ZOOM_connection_error(z[i], &errmsg, &addinfo)))
            fprintf (stderr, "%s error: %s (%d) %s\n",
                     ZOOM_connection_option_get(z[i], "host"),
                     errmsg, error, addinfo);
        else
        {
            int j;
            printf ("%s\n", ZOOM_connection_option_get(z[i], "host"));
            for (j = 0; j < (int) ZOOM_scanset_size (s[i]); j++)
            {
                size_t occur, len;
                const char *term;
                term = ZOOM_scanset_term (s[i], j, &occur, &len);
                if (term)
                    printf ("%d %.*s %d\n", j, (int) len, term, (int) occur);
            }
        }
    }

    /* destroy and exit */
    for (i = 0; i<no; i++)
    {
        ZOOM_scanset_destroy (s[i]);
        ZOOM_connection_destroy (z[i]);
    }
    ZOOM_options_destroy(o);
    exit (0);
}
Example #6
0
int main(int argc, char **argv)
{
    struct time_type time;
    ZOOM_connection *z;
    ZOOM_resultset *r;
    int *elc;
    struct event_line_t *els;
    ZOOM_options o;
    int i;
    int k;

    init_statics();

    read_params(argc, argv, &parameters);

    z = (ZOOM_connection *) xmalloc(sizeof(*z) * parameters.concurrent);
    r = (ZOOM_resultset *) xmalloc(sizeof(*r) * parameters.concurrent);
    elc = (int *) xmalloc(sizeof(*elc) * parameters.concurrent * parameters.repeat);
    els = (struct event_line_t *) xmalloc(
        sizeof(*els) * parameters.concurrent * parameters.repeat * 10);
    o = ZOOM_options_create();

    /* async mode */
    ZOOM_options_set (o, "async", "1");

    /* get first record of result set (using piggypack) */
    if (parameters.piggypack)
        ZOOM_options_set (o, "count", "1");

    /* set proxy */
    if (strlen(parameters.proxy))
        ZOOM_options_set (o, "proxy", parameters.proxy);


    /* preferred record syntax */
    if (0){
        ZOOM_options_set (o, "preferredRecordSyntax", "usmarc");
        ZOOM_options_set (o, "elementSetName", "F");
    }

    time_init(&time);
    /* repeat loop */
    for (k = 0; k < parameters.repeat; k++){

        /* progress zeroing */
        for (i = 0; i < 4096; i++){
            parameters.progress[i] = k * 5 -1;
        }

        /* connect to all concurrent connections*/
        for ( i = 0; i < parameters.concurrent; i++){
            /* set event count to zero */
            elc[k * parameters.concurrent + i] = 0;

            /* create connection - pass options (they are the same for all) */
            z[i] = ZOOM_connection_create(o);

            /* connect and init */
            ZOOM_connection_connect(z[i], parameters.host, 0);
        }
        /* search all */
        for (i = 0; i < parameters.concurrent; i++)
            r[i] = ZOOM_connection_search_pqf (z[i], parameters.query);

        /* network I/O. pass number of connections and array of connections */
        while ((i = ZOOM_event (parameters.concurrent, z))){
            int event = ZOOM_connection_last_event(z[i-1]);
            const char *errmsg;
            const char *addinfo;
            int error = 0;
            //int progress = zoom_progress[event];

            if (event == ZOOM_EVENT_SEND_DATA || event == ZOOM_EVENT_RECV_DATA)
                continue;

            time_stamp(&time);

            /* updating events and event list */
            error = ZOOM_connection_error(z[i-1] , &errmsg, &addinfo);
            if (error)
                parameters.progress[i] = zoom_progress[ZOOM_EVENT_UNKNOWN];
            //parameters.progress[i] = zoom_progress[ZOOM_EVENT_NONE];
            else if (event == ZOOM_EVENT_CONNECT)
                parameters.progress[i] = zoom_progress[event];
            else
                //parameters.progress[i] = zoom_progress[event];
                parameters.progress[i] += 1;

            update_events(elc, els,
                          k, i-1,
                          time_sec(&time), time_usec(&time),
                          parameters.progress[i],
                          event, zoom_events[event],
                          error, errmsg);
        }

        /* destroy connections */
        for (i = 0; i<parameters.concurrent; i++)
            {
                ZOOM_resultset_destroy (r[i]);
                ZOOM_connection_destroy (z[i]);
            }



    } /* for (k = 0; k < parameters.repeat; k++) repeat loop */

    /* output */

    if (parameters.gnuplot){
        printf("# gnuplot data and instruction file \n");
        printf("# gnuplot thisfile \n");
        printf("\n");
        printf("set title \"Z39.50 connection plot\"\n");
        printf("set xlabel \"Connection\"\n");
        printf("set ylabel \"Time Seconds\"\n");
        printf("set zlabel \"Progress\"\n");
        printf("set ticslevel 0\n");
        printf("set grid\n");
        printf("set pm3d\n");
        printf("splot '-' using ($1):($2):($3) t '' with points\n");
        printf("\n");
        printf("\n");
    }

    print_table_header();
    print_events(elc,  els, parameters.concurrent);

    if (parameters.gnuplot){
        printf("end\n");
        printf("pause -1 \"Hit ENTER to return\"\n");
    }

    /* destroy data structures and exit */
    xfree(z);
    xfree(r);
    xfree(elc);
    xfree(els);
    ZOOM_options_destroy(o);
    exit (0);
}
Example #7
0
int main(int argc, char **argv)
{
    int i;
    int no = argc-3;
    ZOOM_connection z[500]; /* allow at most 500 connections */
    ZOOM_resultset r[500];  /* and result sets .. */
    ZOOM_query q;
    ZOOM_options o;

    o = ZOOM_options_create ();
    if (argc < 4)
    {
        fprintf (stderr, "usage:\n%s target1 .. targetN query sort\n",
                 *argv);
        exit (2);
    }
    if (no > 500)
        no = 500;

    /* function my_callback called when reading options .. */
    ZOOM_options_set_callback (o, my_callback, 0);

    /* get 20 (at most) records from beginning */
    ZOOM_options_set (o, "count", "20");

    ZOOM_options_set (o, "implementationName", "sortapp");
    ZOOM_options_set (o, "preferredRecordSyntax", "usmarc");
    ZOOM_options_set (o, "elementSetName", "B");

    /* create query */
    q = ZOOM_query_create ();
    if (ZOOM_query_prefix (q, argv[argc-2]))
    {
        printf ("bad PQF: %s\n", argv[argc-2]);
        exit (1);
    }
    if (ZOOM_query_sortby (q, argv[argc-1]))
    {
        printf ("bad sort spec: %s\n", argv[argc-1]);
        exit (1);
    }
    /* connect - and search all */
    for (i = 0; i<no; i++)
    {
        z[i] = ZOOM_connection_create (o);
        ZOOM_connection_connect (z[i], argv[i+1], 0);
        r[i] = ZOOM_connection_search (z[i], q);
    }

    /* network I/O */
    while (ZOOM_event (no, z))
        ;

    /* handle errors */
    for (i = 0; i<no; i++)
    {
        int error;
        const char *errmsg, *addinfo;
        if ((error = ZOOM_connection_error(z[i], &errmsg, &addinfo)))
            fprintf (stderr, "%s error: %s (%d) %s\n",
                     ZOOM_connection_option_get(z[i], "host"),
                     errmsg, error, addinfo);
        else
        {
            /* OK, no major errors. Look at the result count */
            int pos;
            printf ("%s: %ld hits\n", ZOOM_connection_option_get(z[i], "host"),
                    (long) ZOOM_resultset_size(r[i]));
            /* go through first 20 records at target */
            for (pos = 0; pos < 20; pos++)
            {
                ZOOM_record rec;
                const char *db, *syntax, *str;
                int len;

                rec = ZOOM_resultset_record (r[i], pos);
                /* get database for record and record itself at pos */

                db = ZOOM_record_get (rec,  "database", 0);
                str = ZOOM_record_get (rec, "xml", &len);
                syntax = ZOOM_record_get (rec, "syntax", &len);
                /* if rec is non-null, we got a record for display */
                if (str)
                {
                    printf ("%d %s %s\n", pos+1, syntax, 
                            (db ? db : "unknown"));
                    if (rec)
                    {
                        if (fwrite (str, 1, len, stdout) != (size_t) len)
                            printf("write to stdout failed\n");
                    }
                    printf ("\n");
                }
            }
        }
    }

    /* destroy stuff and exit */
    ZOOM_query_destroy (q);
    for (i = 0; i<no; i++)
    {
        ZOOM_resultset_destroy (r[i]);
        ZOOM_connection_destroy (z[i]);
    }
    ZOOM_options_destroy(o);
    exit(0);
}
Example #8
0
static void non_block_events(struct connection *co)
{
    int got_records = 0;
    IOCHAN iochan = co->iochan;
    ZOOM_connection link = co->link;
    while (1)
    {
        struct client *cl = co->client;
        int ev;
        int r = ZOOM_event_nonblock(1, &link);
        if (!r)
            break;
        if (!cl)
            continue;
        ev = ZOOM_connection_last_event(link);
        
#if 1
        yaz_log(YLOG_DEBUG, "%p Connection ZOOM_EVENT_%s", co, ZOOM_get_event_str(ev));
#endif
        switch (ev) 
        {
        case ZOOM_EVENT_END:
            {
                const char *error, *addinfo;
                int err;
                if ((err = ZOOM_connection_error(link, &error, &addinfo)))
                {
                    yaz_log(YLOG_LOG, "Error %s from %s",
                            error, client_get_id(cl));
                    client_set_diagnostic(cl, err, addinfo);
                    client_set_state(cl, Client_Error);
                }
                else
                {
                    iochan_settimeout(iochan, co->session_timeout);
                    client_set_state(cl, Client_Idle);
                }
                yaz_cond_broadcast(co->host->cond_ready);
            }
            break;
        case ZOOM_EVENT_SEND_DATA:
            break;
        case ZOOM_EVENT_RECV_DATA:
            break;
        case ZOOM_EVENT_UNKNOWN:
            break;
        case ZOOM_EVENT_SEND_APDU:
            client_set_state(co->client, Client_Working);
            iochan_settimeout(iochan, co->operation_timeout);
            break;
        case ZOOM_EVENT_RECV_APDU:
            break;
        case ZOOM_EVENT_CONNECT:
            yaz_log(YLOG_LOG, "Connected to %s", client_get_id(cl));
            co->state = Conn_Open;
            break;
        case ZOOM_EVENT_RECV_SEARCH:
            client_search_response(cl);
            break;
        case ZOOM_EVENT_RECV_RECORD:
            client_record_response(cl);
            got_records = 1;
            break;
        default:
            yaz_log(YLOG_LOG, "Unhandled event (%d) from %s",
                    ev, client_get_id(cl));
            break;
        }
    }
    if (got_records)
    {
        struct client *cl = co->client;
        if (cl)
        {
            client_check_preferred_watch(cl);
            client_got_records(cl);
        }
    }
}
Example #9
0
int main(int argc, char **argv)
{
    int block;
    int i, j;
    ZOOM_connection z;
    ZOOM_resultset r[10];  /* and result sets .. */
    ZOOM_options o;

    o = ZOOM_options_create ();

    z = ZOOM_connection_new ("localhost", 9999);
    if (ZOOM_connection_error (z, 0, 0))
    {
        printf ("error - couldn't connect?\n");
        exit (1);
    }
        
    ZOOM_connection_destroy (z);

    for (block = 0; block < 3; block++)
    {
        switch (block)
        {
        case 0:
            printf ("blocking - not calling ZOOM_events\n");
            break;
        case 1:
            printf ("blocking - calling ZOOM_events\n");
            break;
        case 2:
            printf ("non-blocking - calling ZOOM_events\n");
            break;
        }
        if (block > 1)
            ZOOM_options_set (o, "async", "1");
        for (i = 0; i<10; i++)
        {
            char host[40];

            printf ("session %2d", i);
            sprintf (host, "localhost:9999/%d", i);
            z = ZOOM_connection_create (o);
            ZOOM_connection_connect (z, host, 0);
            
            for (j = 0; j < 10; j++)
            {
                ZOOM_record recs[2];
                char query[40];
                ZOOM_query s = ZOOM_query_create ();
                
                sprintf (query, "i%dr%d", i, j);
                
                if (ZOOM_query_prefix (s, query))
                {
                    printf ("bad PQF: %s\n", query);
                    exit (2);
                }
                ZOOM_options_set (o, "start", "0");
                ZOOM_options_set (o, "count", "0");
                
                r[j] = ZOOM_connection_search (z, s); /* non-piggy */
                
                ZOOM_resultset_records (r[j], recs, 0, 2);  /* first two */
                
                ZOOM_resultset_records (r[j], recs, 1, 2);  /* third */

                ZOOM_resultset_records (r[j], recs, 0, 0);  /* ignored */

                if (ZOOM_resultset_size (r[j]) > 2)
                {
                    if (!recs[0])
                    {
                        fprintf (stderr, "\nrecord missing\n");
                        exit (1);
                    }
                }
                
                ZOOM_query_destroy (s);

                printf (".");
                if (block > 0)
                    while (ZOOM_event (1, &z))
                        ;
            }
            for (j = 0; j<i; j++)
                ZOOM_resultset_destroy (r[j]);
            ZOOM_connection_destroy (z);
            for (; j < 10; j++)
                ZOOM_resultset_destroy (r[j]);
            printf ("10 searches, 20 presents done\n");

        }

        for (i = 0; i<1; i++)
        {
            ZOOM_query q = ZOOM_query_create ();
            char host[40];

            printf ("session %2d", i+10);
            sprintf (host, "localhost:9999/%d", i);
            z = ZOOM_connection_create (o);
            ZOOM_connection_connect (z, host, 0);
            
            for (j = 0; j < 10; j++)
            {
                char query[40];
                
                sprintf (query, "i%dr%d", i, j);
                
                ZOOM_options_set (o, "count", "0");
                
                r[j] = ZOOM_connection_search_pqf (z, query);

                printf (".");
                if (block > 0)
                    while (ZOOM_event (1, &z))
                        ;
            }

            ZOOM_connection_destroy (z);
            
            for (j = 0; j < 10; j++)
            {
                ZOOM_resultset_records (r[j], 0, 0, 1);
            }
            for (j = 0; j < 10; j++)
                ZOOM_resultset_destroy (r[j]);
            ZOOM_query_destroy (q);
            printf ("10 searches, 10 ignored presents done\n");
        }


        for (i = 0; i<1; i++)
        {
            char host[40];
            ZOOM_scanset scan = 0;

            printf ("session %2d", i);
            sprintf (host, "localhost:9999/%d", i);
            z = ZOOM_connection_create (o);
            ZOOM_connection_connect (z, host, 0);

            scan = ZOOM_connection_scan(z, "@attr 1=4 a");
            if (block > 0)
                while (ZOOM_event (1, &z))
                    ;
            printf (" scan size = %ld\n", (long) ZOOM_scanset_size(scan));
            for (j = 0; j < (int) ZOOM_scanset_size (scan); j++)
            {
                int occur, len;
                const char *term;
                term = ZOOM_scanset_term (scan, j, &occur, &len);
                if (term)
                    printf ("%d %.*s %d\n", j, len, term, occur);
                
            }
            ZOOM_scanset_destroy (scan);
            ZOOM_connection_destroy (z);
        }

    }
    ZOOM_options_destroy (o);
    exit (0);
}