| /******************************************************************************* |
| * Copyright (c) 2003, 2007 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.internal.validation; |
| |
| |
| |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.resources.IContainer; |
| import org.eclipse.core.resources.IFile; |
| import org.eclipse.core.resources.IProject; |
| import org.eclipse.core.resources.IResource; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Path; |
| import org.eclipse.core.runtime.jobs.ISchedulingRule; |
| import org.eclipse.core.runtime.jobs.MultiRule; |
| import org.eclipse.emf.common.command.Command; |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.URIConverter; |
| import org.eclipse.jem.util.emf.workbench.WorkbenchURIConverter; |
| import org.eclipse.jem.workbench.utility.JemProjectUtilities; |
| import org.eclipse.jst.j2ee.application.EjbModule; |
| import org.eclipse.jst.j2ee.application.Module; |
| import org.eclipse.jst.j2ee.application.WebModule; |
| import org.eclipse.jst.j2ee.classpathdep.ClasspathDependencyUtil; |
| import org.eclipse.jst.j2ee.classpathdep.IClasspathDependencyConstants; |
| import org.eclipse.jst.j2ee.common.EjbRef; |
| import org.eclipse.jst.j2ee.common.MessageDestinationRef; |
| import org.eclipse.jst.j2ee.common.ResourceEnvRef; |
| import org.eclipse.jst.j2ee.common.ResourceRef; |
| import org.eclipse.jst.j2ee.common.SecurityRoleRef; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.Archive; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.File; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.ModuleFile; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.ValidateXmlCommand; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.exception.ManifestException; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveConstants; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.helpers.ArchiveManifest; |
| import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil; |
| import org.eclipse.jst.j2ee.componentcore.EnterpriseArtifactEdit; |
| import org.eclipse.jst.j2ee.componentcore.J2EEModuleVirtualComponent; |
| import org.eclipse.jst.j2ee.componentcore.util.EARArtifactEdit; |
| import org.eclipse.jst.j2ee.internal.J2EEConstants; |
| import org.eclipse.jst.j2ee.internal.J2EEVersionConstants; |
| import org.eclipse.jst.j2ee.internal.classpathdep.DuplicateClasspathComponentURIValidatorEnablement; |
| import org.eclipse.jst.j2ee.internal.plugin.IJ2EEModuleConstants; |
| import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin; |
| import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities; |
| import org.eclipse.jst.j2ee.model.internal.validation.EARValidationMessageResourceHandler; |
| import org.eclipse.jst.j2ee.model.internal.validation.EarValidator; |
| import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities; |
| import org.eclipse.jst.j2ee.webservice.wsclient.ServiceRef; |
| import org.eclipse.osgi.util.NLS; |
| import org.eclipse.wst.common.componentcore.ComponentCore; |
| import org.eclipse.wst.common.componentcore.internal.impl.ModuleURIUtil; |
| import org.eclipse.wst.common.componentcore.internal.resources.VirtualArchiveComponent; |
| import org.eclipse.wst.common.componentcore.internal.util.IModuleConstants; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualComponent; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualFile; |
| import org.eclipse.wst.common.componentcore.resources.IVirtualReference; |
| import org.eclipse.wst.common.internal.emfworkbench.WorkbenchResourceHelper; |
| import org.eclipse.wst.validation.internal.core.ValidationException; |
| import org.eclipse.wst.validation.internal.operations.IWorkbenchContext; |
| import org.eclipse.wst.validation.internal.operations.LocalizedMessage; |
| import org.eclipse.wst.validation.internal.provisional.core.IMessage; |
| import org.eclipse.wst.validation.internal.provisional.core.IReporter; |
| import org.eclipse.wst.validation.internal.provisional.core.IValidationContext; |
| import org.eclipse.wst.validation.internal.provisional.core.IValidatorJob; |
| |
| |
| /** |
| * Insert the type's description here. Creation date: (9/10/2001 2:11:02 PM) |
| * |
| * @author: Administrator |
| */ |
| public class UIEarValidator extends EarValidator { |
| public static final String VALIDATOR_ID = "org.eclipse.jst.j2ee.internal.validation.UIEarValidator"; //$NON-NLS-1$ |
| public static final String MANIFEST_GROUP_NAME = "WSAD.EAR.MANIFEST"; //$NON-NLS-1$ |
| public static final String DOCTYPE_1_2 = "1.2"; //$NON-NLS-1$ |
| public static final String DOCTYPE_1_3 = "1.3"; //$NON-NLS-1$ |
| |
| protected UIEarHelper earHelper; |
| // private EARArtifactEdit earEdit = null; |
| private IProject project = null; |
| |
| /** |
| * UIEarValidator constructor comment. |
| */ |
| public UIEarValidator() { |
| super(); |
| } |
| |
| @Override |
| public Command createValidateXMLCommand() { |
| |
| ValidateXmlCommand cmd = (ValidateXmlCommand) super.createValidateXMLCommand(); |
| cmd.setValidateNested(false); |
| return cmd; |
| } |
| |
| @Override |
| protected String getResourceName() { |
| return ((EarHelper) _helper).getProject().getName(); |
| } |
| |
| protected void duplicateProjectMapError(String earProjectName, String moduleUri, String projectName) { |
| |
| String[] params = new String[3]; |
| params[0] = projectName; |
| params[1] = earProjectName; |
| params[2] = moduleUri; |
| String msg = NLS.bind(EARValidationMessageResourceHandler.DUPLICATE_MODULE_FOR_PROJECT_NAME_ERROR_, params); |
| |
| addLocalizedError(msg, appDD); |
| } |
| |
| /** |
| * |
| */ |
| @Override |
| protected void cleanUpSubTaskMessages(EObject ref) { |
| String groupName = EJB_REF_GROUP_NAME; |
| if (ref instanceof EjbRef) |
| { |
| // ref = (EjbRef) ref; |
| } |
| else if (ref instanceof ResourceRef) { |
| // ref = (ResourceRef) ref; |
| groupName = RES_REF_GROUP_NAME; |
| } else if (ref instanceof ServiceRef) { |
| // ref = (ServiceRef) ref; |
| groupName = SERVICE_REF_GROUP_NAME; |
| } else if (ref instanceof ResourceEnvRef) { |
| // ref = (ResourceEnvRef) ref; |
| groupName = RES_ENV_REF_GROUP_NAME; |
| } else if (ref instanceof SecurityRoleRef) { |
| // ref = (SecurityRoleRef) ref; |
| groupName = SEC_ROLE_REF_GROUP_NAME; |
| } else if (ref instanceof MessageDestinationRef) { |
| // ref = (MessageDestinationRef) ref; |
| groupName = MESSAGE_REF_GROUP_NAME; |
| } |
| Resource res = ref.eResource(); |
| if (res != null) { |
| IFile file = WorkbenchResourceHelper.getFile(res); |
| if (file != null) |
| _reporter.removeMessageSubset(this, file, groupName); |
| } |
| } |
| |
| @Override |
| protected void cleanUpAllRefSubTaskMessages(Resource res) { |
| if (res != null) { |
| IFile file = WorkbenchResourceHelper.getFile(res); |
| if (file != null) |
| _reporter.removeMessageSubset(this, file, EJB_REF_GROUP_NAME); |
| _reporter.removeMessageSubset(this, file, RES_REF_GROUP_NAME); |
| _reporter.removeMessageSubset(this, file, SERVICE_REF_GROUP_NAME); |
| _reporter.removeMessageSubset(this, file, SEC_ROLE_REF_GROUP_NAME); |
| _reporter.removeMessageSubset(this, file, MESSAGE_REF_GROUP_NAME); |
| _reporter.removeMessageSubset(this, file, RES_ENV_REF_GROUP_NAME); |
| } |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (9/10/2001 2:56:32 PM) |
| * |
| * @return org.eclipse.wst.validation.internal.core.core.ear.workbenchimpl.UIEarHelper |
| */ |
| public org.eclipse.jst.j2ee.internal.validation.UIEarHelper getEarHelper() { |
| return earHelper; |
| } |
| |
| protected void invalidClassPathEntryWarning(String entry, Archive anArchive) { |
| String[] params = new String[2]; |
| params[0] = anArchive.getURI(); |
| params[1] = entry; |
| String msg = NLS.bind(EARValidationMessageResourceHandler.INVALID_MANIFEST_CLASSPATH_ONE_WARN_, params); |
| addLocalizedWarning(msg, getManifestFile(anArchive), MANIFEST_GROUP_NAME); |
| } |
| |
| protected void invalidClassPathEntryWarning(String entry, String resolvedEntry, Archive anArchive) { |
| String[] params = new String[3]; |
| params[0] = anArchive.getURI(); |
| params[1] = entry; |
| params[2] = resolvedEntry; |
| String msg = NLS.bind(EARValidationMessageResourceHandler.INVALID_MANIFEST_CLASSPATH_TWO_WARN_, params); |
| addLocalizedWarning(msg, getManifestFile(anArchive), MANIFEST_GROUP_NAME); |
| } |
| |
| protected void invalidDepedencyWarning(String entry, Archive anArchive, ModuleFile m) { |
| String[] params = new String[3]; |
| params[0] = m.getURI(); |
| params[1] = entry; |
| params[2] = anArchive.getURI(); |
| String msg = NLS.bind(EARValidationMessageResourceHandler.INVALID_MANIFEST_CLASSPATH_DEPENDENCY_WARN_, params); |
| |
| addLocalizedWarning(msg, getManifestFile(anArchive), MANIFEST_GROUP_NAME); |
| } |
| |
| /** |
| * Insert the method's description here. Creation date: (9/10/2001 2:56:32 PM) |
| * |
| * @param newEarHelper |
| * org.eclipse.wst.validation.internal.core.core.ear.workbenchimpl.UIEarHelper |
| */ |
| public void setEarHelper(org.eclipse.jst.j2ee.internal.validation.UIEarHelper newEarHelper) { |
| earHelper = newEarHelper; |
| } |
| |
| @Override |
| public IStatus validateInJob(IValidationContext inHelper, IReporter inReporter) throws org.eclipse.wst.validation.internal.core.ValidationException { |
| IStatus status = IValidatorJob.OK_STATUS; |
| IProject earProj = ((IWorkbenchContext) inHelper).getProject(); |
| IVirtualComponent earModule = ComponentCore.createComponent(earProj); |
| if(JavaEEProjectUtilities.isEARProject(earProj)){ |
| IVirtualFile ddFile = earModule.getRootFolder().getFile(J2EEConstants.APPLICATION_DD_URI); |
| if( ddFile.exists()) { |
| inReporter.removeAllMessages(this); |
| |
| IVirtualReference[] earReferences; |
| boolean isMixedEAR = false; |
| boolean isJavaEEFiveProject = false; |
| boolean isLegacyEAR = J2EEProjectUtilities.isLegacyJ2EEProject(earProj); |
| |
| //because of [224484] 5.0 EARs may get to this validator when they should not, need to protect against this |
| if(isLegacyEAR) { |
| earReferences = earModule.getReferences(); |
| IVirtualComponent referencedComponenet; |
| IProject earRefedProj; |
| //[Bug 241525] need to use referenced components because referenced projects return the EAR for referenced binary archives |
| for(IVirtualReference earReference : earReferences) { |
| referencedComponenet = earReference.getReferencedComponent(); |
| |
| //[Bug 241525]if its a VirtualArchiveComponent then we need to use |
| // components to get version, otherwise use IProject |
| if(referencedComponenet instanceof VirtualArchiveComponent) { |
| isJavaEEFiveProject = JavaEEProjectUtilities.isJEEComponent(referencedComponenet); |
| } else { |
| earRefedProj = referencedComponenet.getProject(); |
| isJavaEEFiveProject = J2EEProjectUtilities.isJEEProject(earRefedProj); |
| } |
| |
| //if any referenced project is a JEE 5 project then ear is mixed |
| if(!isMixedEAR) { |
| isMixedEAR = isJavaEEFiveProject; |
| } |
| } |
| |
| } |
| |
| //should only continue validation if this is not an invalid mixed EAR |
| //isLegacyEAR check needed because of [224484] 5.0 EARs may get to this validator when they should not, need to protect against this |
| if(isLegacyEAR && !isMixedEAR) { |
| status = super.validateInJob(inHelper, inReporter); |
| validateModuleMaps(earModule); |
| validateManifests(); |
| if(DuplicateClasspathComponentURIValidatorEnablement.shouldValidateDuplicateClasspathComponentURI()){ |
| validateDuplicateClasspathComponentURIs(earModule); |
| } |
| // validateUtilJarMaps(earEdit,earModule); |
| // validateUriAlreadyExistsInEar(earEdit,earModule); |
| // validateDocType(earEdit,earModule); |
| } |
| } |
| } |
| return status; |
| } |
| |
| @Override |
| public ISchedulingRule getSchedulingRule(IValidationContext helper) { |
| ISchedulingRule combinedRule = null; |
| IProject project = ((IWorkbenchContext) helper).getProject(); |
| IVirtualComponent comp = ComponentCore.createComponent( project ); |
| IFile appDeploymentDescriptor = null; |
| if( comp != null ){ |
| IVirtualFile vf = comp.getRootFolder().getFile(new Path(J2EEConstants.APPLICATION_DD_URI)); |
| if( vf!= null ){ |
| appDeploymentDescriptor = vf.getUnderlyingFile(); |
| combinedRule = MultiRule.combine(appDeploymentDescriptor, combinedRule); |
| } |
| IVirtualReference[] refs = comp.getReferences(); |
| for( int i=0; i< refs.length; i++ ){ |
| IVirtualComponent refComp = refs[i].getReferencedComponent(); |
| if( refComp != null && !refComp.isBinary() ){ |
| String type = J2EEProjectUtilities.getJ2EEComponentType( refComp ); |
| IVirtualFile refDDFile = null; |
| if( type.equals(IModuleConstants.JST_WEB_MODULE)){ |
| refDDFile = refComp.getRootFolder().getFile(new Path(J2EEConstants.WEBAPP_DD_URI)); |
| }else if ( type.equals(IModuleConstants.JST_CONNECTOR_MODULE)){ |
| refDDFile = refComp.getRootFolder().getFile(new Path(J2EEConstants.RAR_DD_URI)); |
| }else if( type.equals(IModuleConstants.JST_EJB_MODULE)){ |
| refDDFile = refComp.getRootFolder().getFile(new Path(J2EEConstants.EJBJAR_DD_URI)); |
| }else if( type.equals(IModuleConstants.JST_APPCLIENT_MODULE)){ |
| refDDFile = refComp.getRootFolder().getFile(new Path(J2EEConstants.APPLICATION_DD_URI)); |
| } |
| if( refDDFile!= null ){ |
| IFile dd = refDDFile.getUnderlyingFile(); |
| combinedRule = MultiRule.combine(dd, combinedRule); |
| } |
| } |
| } |
| |
| } |
| return combinedRule; |
| } |
| |
| public void validateDuplicateClasspathComponentURIs(final IVirtualComponent earComponent) { |
| if (earFile == null) { |
| return; |
| } |
| final Set moduleURIs = new HashSet(); |
| final List archives = earFile.getArchiveFiles(); |
| for (int i = 0; i < archives.size(); i++) { |
| final Archive anArchive = (Archive) archives.get(i); |
| moduleURIs.add(anArchive.getURI()); |
| } |
| |
| final Map archiveToPath = new HashMap(); |
| final IVirtualReference[] components = earComponent.getReferences(); |
| for (int i = 0; i < components.length; i++) { |
| IVirtualReference reference = components[i]; |
| IVirtualComponent referencedComponent = reference.getReferencedComponent(); |
| |
| // retrieve all Java classpath component dependencies |
| if (referencedComponent instanceof J2EEModuleVirtualComponent) { |
| final IVirtualReference[] cpRefs = ((J2EEModuleVirtualComponent) referencedComponent).getJavaClasspathReferences(); |
| for (int j = 0; j < cpRefs.length; j++) { |
| final IVirtualReference ref = cpRefs[j]; |
| // only ../ runtime paths contribute to the EAR |
| if (ref.getRuntimePath().equals(IClasspathDependencyConstants.RUNTIME_MAPPING_INTO_CONTAINER_PATH)) { |
| String archiveName = ref.getArchiveName(); |
| String[] params = {referencedComponent.getProject().getName(), archiveName}; |
| if (moduleURIs.contains(archiveName)) { |
| String msg = NLS.bind(EARValidationMessageResourceHandler.CLASSPATH_COMPONENT_URI_MATCHES_ARCHIVE_URI, params); |
| addLocalizedError(msg, project); |
| } else { |
| IPath cpEntryPath= ClasspathDependencyUtil.getClasspathVirtualReferenceLocation(ref); |
| if (cpEntryPath != null) { |
| IPath existingPath = (IPath) archiveToPath.get(archiveName); |
| if (existingPath != null && !existingPath.equals(cpEntryPath)) { |
| String msg = NLS.bind(EARValidationMessageResourceHandler.DUPLICATE_CLASSPATH_COMPONENT_URI, params); |
| addLocalizedError(msg, project); |
| } else { |
| archiveToPath.put(archiveName, cpEntryPath); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| public void validateManifests() throws ValidationException { |
| if (earFile == null) |
| return; |
| List archives = earFile.getArchiveFiles(); |
| for (int i = 0; i < archives.size(); i++) { |
| final Archive anArchive = (Archive) archives.get(i); |
| if(anArchive.getLoadStrategy().isReadOnly()){ |
| continue; |
| } |
| IFile target = getManifestFile(anArchive); |
| if (target != null) |
| _reporter.removeMessageSubset(this, target, MANIFEST_GROUP_NAME); |
| validateManifestCase(anArchive); |
| validateManifestLines(anArchive); |
| validateManifestClasspath(anArchive); |
| } |
| } |
| |
| public void validateManifestCase(Archive anArchive) { |
| String mfuri = J2EEConstants.MANIFEST_URI; |
| |
| //Indicates a manifest file with the valid name exists, |
| //nothing left to do |
| if (anArchive.containsFile(mfuri)) |
| return; |
| |
| //Otherwise iterate the list of files |
| //Ensure the archive is read-only first |
| anArchive.getOptions().setIsReadOnly(true); |
| List files = anArchive.getFiles(); |
| String uri = null; |
| for (int i = 0; i < files.size(); i++) { |
| File aFile = (File) files.get(i); |
| uri = aFile.getURI(); |
| if (mfuri.equalsIgnoreCase(uri) && !mfuri.equals(uri)) { |
| String[] params = {uri, anArchive.getURI()}; |
| String msg = NLS.bind(EARValidationMessageResourceHandler.INVALID_CASE_FOR_MANIFEST_ERROR_, params); |
| addLocalizedError(msg, null); |
| } |
| } |
| |
| } |
| |
| |
| public void validateManifestClasspath(Archive anArchive) throws ValidationException { |
| ArchiveManifest manifest = null; |
| try{ |
| manifest = anArchive.getManifest(); |
| }catch( ManifestException mf){ |
| mf.getMessage(); |
| String[] args = new String[]{anArchive.getURI()}; |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.ERROR_READING_MANIFEST_ERROR_, args); |
| addLocalizedError(tmp, args); |
| } |
| |
| if(manifest == null) |
| return; |
| |
| String[] cp = manifest.getClassPathTokenized(); |
| |
| for (int i = 0; i < cp.length; i++) { |
| String uri = ArchiveUtil.deriveEARRelativeURI(cp[i], anArchive); |
| if (uri == null) { |
| invalidClassPathEntryWarning(cp[i], anArchive); |
| continue; |
| } |
| File f = null; |
| //IFile rf = null; |
| try { |
| // if (uri.endsWith(J2EEImportConstants.IMPORTED_JAR_SUFFIX)) { |
| //TODO Needs work here to initialize rf as rf is an IFile and there is no way to get an IFile currently |
| // IVirtualResource resource = component.getRootFolder().findMember(new Path(uri)); |
| // if (resource == null || !resource.exists()) { |
| // invalidClassPathEntryWarning(cp[i], uri, anArchive); |
| // } |
| // } |
| // else |
| f = earFile.getFile(uri); |
| } catch (java.io.FileNotFoundException ex) { |
| invalidClassPathEntryWarning(cp[i], earFile.getURI(), anArchive); |
| continue; |
| } |
| if (f != null && f.isArchive() && anArchive.isModuleFile()) { |
| Archive archive = (Archive) f; |
| ModuleFile m = (ModuleFile) anArchive; |
| if (!ArchiveUtil.isValidDependency(archive, m)) |
| invalidDepedencyWarning(cp[i], archive, m); |
| } |
| } |
| } |
| |
| |
| protected void validateManifestLines(Archive anArchive) throws ValidationException { |
| if (anArchive == null) |
| return; |
| InputStream is = null; |
| try { |
| is = anArchive.getInputStream(J2EEConstants.MANIFEST_URI); |
| ManifestLineValidator lineVal = new ManifestLineValidator(is); |
| lineVal.validate(); |
| addErrorsIfNecessary(anArchive, lineVal); |
| } catch (FileNotFoundException ex) { |
| return; |
| } catch (IOException ex) { |
| handleManifestException(ex, anArchive); |
| } finally { |
| if (is != null) |
| try { |
| is.close(); |
| } catch (IOException ex) { |
| handleManifestException(ex, anArchive); |
| } |
| } |
| } |
| |
| protected void addErrorsIfNecessary(Archive anArchive, ManifestLineValidator mfVal) { |
| if (!mfVal.hasErrors()) |
| return; |
| IFile target = getManifestFile(anArchive); |
| if (!mfVal.endsWithLineBreak()) |
| addFileEndError(anArchive, mfVal, target); |
| int[] lines = mfVal.getLineNumbersExceedingLimit(); |
| for (int i = 0; i < lines.length; i++) { |
| addLineLengthError(anArchive, target, lines[i]); |
| } |
| } |
| |
| protected void addLineLengthError(Archive anArchive, IFile target, int lineNo) { |
| String[] args = new String[2]; |
| args[0] = Integer.toString(lineNo); |
| args[1] = anArchive.getURI(); |
| |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.MANIFEST_LINE_EXCEEDS_LENGTH_ERROR_, args); |
| |
| if( lineNo >= 0 ){ |
| addLocalizedError(tmp, target, MANIFEST_GROUP_NAME, lineNo ); |
| }else{ |
| addLocalizedError(tmp, target, MANIFEST_GROUP_NAME ); |
| } |
| |
| } |
| |
| protected void addFileEndError(Archive anArchive, ManifestLineValidator mfVal, IFile target) { |
| String[] args = new String[]{anArchive.getURI()}; |
| |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.MANIFEST_LINE_END_ERROR_, args); |
| |
| if (target != null) |
| addLocalizedError(tmp, getManifestFile(anArchive), MANIFEST_GROUP_NAME, mfVal.getLineCount()); |
| else |
| addLocalizedError(tmp, null, MANIFEST_GROUP_NAME); |
| } |
| |
| protected void handleManifestException(IOException ex, Archive anArchive) throws ValidationException { |
| J2EEPlugin.logError(ex); |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.ERROR_READING_MANIFEST_ERROR_, new String[]{anArchive.getURI()}); |
| IMessage message = new LocalizedMessage(IMessage.HIGH_SEVERITY, tmp); |
| throw new ValidationException(message, ex); |
| } |
| |
| /** |
| * Validates utiljar maps |
| */ |
| // public void validateUtilJarMaps(EARArtifactEdit edit, IVirtualComponent workbenchModule) { |
| // List utilJarModules = edit.getUtilityModuleReferences(); |
| // if (!utilJarModules.isEmpty() || !utilJarModules.isEmpty()) { |
| // for (int i = 0; i < utilJarModules.size(); i++) { |
| // IVirtualComponent aUtilJar = ((IVirtualReference) utilJarModules.get(i)).getReferencedComponent(); |
| // if (aUtilJar != null) { |
| // IProject project = J2EEPlugin.getWorkspace().getRoot().getProject(aUtilJar.getProject().getName()); |
| // if (project != null) { |
| // if (!project.exists()) { |
| // String[] params = new String[]{project.getName(), aUtilJar.getRuntimePath().toString(), earHelper.getProject().getName()}; |
| // addWarning(getBaseName(), PROJECT_DOES_NOT_EXIST_WARN_, params); |
| // } else { |
| // //validateModuleProjectForValidServerTarget(project); |
| // if (!project.isOpen()) { |
| // String[] params = new String[]{project.getName()}; |
| // addWarning(getBaseName(), PROJECT_IS_CLOSED_WARN_, params); |
| // } |
| // } |
| // } |
| // } |
| // } |
| // } |
| // validateDuplicateUtilJars(edit,workbenchModule); |
| // validateUtilJarNameCollision(edit,workbenchModule); |
| // validateUtilJarContainsNoSpaces(edit,workbenchModule); |
| // |
| // }// validateUtilJarMaps |
| |
| /** |
| * Checks if the util jar contains spaces or not. |
| * |
| * @param EAREditModel |
| * earEditModel - The ear editmodel. |
| */ |
| protected void validateUtilJarContainsNoSpaces(EARArtifactEdit edit, IVirtualComponent module) { |
| IVirtualReference[] utilJars = edit.getUtilityModuleReferences(); |
| |
| if (utilJars == null) |
| return; |
| |
| for (int i = 0; i < utilJars.length; i++) { |
| IVirtualReference utilModule = utilJars[i]; |
| if (utilModule != null) { |
| String uri = ModuleURIUtil.fullyQualifyURI(project).toString(); |
| if (uri != null && uri.indexOf(" ") != -1) { //$NON-NLS-1$ |
| String[] params = new String[1]; |
| params[0] = uri; |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.URI_CONTAINS_SPACES_ERROR_, params); |
| addLocalizedError(tmp, appDD); |
| }// if |
| }// if |
| }// for |
| |
| }// validateUtilJarContainsNoSpaces |
| |
| /** |
| * Validates if the a util jar has the same name as another module. |
| * |
| * @param EAREditModel |
| * earEditModel - The ear editmodel. |
| */ |
| // protected void validateUtilJarNameCollision(EARArtifactEdit edit, IVirtualComponent module) { |
| // List utilJars = edit.getUtilityModuleReferences(); |
| // if (utilJars == null) |
| // return; |
| // for (int i = 0; i < utilJars.size(); i++) { |
| // UtilityJARMapping utilModule = (UtilityJARMapping) utilJars.get(i); |
| // |
| // if (utilModule != null) { |
| // if (edit.uriExists(utilModule.getUri())) { |
| // |
| // String[] params = new String[]{utilModule.getUri(), module.getName()}; |
| // addError(getBaseName(), MESSAGE_UTIL_URI_NAME_COLLISION_ERROR_, params); |
| // |
| // } else if (utilModule.getProjectName() != null || utilModule.getProjectName().length() != 0) { |
| // if (edit.uriExists(utilModule.getUri())) { |
| // String[] params = new String[]{utilModule.getUri(), utilModule.getProjectName()}; |
| // addError(getBaseName(), MESSAGE_UTIL_PROJECT_NAME_COLLISION_ERROR_, params); |
| // } |
| // } |
| // } |
| // } |
| // } |
| |
| |
| |
| /** |
| * validate is there are duplicate util jars. |
| * |
| * @param EAREditModel |
| * earEditModel - The ear editmodel |
| */ |
| protected void validateDuplicateUtilJars(EARArtifactEdit edit, IVirtualComponent module) { |
| IVirtualReference[] utilJars = edit.getUtilityModuleReferences(); |
| Set visitedUtilUri = new HashSet(); |
| if (utilJars == null) |
| return; |
| for (int i = 0; i < utilJars.length; i++) { |
| IVirtualReference utilModule = utilJars[i]; |
| if (utilModule != null) { |
| String uri = ModuleURIUtil.fullyQualifyURI(project).toString(); |
| if (visitedUtilUri.contains(uri)) { |
| String compName = module.getName(); |
| duplicateUtilError(module.getName(),uri, compName); |
| } else |
| visitedUtilUri.add(uri); |
| } // if |
| } // for |
| } // validateModuleMapsDuplicateUtil |
| |
| /** |
| * Creates an error for duplicate util jars. |
| * |
| * @param String |
| * earProjectName - The ears project name. |
| * @param String |
| * moduleUri - The modules uri. |
| * @param String |
| * projectName - The project name. |
| */ |
| protected void duplicateUtilError(String earProjectName, String moduleUri, String projectName) { |
| String[] params = new String[3]; |
| params[0] = projectName; |
| params[1] = earProjectName; |
| params[2] = moduleUri; |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.DUPLICATE_UTILJAR_FOR_PROJECT_NAME_ERROR_, params); |
| |
| addLocalizedError(tmp, null); |
| }// duplicateUtilError |
| |
| public void validateModuleMaps(IVirtualComponent component) { |
| IVirtualFile ddFile = component.getRootFolder().getFile(J2EEConstants.APPLICATION_DD_URI); |
| if( ddFile.exists()){ |
| EList modules = appDD.getModules(); |
| if (!modules.isEmpty()) { |
| EARArtifactEdit edit = null; |
| try{ |
| edit = EARArtifactEdit.getEARArtifactEditForRead( component.getProject() ); |
| |
| for (int i = 0; i < modules.size(); i++) { |
| Module module = (Module) modules.get(i); |
| String uri = module.getUri(); |
| IVirtualComponent referencedComp = edit.getModuleByManifestURI( uri ); |
| if( referencedComp == null ){ |
| String[] params = new String[]{uri, component.getProject().getName()}; |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.MISSING_PROJECT_FORMODULE_WARN_, params); |
| |
| addLocalizedWarning(tmp, null); |
| } |
| validateModuleURIExtension(module); |
| } |
| }finally{ |
| if( edit != null ) |
| edit.dispose(); |
| } |
| } |
| } |
| } |
| |
| |
| protected void validateModuleURIExtension(Module module) { |
| String newUri = module.getUri(); |
| if (newUri != null && newUri.length() > 0) { |
| if (module instanceof EjbModule && !newUri.endsWith(IJ2EEModuleConstants.JAR_EXT)) { |
| String[] params = new String[1]; |
| params[0] = module.getUri(); |
| IResource target = earHelper.getProject().getFile(ArchiveConstants.APPLICATION_DD_URI); |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.INVALID_URI_FOR_MODULE_ERROR_, params); |
| addLocalizedWarning(tmp, target); |
| } else if (module instanceof WebModule && !newUri.endsWith(IJ2EEModuleConstants.WAR_EXT)) { |
| String[] params = new String[1]; |
| params[0] = module.getUri(); |
| IResource target = earHelper.getProject().getFile(ArchiveConstants.APPLICATION_DD_URI); |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.INVALID_URI_FOR_MODULE_ERROR_, params); |
| addLocalizedWarning(tmp, target); |
| } |
| } |
| } |
| |
| |
| @Override |
| public void cleanup(IReporter reporter) { |
| if (earHelper != null) |
| earHelper.closeEARFile(); |
| super.cleanup(reporter); |
| } |
| |
| @Override |
| public void cleanup() { |
| |
| } |
| |
| protected IFile getManifestFile(Archive anArchive) { |
| URIConverter conv = anArchive.getResourceSet().getURIConverter(); |
| if (conv instanceof WorkbenchURIConverter) { |
| WorkbenchURIConverter wbConv = (WorkbenchURIConverter) conv; |
| IContainer input = wbConv.getInputContainer(); |
| if (input == null) |
| return null; |
| IProject p = input.getProject(); |
| if (p == null || JemProjectUtilities.isBinaryProject(p)) |
| return null; |
| IFile result = J2EEProjectUtilities.getManifestFile(p, false); |
| if (result != null && result.exists()) |
| return result; |
| } |
| return null; |
| } |
| |
| /** |
| * Checks if the nature is consistent with doc type. |
| */ |
| protected void validateDocType(EnterpriseArtifactEdit edit,IVirtualComponent module) { |
| if (edit == null) |
| return; |
| if (edit.getJ2EEVersion() >= J2EEVersionConstants.J2EE_1_3_ID && appDD.getVersionID() < J2EEVersionConstants.J2EE_1_3_ID) { |
| String[] params = new String[3]; |
| params[0] = DOCTYPE_1_2; |
| params[1] = getResourceName(); |
| params[2] = DOCTYPE_1_3; |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.EAR_INVALID_DOC_TYPE_ERROR_, params); |
| addLocalizedError(tmp, appDD); |
| } else if (edit.getJ2EEVersion() < J2EEVersionConstants.J2EE_1_3_ID && appDD.getVersionID() >= J2EEVersionConstants.J2EE_1_3_ID) { |
| String[] params = new String[3]; |
| params[0] = DOCTYPE_1_3; |
| params[1] = getResourceName(); |
| params[2] = DOCTYPE_1_2; |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.EAR_INVALID_DOC_TYPE_ERROR_, params); |
| addLocalizedError(tmp, appDD); |
| } |
| } |
| |
| /** |
| * Validates that conflicting jar does not exist in the ear project. |
| */ |
| public void validateUriAlreadyExistsInEar(EARArtifactEdit edit,IVirtualComponent component) { |
| IVirtualReference[] modules = edit.getJ2EEModuleReferences(); |
| if (modules == null) |
| return; |
| for (int i = 0; i < modules.length; i++) { |
| IVirtualReference reference = modules[i]; |
| IVirtualComponent module = reference.getReferencedComponent(); |
| if (module != null && module.getRootFolder().getRuntimePath() != null) { |
| IProject currentEARProject = earHelper.getProject(); |
| try { |
| IFile exFile = currentEARProject.getFile(module.getRootFolder().getRuntimePath()); |
| if (exFile != null && exFile.exists()) { |
| String[] params = new String[2]; |
| params[0] = module.getRootFolder().getRuntimePath().toString(); |
| params[1] = currentEARProject.getName(); |
| String tmp = NLS.bind(EARValidationMessageResourceHandler.URI_ALREADY_EXISTS_IN_EAR_WARN_, params); |
| addLocalizedWarning(tmp, appDD); |
| } |
| } catch (IllegalArgumentException iae) { |
| J2EEPlugin.logError(iae); |
| } |
| } |
| } |
| } |
| |
| @Override |
| protected void removeAllMessages(EObject eObject, String groupName) { |
| Resource res = eObject.eResource(); |
| if(res != null) { |
| IFile file = WorkbenchResourceHelper.getFile(res); |
| if(file != null) |
| _reporter.removeMessageSubset(this,file,groupName); |
| } |
| } |
| |
| }// UIEarValidator |
