Attachment #77826 for bug #202416

Lines 16-21 Link Here

(-)src/org/eclipse/rse/internal/persistence/RSEPersistenceManager.java (-3 / +8 lines)
16	* Martin Oberhuber (Wind River) - [177523] Unify singleton getter methods	16	* Martin Oberhuber (Wind River) - [177523] Unify singleton getter methods
17	* Martin Oberhuber (Wind River) - [175680] Deprecate obsolete ISystemRegistry methods	17	* Martin Oberhuber (Wind River) - [175680] Deprecate obsolete ISystemRegistry methods
18	* Martin Oberhuber (Wind River) - [196919] Fix deadlock with workspace operations	18	* Martin Oberhuber (Wind River) - [196919] Fix deadlock with workspace operations
		19	* Martin Oberhuber (Wind River) - [202416] Protect against NPEs when importing DOM
19	********************************************************************************/	20	********************************************************************************/
20		21
21	package org.eclipse.rse.internal.persistence;	22	package org.eclipse.rse.internal.persistence;
Lines 371-377 Link Here
371	for (int i = 0; i < profileNames.length; i++) {	372	for (int i = 0; i < profileNames.length; i++) {
372	String profileName = profileNames[i];	373	String profileName = profileNames[i];
373	ISystemProfile profile = load(persistenceProvider, profileName, timeout);	374	ISystemProfile profile = load(persistenceProvider, profileName, timeout);
374	profiles.add(profile);	375	if (profile!=null) {
		376	profiles.add(profile);
		377	}
375	}	378	}
376	return profiles;	379	return profiles;
377	}	380	}
Lines 391-398 Link Here
391	if (dom != null) {	394	if (dom != null) {
392	SystemProfileManager.getDefault().setRestoring(true);	395	SystemProfileManager.getDefault().setRestoring(true);
393	profile = _importer.restoreProfile(dom);	396	profile = _importer.restoreProfile(dom);
394	profile.setPersistenceProvider(provider);	397	if (profile!=null) {
395	cleanTree(profile);	398	profile.setPersistenceProvider(provider);
		399	cleanTree(profile);
		400	}
396	SystemProfileManager.getDefault().setRestoring(false);	401	SystemProfileManager.getDefault().setRestoring(false);
397	}	402	}
398	} finally {	403	} finally {




 * Martin Oberhuber (Wind River) - [177523] Unify singleton getter methods
 * Martin Oberhuber (Wind River) - [175680] Deprecate obsolete ISystemRegistry methods
 * Kevin Doyle (IBM) - [163883] Multiple filter strings are disabled
 * Martin Oberhuber (Wind River) - [202416] Protect against NPEs when importing DOM
 ********************************************************************************/

package org.eclipse.rse.internal.persistence.dom;

import java.util.Vector;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.rse.core.IRSECoreRegistry;
import org.eclipse.rse.core.IRSESystemType;
import org.eclipse.rse.core.RSECorePlugin;

	 * @return the restored profile
	 */
	public ISystemProfile restoreProfile(RSEDOM dom) {
		ISystemProfile profile = null;
		String profileName = dom.getName();
		if (profileName != null) {
			boolean defaultPrivate = getBooleanValue(dom, IRSEDOMConstants.ATTRIBUTE_DEFAULT_PRIVATE);
			boolean isActive = getBooleanValue(dom, IRSEDOMConstants.ATTRIBUTE_IS_ACTIVE);
			profile = new SystemProfile(profileName, isActive);
			profile.setDefaultPrivate(defaultPrivate);
			SystemProfileManager.getDefault().addSystemProfile(profile);
			// restore the children for the profile
			RSEDOMNode[] children = dom.getChildren();
			for (int i = 0; i < children.length; i++) {
				try {
					RSEDOMNode child = children[i];
					String type = child.getType();
					if (IRSEDOMConstants.TYPE_HOST.equals(type)) {
						restoreHost(profile, child);
					} else if (IRSEDOMConstants.TYPE_FILTER_POOL.equals(type)) {
						restoreFilterPool(profile, child);
					} else if (IRSEDOMConstants.TYPE_PROPERTY_SET.equals(type)) {
						restorePropertySet(profile, child);
					}
				} catch(Exception e) {
					logException(e);
				}
			}
		} else {
			logNullAttribute(dom, "name"); //$NON-NLS-1$
		}
		return profile;
	}


		// get host node attributes
		String connectionName = hostNode.getName();
		// we changed from storing names to storing IDs, so these may be null
		String systemTypeName = getAttributeValueMaybeNull(hostNode, IRSEDOMConstants.ATTRIBUTE_TYPE);
		String systemTypeId = getAttributeValueMaybeNull(hostNode, IRSEDOMConstants.ATTRIBUTE_SYSTEM_TYPE);
		String hostName = getAttributeValue(hostNode, IRSEDOMConstants.ATTRIBUTE_HOSTNAME);
		String description = getAttributeValue(hostNode, IRSEDOMConstants.ATTRIBUTE_DESCRIPTION);
		boolean isOffline = getBooleanValue(hostNode, IRSEDOMConstants.ATTRIBUTE_OFFLINE);
		boolean isPromptable = getBooleanValue(hostNode, IRSEDOMConstants.ATTRIBUTE_PROMPTABLE);

		// create host and set it's attributes
		try {

			} else if (systemTypeName != null) {
				systemType = registry.getSystemType(systemTypeName);
			}
			//cannot create a host from a profile if we do not know the systemType
			if (systemType != null) {
				host = profile.createHost(systemType, connectionName, hostName, description);
				host.setOffline(isOffline);
				host.setPromptable(isPromptable);
			}
		} catch (Exception e) {
			logException(e);
		}

		// restore children of host
		if (host!=null) {
			RSEDOMNode[] children = hostNode.getChildren();
			for (int i = 0; i < children.length; i++) {
				RSEDOMNode child = children[i];
				String type = child.getType();
				if (IRSEDOMConstants.TYPE_CONNECTOR_SERVICE.equals(type)) {
					restoreConnectorService(host, child);
				} else if (IRSEDOMConstants.TYPE_PROPERTY_SET.equals(type)) {
					restorePropertySet(host, child);
				}
			}
		}
		return host;

		//		String name = connectorServiceNode.getName();
		//		String type = connectorServiceNode.getAttribute(IRSEDOMConstants.ATTRIBUTE_TYPE).getValue();
		//		String group = connectorServiceNode.getAttribute(IRSEDOMConstants.ATTRIBUTE_GROUP).getValue();
		boolean useSSL = getBooleanValue(connectorServiceNode, IRSEDOMConstants.ATTRIBUTE_USE_SSL);
		int port = getIntegerValue(connectorServiceNode, IRSEDOMConstants.ATTRIBUTE_PORT);
		int port = 0;
		if (att != null) {
			port = getIntegerValue(att.getValue());
		}

		// first restore subsystems (since right now we need subsystem to get at service
		RSEDOMNode[] ssChildren = connectorServiceNode.getChildren(IRSEDOMConstants.TYPE_SUBSYSTEM);

		// in most cases (if not all) the subsystem already exists
		// since createHost() ends up recreating subsystems for each factory		
		String name = subSystemNode.getName();
		String type = getAttributeValue(subSystemNode, IRSEDOMConstants.ATTRIBUTE_TYPE);
		boolean isHidden = getBooleanValue(subSystemNode, IRSEDOMConstants.ATTRIBUTE_HIDDEN);
		ISubSystem subSystem = null;
		ISubSystemConfiguration factory = getSubSystemConfiguration(type);
		if (factory != null) {

	public ISystemFilter restoreFilter(ISystemFilterPool filterPool, RSEDOMNode node) {
		// get the node attributes for a filter
		String name = node.getName();
		boolean supportsNestedFilters = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_SUPPORTS_NESTED_FILTERS);
		int relativeOrder = getIntegerValue(node, IRSEDOMConstants.ATTRIBUTE_RELATIVE_ORDER);
		boolean isDefault = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_DEFAULT);
		boolean isSetStringsCaseSensitive = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_STRING_CASE_SENSITIVE);
		boolean isPromptable = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_PROMPTABLE);
		boolean isSetSupportsDuplicateFilterStrings = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_SUPPORTS_DUPLICATE_FILTER_STRINGS);
		boolean isNonDeletable = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_NON_DELETABLE);
		boolean isNonRenamable = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_NON_RENAMABLE);
		boolean isNonChangable = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_NON_CHANGEABLE);
		boolean isStringsNonChangable = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_STRINGS_NON_CHANGABLE);
		int release = getIntegerValue(node, IRSEDOMConstants.ATTRIBUTE_RELEASE);
		boolean isSetSingleFilterStringOnly = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_SINGLE_FILTER_STRING_ONLY);

		Vector filterStrings = new Vector();



		// get the node attributes for a filter pool
		String name = node.getName();
		String type = getAttributeValue(node, IRSEDOMConstants.ATTRIBUTE_TYPE);
		String id = getAttributeValue(node, IRSEDOMConstants.ATTRIBUTE_ID);
		boolean supportsNestedFilters = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_SUPPORTS_NESTED_FILTERS);
		boolean isDeletable = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_DELETABLE);
		boolean isDefault = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_DEFAULT);
		boolean isSetStringsCaseSensitive = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_STRING_CASE_SENSITIVE);
		boolean isSetSupportsDuplicateFilterStrings = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_SUPPORTS_DUPLICATE_FILTER_STRINGS);
		int release = getIntegerValue(node, IRSEDOMConstants.ATTRIBUTE_RELEASE);
		
		// Since old profiles won't have an "singleFilterStringOnlyESet" attribute
		// we must give it a default value.

		RSEDOMNodeAttribute attribute = node.getAttribute("singleFilterStringOnlyESet"); //$NON-NLS-1$
		if (attribute != null) {
			isSingleFilterStringOnlyESet = getBooleanValue(attribute.getValue());
			isSetSingleFilterStringOnly = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_SINGLE_FILTER_STRING_ONLY);
		}
		
		String owningParentName = getAttributeValue(node, IRSEDOMConstants.ATTRIBUTE_OWNING_PARENT_NAME);
		boolean isNonRenamable = getBooleanValue(node, IRSEDOMConstants.ATTRIBUTE_NON_RENAMABLE);

		// create the filter pool and set it's attributes
		try {

//				filterPool.wasRestored();
			}
		} catch (Exception e) {
			logException(e);
		}

		// restore children
		if (filterPool != null) {
			RSEDOMNode[] children = node.getChildren();
			for (int i = 0; i < children.length; i++) {
				RSEDOMNode child = children[i];
				String ctype = child.getType();
				if (IRSEDOMConstants.TYPE_FILTER.equals(ctype)) {
					restoreFilter(filterPool, child);
				} else if (IRSEDOMConstants.TYPE_PROPERTY_SET.equals(ctype)) {
					restorePropertySet(filterPool, child);
				}
			} else if (ctype.equals(IRSEDOMConstants.TYPE_PROPERTY_SET)) {
				restorePropertySet(filterPool, child);
			}
		}
		return filterPool;

		RSEDOMNodeAttribute[] attributes = propertySetNode.getAttributes();
		for (int i = 0; i < attributes.length; i++) {
			RSEDOMNodeAttribute attribute = attributes[i];
			if (IRSEDOMConstants.ATTRIBUTE_DESCRIPTION.equals(attribute.getKey())) { // descriptions really are stored as attributes
				set.setDescription(attribute.getValue());
			} else {
				String typeStr = attribute.getType();

		for (int i = 0; i < children.length; i++) {
			RSEDOMNode child = children[i];
			String propertyName = child.getName();
			String propertyValue = getAttributeValue(child, IRSEDOMConstants.ATTRIBUTE_VALUE);
			String propertyTypeName = getAttributeValue(child, IRSEDOMConstants.ATTRIBUTE_TYPE);
			IPropertyType propertyType = PropertyType.fromString(propertyTypeName);
			if (IPropertySet.DESCRIPTION_KEY.equals(propertyName)) { // any descriptions found as properties should be set directly
				set.setDescription(propertyValue);
			} else {
				set.addProperty(propertyName, propertyValue, propertyType);

	private String getAttributeValue(RSEDOMNode node, String attributeName) {
		String result = null;
		RSEDOMNodeAttribute attribute = node.getAttribute(attributeName);
		if (attribute == null) {
			logNullAttribute(node, attributeName);
		} else {
			result = attribute.getValue();
		}
		return result;
	}

	private String getAttributeValueMaybeNull(RSEDOMNode node, String attributeName) {
		String result = null;
		RSEDOMNodeAttribute attribute = node.getAttribute(attributeName);
		if (attribute != null) {
			result = attribute.getValue();
		}
		return result;
	}

	private boolean getBooleanValue(RSEDOMNode node, String attributeName) {
		String booleanStr = getAttributeValue(node, attributeName);
		if (booleanStr==null) logNullAttribute(node, attributeName);
		return getBooleanValue(booleanStr);
	}

	private int getIntegerValue(RSEDOMNode node, String attributeName) {
		String intStr = getAttributeValue(node, attributeName);
		if (intStr==null) logNullAttribute(node, attributeName);
		return getIntegerValue(intStr);
	}
	
	private void logException(Exception e) {
		RSECorePlugin.getDefault().getLog().log(
				new Status(IStatus.ERROR, RSECorePlugin.getDefault().getBundle().getSymbolicName(), -1, e.getMessage(), e));
	}
	
	private void logNullAttribute(RSEDOMNode node, String attributeName) {
		StringBuffer msg = new StringBuffer(80);
		msg.append("RSEDOMImporter: null attr \""); //$NON-NLS-1$
		msg.append(attributeName==null ? "null" : attributeName); //$NON-NLS-1$
		msg.append("\" in "); //$NON-NLS-1$
		int len = msg.length();
		RSEDOMNode parent = node.getParent();
		while (parent!=null) {
			String parentName = parent.getName();
			msg.insert(len, parentName==null ? "null/" : parentName+'/'); //$NON-NLS-1$
			parent = parent.getParent();
		}
		msg.append(node.getName()==null ? "null" : node.getName()); //$NON-NLS-1$
		RSECorePlugin.getDefault().getLog().log(
				new Status(IStatus.WARNING, RSECorePlugin.getDefault().getBundle().getSymbolicName(), -1, msg.toString(), null));
	}

}

Return to bug 202416