From 46ac66bbd8528819331c18cca14c7c4c96580997 Mon Sep 17 00:00:00 2001 From: jprocter Date: Sun, 26 Mar 2006 17:08:41 +0000 Subject: [PATCH] debugged the runnable main for ArchiveClient. ClientDoc provides api returned by ArchiveClient. git-svn-id: https://svn.lifesci.dundee.ac.uk/svn/repository/trunk@215 be28352e-c001-0410-b1a7-c7978e42abec --- .../vamsas/test/simpleclient/ArchiveClient.java | 228 ++++++++++++++++++-- src/org/vamsas/test/simpleclient/ClientDoc.java | 216 +++++++++++++++++++ 2 files changed, 423 insertions(+), 21 deletions(-) create mode 100644 src/org/vamsas/test/simpleclient/ClientDoc.java diff --git a/src/org/vamsas/test/simpleclient/ArchiveClient.java b/src/org/vamsas/test/simpleclient/ArchiveClient.java index a5deb87..253e993 100644 --- a/src/org/vamsas/test/simpleclient/ArchiveClient.java +++ b/src/org/vamsas/test/simpleclient/ArchiveClient.java @@ -4,24 +4,48 @@ package org.vamsas.test.simpleclient; import java.io.File; +import java.io.IOException; +import java.util.Date; +import java.util.Vector; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; +import org.exolab.castor.xml.MarshalException; +import org.exolab.castor.xml.ValidationException; import org.vamsas.client.ClientHandle; +import org.vamsas.client.IVorbaIdFactory; +import org.vamsas.client.SessionHandle; import org.vamsas.client.UserHandle; +import org.vamsas.client.simpleclient.AppDataOutputStream; import org.vamsas.client.simpleclient.FileWatcher; +import org.vamsas.client.simpleclient.IdFactory; import org.vamsas.client.simpleclient.SessionFile; +import org.vamsas.client.simpleclient.SimpleDocBinding; +import org.vamsas.client.simpleclient.SimpleDocument; import org.vamsas.client.simpleclient.VamsasArchive; +import org.vamsas.client.simpleclient.VamsasArchiveReader; import org.vamsas.client.simpleclient.VamsasFile; +import org.vamsas.objects.core.AppData; +import org.vamsas.objects.core.ApplicationData; +import org.vamsas.objects.core.User; +import org.vamsas.objects.core.VamsasDocument; +import org.vamsas.objects.utils.AppDataReference; +import org.vamsas.objects.utils.DocumentStuff; +import org.vamsas.objects.utils.ProvenanceStuff; +import org.vamsas.objects.utils.SeqSet; +import org.vamsas.objects.utils.document.VersionEntries; +import org.vamsas.test.objects.Core; /** * @author jimp * test the VamsasFile routines for watching, reading and updating a vamsas document jar file. + * simple document access base class. */ -public class ArchiveClient { - Log log = LogFactory.getLog(ArchiveClient.class); - UserHandle user=null; - ClientHandle me = new ClientHandle("ArchiveClient","0.01"); +public class ArchiveClient extends IdFactory { + + private Log log = LogFactory.getLog(ArchiveClient.class); + // protected UserHandle user=null; + // protected ClientHandle me = new ClientHandle("ArchiveClient","0.01"); VamsasFile vsess; /** @@ -29,37 +53,172 @@ public class ArchiveClient { * @param vsess */ public ArchiveClient(UserHandle user, VamsasFile vsess) { - super(); - this.user = user; + super(new SessionHandle("vamsasfile://"+vsess.getVamsasFile()), new ClientHandle("ArchiveClient","0.01"), user); this.vsess = vsess; + valid(); } - public ArchiveClient(String username, String organization, String vsess) { - super(); - this.user = new UserHandle(username, organization); + private void _openVsess(File vsess) { try { - this.vsess = new VamsasFile(new File(vsess)); - } catch (Exception e) { - log.error("Couldn't open session on file "+vsess,e); - this.vsess=null; + this.vsess = new VamsasFile(vsess); } + catch (Exception e) { + log.error("Couldn't open session for file "+vsess,e); + this.vsess = null; + } + } + public ArchiveClient(String username, String organization, File vsess) { + super(new SessionHandle("vamsasfile://"+vsess), new ClientHandle("ArchiveClient","0.01"), new UserHandle(username, organization)); + _openVsess(vsess); + valid(); + } + public ArchiveClient(String username, String organization, String clientName, String clientVersion, File vsess) { + super(new SessionHandle("vamsasfile://"+vsess), new ClientHandle(clientName, clientVersion), new UserHandle(username, organization)); + _openVsess(vsess); + valid(); } public void valid() { if (vsess==null) throw new Error("ArchiveClient instance is invalid!."); } + /** - * + * watch the document file for updates. * @param time - length of time to watch for. - * @return IO interface for session document. + * @return read only IO interface for session document. */ - public VamsasArchive watch(long time) { + public ClientDoc watch(long time) { + valid(); + FileWatcher watcher = new FileWatcher(vsess.getVamsasFile()); + long endtime=System.currentTimeMillis()+time; + try { + org.vamsas.client.simpleclient.Lock doclock; + watcher.setState(); + do { + Thread.sleep(50); // tuning. + doclock=watcher.getChangedState(); + } while (doclock==null && (time==0 || endtime>System.currentTimeMillis())); + if (doclock==null) + return null; + else { + doclock = vsess.getLock(doclock); + VamsasArchiveReader varc = new VamsasArchiveReader(vsess.getVamsasFile()); + return _getReadonly(varc); + } + } catch (Exception e) { + log.error("Whilst watching file "+vsess.getVamsasFile(), e); + } + return null; + } + + // from ClientDocument.getClientAppdata + private AppData[] getAppData(VamsasDocument doc) { + if (doc==null) { + log.debug("extractAppData called for null document object"); + return null; + } + AppData appsGlobal=null, usersData=null; + Vector apldataset = AppDataReference.getUserandApplicationsData( + doc, this.getUserHandle(), this.getClientHandle()); + if (apldataset!=null) { + if (apldataset.size()>0) { + AppData clientdat = (AppData) apldataset.get(0); + if (clientdat instanceof ApplicationData) { + appsGlobal = (ApplicationData) clientdat; + if (apldataset.size()>1) { + clientdat = (AppData) apldataset.get(1); + if (clientdat instanceof User) { + usersData = (User) clientdat; + } + if (apldataset.size()>2) + log.info("Ignoring additional ("+(apldataset.size()-2)+") AppDatas returned by document appdata query."); + } + } else { + log.warn("Unexpected entry in AppDataReference query: id="+clientdat.getVorbaId()+" type="+clientdat.getClass().getName()); + } + apldataset.removeAllElements(); // destroy references. + } + } + return new AppData[] { appsGlobal, usersData}; + } + + protected ClientDoc _getReadonly(VamsasArchiveReader vreader) throws IOException, ValidationException, MarshalException { valid(); - // wait around watching for a change. - VamsasArchive varch=null; - // FileWatcher w = new FileWatcher(vsess); - return varch; + if (vreader!=null) { + SimpleDocBinding docb = new SimpleDocBinding(); + docb.setVorba(this); + VamsasDocument d; + d = docb.getVamsasDocument(vreader); + + if (d!=null) { + ClientDoc creader = new ClientDoc(d, null, vreader, getProvenanceUser()); + return creader; + } + } + return null; + } + /** + * from SimpleClient + * @return user field for a provenance entry + */ + protected String getProvenanceUser() { + return new String(getUserHandle().getFullName()+" ["+getClientHandle().getClientUrn()+"]"); } + public ClientDoc getUpdateable() { + valid(); + try { + vsess.getLock(); + VamsasArchive varc = new VamsasArchive(vsess, true, false); // read archive, write as vamsasDocument, don't erase original contents. + varc.setVorba(this); + VamsasDocument d = varc.getVamsasDocument(getProvenanceUser(), "Created new document.", VersionEntries.latestVersion()); // VAMSAS: provenance user and client combined + + if (d==null) { + log.warn("Backing out from opening a VamsasArchive writable IO session"); + varc.cancelArchive(); + return null; + } + ClientDoc cdoc = new ClientDoc(d, varc, varc.getOriginalArchiveReader(), getProvenanceUser()); + return cdoc; + // do appHandle? + } catch (Exception e) { + log.error("Failed to get Updateable version of "+vsess.getVamsasFile(), e); + } + return null; + } + /** + * trust client to not do anything stupid to the document roots which will now be written to the archive. + * @param cdoc + * @return true if write was a success. + */ + public boolean doUpdate(ClientDoc cdoc) { + valid(); + if (cdoc==null) { + log.warn("Invalid ClientDoc passed to org.vamsas.test.simpleclient.doUpdate()"); + return false; + } + if (cdoc.iohandler==null) { + log.warn("Read only ClientDoc object passed to org.vamsas.test.simpleclient.doUpdate()"); + return false; + } + if (cdoc.iohandler.getVorba()!=this) { + log.error("Mismatch between ClientDoc instances and ArchiveClient instances!"); + return false; + } + try { + // do any appDatas first. + if (cdoc.iohandler.transferRemainingAppDatas()) + log.debug("Remaining appdatas were transfered."); + cdoc.iohandler.putVamsasDocument(cdoc.doc); + cdoc.iohandler.closeArchive(); + cdoc.iohandler=null; + cdoc = null; + vsess.unLock(); + } catch (Exception e) { + log.warn("While updating archive in "+vsess.getVamsasFile(),e); + return false; + } + return true; + } /** * @param args */ @@ -70,8 +229,35 @@ public class ArchiveClient { // really simple. if (args.length<3) usage(); - ArchiveClient client = new ArchiveClient(args[0],args[1], args[2]); + ArchiveClient client = new ArchiveClient(args[0],args[1], new File(args[2])); + ClientDoc cdoc=null; + // sanity test. + try { + cdoc = client.getUpdateable(); + // ArchiveReports.reportDocument(cdoc.doc, cdoc.getReader(), true, System.out); + System.out.println("Report Roots :"); + ArchiveReports.rootReport(cdoc.getVamsasRoots(), true, System.out); + cdoc.addVamsasRoot(Core.getDemoVamsas()); + System.out.println("Doing update."); + client.doUpdate(cdoc); + cdoc = null; + int u=5; + while (--u>0) { + System.out.println("Watch for more... ("+u+" left)"); + cdoc = client.watch(0); + if (cdoc!=null) { + System.out.println("****\nUpdate detected at "+new Date()); + ArchiveReports.reportDocument(cdoc.doc, cdoc.getReader(), true, System.out); + } else { + System.out.println("!!!! Null document update detected at "+new Date()); + } + } + } + catch (Exception e) { + client.log.error("Broken!", e); + } + System.out.println("Finished at "+new Date()); } } diff --git a/src/org/vamsas/test/simpleclient/ClientDoc.java b/src/org/vamsas/test/simpleclient/ClientDoc.java new file mode 100644 index 0000000..d5b0d42 --- /dev/null +++ b/src/org/vamsas/test/simpleclient/ClientDoc.java @@ -0,0 +1,216 @@ +package org.vamsas.test.simpleclient; + +import java.util.Vector; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.vamsas.client.VorbaId; +import org.vamsas.client.simpleclient.ClientDocument; +import org.vamsas.client.simpleclient.VamsasArchive; +import org.vamsas.client.simpleclient.VamsasArchiveReader; +import org.vamsas.objects.core.Entry; +import org.vamsas.objects.core.VAMSAS; +import org.vamsas.objects.core.VamsasDocument; +import org.vamsas.objects.utils.ProvenanceStuff; + +// simple holder to pass to client. +public class ClientDoc { + protected boolean isModified=false; + private Log log = LogFactory.getLog(ClientDoc.class); + protected VamsasDocument doc; + public org.vamsas.objects.core.VAMSAS[] _VamsasRoots; + protected VamsasArchive iohandler=null; + protected VamsasArchiveReader reader=null; + private String user=null; + + /** + * @param doc + * @param iohandler + * @param reader + * @param user + */ + public ClientDoc(VamsasDocument doc, VamsasArchive iohandler, VamsasArchiveReader reader, String user) { + super(); + this.doc = doc; + this.iohandler = iohandler; + this.reader = reader; + this.user = user; + _VamsasRoots = doc.getVAMSAS(); + } + // AppDataOutputStream appd; + //AppDataOutputStream userd; + /* (non-Javadoc) + * @see java.lang.Object#finalize() + */ + protected Entry getProvenanceEntry(String action) { + // VAMSAS: modify schema to allow referencing of user field (plus other issues, ClientUrn field, machine readable action, input parameters, additional data generated notes + Entry prov = ProvenanceStuff.newProvenanceEntry(user, action); + return prov; + } + public VAMSAS[] getVamsasRoots() { + if (doc==null) { + log.debug("Null document for getVamsasRoots(), returning null"); + return null; + } + if (iohandler==null) { + // LATER: decide on read-only status of ClientDocument object + log.warn("getVamsasRoots() called on possibly read-only document."); + } + if (_VamsasRoots!=null) + return _VamsasRoots; + VAMSAS[] roots = doc.getVAMSAS(); + if (roots == null) { + // Make a new one to return to client to get filled. + _VamsasRoots = new VAMSAS[] { new VAMSAS() }; + // Do provenance now. just in case. + doc.getProvenance().addEntry(getProvenanceEntry("Created new document root [id="+_VamsasRoots[0].getId()+"]")); + doc.addVAMSAS(_VamsasRoots[0]); + } else { + _VamsasRoots = new VAMSAS[roots.length]; + for (int r=0;r-1) { + if (isValidUpdate(newr[k], original[i])) { + modified=true; + rts.add(newr[k]); + newr[k]=null; + } else { + // LATER: try harder to merge ducument roots. + log.warn("Couldn't merge new VAMSAS root "+newr[k].getId()); + newr[k] = null; // LATER: this means we ignore mangled roots. NOT GOOD + } + } else { + // add in order. + rts.add(original[i]); + } + } + // add remaining (new) roots + for (int i=0,j=newr.length; i