private String createUriFromBundle(Bundle cl, String ref) {
URL url = cl.getResource(ref);
if (url == null && ref.startsWith("/")) {
url = cl.getResource(ref.substring(1));
}
if (url == null) {
throw new RuntimeException("reference " + ref + " not found on bundle " + cl);
}
return "uri:" + url.toString().replaceFirst(ref + "$", "");
}
@Override
public URL getRootUrl(Bundle b, String location) {
if (location.lastIndexOf('/') > 0) {
location = location.substring(0, location.lastIndexOf('/'));
}
return b.getResource(location);
}
@Test
public void testFragmentAttachOrder() throws Exception {
Bundle fragE1 = installBundle(getFragmentE1());
Bundle fragE2 = installBundle(getFragmentE2());
Bundle hostE = installBundle(getHostE());
Bundle hostF = installBundle(getHostF());
hostE.start();
assertTrue(fragE1.getBundleId() < fragE2.getBundleId());
// Load class provided by the fragment
assertLoadClass(hostE, FragE1Class.class.getName());
assertLoadClass(hostE, FragE2Class.class.getName());
// Tests that if a classpath entry cannot be located in the bundle, then the
// Framework attempts to locate the classpath entry in each attached
// fragment bundle. The attached fragment bundles are searched in ascending
// bundle id order.
URL resourceURL = hostE.getResource("resource.txt");
BufferedReader br = new BufferedReader(new InputStreamReader(resourceURL.openStream()));
assertEquals("fragE1", br.readLine());
hostF.uninstall();
hostE.uninstall();
fragE2.uninstall();
fragE1.uninstall();
}
/**
* Load the class and break on first found match. TODO: Should this throw a different exception or
* warn if multiple classes were found? Naming collisions can and do happen in OSGi...
*/
@Override
protected URL findResource(String name) {
if (resourceCache.containsKey(name)) {
return resourceCache.get(name);
}
for (Bundle bundle : bundles) {
try {
final URL resource = bundle.getResource(name);
if (resource != null) {
resourceCache.put(name, resource);
return resource;
}
} catch (Exception ignore) {
}
}
for (ClassLoader classLoader : classLoaders) {
try {
final URL resource = classLoader.getResource(name);
if (resource != null) {
resourceCache.put(name, resource);
return resource;
}
} catch (Exception ignore) {
}
}
// TODO: Error?
return null;
}
@Test
public void testFragmentOnly() throws Exception {
Bundle fragA = installBundle(getFragmentA());
assertBundleState(Bundle.INSTALLED, fragA.getState());
URL entryURL = fragA.getEntry("resource.txt");
assertEquals("bundle", entryURL.getProtocol());
assertEquals("/resource.txt", entryURL.getPath());
BufferedReader br = new BufferedReader(new InputStreamReader(entryURL.openStream()));
assertEquals("fragA", br.readLine());
URL resourceURL = fragA.getResource("resource.txt");
assertNull("Resource URL null", resourceURL);
try {
fragA.start();
fail("Fragment bundles can not be started");
} catch (BundleException e) {
assertBundleState(Bundle.INSTALLED, fragA.getState());
}
fragA.uninstall();
assertBundleState(Bundle.UNINSTALLED, fragA.getState());
}
private void addEditableLookups(MDSProcessorOutput output, Bundle bundle) {
URL lookupsResource = bundle.getResource(MDS_LOOKUPS_JSON);
if (lookupsResource != null) {
try (InputStream stream = lookupsResource.openStream()) {
String lookupsJson = IOUtils.toString(stream);
if (StringUtils.isNotBlank(lookupsJson)) {
EntityLookups[] entitiesLookups = GSON.fromJson(lookupsJson, EntityLookups[].class);
for (EntityLookups entityLookups : entitiesLookups) {
addEditableEntityLookups(output, entityLookups);
}
} else {
LOGGER.info(EMPTY_JSON, bundle.getSymbolicName());
}
} catch (IOException e) {
LOGGER.error(e.getMessage(), e);
}
}
}
void createPage0() {
try {
xmlEditor = new XMLEditor();
int index = addPage(xmlEditor, getEditorInput());
setPageText(index, xmlEditor.getTitle() + " (Xml View)");
IDocument inputDocument =
xmlEditor.getDocumentProvider().getDocument(xmlEditor.getEditorInput());
String documentContent = inputDocument.get();
if (documentContent.isEmpty()) {
documentContent = "";
Bundle bundle = Platform.getBundle("reprotool.ide.txtspec");
URL url = bundle.getResource("schema/default.txtspec.xml");
try {
InputStream ir = url.openStream();
InputStreamReader isr = new InputStreamReader(ir);
BufferedReader br = new BufferedReader(isr);
String append;
if ((documentContent = (br.readLine())) != null) ;
while ((append = (br.readLine())) != null) documentContent += ("\n" + append);
br.close();
} catch (Exception e) {
System.err.println(e.getMessage() + " " + e.getCause().toString());
}
documentContent = documentContent.trim();
xmlEditor.setDocument(documentContent);
}
} catch (PartInitException e) {
ErrorDialog.openError(
getSite().getShell(), "Error creating xml text editor", null, e.getStatus());
}
}
/** Calculates the contents of page 2 when the it is activated. */
protected void pageChange(int newPageIndex) {
super.pageChange(newPageIndex);
if (newPageIndex == 1) {
IDocument inputDocument =
xmlEditor.getDocumentProvider().getDocument(xmlEditor.getEditorInput());
String documentContent = inputDocument.get();
TSEditor.setDocument(documentContent);
} else if (newPageIndex == 0) {
IDocument inputDocument =
xmlEditor.getDocumentProvider().getDocument(xmlEditor.getEditorInput());
String documentContent = inputDocument.get();
if (documentContent.isEmpty()) {
documentContent = "";
Bundle bundle = Platform.getBundle("reprotool.ide.txtspec");
URL url = bundle.getResource("schema/default.txtspec.xml");
try {
InputStream ir = url.openStream();
InputStreamReader isr = new InputStreamReader(ir);
BufferedReader br = new BufferedReader(isr);
String append;
if ((documentContent = (br.readLine())) != null) ;
while ((append = (br.readLine())) != null) documentContent += ("\n" + append);
br.close();
} catch (Exception e) {
System.err.println(e.getMessage() + " " + e.getCause().toString());
}
documentContent = documentContent.trim();
}
xmlEditor.setDocument(documentContent);
}
}
@Test
public void testAttachedFragment() throws Exception {
Bundle hostA = installBundle(getHostA());
assertBundleState(Bundle.INSTALLED, hostA.getState());
Bundle fragA = installBundle(getFragmentA());
assertBundleState(Bundle.INSTALLED, fragA.getState());
hostA.start();
assertBundleState(Bundle.ACTIVE, hostA.getState());
assertBundleState(Bundle.RESOLVED, fragA.getState());
URL entryURL = hostA.getEntry("resource.txt");
assertNull("Entry URL null", entryURL);
URL resourceURL = hostA.getResource("resource.txt");
assertEquals("bundle", resourceURL.getProtocol());
assertEquals("/resource.txt", resourceURL.getPath());
BufferedReader br = new BufferedReader(new InputStreamReader(resourceURL.openStream()));
assertEquals("fragA", br.readLine());
// Load class provided by the fragment
assertLoadClass(hostA, FragBeanA.class.getName());
// Load a private class from host
assertLoadClass(hostA, SubBeanA.class.getName());
// PackageAdmin.getBundleType
PackageAdmin pa = getPackageAdmin();
assertEquals("Bundle type", 0, pa.getBundleType(hostA));
assertEquals("Bundle type", PackageAdmin.BUNDLE_TYPE_FRAGMENT, pa.getBundleType(fragA));
// PackageAdmin.getHosts
Bundle[] hosts = pa.getHosts(hostA);
assertNull("Not a fragment", hosts);
hosts = pa.getHosts(fragA);
assertNotNull("Hosts not null", hosts);
assertEquals("Hosts length", 1, hosts.length);
assertEquals("Hosts equals", hostA, hosts[0]);
// PackageAdmin.getFragments
Bundle[] fragments = pa.getFragments(fragA);
assertNull("Not a host", fragments);
fragments = pa.getFragments(hostA);
assertNotNull("Fragments not null", fragments);
assertEquals("Fragments length", 1, fragments.length);
assertEquals("Fragments equals", fragA, fragments[0]);
hostA.uninstall();
assertBundleState(Bundle.UNINSTALLED, hostA.getState());
assertBundleState(Bundle.RESOLVED, fragA.getState());
fragA.uninstall();
assertBundleState(Bundle.UNINSTALLED, fragA.getState());
}
@Override
public Object findTemplateSource(String name) throws IOException {
for (Bundle bundle : ctx.getBundles()) {
URL src = bundle.getResource(path + name);
if (src != null) {
return src;
}
}
return null;
}
public URL getResource(String resourceName) {
if (LOGGER.isDebugEnabled()) {
LOGGER.debug("getResource( " + resourceName + " )");
}
if (resourceName.startsWith(mountPoint)) {
resourceName = resourceName.substring(mountPoint.length());
}
return bundle.getResource(resourceName);
}
@Test
public void shouldReturnIconWhenGivenBundleName() {
setupBundleRetrieval();
when(bundle.getResource("icon.gif")).thenReturn(getDefaultIconUrl(DEFAULT_PATH + DEFAULT_ICON));
BundleIcon bundleIcon = bundleIconService.getBundleIconByName(BUNDLE_NAME, null);
byte[] expectedIcon = readDefaultIcon(DEFAULT_PATH + DEFAULT_ICON);
assertArrayEquals(expectedIcon, bundleIcon.getIcon());
assertEquals(ICON_MIME, bundleIcon.getMime());
}
@Test
public void testResourceNotAvailableOnInstall() throws Exception {
Bundle bundleC = installBundle(getLogServiceArchive());
assertBundleState(Bundle.INSTALLED, bundleC.getState());
try {
String resPath = LogService.class.getName().replace('.', '/') + ".class";
URL resURL = bundleC.getResource(resPath);
assertNull("Resource not found", resURL);
assertBundleState(Bundle.RESOLVED, bundleC.getState());
Bundle cmpd = installBundle("bundles/org.osgi.compendium.jar");
try {
resURL = bundleC.getResource(resPath);
assertNotNull("Resource found", resURL);
} finally {
cmpd.uninstall();
}
} finally {
bundleC.uninstall();
}
}
/**
* Uses the plugin bundle's class loader to find a resource.
*
* @return A InputStream object or null if no resource with this name is found.
*/
public InputStream getResourceAsStream(String name) throws IOException {
// We always use the plugin bundle's class loader to access the resource.
// getClass().getResource() would fail for generic plugins (plugin bundles not containing a
// plugin
// subclass) because the core bundle's class loader would be used and it has no access.
URL url = pluginBundle.getResource(name);
if (url != null) {
return url.openStream();
} else {
return null;
}
}
private static Map<String, Version> readBundleActivationFile(
Bundle bundle, String bundleActivationFileName) throws IOException {
Map<String, Version> bundleMap = new HashMap<String, Version>();
URL bundleFileUrl = bundle.getResource(bundleActivationFileName);
Properties bundleProperties = new Properties();
bundleProperties.load(bundleFileUrl.openStream());
for (Map.Entry<Object, Object> entry : bundleProperties.entrySet()) {
String symbolicName = (String) entry.getKey();
Version version = new Version((String) entry.getValue());
bundleMap.put(symbolicName, version);
}
return bundleMap;
}
private static String getFile(Bundle bundle, String path) {
String fileURL;
try {
fileURL = FileLocator.toFileURL(bundle.getEntry(path)).getPath();
} catch (Exception ex) {
try {
fileURL = FileLocator.toFileURL(bundle.getResource(path)).getPath();
} catch (Exception ex2) {
fileURL = FileLocator.find(bundle, new Path(path), null).getPath();
}
}
return fileURL;
}
@Override
protected URL findResource(String name) {
for (Bundle delegate : delegates) {
try {
URL resource = delegate.getResource(name);
if (resource != null) {
return resource;
}
} catch (IllegalStateException _) {
}
}
return null;
}
@Test
public void shouldReturnIcon() throws IOException {
setupBundleRetrieval();
byte[] expectedIcon = readDefaultIcon(DEFAULT_PATH + DEFAULT_ICON);
when(bundle.getResource("icon.gif")).thenReturn(getDefaultIconUrl(DEFAULT_PATH + DEFAULT_ICON));
BundleIcon bundleIcon = bundleIconService.getBundleIconById(BUNDLE_ID, null);
assertArrayEquals(expectedIcon, bundleIcon.getIcon());
assertEquals(expectedIcon.length, bundleIcon.getContentLength());
assertEquals(ICON_MIME, bundleIcon.getMime());
verify(bundleContext).getBundle(BUNDLE_ID);
verify(bundle).getResource("icon.gif");
}
@Test
@Ignore("still working it out")
public void testCallGetResourceOnADifferentBundle() throws Exception {
// find bundles
Bundle[] bundles = bundleContext.getBundles();
for (int i = 1; i < bundles.length; i++) {
Bundle bundle = bundles[i];
logger.debug(
"calling #getResource on bundle " + OsgiStringUtils.nullSafeNameAndSymName(bundle));
URL url = bundle.getResource(LOCATION);
if (!OsgiBundleUtils.isFragment(bundle))
assertNotNull(
"bundle " + OsgiStringUtils.nullSafeNameAndSymName(bundle) + " contains no META-INF/",
url);
}
}
/**
* Gets the icon.
*
* @param e IConfigurationElement
* @param attribute name of icon
* @return icon of algorithm
*/
private static Image getIcon(IConfigurationElement e, String attribute) {
try {
Bundle bundle = Platform.getBundle(e.getContributor().getName());
if (bundle != null) {
URL resource = bundle.getResource(attribute);
if (resource != null) {
return new Image(Display.getDefault(), resource.openStream());
}
}
} catch (InvalidRegistryObjectException e1) {
e1.printStackTrace();
} catch (IOException e1) {
e1.printStackTrace();
}
return null;
}
public Properties getResourceAsProperties(Bundle loader, String path) throws IOException {
URL resourceUrl = loader.getResource(path);
if (null == resourceUrl) {
return null;
}
InputStream in = resourceUrl.openStream();
try {
Properties rv = new Properties();
rv.load(in);
return rv;
} finally {
if (null != in) {
in.close();
}
}
}
/**
* This will try and load a ResourceBundle for the given qualified name.
*
* @param qualifiedName Name if the resource bundle we need to load.
* @return The loaded resource bundle.
*/
public synchronized ResourceBundle getResourceBundle(String qualifiedName) {
MissingResourceException originalException = null;
// shortcut evaluation in case this properties file can be found in the current classloader.
try {
ResourceBundle bundle = ResourceBundle.getBundle(qualifiedName);
return bundle;
} catch (MissingResourceException e) {
originalException = e;
}
if (changedContributions.size() > 0) {
refreshContributions();
}
/*
* We'll iterate over the bundles that have been installed from the workspace, search for one that
* exports a package of the name we're looking for, then try and load the properties file from this
* bundle's class loader (bundle.getResource()). If the resource couldn't be found in that bundle, we
* loop over to the next.
*/
for (Map.Entry<IPluginModelBase, Bundle> entry : workspaceInstalledBundles.entrySet()) {
final Bundle bundle = entry.getValue();
URL propertiesResource =
bundle.getResource(qualifiedName.replace('.', '/') + ".properties"); // $NON-NLS-1$
if (propertiesResource != null) {
InputStream stream = null;
try {
stream = propertiesResource.openStream();
// make sure this stream is buffered
stream = new BufferedInputStream(stream);
return new PropertyResourceBundle(stream);
} catch (IOException e) {
// Swallow this, we'll throw the original MissingResourceException
} finally {
try {
if (stream != null) {
stream.close();
}
} catch (IOException e) {
// Swallow this, we'll throw the original MissingResourceException
}
}
}
}
throw originalException;
}
@Test
public void testDOMParser() throws Exception {
OSGiTestSupport.changeStartLevel(context, 4, 10, TimeUnit.SECONDS);
bundle.start();
DocumentBuilder domBuilder = getDocumentBuilder();
URL resURL = bundle.getResource("example-xml-parser.xml");
Document dom = domBuilder.parse(resURL.openStream());
assertNotNull("Document not null", dom);
Element root = dom.getDocumentElement();
assertEquals("root", root.getLocalName());
Node child = root.getFirstChild();
assertEquals("child", child.getLocalName());
assertEquals("content", child.getTextContent());
}
@Test
public void testHostOnly() throws Exception {
Bundle hostA = installBundle(getHostA());
assertBundleState(Bundle.INSTALLED, hostA.getState());
hostA.start();
assertBundleState(Bundle.ACTIVE, hostA.getState());
URL entryURL = hostA.getEntry("resource.txt");
assertNull("Entry URL null", entryURL);
URL resourceURL = hostA.getResource("resource.txt");
assertNull("Resource URL null", resourceURL);
// Load a private class
assertLoadClass(hostA, SubBeanA.class.getName());
hostA.uninstall();
assertBundleState(Bundle.UNINSTALLED, hostA.getState());
}
@Test
@SuppressWarnings("unchecked")
public void testUnmarshaller() throws Exception {
JAXBContext jaxbContext =
JAXBContext.newInstance(
ObjectFactory.class.getPackage().getName(), ObjectFactory.class.getClassLoader());
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
URL resURL = bundle.getResource("booking.xml");
JAXBElement<CourseBooking> rootElement =
(JAXBElement<CourseBooking>) unmarshaller.unmarshal(resURL.openStream());
assertNotNull("root element not null", rootElement);
CourseBooking booking = rootElement.getValue();
assertNotNull("booking not null", booking);
CompanyType company = booking.getCompany();
assertNotNull("company not null", company);
assertEquals("ACME Consulting", company.getName());
}
@Override
public BundleIcon getBundleIcon(long bundleId) {
BundleIcon bundleIcon = null;
Bundle bundle = getBundle(bundleId);
for (String iconLocation : ICON_LOCATIONS) {
URL iconURL = bundle.getResource(iconLocation);
if (iconURL != null) {
bundleIcon = loadBundleIcon(iconURL);
break;
}
}
if (bundleIcon == null) {
URL defaultIconURL = getClass().getResource(DEFAULT_ICON);
bundleIcon = loadBundleIcon(defaultIconURL);
}
return bundleIcon;
}
private static void addCloneSourceProvider(
List<CloneSourceProvider> cloneSourceProvider, IConfigurationElement[] config, int index) {
try {
int myIndex = index;
String label = config[myIndex].getAttribute("label"); // $NON-NLS-1$
boolean hasFixLocation =
Boolean.valueOf(config[myIndex].getAttribute("hasFixLocation"))
.booleanValue(); //$NON-NLS-1$
String iconPath = config[myIndex].getAttribute("icon"); // $NON-NLS-1$
ImageDescriptor icon = null;
if (iconPath != null) {
Bundle declaringBundle =
Platform.getBundle(config[myIndex].getDeclaringExtension().getNamespaceIdentifier());
icon = ImageDescriptor.createFromURL(declaringBundle.getResource(iconPath));
}
myIndex++;
IConfigurationElement serverProviderElement = null;
if (myIndex < config.length
&& config[myIndex].getName().equals("repositoryServerProvider")) { // $NON-NLS-1$
serverProviderElement = config[myIndex];
myIndex++;
}
IConfigurationElement pageElement = null;
if (myIndex < config.length
&& config[myIndex].getName().equals("repositorySearchPage")) { // $NON-NLS-1$
pageElement = config[myIndex];
myIndex++;
}
cloneSourceProvider.add(
new CloneSourceProvider(label, serverProviderElement, pageElement, hasFixLocation, icon));
if (myIndex == config.length) return;
addCloneSourceProvider(cloneSourceProvider, config, myIndex);
} catch (Exception e) {
Activator.logError(
"Could not create extension provided by "
+ //$NON-NLS-1$
Platform.getBundle(config[index].getDeclaringExtension().getNamespaceIdentifier()),
e);
}
}
/**
* Finds component descriptors based on descriptor location.
*
* @param bundle bundle to search for descriptor files
* @param descriptorLocation descriptor location
* @return array of descriptors or empty array if none found
*/
static URL[] findDescriptors(final Bundle bundle, final String descriptorLocation) {
if (bundle == null || descriptorLocation == null || descriptorLocation.trim().length() == 0) {
return new URL[0];
}
// for compatibility with previoues versions (<= 1.0.8) use getResource() for non wildcarded
// entries
if (descriptorLocation.indexOf("*") == -1) {
final URL descriptor = bundle.getResource(descriptorLocation);
if (descriptor == null) {
return new URL[0];
}
return new URL[] {descriptor};
}
// split pattern and path
final int lios = descriptorLocation.lastIndexOf("/");
final String path;
final String filePattern;
if (lios > 0) {
path = descriptorLocation.substring(0, lios);
filePattern = descriptorLocation.substring(lios + 1);
} else {
path = "/";
filePattern = descriptorLocation;
}
// find the entries
final Enumeration entries = bundle.findEntries(path, filePattern, false);
if (entries == null || !entries.hasMoreElements()) {
return new URL[0];
}
// create the result list
List urls = new ArrayList();
while (entries.hasMoreElements()) {
urls.add(entries.nextElement());
}
return (URL[]) urls.toArray(new URL[urls.size()]);
}
////////////////////////////////////////////////////////////////////////////
//
// Deployment
//
////////////////////////////////////////////////////////////////////////////
public static void deployIfNeededAndLoad() {
if (!m_initialized) {
try {
// extract
Bundle bundle = Platform.getBundle("com.google.gdt.eclipse.designer.hosted.2_0.webkit");
URL resource = FileLocator.resolve(bundle.getResource("WebKit.zip"));
ZipFile zipFile = new ZipFile(resource.getPath());
try {
if (deployNeeded(zipFile)) {
extract(zipFile);
}
} finally {
zipFile.close();
}
load();
m_available = true;
} catch (Throwable e) {
// ignore
}
m_initialized = true;
}
}
protected void collectPortletPreferences(
ServiceReference<Portlet> serviceReference, com.liferay.portal.model.Portlet portletModel) {
String defaultPreferences =
GetterUtil.getString(serviceReference.getProperty("javax.portlet.preferences"));
if ((defaultPreferences != null) && defaultPreferences.startsWith("classpath:")) {
Bundle bundle = serviceReference.getBundle();
URL url = bundle.getResource(defaultPreferences.substring("classpath:".length()));
if (url != null) {
try {
defaultPreferences = StringUtil.read(url.openStream());
} catch (IOException ioe) {
_log.error(ioe, ioe);
}
}
}
portletModel.setDefaultPreferences(defaultPreferences);
}