<artifactId>maven-argeo-osgi-plugin</artifactId>
<configuration>
<systemProperties>
- <slc.osgi.bundles>${basedir}/site;in=*;ex=**/.svn/**</slc.osgi.bundles>
+ <slc.osgi.bundles>${basedir}/site;in=*;ex=**/.svn/**,${basedir}/../server/org.argeo.slc.siteserver/bundles;in=*;ex=**/.svn/**</slc.osgi.bundles>
</systemProperties>
</configuration>
</plugin>
<execDir>target/exec/server</execDir>
<jvmArgs>
<jvmArg>-Xmx256m</jvmArg>
- <!-- <jvmArg>-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=8000</jvmArg>-->
+ <!-- <jvmArg>-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=8000</jvmArg> -->
</jvmArgs>
<systemProperties>
<slc.osgi.start>
<execDir>target/exec/agent</execDir>
<jvmArgs>
<jvmArg>-Xmx128m</jvmArg>
- <!-- <jvmArg>-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=8001</jvmArg> -->
+ <!-- <jvmArg>-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=8001</jvmArg> -->
</jvmArgs>
<systemProperties>
<slc.osgi.start>
<import resource="classpath:org/argeo/slc/activemq/spring.xml" />
+ <bean
+ class="org.springframework.jms.listener.DefaultMessageListenerContainer">
+ <property name="connectionFactory" ref="jmsConnectionFactory" />
+ <property name="destination" ref="slcJms.destination.agent.request" />
+ <property name="messageListener" ref="jmsAgent" />
+ <property name="messageSelector">
+ <bean factory-bean="jmsAgent" factory-method="getMessageSelector" />
+ </property>
+ </bean>
+
<bean id="jmsAgent.listener.newExecution"
class="org.springframework.jms.listener.DefaultMessageListenerContainer">
<property name="connectionFactory" ref="jmsConnectionFactory" />
<property name="agentUnregister" ref="slcJms.destination.agent.unregister" />
<property name="messageConverter" ref="slcDefault.jms.castorMessageConverter" />
<property name="modulesManager" ref="modulesManager" />
+ <property name="responseDestination" ref="slcJms.destination.agent.response" />
</bean>
<!-- TreeTestResult Listener -->
<Export-Package>
org.argeo.slc.*,org.argeo.slc.server,org.argeo.slc.server.spring
</Export-Package>
- <Import-Package>org.w3c.dom;version="0.0.0",javax.xml.*;version="0.0.0",org.argeo.slc.activemq,*</Import-Package>
+ <Import-Package>org.w3c.dom;version="0.0.0",javax.xml.*;version="0.0.0",org.argeo.slc.activemq,org.argeo.slc.execution,*</Import-Package>
</instructions>
</configuration>
</plugin>
import javax.servlet.http.HttpServletResponse;\r
\r
import org.argeo.slc.execution.ExecutionModuleDescriptor;\r
-import org.argeo.slc.execution.ExecutionModulesManager;\r
+import org.argeo.slc.runtime.SlcAgent;\r
+import org.argeo.slc.runtime.SlcAgentFactory;\r
import org.argeo.slc.web.mvc.AbstractServiceController;\r
import org.springframework.web.servlet.ModelAndView;\r
\r
/** . */\r
public class GetModuleDescriptor extends AbstractServiceController {\r
- private ExecutionModulesManager modulesManager;\r
+ private SlcAgentFactory agentFactory;\r
\r
@Override\r
protected void handleServiceRequest(HttpServletRequest request,\r
HttpServletResponse response, ModelAndView modelAndView)\r
throws Exception {\r
\r
+ String agentId = request.getParameter("agentId");\r
String moduleName = request.getParameter("moduleName");\r
String version = request.getParameter("version");\r
\r
- ExecutionModuleDescriptor md = modulesManager\r
- .getExecutionModuleDescriptor(moduleName, version);\r
+ SlcAgent slcAgent = agentFactory.getAgent(agentId);\r
+\r
+ ExecutionModuleDescriptor md = slcAgent.getExecutionModuleDescriptor(\r
+ moduleName, version);\r
modelAndView.addObject(md);\r
}\r
\r
- public void setModulesManager(ExecutionModulesManager modulesManager) {\r
- this.modulesManager = modulesManager;\r
+ public void setAgentFactory(SlcAgentFactory agentFactory) {\r
+ this.agentFactory = agentFactory;\r
}\r
\r
}\r
package org.argeo.slc.web.mvc.execution;\r
\r
-import java.util.ArrayList;\r
import java.util.List;\r
\r
import javax.servlet.http.HttpServletRequest;\r
import javax.servlet.http.HttpServletResponse;\r
\r
-import org.argeo.slc.execution.ExecutionModule;\r
import org.argeo.slc.execution.ExecutionModuleDescriptor;\r
-import org.argeo.slc.execution.ExecutionModulesManager;\r
import org.argeo.slc.msg.ObjectList;\r
+import org.argeo.slc.runtime.SlcAgent;\r
+import org.argeo.slc.runtime.SlcAgentFactory;\r
import org.argeo.slc.web.mvc.AbstractServiceController;\r
import org.springframework.web.servlet.ModelAndView;\r
\r
/** . */\r
public class ListModulesDescriptors extends AbstractServiceController {\r
- private ExecutionModulesManager modulesManager;\r
+ private SlcAgentFactory agentFactory;\r
\r
@Override\r
protected void handleServiceRequest(HttpServletRequest request,\r
HttpServletResponse response, ModelAndView modelAndView)\r
throws Exception {\r
\r
- List<ExecutionModule> modules = modulesManager.listExecutionModules();\r
+ String agentId = request.getParameter("agentId");\r
+ SlcAgent slcAgent = agentFactory.getAgent(agentId);\r
\r
- List<ExecutionModuleDescriptor> descriptors = new ArrayList<ExecutionModuleDescriptor>();\r
- for (ExecutionModule module : modules) {\r
- ExecutionModuleDescriptor md = new ExecutionModuleDescriptor();\r
- md.setName(module.getName());\r
- md.setVersion(module.getVersion());\r
- descriptors.add(md);\r
- }\r
+ List<ExecutionModuleDescriptor> descriptors = slcAgent.listExecutionModuleDescriptors();\r
\r
modelAndView.addObject(new ObjectList(descriptors));\r
}\r
\r
- public void setModulesManager(ExecutionModulesManager modulesManager) {\r
- this.modulesManager = modulesManager;\r
+ public void setAgentFactory(SlcAgentFactory agentFactory) {\r
+ this.agentFactory = agentFactory;\r
}\r
\r
}\r
<bean name="/getExecutionDescriptor.service"
class="org.argeo.slc.web.mvc.execution.GetModuleDescriptor">
- <property name="modulesManager" ref="modulesManager" />
+ <property name="agentFactory" ref="agentFactory" />
</bean>
<bean name="/listModulesDescriptors.service"
class="org.argeo.slc.web.mvc.execution.ListModulesDescriptors">
- <property name="modulesManager" ref="modulesManager" />
+ <property name="agentFactory" ref="agentFactory" />
</bean>
<bean id="handlerMapping"
package org.argeo.slc.runtime;
+import java.util.List;
+
+import org.argeo.slc.execution.ExecutionModuleDescriptor;
+
/** A local agent, able to run SLC Execution locally. */
public interface SlcAgent {
+ public ExecutionModuleDescriptor getExecutionModuleDescriptor(
+ String moduleName, String version);
+
+ public List<ExecutionModuleDescriptor> listExecutionModuleDescriptors();
+
}
package org.argeo.slc.runtime;
-public class SlcAgentDescriptor {
+import java.util.ArrayList;
+import java.util.List;
+
+import org.argeo.slc.execution.ExecutionModuleDescriptor;
+
+public class SlcAgentDescriptor implements Cloneable {
private String uuid;
private String host;
+ private List<ExecutionModuleDescriptor> moduleDescriptors = new ArrayList<ExecutionModuleDescriptor>();
+
+ public SlcAgentDescriptor() {
+
+ }
+
+ public SlcAgentDescriptor(SlcAgentDescriptor template) {
+ uuid = template.uuid;
+ host = template.host;
+ moduleDescriptors.addAll(template.moduleDescriptors);
+ }
public String getUuid() {
return uuid;
this.host = host;
}
+ public List<ExecutionModuleDescriptor> getModuleDescriptors() {
+ return moduleDescriptors;
+ }
+
+ public void setModuleDescriptors(
+ List<ExecutionModuleDescriptor> modulesDescriptors) {
+ this.moduleDescriptors = modulesDescriptors;
+ }
}
--- /dev/null
+package org.argeo.slc.runtime;
+
+public interface SlcAgentFactory {
+ public SlcAgent getAgent(String uuid);
+}
import java.net.InetAddress;
import java.net.UnknownHostException;
+import java.util.ArrayList;
+import java.util.List;
import java.util.UUID;
import javax.jms.ConnectionFactory;
import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+import javax.jms.TextMessage;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.argeo.slc.SlcException;
import org.argeo.slc.core.runtime.AbstractAgent;
+import org.argeo.slc.execution.ExecutionModule;
+import org.argeo.slc.execution.ExecutionModuleDescriptor;
+import org.argeo.slc.msg.ObjectList;
import org.argeo.slc.runtime.SlcAgent;
import org.argeo.slc.runtime.SlcAgentDescriptor;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.jms.core.JmsTemplate;
+import org.springframework.jms.listener.SessionAwareMessageListener;
import org.springframework.jms.support.converter.MessageConverter;
/** JMS based implementation of SLC Agent. */
public class JmsAgent extends AbstractAgent implements SlcAgent,
- InitializingBean, DisposableBean {
+ InitializingBean, DisposableBean, SessionAwareMessageListener {
private final static Log log = LogFactory.getLog(JmsAgent.class);
private final SlcAgentDescriptor agentDescriptor;
private Destination agentRegister;
private Destination agentUnregister;
+ // private Destination requestDestination;
+ private Destination responseDestination;
+
private MessageConverter messageConverter;
public JmsAgent() {
public String getMessageSelector() {
String messageSelector = "slc_agentId='" + agentDescriptor.getUuid()
+ "'";
- // String messageSelector = "slc-agentId LIKE '%'";
- if (log.isDebugEnabled())
- log.debug("Message selector: " + messageSelector);
+ // if (log.isDebugEnabled())
+ // log.debug("Message selector: " + messageSelector);
return messageSelector;
}
+ public void onMessage(Message message, Session session) throws JMSException {
+ MessageProducer producer = session.createProducer(responseDestination);
+ String query = message.getStringProperty("query");
+ String correlationId = message.getJMSCorrelationID();
+ if (log.isDebugEnabled())
+ log.debug("Received query " + query + " with correlationId "
+ + correlationId);
+
+ Message responseMsg = null;
+ if ("getExecutionModuleDescriptor".equals(query)) {
+ String moduleName = message.getStringProperty("moduleName");
+ String version = message.getStringProperty("version");
+ ExecutionModuleDescriptor emd = getExecutionModuleDescriptor(
+ moduleName, version);
+ responseMsg = messageConverter.toMessage(emd, session);
+ } else if ("listExecutionModuleDescriptors".equals(query)) {
+
+ List<ExecutionModuleDescriptor> lst = listExecutionModuleDescriptors();
+ SlcAgentDescriptor agentDescriptorToSend = new SlcAgentDescriptor(
+ agentDescriptor);
+ agentDescriptorToSend.setModuleDescriptors(lst);
+ responseMsg = messageConverter.toMessage(agentDescriptorToSend,
+ session);
+ } else {
+ throw new SlcException("Unsupported query " + query);
+ }
+
+ if (responseMsg != null) {
+ responseMsg.setJMSCorrelationID(correlationId);
+ producer.send(responseMsg);
+ if (log.isDebugEnabled())
+ log.debug("Sent response to query " + query
+ + " with correlationId " + correlationId + ": "
+ + responseMsg);
+ }
+
+ }
+
public void setMessageConverter(MessageConverter messageConverter) {
this.messageConverter = messageConverter;
}
this.connectionFactory = connectionFactory;
}
+ public ExecutionModuleDescriptor getExecutionModuleDescriptor(
+ String moduleName, String version) {
+ return getModulesManager().getExecutionModuleDescriptor(moduleName,
+ version);
+ }
+
+ public List<ExecutionModuleDescriptor> listExecutionModuleDescriptors() {
+ List<ExecutionModule> modules = getModulesManager()
+ .listExecutionModules();
+
+ List<ExecutionModuleDescriptor> descriptors = new ArrayList<ExecutionModuleDescriptor>();
+ for (ExecutionModule module : modules) {
+ ExecutionModuleDescriptor md = new ExecutionModuleDescriptor();
+ md.setName(module.getName());
+ md.setVersion(module.getVersion());
+ descriptors.add(md);
+ }
+ return descriptors;
+ }
+
+ public void setResponseDestination(Destination responseDestination) {
+ this.responseDestination = responseDestination;
+ }
+
}
--- /dev/null
+package org.argeo.slc.jms;
+
+import java.util.List;
+import java.util.UUID;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.Session;
+import javax.jms.TextMessage;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.execution.ExecutionModule;
+import org.argeo.slc.execution.ExecutionModuleDescriptor;
+import org.argeo.slc.msg.ObjectList;
+import org.argeo.slc.runtime.SlcAgent;
+import org.argeo.slc.runtime.SlcAgentDescriptor;
+import org.springframework.jms.JmsException;
+import org.springframework.jms.core.JmsTemplate;
+import org.springframework.jms.core.MessageCreator;
+import org.springframework.jms.support.converter.MessageConversionException;
+import org.springframework.jms.support.converter.MessageConverter;
+
+public class JmsAgentProxy implements SlcAgent {
+ private final static Log log = LogFactory.getLog(JmsAgentProxy.class);
+
+ private final String agentUuid;
+ private final Destination requestDestination;
+ private final Destination responseDestination;
+ private final JmsTemplate jmsTemplate;
+ private final MessageConverter messageConverter;
+
+ public JmsAgentProxy(String agentUuid, Destination requestDestination,
+ Destination responseDestination, JmsTemplate jmsTemplate,
+ MessageConverter messageConverter) {
+ this.agentUuid = agentUuid;
+ this.requestDestination = requestDestination;
+ this.responseDestination = responseDestination;
+ this.jmsTemplate = jmsTemplate;
+ this.messageConverter = messageConverter;
+ }
+
+ public ExecutionModuleDescriptor getExecutionModuleDescriptor(
+ final String moduleName, final String version) {
+ return (ExecutionModuleDescriptor) sendReceive(new AgentProxyMessageCreator(
+ "getExecutionModuleDescriptor") {
+ public void setArguments(Message message) throws JMSException {
+ message.setStringProperty("moduleName", moduleName);
+ message.setStringProperty("version", version);
+ }
+ });
+ }
+
+ public List<ExecutionModuleDescriptor> listExecutionModuleDescriptors() {
+ return ((SlcAgentDescriptor) sendReceive(new AgentProxyMessageCreator(
+ "listExecutionModuleDescriptors"))).getModuleDescriptors();
+ }
+
+ protected Object sendReceive(AgentProxyMessageCreator messageCreator) {
+ String correlationId = UUID.randomUUID().toString();
+ messageCreator.setCorrelationId(correlationId);
+ send(messageCreator);
+ return processResponse(correlationId);
+ }
+
+ protected void send(AgentProxyMessageCreator messageCreator) {
+ jmsTemplate.send(requestDestination, messageCreator);
+ if (log.isDebugEnabled())
+ log.debug("Sent request" + messageCreator.getQuery() + " to agent "
+ + agentUuid + " with correlationId "
+ + messageCreator.getCorrelationId());
+ }
+
+ protected Object processResponse(String correlationId) {
+ try {
+ Message responseMsg = jmsTemplate.receiveSelected(
+ responseDestination, "JMSCorrelationID='" + correlationId
+ + "'");
+ if (log.isDebugEnabled())
+ log.debug("Received response with correlationId "
+ + correlationId);
+ return messageConverter.fromMessage(responseMsg);
+ } catch (Exception e) {
+ throw new SlcException("Could not process response from agent "
+ + agentUuid + " with correlationId " + correlationId, e);
+ }
+ }
+
+ protected class AgentProxyMessageCreator implements MessageCreator {
+ private final String query;
+ private String correlationId;
+
+ public AgentProxyMessageCreator(String query) {
+ this.query = query;
+ }
+
+ public final Message createMessage(Session session) throws JMSException {
+ if (agentUuid == null)
+ throw new SlcException("Agent UUID not set");
+ if (correlationId == null)
+ throw new SlcException("JMSCorrelationID not set");
+ TextMessage msg = session.createTextMessage();
+ msg.setStringProperty("slc_agentId", agentUuid);
+ msg.setStringProperty("query", query);
+ msg.setJMSCorrelationID(correlationId);
+ setArguments(msg);
+ return msg;
+ }
+
+ protected void setArguments(Message message) throws JMSException {
+ }
+
+ public String getQuery() {
+ return query;
+ }
+
+ public String getCorrelationId() {
+ return correlationId;
+ }
+
+ public void setCorrelationId(String correlationId) {
+ this.correlationId = correlationId;
+ }
+
+ }
+}
--- /dev/null
+package org.argeo.slc.jms;
+
+import javax.jms.Destination;
+
+import org.argeo.slc.runtime.SlcAgent;
+import org.argeo.slc.runtime.SlcAgentFactory;
+import org.springframework.jms.core.JmsTemplate;
+import org.springframework.jms.support.converter.MessageConverter;
+
+public class JmsAgentProxyFactory implements SlcAgentFactory {
+ private Destination requestDestination;
+ private Destination responseDestination;
+ private JmsTemplate jmsTemplate;
+ private MessageConverter messageConverter;
+
+ public SlcAgent getAgent(String uuid) {
+ return new JmsAgentProxy(uuid, requestDestination, responseDestination,
+ jmsTemplate, messageConverter);
+ }
+
+ public void setRequestDestination(Destination requestDestination) {
+ this.requestDestination = requestDestination;
+ }
+
+ public void setResponseDestination(Destination responseDestination) {
+ this.responseDestination = responseDestination;
+ }
+
+ public void setJmsTemplate(JmsTemplate jmsTemplate) {
+ this.jmsTemplate = jmsTemplate;
+ }
+
+ public void setMessageConverter(MessageConverter messageConverter) {
+ this.messageConverter = messageConverter;
+ }
+
+}
throw new SlcException("Could not unmarshall " + text, e);
}
} else {
- throw new SlcException("Only JMS TextMessage are supported.");
+ throw new SlcException("This type of messages is not supported: "
+ + message);
}
}
parent="slcJms.amTopic" />
<bean id="slcJms.destination.agent.newExecution" p:physicalName="agent.newExecution"
parent="slcJms.amTopic" />
+ <bean id="slcJms.destination.agent.request" p:physicalName="agent.request"
+ parent="slcJms.amTopic" />
+ <bean id="slcJms.destination.agent.response" p:physicalName="agent.response"
+ parent="slcJms.amTopic" />
<!-- Test result service -->
<bean id="slcJms.destination.test.create" p:physicalName="test.create"
<class name="org.argeo.slc.msg.ObjectList">
<map-to ns-uri="http://argeo.org/projects/slc/schemas"
ns-prefix="slc" />
- <field name="objects" collection="arraylist">
+ <field name="objects" collection="arraylist" type="java.lang.Object">
<bind-xml auto-naming="deriveByClass" />
</field>
</class>
<bind-xml node="attribute" />\r
</field>\r
<field name="host" />\r
+ <field name="moduleDescriptors" collection="arraylist"\r
+ type="org.argeo.slc.execution.ExecutionModuleDescriptor">\r
+ <bind-xml auto-naming="deriveByClass" />\r
+ </field>\r
</class>\r
</mapping>
\ No newline at end of file
import org.argeo.slc.execution.ExecutionFlowDescriptor;\r
import org.argeo.slc.execution.ExecutionModuleDescriptor;\r
import org.argeo.slc.execution.ExecutionSpec;\r
+import org.argeo.slc.msg.ObjectList;\r
import org.argeo.slc.unit.execution.ExecutionFlowDescriptorTestUtils;\r
\r
public class ExecutionModuleDescriptorCastorTest extends AbstractCastorTestCase {\r
\r
marshUnmarsh(moduleDescriptor, false);\r
}\r
+\r
+ public void testMarshUnmarshMini() throws Exception {\r
+ ExecutionModuleDescriptor moduleDescriptor = new ExecutionModuleDescriptor();\r
+ moduleDescriptor.setName("test.moodule");\r
+ moduleDescriptor.setVersion("1.0.0");\r
+ marshUnmarsh(moduleDescriptor, false);\r
+ }\r
+\r
}\r
--- /dev/null
+package org.argeo.slc.castor;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+\r
+import org.argeo.slc.execution.ExecutionFlowDescriptor;\r
+import org.argeo.slc.execution.ExecutionModuleDescriptor;\r
+import org.argeo.slc.execution.ExecutionSpec;\r
+import org.argeo.slc.msg.ObjectList;\r
+import org.argeo.slc.runtime.SlcAgentDescriptor;\r
+import org.argeo.slc.unit.execution.ExecutionFlowDescriptorTestUtils;\r
+\r
+public class SlcAgentDescriptorCastorTest extends AbstractCastorTestCase {\r
+ public void testMarshUnmarshMini() throws Exception {\r
+ SlcAgentDescriptor agentDescriptor = createMiniAgentDescriptor();\r
+ marshUnmarsh(agentDescriptor, false);\r
+ }\r
+\r
+ public void testMarshUnmarshWithModuleDescriptor() throws Exception {\r
+ SlcAgentDescriptor agentDescriptor = createMiniAgentDescriptor();\r
+\r
+ List<ExecutionModuleDescriptor> lst = new ArrayList<ExecutionModuleDescriptor>();\r
+ ExecutionModuleDescriptor moduleDescriptor = new ExecutionModuleDescriptor();\r
+ moduleDescriptor.setName("test.moodule");\r
+ moduleDescriptor.setVersion("1.0.0");\r
+ lst.add(moduleDescriptor);\r
+ agentDescriptor.setModuleDescriptors(lst);\r
+\r
+ marshUnmarsh(agentDescriptor, false);\r
+ }\r
+ \r
+ protected static SlcAgentDescriptor createMiniAgentDescriptor(){\r
+ SlcAgentDescriptor agentDescriptor = new SlcAgentDescriptor();\r
+ agentDescriptor.setHost("localhost");\r
+ agentDescriptor.setUuid("555");\r
+ return agentDescriptor;\r
+ }\r
+}\r
package org.argeo.slc.core.runtime;
-import java.util.Map;
-import java.util.Properties;
-
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
import org.argeo.slc.execution.ExecutionModulesManager;
import org.argeo.slc.process.SlcExecution;
-import org.argeo.slc.runtime.SlcApplication;
-import org.argeo.slc.runtime.SlcExecutionContext;
public abstract class AbstractAgent {
- private final static Log log = LogFactory.getLog(AbstractAgent.class);
+// private final static Log log = LogFactory.getLog(AbstractAgent.class);
-// private SlcApplication<SlcExecutionContext> slcApplication;
-
private ExecutionModulesManager modulesManager;
protected void runSlcExecution(final SlcExecution slcExecution) {
modulesManager.process(slcExecution);
-// Thread thread = new Thread("SlcExecution " + slcExecution.getUuid()) {
-// public void run() {
-// Properties props = new Properties();
-// Map<String, String> attributes = slcExecution.getAttributes();
-// for (String key : attributes.keySet()) {
-// props.setProperty(key, attributes.get(key));
-// if (log.isTraceEnabled())
-// log.trace(key + "=" + props.getProperty(key));
-// }
-// slcApplication.execute(slcExecution, props, null, null);
-// log.debug("Thread for SLC execution #" + slcExecution.getUuid()
-// + " finished.");
-// }
-// };
-// thread.start();
}
public void setModulesManager(ExecutionModulesManager modulesManager) {
this.modulesManager = modulesManager;
}
-
-// public void setSlcApplication(
-// SlcApplication<SlcExecutionContext> application) {
-// this.slcApplication = application;
-// }
+ public ExecutionModulesManager getModulesManager() {
+ return modulesManager;
+ }
+
}
* @param folder {qx.ui.tree.TreeFolder} A Tree folder containing in the key "moduleData" of its user data a map containing the keys {name,version}
*/
flowLoader : function(folder){
- var moduleData = folder.getUserData("moduleData");
+ var moduleData = folder.getUserData("moduleData");
+ var agentUuid = folder.getUserData("agentUuid");
//var pathStub = ["", "/test/toto/zobi", "loop"];
//var indexStub = 0;
- var req = org.argeo.slc.ria.SlcApi.getLoadExecutionDescriptorService(moduleData.name, moduleData.version);
+ var req = org.argeo.slc.ria.SlcApi.getLoadExecutionDescriptorService(agentUuid,moduleData.name, moduleData.version);
req.addListener("completed", function(response){
var executionModule = new org.argeo.slc.ria.execution.Module();
executionModule.setXmlNode(response.getContent());
//indexStub ++;
file.setUserData("executionModule", executionModule);
file.setUserData("executionFlow", execFlows[key]);
- file.setUserData("agentUuid", folder.getUserData("agentUuid"));
+ file.setUserData("agentUuid", agentUuid);
org.argeo.slc.ria.NewLauncherApplet.attachNodeByPath(
folder,
path,
* @param iLoadStatusables {org.argeo.ria.components.ILoadStatusables[]} Gui parts to update \r
* @return {qx.io.remote.Request}\r
*/\r
- getLoadExecutionDescriptorService : function(moduleName, moduleVersion, fireReloadEventType, iLoadStatusables){\r
+ getLoadExecutionDescriptorService : function(agentId,moduleName, moduleVersion, fireReloadEventType, iLoadStatusables){\r
var req = org.argeo.slc.ria.SlcApi.getServiceRequest(\r
org.argeo.slc.ria.SlcApi.GET_EXECUTION_DESC_SERVICE,\r
fireReloadEventType,\r
iLoadStatusables\r
); \r
+ req.setParameter("agentId", agentId);\r
req.setParameter("moduleName", moduleName);\r
req.setParameter("version", moduleVersion);\r
return req;\r
javax.management.j2ee.statistics,
org.apache.commons.logging
Require-Bundle:
+ org.argeo.slc.specs,
org.argeo.slc.server,
org.argeo.slc.support.activemq,
org.springframework.core,
<reference id="jmsConnectionFactory" interface="javax.jms.ConnectionFactory" />
+ <service ref="agentFactory" interface="org.argeo.slc.runtime.SlcAgentFactory" />
</beans:beans>
\ No newline at end of file
<import resource="classpath:org/argeo/slc/activemq/spring.xml" />
+ <bean id="agentFactory" class="org.argeo.slc.jms.JmsAgentProxyFactory">
+ <property name="jmsTemplate">
+ <bean class="org.springframework.jms.core.JmsTemplate">
+ <property name="connectionFactory" ref="jmsConnectionFactory" />
+ <property name="receiveTimeout" value="10000" />
+ </bean>
+ </property>
+ <property name="messageConverter" ref="slcDefault.jms.castorMessageConverter" />
+ <property name="requestDestination" ref="slcJms.destination.agent.request" />
+ <property name="responseDestination" ref="slcJms.destination.agent.response" />
+ </bean>
+
<!-- Agent Service -->
<bean id="agentService.jmsContainer.register" parent="listenerContainer">
<property name="destination" ref="slcJms.destination.agent.register" />
<reference id="transactionManager"\r
interface="org.springframework.transaction.PlatformTransactionManager" />\r
\r
+ <reference id="agentFactory" interface="org.argeo.slc.runtime.SlcAgentFactory" />\r
+\r
</beans:beans>
\ No newline at end of file
projects / gpl / argeo-slc.git / commitdiff