コード例 #1
0
 public static BundleWiringDTO newBundleWiringDTO(BundleRevision revision) {
   if (revision == null) {
     return null;
   }
   BundleWiringDTO dto = new DTOBuilder().getBundleWiringDTO(revision.getWiring());
   return dto;
 }
コード例 #2
0
    public boolean isAssignableTo(Bundle requester, String className) {
      // Always return true if the requester is the same as the provider.
      if (requester == m_bundle) {
        return true;
      }

      // Boolean flag.
      boolean allow = true;
      // Get the package.
      String pkgName = Util.getClassPackage(className);
      // Get package wiring from service requester.
      BundleRevision requesterRevision = requester.adapt(BundleRevision.class);
      BundleWire requesterWire = Util.getWire(requesterRevision, pkgName);
      BundleCapability requesterCap = Util.getPackageCapability(requesterRevision, pkgName);
      // Get package wiring from service provider.
      BundleRevision providerRevision = m_bundle.adapt(BundleRevision.class);
      BundleWire providerWire = Util.getWire(providerRevision, pkgName);
      BundleCapability providerCap = Util.getPackageCapability(providerRevision, pkgName);

      // There are four situations that may occur here:
      //   1. Neither the requester, nor provider have wires for the package.
      //   2. The requester does not have a wire for the package.
      //   3. The provider does not have a wire for the package.
      //   4. Both the requester and provider have a wire for the package.
      // For case 1, if the requester does not have access to the class at
      // all, we assume it is using reflection and do not filter. If the
      // requester does have access to the class, then we make sure it is
      // the same class as the service. For case 2, we do not filter if the
      // requester is the exporter of the package to which the provider of
      // the service is wired. Otherwise, as in case 1, if the requester
      // does not have access to the class at all, we do not filter, but if
      // it does have access we check if it is the same class accessible to
      // the providing revision. For case 3, the provider will not have a wire
      // if it is exporting the package, so we determine if the requester
      // is wired to it or somehow using the same class. For case 4, we
      // simply compare the exporting revisions from the package wiring to
      // determine if we need to filter the service reference.

      // Case 1: Both requester and provider have no wire.
      if ((requesterWire == null) && (providerWire == null)) {
        // If requester has no access then true, otherwise service
        // registration must have same class as requester.
        try {
          Class requestClass =
              ((BundleWiringImpl) requesterRevision.getWiring()).getClassByDelegation(className);
          allow = getRegistration().isClassAccessible(requestClass);
        } catch (Exception ex) {
          // Requester has no access to the class, so allow it, since
          // we assume the requester is using reflection.
          allow = true;
        }
      }
      // Case 2: Requester has no wire, but provider does.
      else if ((requesterWire == null) && (providerWire != null)) {
        // If the requester exports the package, then the provider must
        // be wired to it.
        if (requesterCap != null) {
          allow = providerWire.getProviderWiring().getRevision().equals(requesterRevision);
        }
        // Otherwise, check if the requester has access to the class and,
        // if so, if it is the same class as the provider.
        else {
          try {
            // Try to load class from requester.
            Class requestClass =
                ((BundleWiringImpl) requesterRevision.getWiring()).getClassByDelegation(className);
            try {
              // If requester has access to the class, verify it is the
              // same class as the provider.
              allow =
                  (((BundleWiringImpl) providerRevision.getWiring()).getClassByDelegation(className)
                      == requestClass);
            } catch (Exception ex) {
              allow = false;
            }
          } catch (Exception ex) {
            // Requester has no access to the class, so allow it, since
            // we assume the requester is using reflection.
            allow = true;
          }
        }
      }
      // Case 3: Requester has a wire, but provider does not.
      else if ((requesterWire != null) && (providerWire == null)) {
        // If the provider exports the package, then the requester must
        // be wired to it.
        if (providerCap != null) {
          allow = requesterWire.getProviderWiring().getRevision().equals(providerRevision);
        }
        // If the provider is not the exporter of the requester's package,
        // then try to use the service registration to see if the requester's
        // class is accessible.
        else {
          try {
            // Load the class from the requesting bundle.
            Class requestClass =
                ((BundleWiringImpl) requesterRevision.getWiring()).getClassByDelegation(className);
            // Get the service registration and ask it to check
            // if the service object is assignable to the requesting
            // bundle's class.
            allow = getRegistration().isClassAccessible(requestClass);
          } catch (Exception ex) {
            // Filter to be safe.
            allow = false;
          }
        }
      }
      // Case 4: Both requester and provider have a wire.
      else {
        // Include service reference if the wires have the
        // same source revision.
        allow =
            providerWire
                .getProviderWiring()
                .getRevision()
                .equals(requesterWire.getProviderWiring().getRevision());
      }

      return allow;
    }
コード例 #3
0
  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;
  }