qadevOOo/runner/convwatch/SimpleFileSemaphore.java

   1 /*
   2  * This file is part of the LibreOffice project.
   3  *
   4  * This Source Code Form is subject to the terms of the Mozilla Public
   5  * License, v. 2.0. If a copy of the MPL was not distributed with this
   6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   7  *
   8  * This file incorporates work covered by the following license notice:
   9  *
  10  *   Licensed to the Apache Software Foundation (ASF) under one or more
  11  *   contributor license agreements. See the NOTICE file distributed
  12  *   with this work for additional information regarding copyright
  13  *   ownership. The ASF licenses this file to you under the Apache
  14  *   License, Version 2.0 (the "License"); you may not use this file
  15  *   except in compliance with the License. You may obtain a copy of
  16  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  17  */
  18
  19 package convwatch;
  20
  21 import java.io.File;
  22 import java.io.RandomAccessFile;
  23 import helper.OSHelper;
  24
  25 public class SimpleFileSemaphore /* extends *//* implements */
  26 {
  27     String m_sInternSemaphoreFile;
  28     File m_aInternSemaphoreFile;
  29     GlobalLogWriter m_aLog;
  30
  31     public static void sleep( int _nSeconds)
  32         {
  33             // wait a second here
  34             try
  35             {
  36                 java.lang.Thread.sleep(_nSeconds * 1000);
  37             }
  38             catch (java.lang.InterruptedException e2)
  39             {
  40             }
  41         }
  42
  43     public SimpleFileSemaphore() throws IllegalArgumentException
  44         {
  45             String sInternFileName;
  46             if (OSHelper.isWindows())
  47             {
  48                 sInternFileName = "C:/Temp/ConvwatchOOoSemaphore.txt";
  49             }
  50             else if (OSHelper.isUnix())
  51             {
  52                 sInternFileName = "/tmp/ConvwatchOOoSemaphore.txt";
  53             }
  54             else
  55             {
  56                 m_sInternSemaphoreFile = null;
  57                 throw new IllegalArgumentException("Unknown System, can't initialise SimpleFileSemaphore");
  58             }
  59
  60             m_sInternSemaphoreFile = sInternFileName;
  61             m_aInternSemaphoreFile = new File(sInternFileName);
  62         }
  63
  64     public File getSemaphoreFile()
  65         {
  66             return m_aInternSemaphoreFile;
  67         }
  68 // ------------------------------------------------------------------------------
  69 // wait until resource is available
  70     public void P(File _aSemaphore)
  71         {
  72             int nCount = 0;
  73             int nCheckLoop = 1;
  74
  75             while ( nCheckLoop == 1)
  76             {
  77                 // check if resource is available, if not, wait.
  78                 if ( _aSemaphore.exists() )
  79                 {
  80                     GlobalLogWriter.get().println( "Active wait since " + nCount + "sec..");
  81                     nCount ++;
  82                     sleep( 1 );
  83                 }
  84                 else
  85                 {
  86                     sleep( 1 );
  87                     if ( _aSemaphore.exists() )
  88                     {
  89                         // ups
  90                         GlobalLogWriter.get().println( "ups...");
  91                     }
  92                     else
  93                     {
  94                         nCheckLoop = 0;
  95                     }
  96                 }
  97             }
  98
  99             // block resource by ourself
 100             try
 101             {
 102                 RandomAccessFile aWriter = new RandomAccessFile(_aSemaphore, "rw");
 103                 aWriter.writeByte(1);
 104                 aWriter.close();
 105             }
 106
 107             catch (java.io.FileNotFoundException fne)
 108             {
 109                 GlobalLogWriter.get().println( "caught: FileNotFoundException");
 110             }
 111             catch(java.io.IOException ie)
 112             {
 113                 GlobalLogWriter.get().println( "caught: IOException");
 114             }
 115         }
 116
 117 // ------------------------------------------------------------------------------
 118 // block a resource
 119     public void V(File _aSemaphore)
 120         {
 121
 122             if ( _aSemaphore.exists() )
 123             {
 124                 _aSemaphore.delete();
 125             }
 126             else
 127             {
 128                 GlobalLogWriter.get().println("Could be a problem here? No resource block found.");
 129             }
 130         }
 131
 132     // --------------------------------- Unit test ---------------------------------
 133
 134     private static boolean SEMAPHORE_SHOULD_EXIST = true;
 135     private static boolean SEMAPHORE_SHOULD_NOT_EXIST = false;
 136
 137     private static void assure(boolean _b, String _sText)
 138         {
 139             System.out.print(_sText);
 140             System.out.print("  ");
 141             if (_b)
 142             {
 143                 System.out.println("ok");
 144             }
 145             else
 146             {
 147                 System.out.println("FAILED");
 148             }
 149         }
 150
 151     private static void testSemaphoreFile(SimpleFileSemaphore a, boolean _bShouldFileExists)
 152         {
 153             System.out.println("Check if semaphore file exists.");
 154             File aSemaphoreFile = a.getSemaphoreFile();
 155             if (aSemaphoreFile.exists())
 156             {
 157                 System.out.println("Name is: " + aSemaphoreFile.getAbsolutePath());
 158                 assure(_bShouldFileExists == SEMAPHORE_SHOULD_EXIST, "Semaphore should exist!");
 159             }
 160             else
 161             {
 162                 assure(_bShouldFileExists == SEMAPHORE_SHOULD_NOT_EXIST, "Semaphore should not exist!");
 163             }
 164         }
 165
 166     public static void main( String[] argv )
 167         {
 168             SimpleFileSemaphore a = new SimpleFileSemaphore();
 169
 170             testSemaphoreFile(a, SEMAPHORE_SHOULD_NOT_EXIST);
 171
 172             a.P(a.getSemaphoreFile());
 173
 174             testSemaphoreFile(a, SEMAPHORE_SHOULD_EXIST);
 175
 176             a.V(a.getSemaphoreFile());
 177
 178             testSemaphoreFile(a, SEMAPHORE_SHOULD_NOT_EXIST);
 179         }
 180 }