public DefaultNameVersion() {
}
+ /** Interprets string in OSGi-like format my.module.name;version=0.0.0 */
+ public DefaultNameVersion(String nameVersion) {
+ int index = nameVersion.indexOf(";version=");
+ if (index < 0) {
+ setName(nameVersion);
+ setVersion(null);
+ } else {
+ setName(nameVersion.substring(0, index));
+ setVersion(nameVersion.substring(index + ";version=".length()));
+ }
+ }
+
public DefaultNameVersion(String name, String version) {
this.name = name;
this.version = version;
import java.util.HashMap;
import java.util.Map;
-import org.argeo.slc.BasicNameVersion;
+import org.argeo.slc.DefaultNameVersion;
/** The description of a versioned module. */
-public class ModuleDescriptor extends BasicNameVersion implements Serializable {
+public class ModuleDescriptor extends DefaultNameVersion implements Serializable {
private static final long serialVersionUID = 4310820315478645419L;
private String title;
private String description;
import java.util.HashMap;
import java.util.Map;
-import org.argeo.slc.BasicNameVersion;
+import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
/** A fully configured execution flow, ready to be executed. */
}
public NameVersion getModuleNameVersion() {
- return new BasicNameVersion(getModuleName(), getModuleVersion());
+ return new DefaultNameVersion(getModuleName(), getModuleVersion());
}
public String getModuleVersion() {
import java.util.Map;
import java.util.UUID;
-import org.argeo.slc.BasicNameVersion;
+import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionModuleDescriptor;
String[] path = uri.getPath().split("/");
if (path.length < 3)
throw new SlcException("Badly formatted URI: " + uri);
- NameVersion nameVersion = new BasicNameVersion(path[1]);
+ NameVersion nameVersion = new DefaultNameVersion(path[1]);
StringBuilder flow = new StringBuilder();
for (int i = 2; i < path.length; i++)
flow.append('/').append(path[i]);
ExecutionModuleDescriptor emd;
try {
modulesManager
- .start(new BasicNameVersion(moduleName, moduleVersion));
+ .start(new DefaultNameVersion(moduleName, moduleVersion));
emd = modulesManager.getExecutionModuleDescriptor(moduleName,
moduleVersion);
} catch (SlcException e) {
if (defaultModulePrefix != null) {
moduleName = defaultModulePrefix + "." + moduleName;
- modulesManager.start(new BasicNameVersion(moduleName,
+ modulesManager.start(new DefaultNameVersion(moduleName,
moduleVersion));
emd = modulesManager.getExecutionModuleDescriptor(moduleName,
moduleVersion);
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.security.OsAuthenticationToken;
-import org.argeo.slc.BasicNameVersion;
+import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
import org.argeo.slc.execution.ExecutionFlowDescriptor;
appendModule(emd, buf);
}
} else if (args.length == 1 && !args[0].contains("/")) {// single module
- NameVersion nameVersion = new BasicNameVersion(args[0]);
+ NameVersion nameVersion = new DefaultNameVersion(args[0]);
ExecutionModuleDescriptor emd = agent.getExecutionModuleDescriptor(
nameVersion.getName(), nameVersion.getVersion());
appendModule(emd, buf);
protected void appendUriHelp(URI uri, StringBuilder buf) {
String[] path = uri.getPath().split("/");
- NameVersion nameVersion = new BasicNameVersion(path[1]);
+ NameVersion nameVersion = new DefaultNameVersion(path[1]);
ExecutionModuleDescriptor emd = agent.getExecutionModuleDescriptor(
nameVersion.getName(), nameVersion.getVersion());
return efd;
}
- @SuppressWarnings(value = { "unchecked" })
protected RefValue buildRefValue(RefSpecAttribute rsa,
ExecutionFlow executionFlow, String key) {
RefValue refValue = new RefValue();
return null;\r
}\r
\r
- @SuppressWarnings(value = { "unchecked" })\r
public Object resolveValue(String beanName, Object bean, Object value) {\r
if (value instanceof TypedStringValue) {\r
TypedStringValue tsv = (TypedStringValue) value;\r
} else if (value instanceof ManagedMap) {\r
Map<?, ?> mapVal = (Map<?, ?>) value;\r
\r
- Map<Object, Object> newContent = new ManagedMap();\r
+ Map<Object, Object> newContent = new ManagedMap<Object, Object>();\r
boolean entriesModified = false;\r
for (Iterator<?> it = mapVal.entrySet().iterator(); it.hasNext();) {\r
Map.Entry<?, ?> entry = (Map.Entry<?, ?>) it.next();\r
return entriesModified ? newContent : value;\r
} else if (value instanceof ManagedList) {\r
List<?> listVal = (List<?>) value;\r
- List<Object> newContent = new ManagedList();\r
+ List<Object> newContent = new ManagedList<Object>();\r
boolean valueModified = false;\r
\r
for (int i = 0; i < listVal.size(); i++) {\r
return valueModified ? newContent : value;\r
} else if (value instanceof ManagedSet) {\r
Set<?> setVal = (Set<?>) value;\r
- Set<Object> newContent = new ManagedSet();\r
+ Set<Object> newContent = new ManagedSet<Object>();\r
boolean entriesModified = false;\r
for (Iterator<?> it = setVal.iterator(); it.hasNext();) {\r
Object elem = it.next();\r
import org.springframework.core.io.Resource;
import org.springframework.util.Assert;
-/** Workaround when execution placedholders needs to be passed.*/
-public class ExecutionResourcesFactoryBean implements FactoryBean {
+/** Workaround when execution placedholders needs to be passed. */
+public class ExecutionResourcesFactoryBean implements FactoryBean<Resource> {
private ExecutionResources executionResources;
private String relativePath;
- public Object getObject() throws Exception {
+ public Resource getObject() throws Exception {
Assert.notNull(executionResources, "executionResources is null");
Assert.notNull(relativePath, "relativePath is null");
return executionResources.getWritableResource(relativePath);
private final ThreadLocal<ExecutionContext> executionContext = new ThreadLocal<ExecutionContext>();
private final ThreadLocal<String> executionContextBeanName = new ThreadLocal<String>();
- public Object get(String name, ObjectFactory objectFactory) {
+ public Object get(String name, ObjectFactory<?> objectFactory) {
if (log.isTraceEnabled())
log.debug("Get execution scoped bean " + name);
import org.springframework.util.Assert;
/** Retrieve an OS File from the given resource. */
-public class OsFileFactoryBean implements FactoryBean {
+public class OsFileFactoryBean implements FactoryBean<String> {
private ExecutionResources executionResources;
private Resource resource;
private Boolean overwrite = false;
/** Return an existing file on the file system. */
- public Object getObject() throws Exception {
+ public String getObject() throws Exception {
Assert.notNull(executionResources, "executionResources is null");
Assert.notNull(resource, "resource is null");
return executionResources.getAsOsPath(resource, overwrite);
}
- /** Return {@link Object} because CGLIB is unable to proxy {@link File}.*/
+ /** Return {@link Object} because CGLIB is unable to proxy {@link File}. */
public Class<? extends Object> getObjectType() {
return CharSequence.class;
}
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.FactoryBean;
-public class ParameterRef implements FactoryBean {
+public class ParameterRef implements FactoryBean<Object> {
private final static Log log = LogFactory.getLog(ParameterRef.class);
private InstantiationManager instantiationManager;
import org.springframework.core.io.Resource;
/** Experimental and suboptimal */
-public class SedFilteredResource implements FactoryBean, InitializingBean {
+public class SedFilteredResource implements FactoryBean<Resource>,
+ InitializingBean {
private Resource source;
private List<String> filters = new ArrayList<String>();
// private CharsetEncoder encoder;
- public Object getObject() throws Exception {
+ public Resource getObject() throws Exception {
if (filters.size() == 0)
return source;
import org.springframework.beans.factory.FactoryBean;
/** Merge the provided lists in one single list, in the order provided. */
-public class MergedLists implements FactoryBean {
+public class MergedLists implements FactoryBean<List<Object>> {
private List<List<Object>> lists = new ArrayList<List<Object>>();
public void setLists(List<List<Object>> lists) {
this.lists = lists;
}
- public Object getObject() throws Exception {
+ public List<Object> getObject() throws Exception {
List<Object> merged = new ArrayList<Object>();
for (List<Object> lst : lists) {
merged.addAll(lst);
// TODO make it more secure and robust, test only once
private final String sudoPrompt = UUID.randomUUID().toString();
private String askPassProgram = "/usr/libexec/openssh/ssh-askpass";
+ @SuppressWarnings("unused")
private boolean firstLine = true;
+ @SuppressWarnings("unused")
private CallbackHandler callbackHandler;
/** Chroot to the this path (must not be empty) */
private String chroot = null;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.DefaultExecutionFlow;
import org.argeo.slc.execution.ExecutionFlow;
+import org.springframework.beans.BeanMetadataElement;
import org.springframework.beans.factory.config.BeanDefinitionHolder;
import org.springframework.beans.factory.config.RuntimeBeanReference;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
public class AsFlowDecorator implements BeanDefinitionDecorator {
private Log log = LogFactory.getLog(AsFlowDecorator.class);
- @SuppressWarnings("unchecked")
public BeanDefinitionHolder decorate(Node node, BeanDefinitionHolder bean,
ParserContext ctx) {
String attrValue = ((Attr) node).getValue();
+ " is already defined.");
BeanDefinitionBuilder flow = BeanDefinitionBuilder
.rootBeanDefinition(DefaultExecutionFlow.class);
- ManagedList executables = new ManagedList(1);
+ ManagedList<BeanMetadataElement> executables = new ManagedList<BeanMetadataElement>(
+ 1);
String beanName = bean.getBeanName();
if (beanName == null)
/** Whether the user has already be warned on path attribute usage. */
private Boolean warnedAboutPathAttribute = false;
- @SuppressWarnings("unchecked")
@Override
protected void doParse(Element element, ParserContext parserContext,
BeanDefinitionBuilder builder) {
// Arguments
if (argsElems.size() != 0) {
- ManagedMap args = new ManagedMap(argsElems.size());
+ ManagedMap<String, Object> args = new ManagedMap<String, Object>(
+ argsElems.size());
for (Element argElem : argsElems) {
Object value = NamespaceUtils.parseValue(argElem,
parserContext, builder.getBeanDefinition(), null);
// Executables
if (execElems.size() != 0) {
- ManagedList executables = new ManagedList(execElems.size());
+ ManagedList<Object> executables = new ManagedList<Object>(
+ execElems.size());
for (Element child : execElems) {
// child validity check is performed in xsd
executables.add(NamespaceUtils.parseBeanOrReference(child,
AbstractSingleBeanDefinitionParser {
private Log log = LogFactory.getLog(SpecBeanDefinitionParser.class);
- @SuppressWarnings("unchecked")
@Override
protected void doParse(Element element, ParserContext parserContext,
BeanDefinitionBuilder builder) {
builder.getBeanDefinition().setDescription(
DomUtils.getChildElementValueByTagName(element, "description"));
- ManagedMap attributes = new ManagedMap();
+ ManagedMap<String, BeanDefinition> attributes = new ManagedMap<String, BeanDefinition>();
// Primitives
for (Element child : (List<Element>) DomUtils
if (choicesElem != null) {
List<Element> choices = DomUtils.getChildElementsByTagName(
choicesElem, "choice");
- ManagedList choiceBeans = new ManagedList(choices.size());
+ ManagedList<BeanDefinition> choiceBeans = new ManagedList<BeanDefinition>(
+ choices.size());
for (Element choiceElem : choices) {
BeanDefinitionBuilder choiceBuilder = BeanDefinitionBuilder
.genericBeanDefinition(RefValueChoice.class);
}
- @SuppressWarnings("unchecked")
- protected void putInAttributes(ManagedMap attributes, Element child,
+ protected void putInAttributes(
+ ManagedMap<String, BeanDefinition> attributes, Element child,
BeanDefinition beanDefinition, String nature) {
String name = child.getAttribute("name");
attributes.put(name, beanDefinition);
import org.argeo.jcr.JcrUtils;
import org.argeo.jcr.UserJcrUtils;
-import org.argeo.slc.BasicNameVersion;
+import org.argeo.slc.DefaultNameVersion;
import org.argeo.slc.NameVersion;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.execution.PrimitiveAccessor;
String module = tokens[AGENT_FACTORY_DEPTH + 2];
String moduleName = module.substring(0, module.indexOf('_'));
String moduleVersion = module.substring(module.indexOf('_') + 1);
- return new BasicNameVersion(moduleName, moduleVersion);
+ return new DefaultNameVersion(moduleName, moduleVersion);
}
/** Module node name based on module name and version */
*/
package org.argeo.slc.osgi;
+import java.util.Collection;
+
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.slc.SlcException;
+import org.eclipse.gemini.blueprint.context.BundleContextAware;
+import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEvent;
+import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextListener;
+import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextClosedEvent;
+import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextFailedEvent;
+import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextRefreshedEvent;
+import org.eclipse.gemini.blueprint.util.OsgiBundleUtils;
+import org.eclipse.gemini.blueprint.util.OsgiFilterUtils;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContext;
-import org.eclipse.gemini.blueprint.context.BundleContextAware;
-import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextEvent;
-import org.eclipse.gemini.blueprint.context.event.OsgiBundleApplicationContextListener;
-import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextClosedEvent;
-import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextFailedEvent;
-import org.eclipse.gemini.blueprint.context.event.OsgiBundleContextRefreshedEvent;
-import org.eclipse.gemini.blueprint.util.OsgiBundleUtils;
-import org.eclipse.gemini.blueprint.util.OsgiFilterUtils;
import org.springframework.util.Assert;
/** Wraps low-level access to a {@link BundleContext} */
+@SuppressWarnings("deprecation")
public class BundlesManager implements BundleContextAware, FrameworkListener,
- InitializingBean, DisposableBean, OsgiBundleApplicationContextListener {
+ InitializingBean, DisposableBean,
+ OsgiBundleApplicationContextListener<OsgiBundleApplicationContextEvent> {
private final static Log log = LogFactory.getLog(BundlesManager.class);
private BundleContext bundleContext;
+ ")";
// Wait for application context to be ready
// TODO: use service tracker
- ServiceReference[] srs = getServiceRefSynchronous(
- ApplicationContext.class.getName(), filter);
- ServiceReference sr = srs[0];
+ Collection<ServiceReference<ApplicationContext>> srs = getServiceRefSynchronous(
+ ApplicationContext.class, filter);
+ ServiceReference<ApplicationContext> sr = srs.iterator().next();
long aAppContext = System.currentTimeMillis();
long end = aAppContext;
/** Refresh bundle synchronously. Does nothing if already started. */
protected void refreshSynchronous(Bundle bundle) throws BundleException {
- ServiceReference packageAdminRef = bundleContext
- .getServiceReference(PackageAdmin.class.getName());
+ ServiceReference<PackageAdmin> packageAdminRef = bundleContext
+ .getServiceReference(PackageAdmin.class);
PackageAdmin packageAdmin = (PackageAdmin) bundleContext
.getService(packageAdminRef);
Bundle[] bundles = { bundle };
}
}
- public ServiceReference[] getServiceRefSynchronous(String clss,
- String filter) throws InvalidSyntaxException {
+ public <S> Collection<ServiceReference<S>> getServiceRefSynchronous(
+ Class<S> clss, String filter) throws InvalidSyntaxException {
if (log.isTraceEnabled())
log.debug("Filter: '" + filter + "'");
- ServiceReference[] sfs = null;
+ Collection<ServiceReference<S>> sfs = null;
boolean waiting = true;
long begin = System.currentTimeMillis();
do {
}
/** Creates and open a new service tracker. */
- public ServiceTracker newTracker(Class<?> clss) {
- ServiceTracker st = new ServiceTracker(bundleContext, clss.getName(),
+ public <S> ServiceTracker<S, S> newTracker(Class<S> clss) {
+ ServiceTracker<S, S> st = new ServiceTracker<S, S>(bundleContext, clss,
null);
st.open();
return st;
}
- @SuppressWarnings(value = { "unchecked" })
public <T> T getSingleService(Class<T> clss, String filter,
Boolean synchronous) {
if (filter != null)
Assert.isTrue(OsgiFilterUtils.isValidFilter(filter), "valid filter");
- ServiceReference[] sfs;
+ Collection<ServiceReference<T>> sfs;
try {
if (synchronous)
- sfs = getServiceRefSynchronous(clss.getName(), filter);
+ sfs = getServiceRefSynchronous(clss, filter);
else
- sfs = bundleContext
- .getServiceReferences(clss.getName(), filter);
+ sfs = bundleContext.getServiceReferences(clss, filter);
} catch (InvalidSyntaxException e) {
throw new SlcException("Cannot retrieve service reference for "
+ filter, e);
}
- if (sfs == null || sfs.length == 0)
+ if (sfs == null || sfs.size() == 0)
return null;
- else if (sfs.length > 1)
+ else if (sfs.size() > 1)
throw new SlcException("More than one execution flow found for "
+ filter);
- return (T) bundleContext.getService(sfs[0]);
+ return (T) bundleContext.getService(sfs.iterator().next());
}
public <T> T getSingleServiceStrict(Class<T> clss, String filter,
import java.util.jar.JarFile;
import java.util.jar.Manifest;
+import org.apache.commons.io.IOUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.framework.Constants;
if (file.isDirectory()) {
} else {
+ JarFile jarFile = null;
try {
- JarFile jarFile = new JarFile(file);
+ jarFile = new JarFile(file);
Manifest manifest = jarFile.getManifest();
String symbolicName = manifest.getMainAttributes()
.getValue(Constants.BUNDLE_SYMBOLICNAME);
log.warn("Cannot scan " + file, e);
if (log.isTraceEnabled())
e.printStackTrace();
+ } finally {
+ IOUtils.closeQuietly(jarFile);
}
}
}
import org.argeo.slc.execution.ExecutionModuleDescriptor;
import org.argeo.slc.execution.ExecutionModulesListener;
import org.argeo.slc.execution.RealizedFlow;
+import org.eclipse.gemini.blueprint.service.importer.OsgiServiceLifecycleListener;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleEvent;
import org.osgi.framework.BundleException;
import org.osgi.framework.Constants;
import org.osgi.framework.launch.Framework;
import org.springframework.context.ApplicationContext;
-import org.eclipse.gemini.blueprint.service.importer.OsgiServiceLifecycleListener;
/** Execution modules manager implementation based on an OSGi runtime. */
public class OsgiExecutionModulesManager extends
+ bundle.getSymbolicName() + ")";
try {
bundlesManager.getServiceRefSynchronous(
- ApplicationContext.class.getName(), filter);
+ ApplicationContext.class, filter);
} catch (Exception e) {
// stop if application context not found
bundle.stop();
public synchronized void unregister(ExecutionFlow executionFlow,
Map<String, String> properties) {
// FIXME why are properties null?
- if(properties==null)
+ if (properties == null)
return;
OsgiBundle osgiBundle = asOsgiBundle(properties);
if (executionFlows.containsKey(osgiBundle)) {
private String libDirectory = "/lib";
- @SuppressWarnings(value = { "unchecked" })
protected void fillDistributions(
SortedMap<NameVersion, Distribution> distributions)
throws Exception {
projects / gpl / argeo-slc.git / commitdiff