Attachment #199147 for bug #259981

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2004, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

	private static final int FILETYPE_STANDARD = 0;
	private static final int FILETYPE_RELIABLEFILE = 1;
	private static final SecureAction secure = AccessController.doPrivileged(SecureAction.createSecureAction());
	private static final boolean tempCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanTempFiles")).booleanValue(); //$NON-NLS-1$
	private static final boolean openCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanupOnOpen")).booleanValue(); //$NON-NLS-1$
	private static final String MANAGER_FOLDER = ".manager"; //$NON-NLS-1$
	private static final String TABLE_FILE = ".fileTable"; //$NON-NLS-1$
	private static final String LOCK_FILE = ".fileTableLock"; //$NON-NLS-1$
	private static final int MAX_LOCK_WAIT = 5000; // 5 seconds 
	// these should be static but the tests expect to be able to create new managers after changing this setting dynamically
	private final boolean useReliableFiles = Boolean.valueOf(secure.getProperty("osgi.useReliableFiles")).booleanValue(); //$NON-NLS-1$
	private final boolean tempCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanTempFiles")).booleanValue(); //$NON-NLS-1$
	private final boolean openCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanupOnOpen")).booleanValue(); //$NON-NLS-1$

	private class Entry {
		int readId;

			if (error)
				fileStream.abort();
		}
		// bug 259981 we should clean up
		if (openCleanup) {
			try {
				cleanup(false);
			} catch (IOException ex) {
				// If IOException is thrown from our custom method.
				// log and swallow for now.
				System.out.println("Unexpected IOException is thrown inside cleanupWithLock. Please look below for stacktrace");
				ex.printStackTrace(System.out);
			}
		}
		tableStamp = ReliableFile.lastModifiedVersion(tableFile);
	}


	 * This removal is only done if the instance of eclipse calling this method is the last instance using this storage manager.
	 * @throws IOException
	 */
	private void cleanup(boolean doLock) throws IOException {
		if (readOnly)
			return;
		//Lock first, so someone else can not start while we're in the middle of cleanup
		if (doLock && !lock(true))
			throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);
		try {
			//Iterate through the temp files and delete them all, except the one representing this storage manager.

				}
			}
		} finally {
			if (doLock)
				release();
		}
	}


		if (readOnly)
			return;
		try {
			cleanup(true);
		} catch (IOException e) {
			//Ignore and close.
		}

	 * @throws IOException if an error occurred opening the storage manager
	 */
	public void open(boolean wait) throws IOException {
		if (openCleanup)
			cleanup();
		if (!readOnly) {
			managerRoot.mkdirs();
			if (!managerRoot.exists())
				throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);
			if (openCleanup)
				cleanup(true);
			boolean locked = lock(wait);
			if (!locked && wait)
				throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);




/*******************************************************************************
 * Copyright (c) 2004, 2011 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at

package org.eclipse.osgi.tests.services.datalocation;

import java.io.*;

import junit.framework.Test;
import junit.framework.TestSuite;
import org.eclipse.core.runtime.Platform;

		if (file.isDirectory()) {
			File[] list = file.listFiles();
			if (list != null) {
				for (int idx = 0; idx < list.length; idx++) {
					rm(list[idx]);
				}
			}
		}
		file.delete();
	}

	
	/**
	 * Open a filemanager in readonly and ensure files are
	 * not created.

		manager1 = new StorageManager(testDir, null, true);
		try {
			manager1.open(true);
		} catch (IOException e) {
			fail("unexpected exception", e);
		}
		files = testDir.list();

		try {
			manager1.add(fileName);
			fail("add succedded");
		} catch (IOException e) {
			//good
		}

		try {
			manager1.lookup(fileName, true);
			fail("lookup succedded");
		} catch (IOException e) {
			//good
		}

		try {
			manager1.createTempFile(fileName);
			fail("create temp file succedded");
		} catch (IOException e) {
			//good
		}
		files = testDir.list();

			manager2.update(new String[] {fileName}, new String[] {tmpFile.getName()});
			manager2.close();
			manager2 = null;
		} catch (IOException e) {
			fail("unexpected exception", e);
		}
	}

	
	void writeToFile(File file, String str) throws IOException {
		FileOutputStream fos = new FileOutputStream(file);
		try {

		}
	}

	
	private String getInputStreamContents(InputStream is) throws IOException {
		StringBuffer sb = new StringBuffer();
		byte[] data = new byte[64];

		try {
			while ((len = is.read(data)) != -1) {
				sb.append(new String(data, 0, len));
			}
		} finally {
			is.close();
		}
		return sb.toString();
	}

	
	/**
	 * This tests a FM update where the a specific file is managed with a 
	 * revision number of (n) and an update is requested while there already

		manager1 = new StorageManager(base, null);
		try {
			manager1.open(false);
			File file1 = new File(base, testFile + ".1");
			File file2 = new File(base, testFile + ".2");
			File file3 = new File(base, testFile + ".3");
			File file4 = new File(base, testFile + ".4");
			if (file1.exists() || file2.exists() || file3.exists() || file4.exists()) {
				fail("Test files already exists.");
				return;

				fail("Failed to create a single test file");
				return;
			}

			// create file version (2) outside filemanager
			writeToFile(file2, "file2 exists");


				fail("Failed to skip existing filemanager file.");
				return;
			}

			// open a new manager, ensure a lookup results in file version (3)
			manager2 = new StorageManager(base, null);
			manager2.open(true);

			assertTrue(file.exists());
			FileInputStream fis = new FileInputStream(file);
			assertEquals(getInputStreamContents(fis), "file 3 contents");

			manager2.close();
			manager2 = null;

			manager1.close();
			manager1 = null;
		} catch (IOException e) {
			fail("unexpected exception", e);
		}
	}

	
	/**
	 * This tests that FM apis throw exceptions if FM has not yet been opened
	 * or if FM has been closed.  

			this.writeToFile(tmpFile, "File exists");
			manager1.update(new String[] {permanentFile}, new String[] {tmpFile.getName()});
			manager1.add(scratchFile);
		} catch (IOException e) {
			fail("unexpected exception", e);
		}

		// create a new manager, and try making calls
		manager2 = new StorageManager(base, null);
		checkOpen(false, permanentFile, scratchFile);
		// open the manager, try again
		try {
			manager2.open(true);
		} catch (IOException e) {
			fail("unexpected exception", e);
		}
		checkOpen(true, permanentFile, scratchFile);

		manager2.close();
		checkOpen(false, permanentFile, scratchFile);
		manager2 = null;

		manager1.close();
		manager1 = null;
	}

			if (!open)
				fail("add did not fail.");
			manager2.remove("failFile");
		} catch (IOException e) {
			if (open)
				fail("unexpected exception", e);
		}

			manager2.lookup(permanentFile, false);
			if (!open)
				fail("lookup did not fail.");
		} catch (IOException e) {
			if (open)
				fail("unexpected exception", e);
		}

		} catch (IOException e) {
			fail("unexpected exception", e);
			tmpFile = null;
		}
		if (tmpFile != null) {
			try {
				manager2.update(new String[] {permanentFile}, new String[] {tmpFile.getName()});
				if (!open)
					fail("update did not fail.");
			} catch (IOException e) {
				if (open)
					fail("unexpected exception", e);
			}

			manager2.remove(scratchFile);
			if (!open)
				fail("remove did not fail");
			else
				// add the file back if expected to complete
				manager2.add(scratchFile);
		} catch (IOException e) {
			if (open)
				fail("unexpected exception", e);
		}
	}

	
	/**
	 * This tests FM remove() then add().  On a remove(), the file can not be deleted as it may
	 * be in use by another FM. Then add() the file back and see if the version number written to

	 */
	public void testRemoveThenAdd() {
		String fileName = "testRemoveThenAdd.txt";
		File file1 = new File(base, fileName + ".1");
		File file2 = new File(base, fileName + ".2");
		File file3 = new File(base, fileName + ".3");
		manager1 = new StorageManager(base, null);
		// create a permanent file
		try {

			// sanity check
			if (file1.exists() || !file2.exists() || file3.exists())
				fail("Failed creating a file revision");

			manager2 = new StorageManager(base, null);
			manager2.open(true);
			manager2.remove(fileName);

			assertNotNull(testFile);
			assertTrue(testFile.getName().endsWith(".3"));
			assertTrue(file3.exists());

			// open a new manager, ensure that the database was updated
			// by checking version is also #3
			manager1 = new StorageManager(base, null);

			testFile = manager1.lookup(fileName, false);
			assertNotNull(testFile);
			assertTrue(testFile.getName().endsWith(".3"));

			manager1.close();
			manager1 = null;
			manager2.close();
			manager2 = null;
		} catch (IOException e) {
			fail("unexpected exception", e);
		}
	}

	/**
	 * Test multiple FM do not cleanup any old files as they may be in use.
	 */

			// this is a Windows-only test
			return;
		String fileName = "testMultipleFileManagers.txt";
		File file1 = new File(base, fileName + ".1");
		File file2 = new File(base, fileName + ".2");
		manager1 = new StorageManager(base, null);
		try {
			manager1.open(true);

			file = manager1.createTempFile(fileName);
			writeToFile(file, "test contents #1");
			manager1.update(new String[] {fileName}, new String[] {file.getName()});

			// ensure file is version #1
			file = manager1.lookup(fileName, false);
			assertNotNull(file);
			assertTrue(file.getName().endsWith(".1"));
			assertTrue(file1.exists());

			//new fileMangager using version #1
			manager2 = new StorageManager(base, null);
			manager2.open(true);

			assertNotNull(file);
			assertTrue(file.getName().endsWith(".1"));
			assertTrue(file1.exists() && !file2.exists());

			// back to manager #1, update file again, close
			file = manager1.createTempFile(fileName);
			writeToFile(file, "test contents #2");

			// both files better still exists
			assertTrue(file1.exists());
			assertTrue(file2.exists());

			// manager #2
			// sanity check
			file = manager2.lookup(fileName, false);

			manager2 = null;
			assertTrue(!file1.exists());
			assertTrue(file2.exists());

			// new manager1, does it get version 1?
			manager1 = new StorageManager(base, null);
			manager1.open(true);
			file = manager1.lookup(fileName, false);
			assertNotNull(file);
			assertTrue(file.getName().endsWith(".2"));
			manager1.close();
			manager1 = null;
		} catch (IOException e) {
			fail("unexpected exception", e);
		}
	}

	/**
	 * This test will verify that a FM will fail if a lock is held
	 */

			// this is a Windows-only test
			return;
		String fileName = "testJavaIOLocking";
		File lockFile = new File(new File(base, ".manager"), ".fileTableLock");
		lockFile.getParentFile().mkdirs();
		try {
			new FileOutputStream(lockFile).close();
		} catch (IOException e) {
			fail("unexpected exception", e);
		}
		assertTrue(lockFile.exists());

			try {
				manager1.open(true); // wait for lock
				fail("open with lock succedded");
			} catch (IOException e) {
				//good
			}

			manager1.open(false); // don't wait, should work
			try {
				manager1.add(fileName);
				fail("add succedded");
			} catch (IOException e) {
				//good
			}
			//sanity check, file should not be managed
			assertNull(manager1.lookup(fileName, false));
			manager1.close();
			manager1 = null;
		} catch (IOException e) {
			fail("unexpected exception", e);
		} finally {
			try {
				if (fos != null)
					fos.close();
			} catch (IOException e) {
				fail("unexpected exception", e);
			}
		}
	}

	public void testCleanup() {
		String fileName = "testCleanup.txt";
		File file1 = new File(base, fileName + ".1");
		File file2 = new File(base, fileName + ".2");
		File file3 = new File(base, fileName + ".3");
		System.setProperty("osgi.embedded.cleanupOnOpen", "true");
		// create a permanent file
		try {
			manager1 = new StorageManager(base, null);
			manager1.open(true);
			manager1.add(fileName);
			// create version (1)
			File tmpFile = manager1.createTempFile(fileName);
			writeToFile(tmpFile, "File exists #1");
			manager1.update(new String[] {fileName}, new String[] {tmpFile.getName()});
			// sanity check
			assertTrue(file1.toString(), file1.exists());
			assertFalse(file2.toString(), file2.exists());
			assertFalse(file3.toString(), file3.exists());

			// do it again, now version (2)
			tmpFile = manager1.createTempFile(fileName);
			writeToFile(tmpFile, "File exists #2");
			manager1.update(new String[] {fileName}, new String[] {tmpFile.getName()});
			// sanity check
			assertFalse(file1.toString(), file1.exists());
			assertTrue(file2.toString(), file2.exists());
			assertFalse(file3.toString(), file3.exists());

			// do it again, now version (3)
			tmpFile = manager1.createTempFile(fileName);
			writeToFile(tmpFile, "File exists #3");
			manager1.update(new String[] {fileName}, new String[] {tmpFile.getName()});
			// sanity check
			assertFalse(file1.toString(), file1.exists());
			assertFalse(file2.toString(), file2.exists());
			assertTrue(file3.toString(), file3.exists());

			manager1.close(); // force a cleanup
			manager1 = null;
			// sanity check
			assertFalse(file1.toString(), file1.exists());
			assertFalse(file2.toString(), file2.exists());
			assertTrue(file3.toString(), file3.exists());
		} catch (IOException e) {
			fail("unexpected exception", e);
		} finally {
			System.setProperty("osgi.embedded.cleanupOnOpen", "false");
		}
	}
}

Lines 1-5 Link Here

(-)src/org/eclipse/osgi/tests/services/datalocation/StreamManagerTests.java (-1 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2010 IBM Corporation and others.	2	* Copyright (c) 2004, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 184-189 Link Here
184	manager1 = null;	184	manager1 = null;
185	} catch (IOException e) {	185	} catch (IOException e) {
186	fail("unexepected exception", e);	186	fail("unexepected exception", e);
		187	} finally {
		188	System.setProperty("osgi.useReliableFiles", "false"); // force reliable files off
187	}	189	}
188	}	190	}
189		191

Return to bug 259981

Lines 1-5 Link Here

(-)supplement/src/org/eclipse/osgi/storagemanager/StorageManager.java (-10 / +22 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2010 IBM Corporation and others.	2	* Copyright (c) 2004, 2011 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 87-100 Link Here
87	private static final int FILETYPE_STANDARD = 0;	87	private static final int FILETYPE_STANDARD = 0;
88	private static final int FILETYPE_RELIABLEFILE = 1;	88	private static final int FILETYPE_RELIABLEFILE = 1;
89	private static final SecureAction secure = AccessController.doPrivileged(SecureAction.createSecureAction());	89	private static final SecureAction secure = AccessController.doPrivileged(SecureAction.createSecureAction());
90	private static final boolean tempCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanTempFiles")).booleanValue(); //$NON-NLS-1$
91	private static final boolean openCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanupOnOpen")).booleanValue(); //$NON-NLS-1$
92	private static final String MANAGER_FOLDER = ".manager"; //$NON-NLS-1$	90	private static final String MANAGER_FOLDER = ".manager"; //$NON-NLS-1$
93	private static final String TABLE_FILE = ".fileTable"; //$NON-NLS-1$	91	private static final String TABLE_FILE = ".fileTable"; //$NON-NLS-1$
94	private static final String LOCK_FILE = ".fileTableLock"; //$NON-NLS-1$	92	private static final String LOCK_FILE = ".fileTableLock"; //$NON-NLS-1$
95	private static final int MAX_LOCK_WAIT = 5000; // 5 seconds	93	private static final int MAX_LOCK_WAIT = 5000; // 5 seconds
96	// this should be static but the tests expect to be able to create new managers after changing this setting dynamically	94	// these should be static but the tests expect to be able to create new managers after changing this setting dynamically
97	private final boolean useReliableFiles = Boolean.valueOf(secure.getProperty("osgi.useReliableFiles")).booleanValue(); //$NON-NLS-1$	95	private final boolean useReliableFiles = Boolean.valueOf(secure.getProperty("osgi.useReliableFiles")).booleanValue(); //$NON-NLS-1$
		96	private final boolean tempCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanTempFiles")).booleanValue(); //$NON-NLS-1$
		97	private final boolean openCleanup = Boolean.valueOf(secure.getProperty("osgi.embedded.cleanupOnOpen")).booleanValue(); //$NON-NLS-1$
98		98
99	private class Entry {	99	private class Entry {
100	int readId;	100	int readId;
Lines 554-559 Link Here
554	if (error)	554	if (error)
555	fileStream.abort();	555	fileStream.abort();
556	}	556	}
		557	// bug 259981 we should clean up
		558	if (openCleanup) {
		559	try {
		560	cleanup(false);
		561	} catch (IOException ex) {
		562	// If IOException is thrown from our custom method.
		563	// log and swallow for now.
		564	System.out.println("Unexpected IOException is thrown inside cleanupWithLock. Please look below for stacktrace");
		565	ex.printStackTrace(System.out);
		566	}
		567	}
557	tableStamp = ReliableFile.lastModifiedVersion(tableFile);	568	tableStamp = ReliableFile.lastModifiedVersion(tableFile);
558	}	569	}
559		570
Lines 584-594 Link Here
584	* This removal is only done if the instance of eclipse calling this method is the last instance using this storage manager.	595	* This removal is only done if the instance of eclipse calling this method is the last instance using this storage manager.
585	* @throws IOException	596	* @throws IOException
586	*/	597	*/
587	private void cleanup() throws IOException {	598	private void cleanup(boolean doLock) throws IOException {
588	if (readOnly)	599	if (readOnly)
589	return;	600	return;
590	//Lock first, so someone else can not start while we're in the middle of cleanup	601	//Lock first, so someone else can not start while we're in the middle of cleanup
591	if (!lock(true))	602	if (doLock && !lock(true))
592	throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);	603	throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);
593	try {	604	try {
594	//Iterate through the temp files and delete them all, except the one representing this storage manager.	605	//Iterate through the temp files and delete them all, except the one representing this storage manager.
Lines 636-642 Link Here
636	}	647	}
637	}	648	}
638	} finally {	649	} finally {
639	release();	650	if (doLock)
		651	release();
640	}	652	}
641	}	653	}
642		654
Lines 662-668 Link Here
662	if (readOnly)	674	if (readOnly)
663	return;	675	return;
664	try {	676	try {
665	cleanup();	677	cleanup(true);
666	} catch (IOException e) {	678	} catch (IOException e) {
667	//Ignore and close.	679	//Ignore and close.
668	}	680	}
Lines 680-691 Link Here
680	* @throws IOException if an error occurred opening the storage manager	692	* @throws IOException if an error occurred opening the storage manager
681	*/	693	*/
682	public void open(boolean wait) throws IOException {	694	public void open(boolean wait) throws IOException {
683	if (openCleanup)
684	cleanup();
685	if (!readOnly) {	695	if (!readOnly) {
686	managerRoot.mkdirs();	696	managerRoot.mkdirs();
687	if (!managerRoot.exists())	697	if (!managerRoot.exists())
688	throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);	698	throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);
		699	if (openCleanup)
		700	cleanup(true);
689	boolean locked = lock(wait);	701	boolean locked = lock(wait);
690	if (!locked && wait)	702	if (!locked && wait)
691	throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);	703	throw new IOException(EclipseAdaptorMsg.fileManager_cannotLock);