runtime/org.argeo.slc.repo/src/main/java/org/argeo/slc/repo/osgi/ArgeoOsgiDistributionImpl.java

   1 package org.argeo.slc.repo.osgi;
   2
   3 import java.util.ArrayList;
   4 import java.util.Iterator;
   5 import java.util.List;
   6 import java.util.SortedSet;
   7 import java.util.TreeSet;
   8
   9 import org.apache.commons.logging.Log;
  10 import org.apache.commons.logging.LogFactory;
  11 import org.argeo.slc.ModuleSet;
  12 import org.argeo.slc.NameVersion;
  13 import org.argeo.slc.build.Distribution;
  14 import org.argeo.slc.execution.ExecutionFlow;
  15 import org.argeo.slc.repo.ArgeoOsgiDistribution;
  16 import org.argeo.slc.repo.ArtifactDistribution;
  17
  18 /** A consistent and versioned OSGi distribution, which can be built and tested. */
  19 public class ArgeoOsgiDistributionImpl extends ArtifactDistribution implements
  20                 ArgeoOsgiDistribution {
  21         private final static Log log = LogFactory
  22                         .getLog(ArgeoOsgiDistributionImpl.class);
  23
  24         private List<Object> modules = new ArrayList<Object>();
  25
  26         public ArgeoOsgiDistributionImpl(String coords) {
  27                 super(coords);
  28         }
  29
  30         public void init() {
  31                 if (log.isDebugEnabled()) {
  32                         SortedSet<String> sort = new TreeSet<String>();
  33                         Iterator<? extends NameVersion> nvIt = nameVersions();
  34                         while (nvIt.hasNext()) {
  35                                 NameVersion nv = nvIt.next();
  36                                 sort.add(nv.getName() + ":" + nv.getVersion());
  37                         }
  38
  39                         StringBuffer buf = new StringBuffer(
  40                                         "## OSGi FACTORY MANAGED MODULES : \n");
  41                         for (String str : sort) {
  42                                 buf.append(str).append('\n');
  43                         }
  44
  45                         log.debug(buf);
  46                 }
  47         }
  48
  49         // private static void print(ModuleSet moduleSet, Integer depth) {
  50         // StringBuilder prefix = new StringBuilder();
  51         // for (int i = 0; i < depth; i++) {
  52         // prefix.append(' ');
  53         // }
  54         // String p = prefix.toString();
  55         // prefix.setLength(0);
  56         // log.debug(p + "## " + moduleSet.toString());
  57         // Iterator<? extends NameVersion> nvIt = moduleSet.nameVersions();
  58         // while (nvIt.hasNext()) {
  59         // NameVersion nv = nvIt.next();
  60         // if (nv instanceof ModuleSet)
  61         // print((ModuleSet) nv, depth + 1);
  62         // else
  63         // log.debug(p + nv);
  64         //
  65         // }
  66         // }
  67
  68         public void destroy() {
  69
  70         }
  71
  72         public Distribution getModuleDistribution(String moduleName,
  73                         String moduleVersion) {
  74                 // NameVersion searched = new DefaultNameVersion(moduleName,
  75                 // moduleVersion);
  76                 // for (Distribution ad : modules) {
  77                 // if (ad.equals(searched))
  78                 // return ad;
  79                 // }
  80                 return null;
  81         }
  82
  83         public Iterator<NameVersion> nameVersions() {
  84                 List<NameVersion> nameVersions = new ArrayList<NameVersion>();
  85                 for (Object module : modules) {
  86                         // extract runnable from execution flow
  87                         if (module instanceof ExecutionFlow)
  88                                 module = ((ExecutionFlow) module).getRunnable();
  89
  90                         if (module instanceof ModuleSet)
  91                                 addNameVersions(nameVersions, (ModuleSet) module);
  92                         else if (module instanceof NameVersion) {
  93                                 NameVersion nv = (NameVersion) module;
  94                                 if (!nameVersions.contains(nv))
  95                                         nameVersions.add(nv);
  96                         } else
  97                                 log.warn("Ignored " + module);
  98                 }
  99                 return nameVersions.iterator();
 100         }
 101
 102         private void addNameVersions(List<NameVersion> nameVersions,
 103                         ModuleSet moduleSet) {
 104                 Iterator<? extends NameVersion> it = moduleSet.nameVersions();
 105                 while (it.hasNext()) {
 106                         NameVersion nv = it.next();
 107                         if (!nameVersions.contains(nv))
 108                                 nameVersions.add(nv);
 109                 }
 110         }
 111
 112         public Object getModulesDescriptor(String descriptorType) {
 113                 // TODO Auto-generated method stub
 114                 return null;
 115         }
 116
 117         public void setModules(List<Object> modules) {
 118                 this.modules = modules;
 119         }
 120
 121 }