org.spearce.jgit/src/org/spearce/jgit/lib/LockFile.java

   1 /*
   2  *  Copyright (C) 2006  Shawn Pearce <spearce@spearce.org>
   3  *
   4  *  This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU General Public
   6  *  License, version 2, as published by the Free Software Foundation.
   7  *
   8  *  This library is distributed in the hope that it will be useful,
   9  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  *  General Public License for more details.
  12  *
  13  *  You should have received a copy of the GNU General Public
  14  *  License along with this library; if not, write to the Free Software
  15  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
  16  */
  17 package org.spearce.jgit.lib;
  18
  19 import java.io.BufferedOutputStream;
  20 import java.io.File;
  21 import java.io.FileOutputStream;
  22 import java.io.IOException;
  23 import java.io.OutputStream;
  24 import java.nio.channels.FileLock;
  25 import java.nio.channels.OverlappingFileLockException;
  26
  27 /**
  28  * Git style file locking and replacement.
  29  * <p>
  30  * To modify a ref file Git tries to use an atomic update approach: we write the
  31  * new data into a brand new file, then rename it in place over the old name.
  32  * This way we can just delete the temporary file if anything goes wrong, and
  33  * nothing has been damaged. To coordinate access from multiple processes at
  34  * once Git tries to atomically create the new temporary file under a well-known
  35  * name.
  36  */
  37 public class LockFile {
  38         private final File ref;
  39
  40         private final File lck;
  41
  42         private FileLock fLck;
  43
  44         private boolean haveLck;
  45
  46         private FileOutputStream os;
  47
  48         private boolean needStatInformation;
  49
  50         private long commitLastModified;
  51
  52         /**
  53          * Create a new lock for any file.
  54          *
  55          * @param f
  56          *            the file that will be locked.
  57          */
  58         public LockFile(final File f) {
  59                 ref = f;
  60                 lck = new File(ref.getParentFile(), ref.getName() + ".lock");
  61         }
  62
  63         /**
  64          * Try to establish the lock.
  65          *
  66          * @return true if the lock is now held by the caller; false if it is held
  67          *         by someone else.
  68          * @throws IOException
  69          *             the temporary output file could not be created. The caller
  70          *             does not hold the lock.
  71          */
  72         public boolean lock() throws IOException {
  73                 lck.getParentFile().mkdirs();
  74                 if (lck.createNewFile()) {
  75                         haveLck = true;
  76                         try {
  77                                 os = new FileOutputStream(lck);
  78                                 try {
  79                                         fLck = os.getChannel().tryLock();
  80                                         if (fLck == null)
  81                                                 throw new OverlappingFileLockException();
  82                                 } catch (OverlappingFileLockException ofle) {
  83                                         // We cannot use unlock() here as this file is not
  84                                         // held by us, but we thought we created it. We must
  85                                         // not delete it, as it belongs to some other process.
  86                                         //
  87                                         haveLck = false;
  88                                         try {
  89                                                 os.close();
  90                                         } catch (IOException ioe) {
  91                                                 // Fail by returning haveLck = false.
  92                                         }
  93                                         os = null;
  94                                 }
  95                         } catch (IOException ioe) {
  96                                 unlock();
  97                                 throw ioe;
  98                         }
  99                 }
 100                 return haveLck;
 101         }
 102
 103         /**
 104          * Write an ObjectId and LF to the temporary file.
 105          *
 106          * @param id
 107          *            the id to store in the file. The id will be written in hex,
 108          *            followed by a sole LF.
 109          * @throws IOException
 110          *             the temporary file could not be written. The lock is released
 111          *             before throwing the underlying IO exception to the caller.
 112          * @throws RuntimeException
 113          *             the temporary file could not be written. The lock is released
 114          *             before throwing the underlying exception to the caller.
 115          */
 116         public void write(final ObjectId id) throws IOException {
 117                 requireLock();
 118                 try {
 119                         final BufferedOutputStream b;
 120                         b = new BufferedOutputStream(os, Constants.OBJECT_ID_LENGTH * 2 + 1);
 121                         id.copyTo(b);
 122                         b.write('\n');
 123                         b.flush();
 124                         fLck.release();
 125                         b.close();
 126                         os = null;
 127                 } catch (IOException ioe) {
 128                         unlock();
 129                         throw ioe;
 130                 } catch (RuntimeException ioe) {
 131                         unlock();
 132                         throw ioe;
 133                 } catch (Error ioe) {
 134                         unlock();
 135                         throw ioe;
 136                 }
 137         }
 138
 139         /**
 140          * Write arbitrary data to the temporary file.
 141          *
 142          * @param content
 143          *            the bytes to store in the temporary file. No additional bytes
 144          *            are added, so if the file must end with an LF it must appear
 145          *            at the end of the byte array.
 146          * @throws IOException
 147          *             the temporary file could not be written. The lock is released
 148          *             before throwing the underlying IO exception to the caller.
 149          * @throws RuntimeException
 150          *             the temporary file could not be written. The lock is released
 151          *             before throwing the underlying exception to the caller.
 152          */
 153         public void write(final byte[] content) throws IOException {
 154                 requireLock();
 155                 try {
 156                         os.write(content);
 157                         os.flush();
 158                         fLck.release();
 159                         os.close();
 160                         os = null;
 161                 } catch (IOException ioe) {
 162                         unlock();
 163                         throw ioe;
 164                 } catch (RuntimeException ioe) {
 165                         unlock();
 166                         throw ioe;
 167                 } catch (Error ioe) {
 168                         unlock();
 169                         throw ioe;
 170                 }
 171         }
 172
 173         /**
 174          * Obtain the direct output stream for this lock.
 175          * <p>
 176          * The stream may only be accessed once, and only after {@link #lock()} has
 177          * been successfully invoked and returned true. Callers must close the
 178          * stream prior to calling {@link #commit()} to commit the change.
 179          *
 180          * @return a stream to write to the new file. The stream is unbuffered.
 181          */
 182         public OutputStream getOutputStream() {
 183                 requireLock();
 184                 return new OutputStream() {
 185                         @Override
 186                         public void write(final byte[] b, final int o, final int n)
 187                                         throws IOException {
 188                                 os.write(b, o, n);
 189                         }
 190
 191                         @Override
 192                         public void write(final byte[] b) throws IOException {
 193                                 os.write(b);
 194                         }
 195
 196                         @Override
 197                         public void write(final int b) throws IOException {
 198                                 os.write(b);
 199                         }
 200
 201                         @Override
 202                         public void flush() throws IOException {
 203                                 os.flush();
 204                         }
 205
 206                         @Override
 207                         public void close() throws IOException {
 208                                 try {
 209                                         os.flush();
 210                                         fLck.release();
 211                                         os.close();
 212                                         os = null;
 213                                 } catch (IOException ioe) {
 214                                         unlock();
 215                                         throw ioe;
 216                                 } catch (RuntimeException ioe) {
 217                                         unlock();
 218                                         throw ioe;
 219                                 } catch (Error ioe) {
 220                                         unlock();
 221                                         throw ioe;
 222                                 }
 223                         }
 224                 };
 225         }
 226
 227         private void requireLock() {
 228                 if (os == null) {
 229                         unlock();
 230                         throw new IllegalStateException("Lock on " + ref + " not held.");
 231                 }
 232         }
 233
 234         /**
 235          * Request that {@link #commit()} remember modification time.
 236          *
 237          * @param on
 238          *            true if the commit method must remember the modification time.
 239          */
 240         public void setNeedStatInformation(final boolean on) {
 241                 needStatInformation = on;
 242         }
 243
 244         /**
 245          * Commit this change and release the lock.
 246          * <p>
 247          * If this method fails (returns false) the lock is still released.
 248          *
 249          * @return true if the commit was successful and the file contains the new
 250          *         data; false if the commit failed and the file remains with the
 251          *         old data.
 252          * @throws IllegalStateException
 253          *             the lock is not held.
 254          */
 255         public boolean commit() {
 256                 if (os != null) {
 257                         unlock();
 258                         throw new IllegalStateException("Lock on " + ref + " not closed.");
 259                 }
 260
 261                 saveStatInformation();
 262                 if (lck.renameTo(ref))
 263                         return true;
 264                 if (!ref.exists() || ref.delete())
 265                         if (lck.renameTo(ref))
 266                                 return true;
 267                 unlock();
 268                 return false;
 269         }
 270
 271         private void saveStatInformation() {
 272                 if (needStatInformation)
 273                         commitLastModified = lck.lastModified();
 274         }
 275
 276         /**
 277          * Get the modification time of the output file when it was committed.
 278          *
 279          * @return modification time of the lock file right before we committed it.
 280          */
 281         public long getCommitLastModified() {
 282                 return commitLastModified;
 283         }
 284
 285         /**
 286          * Unlock this file and abort this change.
 287          * <p>
 288          * The temporary file (if created) is deleted before returning.
 289          */
 290         public void unlock() {
 291                 if (os != null) {
 292                         if (fLck != null) {
 293                                 try {
 294                                         fLck.release();
 295                                 } catch (IOException ioe) {
 296                                         // Huh?
 297                                 }
 298                                 fLck = null;
 299                         }
 300                         try {
 301                                 os.close();
 302                         } catch (IOException ioe) {
 303                                 // Ignore this
 304                         }
 305                         os = null;
 306                 }
 307
 308                 if (haveLck) {
 309                         haveLck = false;
 310                         lck.delete();
 311                 }
 312         }
 313 }