Attachment #198334 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");
		}
	}
}




/*******************************************************************************
 * 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;
import org.eclipse.osgi.storagemanager.ManagedOutputStream;
import org.eclipse.osgi.storagemanager.StorageManager;

		else
			System.setProperty("osgi.useReliableFiles", reliableFile);
	}

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

	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();
	}

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

		}
	}

	
	/**
	 * This tests that FM will keep a backup version of a reliableFile and that
	 * corrupting the reliableFile will recover the previous contents.

	 */
	public void testReliableFile() {
		String fileName = "testReliableFile.txt";
		File file1 = new File(base, fileName + ".1");
		File file2 = new File(base, fileName + ".2");
		File file3 = new File(base, fileName + ".3");
		String contents1 = "test reliable file cOntents #1";
		String contents2 = "test reliable file cOntents #2";
		try {

			assertNotNull(fmos);
			fmos.write(contents1.getBytes());
			fmos.close();

			// Write verion2 of the file
			fmos = manager1.getOutputStream(fileName);
			assertNotNull(fmos);

			assertTrue(!file3.exists());
			manager1.close();
			manager1 = null;

			//now, open new manager, verify file contents are #2
			System.setProperty("osgi.useReliableFiles", "true"); // force reliable files
			manager2 = new StorageManager(base, null);

			assertEquals(contents2, getInputStreamContents(is));
			manager2.close();
			manager2 = null;

			// need to sleep, FAT32 doesn't have too fine granularity in timestamps
			try {
				Thread.sleep(5000);
			} catch (InterruptedException e) {/*ignore*/
			}
			//now, corrupt version 2 of the file
			RandomAccessFile raf = new RandomAccessFile(file2, "rw");
			raf.seek(20);

			System.setProperty("osgi.useReliableFiles", "true"); // force reliable files
			manager1 = new StorageManager(base, null);
			manager1.open(true);

			//request any valid stream available
			is = manager1.getInputStream(fileName);
			assertNotNull(is);
			assertEquals(contents1, getInputStreamContents(is));

			//now request only the primary file
			try {
				InputStream[] isSet = manager1.getInputStreamSet(new String[] {fileName});

						isSet[i].close();
				}
				fail("getInputStreamSet was successful");
			} catch (IOException e) {
				//good
			}

			//now, corrupt version 1 of the file
			raf = new RandomAccessFile(file1, "rw");
			raf.seek(20);
			raf.write('0'); // change 'O' to '0'
			raf.close();

			// get input stream should fail
			try {
				is = manager1.getInputStream(fileName);
				fail("get input stream succedded");
			} catch (IOException e) {
				//good
			}
			manager1.close();
			manager1 = null;
		} catch (IOException e) {
			fail("unexepected exception", e);
		} finally {
			System.setProperty("osgi.useReliableFiles", "false"); // force reliable files off
		}
	}

	
	/**
	 * This tests if migration from a prior (non-ReliableFile) .fileTable
	 * to the current .fileTable is correct.

		File testDir = new File(base, "testMigrationManager");
		File managerDir = new File(testDir, ".manager");
		String fileName = "testMigration.txt";
		File file2 = new File(testDir, fileName + ".2");
		File file5 = new File(testDir, fileName + ".5");
		File fileTable = new File(managerDir, ".fileTable");
		File fileTable1 = new File(managerDir, ".fileTable.1");
		File fileTable2 = new File(managerDir, ".fileTable.2");

		try {
			// create a .fileTable and a normal file
			managerDir.mkdirs();
			writeToFile(fileTable, "#safe table\n" + fileName + "=2\n");
			writeToFile(file2, contents1);
			manager1 = new StorageManager(testDir, null);
			manager1.open(true);
			File test = manager1.lookup(fileName, false);
			assertNotNull(test);
			assertTrue(test.exists());

			// update a new file
			File testFile = manager1.createTempFile(fileName);
			writeToFile(testFile, contents2);

			writeToFile(testFile, contents1);
			manager1.update(new String[] {fileName}, new String[] {testFile.getName()});
			manager1.close();
			manager1 = null;

			String[] files = managerDir.list();
			assertEquals(4, files.length);
			//original file never gets deleted

			files = testDir.list();
			assertEquals(2, files.length);
			assertTrue(file5.exists());

			manager2 = new StorageManager(testDir, null);
			manager2.open(true);
			testFile = manager2.lookup(fileName, false);

			assertTrue(testFile.exists());
			assertTrue(testFile.getName().endsWith(".5"));
			manager2.close();
			manager2 = null;

		} catch (IOException e) {
			fail("unexepected exception", e);
		}
	}

		testAbort(true);
		testAbort(false);
	}

	private void testAbort(boolean reliable) {
		String fileName;
		if (reliable)
			fileName = "abortFileReliable.txt";
		else
			fileName = "abortFileStd.txt";
		File file1 = new File(base, fileName + ".1");
		File file2 = new File(base, fileName + ".2");
		File file3 = new File(base, fileName + ".3");
		String contents1 = "test reliable file contents #1";
		String contents2 = "test reliable file contents #2";
		try {

			ManagedOutputStream smos = manager1.getOutputStream(fileName);
			smos.write(contents1.getBytes());
			smos.close();

			//start creating version 2
			smos = manager1.getOutputStream(fileName);
			smos.write(contents2.getBytes());
			smos.abort();
			smos.close(); // shouldn't cause exception, check!

			// now see if we're still on version #1
			assertEquals(1, manager1.getId(fileName));
			// check contents also

			assertNotNull(is);
			assertEquals(contents1, getInputStreamContents(is));
			manager1.close();
			manager1 = null;

			// open a new manager & check the same thing to ensure the database is correct
			System.setProperty("osgi.useReliableFiles", "true"); // force reliable files
			manager2 = new StorageManager(base, null);

			assertNotNull(is);
			assertEquals(contents1, getInputStreamContents(is));
			manager2.close();
			manager2 = null;
			assertTrue(file1.exists());
			assertFalse(file2.exists());
			assertFalse(file3.exists());
		} catch (IOException e) {
			fail("unexepected exception", e);
		}
	}

	
	/**
	 * This tests if getting an output stream-set work properly.
	 *

		testGetOutputStreamSet(true);
		testGetOutputStreamSet(false);
	}

	private void testGetOutputStreamSet(boolean reliable) {
		File mgrDir;
		if (reliable)

			mgrDir = new File(base, "getSetStd");
		String fileName1 = "testSet1.txt";
		String fileName2 = "testSet2.txt";
		File file1_1 = new File(mgrDir, fileName1 + ".1");
		File file1_2 = new File(mgrDir, fileName1 + ".2");
		File file2_1 = new File(mgrDir, fileName2 + ".1");
		File file2_2 = new File(mgrDir, fileName2 + ".2");
		String contents1 = "test reliable file contents #1";
		String contents2 = "test reliable file contents #2";
		try {

			ManagedOutputStream[] outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2});
			assertNotNull(outs);
			assertEquals(2, outs.length);

			outs[0].write(contents1.getBytes());
			outs[1].write(contents2.getBytes());
			outs[1].close();

			outs[0].close();
			assertTrue(file1_1.exists());
			assertTrue(file2_1.exists());

			outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2});
			assertNotNull(outs);

			outs[0].write("new data #1".getBytes());
			outs[1].write("new data #2".getBytes());
			outs[0].close();

			assertTrue(file2_2.exists());
			manager1.close();
			manager1 = null;

			if (reliable) {
				// verify FM thinks they are reliable
				assertTrue(file1_1.exists());

			} else {
				// verify FM thinks they are not reliable
				assertFalse(file1_1.exists());
				assertFalse(file2_1.exists());
			}

		} catch (IOException e) {
			fail("unexepected exception", e);
		}
	}

	/**
	 * This tests if aborting a managed stream-set works as expected
	 *

		testAbortSet(true);
		testAbortSet(false);
	}

	private void testAbortSet(boolean reliable) {
		File mgrDir;
		if (reliable)

			manager1.open(true);
			ManagedOutputStream[] outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2, fileName3, fileName4});
			assertNotNull(outs);

			outs[0].write(contents1.getBytes());
			outs[1].write(contents2.getBytes());
			outs[2].write(contents2.getBytes());

			assertNull(manager1.lookup(fileName4, false));
			manager1.close();
			manager1 = null;

			// open a new manager & check the same thing to ensure the database is correct
			System.setProperty("osgi.useReliableFiles", reliable ? "true" : "false"); // force reliable files
			manager2 = new StorageManager(mgrDir, null);

			assertEquals(1, list.length);
			manager2.close();
			manager2 = null;

		} catch (IOException e) {
			fail("unexepected exception", e);
		}
	}

}

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);

Lines 1-5 Link Here

(-)src/org/eclipse/osgi/tests/services/datalocation/StreamManagerTests.java (-67 / +64 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2004, 2006 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 11-20 Link Here
11	package org.eclipse.osgi.tests.services.datalocation;	11	package org.eclipse.osgi.tests.services.datalocation;
12		12
13	import java.io.*;	13	import java.io.*;
14
15	import junit.framework.Test;	14	import junit.framework.Test;
16	import junit.framework.TestSuite;	15	import junit.framework.TestSuite;
17
18	import org.eclipse.core.runtime.Platform;	16	import org.eclipse.core.runtime.Platform;
19	import org.eclipse.osgi.storagemanager.ManagedOutputStream;	17	import org.eclipse.osgi.storagemanager.ManagedOutputStream;
20	import org.eclipse.osgi.storagemanager.StorageManager;	18	import org.eclipse.osgi.storagemanager.StorageManager;
Lines 57-75 Link Here
57	else	55	else
58	System.setProperty("osgi.useReliableFiles", reliableFile);	56	System.setProperty("osgi.useReliableFiles", reliableFile);
59	}	57	}
60		58
61	private void rm(File file) {	59	private void rm(File file) {
62	if (file.isDirectory()) {	60	if (file.isDirectory()) {
63	File[] list = file.listFiles();	61	File[] list = file.listFiles();
64	if (list != null) {	62	if (list != null) {
65	for (int idx=0; idx<list.length; idx++) {	63	for (int idx = 0; idx < list.length; idx++) {
66	rm(list[idx]);	64	rm(list[idx]);
67	}	65	}
68	}	66	}
69	}	67	}
70	file.delete();	68	file.delete();
71	}	69	}
72		70
73	private String getInputStreamContents(InputStream is) throws IOException {	71	private String getInputStreamContents(InputStream is) throws IOException {
74	StringBuffer sb = new StringBuffer();	72	StringBuffer sb = new StringBuffer();
75	byte[] data = new byte[64];	73	byte[] data = new byte[64];
Lines 77-90 Link Here
77	try {	75	try {
78	while ((len = is.read(data)) != -1) {	76	while ((len = is.read(data)) != -1) {
79	sb.append(new String(data, 0, len));	77	sb.append(new String(data, 0, len));
80	}	78	}
81	} finally {	79	} finally {
82	is.close();	80	is.close();
83	}	81	}
84	return sb.toString();	82	return sb.toString();
85	}	83	}
86		84
87
88	void writeToFile(File file, String str) throws IOException {	85	void writeToFile(File file, String str) throws IOException {
89	FileOutputStream fos = new FileOutputStream(file);	86	FileOutputStream fos = new FileOutputStream(file);
90	try {	87	try {
Lines 96-102 Link Here
96	}	93	}
97	}	94	}
98		95
99
100	/**	96	/**
101	* This tests that FM will keep a backup version of a reliableFile and that	97	* This tests that FM will keep a backup version of a reliableFile and that
102	* corrupting the reliableFile will recover the previous contents.	98	* corrupting the reliableFile will recover the previous contents.
Lines 104-112 Link Here
104	*/	100	*/
105	public void testReliableFile() {	101	public void testReliableFile() {
106	String fileName = "testReliableFile.txt";	102	String fileName = "testReliableFile.txt";
107	File file1 = new File(base, fileName+".1");	103	File file1 = new File(base, fileName + ".1");
108	File file2 = new File(base, fileName+".2");	104	File file2 = new File(base, fileName + ".2");
109	File file3 = new File(base, fileName+".3");	105	File file3 = new File(base, fileName + ".3");
110	String contents1 = "test reliable file cOntents #1";	106	String contents1 = "test reliable file cOntents #1";
111	String contents2 = "test reliable file cOntents #2";	107	String contents2 = "test reliable file cOntents #2";
112	try {	108	try {
Lines 117-123 Link Here
117	assertNotNull(fmos);	113	assertNotNull(fmos);
118	fmos.write(contents1.getBytes());	114	fmos.write(contents1.getBytes());
119	fmos.close();	115	fmos.close();
120		116
121	// Write verion2 of the file	117	// Write verion2 of the file
122	fmos = manager1.getOutputStream(fileName);	118	fmos = manager1.getOutputStream(fileName);
123	assertNotNull(fmos);	119	assertNotNull(fmos);
Lines 128-134 Link Here
128	assertTrue(!file3.exists());	124	assertTrue(!file3.exists());
129	manager1.close();	125	manager1.close();
130	manager1 = null;	126	manager1 = null;
131		127
132	//now, open new manager, verify file contents are #2	128	//now, open new manager, verify file contents are #2
133	System.setProperty("osgi.useReliableFiles", "true"); // force reliable files	129	System.setProperty("osgi.useReliableFiles", "true"); // force reliable files
134	manager2 = new StorageManager(base, null);	130	manager2 = new StorageManager(base, null);
Lines 138-148 Link Here
138	assertEquals(contents2, getInputStreamContents(is));	134	assertEquals(contents2, getInputStreamContents(is));
139	manager2.close();	135	manager2.close();
140	manager2 = null;	136	manager2 = null;
141		137
142	// need to sleep, FAT32 doesn't have too fine granularity in timestamps	138	// need to sleep, FAT32 doesn't have too fine granularity in timestamps
143	try {	139	try {
144	Thread.sleep(5000);	140	Thread.sleep(5000);
145	} catch(InterruptedException e) {/ignore/}	141	} catch (InterruptedException e) {/ignore/
		142	}
146	//now, corrupt version 2 of the file	143	//now, corrupt version 2 of the file
147	RandomAccessFile raf = new RandomAccessFile(file2, "rw");	144	RandomAccessFile raf = new RandomAccessFile(file2, "rw");
148	raf.seek(20);	145	raf.seek(20);
Lines 152-163 Link Here
152	System.setProperty("osgi.useReliableFiles", "true"); // force reliable files	149	System.setProperty("osgi.useReliableFiles", "true"); // force reliable files
153	manager1 = new StorageManager(base, null);	150	manager1 = new StorageManager(base, null);
154	manager1.open(true);	151	manager1.open(true);
155		152
156	//request any valid stream available	153	//request any valid stream available
157	is = manager1.getInputStream(fileName);	154	is = manager1.getInputStream(fileName);
158	assertNotNull(is);	155	assertNotNull(is);
159	assertEquals(contents1, getInputStreamContents(is));	156	assertEquals(contents1, getInputStreamContents(is));
160		157
161	//now request only the primary file	158	//now request only the primary file
162	try {	159	try {
163	InputStream[] isSet = manager1.getInputStreamSet(new String[] {fileName});	160	InputStream[] isSet = manager1.getInputStreamSet(new String[] {fileName});
Lines 166-196 Link Here
166	isSet[i].close();	163	isSet[i].close();
167	}	164	}
168	fail("getInputStreamSet was successful");	165	fail("getInputStreamSet was successful");
169	} catch(IOException e) {	166	} catch (IOException e) {
170	//good	167	//good
171	}	168	}
172		169
173	//now, corrupt version 1 of the file	170	//now, corrupt version 1 of the file
174	raf = new RandomAccessFile(file1, "rw");	171	raf = new RandomAccessFile(file1, "rw");
175	raf.seek(20);	172	raf.seek(20);
176	raf.write('0'); // change 'O' to '0'	173	raf.write('0'); // change 'O' to '0'
177	raf.close();	174	raf.close();
178		175
179	// get input stream should fail	176	// get input stream should fail
180	try {	177	try {
181	is = manager1.getInputStream(fileName);	178	is = manager1.getInputStream(fileName);
182	fail("get input stream succedded");	179	fail("get input stream succedded");
183	} catch(IOException e) {	180	} catch (IOException e) {
184	//good	181	//good
185	}	182	}
186	manager1.close();	183	manager1.close();
187	manager1 = null;	184	manager1 = null;
188	} catch(IOException e) {	185	} catch (IOException e) {
189	fail("unexepected exception", e);	186	fail("unexepected exception", e);
		187	} finally {
		188	System.setProperty("osgi.useReliableFiles", "false"); // force reliable files off
190	}	189	}
191	}	190	}
192		191
193
194	/**	192	/**
195	* This tests if migration from a prior (non-ReliableFile) .fileTable	193	* This tests if migration from a prior (non-ReliableFile) .fileTable
196	* to the current .fileTable is correct.	194	* to the current .fileTable is correct.
Lines 200-207 Link Here
200	File testDir = new File(base, "testMigrationManager");	198	File testDir = new File(base, "testMigrationManager");
201	File managerDir = new File(testDir, ".manager");	199	File managerDir = new File(testDir, ".manager");
202	String fileName = "testMigration.txt";	200	String fileName = "testMigration.txt";
203	File file2 = new File(testDir, fileName+".2");	201	File file2 = new File(testDir, fileName + ".2");
204	File file5 = new File(testDir, fileName+".5");	202	File file5 = new File(testDir, fileName + ".5");
205	File fileTable = new File(managerDir, ".fileTable");	203	File fileTable = new File(managerDir, ".fileTable");
206	File fileTable1 = new File(managerDir, ".fileTable.1");	204	File fileTable1 = new File(managerDir, ".fileTable.1");
207	File fileTable2 = new File(managerDir, ".fileTable.2");	205	File fileTable2 = new File(managerDir, ".fileTable.2");
Lines 212-225 Link Here
212	try {	210	try {
213	// create a .fileTable and a normal file	211	// create a .fileTable and a normal file
214	managerDir.mkdirs();	212	managerDir.mkdirs();
215	writeToFile(fileTable, "#safe table\n"+fileName+"=2\n");	213	writeToFile(fileTable, "#safe table\n" + fileName + "=2\n");
216	writeToFile(file2, contents1);	214	writeToFile(file2, contents1);
217	manager1 = new StorageManager(testDir, null);	215	manager1 = new StorageManager(testDir, null);
218	manager1.open(true);	216	manager1.open(true);
219	File test = manager1.lookup(fileName, false);	217	File test = manager1.lookup(fileName, false);
220	assertNotNull(test);	218	assertNotNull(test);
221	assertTrue(test.exists());	219	assertTrue(test.exists());
222		220
223	// update a new file	221	// update a new file
224	File testFile = manager1.createTempFile(fileName);	222	File testFile = manager1.createTempFile(fileName);
225	writeToFile(testFile, contents2);	223	writeToFile(testFile, contents2);
Lines 233-240 Link Here
233	writeToFile(testFile, contents1);	231	writeToFile(testFile, contents1);
234	manager1.update(new String[] {fileName}, new String[] {testFile.getName()});	232	manager1.update(new String[] {fileName}, new String[] {testFile.getName()});
235	manager1.close();	233	manager1.close();
236	manager1= null;	234	manager1 = null;
237		235
238	String[] files = managerDir.list();	236	String[] files = managerDir.list();
239	assertEquals(4, files.length);	237	assertEquals(4, files.length);
240	//original file never gets deleted	238	//original file never gets deleted
Lines 247-253 Link Here
247	files = testDir.list();	245	files = testDir.list();
248	assertEquals(2, files.length);	246	assertEquals(2, files.length);
249	assertTrue(file5.exists());	247	assertTrue(file5.exists());
250		248
251	manager2 = new StorageManager(testDir, null);	249	manager2 = new StorageManager(testDir, null);
252	manager2.open(true);	250	manager2.open(true);
253	testFile = manager2.lookup(fileName, false);	251	testFile = manager2.lookup(fileName, false);
Lines 255-263 Link Here
255	assertTrue(testFile.exists());	253	assertTrue(testFile.exists());
256	assertTrue(testFile.getName().endsWith(".5"));	254	assertTrue(testFile.getName().endsWith(".5"));
257	manager2.close();	255	manager2.close();
258	manager2=null;	256	manager2 = null;
259		257
260	} catch(IOException e) {	258	} catch (IOException e) {
261	fail("unexepected exception", e);	259	fail("unexepected exception", e);
262	}	260	}
263	}	261	}
Lines 270-285 Link Here
270	testAbort(true);	268	testAbort(true);
271	testAbort(false);	269	testAbort(false);
272	}	270	}
273		271
274	private void testAbort(boolean reliable) {	272	private void testAbort(boolean reliable) {
275	String fileName;	273	String fileName;
276	if (reliable)	274	if (reliable)
277	fileName = "abortFileReliable.txt";	275	fileName = "abortFileReliable.txt";
278	else	276	else
279	fileName = "abortFileStd.txt";	277	fileName = "abortFileStd.txt";
280	File file1 = new File(base, fileName+".1");	278	File file1 = new File(base, fileName + ".1");
281	File file2 = new File(base, fileName+".2");	279	File file2 = new File(base, fileName + ".2");
282	File file3 = new File(base, fileName+".3");	280	File file3 = new File(base, fileName + ".3");
283	String contents1 = "test reliable file contents #1";	281	String contents1 = "test reliable file contents #1";
284	String contents2 = "test reliable file contents #2";	282	String contents2 = "test reliable file contents #2";
285	try {	283	try {
Lines 290-302 Link Here
290	ManagedOutputStream smos = manager1.getOutputStream(fileName);	288	ManagedOutputStream smos = manager1.getOutputStream(fileName);
291	smos.write(contents1.getBytes());	289	smos.write(contents1.getBytes());
292	smos.close();	290	smos.close();
293		291
294	//start creating version 2	292	//start creating version 2
295	smos = manager1.getOutputStream(fileName);	293	smos = manager1.getOutputStream(fileName);
296	smos.write(contents2.getBytes());	294	smos.write(contents2.getBytes());
297	smos.abort();	295	smos.abort();
298	smos.close(); // shouldn't cause exception, check!	296	smos.close(); // shouldn't cause exception, check!
299		297
300	// now see if we're still on version #1	298	// now see if we're still on version #1
301	assertEquals(1, manager1.getId(fileName));	299	assertEquals(1, manager1.getId(fileName));
302	// check contents also	300	// check contents also
Lines 304-311 Link Here
304	assertNotNull(is);	302	assertNotNull(is);
305	assertEquals(contents1, getInputStreamContents(is));	303	assertEquals(contents1, getInputStreamContents(is));
306	manager1.close();	304	manager1.close();
307	manager1=null;	305	manager1 = null;
308		306
309	// open a new manager & check the same thing to ensure the database is correct	307	// open a new manager & check the same thing to ensure the database is correct
310	System.setProperty("osgi.useReliableFiles", "true"); // force reliable files	308	System.setProperty("osgi.useReliableFiles", "true"); // force reliable files
311	manager2 = new StorageManager(base, null);	309	manager2 = new StorageManager(base, null);
Lines 318-333 Link Here
318	assertNotNull(is);	316	assertNotNull(is);
319	assertEquals(contents1, getInputStreamContents(is));	317	assertEquals(contents1, getInputStreamContents(is));
320	manager2.close();	318	manager2.close();
321	manager2=null;	319	manager2 = null;
322	assertTrue(file1.exists());	320	assertTrue(file1.exists());
323	assertFalse(file2.exists());	321	assertFalse(file2.exists());
324	assertFalse(file3.exists());	322	assertFalse(file3.exists());
325	} catch(IOException e) {	323	} catch (IOException e) {
326	fail("unexepected exception", e);	324	fail("unexepected exception", e);
327	}	325	}
328	}	326	}
329		327
330
331	/**	328	/**
332	* This tests if getting an output stream-set work properly.	329	* This tests if getting an output stream-set work properly.
333	*	330	*
Lines 336-342 Link Here
336	testGetOutputStreamSet(true);	333	testGetOutputStreamSet(true);
337	testGetOutputStreamSet(false);	334	testGetOutputStreamSet(false);
338	}	335	}
339		336
340	private void testGetOutputStreamSet(boolean reliable) {	337	private void testGetOutputStreamSet(boolean reliable) {
341	File mgrDir;	338	File mgrDir;
342	if (reliable)	339	if (reliable)
Lines 345-354 Link Here
345	mgrDir = new File(base, "getSetStd");	342	mgrDir = new File(base, "getSetStd");
346	String fileName1 = "testSet1.txt";	343	String fileName1 = "testSet1.txt";
347	String fileName2 = "testSet2.txt";	344	String fileName2 = "testSet2.txt";
348	File file1_1 = new File(mgrDir, fileName1+".1");	345	File file1_1 = new File(mgrDir, fileName1 + ".1");
349	File file1_2 = new File(mgrDir, fileName1+".2");	346	File file1_2 = new File(mgrDir, fileName1 + ".2");
350	File file2_1 = new File(mgrDir, fileName2+".1");	347	File file2_1 = new File(mgrDir, fileName2 + ".1");
351	File file2_2 = new File(mgrDir, fileName2+".2");	348	File file2_2 = new File(mgrDir, fileName2 + ".2");
352	String contents1 = "test reliable file contents #1";	349	String contents1 = "test reliable file contents #1";
353	String contents2 = "test reliable file contents #2";	350	String contents2 = "test reliable file contents #2";
354	try {	351	try {
Lines 358-364 Link Here
358	ManagedOutputStream[] outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2});	355	ManagedOutputStream[] outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2});
359	assertNotNull(outs);	356	assertNotNull(outs);
360	assertEquals(2, outs.length);	357	assertEquals(2, outs.length);
361		358
362	outs[0].write(contents1.getBytes());	359	outs[0].write(contents1.getBytes());
363	outs[1].write(contents2.getBytes());	360	outs[1].write(contents2.getBytes());
364	outs[1].close();	361	outs[1].close();
Lines 367-376 Link Here
367	outs[0].close();	364	outs[0].close();
368	assertTrue(file1_1.exists());	365	assertTrue(file1_1.exists());
369	assertTrue(file2_1.exists());	366	assertTrue(file2_1.exists());
370		367
371	outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2});	368	outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2});
372	assertNotNull(outs);	369	assertNotNull(outs);
373		370
374	outs[0].write("new data #1".getBytes());	371	outs[0].write("new data #1".getBytes());
375	outs[1].write("new data #2".getBytes());	372	outs[1].write("new data #2".getBytes());
376	outs[0].close();	373	outs[0].close();
Lines 381-387 Link Here
381	assertTrue(file2_2.exists());	378	assertTrue(file2_2.exists());
382	manager1.close();	379	manager1.close();
383	manager1 = null;	380	manager1 = null;
384		381
385	if (reliable) {	382	if (reliable) {
386	// verify FM thinks they are reliable	383	// verify FM thinks they are reliable
387	assertTrue(file1_1.exists());	384	assertTrue(file1_1.exists());
Lines 389-402 Link Here
389	} else {	386	} else {
390	// verify FM thinks they are not reliable	387	// verify FM thinks they are not reliable
391	assertFalse(file1_1.exists());	388	assertFalse(file1_1.exists());
392	assertFalse(file2_1.exists());	389	assertFalse(file2_1.exists());
393	}	390	}
394		391
395	} catch(IOException e) {	392	} catch (IOException e) {
396	fail("unexepected exception", e);	393	fail("unexepected exception", e);
397	}	394	}
398	}	395	}
399		396
400	/**	397	/**
401	* This tests if aborting a managed stream-set works as expected	398	* This tests if aborting a managed stream-set works as expected
402	*	399	*
Lines 405-411 Link Here
405	testAbortSet(true);	402	testAbortSet(true);
406	testAbortSet(false);	403	testAbortSet(false);
407	}	404	}
408		405
409	private void testAbortSet(boolean reliable) {	406	private void testAbortSet(boolean reliable) {
410	File mgrDir;	407	File mgrDir;
411	if (reliable)	408	if (reliable)
Lines 427-433 Link Here
427	manager1.open(true);	424	manager1.open(true);
428	ManagedOutputStream[] outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2, fileName3, fileName4});	425	ManagedOutputStream[] outs = manager1.getOutputStreamSet(new String[] {fileName1, fileName2, fileName3, fileName4});
429	assertNotNull(outs);	426	assertNotNull(outs);
430		427
431	outs[0].write(contents1.getBytes());	428	outs[0].write(contents1.getBytes());
432	outs[1].write(contents2.getBytes());	429	outs[1].write(contents2.getBytes());
433	outs[2].write(contents2.getBytes());	430	outs[2].write(contents2.getBytes());
Lines 449-455 Link Here
449	assertNull(manager1.lookup(fileName4, false));	446	assertNull(manager1.lookup(fileName4, false));
450	manager1.close();	447	manager1.close();
451	manager1 = null;	448	manager1 = null;
452		449
453	// open a new manager & check the same thing to ensure the database is correct	450	// open a new manager & check the same thing to ensure the database is correct
454	System.setProperty("osgi.useReliableFiles", reliable ? "true" : "false"); // force reliable files	451	System.setProperty("osgi.useReliableFiles", reliable ? "true" : "false"); // force reliable files
455	manager2 = new StorageManager(mgrDir, null);	452	manager2 = new StorageManager(mgrDir, null);
Lines 463-472 Link Here
463	assertEquals(1, list.length);	460	assertEquals(1, list.length);
464	manager2.close();	461	manager2.close();
465	manager2 = null;	462	manager2 = null;
466		463
467	} catch(IOException e) {	464	} catch (IOException e) {
468	fail("unexepected exception", e);	465	fail("unexepected exception", e);
469	}	466	}
470	}	467	}
471		468
472	}	469	}