/*******************************************************************************
* Copyright (c) 2001, 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.jst.j2ee.commonarchivecore.looseconfig.internal;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.jst.j2ee.application.Module;
import org.eclipse.jst.j2ee.commonarchivecore.internal.Container;
import org.eclipse.jst.j2ee.commonarchivecore.internal.EARFile;
import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ArchiveRuntimeException;
import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil;
import org.eclipse.wst.common.internal.emf.utilities.StringUtil;
/**
* Used internally for loose module support
*/
public class LooseConfigRegister {
/**
* The system property used to specify the absolute path to the loose config document;
* "was.loose.config"
*/
public static final String LOOSE_CONFIG_PROPERTY = "was.loose.config"; //$NON-NLS-1$
protected static LooseConfigRegister singleton;
protected LooseConfiguration looseConfiguration;
protected ResourceSet resourceSet;
/** Have we previously loaded or tried to load the loose configuration? */
protected boolean loadAttempted = false;
private Map looseEarMap;
/**
* Constructor for LooseConfigRegister.
*/
protected LooseConfigRegister() {
super();
initialize();
}
public static LooseConfigRegister singleton() {
if (singleton == null)
singleton = new LooseConfigRegister();
return singleton;
}
/**
* Searches for the ear file in the fluffed LooseConfiguration object, and attempts to load the
* LooseApplication on demand from the existing mappings if it is not already loaded.
*
* @param earFileURI
* @return
*/
public LooseApplication findLooseApplication(String earFileURI) {
// System.out.println(getClass().getName() + ".findLooseApplication(String
// earFileURI=\""+earFileURI+"\")");
if (getLooseConfiguration() != null) {
List apps = getLooseConfiguration().getApplications();
for (int i = 0; i < apps.size(); i++) {
LooseApplication app = (LooseApplication) apps.get(i);
// System.out.println(getClass().getName() + ".findLooseApplication():
// app["+i+"].getURI()=\""+app.getUri()+"\"" );
if (app.getUri().equals(earFileURI))
return app;
}
}
// System.out.println(getClass().getName() + ".findLooseApplication(): did not find loaded
// LooseApplication, loading new value." );
if (getDocumentURI() == null || getDocumentURI().trim().length() == 0) {
URI looseConfig = (URI) getLooseEarMap().get(earFileURI);
// System.out.println(getClass().getName() + ".findLooseApplication(): looseConfig URI
// from map \""+looseConfig+"\"");
LooseApplication application = loadLooseApplication(looseConfig);
// System.out.println(getClass().getName() + ".findLooseApplication():
// looseApplication="+application);
if (application != null) {
List modules = application.getLooseArchives();
// System.out.println(getClass().getName() + ".findLooseApplication():
// looseApplication contains " + modules.size() + " modules.");
for (int i = 0; i < modules.size(); i++)
// System.out.println(getClass().getName() + ".findLooseApplication():
// modules.get("+i+"):"+ modules.get(i));
getLooseConfiguration().getApplications().add(application);
return application;
}
}
return null;
}
/**
* @param earFileURI
* The containing EAR -- the absolute file system URI will be determined
* automatically
* @param looseApplicationResource
* The absolute file system URI of a document containing a LooseApplication as its
* root
*/
public void addLooseMapping(Container container, String looseApplicationResource) {
if (container != null)
addLooseMapping(ArchiveUtil.getOSUri(container.getURI()), looseApplicationResource);
}
/**
* @param earFileURI
* The absolute file system URI of the EAR file of the given mapping
* @param looseApplicationResource
* The absolute file system URI of a document containing a LooseApplication as its
* root
*/
public void addLooseMapping(String earFileURI, String looseApplicationResource) {
if (earFileURI != null) {
// System.out.println(getClass().getName() + ".addLooseMapping(String
// earFileURI=\""+earFileURI+"\", String
// looseApplicationResource=\""+looseApplicationResource+"\")");
if (getLooseEarMap().containsKey(earFileURI)) {
// System.out.println(getClass().getName() + ".addLooseMapping(): Found existing key
// with same earFileURI, looking for loaded app.");
LooseApplication app = findLooseApplicationIfLoaded(earFileURI);
// System.out.println(getClass().getName() + ".addLooseMapping(): Loaded app=" +
// app);
if (app != null) {
Resource res = loadLooseApplicationResource(URI.createURI(looseApplicationResource));
// System.out.println(getClass().getName() + ".addLooseMapping(): clearing
// resource:" + res);
res.unload();
removeLooseApplication(app);
}
}
getLooseEarMap().put(earFileURI, URI.createURI(looseApplicationResource));
}
}
/**
* @param earFileURI
* @return
*/
public LooseApplication findLooseApplicationIfLoaded(String earFileURI) {
// System.out.println(getClass().getName() + ".findLooseApplicationIfLoaded(String
// earFileURI=\""+earFileURI+"\")");
if (getLooseConfiguration() != null) {
List apps = getLooseConfiguration().getApplications();
for (int i = 0; i < apps.size(); i++) {
LooseApplication app = (LooseApplication) apps.get(i);
// System.out.println(getClass().getName() + ".findLooseApplicationIfLoaded():
// app["+i+"].getURI()=\""+app.getUri()+"\"" );
if (app.getUri().equals(earFileURI))
return app;
}
}
return null;
}
/**
* Allows adding LooseApplications dynmically.
*
* @param application
* An application created and persisted by an external entity
*/
public void addLooseApplication(LooseApplication application) {
getLooseConfiguration().getApplications().add(application);
}
/**
* Allows removing LooseApplications dynmically.
*
* @param application
* An application created and persisted by an external entity
*/
public void removeLooseApplication(LooseApplication application) {
// System.out.println(getClass().getName() + ".removeLooseApplication(LooseApplication
// application=\""+application+"\")");
getLooseConfiguration().getApplications().remove(application);
}
/**
* @param earFileURI
* The absolute file system URI of the EAR file of the given mapping
*/
public void removeLooseMapping(String earFileURI) {
// System.out.println(getClass().getName() + ".removeLooseMapping(String
// earFileURI=\""+earFileURI+"\")");
if (earFileURI != null)
getLooseEarMap().remove(earFileURI);
}
public LooseModule findLooseModule(LooseApplication app, String uri, String altDD) {
List archives = app.getLooseArchives();
for (int i = 0; i < archives.size(); i++) {
LooseArchive element = (LooseArchive) archives.get(i);
if (!element.isModule())
continue;
if (StringUtil.stringsEqual(uri, element.getUri()) && StringUtil.stringsEqual(altDD, ((LooseModule) element).getAltDD()))
return (LooseModule) element;
}
return null;
}
public LooseModule findLooseModule(Module m, EARFile ear) {
LooseApplication app = findLooseApplication(ear.getURI());
return app == null ? null : findLooseModule(app, m.getUri(), m.getAltDD());
}
/**
* Clears the loose configuration; the next time it is requested it will be reloaded;
*/
public void flush() {
loadAttempted = false;
looseConfiguration = null;
resourceSet = new ResourceSetImpl();
}
protected void initialize() {
resourceSet = new ResourceSetImpl();
}
protected void loadLooseConfiguration() {
Resource res = loadLooseConfigurationResource();
if (res != null && !res.getContents().isEmpty())
setLooseConfiguration((LooseConfiguration) res.getContents().get(0));
else
/*
* if the document is empty then fluff up a LooseConfiguration object
*/
setLooseConfiguration(LooseconfigFactory.eINSTANCE.createLooseConfiguration());
loadAttempted = true;
}
protected Resource loadLooseConfigurationResource() {
String uri = getDocumentURI();
if (ArchiveUtil.isNullOrEmpty(uri))
return null;
try {
return resourceSet.getResource(URI.createURI(uri), true);
} catch (Exception ex) {
throw new ArchiveRuntimeException("Exception occurred loading loose configuration", ex); //$NON-NLS-1$
}
}
protected LooseApplication loadLooseApplication(URI looseAppURI) {
Resource res = loadLooseApplicationResource(looseAppURI);
if (res != null && !res.getContents().isEmpty())
return (LooseApplication) res.getContents().get(0);
return null;
}
protected Resource loadLooseApplicationResource(URI looseConfigURI) {
if (looseConfigURI == null)
return null;
try {
return resourceSet.getResource(looseConfigURI, true);
} catch (Exception ex) {
throw new ArchiveRuntimeException("Exception occurred loading loose application", ex); //$NON-NLS-1$
}
}
/**
* Gets the looseConfiguration. Basic accessor with no initialization
*
* @return Returns a LooseConfiguration
*/
public LooseConfiguration primGetLooseConfiguration() {
return looseConfiguration;
}
/** The value of the loose config property */
protected String getDocumentURI() {
return System.getProperty(LOOSE_CONFIG_PROPERTY);
}
/**
* Gets the looseConfiguration. Tries to load it using the system property was.loose.config, if
* necessary.
*
* @return Returns a LooseConfiguration or null
*/
public LooseConfiguration getLooseConfiguration() {
if (looseConfiguration == null && !loadAttempted)
loadLooseConfiguration();
return looseConfiguration;
}
/**
* Assumption: the parameter must be a type that can have children, e.g., LooseWAR or
* LooseApplication
*/
public List getLooseChildren(LooseArchive loose) {
if (loose != null) {
if (loose.isEAR())
return ((LooseApplication) loose).getLooseArchives();
else if (loose.isWAR())
return ((LooseWARFile) loose).getLooseLibs();
}
return Collections.EMPTY_LIST;
}
/**
* Assumption: the parameter must be a type that can have children, e.g., LooseWAR or
* LooseApplication
*/
public LooseArchive findFirstLooseChild(String uri, LooseArchive loose) {
List children = getLooseChildren(loose);
for (int i = 0; i < children.size(); i++) {
LooseArchive child = (LooseArchive) children.get(i);
if (StringUtil.stringsEqual(uri, child.getUri()))
return loose;
}
return null;
}
/**
* Sets the looseConfiguration.
*
* @param looseConfiguration
* The looseConfiguration to set
*/
public void setLooseConfiguration(LooseConfiguration config) {
looseConfiguration = config;
}
/**
* Have we previously loaded or tried to load the loose configuration?
*
* @return Returns a boolean
*/
public boolean getLoadAttempted() {
return loadAttempted;
}
/**
* @return Returns the looseEarMap.
*/
public Map getLooseEarMap() {
if (looseEarMap == null)
looseEarMap = new HashMap();
return looseEarMap;
}
}