/*
* Copyright 2005 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.felix.jmood.utils;
import java.util.Dictionary;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Vector;
import org.apache.felix.jmood.AgentContext;
import org.apache.felix.jmood.core.BundleNotAvailableException;
import org.apache.felix.jmood.core.ServiceNotAvailableException;
import org.osgi.framework.Bundle;
import org.osgi.framework.Constants;
import org.osgi.framework.ServiceReference;
import org.osgi.service.packageadmin.ExportedPackage;
import org.osgi.service.packageadmin.PackageAdmin;
import org.osgi.service.packageadmin.RequiredBundle;
/**
* This class contains helper methods
*
*
*/
public class InstrumentationSupport {
private AgentContext ac;
public InstrumentationSupport(AgentContext ac){
this.ac=ac;
}
/**
* <p>For each BundleInfo, this method returns the symbolic name String, which we define as the concatenation of
* the getSymbolicName of the <code>Bundle</code> interface and the bundle version as specified
* in the bundle header. Both parts are divided by a semicolon. An example would be:</p>
* <p>
* <code>com.acme.foo;1.0.0</code>
* </p>
* @param bundles The <code>Bundle</code> array to be converted
* @return The String array
* @see org.osgi.framework.Bundle#getSymbolicName()
*/
public static String[] getSymbolicNames(Bundle[] bundles) {
if(bundles==null) return null;
String[] names=new String[bundles.length];
for (int i = 0; i < names.length; i++) {
names[i]=getSymbolicName(bundles[i]);
}
return names;
}
public static String getSymbolicName(Bundle bundle){
return bundle.getSymbolicName()+";"+bundle.getHeaders().get(Constants.BUNDLE_VERSION);
}
/**
* <p>
*
* OSGi exported packages can be uniquely identified by the tuple (packageName, packageVersion).
* This methods returns a String array representing those packages with the following syntax:
* </p>
* <p>
* <i>packageName</i>;<i>packageVersion</i>
* </p><p>
* where packageName is as returned by the method <i>getName()</i> and packageVersion as returned by the method <i>getVersion()</i>
* in package admin's <code>ExportedPackage</code> class.
* </p>
* @param packages The <code>ExportedPackage</code> array to be converted
* @return The String array
* @see org.osgi.service.packageadmin.ExportedPackage
*/
public static String[] getPackageNames(ExportedPackage[] packages) {
if (packages==null) return null;
String[] names=new String[packages.length];
for (int i = 0; i < names.length; i++) {
names[i]=getPackageName(packages[i]);
}
return names;
}
public static String getPackageName(ExportedPackage pkg) {
return pkg.getName()+";"+pkg.getVersion().toString();
}
/**
* <p>
* OSGi Services can be registered under more than one interface (objectClass in
* the spec). Services have a mandatory unique service id (as defined in the SERVICE_ID property of the org.osgi.framework.Constants interface), during their lifetime (i.e, until they are
* garbage collected). To show this information in a consistent way, we use the following String representation
* of the service:
* </p>
* <p>
* <i>objectClass1</i>[;<i>objectClass2</i>[;<i>objectClass3</i>...]]:<i>service.id</i>
* </p><p>
* where objectClass1..objectClassN are the elements of the mandatory objectClass array
* included in the service property dictionary (and set by the framework at registration time. The property name is defined in <code>org.osgi.framework.Constants#OBJECTCLASS</code>
* </p>
* @param services The <code>ServiceReference</code> array to be converted
* @return The String array
* @see org.osgi.framework.Constants#OBJECTCLASS
* @see org.osgi.framework.Constants#SERVICE_ID
* @see org.osgi.framework.ServiceReference
*/
public static String[] getServiceNames(ServiceReference[] services) {
if(services==null) return null;
String[] names=new String[services.length];
for (int i = 0; i < names.length; i++) {
String[] objectClass=(String[])services[i].getProperty(Constants.OBJECTCLASS);
//We asume that the framework always returns a non-empty, non-null array.
StringBuffer sb=new StringBuffer(objectClass[0]);
for (int j = 1; j < objectClass.length; j++) {
sb.append(";");
sb.append(objectClass[j]);
}
sb.append(services[i].getProperty(Constants.SERVICE_ID));
names[i]=sb.toString();
}
return names;
}
public static ExportedPackage[] getImportedPackages(Bundle bundle, AgentContext ac) throws ServiceNotAvailableException {
Vector imported = new Vector();
Bundle[] allBundles = ac.getBundleContext().getBundles();
for (int i=0; i<allBundles.length;i++) {
Bundle b=allBundles[i];
ExportedPackage[] eps=ac.getPackageadmin()
.getExportedPackages(b);
if(eps==null) continue;
exported: for (int j=0;j<eps.length;j++) {
ExportedPackage ep = eps[j];
Bundle[] imp=ep.getImportingBundles();
if(imp==null) continue;
for (int k=0;k<imp.length;k++) {
Bundle b2 =imp[k];
if (b2.getBundleId() == bundle.getBundleId()) {
imported.add(ep);
continue exported;
}
}
}
}
if (imported.size() == 0)
return null;
else return (ExportedPackage[])imported.toArray(new ExportedPackage[imported.size()]);
}
public static Bundle[] getRequiringBundles(Bundle bundle, AgentContext ac) throws ServiceNotAvailableException{
if (bundle==null) throw new IllegalArgumentException("Bundle argument should not be null");
if (bundle.getSymbolicName()==null) return null;
RequiredBundle[] required=ac.getPackageadmin().getRequiredBundles(bundle.getSymbolicName());
if (required==null) return null;
RequiredBundle b=null;
for (int i=0;i<required.length;i++) {
if(bundle.getBundleId()==required[i].getBundle().getBundleId()) {
b=required[i];
break;
}
}
if(b==null) {
ac.error(InstrumentationSupport.class.getName()+": required bundle should not be null!!!!", new Exception());
return null;
}
return b.getRequiringBundles();
}
public static Bundle[] getBundleDependencies(Bundle bundle, AgentContext ac) throws ServiceNotAvailableException{
Bundle[] all=ac.getBundleContext().getBundles();
Vector required=new Vector();
for (int i = 0; i < all.length; i++) {
Bundle[] requiring=getRequiringBundles(all[i], ac);
if (requiring==null) continue;
for (int j = 0; j < requiring.length; j++) {
//If the solicited bundle is requiring the bundle all[i] we mark it as required
if (requiring[j].getBundleId()==bundle.getBundleId()) required.add(all[i]);
}
}
if (required.size()==0) return null;
return (Bundle[])required.toArray(new Bundle[required.size()]);
}
public static boolean isBundleRequired(Bundle bundle, AgentContext ac) throws ServiceNotAvailableException {
if (getRequiredBundle(bundle, ac)==null) return false;
return true;
}
public static boolean isRequiredBundleRemovalPending(Bundle bundle, AgentContext ac)throws ServiceNotAvailableException{
RequiredBundle r=getRequiredBundle(bundle, ac);
if (r==null) return false;
return r.isRemovalPending();
}
public static RequiredBundle getRequiredBundle(Bundle bundle, AgentContext ac)throws ServiceNotAvailableException{
RequiredBundle[] required=ac.getPackageadmin().getRequiredBundles(bundle.getSymbolicName());
if(required==null) return null;
for (int i = 0; i < required.length; i++) {
if (required[i].getBundle().getBundleId()==bundle.getBundleId()) return required[i];
}
return null;
}
public static String getState(int state) {
switch (state) {
case Bundle.ACTIVE:
return "ACTIVE";
case Bundle.INSTALLED:
return "INSTALLED";
case Bundle.RESOLVED:
return "RESOLVED";
case Bundle.STARTING:
return "STARTING";
case Bundle.STOPPING:
return "STOPPING";
case Bundle.UNINSTALLED:
return "UNINSTALLED";
}
return null;
}
public static boolean isBundlePersistentlyStarted(Bundle bundle, AgentContext ac)throws ServiceNotAvailableException{
// BUG in KNOPFLERFISH: isPersistentlyStarted throws NPE if called
// on System bundle
// Workaround: system bundle should always be persistently started, return true
if (bundle.getBundleId()==0) return true;
else
return ac.getStartLevel().isBundlePersistentlyStarted(bundle);
// End workaround
}
public static int getBundleStartLevel(Bundle bundle, AgentContext ac) throws ServiceNotAvailableException {
return ac.getStartLevel().getBundleStartLevel(bundle);
}
public static ExportedPackage[] getExportedPackages(Bundle bundle, AgentContext ac) throws ServiceNotAvailableException{
return ac.getPackageadmin().getExportedPackages(bundle);
}
public static boolean isFragment(Bundle bundle, AgentContext ac) throws ServiceNotAvailableException{
if(ac.getPackageadmin().getBundleType(bundle)==PackageAdmin.BUNDLE_TYPE_FRAGMENT) return true;
return false;
}
public static Hashtable getHashtable(Dictionary dic){
Hashtable ht = new Hashtable();
for (Enumeration keys = dic.keys(); keys.hasMoreElements();) {
Object key = keys.nextElement();
// Not inmutable, but unlikely to change
ht.put(key, dic.get(key));
}
return ht;
}
public static long getBundleId(String symbolicName, AgentContext ac) throws BundleNotAvailableException{
if(symbolicName==null) throw new IllegalArgumentException("Symbolic name cannot be null");
String [] s=symbolicName.split(";");
if(s==null||s.length==0) throw new BundleNotAvailableException("Could not find bundle identified by "+symbolicName);
Bundle[] bundles=ac.getBundleContext().getBundles();
long id=-1;
Vector candidates=new Vector();
for(int i=0;i<bundles.length;i++) {
//First find all bundles with symbolicName
String name=bundles[i].getSymbolicName();
if(name==null) continue;
if (s[0].equals(name)){
candidates.add(new Long(bundles[i].getBundleId()));
}
}
//now search the one that matches the version
for(int i=0; i< candidates.size();i++){
long cId=((Long)candidates.elementAt(i)).longValue();
Bundle c=ac.getBundleContext().getBundle(cId);
String version=(String)c.getHeaders().get(Constants.BUNDLE_VERSION);
if(s.length==1){//no version available
ac.debug("no version available for "+symbolicName);
if(candidates.size()>1) throw new BundleNotAvailableException("could not distinguish among multiple candidates");
if(candidates.size()==1) {
id=cId;
break;
}
}
if (version.equals(s[1])) id=cId;
}
if(id==-1) throw new BundleNotAvailableException("No " + symbolicName+ "installed");
return id;
}
}