| package org.apache.fulcrum.parser; |
| |
| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| import javax.servlet.ServletException; |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.Part; |
| |
| import org.apache.avalon.framework.configuration.Configurable; |
| import org.apache.avalon.framework.configuration.Configuration; |
| import org.apache.avalon.framework.configuration.ConfigurationException; |
| import org.apache.avalon.framework.logger.AbstractLogEnabled; |
| import org.apache.avalon.framework.logger.LogEnabled; |
| import org.apache.avalon.framework.service.ServiceException; |
| import org.apache.avalon.framework.service.ServiceManager; |
| import org.apache.avalon.framework.service.Serviceable; |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.commons.pool2.impl.GenericObjectPoolConfig; |
| import org.apache.fulcrum.parser.ValueParser.URLCaseFolding; |
| import org.apache.fulcrum.parser.pool.BaseValueParserFactory; |
| import org.apache.fulcrum.parser.pool.BaseValueParserPool; |
| import org.apache.fulcrum.parser.pool.CookieParserFactory; |
| import org.apache.fulcrum.parser.pool.CookieParserPool; |
| import org.apache.fulcrum.parser.pool.DefaultParameterParserFactory; |
| import org.apache.fulcrum.parser.pool.DefaultParameterParserPool; |
| import org.apache.fulcrum.pool.PoolException; |
| import org.apache.fulcrum.pool.PoolService; |
| |
| |
| /** |
| * The DefaultParserService provides the default implementation |
| * of a {@link ParserService}. |
| * |
| * @author <a href="mailto:tv@apache.org">Thomas Vandahl</a> |
| * @version $Id: BaseValueParser.java 542062 2007-05-28 00:29:43Z seade $ |
| */ |
| public class DefaultParserService |
| extends AbstractLogEnabled |
| implements ParserService, |
| Configurable, Serviceable |
| { |
| |
| /** The folding from the configuration */ |
| private URLCaseFolding folding = URLCaseFolding.NONE; |
| |
| /** The automaticUpload setting from the configuration */ |
| private boolean automaticUpload = AUTOMATIC_DEFAULT; |
| |
| /** |
| * The parameter encoding to use when parsing parameter strings |
| */ |
| private String parameterEncoding = PARAMETER_ENCODING_DEFAULT; |
| |
| /** |
| * reintroduced fulcrum, may be used in the case, that |
| * commons pool2 is not configured exactly as needed properly as fast fall back. |
| */ |
| private boolean useFulcrumPool = FULCRUM_POOL_DEFAULT; |
| |
| |
| /** |
| * The Fulcrum pool service component to use (optional), by default it is deactivated and commons pool is used. |
| */ |
| private PoolService fulcrumPoolService = null; |
| |
| /** |
| * Use commons pool to manage value parsers |
| */ |
| private BaseValueParserPool valueParserPool; |
| |
| /** |
| * Use commons pool to manage parameter parsers |
| */ |
| private DefaultParameterParserPool parameterParserPool; |
| |
| /** |
| * Use commons pool to manage cookie parsers |
| */ |
| private CookieParserPool cookieParserPool; |
| |
| |
| public DefaultParserService() |
| { |
| } |
| |
| public DefaultParserService(GenericObjectPoolConfig<?> config) |
| { |
| // init the pool |
| valueParserPool |
| = new BaseValueParserPool(new BaseValueParserFactory(), config); |
| |
| parameterParserPool |
| = new DefaultParameterParserPool(new DefaultParameterParserFactory(), config); |
| } |
| |
| |
| /** |
| * Get the character encoding that will be used by this ValueParser. |
| */ |
| @Override |
| public String getParameterEncoding() |
| { |
| return parameterEncoding; |
| } |
| |
| /** |
| * Set the character encoding that will be used by this ValueParser. |
| */ |
| public void setParameterEncoding(String encoding) |
| { |
| parameterEncoding = encoding; |
| } |
| |
| /** |
| * Trims the string data and applies the conversion specified in |
| * the property given by URL_CASE_FOLDING. It returns a new |
| * string so that it does not destroy the value data. |
| * |
| * @param value A String to be processed. |
| * @return A new String converted to the case as specified by URL_CASE_FOLDING and trimmed. |
| */ |
| @Override |
| public String convert(String value) |
| { |
| return convertAndTrim(value); |
| } |
| |
| /** |
| * Convert a String value according to the url-case-folding property. |
| * |
| * @param value the String to convert |
| * |
| * @return a new String. |
| * |
| */ |
| @Override |
| public String convertAndTrim(String value) |
| { |
| return convertAndTrim(value, getUrlFolding()); |
| } |
| |
| /** |
| * A static version of the convert method, which |
| * trims the string data and applies the conversion specified in |
| * the property given by URL_CASE_FOLDING. It returns a new |
| * string so that it does not destroy the value data. |
| * |
| * @param value A String to be processed. |
| * @return A new String converted to lowercase and trimmed. |
| */ |
| @Override |
| public String convertAndTrim(String value, URLCaseFolding fold) |
| { |
| if (value == null) |
| { |
| return ""; |
| } |
| |
| String tmp = value.trim(); |
| |
| switch (fold) |
| { |
| case NONE: |
| { |
| break; |
| } |
| |
| case LOWER: |
| { |
| tmp = tmp.toLowerCase(); |
| break; |
| } |
| |
| case UPPER: |
| { |
| tmp = tmp.toUpperCase(); |
| break; |
| } |
| |
| default: |
| { |
| getLogger().error("Passed " + fold + " as fold rule, which is illegal!"); |
| break; |
| } |
| } |
| return tmp; |
| } |
| |
| /** |
| * Gets the folding value from the configuration |
| * |
| * @return The current Folding Value |
| */ |
| @Override |
| public URLCaseFolding getUrlFolding() |
| { |
| return folding; |
| } |
| |
| /** |
| * Gets the automaticUpload value from the configuration |
| * |
| * @return The current automaticUpload Value |
| */ |
| @Override |
| public boolean getAutomaticUpload() |
| { |
| return automaticUpload; |
| } |
| |
| /** |
| * Parse the given request for uploaded files |
| * |
| * @return A list of {@link javax.servlet.http.Part}s |
| * |
| * @throws ServiceException if parsing fails |
| */ |
| @Override |
| public List<Part> parseUpload(HttpServletRequest request) throws ServiceException |
| { |
| try |
| { |
| return new ArrayList<Part>(request.getParts()); |
| } |
| catch (IOException | ServletException e) |
| { |
| throw new ServiceException(ParserService.ROLE, "Could not parse upload request", e); |
| } |
| } |
| |
| /** |
| * Get a {@link ValueParser} instance from the service. Use the |
| * given Class to create the object. |
| * |
| * @return An object that implements ValueParser |
| * |
| * @throws InstantiationException if the instance could not be created |
| */ |
| @SuppressWarnings("unchecked") |
| @Override |
| public <P extends ValueParser> P getParser(Class<P> ppClass) throws InstantiationException |
| { |
| P vp = null; |
| |
| try |
| { |
| if (useFulcrumPool) { |
| try |
| { |
| P parserInstance = (P) fulcrumPoolService.getInstance(ppClass); |
| vp = parserInstance; |
| } |
| catch (PoolException pe) |
| { |
| throw new InstantiationException("Parser class '" + ppClass + "' is illegal. " + pe.getMessage()); |
| } |
| } else if ( ppClass.equals(BaseValueParser.class) ) |
| { |
| BaseValueParser parserInstance = null; |
| try { |
| parserInstance = valueParserPool.borrowObject(); |
| vp = (P) parserInstance; |
| if (vp == null) { |
| throw new InstantiationException("Could not borrow object from pool: " + valueParserPool); |
| } |
| } catch (Exception e) { |
| try { |
| valueParserPool.invalidateObject(parserInstance); |
| parserInstance = null; |
| } catch (Exception e1) { |
| throw new InstantiationException("Could not invalidate object " + e1.getMessage() + " after exception: " + e.getMessage()); |
| } |
| } |
| } else if ( ppClass.equals(DefaultParameterParser.class) ) |
| { |
| DefaultParameterParser parserInstance = null; |
| try { |
| parserInstance = parameterParserPool.borrowObject(); |
| vp = (P) parserInstance; |
| if (vp == null) { |
| throw new InstantiationException("Could not borrow object from pool: " + parameterParserPool); |
| } |
| } catch (Exception e) { |
| try { |
| parameterParserPool.invalidateObject(parserInstance); |
| parserInstance = null; |
| } catch (Exception e1) { |
| throw new InstantiationException("Could not invalidate object " + e1.getMessage() + " after exception: " + e.getMessage()); |
| } |
| } |
| } else if ( ppClass.equals(DefaultCookieParser.class) ) |
| { |
| DefaultCookieParser parserInstance = null; |
| try { |
| parserInstance = cookieParserPool.borrowObject(); |
| vp = (P) parserInstance; |
| if (vp == null) { |
| throw new InstantiationException("Could not borrow object from pool: " + cookieParserPool); |
| } |
| } catch (Exception e) { |
| try { |
| cookieParserPool.invalidateObject(parserInstance); |
| parserInstance = null; |
| } catch (Exception e1) { |
| throw new InstantiationException("Could not invalidate object " + e1.getMessage() + " after exception: " + e.getMessage()); |
| } |
| } |
| } |
| |
| if (vp != null && vp instanceof ParserServiceSupport ) { |
| ((ParserServiceSupport)vp).setParserService(this); |
| } else { |
| throw new InstantiationException("Could not set parser"); |
| } |
| if (vp instanceof LogEnabled) |
| { |
| ((LogEnabled)vp).enableLogging(getLogger().getChildLogger(ppClass.getSimpleName())); |
| } |
| } |
| catch (ClassCastException x) |
| { |
| throw new InstantiationException("Parser class '" + ppClass + "' is illegal. " + x.getMessage()); |
| } |
| |
| return vp; |
| } |
| |
| /** |
| * Clears the parse and puts it back into |
| * the pool service. This allows for pooling |
| * and recycling |
| * |
| * As we are not yet using org.apache.fulcrum.pool.Recyclable, we call insteda {@link ValueParser#dispose()}. |
| * |
| * @param parser The value parser to use |
| */ |
| @Override |
| public void putParser(ValueParser parser) |
| { |
| parser.clear(); |
| parser.dispose(); |
| |
| if (useFulcrumPool) { |
| |
| fulcrumPoolService.putInstance(parser); |
| |
| } else if( parser.getClass().equals(BaseValueParser.class) ) |
| { |
| valueParserPool.returnObject( (BaseValueParser) parser ); |
| |
| } else if ( parser.getClass().equals(DefaultParameterParser.class) || |
| parser instanceof DefaultParameterParser) |
| { |
| parameterParserPool.returnObject( (DefaultParameterParser) parser ); |
| |
| } else if ( parser.getClass().equals(DefaultCookieParser.class) || |
| parser instanceof DefaultCookieParser) |
| { |
| cookieParserPool.returnObject( (DefaultCookieParser) parser ); |
| |
| } else { |
| // log |
| getLogger().warn(parser.getClass() + " could not be put back into any pool exhausting some pool"); |
| // log even borrowed count of each pool?: cookieParserPool.getBorrowedCount()) |
| } |
| } |
| |
| /** |
| * Avalon component lifecycle method |
| * |
| * @param conf the configuration |
| * @throws ConfigurationException Generic exception |
| */ |
| @Override |
| public void configure(Configuration conf) throws ConfigurationException |
| { |
| String foldString = conf.getChild(URL_CASE_FOLDING_KEY).getValue(URLCaseFolding.NONE.name()).toLowerCase(); |
| |
| folding = URLCaseFolding.NONE; |
| |
| getLogger().debug("Setting folding from " + foldString); |
| |
| if (StringUtils.isNotEmpty(foldString)) |
| { |
| try |
| { |
| folding = URLCaseFolding.valueOf(foldString.toUpperCase()); |
| } |
| catch (IllegalArgumentException e) |
| { |
| getLogger().error("Got " + foldString + " from " + URL_CASE_FOLDING_KEY + " property, which is illegal!"); |
| throw new ConfigurationException("Value " + foldString + " is illegal!", e); |
| } |
| } |
| |
| parameterEncoding = conf.getChild(PARAMETER_ENCODING_KEY) |
| .getValue(PARAMETER_ENCODING_DEFAULT).toLowerCase(); |
| |
| automaticUpload = conf.getChild(AUTOMATIC_KEY).getValueAsBoolean(AUTOMATIC_DEFAULT); |
| |
| useFulcrumPool = conf.getChild(FULCRUM_POOL_KEY).getValueAsBoolean(FULCRUM_POOL_DEFAULT); |
| |
| if (useFulcrumPool) { |
| if (fulcrumPoolService == null) |
| { |
| // only for fulcrum pool, need to call internal service, if role pool service is set |
| throw new ConfigurationException("Fulcrum Pool is activated", new ServiceException(ParserService.ROLE, |
| "Fulcrum enabled Pool Service requires " + |
| PoolService.ROLE + " to be available")); |
| } |
| getLogger().info("Using Fulcrum Pool Service: "+ fulcrumPoolService); |
| } else { |
| // reset not used fulcrum pool |
| fulcrumPoolService = null; |
| |
| // Define the default configuration |
| GenericObjectPoolConfig config = new GenericObjectPoolConfig(); |
| config.setMaxIdle(DEFAULT_MAX_IDLE); |
| config.setMaxTotal(DEFAULT_POOL_CAPACITY); |
| |
| // init the pool |
| valueParserPool |
| = new BaseValueParserPool(new BaseValueParserFactory(), config); |
| |
| // init the pool |
| parameterParserPool |
| = new DefaultParameterParserPool(new DefaultParameterParserFactory(), config); |
| |
| // init the pool |
| cookieParserPool |
| = new CookieParserPool(new CookieParserFactory(), config); |
| |
| getLogger().info("Init Commons2 Pool Services.." ); |
| getLogger().info(valueParserPool.getClass().getName()); |
| getLogger().info(parameterParserPool.getClass().getName()); |
| getLogger().info(cookieParserPool.getClass().getName()); |
| } |
| |
| Configuration[] poolChildren = conf.getChild(POOL_KEY).getChildren(); |
| if (poolChildren.length > 0) { |
| GenericObjectPoolConfig genObjPoolConfig = new GenericObjectPoolConfig(); |
| genObjPoolConfig.setMaxIdle(DEFAULT_MAX_IDLE); |
| genObjPoolConfig.setMaxTotal(DEFAULT_POOL_CAPACITY); |
| for (Configuration poolConf : poolChildren) { |
| // use common pool2 configuration names |
| switch (poolConf.getName()) { |
| case "maxTotal": |
| int defaultCapacity = poolConf.getValueAsInteger(); |
| genObjPoolConfig.setMaxTotal(defaultCapacity); |
| break; |
| case "maxWaitMillis": |
| int maxWaitMillis = poolConf.getValueAsInteger(); |
| genObjPoolConfig.setMaxWaitMillis(maxWaitMillis); |
| break; |
| case "blockWhenExhausted": |
| boolean blockWhenExhausted = poolConf.getValueAsBoolean(); |
| genObjPoolConfig.setBlockWhenExhausted(blockWhenExhausted); |
| break; |
| case "maxIdle": |
| int maxIdle = poolConf.getValueAsInteger(); |
| genObjPoolConfig.setMaxIdle(maxIdle); |
| break; |
| case "minIdle": |
| int minIdle = poolConf.getValueAsInteger(); |
| genObjPoolConfig.setMinIdle(minIdle); |
| break; |
| case "testOnReturn": |
| boolean testOnReturn = poolConf.getValueAsBoolean(); |
| genObjPoolConfig.setTestOnReturn(testOnReturn); |
| break; |
| case "testOnBorrow": |
| boolean testOnBorrow = poolConf.getValueAsBoolean(); |
| genObjPoolConfig.setTestOnBorrow(testOnBorrow); |
| break; |
| case "testOnCreate": |
| boolean testOnCreate = poolConf.getValueAsBoolean(); |
| genObjPoolConfig.setTestOnCreate(testOnCreate); |
| break; |
| default: |
| |
| break; |
| } |
| } |
| // reinit the pools |
| valueParserPool.setConfig(genObjPoolConfig); |
| parameterParserPool.setConfig(genObjPoolConfig); |
| cookieParserPool.setConfig(genObjPoolConfig); |
| |
| getLogger().debug(valueParserPool.toString()); |
| getLogger().debug(parameterParserPool.toString()); |
| getLogger().debug(cookieParserPool.toString()); |
| } |
| |
| } |
| |
| // ---------------- Avalon Lifecycle Methods --------------------- |
| /** |
| * Avalon component lifecycle method |
| * |
| * @param manager The service manager instance |
| * @throws ServiceException generic exception |
| * |
| */ |
| @Override |
| public void service(ServiceManager manager) throws ServiceException |
| { |
| // only for fulcrum pool, need to call internal service, if role pool service is set |
| if (manager.hasService(PoolService.ROLE)) |
| { |
| fulcrumPoolService = (PoolService)manager.lookup(PoolService.ROLE); |
| } |
| // no check here, until configuration is read |
| } |
| } |
