/*******************************************************************************
* Copyright (c) 2006, 2012 University College London Software Systems Engineering
* 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:
* Bruno Wassermann - initial API and implementation
*******************************************************************************/
package org.eclipse.bpel.runtimes.publishers;
import java.util.Iterator;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jst.server.generic.core.internal.GenericPublisher;
import org.eclipse.jst.server.generic.core.internal.GenericServer;
import org.eclipse.jst.server.generic.servertype.definition.Port;
import org.eclipse.wst.server.core.IModuleArtifact;
/**
* An abstract base class offering some utility methods facilitating the process
* of deploying a BPEL process onto a runtime and indicating a publisher of
* BPEL processes. This extends the generic server
* framework. Implementers of the <code>genericpublishers</code> extension point
* wishing to publish BPEL processes onto some runtime, may find it convenient
* to sub-class this class.
* <p>
* The minimum requirement on sub-classes is to provide an implementation of
* <code>GenericPublisher{@link #publish(IModuleArtifact[], IProgressMonitor)}</code>,
* <code>GenericPublisher{@link #unpublish(IProgressMonitor)}</code> and of
* <code></code>
* <p>
* Clients should not instantiate this class or its sub-classes as they will be
* instantiated by the WTP server framework. Clients can make use of any
* convenience methods contained in this class (all methods defined directly
* on <code>GenericBPELPublisher</code>).
*
*
* @author Bruno Wassermann, written Jun 8, 2006
*/
public abstract class GenericBPELPublisher extends GenericPublisher {
// TODO add utility methods that may be useful to concrete implementations
/**
* Displays engine-specific validation warnings and errors in the BPEL
* Designer.
* <p>
* Sub-classes can call this method to provide information
* about any problems detected during deployment.
*/
protected final void submitValidationMarkers() {
// TODO decide on signature/arguments
}
/**
* Provides access to the relevant project in the workspace in order to
* store a local copy of a generated deployment archive
*
* @param deployArchive
* @param path should probably be relative from project root and if null
* will save archive in project root
*/
protected void storeDeploymentArchive(IFile deployArchive, IPath path) {
// TODO figure out whether this is really useful
// TODO figure out the signature (should it be a file, what's the best
// way to allow specifying an additional path?) - maybe look at some
// of the methods in the WTP tutorial.
}
/**
* Returns the host part of the server on which module is to be published.
* For example, 'localhost'.
*
* @return <code>String</code> representing host part of server on which
* module is to be published. Will return <code>null</code>, if called
* before {@link GenericPublisher#initialize()} has been called.
*/
protected String getHost() {
return getServer().getServer().getHost();
}
/**
* Returns http port defined for the server module is to be published on.
* <p>
* This replicates {@link GenericServer#getHttpPort()}.
*
* @return int
*/
protected int getHttpPort() {
int port = -1;
Iterator pIter = getServer().getServerDefinition().getPort().iterator();
while (pIter.hasNext()) {
Port aPort = (Port) pIter.next();
if(port == -1) {
port = Integer.parseInt(getServer().getServerDefinition().getResolver().resolveProperties(aPort.getNo()));
}
else if( "http".equals(aPort.getProtocol() ) ) { //$NON-NLS-1$
port = Integer.parseInt(aPort.getNo());
}
}
if( port == -1) {
port = 8080;
}
return port;
}
/*
* we don't have something like validate in here as we are not the provider
* of an extension point, but simply providing some utility methods for
* sub-classes to use if they so wish.
*
* if we had provided our own extension point to do publishing, then
* we would probably have specified a validate() method in the abstract base
* class so that our framework could call its implementation in extensions.
*
* If it's just a utility method it should have static methods. Otherwise,
* allow it to be sub-classed and declare some methods as abstract to
* indicate to sub-classes what they need to implement.
*
* What is true though is that we cannot call such methods automatically as
* we are not really offering an extension point.
*
* TODO clarify explain this point about usage in the class comment! the methods
* will not be called automatically as we are not providing an extension
* point as initially expected.
*/
}