/*
* 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.krakenapps.http.internal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.servlet.ServletContext;
import org.apache.felix.ipojo.ComponentInstance;
import org.apache.felix.ipojo.InstanceStateListener;
import org.krakenapps.http.KrakenHttpService;
import org.krakenapps.http.internal.service.HttpServiceFactory;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.http.HttpService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class HttpServiceController implements InstanceStateListener {
private final Logger logger = LoggerFactory.getLogger(HttpServiceController.class);
// customized
private HttpServiceTracker httpServiceTracker;
private ConcurrentMap<Long, KrakenHttpService> httpServiceMap;
private ConcurrentMap<String, Long> servletMap;
private ConcurrentMap<String, ComponentInstance> instanceMap;
private ConcurrentMap<String, String> aliasMap;
// original
private final BundleContext context;
private final Hashtable<String, Object> serviceProps;
// private ServiceRegistration serviceReg;
// stania added
private Map<String, ServiceRegistration> serviceRegs;
public HttpServiceController(BundleContext bundleContext) {
httpServiceMap = new ConcurrentHashMap<Long, KrakenHttpService>();
servletMap = new ConcurrentHashMap<String, Long>();
instanceMap = new ConcurrentHashMap<String, ComponentInstance>();
aliasMap = new ConcurrentHashMap<String, String>();
httpServiceTracker = new HttpServiceTracker(bundleContext, this);
// original
this.context = bundleContext;
// this.registry = new HandlerRegistry();
// this.dispatcher = new Dispatcher(this.registry);
this.serviceProps = new Hashtable<String, Object>();
// stania added
this.serviceRegs = new HashMap<String, ServiceRegistration>();
}
public void start() {
httpServiceTracker.open();
}
public void stop() {
httpServiceTracker.close();
}
public void registerHttpService(long serviceId, KrakenHttpService service) {
// called by tracker
logger.info("new http service registered: " + serviceId);
httpServiceMap.put(serviceId, service);
}
public void unregisterHttpService(long serviceId) {
logger.info("http service unregistered: " + serviceId);
List<String> removeList = new ArrayList<String>();
// find remove target servlet component
for (String instanceName : servletMap.keySet()) {
long mappedId = servletMap.get(instanceName);
if (serviceId == mappedId) {
removeList.add(instanceName);
}
}
// remove from map
for (String instanceName : removeList) {
ComponentInstance instance = instanceMap.get(instanceName);
instance.dispose(); // unregisterServlet will be called.
}
httpServiceMap.remove(serviceId);
}
public void setProperties(Hashtable<String, Object> props) {
this.serviceProps.clear();
this.serviceProps.putAll(props);
// stania: this can be different from original semantics
// this may need servletContext to set serviceProps
for (ServiceRegistration reg: serviceRegs.values()) {
reg.setProperties(this.serviceProps);
}
}
public void register(DispatcherServlet dispatcherServlet, ServletContext servletContext) {
// called by dispatcher servlet
HttpServiceFactory factory = new HttpServiceFactory(servletContext, dispatcherServlet.getHandlerRegistry());
String[] ifaces = new String[] { HttpService.class.getName(),
KrakenHttpService.class.getName() };
// add httpservice.name and bundle.id attribute for http service registration
Hashtable<String, Object> props = new Hashtable<String, Object>();
props.putAll(serviceProps);
String serverName = (String) servletContext.getAttribute("httpservice.name");
props.put("httpservice.name", serverName);
// register http service (OSGi service registration)
serviceRegs.put(serverName, this.context.registerService(ifaces, factory, props));
}
public void unregister(DispatcherServlet dispatcherServlet) {
String serverName = (String) dispatcherServlet.getServletContext().getAttribute("httpservice.name");
if (!serviceRegs.containsKey(serverName)) {
return;
}
ServiceRegistration serviceReg = null;
try {
serviceReg = serviceRegs.get(serverName);
serviceReg.unregister();
} finally {
if (serviceReg != null)
serviceRegs.remove(serverName);
}
}
@Override
public void stateChanged(ComponentInstance instance, int state) {
if (instance.getState() == ComponentInstance.DISPOSED) {
System.out.println(instance.getInstanceName() + " - component instance disposed.");
unregisterServlet(instance);
}
}
private void unregisterServlet(ComponentInstance instance) {
Long httpServiceId = servletMap.get(instance.getInstanceName());
if (httpServiceId == null) {
System.out.println("http service not found");
return;
}
servletMap.remove(instance.getInstanceName());
instanceMap.remove(instance.getInstanceName());
String alias = aliasMap.remove(instance.getInstanceName());
// instance can be already unregistered when http service is unloading.
KrakenHttpService httpService = httpServiceMap.get(httpServiceId);
httpService.unregister(alias);
}
}