org.argeo.init/src/org/argeo/init/osgi/OsgiBootUtils.java

   1 package org.argeo.init.osgi;
   2
   3 import java.lang.System.Logger;
   4 import java.lang.System.Logger.Level;
   5 import java.util.ArrayList;
   6 import java.util.HashMap;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Objects;
  10 import java.util.Optional;
  11 import java.util.ServiceLoader;
  12 import java.util.StringTokenizer;
  13
  14 import org.osgi.framework.Bundle;
  15 import org.osgi.framework.BundleException;
  16 import org.osgi.framework.launch.Framework;
  17 import org.osgi.framework.launch.FrameworkFactory;
  18
  19 /** Utilities, mostly related to logging. */
  20 public class OsgiBootUtils {
  21         private final static Logger logger = System.getLogger(OsgiBootUtils.class.getName());
  22
  23         public static void info(Object obj) {
  24                 logger.log(Level.INFO, () -> Objects.toString(obj));
  25         }
  26
  27         public static void debug(Object obj) {
  28                 logger.log(Level.TRACE, () -> Objects.toString(obj));
  29         }
  30
  31         public static void warn(Object obj) {
  32                 logger.log(Level.WARNING, () -> Objects.toString(obj));
  33         }
  34
  35         public static void error(Object obj, Throwable e) {
  36                 logger.log(Level.ERROR, () -> Objects.toString(obj), e);
  37         }
  38
  39         public static boolean isDebug() {
  40                 return logger.isLoggable(Level.TRACE);
  41         }
  42
  43         public static String stateAsString(int state) {
  44                 switch (state) {
  45                 case Bundle.UNINSTALLED:
  46                         return "UNINSTALLED";
  47                 case Bundle.INSTALLED:
  48                         return "INSTALLED";
  49                 case Bundle.RESOLVED:
  50                         return "RESOLVED";
  51                 case Bundle.STARTING:
  52                         return "STARTING";
  53                 case Bundle.ACTIVE:
  54                         return "ACTIVE";
  55                 case Bundle.STOPPING:
  56                         return "STOPPING";
  57                 default:
  58                         return Integer.toString(state);
  59                 }
  60         }
  61
  62         /**
  63          * @return ==0: versions are identical, &lt;0: tested version is newer, &gt;0:
  64          *         currentVersion is newer.
  65          */
  66         public static int compareVersions(String currentVersion, String testedVersion) {
  67                 List<String> cToks = new ArrayList<String>();
  68                 StringTokenizer cSt = new StringTokenizer(currentVersion, ".");
  69                 while (cSt.hasMoreTokens())
  70                         cToks.add(cSt.nextToken());
  71                 List<String> tToks = new ArrayList<String>();
  72                 StringTokenizer tSt = new StringTokenizer(currentVersion, ".");
  73                 while (tSt.hasMoreTokens())
  74                         tToks.add(tSt.nextToken());
  75
  76                 int comp = 0;
  77                 comp: for (int i = 0; i < cToks.size(); i++) {
  78                         if (tToks.size() <= i) {
  79                                 // equals until then, tested shorter
  80                                 comp = 1;
  81                                 break comp;
  82                         }
  83
  84                         String c = (String) cToks.get(i);
  85                         String t = (String) tToks.get(i);
  86
  87                         try {
  88                                 int cInt = Integer.parseInt(c);
  89                                 int tInt = Integer.parseInt(t);
  90                                 if (cInt == tInt)
  91                                         continue comp;
  92                                 else {
  93                                         comp = (cInt - tInt);
  94                                         break comp;
  95                                 }
  96                         } catch (NumberFormatException e) {
  97                                 if (c.equals(t))
  98                                         continue comp;
  99                                 else {
 100                                         comp = c.compareTo(t);
 101                                         break comp;
 102                                 }
 103                         }
 104                 }
 105
 106                 if (comp == 0 && tToks.size() > cToks.size()) {
 107                         // equals until then, current shorter
 108                         comp = -1;
 109                 }
 110
 111                 return comp;
 112         }
 113
 114         public static Framework launch(Map<String, String> configuration) {
 115                 Optional<FrameworkFactory> frameworkFactory = ServiceLoader.load(FrameworkFactory.class).findFirst();
 116                 if (frameworkFactory.isEmpty())
 117                         throw new IllegalStateException("No framework factory found");
 118                 return launch(frameworkFactory.get(), configuration);
 119         }
 120
 121         /** Launch an OSGi framework. */
 122         public static Framework launch(FrameworkFactory frameworkFactory, Map<String, String> configuration) {
 123                 // start OSGi
 124                 Framework framework = frameworkFactory.newFramework(configuration);
 125                 try {
 126                         framework.start();
 127                 } catch (BundleException e) {
 128                         throw new IllegalStateException("Cannot start OSGi framework", e);
 129                 }
 130                 return framework;
 131         }
 132
 133         @Deprecated
 134         public static Map<String, String> equinoxArgsToConfiguration(String[] args) {
 135                 // FIXME implement it
 136                 return new HashMap<>();
 137         }
 138
 139 }