added validation method to perform minimal check that message class implementation...
[vamsas.git] / src / uk / ac / vamsas / client / simpleclient / SessionsFile.java
1 /*
2  * 
3 * VAMSAS Project
4
5 * Dec 13, 2006  - VamsasClient
6 *
7 */
8  
9 package uk.ac.vamsas.client.simpleclient;
10
11 import java.io.File;
12 import java.io.FileNotFoundException;
13 import java.io.FileOutputStream;
14 import java.io.ObjectInputStream;
15 import java.io.ObjectOutputStream;
16
17
18 import org.apache.commons.logging.Log;
19 import org.apache.commons.logging.LogFactory;
20
21 import uk.ac.vamsas.client.SessionHandle;
22
23 /**
24  * @author <a href="mailto:pierre@ebi.ac.uk">Pierre MARGUERITE</a>
25  * 
26  * 
27  */
28 public class SessionsFile extends ListFile {
29   
30   private static Log log = LogFactory.getLog(SessionsFile.class);
31   /**
32    * when set true - get FileNotFoundExceptions on WinXP when writing to locked stream after the backup has been made (via the backupFile method)
33    */
34   boolean backup=false;
35   /**
36    * number of my session in list - passed back when a session 
37    * is added to list, and used (if valid) for quickly 
38    * looking up presence of session handle in the list.
39    */
40   private int syncnum = 1;
41   /**
42    * @param file
43    */
44   public SessionsFile(File file) throws java.io.IOException {
45     super(file);
46   }
47   
48   
49   /**
50    * internal method for getting sessionsList - ensures a lock has been made but
51    * does not release it.
52    * 
53    * @return list of clients
54    */
55   private SessionHandle[] retrieveSessionHandles() {
56     if (lockFile()) {
57       try {
58         SessionHandle[] sessions =null;
59         if (this.fileLock.length()>0) {
60           
61           ObjectInputStream is = new ObjectInputStream(this.fileLock.getBufferedInputStream(true));
62           Object o;
63           o=is.readObject();
64           if (o!=null) {
65             try {
66               sessions = (SessionHandle[]) o;
67             }
68             catch (Exception e) {
69               log.error("Garbage in the clientHandle list "+this.sessionFile,e);
70             }
71           }
72          // is.close();
73         }
74         return sessions;
75       } catch (FileNotFoundException e) {
76        // e.printStackTrace(System.err);
77         log.error(e);
78       } catch (Exception e) {
79         log.error(e);
80         //e.printStackTrace(System.err);
81       }
82     }
83     return null;
84   }
85
86   /**
87    * get the SessionsList from the file. May return null if lock failed!
88    * @return sessionsList
89    */
90   public SessionHandle[] retrieveSessionsList() {
91     if (lockFile()) {
92       SessionHandle[] clients = retrieveSessionHandles();
93       unlockFile();
94       return clients;
95     }
96     return null;
97   }
98
99   /**
100    * get list from the locked SessionsList.
101    * @param extantlock
102    * @return sessionList or null if lock failed (or file was empty)
103    */
104   public SessionHandle[] retrieveSessionsList(Lock extantlock) {
105     if (lockFile(extantlock)) {
106      SessionHandle[] sessions = retrieveSessionHandles();
107       unlockFile();
108       return sessions;
109     }
110     return null;
111   }
112  
113   
114   /**
115    * adds SessionHandle me to the sessionList under an existing lock extantLock.
116    * @param newSession
117    * @param extantLock
118    * @return session index in list or 0 if lock was invalid or addSession operation failed.
119    */
120   public int addSession(SessionHandle newSession, Lock extantLock) {
121     return addSession(newSession, true, extantLock);
122   }
123   
124   /**
125    * adds SessionsHandle me to the sessionsList under an existing lock.
126    * @param newSession - sessionsHandle
127    * @param disambig - if true then add will fail if an identical sessionHandle already exists
128    * @param extantLock - existing lock
129    * @return client index in list or 0 if addSession (or the lock) failed.
130    */
131   
132   public int addSession(SessionHandle newSession, boolean disambig, Lock extantLock) {
133     if (lockFile(extantLock)) {
134       this.syncnum = addSession(newSession, disambig);
135       unlockFile();
136       return this.syncnum;
137     }
138     return 0;
139   }
140   
141   /**
142    * removes the current session from the  SessionsList without complaint if the session isn't in the sessionsList already.
143    * @param session session handle to be removed
144    * @param sessionlock existing lock passed from watcher.
145    */
146   public void removeSession(SessionHandle session, Lock sessionlock) {
147     int mynum =-1;
148     if (lockFile(sessionlock)) {
149       
150       SessionHandle[] sessions = retrieveSessionHandles();
151       if (sessions != null) {
152        if ((this.syncnum<=0 || this.syncnum>sessions.length) || !sessions[this.syncnum-1].equals(session)) {
153           for (int i = 0, j = sessions.length; i < j; i++)
154           { if (sessions[i].equals(session)) {
155               mynum=i;
156               break;
157             }
158           }
159         } else {
160           mynum=this.syncnum-1;
161         }
162        
163         if (mynum>-1) {
164           SessionHandle[] newlist = new SessionHandle[sessions.length - 1];
165           for (int k=0,i = 0, j = sessions.length; i < j; i++)
166             if (i!=mynum)
167               newlist[k++] = sessions[i];
168           if (!putSessionsList(newlist))
169             throw new Error("Failed to write new sessionsList!"); // failed to put the sessionList to disk.
170         }
171       }
172       unlockFile();
173     } else {
174       throw new Error("Couldn't get lock for "+((this.sessionFile==null) ? "Unitialised sessionFile in SessionsFile" : this.sessionFile.getAbsolutePath()));
175     }
176   }
177   /**
178    * Adds a SessionHandle to the SessionList file - optionally disambiguating 
179    * the SessionHandle (modifes the URN). 
180    * Note: Caller is left to release the lock on the SessionList.
181    * @param session
182    * @param disambiguate -
183    *          flag indicating if the URN for me should be disambiguated to
184    *          differentiate between sessions.
185    * @return index of sessionHandle in new list, or -1-position of existing
186    *         sessionHandle (if disambiguate is true)
187    */
188   protected int addSession(SessionHandle session, boolean disambiguate) {
189     int newsession = 0;
190     int tries=5;
191     while (tries-->0 && !lockFile())
192       try { Thread.sleep(1); } catch (Exception e){};
193     if (lockFile()) {
194       SessionHandle[] sessions = retrieveSessionHandles();
195
196       if (sessions == null) {
197         sessions = new SessionHandle[1];
198         sessions[0] = session;
199         newsession = 1;
200       } else {
201         int k = 0;
202         for (int i = 0, j = sessions.length; i < j; i++) {
203           if ( sessions[i].equals(session)) {
204             if (disambiguate) {
205               while (sessions[i].equals(session)) {
206                // me.setClientUrn(me.getClientUrn() + k++); // TODO: make a better
207                                                           // disambiguation of
208                                                           // urn.
209               }
210             } else {
211               // will not write the ambiguous clientHandle to disk, just return
212               // its index.
213               return -1 - i;
214             }
215           }
216         }
217         int i, j;
218         SessionHandle[] newlist = new SessionHandle[sessions.length + 1];
219         for (i = 0, j = sessions.length; i < j; i++)
220           newlist[i] = sessions[i];
221         newlist[j] = session;
222         sessions = newlist;
223         newsession = j+1;
224       }
225       if (!putSessionsList(sessions))
226         return 0; // failed to put the clientList to disk.
227     }
228     return newsession;
229   }
230   
231   
232   /**
233    * safely writes sessions array to the file referred to by sessionFile.
234    * 
235    * @param clients
236    * @return true if successful write. Throws Errors otherwise.
237    */
238   protected boolean putSessionsList(SessionHandle[] clients) {
239     if (lockFile()) {
240       File templist=null;
241       if (!this.backup || (templist = backupSessionFile()) != null) {
242         int retries=3;
243         while (retries-->0) {
244           try {
245             ObjectOutputStream os = 
246               new ObjectOutputStream(this.fileLock.getBufferedOutputStream(true));
247             log.debug("About to write "+clients.length+" sessionHandles to output stream.");
248             os.writeObject(clients);
249           //  os.flush();
250             os.close();
251           // All done - remove the backup.
252           if (this.backup)
253             templist.delete();
254           templist = null;
255           retries=-1;
256           } catch (Exception e) {
257            // System.err
258             //.println("Serious - problems writing to sessionFile.");
259             log.error("Serious - problems writing to sessionFile.",e);
260             if (retries>0 && templist != null) {
261             //  System.err.println("Recovering from Backup in "
262               //        + templist.getAbsolutePath());
263               log.error("Recovering from Backup in "+ templist.getAbsolutePath());
264               templist.renameTo(this.fileLock.target);
265             }
266             //e.printStackTrace(System.err);
267             log.error(e);
268           }
269         }
270         if (retries>-2) {
271          // System.err
272          // .println("Serious - problems writing to sessionFile. Giving Up.");
273           log.error("Serious - problems writing to sessionFile. Giving Up.");
274           return false;
275         }
276       } else {
277         throw new Error(
278             "Couldn't create backup of the clientList before writing to it!");
279       }
280     } else {
281       throw new Error("Could not lock the clientList: "
282           + ((this.sessionFile == null) ? "Unitialized ClientsFile"
283               : " failed to get lock on " + this.sessionFile.getAbsolutePath()));
284     }
285     // successful!
286     return true;
287   }
288
289   public void clearList() {
290     if (lockFile()) {
291       try {
292         FileOutputStream fout = this.fileLock.getFileOutputStream(true);
293         fout.flush();
294         fout.close();
295       } catch (Exception e) {
296         throw new Error("Problems trying to clear clientlist!",e);
297         
298       }
299     }
300     
301   }
302 }