/*
* See whether any registered extension provides the class requested. If not
* throw an IOException.
*/
public URLConnection openConnection(URL url) throws IOException {
String path = url.getPath();
if (path.trim().equals("/")) {
return new URLHandlersBundleURLConnection(url);
}
Bundle[] extensions = m_extensionsCache;
URL result = null;
for (Bundle extBundle : extensions) {
try {
BundleRevisionImpl bri = (BundleRevisionImpl) extBundle.adapt(BundleRevision.class);
if (bri != null) {
result = bri.getResourceLocal(path);
}
} catch (Exception ex) {
// Maybe the bundle went away, so ignore this exception.
}
if (result != null) {
return result.openConnection();
}
}
return new URLConnection(url) {
public void connect() throws IOException {
throw new IOException("Resource not provided by any extension!");
}
};
}
/**
* Finds the {@link BundleWire} on the specified bundle for the package name
*
* @param bundleContext Context to use to lookup OSGi services
* @param bundle Bundle to find the {@link BundleWire} on
* @param packageName Name of the import package to find the wiring for
* @return {@link BundleWire} for the specified package or <code>null</code> if none found
*/
public static BundleWire getBundleWire(
BundleContext bundleContext, Bundle bundle, String packageName) {
try {
BundleWire result = null;
final PackageAdmin packageAdmin = getPackageAdmin(bundleContext);
final BundleWiring wiring = bundle.adapt(BundleWiring.class);
if (wiring != null) {
for (BundleWire required : wiring.getRequiredWires(BundleRevision.PACKAGE_NAMESPACE)) {
final org.osgi.service.packageadmin.ExportedPackage[] exportedPackages =
packageAdmin.getExportedPackages(required.getProviderWiring().getBundle());
for (org.osgi.service.packageadmin.ExportedPackage exportedPackage : exportedPackages) {
if (packageName.equals(exportedPackage.getName())) {
result = required;
break;
}
}
if (result != null) {
break;
}
}
}
return result;
} catch (Exception exception) {
throw new RuntimeException(
String.format(
"Failed to determine bundle wiring for bundle: %s Package: %s", bundle, packageName),
exception);
}
}
@Override
public ClassLoader getClassLoader(
String componentName, String componentVersion, ComponentReference componentReference) {
Bundle bundle = getBundle(componentName, componentVersion, componentReference);
BundleWiring bundleWiring = bundle.adapt(BundleWiring.class);
return bundleWiring.getClassLoader();
}
public static boolean isBundleFragment(Bundle bundle) {
boolean result = false;
final BundleRevision revision = bundle.adapt(BundleRevision.class);
if (revision != null) {
result = (revision.getTypes() & BundleRevision.TYPE_FRAGMENT) != 0;
}
return result;
}
protected void verifyBundleWiring() {
Bundle bundle = Mockito.verify(_bundle);
bundle.adapt(BundleWiring.class);
BundleWiring bundleWiring = Mockito.verify(_bundleWiring);
bundleWiring.getClassLoader();
}
/**
* We consider a bundle to be a candidate for objects if it imports at least one of the packages
* of our interfaces
*
* @param bundle
* @return true if the bundle is improting.
*/
private boolean isImportingUs(Bundle bundle) {
BundleWiring wiring = bundle.adapt(BundleWiring.class);
List<BundleWire> imports = wiring.getRequiredWires(PACKAGE_NAMESPACE);
for (BundleWire importWire : imports) {
if (packageCapabilities.contains(importWire.getCapability())) {
return true;
}
}
return false;
}
@Test
public void testUpdateHostToFragment() throws Exception {
Bundle bundleA = installBundle(getHostA());
try {
bundleA.start();
assertBundleState(Bundle.ACTIVE, bundleA.getState());
BundleRevisions brevs = bundleA.adapt(BundleRevisions.class);
assertEquals(1, brevs.getRevisions().size());
BundleRevision brev = brevs.getRevisions().get(0);
assertEquals(0, brev.getTypes());
bundleA.update(toInputStream(getFragmentA()));
brevs = bundleA.adapt(BundleRevisions.class);
Assert.assertNotSame(brev, brevs.getRevisions().get(0));
brev = brevs.getRevisions().get(0);
assertEquals(BundleRevision.TYPE_FRAGMENT, brev.getTypes());
} finally {
bundleA.uninstall();
}
}
private CharSequence print(Bundle bundle) {
// [ ID ] [STATE ] [ SL ] symname
int level = bundle.adapt(BundleStartLevel.class).getStartLevel();
return String.format(
"%5d|%-11s|%5d|%s (%s)",
bundle.getBundleId(),
getState(bundle),
level,
bundle.getSymbolicName(),
bundle.getVersion());
}
/** Display bundle dependencies. */
public static void logBundleWires(final BundleContext context) {
for (final Bundle bundle : context.getBundles()) {
final BundleWiring wiring = bundle.adapt(BundleWiring.class);
System.out.println("# bundle=" + bundle);
final List<BundleWire> provided = wiring.getProvidedWires(null);
for (final BundleWire wire : provided) {
System.out.println("# provided=" + wire);
}
final List<BundleWire> required = wiring.getRequiredWires(null);
for (final BundleWire wire : required) {
System.out.println("# required=" + wire);
}
}
}
@Override
public void setBundleStartLevel(long bundleId, int startLevel) throws PortalException {
_checkPermission();
Bundle bundle = getBundle(bundleId);
if (bundle == null) {
throw new PortalException("No bundle with ID " + bundleId);
}
BundleStartLevel bundleStartLevel = bundle.adapt(BundleStartLevel.class);
bundleStartLevel.setStartLevel(startLevel);
}
/**
* Retrieve the set of dependencies for a given bundle symbolic name.
*
* @param bundleSymbolicName the bundle symbolic name.
* @return a set of bundle symbolic names which are dependencies. An empty set if the bundle has
* not been found.
*/
protected Set<String> getBundleDependencies(String bundleSymbolicName) {
Set<String> dependencies = Sets.newLinkedHashSet();
Bundle currentBundle = Platform.getBundle(bundleSymbolicName);
if (currentBundle != null) {
BundleWiring wiring = currentBundle.adapt(BundleWiring.class);
if (wiring != null) {
for (BundleWire wire : wiring.getRequiredWires(BundleRevision.BUNDLE_NAMESPACE)) {
if (wire.getProvider() != null && wire.getProvider().getBundle() != null) {
dependencies.add(wire.getProvider().getBundle().getSymbolicName());
}
}
}
}
return dependencies;
}
private Bundle findDependencyBundle(Bundle bundle, String dependencyName, Set<Bundle> visited) {
BundleWiring bundleWiring = bundle.adapt(BundleWiring.class);
if (bundleWiring == null) {
return null;
}
ArrayList<BundleWire> dependencies = new ArrayList<BundleWire>();
dependencies.addAll(bundleWiring.getRequiredWires(BundleNamespace.BUNDLE_NAMESPACE));
dependencies.addAll(bundleWiring.getRequiredWires(PackageNamespace.PACKAGE_NAMESPACE));
for (BundleWire wire : dependencies) {
Bundle requiredBundle = wire.getProviderWiring().getBundle();
if (requiredBundle != null && visited.add(requiredBundle)) {
if (dependencyName.equals(requiredBundle.getSymbolicName())) {
return requiredBundle;
}
Bundle required = findDependencyBundle(requiredBundle, dependencyName, visited);
if (required != null) {
return required;
}
}
}
return null;
}
@Override
public ClassLoader getClassLoader(Bundle persistentUnitBundle) {
ClassLoader cla = persistentUnitBundle.adapt(BundleWiring.class).getClassLoader();
final ClassLoader clb = getClass().getClassLoader();
return new ClassLoader(cla) {
@Override
protected Class<?> findClass(String className) throws ClassNotFoundException {
return clb.loadClass(className);
}
@Override
protected URL findResource(String resource) {
return clb.getResource(resource);
}
@Override
protected Enumeration<URL> findResources(String resource) throws IOException {
return clb.getResources(resource);
}
};
}
protected ClassLoader getBundleClassLoader(Bundle bundle) {
BundleWiring bundleWiring = bundle.adapt(BundleWiring.class);
return bundleWiring.getClassLoader();
}
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;
}
private void _installInitialBundle(
String location,
List<Bundle> lazyActivationBundles,
List<Bundle> startBundles,
List<Bundle> refreshBundles) {
boolean start = false;
int startLevel = PropsValues.MODULE_FRAMEWORK_BEGINNING_START_LEVEL;
int index = location.lastIndexOf(StringPool.AT);
if (index != -1) {
String[] parts = StringUtil.split(location.substring(index + 1), StringPool.COLON);
for (String part : parts) {
if (part.equals("start")) {
start = true;
} else {
startLevel = GetterUtil.getInteger(part);
}
}
location = location.substring(0, index);
}
InputStream inputStream = null;
try {
if (!location.startsWith("file:")) {
location = "file:".concat(PropsValues.LIFERAY_LIB_PORTAL_DIR.concat(location));
}
URL initialBundleURL = new URL(location);
try {
inputStream = new BufferedInputStream(initialBundleURL.openStream());
} catch (IOException ioe) {
if (_log.isWarnEnabled()) {
_log.warn(ioe.getMessage());
}
return;
}
Bundle bundle = (Bundle) addBundle(initialBundleURL.toString(), inputStream, false);
if ((bundle == null) || _isFragmentBundle(bundle)) {
return;
}
if (!start && _hasLazyActivationPolicy(bundle)) {
lazyActivationBundles.add(bundle);
return;
}
if (((bundle.getState() & Bundle.UNINSTALLED) == 0) && (startLevel > 0)) {
BundleStartLevel bundleStartLevel = bundle.adapt(BundleStartLevel.class);
bundleStartLevel.setStartLevel(startLevel);
}
if (start) {
startBundles.add(bundle);
}
if ((bundle.getState() & Bundle.INSTALLED) != 0) {
refreshBundles.add(bundle);
}
} catch (Exception e) {
_log.error(e, e);
} finally {
StreamUtil.cleanUp(inputStream);
}
}
protected com.liferay.portal.model.Portlet addingPortlet(
ServiceReference<Portlet> serviceReference,
Portlet portlet,
String portletName,
String portletId) {
warnPorletProperties(portletName, serviceReference);
Bundle bundle = serviceReference.getBundle();
BundleWiring bundleWiring = bundle.adapt(BundleWiring.class);
ServiceRegistrations serviceRegistrations = getServiceRegistrations(bundle);
BundlePortletApp bundlePortletApp =
createBundlePortletApp(bundle, bundleWiring.getClassLoader(), serviceRegistrations);
com.liferay.portal.model.Portlet portletModel = buildPortletModel(bundlePortletApp, portletId);
portletModel.setPortletName(portletName);
String displayName =
GetterUtil.getString(
serviceReference.getProperty("javax.portlet.display-name"), portletName);
portletModel.setDisplayName(displayName);
Class<?> portletClazz = portlet.getClass();
portletModel.setPortletClass(portletClazz.getName());
collectJxPortletFeatures(serviceReference, portletModel);
collectLiferayFeatures(serviceReference, portletModel);
PortletContextBag portletContextBag =
new PortletContextBag(bundlePortletApp.getServletContextName());
PortletContextBagPool.put(bundlePortletApp.getServletContextName(), portletContextBag);
PortletBagFactory portletBagFactory = new BundlePortletBagFactory(portlet);
portletBagFactory.setClassLoader(bundleWiring.getClassLoader());
portletBagFactory.setServletContext(bundlePortletApp.getServletContext());
portletBagFactory.setWARFile(true);
try {
portletBagFactory.create(portletModel);
checkWebResources(
bundle.getBundleContext(),
bundlePortletApp.getServletContextName(),
bundleWiring.getClassLoader(),
serviceRegistrations);
checkResourceBundles(
bundle.getBundleContext(),
bundleWiring.getClassLoader(),
portletModel,
serviceRegistrations);
List<Company> companies = _companyLocalService.getCompanies();
deployPortlet(serviceReference, portletModel, companies);
checkResources(serviceReference, portletModel, companies);
portletModel.setReady(true);
if (_log.isInfoEnabled()) {
_log.info("Added " + serviceReference);
}
serviceRegistrations.addServiceReference(serviceReference);
return portletModel;
} catch (Exception e) {
_log.error("Portlet " + portletId + " from " + bundle + " failed to initialize", e);
return null;
}
}