Changeset 340


Ignore:
Timestamp:
04/12/10 12:28:01 (14 years ago)
Author:
oschonef
Message:
  • re-factor
  • re-work argument evaluation
Location:
VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/OAIProvider.java

    r321 r340  
    11package eu.clarin.cmdi.virtualcollectionregistry.oai;
    22
     3import java.io.PrintWriter;
    34import java.util.ArrayList;
    45import java.util.List;
     6import java.util.Set;
    57
    68import org.slf4j.Logger;
    79import org.slf4j.LoggerFactory;
    810
     11import eu.clarin.cmdi.virtualcollectionregistry.oai.verb.Argument;
    912import eu.clarin.cmdi.virtualcollectionregistry.oai.verb.GetRecordVerb;
    1013import eu.clarin.cmdi.virtualcollectionregistry.oai.verb.IdentifyVerb;
    … …  
    2528        }
    2629
    27         public void process(VerbContext ctx) throws OAIException {
     30        public void process(VerbContextImpl ctx) throws OAIException {
     31                String verbName = ctx.getParameter("verb");
     32                if (verbName == null) {
     33                        throw new OAIException("missing verb");
     34                }
     35                if (ctx.isParameterMultivalued("verb")) {
     36                        throw new OAIException("multiple verb arguments");
     37                }
     38
    2839                Verb verb = null;
     40                for (Verb v : verbs) {
     41                        if (verbName.equals(v.getName())) {
     42                                verb = v;
     43                                break;
     44                        }
     45                } // for
    2946
    30                 String verbArg = ctx.getArgument("verb");
    31                 if (verbArg != null && !verbArg.isEmpty()) {
    32                         for (Verb v : verbs) {
    33                                 if (verbArg.equals(v.getName())) {
    34                                         verb = v;
    35                                         break;
     47                if (verb != null) {
     48                        Set<String> remaining = ctx.getParameterNames();
     49                        for (Argument arg : verb.getArguments()) {
     50                                String value = ctx.getParameter(arg.getName());
     51                                if ((value == null) && arg.isRequired()) {
     52                                        ctx.addError(OAIErrorCode.BAD_ARGUMENT,
     53                                                                        "OAI verb '" + verbName +
     54                                        "' requires argument '" +
     55                                        arg.getName() + "'");
     56                                } else {
     57                                        remaining.remove(arg.getName());
     58                                        if (ctx.isParameterMultivalued(arg.getName())) {
     59                                                ctx.addError(OAIErrorCode.BAD_ARGUMENT,
     60                                                                "OAI verb '" + verbName +
     61                                                                "' illegally has multiple values for " +
     62                                                                "argument '" + arg.getName() + "'");
     63                                        } else {
     64                                                logger.debug("key: {}, value: {}",
     65                                                                         arg.getName(), value);
     66                                                try {
     67                                                        arg.validateArgument(value);
     68                                                        ctx.setArgument(arg.getName(), value);
     69                                                } catch (OAIException e) {
     70                                                        ctx.addError(OAIErrorCode.BAD_ARGUMENT,
     71                                                                        "Value of argument '" +
     72                                                                        arg.getName() + "' of OAI verb '" +
     73                                                                        verbName + "' is invalid: " +
     74                                                                        e.getMessage());
     75                                                }
     76                                        }
    3677                                }
    3778                        } // for
    38                         if (verb == null) {
    39                                 ctx.addError(OAIErrorCode.BAD_VERB, "illegal OAI verb '" +
    40                                                 verbArg + "'");
     79
     80                        if (!remaining.isEmpty()) {
     81                                for (String key : remaining) {
     82                                        ctx.addError(OAIErrorCode.BAD_ARGUMENT,
     83                                                                 "superfluous argument '" + key + "'");
     84                                }
     85                        } else {
     86                                logger.debug("processing verb '{}'", verb.getName());
     87                                verb.process(ctx);
    4188                        }
    4289                } else {
    43                         ctx.addError(OAIErrorCode.BAD_VERB, "missing OAI verb");
     90                        ctx.addError(OAIErrorCode.BAD_VERB, "illegal OAI verb '" +
     91                                        verbName + "'");
    4492                }
    4593
    46                 if ((verb != null) && !ctx.hasErrors()) {
    47                         logger.debug("processing verb '{}'", verb.getName());
    48                         verb.process(ctx);
    49                 }
    5094                if (ctx.hasErrors()) {
     95                        PrintWriter out = new PrintWriter(ctx.getWriter());
     96                        out.println("OAI protocol error:");
    5197                        // XXX: just testing ...
     98                        logger.error("OAI-CONTEXT: {}", ctx.getRequestURI());
    5299                        for (VerbContext.Error error : ctx.getErrors()) {
    53100                                logger.error("OAI-ERROR ({}): {}",
    54101                                                         error.getCode(), error.getMessage());
     102                                out.println(error.getCode() + ": " + error.getMessage());
    55103                        }
    56104                }

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/OAIProviderServlet.java

    r321 r340  
    1717import org.slf4j.Logger;
    1818import org.slf4j.LoggerFactory;
    19 
    20 import eu.clarin.cmdi.virtualcollectionregistry.oai.verb.VerbContext;
    2119
    2220public class OAIProviderServlet extends HttpServlet {
    … …  
    5351                try {
    5452                        resp.setCharacterEncoding("utf-8");
    55                         VerbContext ctx = new VerbContextImpl(provider, req, resp);
     53                        VerbContextImpl ctx = new VerbContextImpl(provider, req, resp);
    5654                        provider.process(ctx);
    5755                } catch (OAIException e) {
    … …  
    6866                        df.setTimeZone(TimeZone.getTimeZone("UTC"));
    6967                       
    70                         XMLOutputFactory factory = XMLOutputFactory.newFactory();
     68                        XMLOutputFactory factory = XMLOutputFactory.newInstance();
    7169                        XMLStreamWriter out = factory.createXMLStreamWriter(writer);
    7270                        out.writeStartDocument("utf-8", "1.0");

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/VerbContextImpl.java

    r321 r340  
    11package eu.clarin.cmdi.virtualcollectionregistry.oai;
    22
     3import java.io.IOException;
     4import java.io.Writer;
    35import java.util.ArrayList;
    46import java.util.Collections;
     7import java.util.HashMap;
     8import java.util.HashSet;
     9import java.util.Iterator;
    510import java.util.List;
     11import java.util.Map;
     12import java.util.Set;
    613
    7 import javax.servlet.ServletRequest;
    8 import javax.servlet.ServletResponse;
     14import javax.servlet.http.HttpServletRequest;
     15import javax.servlet.http.HttpServletResponse;
    916
    1017import eu.clarin.cmdi.virtualcollectionregistry.oai.verb.VerbContext;
    … …  
    3239        } // class ErrorImpl
    3340        private final OAIProvider provider;
    34         private final ServletRequest request;
    35         private final ServletResponse response;
     41        private final HttpServletRequest request;
     42        private final HttpServletResponse response;
     43        private Map<String, String> arguments = null;
    3644        private List<Error> errors = null;
    3745
    38         VerbContextImpl(OAIProvider provider, ServletRequest request, ServletResponse response) {
     46        VerbContextImpl(OAIProvider provider,
     47                                    HttpServletRequest request,
     48                                    HttpServletResponse response) {
    3949                super();
    4050                this.provider = provider;
    4151                this.request  = request;
    4252                this.response = response;
     53        }
     54
     55        public String getParameter(String name) {
     56                String value = request.getParameter(name);
     57                if (value != null) {
     58                        value = value.trim();
     59                        if (!value.isEmpty()) {
     60                                return value;
     61                        }
     62                }
     63                return null;
     64        }
     65
     66        public boolean isParameterMultivalued(String name) {
     67                String[] params = request.getParameterValues(name);
     68                if (params != null) {
     69                        return params.length > 1;
     70                }
     71                return false;
     72        }
     73
     74        public Set<String> getParameterNames() {
     75                Set<String> names = new HashSet<String>();
     76                for (Iterator<?> i = request.getParameterMap().keySet().iterator();
     77                         i.hasNext(); ) {
     78                        String s = (String) i.next();
     79                        if (s.equalsIgnoreCase("verb")) {
     80                                continue;
     81                        }
     82                        names.add(s);
     83                }
     84                return names;
     85        }
     86       
     87        public void setArgument(String name, String value) {
     88                if (arguments == null) {
     89                        arguments = new HashMap<String, String>();
     90                }
     91                arguments.put(name, value);
    4392        }
    4493
    … …  
    5099        @Override
    51100        public String getArgument(String name) {
    52                 if (name != null) {
    53                         String value = request.getParameter(name);
    54                         if (value != null) {
    55                                 return value;
    56                         }
     101                String value = null;
     102                if (arguments != null) {
     103                        value = arguments.get(name);
    57104                }
    58                 return null;
     105                if (value == null) {
     106                        throw new NullPointerException("bad argument: value == null");
     107                }
     108                return value;
    59109        }
    60110
    … …  
    65115                }
    66116                errors.add(new ErrorImpl(code, message));
     117        }
     118
     119        @Override
     120        public String getRequestURI() {
     121                // FIXME: supposed to return request uri
     122                return null;
    67123        }
    68124
    … …  
    80136        }
    81137
     138        @Override
     139        public Writer getWriter() {
     140                // FIXME: this is for testing only, need to be re-factored
     141                try {
     142                        response.setCharacterEncoding("utf-8");
     143                        response.setContentType("text/plain");
     144                        response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
     145                        return response.getWriter();
     146                } catch (IOException e) {
     147                }
     148                return null;
     149        }
     150
    82151} // class VerbContextImpl

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/verb/Argument.java

    r321 r340  
    1313                UNTIL;           // until
    1414        } // enum Name
     15        private final Name name;
     16        private final boolean required;
    1517
    16         public static enum Use {
    17                 REQUIRED, OPTIONAL;
    18         } // enum Use
    19 
    20         private final Name name;
    21         private final Use use;
    22 
    23         public Argument(Name name, Use use) {
    24                 this.name = name;
    25                 this.use = use;
     18        public Argument(Name name, boolean required) {
     19                this.name     = name;
     20                this.required = required;
    2621        }
    2722
    … …  
    4641
    4742        public boolean isRequired() {
    48                 return (use == Use.REQUIRED);
     43                return required;
    4944        }
    5045

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/verb/GetRecordVerb.java

    r321 r340  
    55
    66import eu.clarin.cmdi.virtualcollectionregistry.oai.verb.Argument.Name;
    7 import eu.clarin.cmdi.virtualcollectionregistry.oai.verb.Argument.Use;
    87
    98public class GetRecordVerb extends Verb {
    109        private static final List<Argument> s_arguments =
    11                 Arrays.asList(new Argument(Name.IDENTIFIER, Use.REQUIRED),
    12                                           new Argument(Name.METADATAPREFIX, Use.REQUIRED));
     10                Arrays.asList(new Argument(Name.IDENTIFIER, true),
     11                                          new Argument(Name.METADATAPREFIX, true));
    1312
    1413        @Override
    … …  
    1817
    1918        @Override
    20         protected List<Argument> getArguments() {
     19        public List<Argument> getArguments() {
    2120                return s_arguments;
    2221        }
    2322
    2423        @Override
    25         protected void doProcess(VerbContext ctx) {
     24        public void process(VerbContext ctx) {
    2625                logger.debug("process GET-RECORD");
    2726        }

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/verb/IdentifyVerb.java

    r321 r340  
    1212
    1313        @Override
    14         protected List<Argument> getArguments() {
     14        public List<Argument> getArguments() {
    1515                return Collections.emptyList();
    1616        }
    1717
    1818        @Override
    19         protected void doProcess(VerbContext ctx) {
     19        public void process(VerbContext ctx) {
    2020                logger.debug("process IDENTIFY");
    2121        }

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/verb/Verb.java

    r321 r340  
    66import org.slf4j.LoggerFactory;
    77
    8 import eu.clarin.cmdi.virtualcollectionregistry.oai.OAIErrorCode;
    9 import eu.clarin.cmdi.virtualcollectionregistry.oai.OAIException;
    10 
    118public abstract class Verb {
    129        protected static final Logger logger = LoggerFactory.getLogger(Verb.class);
    … …  
    1411        public abstract String getName();
    1512
    16         protected abstract List<Argument> getArguments();
     13        public abstract List<Argument> getArguments();
    1714
    18         protected abstract void doProcess(VerbContext ctx);
    19 
    20         public void process(VerbContext ctx) {
    21                 /* FIXME: need to check for multiple arguments -> illegal
    22                  *        check for superfluous arguments      -> illegal
    23                  */
    24                 for (Argument arg : getArguments()) {
    25                         String value = ctx.getArgument(arg.getName());
    26                         if ((value == null) && arg.isRequired()) {
    27                                 ctx.addError(OAIErrorCode.BAD_ARGUMENT,
    28                                                                 "OAI verb '" + getName() +
    29                                 "' requires argument '" + arg.getName() + "'");
    30                         } else {
    31                                 try {
    32                                         arg.validateArgument(value);
    33                                 } catch (OAIException e) {
    34                                         ctx.addError(OAIErrorCode.BAD_ARGUMENT,
    35                                                         "Value of argument '" +
    36                                                         arg.getName() + "' of OAI verb '" +
    37                                                         getName() + "' is invalid: " + e.getMessage());
    38                                 }
    39                         }
    40                 } // for
    41                 if (!ctx.hasErrors()) {
    42                         doProcess(ctx);
    43                 }
    44         }
    45 
     15        public abstract void process(VerbContext ctx);
     16       
    4617} // abstract class VerbBase

  • VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/oai/verb/VerbContext.java

    r321 r340  
    11package eu.clarin.cmdi.virtualcollectionregistry.oai.verb;
    22
     3import java.io.Writer;
    34import java.util.List;
    45
    … …  
    1718        public String getArgument(String name);
    1819
     20        public String getRequestURI();
     21
    1922        public void addError(OAIErrorCode code, String message);
    2023
    … …  
    2326        public List<Error> getErrors();
    2427
     28        public Writer getWriter();
     29
    2530} // interface VerbContext
Note: See TracChangeset for help on using the changeset viewer.