Changeset 6787

Timestamp:

11/10/15 10:52:04 (9 years ago)

Author:

Oliver Schonefeld

Message:

• re-work version and operation detection mechanism (still needs more re-factoring)

Location:

SRUServer/trunk/src/main/java/eu/clarin/sru/server

Files:

• SRURequestImpl.java (modified) (5 diffs)
• SRUServer.java (modified) (3 diffs)
• SRUServerConfig.java (modified) (10 diffs)

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRURequestImpl.java

@@ -206 +206 @@
      */
     boolean checkParameters() {
-        /*
-         * FIXME: those parameters must be inject from "outside" (probably
-         *        by the appropriate Servlet instance)
-         */
         final SRUVersion minVersion = config.getMinVersion();
         final SRUVersion maxVersion = config.getMaxVersion();
+
+        /*
+         * generally assume, we will also allow processing of SRU 1.1 or 1.2
+         */
+        boolean processSruOld = true;
 
         /*
@@ -220 +221 @@
         if (maxVersion.compareTo(SRUVersion.VERSION_2_0) >= 0) {
             if (getParameter(PARAM_VERSION, false, false) == null) {
+                /*
+                 * Ok, we're committed to SRU 2.0 now, so don't allow processing
+                 * of SRU 1.1 and 1.2 ...
+                 */
+                processSruOld = false;
+
                 logger.debug("handling request as SRU 2.0, because no '{}' " +
                         "parameter was found in the request", PARAM_VERSION);
@@ -246 +253 @@
                 if (op != null) {
                     /*
-                     * XXX: if operation is searchRetrive an operation parameter,
-                     * is also searchRetrieve, the server may ignore it
+                     * XXX: if operation is searchRetrive and the 'operation'
+                     * parameter is also searchRetrieve, should the server just
+                     * ignore it?
                      */
                     if (!(operation == SRUOperation.SEARCH_RETRIEVE) &&
                             op.equals(OP_SEARCH_RETRIEVE)) {
                         addDiagnostic(SRUConstants.SRU_UNSUPPORTED_PARAMETER,
-                                PARAM_OPERATION, "Parameter '" +
+                                PARAM_OPERATION, "Parameter \"" +
                                         PARAM_OPERATION +
-                                        "' is not valid for SRU version 2.0");
+                                        "\" is not valid for SRU version 2.0");
                     }
                 }
@@ -260 +268 @@
                 logger.debug("handling request as legacy SRU, because found " +
                         "parameter '{}' in request", PARAM_VERSION);
-
-                // parse mandatory operation parameter
-                final String op = getParameter(PARAM_OPERATION, false, false);
-                if (op != null) {
-                    if (!op.isEmpty()) {
-                        if (op.equals(OP_EXPLAIN)) {
-                            this.operation = SRUOperation.EXPLAIN;
-                        } else if (op.equals(OP_SCAN)) {
-                            this.operation = SRUOperation.SCAN;
-                        } else if (op.equals(OP_SEARCH_RETRIEVE)) {
-                            this.operation = SRUOperation.SEARCH_RETRIEVE;
-                        } else {
-                            addDiagnostic(SRUConstants.SRU_UNSUPPORTED_OPERATION,
-                                    null, "Operation \"" + op + "\" is not supported.");
-                        }
+            }
+        }
+
+        if (processSruOld) {
+            // parse mandatory operation parameter
+            final String op = getParameter(PARAM_OPERATION, false, false);
+            if (op != null) {
+                if (!op.isEmpty()) {
+                    if (op.equals(OP_EXPLAIN)) {
+                        operation = SRUOperation.EXPLAIN;
+                    } else if (op.equals(OP_SCAN)) {
+                        operation = SRUOperation.SCAN;
+                    } else if (op.equals(OP_SEARCH_RETRIEVE)) {
+                        operation = SRUOperation.SEARCH_RETRIEVE;
                     } else {
                         addDiagnostic(SRUConstants.SRU_UNSUPPORTED_OPERATION,
-                                null, "An empty parameter \"" +
-                                        PARAM_OPERATION +
-                                      "\" is not supported.");
+                                null, "Operation \"" + op + "\" is not supported.");
                     }
-
-                    // parse and check version
-                    version = parseAndCheckVersionParameter(operation);
                 } else {
-                    /*
-                     * absent parameter should be interpreted as "explain"
-                     */
-                    operation = SRUOperation.EXPLAIN;
-
-                    // parse and check version
-                    version = parseAndCheckVersionParameter(operation);
+                    addDiagnostic(SRUConstants.SRU_UNSUPPORTED_OPERATION,
+                            null, "An empty parameter \"" +
+                                    PARAM_OPERATION +
+                                  "\" is not supported.");
                 }
-            }
-        }
-
-        if ((version == null) || (operation == null)) {
-            logger.error("internal error!!!!1elf");
-        }
-
-        if (minVersion.compareTo(version) < 0) {
-            addDiagnostic(SRUConstants.SRU_UNSUPPORTED_VERSION,
-                    version.getVersionString(), "Version '{}' is not supported by this endpoint");
-        }
-        return checkParameters2();
-    }
-
-
-    boolean checkParameters2() {
-
+
+                // parse and check version
+                version = parseAndCheckVersionParameter(operation);
+            } else {
+                /*
+                 * absent parameter should be interpreted as "explain"
+                 */
+                operation = SRUOperation.EXPLAIN;
+
+                // parse and check version
+                version = parseAndCheckVersionParameter(operation);
+            }
+        }
+
+
+        /*
+         * sanity check
+         */
+        if ((version != null) && (operation != null)) {
+            logger.debug("min = {}, min? = {}, max = {}, max? = {}, version = {}",
+                    minVersion,
+                    version.compareTo(minVersion),
+                    maxVersion,
+                    version.compareTo(maxVersion),
+                    version);
+            if ((version.compareTo(minVersion) >= 0) &&
+                    (version.compareTo(maxVersion) <= 0)) {
+                /*
+                 * FIXME: re-factor to make this nicer ...
+                 */
+                this.version   = version;
+                this.operation = operation;
+                return checkParameters2();
+            } else {
+                addDiagnostic(SRUConstants.SRU_UNSUPPORTED_VERSION,
+                        maxVersion.getVersionString(),
+                        "Version \"" + version.getVersionString() +
+                        "\" is not supported by this endpoint.");
+            }
+        }
+        logger.debug("bailed");
+        return false;
+    }
+
+
+    private boolean checkParameters2() {
         if (diagnostics == null) {
             // check mandatory/optional parameters for operation
@@ -457 +485 @@
         }
 
-        // diagnostics != null -> consider as success
+        /*
+         *  diagnostics == null -> consider as success
+         *  FIXME: this should ne done nicer!
+         */
         return (diagnostics == null);
     }

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUServer.java

@@ -1141 +1141 @@
             /* FALL-THROUGH */
         case VERSION_1_2:
-            return NAMESPACES_LEGACY;
+            switch (config.getLegacyNamespaceMode()) {
+            case LOC:
+                return NAMESPACES_LEGACY_LOC;
+            case OASIS:
+                return NAMESPACES_1_2_OASIS;
+            default:
+                // FIXME: better exception?
+                throw new IllegalAccessError("invalid legacy mode: " + version);
+            } // switch
         case VERSION_2_0:
             return NAMESPACES_2_0;
@@ -1153 +1161 @@
 
 
-    private static final SRUNamespaces NAMESPACES_LEGACY = new SRUNamespaces() {
+    private static final SRUNamespaces NAMESPACES_LEGACY_LOC = new SRUNamespaces() {
         private static final String SRU_NS =
                 "http://www.loc.gov/zing/srw/";
@@ -1191 +1199 @@
         public String getScanPrefix() {
             return SRU_PREFIX;
+        }
+
+
+        @Override
+        public String getDiagnosticNS() {
+            return SRU_DIAGNOSIC_NS;
+        }
+
+
+        @Override
+        public String getDiagnosticPrefix() {
+            return SRU_DIAGNOSTIC_PREFIX;
+        }
+
+
+        @Override
+        public String getExplainNS() {
+            return SRU_EXPLAIN_NS;
+        }
+
+
+        @Override
+        public String getExplainPrefix() {
+            return SRU_EXPLAIN_PREFIX;
+        }
+
+
+        @Override
+        public String getXcqlNS() {
+            return SRU_XCQL_NS;
+        }
+    };
+
+
+    private static final SRUNamespaces NAMESPACES_1_2_OASIS = new SRUNamespaces() {
+        private static final String SRU_RESPONSE_NS =
+                "http://docs.oasis-open.org/ns/search-ws/sruResponse";
+        private static final String SRU_RESPONSE_PREFIX =
+                "sruResponse";
+        private static final String SRU_SCAN_NS =
+                "http://docs.oasis-open.org/ns/search-ws/scan";
+        private static final String SRU_SCAN_PREFIX =
+                "scan";
+        private static final String SRU_DIAGNOSIC_NS =
+                "http://docs.oasis-open.org/ns/search-ws/diagnostic";
+        private static final String SRU_DIAGNOSTIC_PREFIX =
+                "diag";
+        private static final String SRU_EXPLAIN_NS =
+                "http://explain.z3950.org/dtd/2.0/";
+        private static final String SRU_EXPLAIN_PREFIX =
+                "zr";
+        private static final String SRU_XCQL_NS =
+                "http://docs.oasis-open.org/ns/search-ws/xcql";
+
+
+        @Override
+        public String getResponseNS() {
+            return SRU_RESPONSE_NS;
+        }
+
+
+        @Override
+        public String getResponsePrefix() {
+            return SRU_RESPONSE_PREFIX;
+        }
+
+
+        @Override
+        public String getScanNS() {
+            return SRU_SCAN_NS;
+        }
+
+
+        @Override
+        public String getScanPrefix() {
+            return SRU_SCAN_PREFIX;
         }
 

SRUServer/trunk/src/main/java/eu/clarin/sru/server/SRUServerConfig.java

@@ -89 +89 @@
      * Valid values: "<code>1.1</code>", "<code>1.2</code>" or "
      * <code>2.0</code>" (without quotation marks)
-     * <p>
+     * </p>
      */
     public static final String SRU_SUPPORTED_VERSION_MIN =
@@ -99 +99 @@
      * Valid values: "<code>1.1</code>", "<code>1.2</code>" or "
      * <code>2.0</code>" (without quotation marks)
-     * <p>
+     * </p>
      */
     public static final String SRU_SUPPORTED_VERSION_MAX =
@@ -112 +112 @@
      * Valid values: "<code>1.1</code>", "<code>1.2</code>" or "
      * <code>2.0</code>" (without quotation marks)
-     * <p>
+     * </p>
      */
     public static final String SRU_SUPPORTED_VERSION_DEFAULT =
             "eu.clarin.sru.server.sruSupportedVersionDefault";
+    /**
+     * Parameter constant for setting the namespace URIs for SRU 1.1 and SRU
+     * 1.2.
+     * <p>
+     * Valid values: "<code>loc"</code> for Library Of Congress URI or "
+     * <code>oasis</code> for OASIS URIs (without quotation marks).
+     * </p>
+     */
+    public static final String SRU_LEGACY_NAMESPACE_MODE =
+            "eu.clarin.sru.server.legacyNamespaceMode";
     /**
      * Parameter constant for configuring the transports for this SRU server.
@@ -268 +278 @@
     private static final SRUVersion DEFAULT_SRU_VERSION_MAX =
             SRUVersion.VERSION_1_2;
+    private static final LegacyNamespaceMode DEFAULT_LEGACY_NAMESPACE_MODE =
+            LegacyNamespaceMode.LOC;
     private static final int DEFAULT_NUMBER_OF_RECORDS    = 100;
     private static final int DEFAULT_MAXIMUM_RECORDS      = 250;
@@ -277 +289 @@
     private static final String CONFIG_FILE_SCHEMA_URL =
             "META-INF/sru-server-config.xsd";
+    public static enum LegacyNamespaceMode {
+        LOC, OASIS
+    } // enum LegacyNamespaceMode
 
     public static final class LocalizedString {
@@ -603 +618 @@
     private final SRUVersion maxVersion;
     private final SRUVersion defaultVersion;
+    private final LegacyNamespaceMode legacyNamespaceMode;
     private final String transport;
     private final String host;
@@ -623 +639 @@
 
 
-    private SRUServerConfig(SRUVersion minVersion, SRUVersion maxVersion,
-            SRUVersion defaultVersion, String transport, String host, int port,
-            String database, int numberOfRecords, int maximumRecords,
-            int numberOfTerms, int maximumTerms, boolean echoRequests,
-            int indentResponse, int responseBufferSize,
+    private SRUServerConfig(SRUVersion minVersion,
+            SRUVersion maxVersion,
+            SRUVersion defaultVersion,
+            LegacyNamespaceMode legacyNamespaceMode,
+            String transport,
+            String host,
+            int port,
+            String database,
+            int numberOfRecords,
+            int maximumRecords,
+            int numberOfTerms,
+            int maximumTerms,
+            boolean echoRequests,
+            int indentResponse,
+            int responseBufferSize,
             boolean allowOverrideMaximumRecords,
             boolean allowOverrideMaximumTerms,
-            boolean allowOverrideIndentResponse, DatabaseInfo databaseinfo,
-            IndexInfo indexInfo, List<SchemaInfo> schemaInfo) {
+            boolean allowOverrideIndentResponse,
+            DatabaseInfo databaseinfo,
+            IndexInfo indexInfo,
+            List<SchemaInfo> schemaInfo) {
         this.minVersion                  = minVersion;
         this.maxVersion                  = maxVersion;
         this.defaultVersion              = defaultVersion;
+        this.legacyNamespaceMode         = legacyNamespaceMode;
         this.transport                   = transport;
         this.host                        = host;
@@ -683 +712 @@
 
 
+    public LegacyNamespaceMode getLegacyNamespaceMode() {
+        return legacyNamespaceMode;
+    }
+
+
     public SRURecordPacking getDefaultRecordPacking() {
         return SRURecordPacking.XML;
@@ -952 +986 @@
                                 SRU_SUPPORTED_VERSION_MAX + "\" (" +
                                 maxVersion.getVersionString() + ")");
+            }
+
+            LegacyNamespaceMode legacyNamespaceMode =
+                    DEFAULT_LEGACY_NAMESPACE_MODE;
+            String mode = params.get(SRU_LEGACY_NAMESPACE_MODE);
+            if ((mode != null) && !mode.isEmpty()) {
+                if ("loc".equals(mode)) {
+                    legacyNamespaceMode = LegacyNamespaceMode.LOC;
+                } else if ("oasis".equals(mode)) {
+                    legacyNamespaceMode = LegacyNamespaceMode.OASIS;
+                } else {
+                    throw new SRUConfigException(
+                            "invalid value for parameter \"" +
+                                    SRU_LEGACY_NAMESPACE_MODE + "\": " + mode);
+                }
             }
 
@@ -1026 +1075 @@
                     DEFAULT_RESPONSE_BUFFER_SIZE, 0, -1);
 
-            return new SRUServerConfig(minVersion, maxVersion, defaultVersion,
-                    transport, host, port, database, numberOfRecords,
-                    maximumRecords, numberOfTerms, maximumTerms, echoRequests,
-                    indentResponse, responseBufferSize,
-                    allowOverrideMaximumRecords, allowOverrideMaximumTerms,
-                    allowOverrideIndentResponse, databaseInfo, indexInfo,
+            return new SRUServerConfig(minVersion,
+                    maxVersion,
+                    defaultVersion,
+                    legacyNamespaceMode,
+                    transport,
+                    host,
+                    port,
+                    database,
+                    numberOfRecords,
+                    maximumRecords,
+                    numberOfTerms,
+                    maximumTerms,
+                    echoRequests,
+                    indentResponse,
+                    responseBufferSize,
+                    allowOverrideMaximumRecords,
+                    allowOverrideMaximumTerms,
+                    allowOverrideIndentResponse,
+                    databaseInfo,
+                    indexInfo,
                     schemaInfo);
         } catch (IOException e) {