plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/views/ModulesView.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.client.ui.dist.views;
  17
  18 import java.util.Comparator;
  19 import java.util.HashMap;
  20 import java.util.Map;
  21 import java.util.Set;
  22 import java.util.TreeMap;
  23 import java.util.TreeSet;
  24
  25 import org.apache.commons.logging.Log;
  26 import org.apache.commons.logging.LogFactory;
  27 import org.argeo.eclipse.ui.TreeParent;
  28 import org.argeo.slc.client.ui.dist.DistPlugin;
  29 import org.eclipse.jface.viewers.ITableLabelProvider;
  30 import org.eclipse.jface.viewers.ITreeContentProvider;
  31 import org.eclipse.jface.viewers.LabelProvider;
  32 import org.eclipse.jface.viewers.TreeViewer;
  33 import org.eclipse.jface.viewers.Viewer;
  34 import org.eclipse.swt.SWT;
  35 import org.eclipse.swt.graphics.Image;
  36 import org.eclipse.swt.widgets.Composite;
  37 import org.eclipse.ui.part.ViewPart;
  38 import org.osgi.framework.Bundle;
  39 import org.osgi.framework.BundleContext;
  40 import org.osgi.framework.ServiceReference;
  41 import org.osgi.service.packageadmin.ExportedPackage;
  42 import org.osgi.service.packageadmin.PackageAdmin;
  43
  44 public class ModulesView extends ViewPart {
  45         private final static Log log = LogFactory.getLog(ModulesView.class);
  46
  47         private TreeViewer viewer;
  48
  49         private PackageAdmin packageAdmin;
  50
  51         private Comparator<ExportedPackage> exportedPackageComparator = new Comparator<ExportedPackage>() {
  52
  53                 public int compare(ExportedPackage o1, ExportedPackage o2) {
  54                         if (!o1.getName().equals(o2.getName()))
  55                                 return o1.getName().compareTo(o2.getName());
  56                         else
  57                                 return o1.getVersion().compareTo(o2.getVersion());
  58                 }
  59         };
  60
  61         @Override
  62         public void createPartControl(Composite parent) {
  63                 viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);
  64                 viewer.setContentProvider(new ModulesContentProvider());
  65                 viewer.setLabelProvider(new ModulesLabelProvider());
  66                 viewer.setInput(DistPlugin.getBundleContext());
  67         }
  68
  69         @Override
  70         public void setFocus() {
  71                 viewer.getTree().setFocus();
  72         }
  73
  74         private class ModulesContentProvider implements ITreeContentProvider {
  75
  76                 public Object[] getElements(Object inputElement) {
  77                         return getChildren(inputElement);
  78                 }
  79
  80                 public Object[] getChildren(Object parentElement) {
  81                         if (parentElement instanceof BundleContext) {
  82                                 BundleContext bundleContext = (BundleContext) parentElement;
  83                                 Bundle[] bundles = bundleContext.getBundles();
  84
  85                                 TreeParent bundlesNode = new TreeParent("Bundles");
  86                                 for (Bundle bundle : bundles) {
  87                                         if (bundle.getState() == Bundle.ACTIVE)
  88                                                 bundlesNode.addChild(new BundleNode(bundle));
  89                                 }
  90
  91                                 // scan packages
  92                                 ServiceReference paSr = bundleContext
  93                                                 .getServiceReference(PackageAdmin.class.getName());
  94                                 // TODO: make a cleaner referencing
  95                                 packageAdmin = (PackageAdmin) bundleContext.getService(paSr);
  96
  97                                 Bundle bundle1 = null;
  98                                 Bundle bundle2 = null;
  99
 100                                 Map<Bundle, Set<ExportedPackage>> importedPackages = new HashMap<Bundle, Set<ExportedPackage>>();
 101                                 Map<String, Set<ExportedPackage>> packages = new TreeMap<String, Set<ExportedPackage>>();
 102                                 for (Bundle bundle : bundles) {
 103                                         if (bundle.getSymbolicName()
 104                                                         .equals("org.argeo.security.ui"))
 105                                                 bundle1 = bundle;
 106                                         if (bundle.getSymbolicName().equals(
 107                                                         "org.argeo.security.equinox"))
 108                                                 bundle2 = bundle;
 109
 110                                         ExportedPackage[] pkgs = packageAdmin
 111                                                         .getExportedPackages(bundle);
 112                                         if (pkgs != null)
 113                                                 for (ExportedPackage pkg : pkgs) {
 114                                                         if (!packages.containsKey(pkg.getName()))
 115                                                                 packages.put(pkg.getName(),
 116                                                                                 new TreeSet<ExportedPackage>(
 117                                                                                                 exportedPackageComparator));
 118                                                         Set<ExportedPackage> expPackages = (Set<ExportedPackage>) packages
 119                                                                         .get(pkg.getName());
 120                                                         expPackages.add(pkg);
 121
 122                                                         // imported
 123                                                         for (Bundle b : pkg.getImportingBundles()) {
 124                                                                 if (bundle.getBundleId() != b.getBundleId()) {
 125                                                                         if (!importedPackages.containsKey(b))
 126                                                                                 importedPackages
 127                                                                                                 .put(b,
 128                                                                                                                 new TreeSet<ExportedPackage>(
 129                                                                                                                                 exportedPackageComparator));
 130                                                                         Set<ExportedPackage> impPackages = (Set<ExportedPackage>) importedPackages
 131                                                                                         .get(b);
 132                                                                         impPackages.add(pkg);
 133                                                                 }
 134                                                         }
 135                                                 }
 136                                 }
 137
 138                                 TreeParent mPackageNode = new TreeParent("Multiple Packages");
 139                                 TreeParent aPackageNode = new TreeParent("All Packages");
 140                                 for (String packageName : packages.keySet()) {
 141                                         Set<ExportedPackage> pkgs = packages.get(packageName);
 142                                         if (pkgs.size() > 1) {
 143                                                 MultiplePackagesNode mpn = new MultiplePackagesNode(
 144                                                                 packageName, pkgs);
 145                                                 mPackageNode.addChild(mpn);
 146                                                 aPackageNode.addChild(mpn);
 147                                         } else {
 148                                                 aPackageNode.addChild(new ExportedPackageNode(pkgs
 149                                                                 .iterator().next()));
 150                                         }
 151                                 }
 152
 153                                 // Map<String, Set<String>> traces1 = new TreeMap<String,
 154                                 // Set<String>>();
 155                                 // Map<String, ExportedPackage> space1 =
 156                                 // dependencySpace(bundle1,
 157                                 // importedPackages, traces1);
 158                                 // Map<String, Set<String>> traces2 = new TreeMap<String,
 159                                 // Set<String>>();
 160                                 // Map<String, ExportedPackage> space2 =
 161                                 // dependencySpace(bundle2,
 162                                 // importedPackages, traces2);
 163                                 // for (String key : space1.keySet()) {
 164                                 // if (space2.containsKey(key)) {
 165                                 // ExportedPackage pkg1 = space1.get(key);
 166                                 // ExportedPackage pkg2 = space2.get(key);
 167                                 // if (!pkg1.getVersion().equals(pkg2.getVersion())) {
 168                                 // log.debug("\n##" + pkg1 + " <> " + pkg2);
 169                                 // log.debug("# Traces for "
 170                                 // + bundle1.getSymbolicName());
 171                                 // for (String trace : traces1.get(pkg1.getName())) {
 172                                 // log.debug(trace);
 173                                 // }
 174                                 // log.debug("# Traces for "
 175                                 // + bundle2.getSymbolicName());
 176                                 // for (String trace : traces2.get(pkg2.getName())) {
 177                                 // log.debug(trace);
 178                                 // }
 179                                 // }
 180                                 // }
 181                                 // }
 182
 183                                 return new Object[] { bundlesNode, mPackageNode, aPackageNode };
 184                         } else if (parentElement instanceof TreeParent) {
 185                                 return ((TreeParent) parentElement).getChildren();
 186                         } else {
 187                                 return null;
 188                         }
 189                 }
 190
 191                 public Object getParent(Object element) {
 192                         // TODO Auto-generated method stub
 193                         return null;
 194                 }
 195
 196                 public boolean hasChildren(Object element) {
 197                         if (element instanceof TreeParent) {
 198                                 return ((TreeParent) element).hasChildren();
 199                         }
 200                         return false;
 201                 }
 202
 203                 public void dispose() {
 204                         // TODO Auto-generated method stub
 205
 206                 }
 207
 208                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 209                         // TODO Auto-generated method stub
 210
 211                 }
 212
 213         }
 214
 215         protected Map<String, ExportedPackage> dependencySpace(Bundle bundle,
 216                         Map<Bundle, Set<ExportedPackage>> importedPackages,
 217                         Map<String, Set<String>> traces) {
 218                 log.debug("Dependency space for " + bundle.getSymbolicName());
 219                 Map<String, ExportedPackage> space = new TreeMap<String, ExportedPackage>();
 220                 fillDependencySpace(space, bundle, importedPackages,
 221                                 bundle.getSymbolicName(), traces);
 222                 return space;
 223         }
 224
 225         /** Recursive */
 226         protected void fillDependencySpace(Map<String, ExportedPackage> space,
 227                         Bundle bundle, Map<Bundle, Set<ExportedPackage>> importedPackages,
 228                         String currTrace, Map<String, Set<String>> traces) {
 229                 if (importedPackages.containsKey(bundle)) {
 230                         Set<ExportedPackage> imports = importedPackages.get(bundle);
 231                         // log.debug("## Fill dependency space for " + bundle + " : ");
 232                         for (ExportedPackage pkg : imports) {
 233                                 if (!traces.containsKey(pkg.getName()))
 234                                         traces.put(pkg.getName(), new TreeSet<String>());
 235                                 traces.get(pkg.getName()).add(currTrace);
 236                                 if (!space.containsKey(pkg.getName())) {
 237                                         space.put(pkg.getName(), pkg);
 238                                         Bundle exportingBundle = pkg.getExportingBundle();
 239                                         // if (bundle.getBundleId() !=
 240                                         // exportingBundle.getBundleId())
 241                                         fillDependencySpace(space, exportingBundle,
 242                                                         importedPackages, currTrace + " > "
 243                                                                         + exportingBundle.getSymbolicName(), traces);
 244                                 }
 245                         }
 246                 }
 247         }
 248
 249         private class ModulesLabelProvider extends LabelProvider implements
 250                         ITableLabelProvider {
 251
 252                 public Image getColumnImage(Object element, int columnIndex) {
 253                         // TODO Auto-generated method stub
 254                         return null;
 255                 }
 256
 257                 public String getColumnText(Object element, int columnIndex) {
 258                         return getText(element);
 259                 }
 260
 261         }
 262
 263         class BundleNode extends TreeParent {
 264                 private final Bundle bundle;
 265
 266                 public BundleNode(Bundle bundle) {
 267                         super(bundle.getSymbolicName());
 268                         this.bundle = bundle;
 269
 270                         // Registered services
 271                         ServiceReference[] registeredServices = bundle
 272                                         .getRegisteredServices();
 273                         if (registeredServices != null) {
 274                                 TreeParent registeredServicesNode = new TreeParent(
 275                                                 "Registered Services");
 276                                 addChild(registeredServicesNode);
 277                                 for (ServiceReference sr : registeredServices) {
 278                                         if (sr != null)
 279                                                 registeredServicesNode
 280                                                                 .addChild(new ServiceReferenceNode(sr));
 281                                 }
 282                         }
 283
 284                         // Used services
 285                         ServiceReference[] usedServices = bundle.getRegisteredServices();
 286                         if (usedServices != null) {
 287                                 TreeParent usedServicesNode = new TreeParent("Used Services");
 288                                 addChild(usedServicesNode);
 289                                 for (ServiceReference sr : usedServices) {
 290                                         if (sr != null)
 291                                                 usedServicesNode.addChild(new ServiceReferenceNode(sr));
 292                                 }
 293                         }
 294                 }
 295
 296                 public Bundle getBundle() {
 297                         return bundle;
 298                 }
 299
 300         }
 301
 302         class ServiceReferenceNode extends TreeParent {
 303                 private final ServiceReference serviceReference;
 304
 305                 public ServiceReferenceNode(ServiceReference serviceReference) {
 306                         super(serviceReference.toString());
 307                         this.serviceReference = serviceReference;
 308
 309                         Bundle[] usedBundles = serviceReference.getUsingBundles();
 310                         if (usedBundles != null) {
 311                                 TreeParent usingBundles = new TreeParent("Using Bundles");
 312                                 addChild(usingBundles);
 313                                 for (Bundle b : usedBundles) {
 314                                         if (b != null)
 315                                                 usingBundles.addChild(new TreeParent(b
 316                                                                 .getSymbolicName()));
 317                                 }
 318                         }
 319
 320                         TreeParent properties = new TreeParent("Properties");
 321                         addChild(properties);
 322                         for (String key : serviceReference.getPropertyKeys()) {
 323                                 properties.addChild(new TreeParent(key + "="
 324                                                 + serviceReference.getProperty(key)));
 325                         }
 326
 327                 }
 328
 329                 public ServiceReference getServiceReference() {
 330                         return serviceReference;
 331                 }
 332
 333         }
 334
 335         class MultiplePackagesNode extends TreeParent {
 336                 private String packageName;
 337                 private Set<ExportedPackage> exportedPackages;
 338
 339                 public MultiplePackagesNode(String packageName,
 340                                 Set<ExportedPackage> exportedPackages) {
 341                         super(packageName);
 342                         this.packageName = packageName;
 343                         this.exportedPackages = exportedPackages;
 344                         for (ExportedPackage pkg : exportedPackages) {
 345                                 addChild(new ExportedPackageNode(pkg));
 346                         }
 347                 }
 348
 349         }
 350
 351         class ConflictingPackageNode extends TreeParent {
 352                 private ExportedPackage exportedPackage;
 353
 354                 public ConflictingPackageNode(ExportedPackage exportedPackage) {
 355                         super(exportedPackage.getName() + " - "
 356                                         + exportedPackage.getVersion() + " ("
 357                                         + exportedPackage.getExportingBundle() + ")");
 358                         this.exportedPackage = exportedPackage;
 359
 360                         TreeParent bundlesNode = new TreeParent("Dependent Bundles");
 361                         this.addChild(bundlesNode);
 362                         Map<String, Bundle> bundles = new TreeMap<String, Bundle>();
 363                         for (Bundle b : exportedPackage.getImportingBundles()) {
 364                                 bundles.put(b.getSymbolicName(), b);
 365                         }
 366                         for (String key : bundles.keySet()) {
 367                                 addDependentBundles(bundlesNode, bundles.get(key));
 368                         }
 369                 }
 370         }
 371
 372         protected void addDependentBundles(TreeParent parent, Bundle bundle) {
 373                 TreeParent bundleNode = new TreeParent(bundle.toString());
 374                 parent.addChild(bundleNode);
 375                 Map<String, Bundle> bundles = new TreeMap<String, Bundle>();
 376                 ExportedPackage[] pkgs = packageAdmin.getExportedPackages(bundle);
 377                 if (pkgs != null)
 378                         for (ExportedPackage pkg : pkgs) {
 379                                 for (Bundle b : pkg.getImportingBundles()) {
 380                                         if (!bundles.containsKey(b.getSymbolicName())
 381                                                         && b.getBundleId() != bundle.getBundleId()) {
 382                                                 bundles.put(b.getSymbolicName(), b);
 383                                         }
 384                                 }
 385                         }
 386
 387                 for (String key : bundles.keySet()) {
 388                         addDependentBundles(bundleNode, bundles.get(key));
 389                 }
 390         }
 391
 392         class ExportedPackageNode extends TreeParent {
 393                 private ExportedPackage exportedPackage;
 394
 395                 public ExportedPackageNode(ExportedPackage exportedPackage) {
 396                         super(exportedPackage.getName() + " - "
 397                                         + exportedPackage.getVersion() + " ("
 398                                         + exportedPackage.getExportingBundle() + ")");
 399                         this.exportedPackage = exportedPackage;
 400                         for (Bundle bundle : exportedPackage.getImportingBundles()) {
 401                                 addChild(new BundleNode(bundle));
 402                         }
 403                 }
 404         }
 405 }