plugins/org.eclipse.objectteams.otequinox/src/org/eclipse/objectteams/internal/osgi/weaving/TeamLoader.java - objectteams/org.eclipse.objectteams - Git at Google

 /**********************************************************************
  * This file is part of "Object Teams Development Tooling"-Software
  *
  * Copyright 2013, 2015 GK Software AG
  *
  * 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
  *
  * Please visit http://www.objectteams.org for updates and contact.
  *
  * Contributors:
  * 	Stephan Herrmann - Initial API and implementation
  **********************************************************************/
 package org.eclipse.objectteams.internal.osgi.weaving;

 import static org.eclipse.objectteams.otequinox.TransformerPlugin.log;

 import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;

 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jdt.annotation.NonNull;
 import org.eclipse.jdt.annotation.NonNullByDefault;
 import org.eclipse.jdt.annotation.Nullable;
 import org.eclipse.objectteams.internal.osgi.weaving.AspectBinding.BaseBundle;
 import org.eclipse.objectteams.internal.osgi.weaving.AspectBinding.TeamBinding;
 import org.eclipse.objectteams.internal.osgi.weaving.Util.ProfileKind;
 import org.eclipse.objectteams.otequinox.ActivationKind;
 import org.eclipse.objectteams.otredyn.runtime.TeamManager;
 import org.eclipse.objectteams.otredyn.transformer.jplis.ObjectTeamsTransformer;
 import org.objectteams.Team;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.hooks.weaving.WovenClass;

 /**
  * This class triggers the actual loading/instantiation/activation of teams.
  * <p>
  * It implements a strategy of deferring those teams that are not ready for
  * instantiating / activating, which we check by comparing the sets of
  * bound base classes of the team vs. the set of classes currently being
  * processed by class loading & weaving.
  * This reflects that fact that classes for which loading has already been
  * started would otherwise trigger an irrecoverable NoClassDefFoundError.
  * </p><p>
  * Which teams participate in deferred instantiation is communicated via the
  * shared list {@link #deferredTeams}.
  * </p>
  */
 @NonNullByDefault
 public class TeamLoader {

 	/** Collect here any teams that cannot yet be handled and should be scheduled later. */
 	private List<WaitingTeamRecord> deferredTeams;

 	private Set<String> beingDefined;

 	boolean useDynamicWeaving;

 	public TeamLoader(List<WaitingTeamRecord> deferredTeams, Set<String> beingDefined, boolean useDynamicWeaving) {
 		this.deferredTeams = deferredTeams;
 		this.beingDefined = beingDefined;
 		this.useDynamicWeaving = useDynamicWeaving;
 	}

 	/**
 	 * Team loading, 1st attempt before the base class is even loaded
 	 * Trying to do these phases: load (now) instantiate/activate (if ready),
 	 */
 	public void loadTeamsForBase(BaseBundle baseBundle, WovenClass baseClass, AspectPermissionManager permissionManager) {
 		@NonNull String className = baseClass.getClassName();
 		Collection<TeamBinding> teamsForBase = baseBundle.teamsPerBase.get(className);
 		if (teamsForBase == null)
 			return; // not done

 		// permission checking can be performed now or later, depending on readiness:
 		boolean permissionManagerReady = permissionManager.isReady();

 		// ==== check permissions before we start activating:
 		if (permissionManagerReady) { // otherwise we will register pending obligations below.
 			Set<TeamBinding> deniedTeams = permissionManager.checkAspectPermissionDenial(teamsForBase);
 			if (!deniedTeams.isEmpty()){
 				for (WaitingTeamRecord rec : new ArrayList<>(this.deferredTeams))
 					if (deniedTeams.contains(rec.team))
 						this.deferredTeams.remove(rec);
 			}
 		}

 		List<Team> teamInstances = new ArrayList<>();
 		for (TeamBinding teamForBase : teamsForBase) {
 			if (teamForBase.isActivated) continue;
 			if (teamForBase.hasBeenDenied()) {
 				log(IStatus.WARNING, "Not activating team "+teamForBase.teamName+" due to denied permissions.");
 				continue;
 			}
 			// Load:
 			Class<? extends Team> teamClass;
 			teamClass = teamForBase.loadTeamClass();
 			if (teamClass == null) {
 				log(new ClassNotFoundException("Not found: "+teamForBase), "Failed to load team "+teamForBase);
 				continue;
 			}
 			// Try to instantiate & activate, failures are recorded in deferredTeams
 			ActivationKind activationKind = teamForBase.getActivation();
 			if (activationKind == ActivationKind.NONE) {
 				teamForBase = teamForBase.getOtherTeamToActivate();
 				if (teamForBase != null) {
 					if (teamForBase.isActivated) continue;
 					activationKind = teamForBase.getActivation();
 					teamClass = teamForBase.loadTeamClass();
 					if (teamClass == null) {
 						log(new ClassNotFoundException("Not found: "+teamForBase.teamName+" in bundle "+teamForBase.getAspectBinding().aspectPlugin), "Failed to load team "+teamForBase);
 						continue;
 					}
 				} else {
 					continue;
 				}
 			}
 			if (activationKind == ActivationKind.NONE)
 				continue;
 			Team instance = instantiateAndActivate(teamForBase.getAspectBinding(), teamForBase, activationKind);
 			if (instance != null)
 				teamInstances.add(instance);
 		}

 		if (!permissionManagerReady)
 			permissionManager.addBaseBundleObligations(teamInstances, teamsForBase, baseBundle);
 	}

 	public static @Nullable Pair<URL,String> findTeamClassResource(String className, Bundle bundle) {
 		for (String candidate : possibleTeamNames(className)) {
 			URL result = bundle.getResource(candidate.replace('.', '/')+".class");
 			if (result != null)
 				return new Pair<>(result, candidate);
 		}
 		return null;
 	}

 	/**
 	 * Starting from currentName compute a list of potential binary names of (nested) teams
 	 * using "$__OT__" as the separator, to find class parts of nested teams.
 	 */
 	public static List<String> possibleTeamNames(String currentName) {
 		List<String> result = new ArrayList<String>();
 		result.add(currentName);
 		char sep = '.'; // assume source name
 		if (currentName.indexOf('$') > -1)
 			// binary name
 			sep = '$';
 		int from = currentName.length()-1;
 		while (true) {
 			int pos = currentName.lastIndexOf(sep, from);
 			if (pos == -1)
 				break;
 			String prefix = currentName.substring(0, pos);
 			String postfix = currentName.substring(pos+1);
 			if (sep=='$') {
 				if (!postfix.startsWith("__OT__"))
 					result.add(0, currentName = prefix+"$__OT__"+postfix);
 			} else {
 				// heuristic:
 				// only replace if parent element looks like a class (expected to start with uppercase)
 				int prevDot = prefix.lastIndexOf('.');
 				if (prevDot > -1 && Character.isUpperCase(prefix.charAt(prevDot+1)))
 					result.add(0, currentName = prefix+"$__OT__"+postfix);
 				else
 					break;
 			}
 			from = pos-1;
 		}
 		return result;
 	}

 	/**
 	 * Check if the given team is ready. If so instantiate it and if activationKind requires also activate it.
 	 */
 	@Nullable Team instantiateAndActivate(AspectBinding aspectBinding, TeamBinding team, ActivationKind activationKind)
 	{
 		for (TeamBinding equivalent : team.equivalenceSet)
 			if (equivalent.instance != null && equivalent.isActivated) return equivalent.instance;

 		String teamName = team.teamName;
 		// don't try to instantiate before all base classes successfully loaded.
 		synchronized(aspectBinding) {
 			if (!isReadyToLoad(aspectBinding, team, teamName, activationKind)) {
 				if (this.useDynamicWeaving)
 					TeamManager.prepareTeamActivation(team.teamClass);
 				return null;
 			}
 			for (TeamBinding equivalent : team.equivalenceSet)
 				equivalent.isActivated = true;
 		}

 		try {
 			long time = 0;
 			if (Util.PROFILE) time= System.nanoTime();

 			Team instance = team.getInstance();

 			try {
 				switch (activationKind) {
 				case ALL_THREADS:
 					instance.activate(Team.ALL_THREADS);
 					log(IStatus.INFO, "Activated team "+teamName);
 					break;
 				case THREAD:
 					instance.activate();
 					log(IStatus.INFO, "Activated team "+teamName);
 					break;
 				//$CASES-OMITTED$
 				default:
 					break;
 				}
 				if (Util.PROFILE) Util.profile(time, ProfileKind.Activation, teamName);
 			} catch (NoClassDefFoundError|ClassCircularityError e) {
 				try { // clean up:
 					switch (activationKind) {
 					case ALL_THREADS: instance.deactivate(Team.ALL_THREADS); break;
 					case THREAD: instance.deactivate(); break;
 					default: break;
 					}
 				} catch (Throwable t) { /* ignore */ }
 				for (TeamBinding eq : team.equivalenceSet)
 					eq.isActivated = false;
 				String notFoundName = e.getMessage().replace('/', '.');
 				synchronized (this.deferredTeams) {
 					this.deferredTeams.add(new WaitingTeamRecord(team, activationKind, notFoundName));
 				}
 			} catch (Throwable t) {
 				// application errors during activation
 				log(t, "Failed to activate team "+teamName);
 			}
 			return instance;
 		} catch (ClassCircularityError e) {
 			for (TeamBinding eq : team.equivalenceSet)
 				eq.isActivated = false;
 			String notFoundName = e.getMessage().replace('/', '.');
 			synchronized (this.deferredTeams) {
 				this.deferredTeams.add(new WaitingTeamRecord(team, activationKind, notFoundName));
 			}
 		} catch (Throwable e) {
 			// application error during constructor execution?
 			log(e, "Failed to instantiate team "+teamName);
 		}
 		return null;
 	}

 	private boolean isReadyToLoad(AspectBinding aspectBinding,
 									TeamBinding team, String teamName,
 									ActivationKind activationKind)
 	{
 		String unloadableBaseClass = findUnloadableBaseClass(team);
 		if (unloadableBaseClass != null) {
 			synchronized (deferredTeams) {
 				WaitingTeamRecord record = new WaitingTeamRecord(team, activationKind, unloadableBaseClass);
 				deferredTeams.add(record);
 			}
 			log(IStatus.INFO, "Defer instantation/activation of team "+teamName+", waiting for "+unloadableBaseClass);
 			return false;
 		}
 		return true;
 	}

 	private @Nullable String findUnloadableBaseClass(TeamBinding team) {
 		// easy tests first:
 		for (String baseclass : team.baseClassNames) {
 			if (this.beingDefined.contains(baseclass))
 				return baseclass;
 		}
 		// definite, more expensive tests:
 		Class<?> teamClass = team.teamClass;
 		if (teamClass != null) {
 			// use a throw-away class loader so we have a fresh chance to load any failed classes later
 			// (only initiating class loader remembers the failure, if this is discarded, the slate is clean):
 			ClassLoader tryLoader = new ClassLoader(teamClass.getClassLoader()) {};
 			for (String baseclass : team.baseClassNames) {
 				Boolean previous = ObjectTeamsTransformer.initiatedByThrowAwayLoader.get();
 				try {
 					ObjectTeamsTransformer.initiatedByThrowAwayLoader.set(Boolean.TRUE);
 					tryLoader.loadClass(baseclass);
 				} catch (Throwable t) {
 					return baseclass;
 				} finally {
 					ObjectTeamsTransformer.initiatedByThrowAwayLoader.set(previous);
 				}
 			}
 		}
 		return null;
 	}
 }
	/**********************************************************************
	* This file is part of "Object Teams Development Tooling"-Software
	*
	* Copyright 2013, 2015 GK Software AG
	*
	* 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
	*
	* Please visit http://www.objectteams.org for updates and contact.
	*
	* Contributors:
	* Stephan Herrmann - Initial API and implementation
	**********************************************************************/
	package org.eclipse.objectteams.internal.osgi.weaving;

	import static org.eclipse.objectteams.otequinox.TransformerPlugin.log;

	import java.net.URL;
	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.List;
	import java.util.Set;

	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.jdt.annotation.NonNull;
	import org.eclipse.jdt.annotation.NonNullByDefault;
	import org.eclipse.jdt.annotation.Nullable;
	import org.eclipse.objectteams.internal.osgi.weaving.AspectBinding.BaseBundle;
	import org.eclipse.objectteams.internal.osgi.weaving.AspectBinding.TeamBinding;
	import org.eclipse.objectteams.internal.osgi.weaving.Util.ProfileKind;
	import org.eclipse.objectteams.otequinox.ActivationKind;
	import org.eclipse.objectteams.otredyn.runtime.TeamManager;
	import org.eclipse.objectteams.otredyn.transformer.jplis.ObjectTeamsTransformer;
	import org.objectteams.Team;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.hooks.weaving.WovenClass;

	/**
	* This class triggers the actual loading/instantiation/activation of teams.
	* <p>
	* It implements a strategy of deferring those teams that are not ready for
	* instantiating / activating, which we check by comparing the sets of
	* bound base classes of the team vs. the set of classes currently being
	* processed by class loading & weaving.
	* This reflects that fact that classes for which loading has already been
	* started would otherwise trigger an irrecoverable NoClassDefFoundError.
	* </p><p>
	* Which teams participate in deferred instantiation is communicated via the
	* shared list {@link #deferredTeams}.
	* </p>
	*/
	@NonNullByDefault
	public class TeamLoader {

	/** Collect here any teams that cannot yet be handled and should be scheduled later. */
	private List<WaitingTeamRecord> deferredTeams;

	private Set<String> beingDefined;

	boolean useDynamicWeaving;

	public TeamLoader(List<WaitingTeamRecord> deferredTeams, Set<String> beingDefined, boolean useDynamicWeaving) {
	this.deferredTeams = deferredTeams;
	this.beingDefined = beingDefined;
	this.useDynamicWeaving = useDynamicWeaving;
	}

	/**
	* Team loading, 1st attempt before the base class is even loaded
	* Trying to do these phases: load (now) instantiate/activate (if ready),
	*/
	public void loadTeamsForBase(BaseBundle baseBundle, WovenClass baseClass, AspectPermissionManager permissionManager) {
	@NonNull String className = baseClass.getClassName();
	Collection<TeamBinding> teamsForBase = baseBundle.teamsPerBase.get(className);
	if (teamsForBase == null)
	return; // not done

	// permission checking can be performed now or later, depending on readiness:
	boolean permissionManagerReady = permissionManager.isReady();

	// ==== check permissions before we start activating:
	if (permissionManagerReady) { // otherwise we will register pending obligations below.
	Set<TeamBinding> deniedTeams = permissionManager.checkAspectPermissionDenial(teamsForBase);
	if (!deniedTeams.isEmpty()){
	for (WaitingTeamRecord rec : new ArrayList<>(this.deferredTeams))
	if (deniedTeams.contains(rec.team))
	this.deferredTeams.remove(rec);
	}
	}

	List<Team> teamInstances = new ArrayList<>();
	for (TeamBinding teamForBase : teamsForBase) {
	if (teamForBase.isActivated) continue;
	if (teamForBase.hasBeenDenied()) {
	log(IStatus.WARNING, "Not activating team "+teamForBase.teamName+" due to denied permissions.");
	continue;
	}
	// Load:
	Class<? extends Team> teamClass;
	teamClass = teamForBase.loadTeamClass();
	if (teamClass == null) {
	log(new ClassNotFoundException("Not found: "+teamForBase), "Failed to load team "+teamForBase);
	continue;
	}
	// Try to instantiate & activate, failures are recorded in deferredTeams
	ActivationKind activationKind = teamForBase.getActivation();
	if (activationKind == ActivationKind.NONE) {
	teamForBase = teamForBase.getOtherTeamToActivate();
	if (teamForBase != null) {
	if (teamForBase.isActivated) continue;
	activationKind = teamForBase.getActivation();
	teamClass = teamForBase.loadTeamClass();
	if (teamClass == null) {
	log(new ClassNotFoundException("Not found: "+teamForBase.teamName+" in bundle "+teamForBase.getAspectBinding().aspectPlugin), "Failed to load team "+teamForBase);
	continue;
	}
	} else {
	continue;
	}
	}
	if (activationKind == ActivationKind.NONE)
	continue;
	Team instance = instantiateAndActivate(teamForBase.getAspectBinding(), teamForBase, activationKind);
	if (instance != null)
	teamInstances.add(instance);
	}

	if (!permissionManagerReady)
	permissionManager.addBaseBundleObligations(teamInstances, teamsForBase, baseBundle);
	}

	public static @Nullable Pair<URL,String> findTeamClassResource(String className, Bundle bundle) {
	for (String candidate : possibleTeamNames(className)) {
	URL result = bundle.getResource(candidate.replace('.', '/')+".class");
	if (result != null)
	return new Pair<>(result, candidate);
	}
	return null;
	}

	/**
	* Starting from currentName compute a list of potential binary names of (nested) teams
	* using "$__OT__" as the separator, to find class parts of nested teams.
	*/
	public static List<String> possibleTeamNames(String currentName) {
	List<String> result = new ArrayList<String>();
	result.add(currentName);
	char sep = '.'; // assume source name
	if (currentName.indexOf('$') > -1)
	// binary name
	sep = '$';
	int from = currentName.length()-1;
	while (true) {
	int pos = currentName.lastIndexOf(sep, from);
	if (pos == -1)
	break;
	String prefix = currentName.substring(0, pos);
	String postfix = currentName.substring(pos+1);
	if (sep=='$') {
	if (!postfix.startsWith("__OT__"))
	result.add(0, currentName = prefix+"$__OT__"+postfix);
	} else {
	// heuristic:
	// only replace if parent element looks like a class (expected to start with uppercase)
	int prevDot = prefix.lastIndexOf('.');
	if (prevDot > -1 && Character.isUpperCase(prefix.charAt(prevDot+1)))
	result.add(0, currentName = prefix+"$__OT__"+postfix);
	else
	break;
	}
	from = pos-1;
	}
	return result;
	}

	/**
	* Check if the given team is ready. If so instantiate it and if activationKind requires also activate it.
	*/
	@Nullable Team instantiateAndActivate(AspectBinding aspectBinding, TeamBinding team, ActivationKind activationKind)
	{
	for (TeamBinding equivalent : team.equivalenceSet)
	if (equivalent.instance != null && equivalent.isActivated) return equivalent.instance;

	String teamName = team.teamName;
	// don't try to instantiate before all base classes successfully loaded.
	synchronized(aspectBinding) {
	if (!isReadyToLoad(aspectBinding, team, teamName, activationKind)) {
	if (this.useDynamicWeaving)
	TeamManager.prepareTeamActivation(team.teamClass);
	return null;
	}
	for (TeamBinding equivalent : team.equivalenceSet)
	equivalent.isActivated = true;
	}

	try {
	long time = 0;
	if (Util.PROFILE) time= System.nanoTime();

	Team instance = team.getInstance();

	try {
	switch (activationKind) {
	case ALL_THREADS:
	instance.activate(Team.ALL_THREADS);
	log(IStatus.INFO, "Activated team "+teamName);
	break;
	case THREAD:
	instance.activate();
	log(IStatus.INFO, "Activated team "+teamName);
	break;
	//$CASES-OMITTED$
	default:
	break;
	}
	if (Util.PROFILE) Util.profile(time, ProfileKind.Activation, teamName);
	} catch (NoClassDefFoundError\|ClassCircularityError e) {
	try { // clean up:
	switch (activationKind) {
	case ALL_THREADS: instance.deactivate(Team.ALL_THREADS); break;
	case THREAD: instance.deactivate(); break;
	default: break;
	}
	} catch (Throwable t) { /* ignore */ }
	for (TeamBinding eq : team.equivalenceSet)
	eq.isActivated = false;
	String notFoundName = e.getMessage().replace('/', '.');
	synchronized (this.deferredTeams) {
	this.deferredTeams.add(new WaitingTeamRecord(team, activationKind, notFoundName));
	}
	} catch (Throwable t) {
	// application errors during activation
	log(t, "Failed to activate team "+teamName);
	}
	return instance;
	} catch (ClassCircularityError e) {
	for (TeamBinding eq : team.equivalenceSet)
	eq.isActivated = false;
	String notFoundName = e.getMessage().replace('/', '.');
	synchronized (this.deferredTeams) {
	this.deferredTeams.add(new WaitingTeamRecord(team, activationKind, notFoundName));
	}
	} catch (Throwable e) {
	// application error during constructor execution?
	log(e, "Failed to instantiate team "+teamName);
	}
	return null;
	}

	private boolean isReadyToLoad(AspectBinding aspectBinding,
	TeamBinding team, String teamName,
	ActivationKind activationKind)
	{
	String unloadableBaseClass = findUnloadableBaseClass(team);
	if (unloadableBaseClass != null) {
	synchronized (deferredTeams) {
	WaitingTeamRecord record = new WaitingTeamRecord(team, activationKind, unloadableBaseClass);
	deferredTeams.add(record);
	}
	log(IStatus.INFO, "Defer instantation/activation of team "+teamName+", waiting for "+unloadableBaseClass);
	return false;
	}
	return true;
	}

	private @Nullable String findUnloadableBaseClass(TeamBinding team) {
	// easy tests first:
	for (String baseclass : team.baseClassNames) {
	if (this.beingDefined.contains(baseclass))
	return baseclass;
	}
	// definite, more expensive tests:
	Class<?> teamClass = team.teamClass;
	if (teamClass != null) {
	// use a throw-away class loader so we have a fresh chance to load any failed classes later
	// (only initiating class loader remembers the failure, if this is discarded, the slate is clean):
	ClassLoader tryLoader = new ClassLoader(teamClass.getClassLoader()) {};
	for (String baseclass : team.baseClassNames) {
	Boolean previous = ObjectTeamsTransformer.initiatedByThrowAwayLoader.get();
	try {
	ObjectTeamsTransformer.initiatedByThrowAwayLoader.set(Boolean.TRUE);
	tryLoader.loadClass(baseclass);
	} catch (Throwable t) {
	return baseclass;
	} finally {
	ObjectTeamsTransformer.initiatedByThrowAwayLoader.set(previous);
	}
	}
	}
	return null;
	}
	}