/*
* 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.felix.http.whiteboard.internal.manager;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.Servlet;
import org.apache.felix.http.api.ExtHttpService;
import org.apache.felix.http.base.internal.logger.SystemLogger;
import org.apache.felix.http.whiteboard.HttpWhiteboardConstants;
import org.apache.felix.http.whiteboard.internal.manager.HttpContextManager.HttpContextHolder;
import org.osgi.framework.Bundle;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceReference;
import org.osgi.service.http.HttpContext;
import org.osgi.service.http.HttpService;
public final class ExtenderManager
{
static final String TYPE_FILTER = "f";
static final String TYPE_SERVLET = "s";
private HttpService httpService;
private final Map<String, AbstractMapping> mapping;
private final HttpContextManager contextManager;
public ExtenderManager()
{
this.mapping = new HashMap<String, AbstractMapping>();
this.contextManager = new HttpContextManager();
}
static boolean isEmpty(final String value)
{
return value == null || value.length() == 0;
}
private String getStringProperty(ServiceReference ref, String key)
{
Object value = ref.getProperty(key);
return (value instanceof String) ? (String)value : null;
}
private boolean getBooleanProperty(ServiceReference ref, String key)
{
Object value = ref.getProperty(key);
if (value instanceof String)
{
return Boolean.valueOf((String) value);
}
else if (value instanceof Boolean)
{
return ((Boolean) value).booleanValue();
}
return false;
}
private int getIntProperty(ServiceReference ref, String key, int defValue)
{
Object value = ref.getProperty(key);
if (value == null) {
return defValue;
}
try {
return Integer.parseInt(value.toString());
} catch (Exception e) {
return defValue;
}
}
private void addInitParams(ServiceReference ref, AbstractMapping mapping)
{
for (String key : ref.getPropertyKeys()) {
if (key.startsWith(HttpWhiteboardConstants.INIT_PREFIX)) {
String paramKey = key.substring(HttpWhiteboardConstants.INIT_PREFIX.length());
String paramValue = getStringProperty(ref, key);
if (paramValue != null) {
mapping.getInitParams().put(paramKey, paramValue);
}
}
}
}
public void add(HttpContext service, ServiceReference ref)
{
String contextId = getStringProperty(ref, HttpWhiteboardConstants.CONTEXT_ID);
if (!isEmpty(contextId))
{
boolean shared = getBooleanProperty(ref, HttpWhiteboardConstants.CONTEXT_SHARED);
Bundle bundle = shared ? null : ref.getBundle();
Collection<AbstractMapping> mappings = this.contextManager.addHttpContext(bundle, contextId, service);
for (AbstractMapping mapping : mappings)
{
registerMapping(mapping);
}
}
else
{
SystemLogger.debug("Ignoring HttpContext Service " + ref + ", " + HttpWhiteboardConstants.CONTEXT_ID
+ " is missing or empty");
}
}
public void remove(HttpContext service)
{
Collection<AbstractMapping> mappings = this.contextManager.removeHttpContext(service);
if (mappings != null)
{
for (AbstractMapping mapping : mappings)
{
unregisterMapping(mapping);
}
}
}
private void getHttpContext(AbstractMapping mapping, ServiceReference ref)
{
Bundle bundle = ref.getBundle();
String contextId = getStringProperty(ref, HttpWhiteboardConstants.CONTEXT_ID);
this.contextManager.getHttpContext(bundle, contextId, mapping);
}
private void ungetHttpContext(AbstractMapping mapping, ServiceReference ref)
{
Bundle bundle = ref.getBundle();
String contextId = getStringProperty(ref, HttpWhiteboardConstants.CONTEXT_ID);
this.contextManager.ungetHttpContext(bundle, contextId, mapping);
}
public void add(Filter service, ServiceReference ref)
{
int ranking = getIntProperty(ref, Constants.SERVICE_RANKING, 0);
String pattern = getStringProperty(ref, HttpWhiteboardConstants.PATTERN);
if (isEmpty(pattern)) {
SystemLogger.debug("Ignoring Filter Service " + ref + ", " + HttpWhiteboardConstants.PATTERN
+ " is missing or empty");
return;
}
FilterMapping mapping = new FilterMapping(ref.getBundle(), service, pattern, ranking);
getHttpContext(mapping, ref);
addInitParams(ref, mapping);
addMapping(TYPE_FILTER, ref, mapping);
}
public void add(Servlet service, ServiceReference ref)
{
String alias = getStringProperty(ref, HttpWhiteboardConstants.ALIAS);
if (isEmpty(alias))
{
SystemLogger.debug("Ignoring Servlet Service " + ref + ", " + HttpWhiteboardConstants.ALIAS
+ " is missing or empty");
return;
}
ServletMapping mapping = new ServletMapping(ref.getBundle(), service, alias);
getHttpContext(mapping, ref);
addInitParams(ref, mapping);
addMapping(TYPE_SERVLET, ref, mapping);
}
public void removeFilter(ServiceReference ref)
{
removeMapping(TYPE_FILTER, ref);
}
public void removeServlet(ServiceReference ref)
{
removeMapping(TYPE_SERVLET, ref);
}
public synchronized void setHttpService(HttpService service)
{
this.httpService = service;
if (this.httpService instanceof ExtHttpService) {
SystemLogger.info("Detected extended HttpService. Filters enabled.");
} else {
SystemLogger.info("Detected standard HttpService. Filters disabled.");
}
registerAll();
}
public synchronized void unsetHttpService()
{
unregisterAll();
this.httpService = null;
}
public synchronized void unregisterAll()
{
AbstractMapping[] mappings = null;
HttpService service;
synchronized (this) {
service = this.httpService;
if (service != null) {
Collection<AbstractMapping> values = this.mapping.values();
mappings = values.toArray(new AbstractMapping[values.size()]);
}
}
if (mappings != null) {
for (AbstractMapping mapping : mappings) {
mapping.unregister(service);
}
}
}
private synchronized void registerAll()
{
AbstractMapping[] mappings = null;
HttpService service;
synchronized (this) {
service = this.httpService;
if (service != null) {
Collection<AbstractMapping> values = this.mapping.values();
mappings = values.toArray(new AbstractMapping[values.size()]);
}
}
if (mappings != null) {
for (AbstractMapping mapping : mappings) {
mapping.register(service);
}
}
}
private synchronized void addMapping(final String servType, ServiceReference ref, AbstractMapping mapping)
{
this.mapping.put(ref.getProperty(Constants.SERVICE_ID).toString() + servType, mapping);
this.registerMapping(mapping);
}
private synchronized void removeMapping(final String servType, ServiceReference ref)
{
AbstractMapping mapping = this.mapping.remove(ref.getProperty(Constants.SERVICE_ID).toString() + servType);
if (mapping != null)
{
ungetHttpContext(mapping, ref);
unregisterMapping(mapping);
}
}
private void registerMapping(AbstractMapping mapping)
{
HttpService httpService = this.httpService;
if (httpService != null)
{
mapping.register(httpService);
}
}
private void unregisterMapping(AbstractMapping mapping)
{
HttpService httpService = this.httpService;
if (httpService != null)
{
mapping.unregister(httpService);
}
}
/**
* Returns
* {@link org.apache.felix.http.whiteboard.internal.manager.HttpContextManager.HttpContextHolder}
* instances of HttpContext services.
*
* @return
*/
Map<String, HttpContextHolder> getHttpContexts()
{
return this.contextManager.getHttpContexts();
}
/**
* Returns {@link AbstractMapping} instances for which there is no
* registered HttpContext as desired by the context ID.
*/
Map<String, Set<AbstractMapping>> getOrphanMappings()
{
return this.contextManager.getOrphanMappings();
}
/**
* Returns mappings indexed by there owning OSGi service.
*/
Map<String, AbstractMapping> getMappings()
{
synchronized (this)
{
return new HashMap<String, AbstractMapping>(this.mapping);
}
}
}