org.eclipse.virgo.snaps.core/src/main/java/org/eclipse/virgo/snaps/core/internal/SnapFactoryMonitor.java - virgo/org.eclipse.virgo.snaps - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008, 2010 VMware Inc.
  * 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:
  *   VMware Inc. - initial contribution
  *******************************************************************************/

 package org.eclipse.virgo.snaps.core.internal;

 import java.util.Collection;
 import java.util.Dictionary;
 import java.util.HashSet;
 import java.util.Hashtable;

 import javax.servlet.ServletContext;
 import javax.servlet.ServletException;

 import org.eclipse.virgo.medic.eventlog.EventLogger;
 import org.eclipse.virgo.snaps.core.RequestRouter;
 import org.eclipse.virgo.snaps.core.internal.Snap;
 import org.eclipse.virgo.snaps.core.SnapRegistry;
 import org.eclipse.virgo.snaps.core.internal.deployer.SnapFactory;
 import org.eclipse.virgo.util.osgi.ServiceRegistrationTracker;
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.Constants;
 import org.osgi.framework.InvalidSyntaxException;
 import org.osgi.framework.ServiceEvent;
 import org.osgi.framework.ServiceListener;
 import org.osgi.framework.ServiceReference;
 import org.osgi.framework.ServiceRegistration;
 import org.osgi.util.tracker.ServiceTracker;
 import org.osgi.util.tracker.ServiceTrackerCustomizer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 final class SnapFactoryMonitor implements ServiceTrackerCustomizer<SnapFactory, Object> {

     private final Logger logger = LoggerFactory.getLogger(this.getClass());

     private final BundleContext bundleContext;

     private final ServiceTracker<SnapFactory, Object> snapFactoryTracker;

     private final EventLogger eventLogger;

     private final SnapRegistry snapRegistry;

     public SnapFactoryMonitor(BundleContext bundleContext, EventLogger eventLogger, SnapRegistry snapRegistry) {
         this.bundleContext = bundleContext;
         this.snapFactoryTracker = new ServiceTracker<SnapFactory, Object>(bundleContext, SnapFactory.class, this);
         this.eventLogger = eventLogger;
         this.snapRegistry = snapRegistry;
     }

     public void start() {
         this.snapFactoryTracker.open();
     }

     public void stop() {
         this.snapFactoryTracker.close();
     }

     public Object addingService(ServiceReference<SnapFactory> reference) {
         SnapFactory snapFactory = this.bundleContext.getService(reference);
         if (snapFactory != null) {
             BundleContext snapBundleContext = reference.getBundle().getBundleContext();
             SnapBinder snapBinder = new SnapBinder(snapBundleContext, snapFactory, SnapHostDefinition.fromServiceReference(reference),
                 this.eventLogger, this.snapRegistry);
             snapBinder.start();
             return snapBinder;
         }
         logger.warn("Unable to create SnapBinder due to missing SnapFactory");
         return null;
     }

     public void modifiedService(ServiceReference<SnapFactory> reference, Object service) {
     }

     public void removedService(ServiceReference<SnapFactory> reference, Object service) {
         logger.info("Destroying SnapBinder for bundle '{}'", reference.getBundle());
         ((SnapBinder) service).destroy();
     }

     private static enum SnapLifecycleState {
     	AWAITING_INIT,
     	INIT_SUCCEEDED,
     	INIT_FAILED
     }

     private static final class SnapBinder implements ServiceListener {

         private static final String SNAP_ORDER = "snap.order";

         private final Logger logger = LoggerFactory.getLogger(this.getClass());

         private final BundleContext context;

         private final SnapFactory factory;

         private final HostSelector hostSelector;

         private final Object hostStateMonitor = new Object();

         private final Object snapStateMonitor = new Object();

         private boolean queriedInitialHosts = false;

         private ServiceReference<ServletContext> hostReference;

         private final ServiceRegistrationTracker registrationTracker = new ServiceRegistrationTracker();

         private final EventLogger eventLogger;

         private final SnapRegistry snapRegistry;

         private Snap snap;

         public SnapBinder(final BundleContext context, final SnapFactory factory, final SnapHostDefinition hostDefinition, final EventLogger eventLogger, final SnapRegistry snapRegistry) {
             this.context = context;
             this.factory = factory;
             this.hostSelector = new HostSelector(hostDefinition, (String)context.getBundle().getHeaders().get("Module-Scope"));
             this.eventLogger = eventLogger;
             this.snapRegistry = snapRegistry;
         }

         private void start() {
             registerHostListener();
         }

         private void registerHostListener() {
             try {
                 this.context.addServiceListener(this, "(objectClass=javax.servlet.ServletContext)");
                 logger.info("Listening for hosts to be registered.");
                 searchForExistingHost();
             } catch (InvalidSyntaxException e) {
                 logger.error("Filter syntax invalid");
             }
         }

         private void hostPublished(ServiceReference<ServletContext> hostReference) {
             assert (!Thread.holdsLock(this.hostStateMonitor));

             ServletContext servletContext = this.context.getService(hostReference);
             if (servletContext != null) {
                 synchronized (this.hostStateMonitor) {

                 	Collection<ServiceReference<ServletContext>> references = new HashSet<ServiceReference<ServletContext>>();
                 	references.add(hostReference);
                     ServiceReference<ServletContext> matchedHost = this.hostSelector.selectHost(references);

                     if (matchedHost == null) {
                         logger.info("Host {} did not match {} ", hostReference.getBundle().getSymbolicName(),
                             this.hostSelector.getHostDefinition().toString());
                         return;
                     }
                 }

                 Bundle hostBundle = hostReference.getBundle();

                 Host host = new Host(hostBundle, servletContext, new RequestRouter(this.snapRegistry, servletContext));

                 synchronized (this.snapStateMonitor) {
                 	if (this.factory.hasSnap()) {
                 		Snap snap = this.factory.getSnap();
                 		snap.addHost(host);
                 		publishSnapService(snap, hostBundle);
                 	} else {
                 		SnapLifecycleState newState = SnapLifecycleState.INIT_FAILED;
                 		Snap snap = this.factory.createSnap(host);
                 		try {
                 			logger.info("Initializing snap '{}'", snap.getContextPath());
                 			snap.init();

                 			newState = SnapLifecycleState.INIT_SUCCEEDED;

                 			logger.info("Publishing snap '{}'", snap.getContextPath());
                 			publishSnapService(snap, hostBundle);
                 		} catch (ServletException e) {
                 			this.eventLogger.log(SnapsLogEvents.SNAP_INIT_FAILURE, SnapUtils.boundContextPath(servletContext.getContextPath(), snap.getContextPath()));
                 		} finally {
                 			if (newState == SnapLifecycleState.INIT_SUCCEEDED) {
                 				this.snap = snap;
                 			}
                 		}
 					}
                 }
             }
         }

         private void publishSnapService(Snap snap, Bundle hostBundle) {
         	Hashtable<Object, Object> props = snap.getSnapProperties();
             Dictionary<String, Object> serviceProperties = new Hashtable<String, Object>();

         	for(Object key : props.keySet()){
         		serviceProperties.put(key.toString(), props.get(key));
         	}

             String snapOrder = (String) serviceProperties.get(SNAP_ORDER);
             if (snapOrder != null) {
                 serviceProperties.put(Constants.SERVICE_RANKING, Integer.parseInt(snapOrder));
             }
             serviceProperties.put("snap.host.id", Long.toString(hostBundle.getBundleId()));
             serviceProperties.put("snap.context.path", snap.getContextPath());
             serviceProperties.put("snap.name", (String) this.context.getBundle().getHeaders().get("Bundle-Name"));

             ServiceRegistration<Snap> registration = this.context.registerService(Snap.class, snap, serviceProperties);
             this.registrationTracker.track(registration);
             logger.info("Published snap service for '{}'", snap.getContextPath());
         }

         private void destroy() {
             try {
                 destroySnap();
             } finally {
                 unregisterHostListener();
             }
         }

         private void unregisterHostListener() {
             logger.info("No longer listening for hosts to be registered.");
             try {
 				this.context.removeServiceListener(this);
 			} catch (IllegalStateException e) {
 				logger.warn("Could not remove host listener. Reason: " + e.getMessage());
 			}
         }

 		public void serviceChanged(ServiceEvent event) {
             synchronized (this.hostStateMonitor) {
                 while (!queriedInitialHosts) {
                     try {
                         this.hostStateMonitor.wait();
                     } catch (InterruptedException e) {
                         Thread.currentThread().interrupt();
                     }
                 }
             }

             int type = event.getType();
             @SuppressWarnings("unchecked")
 			ServiceReference<ServletContext> serviceReference = (ServiceReference<ServletContext>) event.getServiceReference();

             if (type == ServiceEvent.REGISTERED && this.hostReference == null) {
                 hostPublished(serviceReference);
             } else if (type == ServiceEvent.UNREGISTERING) {
                 if (serviceReference.equals(this.hostReference)) {
                     hostRetracted(serviceReference);
                 }
             }
         }

         private void hostRetracted(ServiceReference<ServletContext> serviceReference) {
             try {
                 destroySnap();
             } finally {
                 synchronized (this.hostStateMonitor) {
                     this.hostReference = null;
                 }
             }
         }

         private void destroySnap() {
             Snap s = null;
             synchronized (this.snapStateMonitor) {
                 s = this.snap;
                 this.snap = null;
             }
             this.registrationTracker.unregisterAll();
             if(s != null) {
             logger.info("Retracted snap service for '{}'", s.getContextPath());
             	s.destroy();
             }
         }

         private void searchForExistingHost() {
             ServiceReference<ServletContext> existingHost = null;
             Collection<ServiceReference<ServletContext>> candidates = findHostCandidiates();
             if (candidates != null && !candidates.isEmpty()) {
                 logger.info("{} host candidates found", candidates.size());
             } else {
                 logger.info("No host candidates found");
             }

             synchronized (this.hostStateMonitor) {
                 try {
                     existingHost = this.hostSelector.selectHost(candidates);
                     this.queriedInitialHosts = true;
                 } finally {
                     this.hostStateMonitor.notifyAll();
                 }
             }
             if (existingHost != null) {
                 hostPublished(existingHost);
             }
         }

         private Collection<ServiceReference<ServletContext>> findHostCandidiates() {
             try {
                 return this.context.getServiceReferences(ServletContext.class, null);
             } catch (InvalidSyntaxException ise) {
                 throw new IllegalStateException("Unexpected invalid filter syntax with null filter", ise);
             }
         }
     }
 }
	/*******************************************************************************
	* Copyright (c) 2008, 2010 VMware Inc.
	* 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:
	* VMware Inc. - initial contribution
	*******************************************************************************/

	package org.eclipse.virgo.snaps.core.internal;

	import java.util.Collection;
	import java.util.Dictionary;
	import java.util.HashSet;
	import java.util.Hashtable;

	import javax.servlet.ServletContext;
	import javax.servlet.ServletException;

	import org.eclipse.virgo.medic.eventlog.EventLogger;
	import org.eclipse.virgo.snaps.core.RequestRouter;
	import org.eclipse.virgo.snaps.core.internal.Snap;
	import org.eclipse.virgo.snaps.core.SnapRegistry;
	import org.eclipse.virgo.snaps.core.internal.deployer.SnapFactory;
	import org.eclipse.virgo.util.osgi.ServiceRegistrationTracker;
	import org.osgi.framework.Bundle;
	import org.osgi.framework.BundleContext;
	import org.osgi.framework.Constants;
	import org.osgi.framework.InvalidSyntaxException;
	import org.osgi.framework.ServiceEvent;
	import org.osgi.framework.ServiceListener;
	import org.osgi.framework.ServiceReference;
	import org.osgi.framework.ServiceRegistration;
	import org.osgi.util.tracker.ServiceTracker;
	import org.osgi.util.tracker.ServiceTrackerCustomizer;
	import org.slf4j.Logger;
	import org.slf4j.LoggerFactory;

	final class SnapFactoryMonitor implements ServiceTrackerCustomizer<SnapFactory, Object> {

	private final Logger logger = LoggerFactory.getLogger(this.getClass());

	private final BundleContext bundleContext;

	private final ServiceTracker<SnapFactory, Object> snapFactoryTracker;

	private final EventLogger eventLogger;

	private final SnapRegistry snapRegistry;

	public SnapFactoryMonitor(BundleContext bundleContext, EventLogger eventLogger, SnapRegistry snapRegistry) {
	this.bundleContext = bundleContext;
	this.snapFactoryTracker = new ServiceTracker<SnapFactory, Object>(bundleContext, SnapFactory.class, this);
	this.eventLogger = eventLogger;
	this.snapRegistry = snapRegistry;
	}

	public void start() {
	this.snapFactoryTracker.open();
	}

	public void stop() {
	this.snapFactoryTracker.close();
	}

	public Object addingService(ServiceReference<SnapFactory> reference) {
	SnapFactory snapFactory = this.bundleContext.getService(reference);
	if (snapFactory != null) {
	BundleContext snapBundleContext = reference.getBundle().getBundleContext();
	SnapBinder snapBinder = new SnapBinder(snapBundleContext, snapFactory, SnapHostDefinition.fromServiceReference(reference),
	this.eventLogger, this.snapRegistry);
	snapBinder.start();
	return snapBinder;
	}
	logger.warn("Unable to create SnapBinder due to missing SnapFactory");
	return null;
	}

	public void modifiedService(ServiceReference<SnapFactory> reference, Object service) {
	}

	public void removedService(ServiceReference<SnapFactory> reference, Object service) {
	logger.info("Destroying SnapBinder for bundle '{}'", reference.getBundle());
	((SnapBinder) service).destroy();
	}

	private static enum SnapLifecycleState {
	AWAITING_INIT,
	INIT_SUCCEEDED,
	INIT_FAILED
	}

	private static final class SnapBinder implements ServiceListener {

	private static final String SNAP_ORDER = "snap.order";

	private final Logger logger = LoggerFactory.getLogger(this.getClass());

	private final BundleContext context;

	private final SnapFactory factory;

	private final HostSelector hostSelector;

	private final Object hostStateMonitor = new Object();

	private final Object snapStateMonitor = new Object();

	private boolean queriedInitialHosts = false;

	private ServiceReference<ServletContext> hostReference;

	private final ServiceRegistrationTracker registrationTracker = new ServiceRegistrationTracker();

	private final EventLogger eventLogger;

	private final SnapRegistry snapRegistry;

	private Snap snap;

	public SnapBinder(final BundleContext context, final SnapFactory factory, final SnapHostDefinition hostDefinition, final EventLogger eventLogger, final SnapRegistry snapRegistry) {
	this.context = context;
	this.factory = factory;
	this.hostSelector = new HostSelector(hostDefinition, (String)context.getBundle().getHeaders().get("Module-Scope"));
	this.eventLogger = eventLogger;
	this.snapRegistry = snapRegistry;
	}

	private void start() {
	registerHostListener();
	}

	private void registerHostListener() {
	try {
	this.context.addServiceListener(this, "(objectClass=javax.servlet.ServletContext)");
	logger.info("Listening for hosts to be registered.");
	searchForExistingHost();
	} catch (InvalidSyntaxException e) {
	logger.error("Filter syntax invalid");
	}
	}

	private void hostPublished(ServiceReference<ServletContext> hostReference) {
	assert (!Thread.holdsLock(this.hostStateMonitor));

	ServletContext servletContext = this.context.getService(hostReference);
	if (servletContext != null) {
	synchronized (this.hostStateMonitor) {

	Collection<ServiceReference<ServletContext>> references = new HashSet<ServiceReference<ServletContext>>();
	references.add(hostReference);
	ServiceReference<ServletContext> matchedHost = this.hostSelector.selectHost(references);

	if (matchedHost == null) {
	logger.info("Host {} did not match {} ", hostReference.getBundle().getSymbolicName(),
	this.hostSelector.getHostDefinition().toString());
	return;
	}
	}

	Bundle hostBundle = hostReference.getBundle();

	Host host = new Host(hostBundle, servletContext, new RequestRouter(this.snapRegistry, servletContext));

	synchronized (this.snapStateMonitor) {
	if (this.factory.hasSnap()) {
	Snap snap = this.factory.getSnap();
	snap.addHost(host);
	publishSnapService(snap, hostBundle);
	} else {
	SnapLifecycleState newState = SnapLifecycleState.INIT_FAILED;
	Snap snap = this.factory.createSnap(host);
	try {
	logger.info("Initializing snap '{}'", snap.getContextPath());
	snap.init();

	newState = SnapLifecycleState.INIT_SUCCEEDED;

	logger.info("Publishing snap '{}'", snap.getContextPath());
	publishSnapService(snap, hostBundle);
	} catch (ServletException e) {
	this.eventLogger.log(SnapsLogEvents.SNAP_INIT_FAILURE, SnapUtils.boundContextPath(servletContext.getContextPath(), snap.getContextPath()));
	} finally {
	if (newState == SnapLifecycleState.INIT_SUCCEEDED) {
	this.snap = snap;
	}
	}
	}
	}
	}
	}

	private void publishSnapService(Snap snap, Bundle hostBundle) {
	Hashtable<Object, Object> props = snap.getSnapProperties();
	Dictionary<String, Object> serviceProperties = new Hashtable<String, Object>();

	for(Object key : props.keySet()){
	serviceProperties.put(key.toString(), props.get(key));
	}

	String snapOrder = (String) serviceProperties.get(SNAP_ORDER);
	if (snapOrder != null) {
	serviceProperties.put(Constants.SERVICE_RANKING, Integer.parseInt(snapOrder));
	}
	serviceProperties.put("snap.host.id", Long.toString(hostBundle.getBundleId()));
	serviceProperties.put("snap.context.path", snap.getContextPath());
	serviceProperties.put("snap.name", (String) this.context.getBundle().getHeaders().get("Bundle-Name"));

	ServiceRegistration<Snap> registration = this.context.registerService(Snap.class, snap, serviceProperties);
	this.registrationTracker.track(registration);
	logger.info("Published snap service for '{}'", snap.getContextPath());
	}

	private void destroy() {
	try {
	destroySnap();
	} finally {
	unregisterHostListener();
	}
	}

	private void unregisterHostListener() {
	logger.info("No longer listening for hosts to be registered.");
	try {
	this.context.removeServiceListener(this);
	} catch (IllegalStateException e) {
	logger.warn("Could not remove host listener. Reason: " + e.getMessage());
	}
	}

	public void serviceChanged(ServiceEvent event) {
	synchronized (this.hostStateMonitor) {
	while (!queriedInitialHosts) {
	try {
	this.hostStateMonitor.wait();
	} catch (InterruptedException e) {
	Thread.currentThread().interrupt();
	}
	}
	}

	int type = event.getType();
	@SuppressWarnings("unchecked")
	ServiceReference<ServletContext> serviceReference = (ServiceReference<ServletContext>) event.getServiceReference();

	if (type == ServiceEvent.REGISTERED && this.hostReference == null) {
	hostPublished(serviceReference);
	} else if (type == ServiceEvent.UNREGISTERING) {
	if (serviceReference.equals(this.hostReference)) {
	hostRetracted(serviceReference);
	}
	}
	}

	private void hostRetracted(ServiceReference<ServletContext> serviceReference) {
	try {
	destroySnap();
	} finally {
	synchronized (this.hostStateMonitor) {
	this.hostReference = null;
	}
	}
	}

	private void destroySnap() {
	Snap s = null;
	synchronized (this.snapStateMonitor) {
	s = this.snap;
	this.snap = null;
	}
	this.registrationTracker.unregisterAll();
	if(s != null) {
	logger.info("Retracted snap service for '{}'", s.getContextPath());
	s.destroy();
	}
	}

	private void searchForExistingHost() {
	ServiceReference<ServletContext> existingHost = null;
	Collection<ServiceReference<ServletContext>> candidates = findHostCandidiates();
	if (candidates != null && !candidates.isEmpty()) {
	logger.info("{} host candidates found", candidates.size());
	} else {
	logger.info("No host candidates found");
	}

	synchronized (this.hostStateMonitor) {
	try {
	existingHost = this.hostSelector.selectHost(candidates);
	this.queriedInitialHosts = true;
	} finally {
	this.hostStateMonitor.notifyAll();
	}
	}
	if (existingHost != null) {
	hostPublished(existingHost);
	}
	}

	private Collection<ServiceReference<ServletContext>> findHostCandidiates() {
	try {
	return this.context.getServiceReferences(ServletContext.class, null);
	} catch (InvalidSyntaxException ise) {
	throw new IllegalStateException("Unexpected invalid filter syntax with null filter", ise);
	}
	}
	}
	}