X-Git-Url: http://git.argeo.org/?a=blobdiff_plain;f=runtime%2Forg.argeo.slc.support.equinox%2Fsrc%2Fmain%2Fjava%2Forg%2Fargeo%2Fslc%2Fequinox%2FExecutionCommandProvider.java;h=2a265bb9151789f7c3b7eea30efe888a8557fa05;hb=afb6d7b61d38bdb104414601d296070c893ece8c;hp=f94ded602504f72f828dea8c7280925bb0873fd7;hpb=9f3bb3da19667430f2048c1b60ccd4785c210086;p=gpl%2Fargeo-slc.git diff --git a/runtime/org.argeo.slc.support.equinox/src/main/java/org/argeo/slc/equinox/ExecutionCommandProvider.java b/runtime/org.argeo.slc.support.equinox/src/main/java/org/argeo/slc/equinox/ExecutionCommandProvider.java index f94ded602..2a265bb91 100644 --- a/runtime/org.argeo.slc.support.equinox/src/main/java/org/argeo/slc/equinox/ExecutionCommandProvider.java +++ b/runtime/org.argeo.slc.support.equinox/src/main/java/org/argeo/slc/equinox/ExecutionCommandProvider.java @@ -1,49 +1,57 @@ +/* + * Copyright (C) 2010 Mathieu Baudier + * + * Licensed 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.argeo.slc.equinox; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.argeo.slc.SlcException; -import org.argeo.slc.execution.ExecutionFlowDescriptor; -import org.argeo.slc.execution.ExecutionModule; +import org.argeo.slc.osgi.OsgiExecutionModulesManager; +import org.argeo.slc.process.RealizedFlow; +import org.eclipse.core.runtime.adaptor.EclipseStarter; import org.eclipse.osgi.framework.console.CommandInterpreter; import org.eclipse.osgi.framework.console.CommandProvider; -import org.osgi.framework.Bundle; -import org.osgi.framework.BundleContext; -import org.osgi.framework.BundleException; -import org.osgi.framework.FrameworkEvent; -import org.osgi.framework.FrameworkListener; -import org.osgi.framework.InvalidSyntaxException; -import org.osgi.framework.ServiceReference; -import org.osgi.service.packageadmin.PackageAdmin; -import org.springframework.beans.factory.InitializingBean; -import org.springframework.context.ApplicationContext; -import org.springframework.osgi.context.BundleContextAware; -public class ExecutionCommandProvider implements CommandProvider, - BundleContextAware, FrameworkListener, InitializingBean { +@SuppressWarnings("restriction") +public class ExecutionCommandProvider implements CommandProvider { private final static Log log = LogFactory .getLog(ExecutionCommandProvider.class); - private Long defaultTimeout = 10000l; + private final static String SLC_WITH_REFRESH = "slc"; + private final static String SLC_NO_REFRESH = "slcnr"; - private BundleContext bundleContext; + private OsgiExecutionModulesManager modulesManager; - private String lastModuleName = null; - private String lastExecutionName = null; + private RealizedFlow lastLaunch = null; - private final Object refreshedPackageSem = new Object(); + public Object _slc(CommandInterpreter ci) { + return exec(SLC_WITH_REFRESH, ci); + } - /** @deprecated Use slc command instead. */ - public Object _slc_exec(CommandInterpreter ci) { - return _slc(ci); + public Object _slcnr(CommandInterpreter ci) { + return exec(SLC_NO_REFRESH, ci); } - public Object _slc(CommandInterpreter ci) { + protected Object exec(String slcCommand, CommandInterpreter ci) { // TODO: check version String firstArg = ci.nextArgument(); if (firstArg == null) { - if (lastModuleName != null) { - String cmd = "slc " + lastModuleName + " " + lastExecutionName; + if (lastLaunch != null) { + String cmd = slcCommand + " " + lastLaunch.getModuleName() + + " " + lastLaunch.getFlowDescriptor().getName(); if (log.isDebugEnabled()) log.debug("Execute again last command: " + cmd); return ci.execute(cmd); @@ -54,240 +62,69 @@ public class ExecutionCommandProvider implements CommandProvider, } String executionName = ci.nextArgument(); - String moduleName = null; - - // First check whether we have a bundleId - Long bundleId = null; - try { - bundleId = Long.parseLong(firstArg); - } catch (NumberFormatException e) { - // silent - } - - // Look for bundle names containing pattern - Bundle bundle = null; - if (bundleId != null) { - bundle = bundleContext.getBundle(bundleId); - } else { - for (Bundle b : bundleContext.getBundles()) { - if (b.getSymbolicName().contains(firstArg)) { - bundle = b; - break; - } - } - } - - if (bundle != null) { - moduleName = bundle.getSymbolicName(); - lastModuleName = moduleName; - lastExecutionName = executionName; - } else { - log - .warn("Could not find any execution module matching these requirements."); - return null; - } - - // Find module - ExecutionModule module = null; - ServiceReference serviceRef = null; - try { - stopSynchronous(bundle); - updateSynchronous(bundle); - // Refresh in case there are fragments - refreshSynchronous(bundle); - startSynchronous(bundle); - - String filter = "(Bundle-SymbolicName=" + moduleName + ")"; - // Wait for application context to be ready - getServiceRefSynchronous(ApplicationContext.class.getName(), filter); - - if (log.isDebugEnabled()) - log.debug("Bundle " + bundle.getSymbolicName() - + " ready to be used at latest version."); - - ServiceReference[] sfs = getServiceRefSynchronous( - ExecutionModule.class.getName(), filter); - - if (sfs.length > 1) - log - .warn("More than one execution module service found in module " - + moduleName); - - if (sfs.length > 0) { - serviceRef = sfs[0]; - module = (ExecutionModule) bundleContext.getService(serviceRef); - } - - if (module != null) { - ExecutionFlowDescriptor descriptor = new ExecutionFlowDescriptor(); - descriptor.setName(executionName); - module.execute(descriptor); - log.info("Executed " + executionName + " from " + moduleName); - } - - } catch (Exception e) { - throw new SlcException("Cannot find or update module.", e); - } finally { - if (serviceRef != null) - bundleContext.ungetService(serviceRef); - } - + launch(slcCommand, firstArg, executionName); return "COMMAND COMPLETED"; } + protected void launch(String slcCommand, String firstArg, + String executionName) { + lastLaunch = modulesManager.findRealizedFlow(firstArg, executionName); + if (lastLaunch == null) + throw new SlcException("Cannot find launch for " + firstArg + " " + + executionName); + + // Execute + if (SLC_WITH_REFRESH.equals(slcCommand)) { + modulesManager.upgrade(lastLaunch.getModuleNameVersion()); + modulesManager.execute(lastLaunch); + } else if (SLC_NO_REFRESH.equals(slcCommand)) + modulesManager.execute(lastLaunch); + else + throw new SlcException("Unrecognized SLC command " + slcCommand); + } + public String getHelp() { StringBuffer buf = new StringBuffer(); buf.append("---SLC Execution Commands---\n"); buf - .append("\tslc (|) - execute an execution flow (without arg, execute last)\n"); + .append("\tslc (|) " + + " - refresh the bundle, execute an execution flow (without arg, execute last)\n"); + buf + .append("\tslcnr (|) " + + " - execute an execution flow (without arg, execute last)\n"); return buf.toString(); } - /** Updates bundle synchronously. */ - protected void updateSynchronous(Bundle bundle) throws BundleException { - // int originalState = bundle.getState(); - bundle.update(); - boolean waiting = true; - - long begin = System.currentTimeMillis(); - do { - int state = bundle.getState(); - if (state == Bundle.INSTALLED || state == Bundle.ACTIVE - || state == Bundle.RESOLVED) - waiting = false; - - sleep(100); - if (System.currentTimeMillis() - begin > defaultTimeout) - throw new SlcException("Update of bundle " - + bundle.getSymbolicName() - + " timed out. Bundle state = " + bundle.getState()); - } while (waiting); - - if (log.isTraceEnabled()) - log.debug("Bundle " + bundle.getSymbolicName() + " updated."); + public void setModulesManager(OsgiExecutionModulesManager osgiModulesManager) { + this.modulesManager = osgiModulesManager; } - /** Starts bundle synchronously. Does nothing if already started. */ - protected void startSynchronous(Bundle bundle) throws BundleException { - int originalState = bundle.getState(); - if (originalState == Bundle.ACTIVE) - return; - - bundle.start(); - boolean waiting = true; - - long begin = System.currentTimeMillis(); - do { - if (bundle.getState() == Bundle.ACTIVE) - waiting = false; - - sleep(100); - if (System.currentTimeMillis() - begin > defaultTimeout) - throw new SlcException("Start of bundle " - + bundle.getSymbolicName() - + " timed out. Bundle state = " + bundle.getState()); - } while (waiting); - - if (log.isTraceEnabled()) - log.debug("Bundle " + bundle.getSymbolicName() + " started."); - } - - /** Stops bundle synchronously. Does nothing if already started. */ - protected void stopSynchronous(Bundle bundle) throws BundleException { - int originalState = bundle.getState(); - if (originalState != Bundle.ACTIVE) - return; - - bundle.stop(); - boolean waiting = true; - - long begin = System.currentTimeMillis(); - do { - if (bundle.getState() != Bundle.ACTIVE - && bundle.getState() != Bundle.STOPPING) - waiting = false; - - sleep(100); - if (System.currentTimeMillis() - begin > defaultTimeout) - throw new SlcException("Stop of bundle " - + bundle.getSymbolicName() - + " timed out. Bundle state = " + bundle.getState()); - } while (waiting); - - if (log.isTraceEnabled()) - log.debug("Bundle " + bundle.getSymbolicName() + " stopped."); - } - - /** Refresh bundle synchronously. Does nothing if already started. */ - protected void refreshSynchronous(Bundle bundle) throws BundleException { - ServiceReference packageAdminRef = bundleContext - .getServiceReference(PackageAdmin.class.getName()); - PackageAdmin packageAdmin = (PackageAdmin) bundleContext - .getService(packageAdminRef); - Bundle[] bundles = { bundle }; - packageAdmin.refreshPackages(bundles); - - synchronized (refreshedPackageSem) { - try { - refreshedPackageSem.wait(defaultTimeout); - } catch (InterruptedException e) { - // silent - } - } - - if (log.isTraceEnabled()) - log.debug("Bundle " + bundle.getSymbolicName() + " refreshed."); - } - - public void frameworkEvent(FrameworkEvent event) { - if (event.getType() == FrameworkEvent.PACKAGES_REFRESHED) { - synchronized (refreshedPackageSem) { - refreshedPackageSem.notifyAll(); - } - } - } - - protected ServiceReference[] getServiceRefSynchronous(String clss, - String filter) throws InvalidSyntaxException { - if (log.isTraceEnabled()) - log.debug("Filter: '" + filter + "'"); - ServiceReference[] sfs = null; - boolean waiting = true; - long begin = System.currentTimeMillis(); - do { - sfs = bundleContext.getServiceReferences(clss, filter); - - if (sfs != null) - waiting = false; - - sleep(100); - if (System.currentTimeMillis() - begin > defaultTimeout) - throw new SlcException("Search of services " + clss - + " with filter " + filter + " timed out."); - } while (waiting); - - return sfs; - } + public void init() throws Exception { + final String module = System.getProperty("slc.launch.module"); + final String executionName = System.getProperty("slc.launch.execution"); + if (module != null) { + new Thread() { + + @Override + public void run() { + try { + launch(SLC_NO_REFRESH, module, executionName); + // in case of failure OSGi runtime stays up and last + // launch can be used to debug by calling 'slc' + } catch (Exception e) { + throw new SlcException("Error when executing " + + executionName + " on " + module, e); + } + try { + EclipseStarter.shutdown(); + } catch (Exception e) { + throw new SlcException("Cannot shutdown equinox.", e); + } + } - protected void sleep(long ms) { - try { - Thread.sleep(ms); - } catch (InterruptedException e) { - // silent + }.start(); } - } - - public void setBundleContext(BundleContext bundleContext) { - this.bundleContext = bundleContext; - } - public void afterPropertiesSet() throws Exception { - bundleContext.addFrameworkListener(this); } - - public void setDefaultTimeout(Long defaultTimeout) { - this.defaultTimeout = defaultTimeout; - } - }