X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=src%2Fuk%2Fac%2Fvamsas%2Fclient%2Fsimpleclient%2FVamsasSession.java;h=61cf0fbc624fb40f92958d30e1ad3d4bf443738d;hb=415ccdba81aeafe0d06c24054226c87317cb77d6;hp=05014abad6c3565502e0520a017b57ee09bec456;hpb=8879baa96b917d81b39fee0c2e2cc9e5021865bc;p=vamsas.git diff --git a/src/uk/ac/vamsas/client/simpleclient/VamsasSession.java b/src/uk/ac/vamsas/client/simpleclient/VamsasSession.java index 05014ab..61cf0fb 100644 --- a/src/uk/ac/vamsas/client/simpleclient/VamsasSession.java +++ b/src/uk/ac/vamsas/client/simpleclient/VamsasSession.java @@ -2,20 +2,16 @@ package uk.ac.vamsas.client.simpleclient; import java.io.File; import java.io.IOException; -import java.io.PrintStream; -import java.io.PrintWriter; import java.io.RandomAccessFile; -import java.io.Writer; -import java.util.Enumeration; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; -import org.apache.log4j.Appender; -import org.apache.log4j.Logger; import org.apache.log4j.FileAppender; +import org.apache.log4j.Logger; import org.apache.log4j.PatternLayout; import uk.ac.vamsas.client.ClientHandle; +import uk.ac.vamsas.client.Events; import uk.ac.vamsas.client.IClient; import uk.ac.vamsas.client.UserHandle; /** @@ -85,6 +81,18 @@ public class VamsasSession { private SimpleSessionManager sessionManager = null; /** + * Count of cycles before considering the current client as the last one of the session (if no other client registered as active ) + */ + private final int watchCycleCountBeforeLastClient = 1100 ; + + /** + * time between checking + */ + public int WATCH_SLEEP=30; + + //protected String clientFileDirectory = "clients"; + + /** * called to clear update flag after a successful offline storage event */ protected void clearUnsavedFlag() { @@ -222,7 +230,7 @@ public class VamsasSession { * make a new watcher object for the clientFile * @return new ClientFile watcher instance */ - public FileWatcher getClientWatcher() { + public FileWatcher getClientWatcher() { return new FileWatcher(clist.sessionFile); } /** @@ -361,11 +369,78 @@ public class VamsasSession { log.debug("Adding client "+client.getClientHandle().getClientUrn()); getClientWatcherElement().haltWatch(); clist.addClient(client.getClientHandle()); - getClientWatcherElement().enableWatch(); + log.debug("Added."); + log.debug("Register Client as Active."); + /* try { + client.createActiveClientFile(); + } catch (IOException e) { + log.debug("Error during active client file creation."); + }*/ + //tracks modification to the client list and readds client to the list + getClientWatcherElement().setHandler(new AddClientWatchCallBack(client)); + getClientWatcherElement().enableWatch(); } } + /** + * Handler for the client watcher. + * + * If (the current client is not in the client list, it is added again;) + */ + private class AddClientWatchCallBack implements WatcherCallBack + { + + private IClient client ; + + /** + *Inits the handler with the client to check in the list + * @param client client to monitor in the client list + */ + protected AddClientWatchCallBack (IClient client) + { + this.client = client; + } + + /** + * If the client list is modified, checks if the current is still in the list. otherwise, readds ti. + * @return true to enable watcher, or false to disable it in future WatcherThread cycles. + */ + public boolean handleWatchEvent(WatcherElement watcher, Lock lock) + { + boolean isWatchEnable = watcher.isWatchEnabled(); + if (lock== null)//no update on the list + return isWatchEnable; + // log.debug("change on the client list "); + if (client != null) + { + + + //checks if the client is not already in the lists + ClientHandle[] cl = clist.retrieveClientList(lock);//clist.retrieveClientList(); + boolean found = false; + if (cl != null) + { + for (int chi = cl.length-1; !found && chi > -1; chi--) { + found = cl[chi].equals(this.client.getClientHandle()); + } + + } + if (! found) + {log.debug("client not in the list "); + if( log.isDebugEnabled()) + log.debug("the client has not been found in the list. Adding it again :"+cl); + addClient(client); + } + else + log.debug("client is in the list"); + + } + //log.debug("isWatchEnable "+isWatchEnable); + return isWatchEnable; + } + } + /** * * removes a client from the current session @@ -373,22 +448,46 @@ public class VamsasSession { * if the client is the last one from the session (ClientList), the current session is removed * from active session list. * + * The active should add them self to the client list. To insure to close the session,when the current client is the lact active client, + * clears the list of clients and when two cycles to insure there is no more active client, that otherwise would have readd themself to the list + * * @param client client to remove */ - protected void removeClient(IClient client) + protected void removeClient(SimpleClient client)//IClient client) { if (client == null) { log.error("Null client passed to removeClient"); return; } - SessionFileWatcherElement cwe=getClientWatcherElement(); + ClientSessionFileWatcherElement cwe=getClientWatcherElement(); if (cwe!=null && cwe.isWatchEnabled()) { cwe.haltWatch(); - } else { - cwe=null; + }; + //set handler to check is the the last active client of the session + //Wait for several watchers cycle to see if the current client was the last client active in the session. + //if yes, close the session + + getClientWatcherElement().setHandler(new RemoveClientWatchCallBack (client)); + getClientWatcherElement().setTimeoutBeforeLastCycle(this.watchCycleCountBeforeLastClient); + log.info("remove client from list"); + clist.clearList(); + log.info("client list cleared"); + if (cwe!=null) { + cwe.enableWatch(); + + + /* try { + log.debug("Releasing active client file"); + client.releaseActiveClientFile(); + } catch (IOException e) { + log.error("error during active file client release"); + }*/ } - clist.removeClient(client.getClientHandle(),null); + + + + /*clist.removeClient(client.getClientHandle(),null); if (this.clist.retrieveClientList() == null|| this.clist.retrieveClientList().length<1) {//assume it is the last client has been removed shutting down session slog.info("last client removed: removing session"); @@ -396,15 +495,103 @@ public class VamsasSession { this.getSessionManager().removeSession(client.getSessionHandle()); } else - { - int active=clist.retrieveClientList().length; - log.debug("Still "+active+" active clients"); - slog.info("Still "+active+" active clients"); - } - if (cwe!=null) { - cwe.enableWatch(); - } + { + int active=clist.retrieveClientList().length; + log.debug("Still "+active+" active clients"); + slog.info("Still "+active+" active clients"); + }*/ + } + + /** + * Handler for the client watcher. after a client have been removed + * + * Checks if the client is not the last active one. + * + * If (the current client is not in the client list readd it;) + */ + private class RemoveClientWatchCallBack implements WatcherCallBack + { + + private SimpleClient client ; + private boolean manualCheckOfClientCount = false; + /** + *Inits the handler with the client to check in the list + * @param client client to monitor in the client list + */ + protected RemoveClientWatchCallBack (SimpleClient client) + { + this.client = client; + } + + /** + * If the client list is modified, checks if the current is still in the list. otherwise, readds ti. + * @return true to enable watcher, or false to disable it in future WatcherThread cycles. + */ + public boolean handleWatchEvent(WatcherElement watcher, Lock lock) + { + // if lock is null, no client has been added since last, clear. + //the client is then the last client + if (client != null) + { + + if (lock == null ) + { + + //checks if the client is not already in the lists + // ClientHandle[] cl = clist.retrieveClientList();//lock);//clist.retrieveClientList(); +// ask to the client to cpoy application data into the document + client.evgen._raise(Events.DOCUMENT_FINALIZEAPPDATA, null, client,null); + boolean islastClient = true; + if (manualCheckOfClientCount) + { + log.debug("manual checking of count of client"); + //checks if the client is not already in the lists + ClientHandle[] cl = clist.retrieveClientList();//lock);//clist.retrieveClientList(); + if(cl == null || cl.length<1 ) + // {//no client has registered as active + { + islastClient = true; + log.debug("list is empty"); + } + else + islastClient = false; + log.debug("list is not empty"); + } + // if(cl == null || cl.length<1 ) + // {//no client has registered as active + if (islastClient) + { + //the client is the last one, so close current session + log.info("last client removed: closing session"); + +// close document + client.evgen._raise(Events.DOCUMENT_REQUESTTOCLOSE, null, client,null); + log.debug("close document request done"); + + getSessionManager().removeSession(client.getSessionHandle()); + log.debug("Session removed"); + } + } + else + { + log.debug("not the last client found "); +// ask to the client to cpoy application data into the document + // client.evgen._raise(Events.DOCUMENT_FINALIZEAPPDATA, null, client,null); + + // / } + + } + log.debug("Stopping EventGenerator.."); + client.evgen.stopWatching(); + } + watcher.setHandler(null);//Do not check if the client is the last client. watcher will shutdown anyway + // watcher.haltWatch(); + // watcher. + return false; + } + } + /** * @return the sessionManager */ @@ -423,13 +610,30 @@ public ClientsFile getStoreDocFile() { } return storedocfile; } -SessionFileWatcherElement clistWatchElement=null; -public SessionFileWatcherElement getClientWatcherElement() { + +ClientSessionFileWatcherElement clistWatchElement=null; +public ClientSessionFileWatcherElement getClientWatcherElement() { if (clistWatchElement==null) { - clistWatchElement=new SessionFileWatcherElement(clist,null); + clistWatchElement=new ClientSessionFileWatcherElement(clist,null); } return clistWatchElement; } +/** + * writes a vector of vorba Ids to the session. + * @param modObjects +public void setModObjectList(Vector modObjects) { + log.debug("Writing "+modObjects.size()+" ids to ModObjectList"); + // TODO Auto-generated method stub +} +** + * get current list of modified objects. + * @return null or Vector of objects + * +public Vector getModObjectList() { + log.debug("Reading modObjectList"); + return null; +} +*/ }