Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2005, 2009 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 http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation /
 
 
 package org.eclipse.core.runtime.internal.adaptor;
 
 import java.io.*;
 import java.net.URL;
 
 public final class EclipseStorageHook implements StorageHookHookConfigurator {
 	// System property used to check timestamps of the bundles in the configuration
 	private static final String PROP_CHECK_CONFIG = "osgi.checkConfiguration"//$NON-NLS-1$
 	private static final String PROP_COMPATIBILITY_LAZYSTART = "osgi.compatibility.eagerStart.LazyActivation"//$NON-NLS-1$
 	private static final boolean COMPATIBILITY_LAZYSTART = Boolean.valueOf(FrameworkProperties.getProperty("true")).booleanValue(); //$NON-NLS-1$
 	private static final int STORAGE_VERION = 4;
 
 	public static final String KEY = EclipseStorageHook.class.getName();
 	public static final int HASHCODE = .hashCode();
 
 	private static final byte FLAG_LAZY_START = 0x01;
 	private static final byte FLAG_HAS_PACKAGE_INFO = 0x02;
 	// Note that the 0x04 was used in previous versions, if a new flag is needed then do not reuse this one
 	//private static final byte FLAG_ACTIVATE_ON_CLASSLOAD = 0x04;
 	// Flag to indicate that an include directive is present on the lazy activation policy
 	private static final byte FLAG_HAS_LAZY_INCLUDE = 0x08;

data to detect modification made in the manifest
 
 	private long manifestTimeStamp = 0;
 
 	private BaseData bundledata;

the Plugin-Class header
 
 	private String pluginClass = null;
Eclipse-LazyStart header
 
 	private String[] lazyStartExcludes;
 	private String[] lazyStartIncludes;
 	private int bundleManfestVersion;
shortcut to know if a bundle has a buddy
 
 	private String buddyList;
shortcut to know if a bundle is a registrant to a registered policy
 
DS Service Component header
 
 	private byte flags = 0;
 
 	public int getStorageVersion() {
 		return ;
 	}
 
 	public StorageHook create(BaseData bundledatathrows BundleException {
 		EclipseStorageHook storageHook = new EclipseStorageHook();
 		storageHook.bundledata = bundledata;
 		return storageHook;
 	}
 
 	public void initialize(Dictionary manifestthrows BundleException {
 		String activationPolicy = (Stringmanifest.get(.);
 		if (activationPolicy != null) {
 			parseActivationPolicy(thisactivationPolicy);
 		} else {
 			String lazyStart = (Stringmanifest.get(.);
 			if (lazyStart == null)
 				lazyStart = (Stringmanifest.get(.);
 			parseLazyStart(thislazyStart);
 		}
 		try {
 			String versionString = (Stringmanifest.get(.);
 			 = versionString == null ? 0 : Integer.parseInt(versionString);
 		} catch (NumberFormatException nfe) {
 		}
		if (genFrom != null) {
			ManifestElement generatedFrom = ManifestElement.parseHeader(.genFrom)[0];
			if (generatedFrom != null) {
				 = Long.parseLong(generatedFrom.getValue());
			}
		}
		if (isAutoStartable()) {
		}
	}
	public StorageHook load(BaseData targetDataInputStream inthrows IOException {
		EclipseStorageHook storageHook = new EclipseStorageHook();
		storageHook.bundledata = target;
		storageHook.flags = in.readByte();
		int pkgCount = in.readInt();
		String[] packageList = pkgCount > 0 ? new String[pkgCount] : null;
		for (int i = 0; i < pkgCounti++)
			packageList[i] = in.readUTF();
		storageHook.lazyStartExcludes = packageList;
		if ((storageHook.flags & ) != 0) {
			pkgCount = in.readInt();
			packageList = pkgCount > 0 ? new String[pkgCount] : null;
			for (int i = 0; i < pkgCounti++)
				packageList[i] = in.readUTF();
			storageHook.lazyStartIncludes = packageList;
		}
		storageHook.buddyList = AdaptorUtil.readString(infalse);
		storageHook.registeredBuddyList = AdaptorUtil.readString(infalse);
		storageHook.pluginClass = AdaptorUtil.readString(infalse);
		storageHook.manifestTimeStamp = in.readLong();
		storageHook.manifestType = in.readByte();
		storageHook.bundleManfestVersion = in.readInt();
		if (storageHook.isAutoStartable()) {
			if ((target.getStatus() & .) == 0)
			// if the compatibility flag is set then we must make sure the persistent start bit is set and the activation policy bit;
			// if the persistent start bit was already set then we should not set the activation policy bit because this is an "eager" started bundle.
		}
		storageHook.serviceComponent = AdaptorUtil.readString(infalse);
		return storageHook;
	}
	public void save(DataOutputStream outthrows IOException {
		if ( == null)
			throw new IllegalStateException();
		// when this is stored back we always use the has include/exclude flag
		String[] excludes = getLazyStartExcludes();
		if (excludes == null)
			out.writeInt(0);
		else {
			out.writeInt(excludes.length);
			for (int i = 0; i < excludes.lengthi++)
				out.writeUTF(excludes[i]);
		}
		if (( & ) != 0) {
			String[] includes = getLazyStartIncludes();
			if (includes == null)
				out.writeInt(0);
			else {
				out.writeInt(includes.length);
				for (int i = 0; i < includes.lengthi++)
					out.writeUTF(includes[i]);
			}
		}
		AdaptorUtil.writeStringOrNull(outgetBuddyList());
		AdaptorUtil.writeStringOrNull(outgetPluginClass());
	}
	public int getKeyHashCode() {
		return ;
	}
	public boolean compare(KeyedElement other) {
		return other.getKey() == ;
	}
	public Object getKey() {
		return ;
	}
	public boolean isLazyStart() {
	}
	}
	}
	public String getBuddyList() {
		return ;
	}
	public boolean hasPackageInfo() {
	}
	public String getPluginClass() {
		return ;
	}
	}
	public long getManifestTimeStamp() {
	}
	public byte getManifestType() {
		return ;
	}
	public int getBundleManifestVersion() {
	}
	}

Checks whether this bundle is auto started for all resource/class loads or only for a subset of resource/classloads

Returns:
true if the bundle is auto started; false otherwise
	public boolean isAutoStartable() {
		return isLazyStart() || ( != null && . > 0);
	}
	private void parseLazyStart(EclipseStorageHook storageHookString headerValue) {
		storageHook.lazyStartExcludes = null;
		ManifestElement[] allElements = null;
		try {
			allElements = ManifestElement.parseHeader(.headerValue);
catch (BundleException e) {
			// just use the default settings (no auto activation)
		}
		//Eclipse-AutoStart not found... 
		if (allElements == null)
			return;
		// the single value for this element should be true|false
		if ("true".equalsIgnoreCase(allElements[0].getValue())) //$NON-NLS-1$
			storageHook.flags |= ;
		// look for any exceptions (the attribute) to the autoActivate setting
		String[] exceptions = ManifestElement.getArrayFromList(allElements[0].getAttribute(.));
		storageHook.lazyStartExcludes = exceptions;
	}
	private void parseActivationPolicy(EclipseStorageHook storageHookString headerValue) {
		storageHook.lazyStartExcludes = null;
		ManifestElement[] allElements = null;
		try {
			allElements = ManifestElement.parseHeader(.headerValue);
catch (BundleException e) {
			// just use the default settings (no auto activation)
		}
		//Bundle-ActivationPolicy not found. 
		if (allElements == null)
			return;
		// the single value for this type is lazy
			return;
		storageHook.flags |= ;
		// look for any include or exclude attrs
		storageHook.lazyStartExcludes = ManifestElement.getArrayFromList(allElements[0].getDirective(.));
		storageHook.lazyStartIncludes = ManifestElement.getArrayFromList(allElements[0].getDirective(.));
		if (storageHook.lazyStartIncludes != null)
			storageHook.flags |= ;
	}
	// Used to check the bundle manifest file for any package information.
	// This is used when '.' is on the Bundle-ClassPath to prevent reading
	// the bundle manifest for pacakge information when loading classes.
	private static boolean hasPackageInfo(URL url) {
		if (url == null)
			return false;
		BufferedReader br = null;
		try {
			String line;
			while ((line = br.readLine()) != null) {
				if (line.length() < 20)
					continue;
				switch (line.charAt(0)) {
					case 'S' :
						if (line.charAt(1) == 'p')
							if (line.startsWith("Specification-Title: ") || line.startsWith("Specification-Version: ") || line.startsWith("Specification-Vendor: ")) //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$
								return true;
						break;
					case 'I' :
						if (line.startsWith("Implementation-Title: ") || line.startsWith("Implementation-Version: ") || line.startsWith("Implementation-Vendor: ")) //$NON-NLS-1$ //$NON-NLS-2$//$NON-NLS-3$ 
							return true;
						break;
				}
			}
catch (IOException ioe) {
			// do nothing
finally {
			if (br != null)
				try {
					br.close();
catch (IOException e) {
					// do nothing
				}
		}
		return false;
	}
	public void addHooks(HookRegistry hookRegistry) {
		hookRegistry.addStorageHook(this);
	}
	private void checkTimeStamp() throws IllegalArgumentException {
	}
	private boolean checkManifestTimeStamp() {
		if (!"true".equalsIgnoreCase(FrameworkProperties.getProperty(.))) //$NON-NLS-1$
			return true;
				return true;
			String cacheLocation = FrameworkProperties.getProperty(.);
			Location parentConfiguration = LocationManager.getConfigurationLocation().getParentLocation();
			if (parentConfiguration != null) {
				try {
catch (BundleException e) {
					return false;
				}
			}
			File cacheFile = new File(cacheLocation.getSymbolicName() + '_' + .getVersion() + ".MF"); //$NON-NLS-1$
			if (cacheFile.isFile())
				return true;
		}
		return false;
	}
	private Headers checkManifestAndParent(String cacheLocationString symbolicNameString versionbyte inputTypethrows BundleException {
		Headers result = basicCheckManifest(cacheLocationsymbolicNameversioninputType);
		if (result != null)
			return result;
		Location parentConfiguration = null;
		if ((parentConfiguration = LocationManager.getConfigurationLocation().getParentLocation()) != null)
			result = basicCheckManifest(new File(parentConfiguration.getURL().getFile(), . + '/' + .).toString(), symbolicNameversioninputType);
		return result;
	}
	private Headers basicCheckManifest(String cacheLocationString symbolicNameString versionbyte inputTypethrows BundleException {
		File currentFile = new File(cacheLocationsymbolicName + '_' + version + ".MF"); //$NON-NLS-1$
		if (PluginConverterImpl.upToDate(currentFile.getBundleFile().getBaseFile(), inputType)) {
			try {
				return Headers.parseManifest(new FileInputStream(currentFile));
catch (FileNotFoundException e) {
				// do nothing.
			}
		}
		return null;
	}
	Dictionary createCachedManifest(boolean firstTimethrows BundleException {
		return firstTime ? getGeneratedManifest() : new CachedManifest(this);
	}
		if (System.getSecurityManager() == null)
		try {
			return (Dictionary) AccessController.doPrivileged(new PrivilegedExceptionAction() {
				public Object run() throws BundleException {
				}
			});
catch (PrivilegedActionException e) {
		}
	}
		Dictionary builtIn = AdaptorUtil.loadManifestFrom();
		if (builtIn != null) {
			// the bundle has a built-in manifest - we may not have to generate one
			if (!isComplete(builtIn)) {
				Dictionary generatedManifest = generateManifest(builtIn);
				if (generatedManifest != null)
					return generatedManifest;
			}
			// the manifest is complete or we could not complete it - take it as it is
else
			return builtIn;
		}
		Dictionary result = generateManifest(null);
		if (result == null)
		return result;
	}
	private Dictionary generateManifest(Dictionary builtInthrows BundleException {
		String cacheLocation = FrameworkProperties.getProperty(.);
		if (.getSymbolicName() != null) {
			if (existingHeaders != null)
				return existingHeaders;
		}
		PluginConverterImpl converter = PluginConverterImpl.getDefault();
		if (converter == null)
		Dictionary generatedManifest;
		try {
			generatedManifest = converter.convertManifest(.getBundleFile().getBaseFile(), truenulltruenull);
catch (PluginConversionException pce) {
			throw new BundleException(message.pce);
		}
		//Now we know the symbolicId and the version of the bundle, we check to see if don't have a manifest for it already
		Version version = Version.parseVersion((StringgeneratedManifest.get(.));
		ManifestElement generatedFrom = ManifestElement.parseHeader(., (StringgeneratedManifest.get(.))[0];
		Headers existingHeaders = checkManifestAndParent(cacheLocationsymbolicNameversion.toString(), Byte.parseByte(generatedFrom.getAttribute(.)));
		//We don't have a manifest.
		 = Long.parseLong(generatedFrom.getValue());
		if (.getAdaptor().isReadOnly() || existingHeaders != null)
			return existingHeaders;
		//merge the original manifest with the generated one
		if (builtIn != null) {
			Enumeration keysEnum = builtIn.keys();
			while (keysEnum.hasMoreElements()) {
				Object key = keysEnum.nextElement();
				generatedManifest.put(keybuiltIn.get(key));
			}
		}
		//write the generated manifest
		File bundleManifestLocation = new File(cacheLocationsymbolicName + '_' + version.toString() + ".MF"); //$NON-NLS-1$
		try {
			converter.writeManifest(bundleManifestLocationgeneratedManifesttrue);
catch (Exception e) {
			//TODO Need to log
		}
		return generatedManifest;
	}
	private boolean isComplete(Dictionary manifest) {
		// a manifest is complete if it has a Bundle-SymbolicName entry...
			return true;
		// ...or it does not have a plugin/fragment manifest where to get the other entries from  
	}
	public BaseData getBaseData() {
		return ;
	}
	public void copy(StorageHook storageHook) {
		// copy nothing all must be re-read from a manifest
	}
	public void validate() throws IllegalArgumentException {
	}
		if ( != null)
		return null;
	}
	public Dictionary getManifest(boolean firstLoadthrows BundleException {
		return createCachedManifest(firstLoad);
	}
	public boolean forgetStatusChange(int status) {
		return false;
	}
	public boolean forgetStartLevelChange(int startlevel) {
		return false;
	}
New to GrepCode? Check out our FAQ X