/*******************************************************************************
* Copyright (c) 2004, 2005 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.jem.internal.beaninfo.adapters;
import java.util.logging.Level;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.*;
import org.eclipse.jem.internal.beaninfo.core.BeaninfoPlugin;
import org.eclipse.jem.util.logger.proxy.Logger;
/**
* This class is used by BeaninfoNature to handle the creation of the registry,
* This class will be a singleton. It is needed to handle if UI active without
* requiring UI plugin. (So headless will work too). The subclass <code>UICreateRegistryJobHandler</code>
* will be instantiated in case of UI active.
* @since 1.0.0
*/
class CreateRegistryJobHandler {
private static CreateRegistryJobHandler jobHandler = null;
public static void createRegistry(BeaninfoNature nature) {
synchronized (CreateRegistryJobHandler.class) {
if (jobHandler == null) {
if (Platform.getBundle("org.eclipse.ui") != null) { //$NON-NLS-1$
try {
// There is a UI, it may not be active, but bring in UICreateRegistryJobHandler to do the
// actual work since it can reference the UI.
jobHandler = (CreateRegistryJobHandler) Class.forName("org.eclipse.jem.internal.beaninfo.adapters.UICreateRegistryJobHandler").newInstance(); //$NON-NLS-1$
} catch (InstantiationException e) {
jobHandler = new CreateRegistryJobHandler();
} catch (IllegalAccessException e) {
jobHandler = new CreateRegistryJobHandler();
} catch (ClassNotFoundException e) {
jobHandler = new CreateRegistryJobHandler();
}
}
}
}
// See if Autobuild sleeping or waiting. This could be a race condition for us. We can't wait for it
// because we may already have the build rule locked by our thread. No way of testing this if beginRule was used.
// We can test if we are a build job (not an inline build), and if so, just go on.
// Maybe we can figure out in future if we find race condition happens significant amount of time.
IJobManager jobManager = Job.getJobManager();
Job currentJob = jobManager.currentJob();
if (currentJob == null || (!currentJob.belongsTo(ResourcesPlugin.FAMILY_AUTO_BUILD) && !currentJob.belongsTo(ResourcesPlugin.FAMILY_MANUAL_BUILD))) {
// See if autojob is waiting or sleeping.
// Give it up to a second at .2 second intervals to try (i.e. 5 tries)
int tries = 5;
while (isAutoWaiting() && --tries>0) {
try {
Thread.sleep(200); // Wait just .2 seconds to give build a chance to start. If it is still not started, then just go on.
} catch (InterruptedException e) {
}
}
if (tries==0) {
Logger logger = BeaninfoPlugin.getPlugin().getLogger();
if (logger.isLoggingLevel(Level.WARNING))
logger.log("Build job waiting when trying to start beaninfo registry. Possible race.", Level.WARNING); // $NON-NLS-1$ //$NON-NLS-1$
}
}
jobHandler.processCreateRegistry(nature);
}
private static boolean isAutoWaiting() {
Job[] autojobs = Job.getJobManager().find(ResourcesPlugin.FAMILY_AUTO_BUILD);
for (int i = 0; i < autojobs.length; i++) {
int state = autojobs[i].getState();
if (state == Job.WAITING || state == Job.SLEEPING)
return true;
}
return false;
}
/**
* Process the create of the registry. This should be overridden to
* do what the UI needs. The UI implimentation should call doCreateRegistry at the
* appropriate time.
*
* @param nature
*
* @since 1.0.0
*/
protected void processCreateRegistry(final BeaninfoNature nature) {
IJobManager jobManager = Job.getJobManager();
ISchedulingRule buildRule = ResourcesPlugin.getWorkspace().getRuleFactory().buildRule();
boolean gotRuleLocally = true;
try {
try {
jobManager.beginRule(buildRule, new NullProgressMonitor());
} catch (IllegalArgumentException e) {
gotRuleLocally = false; // This thread already had a rule, and it conflicted with the build rule, so we need to spawn off.
}
if (gotRuleLocally)
doCreateRegistry(nature, new NullProgressMonitor());
} finally {
jobManager.endRule(buildRule); // Whether we got the rule or not, we must do endrule.
}
if (!gotRuleLocally) {
// Spawn off to a job and wait for it. Hopefully we don't have a deadlock somewhere.
Job doCreateJob = new Job(BeanInfoAdapterMessages.UICreateRegistryJobHandler_StartBeaninfoRegistry) {
protected IStatus run(IProgressMonitor monitor) {
doCreateRegistry(nature, monitor);
return Status.OK_STATUS;
}
};
doCreateJob.schedule();
while (true) {
try {
doCreateJob.join();
break;
} catch (InterruptedException e) {
}
}
}
}
/*
* Do the creation. It is expected that the build rule has already been given to this thread.
* It is important that the build rule be given to this thread. This is so that a build won't
* start trying to create the same registry (which has happened in the past) at the same time
* a different thread was trying to start the registry. You would either have a deadlock, or
* a race and get two different registries started.
*
* The build rule also means that all beaninfo registry creations will be serialized and have
* a race condition. The unfortunate part is that two independent project's registries can't be
* created at same time. But that is the result of the build rule. We can't allow the builds, so
* we need to stop all parallel beaninfo registry creations.
*
* @param nature
* @param pm
*
* @since 1.0.0
*/
protected final void doCreateRegistry(BeaninfoNature nature, IProgressMonitor pm) {
pm.beginTask("", 100); //$NON-NLS-1$
try {
nature.createRegistry(new SubProgressMonitor(pm, 100));
} finally {
pm.done();
}
}
}