qadevOOo/runner/convwatch/SimpleFileSemaphore.java

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: SimpleFileSemaphore.java,v $
  10  * $Revision: 1.3.8.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 package convwatch;
  32
  33 import java.io.File;
  34 import java.io.RandomAccessFile;
  35 import helper.OSHelper;
  36
  37 public class SimpleFileSemaphore /* extends *//* implements */
  38 {
  39     String m_sInternSemaphoreFile;
  40     File m_aInternSemaphoreFile;
  41     GlobalLogWriter m_aLog;
  42
  43     public static void sleep( int _nSeconds)
  44         {
  45             // wait a second here
  46             try
  47             {
  48                 java.lang.Thread.sleep(_nSeconds * 1000);
  49             }
  50             catch (java.lang.InterruptedException e2)
  51             {
  52             }
  53         }
  54
  55     public SimpleFileSemaphore() throws IllegalArgumentException
  56         {
  57             String sInternFileName;
  58             if (OSHelper.isWindows())
  59             {
  60                 sInternFileName = "C:/Temp/ConvwatchOOoSemaphore.txt";
  61             }
  62             else if (OSHelper.isUnix())
  63             {
  64                 sInternFileName = "/tmp/ConvwatchOOoSemaphore.txt";
  65             }
  66             else
  67             {
  68                 m_sInternSemaphoreFile = null;
  69                 throw new IllegalArgumentException("Unknown System, can't initialise SimpleFileSemaphore");
  70             }
  71
  72             m_sInternSemaphoreFile = sInternFileName;
  73             m_aInternSemaphoreFile = new File(sInternFileName);
  74         }
  75
  76     public File getSemaphoreFile()
  77         {
  78             return m_aInternSemaphoreFile;
  79         }
  80 // ------------------------------------------------------------------------------
  81 // wait until resource is available
  82     public void P(File _aSemaphore)
  83         {
  84             int nCount = 0;
  85             int nCheckLoop = 1;
  86
  87             while ( nCheckLoop == 1)
  88             {
  89                 // check if resource is available, if not, wait.
  90                 if ( _aSemaphore.exists() )
  91                 {
  92                     m_aLog.get().println( "Active wait since " + nCount + "sec..");
  93                     nCount ++;
  94                     sleep( 1 );
  95                 }
  96                 else
  97                 {
  98                     sleep( 1 );
  99                     if ( _aSemaphore.exists() )
 100                     {
 101                         // ups
 102                         m_aLog.get().println( "ups...");
 103                     }
 104                     else
 105                     {
 106                         nCheckLoop = 0;
 107                     }
 108                 }
 109             }
 110
 111             // block resource by ourself
 112             try
 113             {
 114                 RandomAccessFile aWriter = new RandomAccessFile(_aSemaphore, "rw");
 115                 aWriter.writeByte((int)1);
 116                 aWriter.close();
 117             }
 118
 119             catch (java.io.FileNotFoundException fne)
 120             {
 121                 m_aLog.get().println( "caught: FileNotFoundException");
 122             }
 123             catch(java.io.IOException ie)
 124             {
 125                 m_aLog.get().println( "caught: IOException");
 126             }
 127         }
 128
 129 // ------------------------------------------------------------------------------
 130 // block a resource
 131     public void V(File _aSemaphore)
 132         {
 133
 134             if ( _aSemaphore.exists() )
 135             {
 136                 _aSemaphore.delete();
 137             }
 138             else
 139             {
 140                 m_aLog.get().println("Could be a problem here? No resource block found.");
 141             }
 142         }
 143
 144     // --------------------------------- Unit test ---------------------------------
 145
 146     private static boolean SEMAPHORE_SHOULD_EXIST = true;
 147     private static boolean SEMAPHORE_SHOULD_NOT_EXIST = false;
 148
 149     private static void assure(boolean _b, String _sText)
 150         {
 151             System.out.print(_sText);
 152             System.out.print("  ");
 153             if (_b)
 154             {
 155                 System.out.println("ok");
 156             }
 157             else
 158             {
 159                 System.out.println("FAILED");
 160             }
 161         }
 162
 163     private static void testSemaphoreFile(SimpleFileSemaphore a, boolean _bShouldFileExists)
 164         {
 165             System.out.println("Check if semaphore file exists.");
 166             File aSemaphoreFile = a.getSemaphoreFile();
 167             if (aSemaphoreFile.exists())
 168             {
 169                 System.out.println("Name is: " + aSemaphoreFile.getAbsolutePath());
 170                 assure(_bShouldFileExists == SEMAPHORE_SHOULD_EXIST, "Semaphore should exist!");
 171             }
 172             else
 173             {
 174                 assure(_bShouldFileExists == SEMAPHORE_SHOULD_NOT_EXIST, "Semaphore should not exist!");
 175             }
 176         }
 177
 178     public static void main( String[] argv )
 179         {
 180             SimpleFileSemaphore a = new SimpleFileSemaphore();
 181
 182             testSemaphoreFile(a, SEMAPHORE_SHOULD_NOT_EXIST);
 183
 184             a.P(a.getSemaphoreFile());
 185
 186             testSemaphoreFile(a, SEMAPHORE_SHOULD_EXIST);
 187
 188             a.V(a.getSemaphoreFile());
 189
 190             testSemaphoreFile(a, SEMAPHORE_SHOULD_NOT_EXIST);
 191         }
 192 }