/* (non-Javadoc) * @see org.osgi.framework.ServiceFactory#getService(org.osgi.framework.Bundle, org.osgi.framework.ServiceRegistration) */ @Override public Object getService(Bundle bundle, ServiceRegistration registration) { if (serviceInstance == null) { IRepositoryService repositoryService = null; IMarketService marketService = null; try { BundleContext context = CoreActivator.getDefault().getBundle().getBundleContext(); ServiceReference serviceReference = context.getServiceReference(IRepositoryService.class.getName()); if (serviceReference != null) { repositoryService = (IRepositoryService) context.getService(serviceReference); context.ungetService(serviceReference); } serviceReference = context.getServiceReference(IMarketService.class.getName()); if (serviceReference != null) { marketService = (IMarketService) context.getService(serviceReference); context.ungetService(serviceReference); } serviceInstance = new CurrencyService(repositoryService, marketService); serviceInstance.startUp(null); } catch (Exception e) { CoreActivator.log("Error starting currency service", e); } } return serviceInstance; }
@Override public com.liferay.portal.model.Portlet addingService( ServiceReference<Portlet> serviceReference) { BundleContext bundleContext = _componentContext.getBundleContext(); Portlet portlet = bundleContext.getService(serviceReference); String portletName = (String) serviceReference.getProperty("javax.portlet.name"); if (Validator.isNull(portletName)) { Class<?> clazz = portlet.getClass(); portletName = StringUtil.replace(clazz.getName(), new String[] {".", "$"}, new String[] {"_", "_"}); } String portletId = StringUtil.replace(portletName, new String[] {".", "$"}, new String[] {"_", "_"}); if (portletId.length() > PortletInstance.PORTLET_INSTANCE_KEY_MAX_LENGTH) { _log.error( "Portlet ID " + portletId + " has more than " + PortletInstance.PORTLET_INSTANCE_KEY_MAX_LENGTH + " characters"); bundleContext.ungetService(serviceReference); return null; } com.liferay.portal.model.Portlet portletModel = _portletLocalService.getPortletById(portletId); if (portletModel != null) { _log.error("Portlet id " + portletId + " is already in use"); bundleContext.ungetService(serviceReference); return null; } if (_log.isInfoEnabled()) { _log.info("Adding " + serviceReference); } portletModel = addingPortlet(serviceReference, portlet, portletName, portletId); if (portletModel == null) { bundleContext.ungetService(serviceReference); } return portletModel; }
@Override public void start(BundleContext context) throws Exception { LOG.info("Starting Bundle"); // Get our name. String myName = context.getBundle().getSymbolicName(); // Find reference. ServiceReference<HelloService> ref = context.getServiceReference(HelloService.class); if (ref != null) { try { // Print service properties. String props = getServiceProperties(ref); LOG.info( "Calling HelloService#sayHello('{}') Published by {}. Props:\n{}", myName, ref.getBundle().getSymbolicName(), props); // Get the service HelloService service = context.getService(ref); if (service != null) { service.sayHello(myName); } } finally { // Release reference context.ungetService(ref); } } }
static Object getService(String name) { ServiceReference reference = context.getServiceReference(name); if (reference == null) return null; Object result = context.getService(reference); context.ungetService(reference); return result; }
@Override public void undeployBundle(String bundleName) throws BundleException { if (bundleName == null) { // ignore return; } log.info( String.format( "Before undeploy bundle with name '%s'.\n" + "%s", bundleName, getRuntimeStatus())); BundleContext ctx = getBundleContext(); ServiceReference ref = ctx.getServiceReference(PackageAdmin.class.getName()); PackageAdmin srv = (PackageAdmin) ctx.getService(ref); try { for (Bundle b : srv.getBundles(bundleName, null)) { if (b != null && b.getState() == Bundle.ACTIVE) { Transaction tx = TransactionHelper.suspendTransaction(); try { b.stop(); b.uninstall(); } finally { TransactionHelper.resumeTransaction(tx); } } } } finally { ctx.ungetService(ref); } log.info(String.format("Undeploy done.\n" + "%s", getRuntimeStatus())); }
/** * This will try and find a resource of the given name using the bundle from which was originally * loaded the given class so as to try and detect if it is jarred. If <code>clazz</code> hasn't * been loaded from a bundle class loader, we'll resort to the default class loader mechanism. * This will only return <code>null</code> in the case where the resource at <code>resourcePath * </code> cannot be located at all. * * @param clazz Class which class loader will be used to try and locate the resource. * @param resourcePath Path of the resource we seek, relative to the class. * @return The URL of the resource as we could locate it. * @throws IOException This will be thrown if we fail to convert bundle-scheme URIs into * file-scheme URIs. */ public static URL getResourceURL(Class<?> clazz, String resourcePath) throws IOException { BundleContext context = AcceleoCommonPlugin.getDefault().getContext(); ServiceReference packageAdminReference = context.getServiceReference(PackageAdmin.class.getName()); PackageAdmin packageAdmin = null; if (packageAdminReference != null) { packageAdmin = (PackageAdmin) context.getService(packageAdminReference); } URL resourceURL = null; if (packageAdmin != null) { Bundle bundle = packageAdmin.getBundle(clazz); if (bundle != null) { final String pathSeparator = "/"; // $NON-NLS-1$ // We found the appropriate bundle. We'll now try and determine whether the emtl is jarred resourceURL = getBundleResourceURL(bundle, pathSeparator, resourcePath); } } /* * We couldn't locate either the bundle which loaded the class or the resource. Resort to the class * loader and return null if it cannot locate the resource either. */ if (resourceURL == null) { resourceURL = clazz.getResource(resourcePath); } if (packageAdminReference != null) { context.ungetService(packageAdminReference); } return resourceURL; }
public void stop() throws IOException { if (context != null && httpServiceReference != null) context.ungetService(httpServiceReference); httpService = null; httpServiceReference = null; registrations.clear(); }
/** * This method tells the proxy to dispose of its service object; this is called when the * underlying service goes away. */ public void dispose() { if (m_shape != null) { m_context.ungetService(m_ref); m_context = null; m_ref = null; m_shape = null; } }
public static void ungetService(Object service) { if (service != null) { ServiceReference<?> serviceRef = services.remove(service); if (serviceRef != null) { bundleContext.ungetService(serviceRef); } } }
private void removeRef(ServiceReference<T> ref) { synchronized (refs) { if (refs.remove(ref) == null) { return; } } ctx.ungetService(ref); }
public void stop(BundleContext bundleContext) throws Exception { runnablePrinterClient.stop(); if (serviceReference != null) { bundleContext.ungetService(serviceReference); } bundleContext.removeServiceListener(this); }
/* * (non-Javadoc) * * @see * org.osgi.framework.BundleActivator#stop(org.osgi.framework.BundleContext) */ @Override public void stop(BundleContext context) throws Exception { // Update everything in the ItemManager that requires it itemManager.persistItems(); // Unregister with the HTTP Service if (httpServiceRef != null) { bundleContext.ungetService(httpServiceRef); } // Unregister with the Materials Database service if (matDBServiceRef != null) { bundleContext.ungetService(matDBServiceRef); } // Unregister this service from the framework registration.unregister(); }
public static void oneTimeTearDown() throws Exception { BundleContext context = TestActivator.getContext(); certificateUIRegistration.unregister(); PackageAdmin pkgAdmin = context.getService(packageAdminRef); stopTransient(pkgAdmin, BUNDLE_TESTSERVER); stopTransient(pkgAdmin, BUNDLE_EQUINOX_HTTP); context.ungetService(packageAdminRef); setUpCounter = 0; }
/** * Return a map containing all managed {@code EventHandler}s and their status. * * @param command the manage handlers command to execute. * @return a result containing the map of event handlers (and their status). */ @Override public ManageHandlersResult execute(ManageHandlersCommand command) { ManageHandlersResult result = new ManageHandlersResult(command.getId()); BundleContext bundleContext = ((BundleReference) getClass().getClassLoader()).getBundle().getBundleContext(); ServiceReference[] references = new ServiceReference[0]; try { references = bundleContext.getServiceReferences( EventHandler.class.getName(), EventHandler.MANAGED_FILTER); if (references != null && references.length > 0) { for (ServiceReference ref : references) { EventHandler handler = (EventHandler) bundleContext.getService(ref); // unproxy if required (due to the Service Guard of Karaf 3.0.x) if (proxyManager.isProxy(handler)) { handler = (EventHandler) proxyManager.unwrap(handler).call(); } if (command.getHandlerName() == null) { result .getHandlers() .put(handler.getClass().getName(), handler.getSwitch().getStatus().name()); } else { if (command.getHandlerName().equals(handler.getClass().getName())) { if (command.getStatus() != null) { if (command.getStatus()) { // persist the handler switch status to configuration admin persist(handler.getClass().getName(), SwitchStatus.ON); handler.getSwitch().turnOn(); } else { // persist the handler switch status to configuration admin persist(handler.getClass().getName(), SwitchStatus.OFF); handler.getSwitch().turnOff(); } } result .getHandlers() .put(handler.getClass().getName(), handler.getSwitch().getStatus().name()); break; } } } } } catch (Exception e) { LOGGER.error("Can't get the current handlers status", e); } finally { if (references != null) { for (ServiceReference ref : references) { bundleContext.ungetService(ref); } } } return result; }
private void addRef(ServiceReference<T> ref) { T service = ctx.getService(ref); synchronized (refs) { if (!refs.containsKey(ref)) { refs.put(ref, service); return; } } ctx.ungetService(ref); }
@Override protected void tearDown() throws Exception { BundleContext context = HistoryServiceLick.bc; context.ungetService(this.historyServiceRef); this.history = null; this.historyService = null; this.historyServiceRef = null; }
public Object execute(CommandSession session, List<Object> arguments) throws Exception { Object target = context.getService(reference); try { if (target instanceof Function) { return ((Function) target).execute(session, arguments); } else { return method(session, target, function, arguments); } } finally { context.ungetService(reference); } }
/** * Implements BundleActivator.start(). * * @param context the framework context for the bundle. */ public void start(BundleContext context) { ServiceReference ref = context.getServiceReference(Statistics.class.getName()); if (ref != null) { Statistics stat = (Statistics) context.getService(ref); if (stat != null) { stat.addNumber(1.0); stat.addNumber(2.0); System.out.println("Average " + stat.getAverage()); } context.ungetService(ref); } }
/** * Returns a service with the specified name or {@code null} if none. * * @param serviceName name of service * @return service object or {@code null} if none */ public Object getService(final String serviceName) { final ServiceReference reference = bundleContext.getServiceReference(serviceName); if (reference == null) { return null; } final Object service = bundleContext.getService(reference); if (service != null) { bundleContext.ungetService(reference); } return service; }
/** * Internal log method. * * @param level the level of the message. * @param msg the message to log * @param exception the exception attached to the message */ private void dispatch(int level, String msg, Throwable exception) { LogService log = null; ServiceReference ref = null; try { // Security Check if (SecurityHelper.hasPermissionToGetService(LogService.class.getName(), m_context)) { ref = m_context.getServiceReference(LogService.class.getName()); } else { Extender.getIPOJOBundleContext().getServiceReference(LogService.class.getName()); } if (ref != null) { log = (LogService) m_context.getService(ref); } } catch (IllegalStateException e) { // Handle the case where the iPOJO bundle is stopping, or the log service already ran away. } if (log == null) { log = m_defaultLogger; } String name = m_name; if (name == null) { name = ""; } String message = String.format("%s %s : %s", getLogHeaderForLevel(level), name, msg); switch (level) { case DEBUG: log.log(LogService.LOG_DEBUG, message, exception); break; case INFO: log.log(LogService.LOG_INFO, message, exception); break; case WARNING: log.log(LogService.LOG_WARNING, message, exception); break; case ERROR: log.log(LogService.LOG_ERROR, message, exception); break; default: log.log(LogService.LOG_INFO, message, exception); break; } if (ref != null) { m_context.ungetService(ref); } }
public void close() { if (open.compareAndSet(true, false)) { ctx.removeServiceListener(listener); List<ServiceReference> oldRefs; synchronized (refs) { oldRefs = new ArrayList<ServiceReference>(refs.keySet()); refs.clear(); } for (ServiceReference ref : oldRefs) { ctx.ungetService(ref); } } }
/** * locateProxyTarget. * * @return a {@link org.ops4j.pax.wicket.spi.ProxyTarget} object. */ public ProxyTarget locateProxyTarget() { if (bundleContext == null) { throw new IllegalStateException("Bundle context is not allowed to be null"); } ClassLoader oldClassloader = Thread.currentThread().getContextClassLoader(); String filter = getApplicationContextFilter(bundleContext.getBundle().getSymbolicName()); ServiceReference<?>[] references = null; try { references = bundleContext.getServiceReferences(getContainerClass().getName(), filter); } catch (InvalidSyntaxException e) { throw new IllegalStateException("not possible", e); } if (references == null || references.length == 0) { throw new IllegalStateException( String.format( "Found zero service references for %s; this is not OK...", bundleContext.getBundle().getSymbolicName())); } try { Thread.currentThread().setContextClassLoader(parent.getClassLoader()); final BeanReactor<Container> strategy = createStrategy(); for (ServiceReference<?> serviceReference : references) { @SuppressWarnings("unchecked") final Container service = (Container) bundleContext.getService(serviceReference); try { if (!strategy.containsBean(service)) { continue; } return new ProxyTarget() { public Object getTarget() { return strategy.createBean(service); } }; } finally { bundleContext.ungetService(serviceReference); } } } finally { Thread.currentThread().setContextClassLoader(oldClassloader); } throw new IllegalStateException( String.format( "Bundle %s can no longer attach bean %s, class %s to page %s", bundleContext.getBundle().getSymbolicName(), beanType.getName(), beanType.getName(), parent.getName())); }
/* * (non-Javadoc) * * @see * org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext * ) */ @SuppressWarnings({"rawtypes", "unchecked"}) public void start(BundleContext context) throws Exception { super.start(context); plugin = this; DebugOptions service = null; final ServiceReference reference = context.getServiceReference(DebugOptions.class.getName()); if (reference != null) service = (DebugOptions) context.getService(reference); if (service == null) return; try { LOGGING = service.getBooleanOption("org.eclipse.rcptt.tesla.core.am/logging", false); } finally { // we have what we want - release the service context.ungetService(reference); } }
@Override public void run() { while (!stop) { ServiceObjects<String> serviceObjects = ctx.getServiceObjects(ref); try { String svc = serviceObjects.getService(); if (!"bar".equals(svc)) System.out.println("Bad Service!"); else counter++; // serviceObjects.ungetService(svc); } finally { ctx.ungetService(ref); } } System.out.println("Thread done (" + getClass().getSimpleName() + ")"); }
private void setDebugEnabled(final BundleContext bundleContext) { final ServiceReference<?> debugOptionsReference = bundleContext.getServiceReference(DebugOptions.class.getName()); if (debugOptionsReference != null) { final DebugOptions debugOptions = (DebugOptions) bundleContext.getService(debugOptionsReference); if (debugOptions != null) { Log.debugEnabled = debugOptions.getBooleanOption( "org.eclipse.equinox.weaving.caching/debug", false); // $NON-NLS-1$ } } if (debugOptionsReference != null) { bundleContext.ungetService(debugOptionsReference); } }
@SuppressWarnings("PMD.SystemPrintln") private void logError(String message, Throwable throwable) { ServiceReference lRef = bundleContext.getServiceReference(LogService.class.getName()); if (lRef != null) { try { LogService logService = (LogService) bundleContext.getService(lRef); if (logService != null) { logService.log(LogService.LOG_ERROR, message, throwable); return; } } finally { bundleContext.ungetService(lRef); } } System.err.println("Jolokia-Error: " + message + " : " + throwable.getMessage()); }
@Override public void start(BundleContext bundleContext) throws Exception { ServiceReference<ConfigurationAdmin> serviceReference = bundleContext.getServiceReference(ConfigurationAdmin.class); try { ConfigurationAdmin configurationAdmin = bundleContext.getService(serviceReference); _cxfConfiguration = configurationAdmin.createFactoryConfiguration( "com.liferay.portal.cxf.common.configuration." + "CXFEndpointPublisherConfiguration", null); Dictionary<String, Object> properties = new Hashtable<>(); properties.put("contextPath", "/soap-test"); _cxfConfiguration.update(properties); _jaxWsApiConfiguration = configurationAdmin.getConfiguration( "com.liferay.portal.soap.extender.configuration." + "JaxWsApiConfiguration", null); properties = new Hashtable<>(); properties.put("contextPath", "/soap-test"); properties.put("timeout", 10000); _jaxWsApiConfiguration.update(properties); _soapConfiguration = configurationAdmin.createFactoryConfiguration( "com.liferay.portal.soap.extender.configuration." + "SoapExtenderConfiguration", null); properties = new Hashtable<>(); properties.put("contextPaths", new String[] {"/soap-test"}); properties.put("jaxWsHandlerFilterStrings", new String[] {"(soap.address=*)"}); properties.put("jaxWsServiceFilterStrings", new String[] {"(jaxws=true)"}); _soapConfiguration.update(properties); } finally { bundleContext.ungetService(serviceReference); } }
/** * Helper method to create an {@link Action}. * * @param nsPrefix * @param name * @return * @deprecated Use {@link StorySchemaCatalog#createAction(Class)}. */ @Deprecated public static <T extends Action> T createAction(@Nonnull final Class<T> targetClass) { final BundleContext bundleContext = FrameworkUtil.getBundle(StoryUtils.class).getBundleContext(); final ServiceReference<StorySchemaCatalog> storySchemaCatalogRef = Preconditions.checkNotNull( bundleContext.getServiceReference(StorySchemaCatalog.class), "Cannot get %s service reference", StorySchemaCatalog.class.getName()); final StorySchemaCatalog storySchemaCatalog = Preconditions.checkNotNull( bundleContext.getService(storySchemaCatalogRef), "Cannot get %s service", StorySchemaCatalog.class.getName()); try { final ActionType actionType = Iterables.find( storySchemaCatalog.getActionTypes(), new Predicate<ActionType>() { @Override public boolean apply(@Nullable final ActionType input) { return targetClass.equals(input.getJavaClass()); } }); return (T) actionType.create(); } catch (final NoSuchElementException e) { final Function<ActionType, String> targetTypeQName = new Function<ActionType, String>() { @Override @Nullable public String apply(@Nullable ActionType input) { return input.getJavaClass().getName(); } }; final List<String> supportedActionTypeQNames = Lists.transform(storySchemaCatalog.getActionTypes(), targetTypeQName); throw new StoryException( String.format( "Cannot find action type %s, %s supported types are: %s", targetClass.getName(), supportedActionTypeQNames.size(), supportedActionTypeQNames), e); } finally { bundleContext.ungetService(storySchemaCatalogRef); } }
/** * Returns the bundles with the given name. * * @param bundleName The bundle name. * @return The bundles with the given name. */ public static Bundle[] getBundles(String bundleName) { Bundle[] bundle = null; BundleContext context = AcceleoCommonPlugin.getDefault().getContext(); ServiceReference packageAdminReference = context.getServiceReference(PackageAdmin.class.getName()); PackageAdmin packageAdmin = null; if (packageAdminReference != null) { packageAdmin = (PackageAdmin) context.getService(packageAdminReference); } if (packageAdmin != null) { bundle = packageAdmin.getBundles(bundleName, null); } if (packageAdminReference != null) { context.ungetService(packageAdminReference); } return bundle; }
private <S> S getService(Class<S> clazz, String filter) { BundleContext context = Activator.getContext(); if (context == null) return null; Collection<ServiceReference<S>> references; try { references = context.getServiceReferences(clazz, filter); } catch (InvalidSyntaxException e) { // TODO Auto-generated catch block return null; } if (references == null || references.size() == 0) return null; ServiceReference<S> ref = references.iterator().next(); S result = context.getService(ref); context.ungetService(ref); return result; }