private BundleRevisionDTO getBundleRevisionDTO(BundleRevision revision) {
   if (revision == null) {
     return null;
   }
   BundleRevisionDTO dto = resources.get(revision);
   if (dto != null) {
     return dto;
   }
   dto = new BundleRevisionDTO();
   dto.id = identifier(revision);
   resources.put(revision, dto);
   dto.bundle = revision.getBundle().getBundleId();
   dto.symbolicName = revision.getSymbolicName();
   dto.type = revision.getTypes();
   dto.version = revision.getVersion().toString();
   dto.capabilities = getListCapabilityDTO(revision.getDeclaredCapabilities(null));
   dto.requirements = getListRequirementDTO(revision.getDeclaredRequirements(null));
   return dto;
 }
Exemplo n.º 2
0
  /**
   * Add an extension bundle. The bundle will be added to the parent classloader and it's exported
   * packages will be added to the module definition exports of this instance. Subsequently, they
   * are available form the instance in it's role as content loader.
   *
   * @param felix the framework instance the given extension bundle comes from.
   * @param bundle the extension bundle to add.
   * @throws BundleException if extension bundles are not supported or this is not a framework
   *     extension.
   * @throws SecurityException if the caller does not have the needed
   *     AdminPermission.EXTENSIONLIFECYCLE and security is enabled.
   * @throws Exception in case something goes wrong.
   */
  synchronized void addExtensionBundle(Felix felix, BundleImpl bundle)
      throws SecurityException, BundleException, Exception {
    Object sm = System.getSecurityManager();
    if (sm != null) {
      ((SecurityManager) sm)
          .checkPermission(new AdminPermission(bundle, AdminPermission.EXTENSIONLIFECYCLE));
    }

    if (!((BundleProtectionDomain) bundle.getProtectionDomain())
        .impliesDirect(new AllPermission())) {
      throw new SecurityException("Extension Bundles must have AllPermission");
    }

    String directive =
        ManifestParser.parseExtensionBundleHeader(
            (String)
                ((BundleRevisionImpl) bundle.adapt(BundleRevision.class))
                    .getHeaders()
                    .get(Constants.FRAGMENT_HOST));

    // We only support classpath extensions (not bootclasspath).
    if (!Constants.EXTENSION_FRAMEWORK.equals(directive)) {
      throw new BundleException(
          "Unsupported Extension Bundle type: " + directive,
          new UnsupportedOperationException("Unsupported Extension Bundle type!"));
    }

    try {
      // Merge the exported packages with the exported packages of the systembundle.
      List<BundleCapability> exports = null;
      try {
        exports =
            ManifestParser.parseExportHeader(
                m_logger,
                m_systemBundleRevision,
                (String)
                    ((BundleRevisionImpl) bundle.adapt(BundleRevision.class))
                        .getHeaders()
                        .get(Constants.EXPORT_PACKAGE),
                m_systemBundleRevision.getSymbolicName(),
                m_systemBundleRevision.getVersion());
        exports = aliasSymbolicName(exports);
      } catch (Exception ex) {
        m_logger.log(
            bundle,
            Logger.LOG_ERROR,
            "Error parsing extension bundle export statement: "
                + ((BundleRevisionImpl) bundle.adapt(BundleRevision.class))
                    .getHeaders()
                    .get(Constants.EXPORT_PACKAGE),
            ex);
        return;
      }

      // Add the bundle as extension if we support extensions
      if (m_extensionManager != null) {
        // This needs to be the private instance.
        m_extensionManager.addExtension(felix, bundle);
      } else {
        // We don't support extensions (i.e., the parent is not an URLClassLoader).
        m_logger.log(
            bundle,
            Logger.LOG_WARNING,
            "Unable to add extension bundle to FrameworkClassLoader - Maybe not an URLClassLoader?");
        throw new UnsupportedOperationException(
            "Unable to add extension bundle to FrameworkClassLoader - Maybe not an URLClassLoader?");
      }
      appendCapabilities(exports);
    } catch (Exception ex) {
      throw ex;
    }

    BundleRevisionImpl bri = (BundleRevisionImpl) bundle.adapt(BundleRevision.class);
    List<BundleRequirement> reqs = bri.getDeclaredRequirements(BundleRevision.HOST_NAMESPACE);
    List<BundleCapability> caps = getCapabilities(BundleRevision.HOST_NAMESPACE);
    BundleWire bw = new BundleWireImpl(bri, reqs.get(0), m_systemBundleRevision, caps.get(0));
    bri.resolve(
        new BundleWiringImpl(
            m_logger,
            m_configMap,
            null,
            bri,
            null,
            Collections.singletonList(bw),
            Collections.EMPTY_MAP,
            Collections.EMPTY_MAP));
    felix.getDependencies().addDependent(bw);
    felix.setBundleStateAndNotify(bundle, Bundle.RESOLVED);
  }
  private List<Definition> resolveAspectsForBundle(
      final List<String> fingerprintElements,
      final Bundle bundle,
      final BundleRevision bundleRevision) {
    final List<Definition> result = new ArrayList<Definition>();
    final BundleWiring wiring = bundleRevision.getWiring();

    if (wiring != null && weavingBundleContext != null) {

      Definition aspects = null;

      // fragments
      for (final BundleWire hostWire : wiring.getProvidedWires(HostNamespace.HOST_NAMESPACE)) {
        final Bundle fragmentBundle = hostWire.getRequirer().getBundle();
        if (fragmentBundle != null) {
          aspects = aspectAdmin.getAspectDefinition(fragmentBundle);
          if (aspects != null) {
            result.add(aspects);
            fingerprintElements.add(
                fragmentBundle.getSymbolicName()
                    + ":" //$NON-NLS-1$
                    + hostWire.getRequirer().getVersion().toString());
          }
        }
      }

      // required bundles
      final List<BundleWire> requiredBundles =
          wiring.getRequiredWires(BundleNamespace.BUNDLE_NAMESPACE);
      ManifestElement[] requireHeaders = null;
      if (!requiredBundles.isEmpty()) {
        try {
          requireHeaders =
              ManifestElement.parseHeader(
                  Constants.REQUIRE_BUNDLE,
                  bundle.getHeaders("").get(Constants.REQUIRE_BUNDLE)); // $NON-NLS-1$
        } catch (final BundleException e) {
        }
      }
      for (final BundleWire requiredBundleWire : requiredBundles) {
        final Bundle requiredBundle = requiredBundleWire.getProvider().getBundle();
        if (requiredBundle != null) {
          final int applyPolicy =
              getApplyAspectsPolicy(requireHeaders, requiredBundle.getSymbolicName());

          aspects = aspectAdmin.resolveRequiredBundle(requiredBundle, applyPolicy);

          if (aspects != null) {
            result.add(aspects);
            fingerprintElements.add(
                requiredBundle.getSymbolicName()
                    + ":" //$NON-NLS-1$
                    + requiredBundleWire.getProvider().getVersion().toString());
          }
        }
      }

      // imported packages
      final List<BundleWire> importedPackages =
          wiring.getRequiredWires(PackageNamespace.PACKAGE_NAMESPACE);
      ManifestElement[] importHeaders = null;
      if (!importedPackages.isEmpty()) {
        try {
          importHeaders =
              ManifestElement.parseHeader(
                  Constants.IMPORT_PACKAGE,
                  bundle.getHeaders("").get(Constants.IMPORT_PACKAGE)); // $NON-NLS-1$
        } catch (final BundleException e) {
        }
      }
      for (final BundleWire importPackageWire : importedPackages) {
        final Bundle exportingBundle = importPackageWire.getProvider().getBundle();
        if (exportingBundle != null) {
          final String importedPackage =
              (String)
                  importPackageWire
                      .getCapability()
                      .getAttributes()
                      .get(PackageNamespace.PACKAGE_NAMESPACE);

          final int applyPolicy = getApplyAspectsPolicy(importHeaders, importedPackage);

          aspects =
              aspectAdmin.resolveImportedPackage(exportingBundle, importedPackage, applyPolicy);

          if (aspects != null) {
            result.add(aspects);
            final Object v =
                importPackageWire
                    .getCapability()
                    .getAttributes()
                    .get(PackageNamespace.CAPABILITY_VERSION_ATTRIBUTE);
            final String version = v == null ? Version.emptyVersion.toString() : v.toString();
            fingerprintElements.add(
                importedPackage
                    + ":" //$NON-NLS-1$
                    + version);
          }
        }
      }

      // supplementers
      final Supplementer[] supplementers =
          this.supplementerRegistry.getSupplementers(bundleRevision.getBundle().getBundleId());

      for (int i = 0; i < supplementers.length; i++) {
        aspects =
            aspectAdmin.getExportedAspectDefinitions(supplementers[i].getSupplementerBundle());
        if (aspects != null) {
          result.add(aspects);
          fingerprintElements.add(
              supplementers[i].getSymbolicName()
                  + ":" //$NON-NLS-1$
                  + getBundleVersion(supplementers[i].getSupplementerBundle()));
        }
      }

      // this bundle
      aspects = aspectAdmin.getAspectDefinition(bundle);
      if (aspects != null) {
        final String finishedValue =
            bundle
                .getHeaders("")
                .get( //$NON-NLS-1$
                    AspectAdmin.AOP_BUNDLE_FINISHED_HEADER);
        if (finishedValue == null || !AspectAdmin.AOP_BUNDLE_FINISHED_VALUE.equals(finishedValue)) {
          result.add(aspects);
          fingerprintElements.add(
              bundle.getSymbolicName()
                  + ":" //$NON-NLS-1$
                  + bundleRevision.getVersion().toString());
        }
      }
    }

    return result;
  }