| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you 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.gogo.command; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.PrintWriter; |
| import java.io.StringWriter; |
| import java.lang.annotation.Annotation; |
| import java.lang.reflect.Method; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.text.SimpleDateFormat; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Date; |
| import java.util.Dictionary; |
| import java.util.Enumeration; |
| import java.util.Formatter; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.TreeMap; |
| |
| import org.apache.felix.service.command.CommandSession; |
| import org.apache.felix.service.command.Descriptor; |
| import org.apache.felix.service.command.Parameter; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.BundleContext; |
| import org.osgi.framework.BundleException; |
| import org.osgi.framework.BundleReference; |
| import org.osgi.framework.Constants; |
| import org.osgi.framework.InvalidSyntaxException; |
| import org.osgi.framework.ServiceReference; |
| import org.osgi.framework.startlevel.BundleStartLevel; |
| import org.osgi.framework.startlevel.FrameworkStartLevel; |
| import org.osgi.framework.wiring.FrameworkWiring; |
| import org.osgi.service.log.LogEntry; |
| import org.osgi.service.log.LogReaderService; |
| import org.osgi.service.log.LogService; |
| |
| public class Basic |
| { |
| private final BundleContext m_bc; |
| private final Bundle m_b0; |
| |
| public Basic(BundleContext bc) |
| { |
| m_bc = bc; |
| m_b0 = m_bc.getBundle(0); |
| } |
| |
| @Descriptor("query bundle start level") |
| public String bundlelevel(@Descriptor("bundle to query") Bundle bundle) |
| { |
| return bundle + " is level " + bundle.adapt(BundleStartLevel.class).getStartLevel(); |
| } |
| |
| @Descriptor("set bundle start level or initial bundle start level") |
| public String bundlelevel( |
| @Descriptor("set the bundle's start level") @Parameter(names = { "-s", |
| "--setlevel" }, presentValue = "true", absentValue = "false") boolean set, |
| @Descriptor("set the initial bundle start level") @Parameter(names = { "-i", |
| "--setinitial" }, presentValue = "true", absentValue = "false") boolean initial, |
| @Descriptor("target level") int level, |
| @Descriptor("target identifiers") Bundle[] bundles) |
| { |
| |
| if (set && initial) |
| { |
| return "Cannot specify '-s' and '-i' at the same time."; |
| } |
| else if (!set && !initial) |
| { |
| return "Must specify either '-s' or '-i'."; |
| } |
| else if (level <= 0) |
| { |
| return "Specified start level must be greater than zero."; |
| } |
| // Set the initial bundle start level. |
| else if (initial) |
| { |
| if ((bundles != null) && (bundles.length == 0)) |
| { |
| m_b0.adapt(FrameworkStartLevel.class).setInitialBundleStartLevel(level); |
| } |
| else |
| { |
| return "Cannot specify bundles when setting initial start level."; |
| } |
| } |
| // Set the bundle start level. |
| else if (set) |
| { |
| if ((bundles != null) && (bundles.length != 0)) |
| { |
| for (Bundle bundle : bundles) |
| { |
| bundle.adapt(BundleStartLevel.class).setStartLevel(level); |
| } |
| } |
| else |
| { |
| return "Must specify target bundles."; |
| } |
| } |
| return null; |
| } |
| |
| @Descriptor("query framework active start level") |
| public String frameworklevel() |
| { |
| return "Level is " + m_b0.adapt(FrameworkStartLevel.class).getStartLevel(); |
| } |
| |
| @Descriptor("set framework active start level") |
| public void frameworklevel(@Descriptor("target start level") int level) |
| { |
| m_b0.adapt(FrameworkStartLevel.class).setStartLevel(level); |
| } |
| |
| @Descriptor("display bundle headers") |
| public String headers(@Descriptor("target bundles") Bundle[] bundles) |
| { |
| try (Formatter f = new Formatter()) { |
| bundles = ((bundles == null) || (bundles.length == 0)) ? m_bc.getBundles() |
| : bundles; |
| String prefix = ""; |
| for (Bundle bundle : bundles) |
| { |
| String title = Util.getBundleName(bundle); |
| f.format("%s%s%n", prefix, title); |
| f.format("%s%n", Util.getUnderlineString(title.length())); |
| Dictionary<String, String> dict = bundle.getHeaders(); |
| Enumeration<String> keys = dict.keys(); |
| while (keys.hasMoreElements()) |
| { |
| String k = keys.nextElement(); |
| String v = dict.get(k); |
| f.format("%s = %s%n", k, v); |
| } |
| prefix = "\n"; |
| } |
| return f.toString(); |
| } |
| } |
| |
| @Descriptor("displays available commands") |
| public String help() |
| { |
| try (Formatter f = new Formatter()) { |
| Map<String, List<Method>> commands = getCommands(); |
| for (String name : commands.keySet()) |
| { |
| f.format("%s%n", name); |
| } |
| return f.toString(); |
| } |
| } |
| |
| @Descriptor("displays information about a specific command") |
| public String help(@Descriptor("target command") String name) |
| { |
| Map<String, List<Method>> commands = getCommands(); |
| |
| List<Method> methods = null; |
| |
| // If the specified command doesn't have a scope, then |
| // search for matching methods by ignoring the scope. |
| int scopeIdx = name.indexOf(':'); |
| if (scopeIdx < 0) |
| { |
| for (Entry<String, List<Method>> entry : commands.entrySet()) |
| { |
| String k = entry.getKey().substring(entry.getKey().indexOf(':') + 1); |
| if (name.equals(k)) |
| { |
| name = entry.getKey(); |
| methods = entry.getValue(); |
| break; |
| } |
| } |
| } |
| // Otherwise directly look up matching methods. |
| else |
| { |
| methods = commands.get(name); |
| } |
| |
| if ((methods == null) || (methods.size() <= 0)) |
| { |
| return "No methods found matching: " + name; |
| } |
| |
| try (Formatter f = new Formatter()) { |
| String prefix = ""; |
| for (Method m : methods) |
| { |
| Descriptor d = m.getAnnotation(Descriptor.class); |
| if (d == null) |
| { |
| f.format("%s%s%n", prefix, m.getName()); |
| } |
| else |
| { |
| f.format("%s%s - %s%n", prefix, m.getName(), d.value()); |
| } |
| |
| f.format(" scope: %s%n", name.substring(0, name.indexOf(':'))); |
| |
| // Get flags and options. |
| Class<?>[] paramTypes = m.getParameterTypes(); |
| Map<String, Parameter> flags = new TreeMap<>(); |
| Map<String, String> flagDescs = new TreeMap<>(); |
| Map<String, Parameter> options = new TreeMap<>(); |
| Map<String, String> optionDescs = new TreeMap<>(); |
| List<String> params = new ArrayList<>(); |
| Annotation[][] anns = m.getParameterAnnotations(); |
| for (int paramIdx = 0; paramIdx < anns.length; paramIdx++) |
| { |
| Class<?> paramType = m.getParameterTypes()[paramIdx]; |
| if (paramType == CommandSession.class) { |
| /* Do not bother the user with a CommandSession. */ |
| continue; |
| } |
| Parameter p = findAnnotation(anns[paramIdx], Parameter.class); |
| d = findAnnotation(anns[paramIdx], Descriptor.class); |
| if (p != null) |
| { |
| if (p.presentValue().equals(Parameter.UNSPECIFIED)) |
| { |
| options.put(p.names()[0], p); |
| if (d != null) |
| { |
| optionDescs.put(p.names()[0], d.value()); |
| } |
| } |
| else |
| { |
| flags.put(p.names()[0], p); |
| if (d != null) |
| { |
| flagDescs.put(p.names()[0], d.value()); |
| } |
| } |
| } |
| else if (d != null) |
| { |
| params.add(paramTypes[paramIdx].getSimpleName()); |
| params.add(d.value()); |
| } |
| else |
| { |
| params.add(paramTypes[paramIdx].getSimpleName()); |
| params.add(""); |
| } |
| } |
| |
| // Print flags and options. |
| if (flags.size() > 0) |
| { |
| f.format(" flags:%n"); |
| for (Entry<String, Parameter> entry : flags.entrySet()) |
| { |
| // Print all aliases. |
| String[] names = entry.getValue().names(); |
| f.format(" %s", names[0]); |
| for (int aliasIdx = 1; aliasIdx < names.length; aliasIdx++) |
| { |
| f.format(", %s", names[aliasIdx]); |
| } |
| f.format(" %s%n", flagDescs.get(entry.getKey())); |
| } |
| } |
| if (options.size() > 0) |
| { |
| f.format(" options:%n"); |
| for (Entry<String, Parameter> entry : options.entrySet()) |
| { |
| // Print all aliases. |
| String[] names = entry.getValue().names(); |
| f.format(" %s", names[0]); |
| for (int aliasIdx = 1; aliasIdx < names.length; aliasIdx++) |
| { |
| f.format(", %s", names[aliasIdx]); |
| } |
| f.format(" %s%s%n", |
| optionDescs.get(entry.getKey()), |
| ((entry.getValue().absentValue() == null) ? "" : " [optional]")); |
| } |
| } |
| if (params.size() > 0) |
| { |
| f.format(" parameters:%n"); |
| for (Iterator<String> it = params.iterator(); it.hasNext();) |
| { |
| f.format(" %s %s%n", it.next(), it.next()); |
| } |
| } |
| prefix = "\n"; |
| } |
| return f.toString(); |
| } |
| } |
| |
| private static <T extends Annotation> T findAnnotation(Annotation[] anns, |
| Class<T> clazz) |
| { |
| for (int i = 0; (anns != null) && (i < anns.length); i++) |
| { |
| if (clazz.isInstance(anns[i])) |
| { |
| return clazz.cast(anns[i]); |
| } |
| } |
| return null; |
| } |
| |
| private Map<String, List<Method>> getCommands() |
| { |
| ServiceReference<?>[] refs = null; |
| try |
| { |
| refs = m_bc.getAllServiceReferences(null, "(osgi.command.scope=*)"); |
| } |
| catch (InvalidSyntaxException ex) |
| { |
| // This should never happen. |
| } |
| |
| Map<String, List<Method>> commands = new TreeMap<>(); |
| |
| for (ServiceReference<?> ref : refs) |
| { |
| Object svc = m_bc.getService(ref); |
| if (svc != null) |
| { |
| String scope = (String) ref.getProperty("osgi.command.scope"); |
| Object ofunc = ref.getProperty("osgi.command.function"); |
| String[] funcs = (ofunc instanceof String[]) ? (String[]) ofunc |
| : new String[] { String.valueOf(ofunc) }; |
| |
| for (String func : funcs) |
| { |
| commands.put(scope + ":" + func, new ArrayList<Method>()); |
| } |
| |
| if (!commands.isEmpty()) |
| { |
| Method[] methods = svc.getClass().getMethods(); |
| for (Method method : methods) |
| { |
| List<Method> commandMethods = commands.get(scope + ":" |
| + method.getName()); |
| if (commandMethods != null) |
| { |
| commandMethods.add(method); |
| } |
| } |
| } |
| |
| // Remove any missing commands. |
| Iterator<Entry<String, List<Method>>> it = commands.entrySet().iterator(); |
| while (it.hasNext()) |
| { |
| if (it.next().getValue().size() == 0) |
| { |
| it.remove(); |
| } |
| } |
| } |
| } |
| |
| return commands; |
| } |
| |
| @Descriptor("install bundle using URLs") |
| public String install(@Descriptor("command session")CommandSession session, |
| @Descriptor("target URLs") String[] urls) throws IOException |
| { |
| try (Formatter f = new Formatter()) { |
| |
| StringBuilder sb = new StringBuilder(); |
| |
| for (String url : urls) |
| { |
| String location = Util.resolveUri(session, url.trim()); |
| Bundle bundle = null; |
| try |
| { |
| bundle = m_bc.installBundle(location, null); |
| } |
| catch (IllegalStateException ex) |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| catch (BundleException ex) |
| { |
| if (ex.getNestedException() != null) |
| { |
| f.format("%s%n", ex.getNestedException().toString()); |
| } |
| else |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| } |
| catch (Exception ex) |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| if (bundle != null) |
| { |
| if (sb.length() > 0) |
| { |
| sb.append(", "); |
| } |
| sb.append(bundle.getBundleId()); |
| } |
| } |
| if (sb.toString().indexOf(',') > 0) |
| { |
| return "Bundle IDs: " + sb.toString(); |
| } |
| else if (sb.length() > 0) |
| { |
| return "Bundle ID: " + sb.toString(); |
| } |
| return f.toString(); |
| } |
| } |
| |
| @Descriptor("list all installed bundles") |
| public String lb( |
| @Descriptor("show location") @Parameter(names = { "-l", "--location" }, presentValue = "true", absentValue = "false") boolean showLoc, |
| @Descriptor("show symbolic name") @Parameter(names = { "-s", "--symbolicname" }, presentValue = "true", absentValue = "false") boolean showSymbolic, |
| @Descriptor("show update location") @Parameter(names = { "-u", "--updatelocation" }, presentValue = "true", absentValue = "false") boolean showUpdate) |
| { |
| return lb(showLoc, showSymbolic, showUpdate, null); |
| } |
| |
| @Descriptor("list installed bundles matching a substring") |
| public String lb( |
| @Descriptor("show location") @Parameter(names = { "-l", "--location" }, presentValue = "true", absentValue = "false") boolean showLoc, |
| @Descriptor("show symbolic name") @Parameter(names = { "-s", "--symbolicname" }, presentValue = "true", absentValue = "false") boolean showSymbolic, |
| @Descriptor("show update location") @Parameter(names = { "-u", "--updatelocation" }, presentValue = "true", absentValue = "false") boolean showUpdate, |
| @Descriptor("subtring matched against name or symbolic name") String pattern) |
| { |
| if ((showLoc && showSymbolic && showUpdate) || |
| (showLoc && showSymbolic) || |
| (showSymbolic && showUpdate) || |
| (showLoc && showUpdate)) { |
| return "Only one of -l, -s, -u should be used."; |
| } |
| List<Bundle> found = new ArrayList<>(); |
| |
| if (pattern == null) |
| { |
| found.addAll(Arrays.asList(m_bc.getBundles())); |
| } |
| else |
| { |
| Bundle[] bundles = m_bc.getBundles(); |
| for (Bundle bundle : bundles) { |
| String name = bundle.getHeaders().get(Constants.BUNDLE_NAME); |
| if (matchBundleName(bundle.getSymbolicName(), pattern) |
| || matchBundleName(name, pattern)) { |
| found.add(bundle); |
| } |
| } |
| } |
| |
| if (found.size() > 0) |
| { |
| try (Formatter f = new Formatter()) { |
| printBundleList(found.toArray(new Bundle[found.size()]), |
| showLoc, showSymbolic, showUpdate, m_b0, f); |
| return f.toString(); |
| } |
| } |
| else |
| { |
| return "No matching bundles found."; |
| } |
| } |
| |
| private boolean matchBundleName(String name, String pattern) |
| { |
| return (name != null) && name.toLowerCase().contains(pattern.toLowerCase()); |
| } |
| |
| @Descriptor("display all matching log entries") |
| public String log( |
| @Descriptor("minimum log level [ debug | info | warn | error ]") String logLevel) |
| { |
| return log(-1, logLevel); |
| } |
| |
| @Descriptor("display some matching log entries") |
| public String log(@Descriptor("maximum number of entries") int maxEntries, |
| @Descriptor("minimum log level [ debug | info | warn | error ]") String logLevel) |
| { |
| // Keep track of service references. |
| List<ServiceReference<?>> refs = new ArrayList<>(); |
| |
| // Get start level service. |
| try { |
| LogReaderService lrs = Util.getService(m_bc, LogReaderService.class, refs); |
| if (lrs == null) |
| { |
| return "Log reader service is unavailable."; |
| } |
| else |
| { |
| try (Formatter f = new Formatter()) { |
| @SuppressWarnings("unchecked") |
| Enumeration<LogEntry> entries = lrs.getLog(); |
| List<LogEntry> select = new ArrayList<>(); |
| |
| int minLevel = logLevelAsInt(logLevel); |
| |
| int index = 0; |
| while (entries.hasMoreElements() && (maxEntries < 0 || index < maxEntries)) |
| { |
| LogEntry entry = entries.nextElement(); |
| if (entry.getLevel() <= minLevel) |
| { |
| select.add(0, entry); |
| index++; |
| } |
| } |
| |
| for (LogEntry e : select) { |
| display(e,f); |
| } |
| Util.ungetServices(m_bc, refs); |
| return f.toString(); |
| } |
| } |
| } |
| catch (NoClassDefFoundError ncdfe) { |
| return "Log reader service is unavailable."; |
| } |
| } |
| |
| private void display(LogEntry entry, Formatter f) |
| { |
| SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss"); |
| |
| StringBuilder buffer = new StringBuilder(); |
| buffer.append(sdf.format(new Date(entry.getTime()))).append(" "); |
| buffer.append(logLevelAsString(entry.getLevel())).append(" - "); |
| buffer.append("Bundle: ").append(entry.getBundle().getSymbolicName()); |
| if (entry.getServiceReference() != null) |
| { |
| buffer.append(" - "); |
| buffer.append(entry.getServiceReference().toString()); |
| } |
| buffer.append(" - ").append(entry.getMessage()); |
| if (entry.getException() != null) |
| { |
| buffer.append(" - "); |
| StringWriter writer = new StringWriter(); |
| PrintWriter pw = new PrintWriter(writer); |
| entry.getException().printStackTrace(pw); |
| buffer.append(writer.toString()); |
| } |
| |
| f.format("%s%n", buffer.toString()); |
| } |
| |
| private static int logLevelAsInt(String logLevel) |
| { |
| if ("error".equalsIgnoreCase(logLevel)) |
| { |
| return LogService.LOG_ERROR; |
| } |
| else if ("warn".equalsIgnoreCase(logLevel)) |
| { |
| return LogService.LOG_WARNING; |
| } |
| else if ("info".equalsIgnoreCase(logLevel)) |
| { |
| return LogService.LOG_INFO; |
| } |
| return LogService.LOG_DEBUG; |
| } |
| |
| private static String logLevelAsString(int level) |
| { |
| switch (level) |
| { |
| case LogService.LOG_ERROR: |
| return "ERROR"; |
| case LogService.LOG_WARNING: |
| return "WARNING"; |
| case LogService.LOG_INFO: |
| return "INFO"; |
| default: |
| return "DEBUG"; |
| } |
| } |
| |
| @Descriptor("refresh bundles") |
| public void refresh( |
| @Descriptor("target bundles (can be null or empty)") Bundle[] bundles) |
| { |
| if ((bundles != null) && (bundles.length == 0)) |
| { |
| bundles = null; |
| } |
| |
| m_b0.adapt(FrameworkWiring.class).refreshBundles(Arrays.asList(bundles)); |
| } |
| |
| @Descriptor("resolve bundles") |
| public String resolve( |
| @Descriptor("target bundles (can be null or empty)") Bundle[] bundles) |
| { |
| if (m_b0.adapt(FrameworkWiring.class).resolveBundles(bundles != null ? Arrays.asList(bundles) : null)) |
| { |
| return "Not all bundles could be resolved."; |
| } |
| return null; |
| } |
| |
| @Descriptor("start bundles") |
| public String start( |
| @Descriptor("start bundle transiently") @Parameter(names = { "-t", "--transient" }, presentValue = "true", absentValue = "false") boolean trans, |
| @Descriptor("use declared activation policy") @Parameter(names = { "-p", |
| "--policy" }, presentValue = "true", absentValue = "false") boolean policy, |
| @Descriptor("target bundle identifiers or URLs") String[] ss) |
| { |
| if ((ss == null) || (ss.length < 1)) { |
| return "Please specify the bundles to start."; |
| } |
| |
| int options = 0; |
| |
| // Check for "transient" switch. |
| if (trans) |
| { |
| options |= Bundle.START_TRANSIENT; |
| } |
| |
| // Check for "start policy" switch. |
| if (policy) |
| { |
| options |= Bundle.START_ACTIVATION_POLICY; |
| } |
| |
| try (Formatter f = new Formatter()) { |
| for (String s : ss) |
| { |
| String id = s.trim(); |
| |
| try |
| { |
| Bundle bundle = null; |
| |
| // The id may be a number or a URL, so check. |
| if (Character.isDigit(id.charAt(0))) |
| { |
| long l = Long.parseLong(id); |
| bundle = m_bc.getBundle(l); |
| } |
| else |
| { |
| bundle = m_bc.installBundle(id); |
| } |
| |
| if (bundle != null) |
| { |
| bundle.start(options); |
| } |
| else |
| { |
| f.format("Bundle ID '%s' is invalid.%n", id); |
| } |
| } |
| catch (NumberFormatException ex) |
| { |
| f.format("Unable to parse id '%s'.%n", id); |
| } |
| catch (BundleException ex) |
| { |
| if (ex.getNestedException() != null) |
| { |
| f.format("%s%n", ex.getNestedException().toString()); |
| } |
| else |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| } |
| catch (Exception ex) |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| } |
| return f.toString(); |
| } |
| } |
| |
| @Descriptor("stop bundles") |
| public String stop(@Descriptor("stop bundle transiently") @Parameter(names = { "-t", |
| "--transient" }, presentValue = "true", absentValue = "false") boolean trans, |
| @Descriptor("target bundles") Bundle[] bundles) |
| { |
| if ((bundles == null) || (bundles.length == 0)) |
| { |
| return "Please specify the bundles to stop."; |
| } |
| |
| int options = 0; |
| |
| // Check for "transient" switch. |
| if (trans) |
| { |
| options |= Bundle.STOP_TRANSIENT; |
| } |
| |
| try (Formatter f = new Formatter()) { |
| for (Bundle bundle : bundles) |
| { |
| try |
| { |
| bundle.stop(options); |
| } |
| catch (BundleException ex) |
| { |
| if (ex.getNestedException() != null) |
| { |
| f.format("%s%n", ex.getNestedException().toString()); |
| } |
| else |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| } |
| catch (Exception ex) |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| } |
| return f.toString(); |
| } |
| } |
| |
| @Descriptor("uninstall bundles") |
| public String uninstall(@Descriptor("target bundles") Bundle[] bundles) |
| { |
| if ((bundles == null) || (bundles.length == 0)) |
| { |
| return "Please specify the bundles to uninstall."; |
| } |
| |
| try (Formatter f = new Formatter()) { |
| for (Bundle bundle : bundles) |
| { |
| try |
| { |
| bundle.uninstall(); |
| } |
| catch (BundleException ex) |
| { |
| if (ex.getNestedException() != null) |
| { |
| f.format("%s%n", ex.getNestedException().toString()); |
| } |
| else { |
| f.format("%s%n", ex.toString()); |
| } |
| } |
| catch (Exception ex) |
| { |
| f.format("%s%n", ex.toString()); |
| } |
| } |
| return f.toString(); |
| } |
| } |
| |
| @Descriptor("update bundle") |
| public String update(@Descriptor("target bundle") Bundle bundle) |
| { |
| if (bundle == null) |
| { |
| return "Must specify a bundle."; |
| } |
| |
| try |
| { |
| bundle.update(); |
| return null; |
| } |
| catch (BundleException ex) |
| { |
| if (ex.getNestedException() != null) |
| { |
| return ex.getNestedException().toString(); |
| } |
| |
| return ex.toString(); |
| } |
| catch (Exception ex) |
| { |
| return ex.toString(); |
| } |
| } |
| |
| @Descriptor("update bundle from URL") |
| public String update( |
| @Descriptor("command session") CommandSession session, |
| @Descriptor("target bundle") Bundle bundle, |
| @Descriptor("URL from where to retrieve bundle") String location) throws IOException { |
| if (bundle == null) |
| { |
| return "Must specify a bundle."; |
| } |
| if (location == null) |
| { |
| return "Must specify a location."; |
| } |
| |
| try |
| { |
| location = Util.resolveUri(session, location.trim()); |
| InputStream is = new URL(location).openStream(); |
| bundle.update(is); |
| return null; |
| } |
| catch (MalformedURLException ex) |
| { |
| return "Unable to parse URL"; |
| } |
| catch (IOException ex) |
| { |
| return "Unable to open input stream: " + ex; |
| } |
| catch (BundleException ex) |
| { |
| if (ex.getNestedException() != null) |
| { |
| return ex.getNestedException().toString(); |
| } |
| |
| return ex.toString(); |
| } |
| catch (Exception ex) |
| { |
| return ex.toString(); |
| } |
| } |
| |
| @Descriptor("determines from where a bundle loads a class") |
| public String which(@Descriptor("target bundle") Bundle bundle, |
| @Descriptor("target class name") String className) |
| { |
| if (bundle == null) |
| { |
| return "Please specify a bundle"; |
| } |
| |
| Class<?> clazz = null; |
| try |
| { |
| clazz = bundle.loadClass(className); |
| if (clazz.getClassLoader() == null) |
| { |
| return "Loaded from: boot class loader"; |
| } |
| else if (clazz.getClassLoader() instanceof BundleReference) |
| { |
| Bundle p = ((BundleReference) clazz.getClassLoader()).getBundle(); |
| return "Loaded from: " + p; |
| } |
| else |
| { |
| return "Loaded from: " + clazz.getClassLoader(); |
| } |
| } |
| catch (ClassNotFoundException ex) |
| { |
| return "Class not found"; |
| } |
| } |
| |
| private static void printBundleList(Bundle[] bundles, |
| boolean showLoc, boolean showSymbolic, boolean showUpdate, Bundle b0, Formatter f) |
| { |
| f.format("START LEVEL %s%n", b0.adapt(FrameworkStartLevel.class).getStartLevel()); |
| |
| // Determine last column. |
| String lastColumn = "Name"; |
| if (showLoc) |
| { |
| lastColumn = "Location"; |
| } |
| else if (showSymbolic) |
| { |
| lastColumn = "Symbolic name"; |
| } |
| else if (showUpdate) |
| { |
| lastColumn = "Update location"; |
| } |
| |
| f.format("%5s|%-11s|%5s|%s%n", "ID", "State", "Level", lastColumn); |
| for (Bundle bundle : bundles) |
| { |
| // Get the bundle name or location. |
| String name = bundle.getHeaders().get(Constants.BUNDLE_NAME); |
| // If there is no name, then default to symbolic name. |
| name = (name == null) ? bundle.getSymbolicName() : name; |
| // If there is no symbolic name, resort to location. |
| name = (name == null) ? bundle.getLocation() : name; |
| |
| // Overwrite the default value is the user specifically |
| // requested to display one or the other. |
| if (showLoc) |
| { |
| name = bundle.getLocation(); |
| } |
| else if (showSymbolic) |
| { |
| name = bundle.getSymbolicName(); |
| name = (name == null) ? "<no symbolic name>" : name; |
| } |
| else if (showUpdate) |
| { |
| name = bundle.getHeaders().get(Constants.BUNDLE_UPDATELOCATION); |
| name = (name == null) ? bundle.getLocation() : name; |
| } |
| |
| // Show bundle version if not showing location. |
| name = (!showLoc && !showUpdate) ? name + " (" + bundle.getVersion() + ")" |
| : name; |
| |
| // Get the bundle's start level. |
| int level = bundle.adapt(BundleStartLevel.class).getStartLevel(); |
| |
| f.format("%5d|%-11s|%5d|%s|%s%n", |
| bundle.getBundleId(), getStateString(bundle), level, name, |
| bundle.getVersion()); |
| } |
| } |
| |
| private static String getStateString(Bundle bundle) |
| { |
| int state = bundle.getState(); |
| if (state == Bundle.ACTIVE) |
| { |
| return "Active "; |
| } |
| else if (state == Bundle.INSTALLED) |
| { |
| return "Installed "; |
| } |
| else if (state == Bundle.RESOLVED) |
| { |
| return "Resolved "; |
| } |
| else if (state == Bundle.STARTING) |
| { |
| return "Starting "; |
| } |
| else if (state == Bundle.STOPPING) |
| { |
| return "Stopping "; |
| } |
| else |
| { |
| return "Unknown "; |
| } |
| } |
| } |
