/*
* 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.
*/
package org.apache.shiro.web.config;
import org.apache.shiro.config.Ini;
import org.apache.shiro.config.IniFactorySupport;
import org.apache.shiro.config.IniSecurityManagerFactory;
import org.apache.shiro.config.ReflectionBuilder;
import org.apache.shiro.util.CollectionUtils;
import org.apache.shiro.util.Factory;
import org.apache.shiro.web.filter.mgt.FilterChainManager;
import org.apache.shiro.web.filter.mgt.FilterChainResolver;
import org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.Filter;
import javax.servlet.FilterConfig;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* A {@link Factory} that creates {@link FilterChainResolver} instances based on {@link Ini} configuration.
*
* @author The Apache Shiro Project (shiro-dev@incubator.apache.org)
* @since 1.0
*/
public class IniFilterChainResolverFactory extends IniFactorySupport<FilterChainResolver> {
public static final String FILTERS = "filters";
public static final String URLS = "urls";
private static transient final Logger log = LoggerFactory.getLogger(IniFilterChainResolverFactory.class);
private FilterConfig filterConfig;
private Map<String, ?> defaultBeans;
public IniFilterChainResolverFactory() {
super();
}
public IniFilterChainResolverFactory(Ini ini) {
super(ini);
}
public IniFilterChainResolverFactory(Ini ini, Map<String, ?> defaultBeans) {
this(ini);
this.defaultBeans = defaultBeans;
}
public FilterConfig getFilterConfig() {
return filterConfig;
}
public void setFilterConfig(FilterConfig filterConfig) {
this.filterConfig = filterConfig;
}
protected FilterChainResolver createInstance(Ini ini) {
FilterChainResolver filterChainResolver = createDefaultInstance();
if (filterChainResolver instanceof PathMatchingFilterChainResolver) {
PathMatchingFilterChainResolver resolver = (PathMatchingFilterChainResolver) filterChainResolver;
FilterChainManager manager = resolver.getFilterChainManager();
buildChains(manager, ini);
}
return filterChainResolver;
}
protected FilterChainResolver createDefaultInstance() {
FilterConfig filterConfig = getFilterConfig();
if (filterConfig != null) {
return new PathMatchingFilterChainResolver(filterConfig);
} else {
return new PathMatchingFilterChainResolver();
}
}
protected void buildChains(FilterChainManager manager, Ini ini) {
//filters section:
Ini.Section section = ini.getSection(FILTERS);
if (!CollectionUtils.isEmpty(section)) {
String msg = "The [{}] section has been deprecated and will be removed in a future release! Please " +
"move all object configuration (filters and all other objects) to the [{}] section.";
log.warn(msg, FILTERS, IniSecurityManagerFactory.MAIN_SECTION_NAME);
}
Map<String, Object> defaults = new LinkedHashMap<String, Object>();
Map<String, Filter> defaultFilters = manager.getFilters();
//now let's see if there are any object defaults in addition to the filters
//these can be used to configure the filters:
//create a Map of objects to use as the defaults:
if (!CollectionUtils.isEmpty(defaultFilters)) {
defaults.putAll(defaultFilters);
}
//User-provided objects must come _after_ the default filters - to allow the user-provided
//ones to override the default filters if necessary.
if (!CollectionUtils.isEmpty(this.defaultBeans)) {
defaults.putAll(this.defaultBeans);
}
Map<String, Filter> filters = getFilters(section, defaults);
//add the filters to the manager:
registerFilters(filters, manager);
//urls section:
section = ini.getSection(URLS);
createChains(section, manager);
}
protected void registerFilters(Map<String, Filter> filters, FilterChainManager manager) {
if (!CollectionUtils.isEmpty(filters)) {
boolean init = getFilterConfig() != null; //only call filter.init if there is a FilterConfig available
for (Map.Entry<String, Filter> entry : filters.entrySet()) {
String name = entry.getKey();
Filter filter = entry.getValue();
manager.addFilter(name, filter, init);
}
}
}
protected Map<String, Filter> getFilters(Map<String, String> section, Map<String, ?> defaults) {
Map<String, Filter> filters;
if (!CollectionUtils.isEmpty(section)) {
ReflectionBuilder builder = new ReflectionBuilder(defaults);
Map<String, ?> built = builder.buildObjects(section);
filters = extractFilters(built);
} else {
filters = extractFilters(defaults);
}
return filters;
}
private Map<String, Filter> extractFilters(Map<String, ?> objects) {
if (CollectionUtils.isEmpty(objects)) {
return null;
}
Map<String, Filter> filterMap = new LinkedHashMap<String, Filter>();
for (Map.Entry<String, ?> entry : objects.entrySet()) {
String key = entry.getKey();
Object value = entry.getValue();
if (value instanceof Filter) {
filterMap.put(key, (Filter) value);
}
}
return filterMap;
}
protected void createChains(Map<String, String> urls, FilterChainManager manager) {
if (CollectionUtils.isEmpty(urls)) {
if (log.isDebugEnabled()) {
log.debug("No urls to process.");
}
return;
}
if (log.isTraceEnabled()) {
log.trace("Before url processing.");
}
for (Map.Entry<String, String> entry : urls.entrySet()) {
String path = entry.getKey();
String value = entry.getValue();
manager.createChain(path, value);
}
}
}