public void fireModuleEvent(final Module module, final int type) { fireModuleEvent(null, module, type); }
public void addServiceListener(final Module module, final ServiceListener listener, final String filterstr) { assert listener != null : "Null listener"; synchronized (serviceListeners) { List<ServiceListenerRegistration> listeners = serviceListeners.get(module); if (listeners == null) { listeners = new CopyOnWriteArrayList<ServiceListenerRegistration>(); serviceListeners.put(module, listeners); } // If the context moduleState's list of listeners already contains a listener l such that (l==listener), // then this method replaces that listener's filter (which may be null) with the specified one (which may be null). removeServiceListener(module, listener); // Create the new listener registration Filter filter = (filterstr != null ? FilterFactory.createFilter(filterstr) : NoFilter.INSTANCE); ServiceListenerRegistration slreg = new ServiceListenerRegistration(module, listener, filter); // Add the listener to the list listeners.add(slreg); } }
protected AbstractRuntime(PropertiesProvider propertiesProvider) { IllegalArgumentAssertion.assertNotNull(propertiesProvider, "propertiesProvider"); runtimeEvents = new RuntimeEventsManager(); properties = propertiesProvider; }
void fireServiceEvent(Module module, int type, ServiceState<?> serviceState) { frameworkEvents.fireServiceEvent(module, type, serviceState); }
@Override public void addServiceListener(ServiceListener listener, String filterstr) { IllegalArgumentAssertion.assertNotNull(listener, "listener"); assertNotDestroyed(); getEventsManager().addServiceListener(getModule(), listener, filterstr); }
public void removeModuleListener(final Module module, final ModuleListener listener) { assert listener != null : "Null listener"; List<ModuleListenerRegistration> registrations = moduleListeners.get(module); if (registrations != null) { if (registrations.size() > 1) { Iterator<ModuleListenerRegistration> iterator = registrations.iterator(); while(iterator.hasNext()) { ModuleListenerRegistration registration = iterator.next(); if (registration.getListener() == listener) { iterator.remove(); break; } } } else { removeBundleListeners(module); } } }
RuntimeEventsManager() { asyncBundleEvents.add(new Integer(ModuleEvent.INSTALLED)); asyncBundleEvents.add(new Integer(ModuleEvent.STARTED)); asyncBundleEvents.add(new Integer(ModuleEvent.STOPPED)); asyncBundleEvents.add(new Integer(ModuleEvent.UNINSTALLED)); infoEvents.add(ConstantsHelper.moduleEvent(ModuleEvent.INSTALLED)); infoEvents.add(ConstantsHelper.moduleEvent(ModuleEvent.STARTED)); infoEvents.add(ConstantsHelper.moduleEvent(ModuleEvent.STOPPED)); infoEvents.add(ConstantsHelper.moduleEvent(ModuleEvent.UNINSTALLED)); executorService = createExecutorService("RuntimeEvents"); }
@Override public void addModuleListener(ModuleListener listener) { IllegalArgumentAssertion.assertNotNull(listener, "listener"); assertNotDestroyed(); getEventsManager().addModuleListener(getModule(), listener); }
@Override public void removeModuleListener(ModuleListener listener) { IllegalArgumentAssertion.assertNotNull(listener, "listener"); assertNotDestroyed(); getEventsManager().removeModuleListener(getModule(), listener); }
frameworkEvents.fireServiceEvent(context.getModule(), ServiceEvent.REGISTERED, serviceState);
@Override public void addServiceListener(ServiceListener listener) { IllegalArgumentAssertion.assertNotNull(listener, "listener"); assertNotDestroyed(); getEventsManager().addServiceListener(getModule(), listener, null); }
@Override public void uninstall() { assertNotUninstalled(); // #1 This module is stopped as described in the {@code Module.stop} method. try { stop(); } catch (Exception ex) { LOGGER.error("Cannot stop module on uninstall: " + this, ex); } // #2 This bundle's state is set to {@code UNINSTALLED}. setState(State.UNINSTALLED); // #3 A module event of type {@link ModuleEvent#UNINSTALLED} is fired. RuntimeEventsManager eventHandler = getRuntime().adapt(RuntimeEventsManager.class); eventHandler.fireModuleEvent(this, ModuleEvent.UNINSTALLED); getRuntime().uninstallModule(this); }
@Override public void removeServiceListener(ServiceListener listener) { IllegalArgumentAssertion.assertNotNull(listener, "listener"); assertNotDestroyed(); getEventsManager().removeServiceListener(getModule(), listener); }
/** * Unregister the given service. */ void unregisterService(ServiceState<?> serviceState) { if (serviceState.isUnregistered()) return; LOGGER.debug("Unregister service: {}", serviceState); for (String className : serviceState.getClassNames()) { try { List<ServiceState<?>> serviceStates = serviceMap.get(className); if (serviceStates != null) { serviceStates.remove(serviceState); } } catch (RuntimeException ex) { LOGGER.error("Cannot unregister service: " + className, ex); } } Module serviceOwner = serviceState.getServiceOwner(); // This event is synchronously delivered before the service has completed unregistering. frameworkEvents.fireServiceEvent(serviceOwner, ServiceEvent.UNREGISTERING, serviceState); // Remove from using modules for (AbstractModule module : serviceState.getUsingModulesInternal()) { while (ungetService(module, serviceState)) { } } }
eventHandler.fireModuleEvent(this, ModuleEvent.STOPPING); eventHandler.fireModuleEvent(this, ModuleEvent.STOPPED);
eventHandler.fireModuleEvent(this, ModuleEvent.STARTING); eventHandler.fireModuleEvent(this, ModuleEvent.STOPPING); eventHandler.fireModuleEvent(this, ModuleEvent.STOPPED); eventHandler.fireModuleEvent(this, ModuleEvent.STARTED);
@Override public final Module installModule(ClassLoader classLoader, Resource resource, Dictionary<String, String> headers, Attachable context) throws ModuleException { assertNoShutdown(); context = context != null ? context : new AttachableSupport(); AbstractModule module = createModule(classLoader, resource, headers, context); // Attach the {@link ModuleEntriesProvider} ModuleEntriesProvider entriesProvider = context.getAttachment(AbstractModule.MODULE_ENTRIES_PROVIDER_KEY); entriesProvider = entriesProvider != null ? entriesProvider : getDefaultEntriesProvider(module, context); if (entriesProvider != null) { module.putAttachment(AbstractModule.MODULE_ENTRIES_PROVIDER_KEY, entriesProvider); } if (getModule(module.getIdentity()) != null) throw new ModuleException("Module already installed: " + module); modules.put(module.getModuleId(), module); // #1 The module's state is set to {@code INSTALLED}. module.setState(State.INSTALLED); // #2 A module event of type {@link ModuleEvent#INSTALLED} is fired. runtimeEvents.fireModuleEvent(module, ModuleEvent.INSTALLED); LOGGER.info("Installed: {}", module); return module; }