Changeset 273

Timestamp:

03/22/10 17:27:53 (14 years ago)

Author:

oschonef

Message:

• further work on GWDG handle service integration

File:

• VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/model/GWDGPersistentIdentifierProvider.java (modified) (7 diffs)

VirtualCollectionRegistry/trunk/VirtualCollectionRegistry/src/main/java/eu/clarin/cmdi/virtualcollectionregistry/model/GWDGPersistentIdentifierProvider.java

@@ -4 +4 @@
 import java.net.URISyntaxException;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -21 +23 @@
 import org.apache.http.impl.client.DefaultHttpClient;
 import org.apache.http.message.BasicNameValuePair;
+import org.apache.http.params.HttpProtocolParams;
 import org.apache.http.protocol.BasicHttpContext;
 import org.apache.http.protocol.HttpContext;
@@ -31 +34 @@
 public class GWDGPersistentIdentifierProvider extends
                 PersistentIdentifierProvider {
+        private static enum Attribute {
+                PID, URL, CREATOR, EXPDATE;
+                
+                public static Attribute fromString(String s) {
+                        if (s.equalsIgnoreCase("pid")) {
+                                return PID;
+                        } else if (s.equalsIgnoreCase("url")) {
+                                return URL;
+                        } else if (s.equalsIgnoreCase("creator")) {
+                                return CREATOR;
+                        } else if (s.equalsIgnoreCase("expdate")) {
+                                return EXPDATE;
+                        }
+                        return null;
+                }
+                
+                public String toString() {
+                        switch (this) {
+                        case PID:
+                                return "pid";
+                        case URL:
+                                return "url";
+                        case CREATOR:
+                                return "creator";
+                        case EXPDATE:
+                                return "expdate";
+                        default:
+                                throw new InternalError();
+                        }
+                }
+        } // private enum Attribute
         public static final String USERNAME = "pid_provider.username";
         public static final String PASSWORD = "pid_provider.password";
-        private static final URI SERVICE_URI =
-                URI.create("http://handle.gwdg.de:8080/pidservice/");
+        private static final String SERVICE_URI_BASE =
+                "http://handle.gwdg.de:8080/pidservice/";
+        private static final String USER_AGENT =
+                "CLARIN-VirtualCollectionRegisty/1.0";
         private static final Logger logger =
                 LoggerFactory.getLogger(GWDGPersistentIdentifierProvider.class);
@@ -40 +76 @@
         private String username = null;
         private String password = null;
+        private XMLInputFactory factory;
 
         /* XXX: refactor Internal and GWDG PID class/providers, so only one
@@ -63 +100 @@
                 this.username = getParameter(config, USERNAME);
                 this.password = getParameter(config, PASSWORD);
+                
+                this.factory = XMLInputFactory.newInstance();
+                factory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
+                factory.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES,
+                                                        Boolean.TRUE);
         }
 
         public PersistentIdentifier createPersistentIdentifier(VirtualCollection vc)
                         throws VirtualCollectionRegistryException {
-                logger.debug("creating handle for virtual collection {}", vc.getUUID());
-                URI target    = makeCollectionURI(vc);
-                String handle = createHandle(target);
-                logger.info("created handle {} for virtual collection {}",
-                                        handle, vc.getUUID());
-                return new GWDGPersistentIdentifier(vc, handle);
-        }
-
-        private URI makeCollectionURI(VirtualCollection vc) {
-                return URI.create(base_uri +
-                          "service/clarin-virtualcollection/" + vc.getUUID());
-        }
-
-        private String createHandle(URI target) {
-                logger.debug("pid target: {}", target);
-                foo(target);
-                return "12345/007";
+                logger.debug("creating handle for virtual collection \"{}\"",
+                                vc.getUUID());
+                try {
+                        String target  = makeCollectionURI(vc);
+                        // XXX: testing
+                        // URI serviceURI = URI.create(SERVICE_URI_BASE + "write/create");
+                        URI serviceURI = URI.create(SERVICE_URI_BASE + "write/modify");
+
+                        List<NameValuePair> params = new ArrayList<NameValuePair>();
+                        params.add(new BasicNameValuePair("url", target));
+                        // XXX: testing
+                        params.add(new BasicNameValuePair("pid", "11858/00-232Z-0000-0000-40AE-F"));
+                        Map<Attribute, String> props = invokeWebService(serviceURI, params);
+                        String pid = props.get(Attribute.PID);
+                        if (pid == null) {
+                                throw new VirtualCollectionRegistryException(
+                                        "no handle returned");
+                        }
+                        logger.info("created handle \"{}\" for virtual collection \"{}\"",
+                                        pid, vc.getUUID());
+                        return new GWDGPersistentIdentifier(vc, pid);
+                } catch (VirtualCollectionRegistryException e) {
+                        throw new RuntimeException("failed to create handle", e);
+                }
+        }
+
+        @SuppressWarnings("unused")
+        private void update(String pid, URI target) throws VirtualCollectionRegistryException {
+                List<NameValuePair> params = new ArrayList<NameValuePair>();
+                params.add(new BasicNameValuePair("pid", pid));
+                params.add(new BasicNameValuePair("url", target.toString()));
+                URI serviceURI = URI.create(SERVICE_URI_BASE + "write/modify");
+                invokeWebService(serviceURI, params);
+        }
+
+        private String makeCollectionURI(VirtualCollection vc) {
+                return base_uri + "service/clarin-virtualcollection/" + vc.getUUID();
         }
 
@@ -101 +163 @@
         }
 
-        private void foo(URI target) {
+        private Map<Attribute, String> invokeWebService(URI serviceTargetURI,
+                        List<NameValuePair> formparams)
+                        throws VirtualCollectionRegistryException {
+                // force xml encoding
+                formparams.add(new BasicNameValuePair("encoding", "xml"));
+
+                DefaultHttpClient client = null;
                 try {
-                        URI serviceURI = URI.create(SERVICE_URI.toString() + "write/modify");
-                        DefaultHttpClient client = new DefaultHttpClient();
-                        int port = serviceURI.getPort() != -1
-                                 ? serviceURI.getPort()
+                        client = new DefaultHttpClient();
+                        int port = serviceTargetURI.getPort() != -1
+                                 ? serviceTargetURI.getPort()
                      : AuthScope.ANY_PORT
                      ;
                         client.getCredentialsProvider().setCredentials(
-                                        new AuthScope(serviceURI.getHost(), port),
+                                        new AuthScope(serviceTargetURI.getHost(), port),
                                         new UsernamePasswordCredentials(username, password)
                         );
-                        List<NameValuePair> formparams = new ArrayList<NameValuePair>();
-                        formparams.add(new BasicNameValuePair("encoding", "xml"));
-                        formparams.add(new BasicNameValuePair("url", target.toString()));
-                        formparams.add(new BasicNameValuePair("pid", "11858/00-232Z-0000-0000-40AE-F"));
-                        
-                        HttpPost request = new HttpPost(serviceURI);
+                        // disable expect continue, GWDG does not like very well
+                        client.getParams()
+                                .setParameter(HttpProtocolParams.USE_EXPECT_CONTINUE, Boolean.FALSE);
+                        // set a proper user agent
+                        client.getParams()
+                                .setParameter(HttpProtocolParams.USER_AGENT, USER_AGENT);
+                        HttpPost request = new HttpPost(serviceTargetURI);
+                        request.addHeader("Accept", "text/xml, application/xml");
                         request.setEntity(new UrlEncodedFormEntity(formparams, "UTF-8"));
                         HttpContext ctx = new BasicHttpContext();
-                        
+
+                        logger.debug("invoking GWDG service at {}", serviceTargetURI);
                         HttpResponse response = client.execute(request, ctx);
                         StatusLine status = response.getStatusLine();
                         HttpEntity entity = response.getEntity();
-                        
+                        Map<Attribute, String> props = Collections.emptyMap();
+
                         logger.debug("GWDG Service status: {}", status.toString());
                         if ((status.getStatusCode() >= 200) &&
@@ -135 +206 @@
                                 }
 
-                                logger.debug("type={}, length={}",
-                                                entity.getContentType(), entity.getContentLength());
-                                logger.debug("encoding={}", encoding);
-
-                                XMLInputFactory factory = XMLInputFactory.newInstance();
-                                factory.setProperty(XMLInputFactory.IS_COALESCING, true);
-                                factory.setProperty(XMLInputFactory.IS_REPLACING_ENTITY_REFERENCES, true);
-                                XMLStreamReader reader = factory.createXMLStreamReader(response.getEntity().getContent(), encoding);
+                                XMLStreamReader reader = factory
+                                                .createXMLStreamReader(entity.getContent(), encoding);
+                                props = new HashMap<Attribute, String>(); 
                                 while (reader.hasNext()) {
                                         reader.next();
-                                        if (reader.getEventType() == XMLStreamConstants.START_ELEMENT) {
-                                                if (reader.getLocalName().equalsIgnoreCase("pid")) {
-                                                        reader.next();
-                                                        logger.trace("-> PID: " + reader.getText());
-                                                } else if (reader.getLocalName().equalsIgnoreCase("expdate")) {
-                                                        reader.next();
-                                                        logger.trace("-> EXP-Date: " + reader.getText());
-                                                } else if (reader.getLocalName().equalsIgnoreCase("url")) {
-                                                        reader.next();
-                                                        logger.trace("-> URI: " + reader.getText());
+                                        
+                                        int type = reader.getEventType();
+                                        if (type != XMLStreamConstants.START_ELEMENT) {
+                                                continue;
+                                        }
+                                        Attribute attribute =
+                                                Attribute.fromString(reader.getLocalName());
+                                        if (attribute != null) {
+                                                if (!reader.hasNext()) {
+                                                        throw new VirtualCollectionRegistryException(
+                                                                "unexpected end of data stream");
+                                                }
+                                                reader.next();
+                                                if (reader.getEventType() !=
+                                                                XMLStreamConstants.CHARACTERS) {
+                                                        throw new VirtualCollectionRegistryException(
+                                                                "unexpected element type: " +
+                                                                reader.getEventType());
+                                                }
+                                                String value = reader.getText();
+                                                if (value == null) {
+                                                        throw new VirtualCollectionRegistryException(
+                                                                "element \"" + attribute + "\" was empty");
+                                                }
+                                                value = value.trim();
+                                                if (!value.isEmpty()) {
+                                                        props.put(attribute, value);
                                                 }
                                         }
                                 }
+
                         } else {
-                                logger.error("http failed: {}", status);
-                        }
-                        client.getConnectionManager().shutdown();
+                                logger.debug("GWDG Handle service failed: {}", status);
+                                request.abort();
+                                throw new VirtualCollectionRegistryException(
+                                        "error invoking GWDG handle service");
+                        }
+                        return props;
+                } catch (VirtualCollectionRegistryException e) {
+                        throw e;
                 } catch (Exception e) {
-                        logger.error("http failed", e);
+                        logger.debug("GWDG Handle service failed", e);
+                        throw new VirtualCollectionRegistryException(
+                                        "error invoking GWDG handle service", e);
+                } finally {
+                        if (client != null) {
+                                client.getConnectionManager().shutdown();
+                        }
                 }
         }