Ignore:
Timestamp:
07/10/12 16:29:35 (12 years ago)
Author:
oschonef
Message:
  • be more robust, when parsing responses
  • add mechanism to send invalid requests (NB: use to provoke errors when testing endpoints for protocol conformance)
File:
1 edited

Legend:

Unmodified
Added
Removed

  • SRUClient/trunk/src/main/java/eu/clarin/sru/client/SRUClient.java

    r2022 r2024  
    1313
    1414import javax.xml.stream.XMLStreamException;
     15import javax.xml.stream.XMLStreamReader;
    1516
    1617import org.apache.commons.lang.NullArgumentException;
    … …  
    2425import org.apache.http.impl.client.DefaultHttpClient;
    2526import org.apache.http.params.CoreProtocolPNames;
     27import org.apache.http.util.EntityUtils;
    2628import org.slf4j.Logger;
    2729import org.slf4j.LoggerFactory;
    … …  
    282284
    283285    private HttpResponse executeRequest(URI uri) throws SRUClientException {
     286        HttpGet request = null;
     287        HttpResponse response = null;
    284288        try {
    285289            logger.debug("executing HTTP request: {}", uri.toString());
    286             HttpGet request = new HttpGet(uri);
    287             HttpResponse response = httpClient.execute(request);
    288             StatusLine status = response.getStatusLine();
    289             if (status.getStatusCode() != HttpStatus.SC_OK) {
    290                 if (status.getStatusCode() == HttpStatus.SC_NOT_FOUND) {
    291                     throw new SRUClientException("not found: " + uri);
    292                 } else {
    293                     throw new SRUClientException("unexpected status: " +
    294                             status.getStatusCode());
    295                 }
    296             }
    297             return response;
    298         } catch (ClientProtocolException e) {
    299             throw new SRUClientException("client protocol exception", e);
    300         } catch (UnknownHostException e) {
    301             throw new SRUClientException("unknown host: " + uri.getHost(), e);
    302         } catch (IOException e) {
    303             throw new SRUClientException("input/output error", e);
    304         }
    305     }
    306 
    307 
    308     private void parseExplainResponse(SRUXMLStreamReader reader,
    309             SRUExplainRequest request, SRUExplainHandler handler)
     290            try {
     291                request = new HttpGet(uri);
     292                response = httpClient.execute(request);
     293                StatusLine status = response.getStatusLine();
     294                if (status.getStatusCode() != HttpStatus.SC_OK) {
     295                    if (status.getStatusCode() == HttpStatus.SC_NOT_FOUND) {
     296                        throw new SRUClientException("not found: " + uri);
     297                    } else {
     298                        throw new SRUClientException("unexpected status: " +
     299                                status.getStatusCode());
     300                    }
     301                }
     302                return response;
     303            } catch (ClientProtocolException e) {
     304                throw new SRUClientException("client protocol exception", e);
     305            } catch (UnknownHostException e) {
     306                throw new SRUClientException("unknown host: " + uri.getHost(),
     307                        e);
     308            } catch (IOException e) {
     309                throw new SRUClientException("input/output error", e);
     310            }
     311        } catch (SRUClientException e) {
     312            /*
     313             * if an error occurred, make sure we are freeing up the resources
     314             * we've used
     315             */
     316            if (response != null) {
     317                try {
     318                    EntityUtils.consume(response.getEntity());
     319                } catch (IOException ex) {
     320                    /* IGNORE */
     321                }
     322            }
     323            if (request != null) {
     324                request.abort();
     325            }
     326            throw e;
     327        }
     328    }
     329
     330
     331    private void parseExplainResponse(final SRUXMLStreamReader reader,
     332            final SRUAbstractRequest request, final SRUExplainHandler handler)
    310333            throws SRUClientException {
    311334        logger.debug("parsing 'explain' response");
    … …  
    317340            SRUVersion version = parseVersion(reader);
    318341            logger.debug("version = {}, requested = {}",
    319                     version, this.defaultVersion);
     342                    version, request.getVersionPerformed());
    320343
    321344            // explainResponse/record
    … …  
    376399
    377400
    378     private void parseScanResponse(SRUXMLStreamReader reader,
    379             SRUScanRequest request, SRUScanHandler handler)
     401    private void parseScanResponse(final SRUXMLStreamReader reader,
     402            final SRUScanRequest request, final SRUScanHandler handler)
    380403            throws SRUClientException {
    381         logger.debug("parsing 'scanResponse' response");
    382404        try {
    383             // scanResponse
    384             reader.readStart(SRU_NS, "scanResponse", true);
    385 
    386             // scanResponse/version
    387             SRUVersion version = parseVersion(reader);
    388             logger.debug("version = {}, requested = {}",
    389                     version, this.defaultVersion);
    390 
    391             // scanResponse/terms
    392             if (reader.readStart(SRU_NS, "terms", false)) {
    393                 boolean first = true;
    394                 while (reader.readStart(SRU_NS, "term", first)) {
    395                     if (first) {
    396                         first = false;
    397                         handler.onStartTerms();
     405            /*
     406             * if the endpoint cannot determine the operation, it should create
     407             * a explain response.
     408             */
     409            if (reader.peekStart(SRU_NS, "explainResponse")) {
     410                parseExplainResponse(reader, request, new SRUExplainHandler() {
     411                    @Override
     412                    public void onRequestStatistics(int bytes, long millisTotal,
     413                            long millisNetwork, long millisParsing) {
    398414                    }
    399415
    400                     // scanResponse/terms/value
    401                     String value = reader.readContent(SRU_NS, "value", true);
    402 
    403                     // scanResponse/terms/numberOfRecords
    404                     int numberOfRecords = reader.readContent(SRU_NS,
    405                             "numberOfRecords", false, -1);
    406 
    407                     // scanResponse/terms/displayTerm
    408                     String displayTerm = reader.readContent(SRU_NS,
    409                             "displayTerm", false);
    410 
    411                     // scanResponse/terms/whereInList
    412                     String s = reader.readContent(SRU_NS, "whereInList", false);
    413                     WhereInList whereInList = null;
    414                     if (s != null) {
    415                         if ("first".equals(s)) {
    416                             whereInList = WhereInList.FIRST;
    417                         } else if ("last".equals(s)) {
    418                             whereInList = WhereInList.LAST;
    419                         } else if ("only".equals(s)) {
    420                             whereInList = WhereInList.ONLY;
    421                         } else if ("inner".equals(s)) {
    422                             whereInList = WhereInList.INNER;
    423                         } else {
    424                             throw new SRUClientException(
    425                                     "invalid value for 'whereInList': " + s);
    426                         }
     416
     417                    @Override
     418                    public void onExtraResponseData(XMLStreamReader reader)
     419                            throws XMLStreamException, SRUClientException {
    427420                    }
    428                     logger.debug("value = {}, numberOfRecords = {}, "
    429                             + "displayTerm = {}, whereInList = {}",
    430                             new Object[] { value, numberOfRecords, displayTerm,
    431                                     whereInList });
    432                     handler.onTerm(value, numberOfRecords,
    433                             displayTerm, whereInList);
    434 
    435                     // scanResponse/terms/extraTermData
    436                     if (reader.readStart(SRU_NS, "extraTermData", first)) {
    437                         reader.consumeWhitespace();
    438                         proxy.reset(reader);
    439                         try {
    440                             handler.onExtraTermData(value, proxy);
    441                         } catch (XMLStreamException e) {
    442                             throw new SRUClientException("handler "
    443                                     + "triggered error while parsing "
    444                                     + "'extraTermData'", e);
    445                         }
    446                         reader.consumeWhitespace();
    447                         reader.readEnd(SRU_NS, "extraTermData", true);
     421
     422
     423                    @Override
     424                    public void onDiagnostics(List<SRUDiagnostic> diagnostics)
     425                            throws SRUClientException {
     426                        handler.onDiagnostics(diagnostics);
    448427                    }
    449                     reader.readEnd(SRU_NS, "term", true);
    450 
    451                 } // while
    452                 reader.readEnd(SRU_NS, "terms");
    453                 handler.onFinishTerms();
    454             }
    455 
    456             // scanResponse/echoedScanRequest
    457             if (reader.readStart(SRU_NS, "echoedScanRequest", false)) {
    458                 reader.readEnd(SRU_NS, "echoedScanRequest", true);
    459             }
    460 
    461             // scanResponse/diagnostics
    462             final List<SRUDiagnostic> diagnostics = parseDiagnostics(reader);
    463             if (diagnostics != null) {
    464                 handler.onDiagnostics(diagnostics);
    465             }
    466 
    467             // scanResponse/extraResponseData
    468             if (reader.readStart(SRU_NS, "extraResponseData", false)) {
    469                 reader.consumeWhitespace();
    470                 proxy.reset(reader);
    471                 try {
    472                     handler.onExtraResponseData(proxy);
    473                 } catch (XMLStreamException e) {
    474                     throw new SRUClientException("handler triggered "
    475                             + "error while parsing 'extraResponseData'", e);
    476                 }
    477                 reader.consumeWhitespace();
    478                 reader.readEnd(SRU_NS, "extraResponseData", true);
    479             }
    480 
    481             reader.readEnd(SRU_NS, "scanResponse");
     428                });
     429            } else {
     430                logger.debug("parsing 'scanResponse' response");
     431
     432                // scanResponse
     433                reader.readStart(SRU_NS, "scanResponse", true);
     434
     435                // scanResponse/version
     436                SRUVersion version = parseVersion(reader);
     437                logger.debug("version = {}, requested = {}", version,
     438                        request.getVersionPerformed());
     439
     440                // scanResponse/terms
     441                if (reader.readStart(SRU_NS, "terms", false)) {
     442                    boolean first = true;
     443                    while (reader.readStart(SRU_NS, "term", first)) {
     444                        if (first) {
     445                            first = false;
     446                            handler.onStartTerms();
     447                        }
     448
     449                        // scanResponse/terms/value
     450                        String value = reader
     451                                .readContent(SRU_NS, "value", true);
     452
     453                        // scanResponse/terms/numberOfRecords
     454                        int numberOfRecords = reader.readContent(SRU_NS,
     455                                "numberOfRecords", false, -1);
     456
     457                        // scanResponse/terms/displayTerm
     458                        String displayTerm = reader.readContent(SRU_NS,
     459                                "displayTerm", false);
     460
     461                        // scanResponse/terms/whereInList
     462                        String s = reader.readContent(SRU_NS,
     463                                "whereInList", false);
     464                        WhereInList whereInList = null;
     465                        if (s != null) {
     466                            if ("first".equals(s)) {
     467                                whereInList = WhereInList.FIRST;
     468                            } else if ("last".equals(s)) {
     469                                whereInList = WhereInList.LAST;
     470                            } else if ("only".equals(s)) {
     471                                whereInList = WhereInList.ONLY;
     472                            } else if ("inner".equals(s)) {
     473                                whereInList = WhereInList.INNER;
     474                            } else {
     475                                throw new SRUClientException(
     476                                        "invalid value for 'whereInList': " + s);
     477                            }
     478                        }
     479                        logger.debug("value = {}, numberOfRecords = {}, "
     480                                + "displayTerm = {}, whereInList = {}",
     481                                new Object[] { value, numberOfRecords,
     482                                        displayTerm, whereInList });
     483                        handler.onTerm(value, numberOfRecords, displayTerm,
     484                                whereInList);
     485
     486                        // scanResponse/terms/extraTermData
     487                        if (reader.readStart(SRU_NS, "extraTermData", first)) {
     488                            reader.consumeWhitespace();
     489                            proxy.reset(reader);
     490                            try {
     491                                handler.onExtraTermData(value, proxy);
     492                            } catch (XMLStreamException e) {
     493                                throw new SRUClientException("handler "
     494                                        + "triggered error while parsing "
     495                                        + "'extraTermData'", e);
     496                            }
     497                            reader.consumeWhitespace();
     498                            reader.readEnd(SRU_NS, "extraTermData", true);
     499                        }
     500                        reader.readEnd(SRU_NS, "term", true);
     501
     502                    } // while
     503                    reader.readEnd(SRU_NS, "terms");
     504                    handler.onFinishTerms();
     505                }
     506
     507                // scanResponse/echoedScanRequest
     508                if (reader.readStart(SRU_NS, "echoedScanRequest", false)) {
     509                    reader.readEnd(SRU_NS, "echoedScanRequest", true);
     510                }
     511
     512                // scanResponse/diagnostics
     513                final List<SRUDiagnostic> diagnostics = parseDiagnostics(reader);
     514                if (diagnostics != null) {
     515                    handler.onDiagnostics(diagnostics);
     516                }
     517
     518                // scanResponse/extraResponseData
     519                if (reader.readStart(SRU_NS, "extraResponseData", false)) {
     520                    reader.consumeWhitespace();
     521                    proxy.reset(reader);
     522                    try {
     523                        handler.onExtraResponseData(proxy);
     524                    } catch (XMLStreamException e) {
     525                        throw new SRUClientException("handler triggered "
     526                                + "error while parsing 'extraResponseData'", e);
     527                    }
     528                    reader.consumeWhitespace();
     529                    reader.readEnd(SRU_NS, "extraResponseData", true);
     530                }
     531
     532                reader.readEnd(SRU_NS, "scanResponse");
     533            }
    482534        } catch (XMLStreamException e) {
    483535            throw new SRUClientException(e.getMessage(), e);
    … …  
    486538
    487539
    488     private void parseSearchRetrieveResponse(SRUXMLStreamReader reader,
    489             SRUSearchRetrieveRequest request, SRUSearchRetrieveHandler handler)
    490             throws SRUClientException {
    491         logger.debug("parsing 'serarchRetrieve' response");
     540    private void parseSearchRetrieveResponse(final SRUXMLStreamReader reader,
     541            final SRUSearchRetrieveRequest request,
     542            final SRUSearchRetrieveHandler handler) throws SRUClientException {
    492543        try {
    493             // searchRetrieveResponse
    494             reader.readStart(SRU_NS, "searchRetrieveResponse", true);
    495 
    496             // searchRetrieveResponse/version
    497             SRUVersion version = parseVersion(reader);
    498             logger.debug("version = {}, requested = {}",
    499                     version, this.defaultVersion);
    500 
    501             // searchRetrieveResponse/numberOfRecords
    502             int numberOfRecords = reader.readContent(SRU_NS,
    503                     "numberOfRecords", true, -1);
    504 
    505             // searchRetrieveResponse/resultSetId
    506             int resultSetId = reader.readContent(SRU_NS,
    507                     "resultSetId", false, -1);
    508 
    509             // searchRetrieveResponse/resultSetIdleTime
    510             int resultSetIdleTime = reader.readContent(SRU_NS,
    511                     "resultSetIdleTime", false, -1);
    512 
    513             logger.debug("numberOfRecords = {}, resultSetId = {}, "
    514                     + "resultSetIdleTime = {}", new Object[] {
    515                                                     numberOfRecords,
    516                                                     resultSetId,
    517                                                     resultSetIdleTime
    518                                                 });
    519 
    520             // searchRetrieveResponse/results
    521             if (numberOfRecords > 0) {
    522                 reader.readStart(SRU_NS, "records", true);
    523 
    524                 // searchRetrieveResponse/records/record
    525                 boolean first = true;
    526                 while (reader.readStart(SRU_NS, "record", first)) {
    527                     if (first) {
    528                         first = false;
    529                         handler.onStartRecords(numberOfRecords,
    530                                 resultSetId, resultSetIdleTime);
     544            /*
     545             * if the endpoint cannot determine the operation, it should create
     546             * a explain response.
     547             */
     548            if (reader.peekStart(SRU_NS, "explainResponse")) {
     549                parseExplainResponse(reader, request, new SRUExplainHandler() {
     550                    @Override
     551                    public void onRequestStatistics(int bytes, long millisTotal,
     552                            long millisNetwork, long millisParsing) {
    531553                    }
    532554
    533                     String schema = reader.readContent(SRU_NS,
    534                             "recordSchema", true);
    535 
    536                     SRURecordPacking packing = parseRecordPacking(reader);
    537 
    538                     logger.debug("schema = {}, packing = {}, requested packing = {}",
    539                             new Object[] { schema, packing,
    540                                     request.getRecordPacking() });
    541 
    542                     if ((request.getRecordPacking() != null) &&
    543                             (packing != request.getRecordPacking())) {
    544                         logger.warn("requested '{}' record packing, but server responded with '{}' record packing",
    545                                 request.getRecordPacking().toProtocolString(),
    546                                 packing.toProtocolString());
    547                         // XXX: only throw if client is pedantic?
    548                         throw new SRUClientException(
    549                                 "requested '" +
    550                                         request.getRecordPacking()
    551                                                 .toProtocolString() +
    552                                         "' record packing, but server responded with '" +
    553                                         packing.toProtocolString() +
    554                                         "' record packing");
     555
     556                    @Override
     557                    public void onExtraResponseData(XMLStreamReader reader)
     558                            throws XMLStreamException, SRUClientException {
    555559                    }
    556560
    557                     // searchRetrieveResponse/record/recordData
    558                     reader.readStart(SRU_NS, "recordData", true);
     561
     562                    @Override
     563                    public void onDiagnostics(List<SRUDiagnostic> diagnostics)
     564                            throws SRUClientException {
     565                        handler.onDiagnostics(diagnostics);
     566                    }
     567                });
     568            } else {
     569                logger.debug("parsing 'serarchRetrieve' response");
     570
     571                // searchRetrieveResponse
     572                reader.readStart(SRU_NS, "searchRetrieveResponse", true);
     573
     574                // searchRetrieveResponse/version
     575                SRUVersion version = parseVersion(reader);
     576                logger.debug("version = {}, requested = {}", version,
     577                        request.getVersionPerformed());
     578
     579                // searchRetrieveResponse/numberOfRecords
     580                int numberOfRecords = reader.readContent(SRU_NS,
     581                        "numberOfRecords", true, -1);
     582
     583                // searchRetrieveResponse/resultSetId
     584                int resultSetId = reader.readContent(SRU_NS,
     585                        "resultSetId", false, -1);
     586
     587                // searchRetrieveResponse/resultSetIdleTime
     588                int resultSetIdleTime = reader.readContent(SRU_NS,
     589                        "resultSetIdleTime", false, -1);
     590
     591                logger.debug("numberOfRecords = {}, resultSetId = {}, "
     592                        + "resultSetIdleTime = {}", new Object[] {
     593                        numberOfRecords, resultSetId, resultSetIdleTime });
     594
     595                // searchRetrieveResponse/results
     596                if (numberOfRecords > 0) {
     597                    reader.readStart(SRU_NS, "records", true);
     598
     599                    // searchRetrieveResponse/records/record
     600                    boolean first = true;
     601                    while (reader.readStart(SRU_NS, "record", first)) {
     602                        if (first) {
     603                            first = false;
     604                            handler.onStartRecords(numberOfRecords,
     605                                    resultSetId, resultSetIdleTime);
     606                        }
     607
     608                        String schema = reader.readContent(SRU_NS,
     609                                "recordSchema", true);
     610
     611                        SRURecordPacking packing = parseRecordPacking(reader);
     612
     613                        logger.debug("schema = {}, packing = {}, requested packing = {}",
     614                                new Object[] { schema, packing,
     615                                        request.getRecordPacking() });
     616
     617                        if ((request.getRecordPacking() != null) &&
     618                                (packing != request.getRecordPacking())) {
     619                            logger.warn("requested '{}' record packing, but server responded with '{}' record packing",
     620                                    request.getRecordPacking()
     621                                            .toProtocolString(), packing
     622                                            .toProtocolString());
     623                            // XXX: only throw if client is pedantic?
     624                            throw new SRUClientException(
     625                                    "requested '" +
     626                                            request.getRecordPacking()
     627                                                    .toProtocolString() +
     628                                            "' record packing, but server responded with '" +
     629                                            packing.toProtocolString() +
     630                                            "' record packing");
     631                        }
     632
     633                        // searchRetrieveResponse/record/recordData
     634                        reader.readStart(SRU_NS, "recordData", true);
     635                        reader.consumeWhitespace();
     636
     637                        SRURecordData recordData = null;
     638                        SRUDiagnostic surrogate = null;
     639                        SRUXMLStreamReader recordReader = null;
     640
     641                        if (packing == SRURecordPacking.STRING) {
     642                            /*
     643                             * read content into temporary buffer and then use
     644                             * a new XML reader to parse record data
     645                             */
     646                            final String data = reader.readString(true);
     647                            InputStream in =
     648                                    new ByteArrayInputStream(data.getBytes());
     649                            // FIXME: namespace context?
     650                            recordReader = createReader(in, false);
     651                        } else {
     652                            recordReader = reader;
     653                        }
     654
     655                        if (SRU_DIAGNOSTIC_RECORD_SCHEMA.equals(schema)) {
     656                            surrogate = parseDiagnostic(recordReader, true);
     657                        } else {
     658                            SRURecordDataParser parser = parsers.get(schema);
     659                            if (parser != null) {
     660                                try {
     661                                    proxy.reset(recordReader);
     662                                    recordData = parser.parse(proxy);
     663                                } catch (XMLStreamException e) {
     664                                    throw new SRUClientException(
     665                                            "error parsing record", e);
     666                                }
     667                            } else {
     668                                // FIXME: handle this better?
     669                                logger.debug("no record parser found for schema '{}'",
     670                                        schema);
     671                            }
     672                        }
     673
     674                        if (packing == SRURecordPacking.STRING) {
     675                            recordReader.closeCompletly();
     676                        }
     677
     678                        reader.consumeWhitespace();
     679                        reader.readEnd(SRU_NS, "recordData", true);
     680
     681                        String identifier = null;
     682                        if (version == SRUVersion.VERSION_1_2) {
     683                            identifier = reader.readContent(SRU_NS,
     684                                    "recordIdentifier", false);
     685                        }
     686
     687                        int position = reader.readContent(SRU_NS,
     688                                "recordPosition", false, -1);
     689
     690                        logger.debug("recordIdentifier = {}, recordPosition = {}",
     691                                identifier, position);
     692
     693                        // notify handler
     694                        if (surrogate != null) {
     695                            handler.onSurrogateRecord(identifier,
     696                                    position, surrogate);
     697                        } else {
     698                            if (recordData != null) {
     699                                handler.onRecord(identifier,
     700                                        position, recordData);
     701                            }
     702                        }
     703
     704                        if (reader.readStart(SRU_NS, "extraRecordData", false)) {
     705                            reader.consumeWhitespace();
     706                            proxy.reset(reader);
     707                            try {
     708                                handler.onExtraRecordData(identifier,
     709                                        position, proxy);
     710                            } catch (XMLStreamException e) {
     711                                throw new SRUClientException("handler "
     712                                        + "triggered error while parsing "
     713                                        + "'extraRecordData'", e);
     714                            }
     715                            reader.consumeWhitespace();
     716                            reader.readEnd(SRU_NS, "extraRecordData", true);
     717                        }
     718
     719                        reader.readEnd(SRU_NS, "record");
     720                    } // while
     721                    reader.readEnd(SRU_NS, "records");
     722                }
     723
     724                int nextRecordPosition = reader.readContent(SRU_NS,
     725                        "nextRecordPosition", false, -1);
     726                logger.debug("nextRecordPosition = {}", nextRecordPosition);
     727                handler.onFinishRecords(nextRecordPosition);
     728
     729                // searchRetrieveResponse/echoedSearchRetrieveResponse
     730                if (reader.readStart(SRU_NS,
     731                        "echoedSearchRetrieveRequest", false)) {
     732                    reader.readEnd(SRU_NS, "echoedSearchRetrieveRequest", true);
     733                }
     734
     735                // searchRetrieveResponse/diagnostics
     736                final List<SRUDiagnostic> diagnostics = parseDiagnostics(reader);
     737                if (diagnostics != null) {
     738                    handler.onDiagnostics(diagnostics);
     739                }
     740
     741                // explainResponse/extraResponseData
     742                if (reader.readStart(SRU_NS, "extraResponseData", false)) {
    559743                    reader.consumeWhitespace();
    560 
    561                     SRURecordData recordData = null;
    562                     SRUDiagnostic surrogate = null;
    563                     SRUXMLStreamReader recordReader = null;
    564 
    565                     if (packing == SRURecordPacking.STRING) {
    566                         /*
    567                          * read content into temporary buffer and then use a new
    568                          * XML reader to parse record data
    569                          */
    570                         final String data = reader.readString(true);
    571                         InputStream in = new ByteArrayInputStream(
    572                                 data.getBytes());
    573                         // FIXME: namespace context?
    574                         recordReader = createReader(in, false);
    575                     } else {
    576                         recordReader = reader;
     744                    proxy.reset(reader);
     745                    try {
     746                        handler.onExtraResponseData(proxy);
     747                    } catch (XMLStreamException e) {
     748                        throw new SRUClientException("handler triggered "
     749                                + "error while parsing 'extraResponseData'", e);
    577750                    }
    578 
    579                     if (SRU_DIAGNOSTIC_RECORD_SCHEMA.equals(schema)) {
    580                         surrogate = parseDiagnostic(recordReader, true);
    581                     } else {
    582                         SRURecordDataParser parser = parsers.get(schema);
    583                         if (parser != null) {
    584                             try {
    585                                 proxy.reset(recordReader);
    586                                 recordData = parser.parse(proxy);
    587                             } catch (XMLStreamException e) {
    588                                 throw new SRUClientException(
    589                                         "error parsing record", e);
    590                             }
    591                         } else {
    592                             // FIXME: handle this better?
    593                             logger.debug(
    594                                     "no record parser found for schema '{}'",
    595                                     schema);
    596                         }
    597                     }
    598 
    599                     if (packing == SRURecordPacking.STRING) {
    600                         recordReader.closeCompletly();
    601                     }
    602 
    603751                    reader.consumeWhitespace();
    604                     reader.readEnd(SRU_NS, "recordData", true);
    605 
    606                     String identifier = null;
    607                     if (version == SRUVersion.VERSION_1_2) {
    608                         identifier = reader.readContent(SRU_NS,
    609                                 "recordIdentifier", false);
    610                     }
    611 
    612                     int position = reader.readContent(SRU_NS, "recordPosition",
    613                             false, -1);
    614 
    615                     logger.debug("recordIdentifier = {}, recordPosition = {}",
    616                             identifier, position);
    617 
    618                     // notify handler
    619                     if (surrogate != null) {
    620                         handler.onSurrogateRecord(identifier, position,
    621                                 surrogate);
    622                     } else {
    623                         if (recordData != null) {
    624                             handler.onRecord(identifier, position, recordData);
    625                         }
    626                     }
    627 
    628                     if (reader.readStart(SRU_NS, "extraRecordData", false)) {
    629                         reader.consumeWhitespace();
    630                         proxy.reset(reader);
    631                         try {
    632                             handler.onExtraRecordData(identifier, position,
    633                                     proxy);
    634                         } catch (XMLStreamException e) {
    635                             throw new SRUClientException("handler "
    636                                     + "triggered error while parsing "
    637                                     + "'extraRecordData'", e);
    638                         }
    639                         reader.consumeWhitespace();
    640                         reader.readEnd(SRU_NS, "extraRecordData", true);
    641                     }
    642 
    643                     reader.readEnd(SRU_NS, "record");
    644                 } // while
    645                 reader.readEnd(SRU_NS, "records");
    646             }
    647 
    648             int nextRecordPosition = reader.readContent(SRU_NS,
    649                     "nextRecordPosition", false, -1);
    650             logger.debug("nextRecordPosition = {}", nextRecordPosition);
    651             handler.onFinishRecords(nextRecordPosition);
    652 
    653             // searchRetrieveResponse/echoedSearchRetrieveResponse
    654             if (reader.readStart(SRU_NS, "echoedSearchRetrieveRequest", false)) {
    655                 reader.readEnd(SRU_NS, "echoedSearchRetrieveRequest", true);
    656             }
    657 
    658             // searchRetrieveResponse/diagnostics
    659             final List<SRUDiagnostic> diagnostics = parseDiagnostics(reader);
    660             if (diagnostics != null) {
    661                 handler.onDiagnostics(diagnostics);
    662             }
    663 
    664             // explainResponse/extraResponseData
    665             if (reader.readStart(SRU_NS, "extraResponseData", false)) {
    666                 reader.consumeWhitespace();
    667                 proxy.reset(reader);
    668                 try {
    669                     handler.onExtraResponseData(proxy);
    670                 } catch (XMLStreamException e) {
    671                     throw new SRUClientException("handler triggered "
    672                             + "error while parsing 'extraResponseData'", e);
    673                 }
    674                 reader.consumeWhitespace();
    675                 reader.readEnd(SRU_NS, "extraResponseData", true);
    676             }
    677 
    678             reader.readEnd(SRU_NS, "searchRetrieveResponse");
     752                    reader.readEnd(SRU_NS, "extraResponseData", true);
     753                }
     754
     755                reader.readEnd(SRU_NS, "searchRetrieveResponse");
     756            }
    679757        } catch (XMLStreamException e) {
    680758            throw new SRUClientException(e.getMessage(), e);
    … …  
    701779            SRUXMLStreamReader reader) throws XMLStreamException,
    702780            SRUClientException {
    703         logger.debug("XXX: try diagnostics: {}", reader.dumpState());
    704781        if (reader.readStart(SRU_NS, "diagnostics", false)) {
    705782            List<SRUDiagnostic> diagnostics = null;
    … …  
    745822        }
    746823    }
     824
    747825
    748826    private static SRURecordPacking parseRecordPacking(SRUXMLStreamReader reader)
Note: See TracChangeset for help on using the changeset viewer.