| /******************************************************************************* |
| * Copyright (c) 2001, 2006 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.wsdl.validation.internal.ui.text; |
| |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.text.MessageFormat; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.MissingResourceException; |
| import java.util.ResourceBundle; |
| |
| import org.eclipse.wst.wsdl.validation.internal.ClassloaderWSDLValidatorDelegate; |
| import org.eclipse.wst.wsdl.validation.internal.IValidationMessage; |
| import org.eclipse.wst.wsdl.validation.internal.IValidationReport; |
| import org.eclipse.wst.wsdl.validation.internal.WSDLValidationConfiguration; |
| import org.eclipse.wst.wsdl.validation.internal.WSDLValidator; |
| import org.eclipse.wst.wsdl.validation.internal.logging.ILogger; |
| import org.eclipse.wst.wsdl.validation.internal.logging.LoggerFactory; |
| import org.eclipse.wst.wsdl.validation.internal.resolver.URIResolverDelegate; |
| import org.eclipse.wst.wsdl.validation.internal.wsdl11.ClassloaderWSDL11ValidatorDelegate; |
| import org.eclipse.wst.wsdl.validation.internal.wsdl11.WSDL11ValidatorDelegate; |
| import org.eclipse.wst.wsdl.validation.internal.xml.XMLCatalog; |
| import org.eclipse.wst.wsdl.validation.internal.xml.XMLCatalogEntityHolder; |
| |
| import com.ibm.wsdl.util.StringUtils; |
| |
| /** |
| * A commande line tool to run WSDL Validation on a single or multiple files. |
| * |
| * Options |
| * -schemaDir directory : a directory of schemas to load into the catalog |
| * -schema namespace location : a schema to load into the registry |
| * -wsdl11v classname namespace resourcebundle : register a WSDL 1.1 extension validator |
| * to load for the given namespace with the given resourcebundle |
| * -wsiv validatorClass namespace propertiesfile : register a WS-I validator |
| * -uriresolver URIResolverClass : register an extension URI resolver |
| */ |
| public class WSDLValidate |
| { |
| private final String FILE_PREFIX = "file:///"; |
| private static final String VALIDATOR_PROPERTIES = |
| org.eclipse.wst.wsdl.validation.internal.Constants.WSDL_VALIDATOR_PROPERTIES_FILE; |
| |
| protected static final String PARAM_WSDL11VAL = "-wsdl11v"; |
| protected static final String PARAM_EXTVAL = "-extv"; |
| protected static final String PARAM_SCHEMADIR = "-schemaDir"; |
| protected static final String PARAM_SCHEMA = "-schema"; |
| protected static final String PARAM_URIRESOLVER = "-uriresolver"; |
| protected static final String PARAM_LOGGER = "-logger"; |
| protected static final String PARAM_PROPERTY = "-D"; |
| protected static final String PARAM_VERBOSE = "-verbose"; |
| protected static final String PARAM_VERBOSE_SHORT = "-v"; |
| |
| private static final String STRING_EMPTY = ""; |
| private static final String STRING_SPACE = " "; |
| private static final String STRING_DASH = "-"; |
| |
| String workingdir = System.getProperty("user.dir"); |
| |
| //protected ResourceBundle resourceBundle; |
| |
| protected WSDLValidator wsdlValidator = null; |
| protected WSDLValidationConfiguration configuration = null; |
| protected List wsdlFiles = new ArrayList(); |
| protected boolean verbose = false; |
| protected ResourceBundle validatorRB = null; |
| |
| /** |
| * Constuctor. |
| */ |
| protected WSDLValidate() |
| { |
| wsdlValidator = new WSDLValidator(); |
| configuration = new WSDLValidationConfiguration(); |
| |
| try |
| { |
| validatorRB = ResourceBundle.getBundle(VALIDATOR_PROPERTIES); |
| } |
| catch (MissingResourceException e) |
| { |
| LoggerFactory.getInstance().getLogger().log("Validation failed: Unable to load the WSDL validator properties file.", ILogger.SEV_ERROR, e); |
| } |
| } |
| |
| /** |
| * Validate the files specified. |
| */ |
| protected void validate() |
| { |
| ILogger logger = LoggerFactory.getInstance().getLogger(); |
| |
| int numInvalid = 0; |
| |
| Iterator filesIter = wsdlFiles.iterator(); |
| while (filesIter.hasNext()) |
| { |
| String wsdlFile = (String)filesIter.next(); |
| IValidationReport valReport = validateFile(wsdlFile); |
| |
| if(valReport.hasErrors()) |
| { |
| numInvalid++; |
| logger.log(MessageFormat.format(WSDLValidateTextUIMessages._UI_FILE_INVALID, new Object[]{wsdlFile}), ILogger.SEV_INFO); |
| //logger.log(WSDLValidateTextUIMessages._UI_INFORMATION_DELIMITER, ILogger.SEV_ERROR); |
| logger.log(getMessages(valReport.getValidationMessages()), ILogger.SEV_INFO); |
| } |
| else if(verbose) |
| { |
| logger.log(MessageFormat.format(WSDLValidateTextUIMessages._UI_FILE_VALID, new Object[]{wsdlFile}), ILogger.SEV_VERBOSE); |
| } |
| } |
| |
| // Log the summary. |
| logger.log(MessageFormat.format(WSDLValidateTextUIMessages._UI_VALIDATION_SUMMARY, new Object[]{new Integer(wsdlFiles.size()), new Integer(numInvalid)}), ILogger.SEV_INFO); |
| } |
| |
| /** |
| * Run WSDL validation on a given file. |
| * |
| * @param filename |
| * The name of the file to validate. |
| * @throws Exception |
| */ |
| protected IValidationReport validateFile(String filename) |
| { |
| // Resolve the location of the file. |
| String filelocation = null; |
| try |
| { |
| URL fileURL = StringUtils.getURL(new URL(FILE_PREFIX + workingdir + "/"), filename); |
| filelocation = fileURL.toExternalForm(); |
| } |
| catch (MalformedURLException e) |
| { |
| // Do nothing. The WSDL validator will handle the error. |
| //LoggerFactory.getInstance().getLogger().log(MessageFormat.format(WSDLValidateTextUIMessages._ERROR_UNABLE_TO_READ_FILE, new Object[]{filename}), ILogger.SEV_ERROR); |
| } |
| |
| // Run validation on the file. |
| IValidationReport valReport = wsdlValidator.validate(filelocation, null, configuration); |
| return valReport; |
| } |
| |
| /** |
| * Returns a String with formatted output for a list of messages. |
| * |
| * @param messages |
| * The messages to get. |
| * @return |
| * A string with a formatted list of the messages. |
| */ |
| protected String getMessages(IValidationMessage[] messages) |
| { |
| StringBuffer outputBuffer = new StringBuffer(); |
| if (messages != null) |
| { |
| // create a list of messages that looks like |
| // ERROR 1:1 Error message content |
| int numMessages = messages.length; |
| String marker = null; |
| for (int i = 0; i < numMessages; i++) |
| { |
| IValidationMessage message = messages[i]; |
| int severity = message.getSeverity(); |
| if (severity == IValidationMessage.SEV_ERROR) |
| { |
| marker = WSDLValidateTextUIMessages._UI_ERROR_MARKER; |
| } |
| else if (severity == IValidationMessage.SEV_WARNING) |
| { |
| marker = WSDLValidateTextUIMessages._UI_WARNING_MARKER; |
| } |
| else |
| { |
| marker = STRING_EMPTY; |
| } |
| outputBuffer |
| .append(marker) |
| .append(STRING_SPACE) |
| .append(message.getLine()) |
| .append(":") |
| .append(message.getColumn()) |
| .append(STRING_SPACE) |
| .append(message.getMessage()); |
| if(i != numMessages -1) |
| { |
| outputBuffer.append("\n"); |
| } |
| } |
| } |
| return outputBuffer.toString(); |
| } |
| |
| /** |
| * The main entry point into the command line tool. |
| * Checks the command line arguments, registers the default validators and runs validation on the |
| * list of files. |
| * |
| * @param args - the arguments to the validator |
| */ |
| public static void main(String[] args) |
| { |
| // No arguments specified. Print usage. |
| if (args.length < 1) |
| { |
| System.err.println(WSDLValidateTextUIMessages._ERROR_WRONG_ARGUMENTS); |
| System.exit(0); |
| } |
| |
| WSDLValidate wsdlValidate = new WSDLValidate(); |
| wsdlValidate.parseArguments(args); |
| wsdlValidate.validate(); |
| } |
| |
| /** |
| * Parse the arguments specified for this WSDLValidate task and |
| * configure validation. |
| * |
| * @param args |
| * The arguments specified for this task. |
| */ |
| protected void parseArguments(String[] args) |
| { |
| int numargs = args.length; |
| |
| for (int i = 0; i < numargs; i++) |
| { |
| String param = args[i]; |
| |
| // Registering an extension validator or WSDL 1.1 extension validator. |
| if (param.equals(WSDLValidate.PARAM_WSDL11VAL) |
| || param.equals(WSDLValidate.PARAM_EXTVAL)) |
| { |
| String namespace = args[++i]; |
| if (!namespace.startsWith(WSDLValidate.STRING_DASH)) |
| { |
| String validatorClass = args[++i]; |
| |
| if (!validatorClass.startsWith(WSDLValidate.STRING_DASH)) |
| { |
| if(param.equalsIgnoreCase(WSDLValidate.PARAM_WSDL11VAL)) |
| { |
| WSDL11ValidatorDelegate delegate = new ClassloaderWSDL11ValidatorDelegate(validatorClass); |
| wsdlValidator.registerWSDL11Validator(namespace, delegate); |
| } |
| else if(param.equalsIgnoreCase(WSDLValidate.PARAM_EXTVAL)) |
| { |
| ClassloaderWSDLValidatorDelegate delegate = new ClassloaderWSDLValidatorDelegate(validatorClass); |
| wsdlValidator.registerWSDLExtensionValidator(namespace, delegate); |
| } |
| } |
| else |
| { |
| i--; |
| } |
| } |
| else |
| { |
| i--; |
| } |
| } |
| // Register a directory with schemas. |
| else if (param.equalsIgnoreCase(WSDLValidate.PARAM_SCHEMADIR)) |
| { |
| String xsdDir = args[++i]; |
| XMLCatalog.addSchemaDir(xsdDir); |
| } |
| // Register a schema. |
| // TODO: Replace this with an XML catalog. |
| else if (param.equalsIgnoreCase(WSDLValidate.PARAM_SCHEMA)) |
| { |
| String publicid = args[++i]; |
| String systemid = args[++i]; |
| XMLCatalog.addEntity(new XMLCatalogEntityHolder(publicid, systemid)); |
| } |
| // Register a URI resolver. |
| // TODO: Determine if this is appropriate for the text UI. |
| else if(param.equalsIgnoreCase(PARAM_URIRESOLVER)) |
| { |
| String resolverClass = args[++i]; |
| wsdlValidator.addURIResolver(new URIResolverDelegate(resolverClass, null).getURIResolver()); |
| } |
| // Configure the logger. |
| else if(param.equals(PARAM_LOGGER)) |
| { |
| String loggerClassString = args[++i]; |
| try |
| { |
| Class loggerClass = WSDLValidate.class.getClassLoader().loadClass(loggerClassString); |
| ILogger logger = (ILogger)loggerClass.newInstance(); |
| LoggerFactory.getInstance().setLogger(logger); |
| } |
| catch(Exception e) |
| { |
| System.err.println(MessageFormat.format(WSDLValidateTextUIMessages._ERROR_LOADING_LOGGER, new Object[]{loggerClassString})); |
| } |
| } |
| // Set properties. |
| else if(param.startsWith(PARAM_PROPERTY)) |
| { |
| int separator = param.indexOf('='); |
| String name = param.substring(2, separator); |
| String value = param.substring(separator+1); |
| configuration.setProperty(name, value); |
| } |
| // Set verbose; |
| else if(param.equals(PARAM_VERBOSE) || param.equals( PARAM_VERBOSE_SHORT)) |
| { |
| verbose = true; |
| } |
| // a file to validate |
| else |
| { |
| if(!param.startsWith(WSDLValidate.STRING_DASH)) |
| { |
| wsdlFiles.add(param); |
| } |
| } |
| } |
| } |
| } |