@SuppressWarnings({"ThrowableResultOfMethodCallIgnored"}) public void frameworkEvent(final FrameworkEvent event) { String bundleBits = ""; if (event.getBundle() != null) { bundleBits = " in bundle " + event.getBundle().getSymbolicName(); } switch (event.getType()) { case FrameworkEvent.ERROR: log.error("Framework error" + bundleBits, event.getThrowable()); break; case FrameworkEvent.WARNING: log.warn("Framework warning" + bundleBits, event.getThrowable()); break; case FrameworkEvent.INFO: log.info("Framework info" + bundleBits, event.getThrowable()); break; } } }
public FrameworkEvent waitForStop(long timeout) throws InterruptedException { Framework current = framework; if (current == null) return new FrameworkEvent(FrameworkEvent.STOPPED, this, null); return current.waitForStop(timeout); }
private void logFrameworkEvent(FrameworkEvent frameworkEvent) { if (frameworkEvent.getType() == FrameworkEvent.ERROR) { LOG.error( String.format("Framework ERROR event %s", frameworkEvent.toString()), frameworkEvent.getThrowable()); } else { LOG.debug(String.format("Framework event type %s: %s", FrameworkEventUtils.getFrameworkEventString(frameworkEvent.getType()), frameworkEvent.toString()), frameworkEvent.getThrowable()); } }
public void log(FrameworkEvent frameworkEvent) { log(new FrameworkLogEntry(frameworkEvent.getBundle().getSymbolicName() == null ? frameworkEvent.getBundle().getLocation() : frameworkEvent.getBundle().getSymbolicName(), FrameworkLogEntry.ERROR, 0, "FrameworkEvent.ERROR", 0, frameworkEvent.getThrowable(), null)); //$NON-NLS-1$ }
while (event.getType() == FrameworkEvent.STOPPED_UPDATE);
@Override public void refreshPackages(Collection<Bundle> bundles) throws InterruptedException { final CountDownLatch latch = new CountDownLatch(1); FrameworkWiring fw = systemBundleContext.getBundle().adapt(FrameworkWiring.class); fw.refreshBundles(bundles, (FrameworkListener) event -> { if (event.getType() == FrameworkEvent.ERROR) { LOGGER.error("Framework error", event.getThrowable()); } latch.countDown(); }); latch.await(); }
@Override public void frameworkEvent(final FrameworkEvent event) { int eventType = event.getType(); if ((eventType == FrameworkEvent.ERROR) || (eventType == FrameworkEvent.PACKAGES_REFRESHED)) { refreshFinishLock.lock(); try { refreshFinished.set(true); Logger.info("Framework refresh finished with code " + BundleUtil.convertFrameworkEventTypeCode(eventType)); refreshFinishCondition.signal(); } finally { refreshFinishLock.unlock(); } } else { StringBuilder sb = new StringBuilder("Event caught during refreshing packages with data:"); if (event.getBundle() != null) { sb.append("\n\tBundle: ").append(event.getBundle().toString()); } if (event.getSource() != null) { sb.append("\n\tSource object: ").append(event.getSource().toString()); } sb.append("\n\tEvent type: ").append(BundleUtil.convertFrameworkEventTypeCode(event.getType())); if (event.getThrowable() != null) { Logger.error(sb.toString(), event.getThrowable()); } else { Logger.info(sb.toString()); } } }
@Override public void frameworkEvent(FrameworkEvent event) { if (event.getThrowable() != null) { //NOSONAR LOGGER.error("An error was detected while refreshing the bundles", event.getThrowable()); } } });
public void frameworkEvent(FrameworkEvent event) { if (event.getType() == FrameworkEvent.PACKAGES_REFRESHED) { // We cannot know which are the affected packages, just refresh all //However, registering mbeans is expensive, as it involves reflection //TODO improve this unregisterPackageMBeans(); registerPackageMBeans(); unregisterBundleMBeans(); registerBundleMBeans(); } } };
@Override public void frameworkEvent(final FrameworkEvent event) { lock.lock(); int eventType = event.getType(); if ((eventType == FrameworkEvent.STARTLEVEL_CHANGED) || (eventType == FrameworkEvent.ERROR)) { if (eventType == FrameworkEvent.ERROR) { Logger.error("Setting framework startlevel to " + startLevel + " finished with error: ", event.getThrowable()); } else { Logger.info("Setting framework startlevel to " + startLevel + " finished with success"); } startLevelReached.set(true); startLevelReachedCondition.signal(); } lock.unlock(); } });
protected void assertFrameworkEvent(int type, Bundle bundle, Class<? extends Throwable> expectedThrowable) throws Exception { waitForEvent(frameworkEvents, type); log.debug("frameworkEvents=" + frameworkEvents); int size = frameworkEvents.size(); assertTrue("" + size, size > 0); FrameworkEvent event = frameworkEvents.remove(0); assertEquals(ConstantsHelper.frameworkEvent(type), ConstantsHelper.frameworkEvent(event.getType())); Throwable t = event.getThrowable(); if (expectedThrowable == null) { if (t != null) { log.error("Unexpected error in Framework event: ", t); fail("Unexpected throwable: " + t); } } else { String message = expectedThrowable.getSimpleName() + " is assignable from " + t.getClass().getSimpleName(); assertTrue(message, expectedThrowable.isAssignableFrom(t.getClass())); } assertEquals(bundle, event.getSource()); assertEquals(bundle, event.getBundle()); }
@Override public void frameworkEvent(FrameworkEvent frameworkEvent) { if (frameworkEvent.getType() == FrameworkEvent.ERROR) { LOG.error( String.format("Framework ERROR event %s", frameworkEvent.toString()), frameworkEvent.getThrowable()); } else { LOG.debug(String.format("Framework event type %s: %s", FrameworkEventUtils.getFrameworkEventString(frameworkEvent.getType()), frameworkEvent.toString()), frameworkEvent.getThrowable()); } } });
public void log(FrameworkEvent frameworkEvent) { log(new FrameworkLogEntry(frameworkEvent.getBundle().getSymbolicName() == null ? frameworkEvent.getBundle().getLocation() : frameworkEvent.getBundle().getSymbolicName(), FrameworkLogEntry.ERROR, 0, "FrameworkEvent.ERROR", 0, frameworkEvent.getThrowable(), null)); //$NON-NLS-1$ }
public static CompositeData encodeFrameworkEvent(FrameworkEvent event) throws Exception{ if(event==null) return null; String[] itemNames=CompositeDataItemNames.FRAMEWORK_EVENT; Object[] itemValues=new Object[4]; itemValues[0]=new Integer((int)event.getBundle().getBundleId()); itemValues[1]=event.getBundle().getLocation(); if (event.getThrowable()==null) itemValues[2]=null; else itemValues[2]=encodeException(event.getThrowable()); itemValues[3]=new Integer(event.getType()); return new CompositeDataSupport( OSGiTypes.FRAMEWORKEVENT, itemNames, itemValues); } public static CompositeData encodeUserAdminEvent(UserAdminEvent event) throws Exception{
@Override public void frameworkEvent(FrameworkEvent event) { if(event.getType() == FrameworkEvent.STARTLEVEL_CHANGED) { if(filterServiceRegistration==null) { registerFilter(); } } } }
@Override public void refreshPackages() { FrameworkWiring wiring = felix.adapt(FrameworkWiring.class); final CountDownLatch latch = new CountDownLatch(1); wiring.refreshBundles(null, event -> { switch (event.getType()) { case FrameworkEvent.PACKAGES_REFRESHED: latch.countDown(); break; case FrameworkEvent.ERROR: log.log(Level.SEVERE, "ERROR FrameworkEvent received.", event.getThrowable()); break; } }); try { long TIMEOUT_SECONDS = 60L; if (!latch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS)) { log.warning("No PACKAGES_REFRESHED FrameworkEvent received within " + TIMEOUT_SECONDS + " seconds of calling FrameworkWiring.refreshBundles()"); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }
/** * Convenience method for throwing framework info event. * * @param b Bundle which caused the throwable. * @param t Throwable generated. */ public void frameworkInfo(Bundle b, Throwable t, FrameworkListener... oneTimeListeners) { listeners.frameworkEvent(new FrameworkEvent(FrameworkEvent.INFO, b, t), oneTimeListeners); }
/** * Called when a framework event occurs. * @param event the event that occured */ public void frameworkEvent(final FrameworkEvent event) { int eventType = event.getType(); String message = null; for (int i = 0; message == null && i < FRAMEWORK_EVENT_MESSAGES.length; ++i) { if (eventType >> i == 1) { message = FRAMEWORK_EVENT_MESSAGES[i]; } } log( "Events.Framework", event.getBundle(), null, (eventType == FrameworkEvent.ERROR) ? LogLevel.ERROR : LogLevel.INFO, message, event.getThrowable()); }