--- /dev/null
+/*
+ *
+ */
+package uk.ac.vamsas.client.simpleclient;
+
+import java.io.IOException;
+import java.util.Vector;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.vamsas.client.ClientHandle;
+import org.vamsas.client.IClientAppdata;
+import org.vamsas.client.IClientDocument;
+import org.vamsas.client.UserHandle;
+import org.vamsas.client.Vobject;
+import org.vamsas.client.VorbaId;
+import org.vamsas.objects.core.ApplicationData;
+import org.vamsas.objects.core.User;
+import org.vamsas.objects.core.VAMSAS;
+import org.vamsas.objects.core.VamsasDocument;
+import org.vamsas.objects.utils.AppDataReference;
+import org.vamsas.test.objects.Core;
+
+/**
+ * Maintains a collection of vamsas objects, appdatas and states, and provides api for a SimpleClient's client.
+ * @author jimp
+ */
+public class ClientDocument extends org.vamsas.client.ClientDocument implements IClientDocument {
+ private static Log log = LogFactory.getLog(ClientDocument.class);
+ private VamsasDocument doc;
+ protected SimpleClient sclient;
+ protected VamsasArchive archive = null;
+ /**
+ * indicate if new data has been incorporated
+ */
+ private boolean isModified = false;
+ /**
+ * Public method for internal use by SimpleClient.
+ * @return true if document has been modified.
+ */
+ public boolean isModified() {
+ return isModified;
+ }
+ private Vector updatedObjects=null;
+ /**
+ *
+ * prepare Application-side dataset from the vamsas Document archive
+ * @param doc - the dataset
+ * @param docHandler - the sessionFile IO handler
+ * @param Factory - the source of current and new vorbaIds
+ * @param sclient - the simpleclient instance
+ */
+ protected ClientDocument(VamsasDocument doc, VamsasArchive docHandler, IdFactory Factory, SimpleClient sclient) {
+ super(Factory.getVorbaIdHash(), Factory);
+
+
+ /**
+ * prepare Application-side dataset from the vamsas Document archive
+ */
+ this.sclient = sclient;
+ archive = docHandler;
+ this.doc = doc;
+ updatedObjects=null; /// TODO: correct this line
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.vamsas.client.IClientDocument#getObject(org.vamsas.client.VorbaId)
+ */
+ public Vobject getObject(VorbaId id) {
+ if (vamsasObjects==null) {
+ log.debug("getObject called on null objrefs list.");
+ return null;
+ }
+ if (vamsasObjects.containsKey(id))
+ return (Vobject) vamsasObjects.get(id);
+ log.debug("Returning null Vobject reference for id "+id.getId());
+ return null;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.vamsas.client.IClientDocument#getObjects(org.vamsas.client.VorbaId[])
+ */
+ public Vobject[] getObjects(VorbaId[] ids) {
+ if (vamsasObjects==null) {
+ log.debug("getObject[] called on null vamsasObjects list.");
+ return null;
+ }
+ Vobject[] vo = new Vobject[ids.length];
+ for (int i=0,j=ids.length; i<j;i++)
+ if (vamsasObjects.containsKey(ids[i]))
+ vo[i] = (Vobject) vamsasObjects.get(ids[i]);
+ else
+ log.debug("Returning null Vobject reference for id "+ids[i].getId());
+ return vo;
+ }
+ /**
+ * internal reference to single copy of Document Roots array
+ */
+ private VAMSAS[] _VamsasRoots=null;
+ /*
+ * (non-Javadoc)
+ * LATER: currently there is only one Vector of roots ever passed to client - decide if this is correct (means this is not thread safe and may behave unexpectedly)
+ * @see org.vamsas.client.IClientDocument#getVamsasRoots()
+ */
+ public VAMSAS[] getVamsasRoots() {
+ if (doc==null) {
+ log.debug("Null document for getVamsasRoots(), returning null");
+ return null;
+ }
+ if (archive==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(sclient.getProvenanceEntry("Created new document root [id="+_VamsasRoots[0].getId()+"]"));
+ doc.addVAMSAS(_VamsasRoots[0]);
+ } else {
+ _VamsasRoots = new VAMSAS[roots.length];
+ for (int r=0;r<roots.length; r++)
+ _VamsasRoots[r] = roots[r];
+ }
+ return _VamsasRoots;
+ }
+
+ private int _contains(VAMSAS root, VAMSAS[] docRoots) {
+ if (root==null)
+ return -1;
+ if (docRoots==null || docRoots.length==0)
+ return -1;
+ String r_id = root.getId();
+ for (int i=0,j=docRoots.length; i<j; i++)
+ if (docRoots[i]==root || (docRoots[i]!=null && docRoots[i].getId().equals(r_id)))
+ return i;
+ return -1;
+ }
+/**
+ * verify that newr version is really an intact version of the
+ * @param newVersion (may be modified)
+ * @param oldVersion
+ * @return true if newVersion is a valid root that preserves original references
+ */
+ private boolean isValidUpdate(VAMSAS newVersion, final VAMSAS oldVersion) {
+ // ideal - this cascades down the two structures, ensuring that all ID'd objects in one are present in the other.
+ if (oldVersion==newVersion) {
+ // may be a virgin root element.
+ if (!newVersion.isRegistered())
+ _registerObject(newVersion);
+ // Should retrieve original version and compare - unless local hashes can be used to determine if resultSet has been truncated.
+ // just do internal validation for moment.
+ if (newVersion.isValid())
+ return true;
+ return false;
+ } else {
+ // redundant ? if (oldVersion.is__stored_in_document())
+ if (!newVersion.isRegistered())
+ _registerObject(newVersion);
+ if (newVersion.isValid())
+ return true;
+ }
+ return false;
+ /**
+ * LATER isValidUpdate : Ideally. we efficiently walk down, comparing hashes, to deal with merging and verifying provenance for objects
+
+ // extract root objects
+ if (newroots != null) {
+ // check newroots for objects that were present in the old document
+ // check to see if the 'old' objects have been modified
+ // if they have ? we overwrite them with their new version, ensuring that
+ // provenance is updated.
+ // if they haven't ? do nothing ?
+
+ for (int i = 0, k = newroots.length; i < k; i++) {
+ if (newroots[i].isRegistered()) {
+ // easy - just check if anything has changed and do provenance
+ Vobject oldversion = getObject(newroots[i].getVorbaId());
+ if (oldversion instanceof VAMSAS) {
+ // LATER: appropriate merging behaviour when two clients have improperly modified the same Vobject independently.
+ if (newroots[i].get__last_hash() != newroots[i].hashCode()) {
+ // client has modified this Vobject since last retrieval.
+ if (newroots[i].get__last_hash() != oldversion.get__last_hash()) {
+ // Vobject has been modified by another client since this
+ // client's
+ // last access to document.
+ }
+ }
+ } else {
+ throw new Error(
+ "SimpleClient error when using setVamsasRoots : The vorbaId for Vobject "
+ + i
+ + " does not refer to an Vobject of type VAMSAS in the current document!");
+ }
+ } else {
+ if (!newroots[i].is__stored_in_document()) {
+ // check if Vobject is modified
+ if (newroots[i].get__last_hash() != newroots[i].hashCode()) {
+ // it is - so we add newroots[i] as a new Vobject, with updated
+ // provenance.
+ } else {
+ // do nothing
+ newroots[i] = null;
+ }
+ } else {
+ // just add newroots[i] as a new Vobject in the document
+ // - with appropriate provenance.
+ }
+ }
+ }*/
+ }
+ /**
+ * merge old and new root vectors
+ * @param newr This array may be written to
+ * @param original
+ * @param the client document (usually this) which this root set belongs to.
+ * @return merged vector of vamsas roots
+ */
+ private VAMSAS[] _combineRoots(VAMSAS[] newr, final VAMSAS[] original, ClientDocument modflag) {
+ Vector rts = new Vector();
+ boolean modified=false;
+ for (int i=0,j=original.length; i<j; i++) {
+ int k = _contains(original[i], newr);
+ if (k>-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<j; i++) {
+ if (newr[i]!=null) {
+ rts.add(newr[i]);
+ modified=true;
+ }
+ }
+ newr = new VAMSAS[rts.size()];
+ for (int i=0,j=rts.size(); i<j; i++)
+ newr[i] = (VAMSAS) rts.get(i);
+ if (modflag!=null)
+ modflag.isModified = modified;
+ return newr;
+ }
+
+ /**
+ * update the document with new roots.
+ * LATER: decide: this affects the next call to getVamsasRoots()
+ * @see org.vamsas.IClientDocument.setVamsasRoots
+ */
+ public void setVamsasRoots(VAMSAS[] newroots) {
+ if (doc==null) {
+ log.debug("setVamsasRoots called on null document.");
+ return;
+ }
+ VAMSAS[] newr;
+ if (newroots==null) {
+ log.debug("setVamsasRoots(null) - do nothing.");
+ return;
+ }
+ // are we dealing with same array ?
+ if (_VamsasRoots!=newroots) {
+ // merge roots into local version.
+ newr = new VAMSAS[newroots.length];
+ for (int i=0;i<newr.length;i++)
+ newr[i] = newroots[i];
+ newr=_combineRoots(newr,_VamsasRoots,this);
+ } else {
+ newr = new VAMSAS[_VamsasRoots.length];
+ for (int i=0;i<newr.length;i++)
+ newr[i]=_VamsasRoots[i];
+ }
+ // actually compare with document root set for final combination (to ensure nothing is lost)
+ _VamsasRoots = _combineRoots(newr, doc.getVAMSAS(), this);
+ }
+
+
+ /* (non-Javadoc)
+ * LATER: decide: this affects the next call to getVamsasRoots()
+ * @see org.vamsas.client.IClientDocument#addVamsasRoot(org.vamsas.objects.core.VAMSAS)
+ */
+ public void addVamsasRoot(VAMSAS newroot) {
+ if (doc==null) {
+ log.debug("addVamsasRoots called on null document.");
+ return;
+ }
+ VAMSAS[] newroots = _combineRoots(new VAMSAS[] {newroot}, _VamsasRoots, this);
+ _VamsasRoots = newroots;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.vamsas.client.IClientDocument#registerObjects(org.vamsas.client.Vobject[])
+ */
+ public VorbaId[] registerObjects(Vobject[] unregistered) {
+ if (doc==null) {
+ log.warn("registerObjects[] called on null document.");
+ return null;
+ }
+ if (vamsasObjects==null) {
+ log.warn("registerObjects[] called for null vamsasObjects hasharray.");
+ return null;
+ }
+ if (unregistered!=null) {
+ VorbaId ids[] = new VorbaId[unregistered.length];
+ for (int i=0,k=unregistered.length; i<k; i++)
+ if (unregistered[i]!=null) {
+ log.warn("Null Vobject passed to registerObject[] at position "+i);
+ return null;
+ } else {
+ ids[i]=registerObject(unregistered[i]);
+ }
+ log.debug("Registered "+unregistered.length+" objects - total of "+vamsasObjects.size()+" ids.");
+ return ids;
+ }
+ return null;
+ }
+ /* (non-Javadoc)
+ * @see org.vamsas.client.IClientDocument#registerObject(org.vamsas.client.Vobject)
+ */
+ public VorbaId registerObject(Vobject unregistered) {
+ if (doc==null) {
+ log.warn("registerObjects called on null document.");
+ return null;
+ }
+ if (vamsasObjects==null) {
+ log.warn("registerObjects called for null vamsasObjects hasharray.");
+ return null;
+ }
+ if (unregistered!=null) {
+ VorbaId id = _registerObject(unregistered);
+ log.debug("Registered object - total of "+vamsasObjects.size()+" ids.");
+ return id;
+ }
+ log.warn("Null Vobject passed to registerObject.");
+ return null;
+ }
+ /**
+ * IClientAppdata instance - if it exists.
+ */
+ SimpleClientAppdata scappd = null;
+ /* (non-Javadoc)
+ * @see org.vamsas.client.IClientDocument#getClientAppdata()
+ */
+ public IClientAppdata getClientAppdata() {
+ if (doc==null) {
+ log.warn("getClientAppdata called on null document.");
+ return null;
+ }
+ if (scappd==null) {
+ log.debug("Creating new SimpleClientAppdata instance for "+sclient.getSessionHandle());
+ scappd = new SimpleClientAppdata(this);
+ if (scappd==null) {
+ // LATER: may not need this as a warning message.
+ log.warn("Null appdata object for "+sclient.getSessionHandle());
+ } else {
+ log.debug("Created SimpleClientAppdata successfully.");
+ }
+ } else {
+ log.debug("Returning existing SimpleClientAppdata reference.");
+ }
+ return scappd;
+ }
+ /**
+ * access the vamsas document
+ * @return the session's vamsas document
+ */
+ protected VamsasDocument getVamsasDocument() {
+ return doc;
+ }
+ /**
+ * returns the read-only IO interface for the vamsas document Jar file
+ * @return
+ */
+ protected VamsasArchiveReader getVamsasArchiveReader() {
+ try {
+ return archive.getOriginalArchiveReader();
+ } catch (Exception e) {
+ log.warn("Unable to create OriginalArchiveReader!", e);
+ }
+ return null;
+ }
+ protected boolean updateSessionDocument() throws java.io.IOException {
+ boolean docupdate = true; // 'non-serious' problems below set this false
+ if (doc==null) {
+ log.warn("updateSessionDocument called on null document.");
+ throw new java.io.IOException("Document is closed.");
+ }
+ if (archive==null) {
+ log.warn("updateSessionDocument called document archive handler.");
+ throw new java.io.IOException("Document is closed.");
+ }
+
+ if (!isModified() && !scappd.isModified()) {
+ log.debug("Document update not necessary. returning false.");
+ return false;
+ }
+ VamsasSession session = sclient._session;
+ log.debug("updating Session Document in "+session.sessionDir);
+ // update the VamsasDocument structure with any new appData's.
+ // try to update the sessionFile
+ log.debug("Attempting to update session "+sclient.session.getSessionUrn());
+ if (scappd.isModified()) {
+ ClientHandle client = sclient.client;
+ UserHandle user = sclient.user;
+ scappd.closeForWriting();
+ if (scappd.appsGlobal==null) {
+ log.debug("Creating new appData entry for this application...");
+ // first write for this application - add a new section in document
+ ApplicationData appd = scappd.appsGlobal = new ApplicationData();
+ appd.setName(client.getClientName());
+ // appd.setUrn(client.getClientUrn());
+ appd.setVersion(client.getVersion());
+ doc.addApplicationData(appd);
+ // embed or jarEntry ? - for now only jarEntry's are dealt with.
+ appd.setDataReference(AppDataReference.uniqueAppDataReference(doc, sclient.client.getClientUrn()));
+ log.debug("... created.");
+ }
+ if (scappd.newAppData!=null && scappd.newAppData.sessionFile.exists()) {
+ log.debug("Beginning update for new Global Appdata...");
+ // new global appdata to write.
+ if (scappd.appsGlobal.getData()!=null) {
+ scappd.appsGlobal.setData(null);
+ scappd.appsGlobal.setDataReference(AppDataReference.uniqueAppDataReference(doc, sclient.client.getClientUrn()));
+ }
+ // LATER: use a switch to decide if the data should be written as a reference or as an embedded data chunk
+ scappd.updateAnAppdataEntry(archive, scappd.appsGlobal, scappd.newAppData);
+ log.debug("...Successfully updated Global Appdata Entry.");
+ }
+ if (scappd.newUserData!=null && scappd.newUserData.sessionFile.exists()) {
+ log.debug("Beginning to update Users Appdata entry....");
+ if (scappd.usersData==null) {
+ // create new user appdata
+ scappd.usersData = new User();
+ scappd.usersData.setFullname(user.getFullName());
+ scappd.usersData.setOrganization(user.getOrganization());
+ scappd.appsGlobal.addUser(scappd.usersData);
+ }
+ User appd = scappd.usersData;
+ if (appd.getData()!=null || appd.getDataReference()==null) {
+ // LATER make standard appDataReference constructor for client+user
+ appd.setData(null);
+ String safe_username = user.getFullName();
+ int t = safe_username.indexOf(" ");
+ if (t!=-1) {
+ safe_username = safe_username.substring(t);
+ }
+ appd.setDataReference(AppDataReference.uniqueAppDataReference(doc, sclient.client.getClientUrn()+safe_username));
+ }
+ scappd.updateAnAppdataEntry(archive, scappd.usersData, scappd.newUserData);
+ log.debug("...Successfully updated user AppData entry.");
+ }
+ }
+ log.debug("Updating Document...");
+ // now update the document.
+ try {
+ archive.putVamsasDocument(doc);
+ log.debug("Successfully written document entry.");
+ }
+ catch (Exception e) {
+ log.error("Marshalling error for vamsas document.",e);
+ docupdate = false; // pass on the (probable) object validation error
+ }
+ if (archive.transferRemainingAppDatas())
+ log.debug("Remaining appdatas were transferred.");
+ else
+ log.debug("No remaining appdatas were transferred. (Correct?)");
+ archive.closeArchive();
+ log.debug("...successully finished and closed.");
+ return docupdate; // no errors ?
+ }
+ /* (non-Javadoc)
+ * @see java.lang.Object#finalize()
+ */
+ protected void finalize() throws Throwable {
+ log.debug("Garbage collecting on ClientDocument instance.");
+ if (scappd!=null) {
+ scappd.finalize();
+ scappd = null;
+ }
+ if (doc!=null) {
+ doc = null;
+ }
+ // disengage from client
+ if (sclient!=null)
+ sclient.cdocument = null;
+ sclient=null;
+
+ super.finalize();
+ }
+ public Vector getUpdatedObjects() {
+ return updatedObjects;
+ }
+}
git://source.jalview.org / vamsas.git / blobdiff