plugins/org.eclipse.wst.server.core/servercore/org/eclipse/wst/server/core/internal/Publisher.java

/*******************************************************************************
 * Copyright (c) 2008, 2010 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.wst.server.core.internal;

import java.util.Iterator;
import java.util.List;

import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.wst.server.core.IModule;
import org.eclipse.wst.server.core.IServerWorkingCopy;
import org.eclipse.wst.server.core.TaskModel;
import org.eclipse.wst.server.core.model.PublisherDelegate;
/**
 * 
 */
public class Publisher {
	private IConfigurationElement element;
	private PublisherDelegate delegate;
	private boolean modifyModules = false;

	/**
	 * Publisher constructor comment.
	 * 
	 * @param element a configuration element 
	 */
	public Publisher(IConfigurationElement element) {
		super();
		this.element = element;
	}

	/*
	 * @see
	 */
	public String getId() {
		return element.getAttribute("id");
	}

	public String getName() {
		return element.getAttribute("name");
	}

	public String getDescription() {
		return element.getAttribute("description");
	}

	protected String[] getTypeIds() {
		try {
			return ServerPlugin.tokenize(element.getAttribute("typeIds"), ",");
		} catch (Exception e) {
			return null;
		}
	}

	public boolean supportsType(String id) {
		return ServerPlugin.contains(getTypeIds(), id);
	}

	/*
	 * @see IPublisher#getDelegate()
	 */
	public PublisherDelegate getDelegate() {
		if (delegate == null) {
			try {
				long time = System.currentTimeMillis();
				delegate = (PublisherDelegate) element.createExecutableExtension("class");
				Trace.trace(Trace.PERFORMANCE, "PublishTask.getDelegate(): <" + (System.currentTimeMillis() - time) + "> " + getId());
			} catch (Throwable t) {
				Trace.trace(Trace.SEVERE, "Could not create delegate" + toString(), t);
			}
		}
		return delegate;
	}

	/**
	 * Should the original {@link ISchedulingRule} be changed with the new {@link ISchedulingRule}?
	 * 
	 * @param originalRule
	 *            The original {@link ISchedulingRule}
	 * @param newRule
	 *            The new {@link ISchedulingRule}
	 * @return <code>true</code> if the new scheduling rule should be applied; Otherwise <code>false</code>.
	 */
	private boolean changeSchedulingRule(ISchedulingRule originalRule, ISchedulingRule newRule) {

		boolean changeRule = false;
		if ((originalRule == null) && (newRule == null)) {
			// no need to change rules if they're both null
			changeRule = false;
		}
		else if((originalRule == null) && (newRule != null)) {
			// there is currently no rule and a new not-null rule wants to be added 
			changeRule = true;
		}
		else if((originalRule != null) && (newRule == null)) {
			// there is currently a rule and a new null rule wants to be applied
			changeRule = true;
		}
		else if((originalRule != null) && (newRule != null)) {
			// there is currently a rule and a new not-null rule wants to be applied.
			changeRule = !originalRule.equals(newRule);
		}
		return changeRule;
	}

	/**
	 * rebuild the cache for the modules involved with this task.
	 */
	private void rebuildModuleCache() {

		// reset the publishing cache for the modules that are part of this task.
		Server server = (Server) getDelegate().getTaskModel().getObject(TaskModel.TASK_SERVER);
		if (server != null) {
			// make sure the right server is used.
			if(server.isWorkingCopy()) {
				IServerWorkingCopy workingCopy = (IServerWorkingCopy)server;
				server = (Server) workingCopy.getOriginal();
			}
			final List<IModule[]> moduleList = getDelegate().getModifiedModules();
			if (moduleList != null) {
				final Iterator<IModule[]> moduleIterator = moduleList.iterator();
				while (moduleIterator.hasNext()) {
					IModule[] module = moduleIterator.next();
					if (module != null) {
						Trace.trace(Trace.FINEST, "rebuilding cache for module: " + module[module.length - 1]);
						server.getServerPublishInfo().rebuildCache(module);
					}
				}
			}
		}
	}
	
	public IStatus execute(int kind, IProgressMonitor monitor, IAdaptable info) throws CoreException {

		Trace.trace(Trace.FINEST, "Task.init " + this);
		ISchedulingRule delegatePublisherRule = null;
		final ISchedulingRule originalPublisherRule = Job.getJobManager().currentRule();
		IStatus resultStatus = null;
		boolean changeSchedulingRules = false;
		try {
			delegatePublisherRule = getDelegate().getRule();
			changeSchedulingRules = this.changeSchedulingRule(originalPublisherRule, delegatePublisherRule);
			Trace.trace(Trace.FINEST, "Change the scheduling rule to execute delegate: " + changeSchedulingRules);
			if (changeSchedulingRules) {
				Trace.trace(Trace.FINEST, "Ending the current scheduling rule " + originalPublisherRule);
				Job.getJobManager().endRule(originalPublisherRule);
				Trace.trace(Trace.FINEST, "Beginning the new scheduling rule: " + delegatePublisherRule);
				Job.getJobManager().beginRule(delegatePublisherRule, monitor);
			}
			resultStatus = getDelegate().execute(kind, monitor, info);
			this.modifyModules = getDelegate().isModifyModules();
			Trace.trace(Trace.FINEST, "The publisher delegate stated that it modified modules: " + this.modifyModules);
			if(this.modifyModules) {
				this.rebuildModuleCache();
			}
		}
		catch (Exception e) {
			Trace.trace(Trace.SEVERE, "Error calling delegate " + toString(), e);
			resultStatus = new Status(IStatus.ERROR, ServerPlugin.PLUGIN_ID, "Error in delegate", e);
		}
		finally {
			if (changeSchedulingRules) {
				Trace.trace(Trace.FINEST, "Reseting the scheduling rules... ending: " + delegatePublisherRule);
				Job.getJobManager().endRule(delegatePublisherRule);
				Trace.trace(Trace.FINEST, "Reseting the scheduling rules... beginning: " + originalPublisherRule);
				Job.getJobManager().beginRule(originalPublisherRule, monitor);
			}
		}
		return resultStatus;
	}

	public void setTaskModel(TaskModel taskModel) {
		try {
			getDelegate().setTaskModel(taskModel);
		} catch (Exception e) {
			Trace.trace(Trace.SEVERE, "Error calling delegate " + toString(), e);
		}
	}

	/**
	 * Accessor to find out if this publisher modified any modules that are published on the server.
	 * 
	 * @return <code>true</code> if the publisher modified the contents of any modules that are published on the server.
	 */
	public boolean isModifyModules() {

		return this.modifyModules;
	}
	
	/**
	 * Return a string representation of this object.
	 * 
	 * @return a string
	 */
	public String toString() {
		return "Publisher[" + getId() + "]";
	}
}