| /******************************************************************************* | |
| * Copyright (c) 2010 Oracle. | |
| * All rights reserved. This program and the accompanying materials | |
| * are made available under the terms of the Eclipse Public License v1.0 | |
| * and Apache License v2.0 which accompanies this distribution. | |
| * The Eclipse Public License is available at | |
| * http://www.eclipse.org/legal/epl-v10.html | |
| * and the Apache License v2.0 is available at | |
| * http://www.opensource.org/licenses/apache2.0.php. | |
| * You may elect to redistribute this code under either of these licenses. | |
| * | |
| * Contributors: | |
| * Hal Hildebrand - Initial JMX support | |
| ******************************************************************************/ | |
| package org.eclipse.gemini.mgmt.framework.internal; | |
| import static org.osgi.framework.Constants.SERVICE_ID; | |
| import java.io.IOException; | |
| import java.util.ArrayList; | |
| import java.util.Arrays; | |
| import java.util.Dictionary; | |
| import java.util.Enumeration; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import javax.management.openmbean.CompositeData; | |
| import javax.management.openmbean.CompositeDataSupport; | |
| import javax.management.openmbean.CompositeType; | |
| import javax.management.openmbean.OpenDataException; | |
| import javax.management.openmbean.TabularData; | |
| import javax.management.openmbean.TabularDataSupport; | |
| import org.eclipse.gemini.mgmt.framework.CustomBundleStateMBean; | |
| import org.eclipse.gemini.mgmt.internal.BundleUtil; | |
| import org.osgi.framework.Bundle; | |
| import org.osgi.framework.ServiceReference; | |
| import org.osgi.framework.wiring.BundleRevision; | |
| import org.osgi.framework.wiring.BundleWire; | |
| import org.osgi.framework.wiring.BundleWiring; | |
| import org.osgi.jmx.Item; | |
| import org.osgi.jmx.framework.BundleStateMBean; | |
| /** | |
| * <p> | |
| * This class represents the CODEC for the composite data representing a single | |
| * OSGi <link>Bundle</link>. | |
| * <p> | |
| * It serves as both the documentation of the type structure and as the | |
| * codification of the mechanism to convert to/from the CompositeData. | |
| * <p> | |
| */ | |
| public final class OSGiBundle { | |
| private Bundle bundle; | |
| /** | |
| * Construct an OSGiBundle representation | |
| * | |
| * @param b - the Bundle to represent | |
| */ | |
| public OSGiBundle(Bundle b) { | |
| this.bundle = b; | |
| } | |
| public static TabularData tableFrom(List<OSGiBundle> bundles, String... bundleTypeItems) throws IOException { | |
| List<String> bundleTypes = Arrays.asList(bundleTypeItems); | |
| CompositeType computeBundleType = OSGiBundle.computeBundleType(bundleTypes); | |
| TabularDataSupport table = new TabularDataSupport(Item.tabularType("BUNDLES", "A list of bundles", computeBundleType, new String[] { BundleStateMBean.IDENTIFIER })); | |
| for (OSGiBundle bundle : bundles) { | |
| table.put(bundle.asCompositeData(computeBundleType, bundleTypes)); | |
| } | |
| return table; | |
| } | |
| private static CompositeType computeBundleType(List<String> bundleTypes) { | |
| List<Item> bundleTypeItems = new ArrayList<Item>(); | |
| bundleTypeItems.add(BundleStateMBean.IDENTIFIER_ITEM); | |
| if(bundleTypes.contains(BundleStateMBean.LOCATION)) { | |
| bundleTypeItems.add(BundleStateMBean.LOCATION_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.SYMBOLIC_NAME)) { | |
| bundleTypeItems.add(BundleStateMBean.SYMBOLIC_NAME_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.VERSION)) { | |
| bundleTypeItems.add(BundleStateMBean.VERSION_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.START_LEVEL)) { | |
| bundleTypeItems.add(BundleStateMBean.START_LEVEL_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.STATE)) { | |
| bundleTypeItems.add(BundleStateMBean.STATE_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.LAST_MODIFIED)) { | |
| bundleTypeItems.add(BundleStateMBean.LAST_MODIFIED_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.PERSISTENTLY_STARTED)) { | |
| bundleTypeItems.add(BundleStateMBean.PERSISTENTLY_STARTED_ITEM); | |
| } | |
| if(bundleTypes.contains(CustomBundleStateMBean.ACTIVATION_POLICY)) { | |
| bundleTypeItems.add(CustomBundleStateMBean.ACTIVATION_POLICY_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REMOVAL_PENDING)) { | |
| bundleTypeItems.add(BundleStateMBean.REMOVAL_PENDING_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REQUIRED)) { | |
| bundleTypeItems.add(BundleStateMBean.REQUIRED_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.FRAGMENT)) { | |
| bundleTypeItems.add(BundleStateMBean.FRAGMENT_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REGISTERED_SERVICES)) { | |
| bundleTypeItems.add(BundleStateMBean.REGISTERED_SERVICES_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.SERVICES_IN_USE)) { | |
| bundleTypeItems.add(BundleStateMBean.SERVICES_IN_USE_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.HEADERS)) { | |
| bundleTypeItems.add(BundleStateMBean.HEADERS_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.EXPORTED_PACKAGES)) { | |
| bundleTypeItems.add(BundleStateMBean.EXPORTED_PACKAGES_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.IMPORTED_PACKAGES)) { | |
| bundleTypeItems.add(BundleStateMBean.IMPORTED_PACKAGES_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.FRAGMENTS)) { | |
| bundleTypeItems.add(BundleStateMBean.FRAGMENTS_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.HOSTS)) { | |
| bundleTypeItems.add(BundleStateMBean.HOSTS_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REQUIRING_BUNDLES)) { | |
| bundleTypeItems.add(BundleStateMBean.REQUIRING_BUNDLES_ITEM); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REQUIRED_BUNDLES)) { | |
| bundleTypeItems.add(BundleStateMBean.REQUIRED_BUNDLES_ITEM); | |
| } | |
| CompositeType currentCompositeType = Item.compositeType("BUNDLE", "This type encapsulates OSGi bundles", bundleTypeItems.toArray(new Item[]{})); | |
| return currentCompositeType; | |
| } | |
| private CompositeData asCompositeData(CompositeType computeBundleType, List<String> bundleTypes) throws IOException { | |
| Map<String, Object> items = new HashMap<String, Object>(); | |
| items.put(BundleStateMBean.IDENTIFIER, getIdentifier()); | |
| if(bundleTypes.contains(BundleStateMBean.LOCATION)) { | |
| items.put(BundleStateMBean.LOCATION, getLocation()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.SYMBOLIC_NAME)) { | |
| items.put(BundleStateMBean.SYMBOLIC_NAME, getSymbolicName()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.VERSION)) { | |
| items.put(BundleStateMBean.VERSION, getVersion()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.START_LEVEL)) { | |
| items.put(BundleStateMBean.START_LEVEL, getStartLevel()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.STATE)) { | |
| items.put(BundleStateMBean.STATE, getState()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.LAST_MODIFIED)) { | |
| items.put(BundleStateMBean.LAST_MODIFIED, getLastModified()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.PERSISTENTLY_STARTED)) { | |
| items.put(BundleStateMBean.PERSISTENTLY_STARTED, isPersistentlyStarted()); | |
| } | |
| if(bundleTypes.contains(CustomBundleStateMBean.ACTIVATION_POLICY)) { | |
| items.put(CustomBundleStateMBean.ACTIVATION_POLICY_USED, isActivationPolicyUsed()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REMOVAL_PENDING)) { | |
| items.put(BundleStateMBean.REMOVAL_PENDING, isRemovalPending()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REQUIRED)) { | |
| items.put(BundleStateMBean.REQUIRED, isRequired()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.FRAGMENT)) { | |
| items.put(BundleStateMBean.FRAGMENT, isFragment()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REGISTERED_SERVICES)) { | |
| items.put(BundleStateMBean.REGISTERED_SERVICES, getRegisteredServices()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.SERVICES_IN_USE)) { | |
| items.put(BundleStateMBean.SERVICES_IN_USE, getServicesInUse()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.HEADERS)) { | |
| items.put(BundleStateMBean.HEADERS, headerTable(getHeaders())); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.EXPORTED_PACKAGES)) { | |
| items.put(BundleStateMBean.EXPORTED_PACKAGES, getExportedPackages()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.IMPORTED_PACKAGES)) { | |
| items.put(BundleStateMBean.IMPORTED_PACKAGES, getImportedPackages()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.FRAGMENTS)) { | |
| items.put(BundleStateMBean.FRAGMENTS, getFragments()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.HOSTS)) { | |
| items.put(BundleStateMBean.HOSTS, getHosts()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REQUIRING_BUNDLES)) { | |
| items.put(BundleStateMBean.REQUIRING_BUNDLES, getRequiringBundles()); | |
| } | |
| if(bundleTypes.contains(BundleStateMBean.REQUIRED_BUNDLES)) { | |
| items.put(BundleStateMBean.REQUIRED_BUNDLES, getRequiredBundles()); | |
| } | |
| try { | |
| return new CompositeDataSupport(computeBundleType, items); | |
| } catch (OpenDataException e) { | |
| throw new IllegalStateException("Cannot form bundle open data", e); | |
| } | |
| } | |
| /** | |
| * Answer the TabularData representing the list of OSGiBundle state | |
| * | |
| * @param bundles - the list of bundles to represent | |
| * @param mask | |
| * | |
| * @return the Tabular data which represents the list of bundles | |
| * @throws IOException | |
| */ | |
| public static TabularData tableFrom(List<OSGiBundle> bundles, int mask) throws IOException { | |
| CompositeType computeBundleType = OSGiBundle.computeBundleType(mask); | |
| TabularDataSupport table = new TabularDataSupport(Item.tabularType("BUNDLES", "A list of bundles", computeBundleType, new String[] { BundleStateMBean.IDENTIFIER })); | |
| for (OSGiBundle bundle : bundles) { | |
| table.put(bundle.asCompositeData(computeBundleType, mask)); | |
| } | |
| return table; | |
| } | |
| private static CompositeType computeBundleType(int mask) { | |
| List<Item> bundleTypeItems = new ArrayList<Item>(); | |
| bundleTypeItems.add(BundleStateMBean.IDENTIFIER_ITEM); | |
| if((mask | CustomBundleStateMBean.LOCATION) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.LOCATION_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.SYMBOLIC_NAME) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.SYMBOLIC_NAME_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.VERSION) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.VERSION_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.START_LEVEL) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.START_LEVEL_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.STATE) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.STATE_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.LAST_MODIFIED) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.LAST_MODIFIED_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.PERSISTENTLY_STARTED) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.PERSISTENTLY_STARTED_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.ACTIVATION_POLICY) == mask) { | |
| bundleTypeItems.add(CustomBundleStateMBean.ACTIVATION_POLICY_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.REMOVAL_PENDING) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.REMOVAL_PENDING_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.REQUIRED) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.REQUIRED_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.FRAGMENT) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.FRAGMENT_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.REGISTERED_SERVICES) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.REGISTERED_SERVICES_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.SERVICES_IN_USE) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.SERVICES_IN_USE_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.HEADERS) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.HEADERS_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.EXPORTED_PACKAGES) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.EXPORTED_PACKAGES_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.IMPORTED_PACKAGES) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.IMPORTED_PACKAGES_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.FRAGMENTS) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.FRAGMENTS_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.HOSTS) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.HOSTS_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.REQUIRING_BUNDLES) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.REQUIRING_BUNDLES_ITEM); | |
| } | |
| if((mask | CustomBundleStateMBean.REQUIRED_BUNDLES) == mask) { | |
| bundleTypeItems.add(BundleStateMBean.REQUIRED_BUNDLES_ITEM); | |
| } | |
| CompositeType currentCompositeType = Item.compositeType("BUNDLE", "This type encapsulates OSGi bundles", bundleTypeItems.toArray(new Item[]{})); | |
| return currentCompositeType; | |
| } | |
| /** | |
| * Answer the receiver encoded as CompositeData | |
| * @param mask | |
| * | |
| * @return the CompositeData encoding of the receiver. | |
| * @throws IOException | |
| */ | |
| private CompositeData asCompositeData(CompositeType computeBundleType, int mask) throws IOException { | |
| Map<String, Object> items = new HashMap<String, Object>(); | |
| items.put(BundleStateMBean.IDENTIFIER, getIdentifier()); | |
| if((mask | CustomBundleStateMBean.LOCATION) == mask) { | |
| items.put(BundleStateMBean.LOCATION, getLocation()); | |
| } | |
| if((mask | CustomBundleStateMBean.SYMBOLIC_NAME) == mask) { | |
| items.put(BundleStateMBean.SYMBOLIC_NAME, getSymbolicName()); | |
| } | |
| if((mask | CustomBundleStateMBean.VERSION) == mask) { | |
| items.put(BundleStateMBean.VERSION, getVersion()); | |
| } | |
| if((mask | CustomBundleStateMBean.START_LEVEL) == mask) { | |
| items.put(BundleStateMBean.START_LEVEL, getStartLevel()); | |
| } | |
| if((mask | CustomBundleStateMBean.STATE) == mask) { | |
| items.put(BundleStateMBean.STATE, getState()); | |
| } | |
| if((mask | CustomBundleStateMBean.LAST_MODIFIED) == mask) { | |
| items.put(BundleStateMBean.LAST_MODIFIED, getLastModified()); | |
| } | |
| if((mask | CustomBundleStateMBean.PERSISTENTLY_STARTED) == mask) { | |
| items.put(BundleStateMBean.PERSISTENTLY_STARTED, isPersistentlyStarted()); | |
| } | |
| if((mask | CustomBundleStateMBean.ACTIVATION_POLICY) == mask) { | |
| items.put(CustomBundleStateMBean.ACTIVATION_POLICY_USED, isActivationPolicyUsed()); | |
| } | |
| if((mask | CustomBundleStateMBean.REMOVAL_PENDING) == mask) { | |
| items.put(BundleStateMBean.REMOVAL_PENDING, isRemovalPending()); | |
| } | |
| if((mask | CustomBundleStateMBean.REQUIRED) == mask) { | |
| items.put(BundleStateMBean.REQUIRED, isRequired()); | |
| } | |
| if((mask | CustomBundleStateMBean.FRAGMENT) == mask) { | |
| items.put(BundleStateMBean.FRAGMENT, isFragment()); | |
| } | |
| if((mask | CustomBundleStateMBean.REGISTERED_SERVICES) == mask) { | |
| items.put(BundleStateMBean.REGISTERED_SERVICES, getRegisteredServices()); | |
| } | |
| if((mask | CustomBundleStateMBean.SERVICES_IN_USE) == mask) { | |
| items.put(BundleStateMBean.SERVICES_IN_USE, getServicesInUse()); | |
| } | |
| if((mask | CustomBundleStateMBean.HEADERS) == mask) { | |
| items.put(BundleStateMBean.HEADERS, headerTable(getHeaders())); | |
| } | |
| if((mask | CustomBundleStateMBean.EXPORTED_PACKAGES) == mask) { | |
| items.put(BundleStateMBean.EXPORTED_PACKAGES, getExportedPackages()); | |
| } | |
| if((mask | CustomBundleStateMBean.IMPORTED_PACKAGES) == mask) { | |
| items.put(BundleStateMBean.IMPORTED_PACKAGES, getImportedPackages()); | |
| } | |
| if((mask | CustomBundleStateMBean.FRAGMENTS) == mask) { | |
| items.put(BundleStateMBean.FRAGMENTS, getFragments()); | |
| } | |
| if((mask | CustomBundleStateMBean.HOSTS) == mask) { | |
| items.put(BundleStateMBean.HOSTS, getHosts()); | |
| } | |
| if((mask | CustomBundleStateMBean.REQUIRING_BUNDLES) == mask) { | |
| items.put(BundleStateMBean.REQUIRING_BUNDLES, getRequiringBundles()); | |
| } | |
| if((mask | CustomBundleStateMBean.REQUIRED_BUNDLES) == mask) { | |
| items.put(BundleStateMBean.REQUIRED_BUNDLES, getRequiredBundles()); | |
| } | |
| try { | |
| return new CompositeDataSupport(computeBundleType, items); | |
| } catch (OpenDataException e) { | |
| throw new IllegalStateException("Cannot form bundle open data", e); | |
| } | |
| } | |
| /** | |
| * Answer the receiver encoded as CompositeData | |
| * @param mask | |
| * | |
| * @return the CompositeData encoding of the receiver. | |
| * @throws IOException | |
| */ | |
| public CompositeData asCompositeData() throws IOException { | |
| Map<String, Object> items = new HashMap<String, Object>(); | |
| items.put(BundleStateMBean.IDENTIFIER, getIdentifier()); | |
| items.put(BundleStateMBean.LOCATION, getLocation()); | |
| items.put(BundleStateMBean.SYMBOLIC_NAME, getSymbolicName()); | |
| items.put(BundleStateMBean.VERSION, getVersion()); | |
| items.put(BundleStateMBean.START_LEVEL, getStartLevel()); | |
| items.put(BundleStateMBean.STATE, getState()); | |
| items.put(BundleStateMBean.LAST_MODIFIED, getLastModified()); | |
| items.put(BundleStateMBean.PERSISTENTLY_STARTED, isPersistentlyStarted()); | |
| items.put(CustomBundleStateMBean.ACTIVATION_POLICY_USED, isActivationPolicyUsed()); | |
| items.put(BundleStateMBean.REMOVAL_PENDING, isRemovalPending()); | |
| items.put(BundleStateMBean.REQUIRED, isRequired()); | |
| items.put(BundleStateMBean.FRAGMENT, isFragment()); | |
| items.put(BundleStateMBean.REGISTERED_SERVICES, getRegisteredServices()); | |
| items.put(BundleStateMBean.SERVICES_IN_USE, getServicesInUse()); | |
| items.put(BundleStateMBean.HEADERS, headerTable(getHeaders())); | |
| items.put(BundleStateMBean.EXPORTED_PACKAGES, getExportedPackages()); | |
| items.put(BundleStateMBean.IMPORTED_PACKAGES, getImportedPackages()); | |
| items.put(BundleStateMBean.FRAGMENTS, getFragments()); | |
| items.put(BundleStateMBean.HOSTS, getHosts()); | |
| items.put(BundleStateMBean.REQUIRING_BUNDLES, getRequiringBundles()); | |
| items.put(BundleStateMBean.REQUIRED_BUNDLES, getRequiredBundles()); | |
| try { | |
| return new CompositeDataSupport(CustomBundleStateMBean.CUSTOM_BUNDLE_TYPE, items); | |
| } catch (OpenDataException e) { | |
| throw new IllegalStateException("Cannot form bundle open data", e); | |
| } | |
| } | |
| /** | |
| * Answer the TabularData representing the supplied map of bundle headers | |
| * | |
| * @param headers | |
| * @return the bundle headers | |
| */ | |
| public static TabularData headerTable(Dictionary<String, String> headersDictionary) { | |
| TabularDataSupport table = new TabularDataSupport(BundleStateMBean.HEADERS_TYPE); | |
| for(Enumeration<String> headers = headersDictionary.keys(); headers.hasMoreElements();) { | |
| String key = (String) headers.nextElement(); | |
| table.put(getHeaderCompositeData(key, (String) headersDictionary.get(key))); | |
| } | |
| return table; | |
| } | |
| public static CompositeData getHeaderCompositeData(String key, String value) { | |
| Map<String, Object> items = new HashMap<String, Object>(); | |
| items.put(BundleStateMBean.KEY, key); | |
| items.put(BundleStateMBean.VALUE, value); | |
| try { | |
| return new CompositeDataSupport(BundleStateMBean.HEADER_TYPE, items); | |
| } catch (OpenDataException e) { | |
| throw new IllegalStateException("Cannot form bundle header open data", e); | |
| } | |
| } | |
| /** | |
| * @return The list of exported packages by this bundle, in the form of | |
| * <packageName>;<version> | |
| * | |
| */ | |
| private String[] getExportedPackages() { | |
| return BundleUtil.getBundleExportedPackages(bundle); | |
| } | |
| /** | |
| * @return the map of headers for this bundle | |
| */ | |
| private Dictionary<String, String> getHeaders() { | |
| return bundle.getHeaders(); | |
| } | |
| /** | |
| * @return the list of identifiers of the bundle fragments which use this | |
| * bundle as a host | |
| */ | |
| private Long[] getFragments() { | |
| BundleWiring wiring = bundle.adapt(BundleWiring.class); | |
| List<BundleWire> requiredWires = wiring.getRequiredWires(BundleRevision.HOST_NAMESPACE); | |
| return bundleWiresToIds(requiredWires); | |
| } | |
| /** | |
| * @return list of identifiers of the bundles which host this fragment | |
| */ | |
| private Long[] getHosts() { | |
| BundleWiring wiring = bundle.adapt(BundleWiring.class); | |
| List<BundleWire> providedWires = wiring.getProvidedWires(BundleRevision.HOST_NAMESPACE); | |
| return bundleWiresToIds(providedWires); | |
| } | |
| /** | |
| * @return the identifier of this bundle | |
| */ | |
| private long getIdentifier() { | |
| return bundle.getBundleId(); | |
| } | |
| /** | |
| * @return The list of imported packages by this bundle, in the form of | |
| * <packageName>;<version> | |
| */ | |
| private String[] getImportedPackages() { | |
| return BundleUtil.getBundleImportedPackages(bundle); | |
| } | |
| /** | |
| * @return the last modified time of this bundle | |
| */ | |
| private long getLastModified() { | |
| return bundle.getLastModified(); | |
| } | |
| /** | |
| * @return the name of this bundle | |
| */ | |
| private String getLocation() { | |
| return bundle.getLocation(); | |
| } | |
| /** | |
| * @return the list of identifiers of the services registered by this bundle | |
| */ | |
| private Long[] getRegisteredServices() { | |
| return serviceIds(bundle.getRegisteredServices()); | |
| } | |
| /** | |
| * @return the list of identifiers of bundles required by this bundle | |
| * @throws IOException | |
| */ | |
| private Long[] getRequiredBundles() throws IOException { | |
| BundleWiring wiring = bundle.adapt(BundleWiring.class); | |
| List<BundleWire> requiredWires = wiring.getRequiredWires(BundleRevision.BUNDLE_NAMESPACE); | |
| return bundleWiresToIds(requiredWires); | |
| } | |
| /** | |
| * @return the list of identifiers of bundles which require this bundle | |
| * @throws IOException | |
| */ | |
| private Long[] getRequiringBundles() throws IOException { | |
| BundleWiring wiring = bundle.adapt(BundleWiring.class); | |
| List<BundleWire> providedWires = wiring.getProvidedWires(BundleRevision.BUNDLE_NAMESPACE); | |
| return bundleWiresToIds(providedWires); | |
| } | |
| /** | |
| * @return the list of identifiers of services in use by this bundle | |
| */ | |
| private Long[] getServicesInUse() { | |
| return serviceIds(bundle.getServicesInUse()); | |
| } | |
| /** | |
| * @return the start level of this bundle | |
| */ | |
| private int getStartLevel() { | |
| return BundleUtil.getBundleStartLevel(bundle); | |
| } | |
| /** | |
| * @return the state of this bundle | |
| */ | |
| private String getState() { | |
| return BundleUtil.getBundleState(bundle); | |
| } | |
| /** | |
| * @return the symbolic name of this bundle | |
| */ | |
| private String getSymbolicName() { | |
| return bundle.getSymbolicName(); | |
| } | |
| /** | |
| * @return the version of this bundle | |
| */ | |
| private String getVersion() { | |
| return bundle.getVersion().toString(); | |
| } | |
| /** | |
| * @return true if this bundle represents a fragment | |
| */ | |
| private boolean isFragment() { | |
| return BundleUtil.isBundleFragment(bundle); | |
| } | |
| /** | |
| * @return true if this bundle is persistently started | |
| */ | |
| private boolean isPersistentlyStarted() { | |
| return BundleUtil.isBundlePersistentlyStarted(bundle); | |
| } | |
| /** | |
| * @return true if this bundle is persistently started | |
| */ | |
| private boolean isActivationPolicyUsed() { | |
| return BundleUtil.isBundleActivationPolicyUsed(bundle); | |
| } | |
| /** | |
| * @return true if this bundle is pending removal | |
| */ | |
| private boolean isRemovalPending() { | |
| return BundleUtil.isRemovalPending(bundle); | |
| } | |
| /** | |
| * @return true if this bundle is required | |
| */ | |
| private boolean isRequired() { | |
| return BundleUtil.isRequired(bundle); | |
| } | |
| private Long[] bundleWiresToIds(List<BundleWire> wires){ | |
| Long[] consumerWirings = new Long[wires.size()]; | |
| int i = 0; | |
| for (BundleWire bundleWire : wires) { | |
| consumerWirings[i] = bundleWire.getRequirerWiring().getBundle().getBundleId(); | |
| i++; | |
| } | |
| return consumerWirings; | |
| } | |
| private Long[] serviceIds(ServiceReference<?>[] refs) { | |
| if (refs == null) { | |
| return new Long[0]; | |
| } | |
| Long[] ids = new Long[refs.length]; | |
| for (int i = 0; i < refs.length; i++) { | |
| ids[i] = (Long) refs[i].getProperty(SERVICE_ID); | |
| } | |
| return ids; | |
| } | |
| } |