added validation method to perform minimal check that message class implementation...
[vamsas.git] / src / uk / ac / vamsas / client / simpleclient / NativeLock.java
1 package uk.ac.vamsas.client.simpleclient;
2
3 import java.io.BufferedInputStream;
4 import java.io.BufferedOutputStream;
5 import java.io.File;
6 import java.io.FileInputStream;
7 import java.io.FileNotFoundException;
8 import java.io.FileOutputStream;
9 import java.io.IOException;
10 import java.io.OutputStream;
11 import java.io.RandomAccessFile;
12 import java.nio.channels.FileChannel;
13 import java.nio.channels.FileLock;
14 import java.nio.channels.ReadableByteChannel;
15
16 /**
17  * @author JimP
18  *
19  */
20 public class NativeLock extends Lock {
21
22   protected FileLock lock = null;
23
24   /**
25    * @param lockfile
26    * @param block true means thread will block until a lock is obtained.
27    */
28   public NativeLock(File lockfile, boolean block) {
29     super(lockfile);
30     // try and get a lock.
31     lock = null;
32     
33     try {
34       /*if (!lockfile.createNewFile()) {
35           log.warn("Failed to create locked file "+lockfile);
36           return;
37         }
38       */
39       rafile=new RandomAccessFile(lockfile,"rw");
40       if (block)
41         lock = rafile.getChannel().lock();
42       else
43         lock = rafile.getChannel().tryLock();
44       if (lock==null || !lock.isValid()) {
45         // failed to get lock. Close the file channel
46         log.debug("failed to get lock for "+lockfile);
47         rafile.getChannel().close();
48         lock=null;
49       }
50     } catch (FileNotFoundException e) {
51       //
52       log.debug("Lock failed - normal behaviour for windows locking.");
53       //log.error("Error! Couldn't create a lockfile at "
54       //  + lockfile.getAbsolutePath(), e);
55     } catch (IOException e) {
56       log.error("Error! Problems with IO when creating a lock on "
57           + lockfile.getAbsolutePath(),e);
58     } // catch (Exception )
59   }
60
61   public boolean isLocked() {
62     if (lock != null && lock.isValid()) {
63       return true;
64     }
65     return false;
66   }
67
68   public void release() {
69     release(true);
70   }
71
72   public void release(boolean closeChannel) {
73     if (lock==null)
74       return;
75     try {
76       // channel.close should be called before release() for rigourous locking.
77       if (lock.isValid() && rafile!=null && rafile.getFD().valid() && rafile.getChannel()!=null) {
78         if (closeChannel && rafile.getChannel().isOpen()) {
79             rafile.close();
80             rafile=null; 
81         } else {
82           // just release the lock without doing anything to the channe;l
83           if (lock!=null && lock.isValid())
84             lock.release();
85         }
86       }
87     } catch (IOException e) {
88       log.warn("Whilst releasing lock",e);
89     }
90     lock=null;
91   }
92
93   /**
94    * gets Locked Stream for reading from
95    * @param atStart true to start reading at beginning of file.
96    * @return null if file not locked
97    * @throws IOException
98    */
99   public FileInputStream getFileInputStream(boolean atStart) throws IOException {
100     if (!isLocked())
101       return null;
102     if (atStart)
103       rafile.seek(0);
104     return new FileInputStream(rafile.getFD());
105   }
106
107   /**
108    * gets Locked stream to write to
109    * FileInput always starts at the *end* of the file (after any truncation)
110    * @param clear true means file will be cleared to zero length
111    * @return null if file is not locked
112    * @throws IOException
113    */
114   public FileOutputStream getFileOutputStream(boolean clear) throws IOException {
115     if (!isLocked())
116       return null;
117     if (clear) {
118       rafile.seek(0);
119       rafile.setLength(0);
120     } else
121       rafile.seek(rafile.length());
122     return new LockedFileOutputStream(rafile.getFD());
123   }
124
125   /**
126    * return buffered output stream to locked file.
127    * @param clear - true means file is truncated to 0 length before writing 
128    * @return
129    */
130   public BufferedOutputStream getBufferedOutputStream(boolean clear) throws IOException {
131     OutputStream fos = getFileOutputStream(clear);
132     if (fos!=null)
133       return new BufferedOutputStream(fos);
134     return null;
135   }
136   /**
137    * @see uk.ac.vamsas.client.simpleclient.Lock#finalize()
138    */
139   protected void finalize() throws Throwable {
140     release(true); // we explicitly lose the lock here.
141     // log.debug("lock closing through garbage collection ?");
142     super.finalize();
143   }
144
145   /* (non-Javadoc)
146    * @see uk.ac.vamsas.client.simpleclient.Lock#getLength()
147    */
148   public long length() {
149     if (isLocked()){
150       try {
151         return rafile.length();
152       } catch (Exception e) {
153         log.debug("getLength exception:",e);
154       }
155     }
156     return -1;
157   }
158
159   public RandomAccessFile getRaFile() throws IOException {
160     if (isLocked())
161       return rafile;
162     else
163       log.debug("Failed to getRaFile on "+target);
164     return null;
165   }  
166   
167   public FileChannel getRaChannel() throws IOException {
168     if (isLocked())
169       return rafile.getChannel();
170     else
171       log.debug("Failed to getRaChannel on "+target);
172     return null;
173   }
174
175   public boolean isTargetLockFile(File afile) {
176     if (isLocked() && target.equals(afile))
177       return true;
178     return false;
179   }
180
181 }