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