<groupId>org.argeo.slc.maven</groupId>
<artifactId>maven-argeo-osgi-plugin</artifactId>
<configuration>
+ <argsToAppend>
+ <arg>-clean</arg>
+ </argsToAppend>
<systemProperties>
<slc.osgi.bundles>${basedir}/site;in=*;ex=**/.svn/**,${basedir}/../server/org.argeo.slc.siteserver/bundles;in=*;ex=**/.svn/**</slc.osgi.bundles>
</systemProperties>
--- /dev/null
+package org.argeo.slc.services;
+
+import java.util.Iterator;
+import java.util.List;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.core.runtime.AbstractAgent;
+import org.argeo.slc.msg.event.SlcEvent;
+import org.argeo.slc.msg.event.SlcEventPublisher;
+import org.argeo.slc.runtime.SlcAgentDescriptor;
+import org.aspectj.lang.JoinPoint;
+import org.aspectj.lang.annotation.After;
+import org.aspectj.lang.annotation.Aspect;
+
+@Aspect
+public class EventPublisherAspect {
+ private final static Log log = LogFactory
+ .getLog(EventPublisherAspect.class);
+
+ private List<SlcEventPublisher> eventPublishers;
+
+ @After("execution(void org.argeo.slc.services.runtime.AgentService.register(..))")
+ public void registerAgent(JoinPoint jp) throws Throwable {
+ SlcAgentDescriptor agentDescriptor = (SlcAgentDescriptor) jp.getArgs()[0];
+ SlcEvent event = new SlcEvent("agentRegistered");
+ event.getHeaders().put(AbstractAgent.PROPERTY_SLC_AGENT_ID,
+ agentDescriptor.getUuid());
+ publishEvent(event);
+ }
+
+ @After("execution(void org.argeo.slc.services.runtime.AgentService.unregister(..))")
+ public void unregisterAgent(JoinPoint jp) throws Throwable {
+ SlcAgentDescriptor agentDescriptor = (SlcAgentDescriptor) jp.getArgs()[0];
+ SlcEvent event = new SlcEvent("agentUnregistered");
+ event.getHeaders().put(AbstractAgent.PROPERTY_SLC_AGENT_ID,
+ agentDescriptor.getUuid());
+ publishEvent(event);
+ }
+
+ public void setEventPublishers(List<SlcEventPublisher> eventPublishers) {
+ this.eventPublishers = eventPublishers;
+ }
+
+ protected void publishEvent(SlcEvent event) {
+
+ for (Iterator<SlcEventPublisher> it = eventPublishers.iterator(); it
+ .hasNext();) {
+ SlcEventPublisher eventPublisher = it.next();
+ if (log.isTraceEnabled())
+ log.debug("Publish event: "
+ + event.getHeaders().get(SlcEvent.EVENT_TYPE) + " to "
+ + eventPublisher);
+ eventPublisher.publish(event);
+ }
+ }
+}
--- /dev/null
+package org.argeo.slc.web.mvc.event;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.argeo.slc.msg.event.SlcEvent;
+import org.argeo.slc.msg.event.SlcEventListenerDescriptor;
+import org.argeo.slc.msg.event.SlcEventListenerRegister;
+import org.argeo.slc.web.mvc.AbstractServiceController;
+import org.springframework.web.servlet.ModelAndView;
+
+public class AddEventListenerController extends AbstractServiceController {
+
+ private SlcEventListenerRegister eventListenerRegister;
+
+ @Override
+ protected void handleServiceRequest(HttpServletRequest request,
+ HttpServletResponse response, ModelAndView modelAndView)
+ throws Exception {
+ String eventType = request.getParameter(SlcEvent.EVENT_TYPE);
+ String eventFilter = request.getParameter(SlcEvent.EVENT_FILTER);
+
+ eventListenerRegister
+ .addEventListenerDescriptor(new SlcEventListenerDescriptor(
+ eventType, eventFilter));
+ }
+
+ public void setEventListenerRegister(
+ SlcEventListenerRegister eventListenerRegister) {
+ this.eventListenerRegister = eventListenerRegister;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.web.mvc.event;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.msg.event.SlcEvent;
+import org.argeo.slc.msg.event.SlcEventListener;
+import org.argeo.slc.msg.event.SlcEventListenerRegister;
+import org.argeo.slc.web.mvc.AbstractServiceController;
+import org.springframework.web.servlet.ModelAndView;
+
+public class PollEventController extends AbstractServiceController {
+ private final static Log log = LogFactory.getLog(PollEventController.class);
+
+ private SlcEventListener eventListener;
+ private SlcEventListenerRegister eventListenerRegister;
+ private Long defaultTimeout = 10000l;
+
+ @Override
+ protected void handleServiceRequest(HttpServletRequest request,
+ HttpServletResponse response, ModelAndView modelAndView)
+ throws Exception {
+ String timeoutStr = request.getParameter("timeout");
+
+ final Long timeout;
+ if (timeoutStr != null)
+ timeout = Long.parseLong(timeoutStr);
+ else
+ timeout = defaultTimeout;
+
+ SlcEvent event = eventListener.listen(eventListenerRegister, timeout);
+ if (event != null) {
+ modelAndView.addObject("event", event);
+
+ if (log.isTraceEnabled())
+ log.debug("Received event: "
+ + event.getHeaders().get(SlcEvent.EVENT_TYPE));
+ }
+ }
+
+ public void setEventListener(SlcEventListener slcEventListener) {
+ this.eventListener = slcEventListener;
+ }
+
+ public void setEventListenerRegister(
+ SlcEventListenerRegister eventListenerRegister) {
+ this.eventListenerRegister = eventListenerRegister;
+ }
+
+ public void setDefaultTimeout(Long defaultTimeout) {
+ this.defaultTimeout = defaultTimeout;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.web.mvc.event;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import org.argeo.slc.msg.event.SlcEvent;
+import org.argeo.slc.msg.event.SlcEventListenerDescriptor;
+import org.argeo.slc.msg.event.SlcEventListenerRegister;
+import org.argeo.slc.web.mvc.AbstractServiceController;
+import org.springframework.web.servlet.ModelAndView;
+
+public class RemoveEventListenerController extends AbstractServiceController {
+
+ private SlcEventListenerRegister eventListenerRegister;
+
+ @Override
+ protected void handleServiceRequest(HttpServletRequest request,
+ HttpServletResponse response, ModelAndView modelAndView)
+ throws Exception {
+ String eventType = request.getParameter(SlcEvent.EVENT_TYPE);
+ String eventFilter = request.getParameter(SlcEvent.EVENT_FILTER);
+
+ eventListenerRegister
+ .removeEventListenerDescriptor(new SlcEventListenerDescriptor(
+ eventType, eventFilter));
+ }
+
+ public void setEventListenerRegister(
+ SlcEventListenerRegister eventListenerRegister) {
+ this.eventListenerRegister = eventListenerRegister;
+ }
+
+}
public class JmsAgent extends AbstractAgent implements SlcAgent,
InitializingBean, DisposableBean, MessageListener {
public final static String PROPERTY_QUERY = "query";
- public final static String PROPERTY_SLC_AGENT_ID = "slc_agentId";
-
public final static String QUERY_PING_ALL = "pingAll";
private final static Log log = LogFactory.getLog(JmsAgent.class);
public Message postProcessMessage(Message messageToSend)
throws JMSException {
messageToSend.setStringProperty(PROPERTY_QUERY, query);
- messageToSend.setStringProperty(PROPERTY_SLC_AGENT_ID,
+ messageToSend.setStringProperty(AbstractAgent.PROPERTY_SLC_AGENT_ID,
agentDescriptor.getUuid());
messageToSend.setJMSCorrelationID(correlationId);
return messageToSend;
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.ExecutionModuleDescriptor;
import org.argeo.slc.msg.ExecutionAnswer;
import org.argeo.slc.process.SlcExecution;
msg = session.createTextMessage();
else
msg = toMessage(body, session);
- msg.setStringProperty(JmsAgent.PROPERTY_SLC_AGENT_ID, agentUuid);
+ msg.setStringProperty(AbstractAgent.PROPERTY_SLC_AGENT_ID, agentUuid);
msg.setStringProperty(JmsAgent.PROPERTY_QUERY, query);
msg.setJMSCorrelationID(correlationId);
setArguments(msg);
--- /dev/null
+package org.argeo.slc.jms;
+
+import java.util.List;
+
+import javax.jms.ConnectionFactory;
+import javax.jms.Destination;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.SlcException;
+import org.argeo.slc.msg.event.SlcEvent;
+import org.argeo.slc.msg.event.SlcEventListener;
+import org.argeo.slc.msg.event.SlcEventListenerDescriptor;
+import org.argeo.slc.msg.event.SlcEventListenerRegister;
+import org.springframework.jms.core.JmsTemplate;
+import org.springframework.jms.support.converter.MessageConverter;
+
+public class JmsSlcEventListener implements SlcEventListener {
+ private final static Log log = LogFactory.getLog(JmsSlcEventListener.class);
+
+ private Destination eventsDestination;
+ private ConnectionFactory jmsConnectionFactory;
+ private MessageConverter messageConverter;
+
+ public SlcEvent listen(SlcEventListenerRegister register, Long timeout) {
+ JmsTemplate jmsTemplate = new JmsTemplate(jmsConnectionFactory);
+ jmsTemplate.setMessageConverter(messageConverter);
+ jmsTemplate.setReceiveTimeout(timeout);
+
+ List<SlcEventListenerDescriptor> descriptors = register
+ .getDescriptorsCopy();
+
+ if (descriptors.size() == 0) {
+ // No listeners, just waiting
+ try {
+ Thread.sleep(timeout);
+ } catch (InterruptedException e) {
+ // silent
+ }
+ return null;
+ } else {
+ String selector = createSelector(descriptors);
+
+ if (log.isTraceEnabled())
+ log.debug("Selector: " + selector);
+
+ Object obj = jmsTemplate.receiveSelectedAndConvert(
+ eventsDestination, selector);
+
+ if (obj == null)
+ return null;
+ else
+ return (SlcEvent) obj;
+ }
+ }
+
+ /** Returns null if no filter */
+ protected String createSelector(List<SlcEventListenerDescriptor> descriptors) {
+ if (descriptors.size() == 0)
+ throw new SlcException("No listeners, cannot generate JMS selector");
+
+ StringBuffer buf = new StringBuffer(256);
+ Boolean first = true;
+ for (SlcEventListenerDescriptor descriptor : descriptors) {
+ if (first)
+ first = false;
+ else
+ buf.append(" OR ");
+
+ buf.append('(');
+ buf.append(SlcEvent.EVENT_TYPE).append("=").append('\'').append(
+ descriptor.getEventType()).append('\'');
+ if (descriptor.getFilter() != null) {
+ buf.append(" AND ");
+ buf.append('(').append(descriptor.getFilter()).append(')');
+ }
+ buf.append(')');
+ }
+ return buf.toString();
+ }
+
+ public void setEventsDestination(Destination eventsDestination) {
+ this.eventsDestination = eventsDestination;
+ }
+
+ public void setJmsConnectionFactory(ConnectionFactory jmsConnectionFactory) {
+ this.jmsConnectionFactory = jmsConnectionFactory;
+ }
+
+ public void setMessageConverter(MessageConverter messageConverter) {
+ this.messageConverter = messageConverter;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.jms;
+
+import java.util.Map;
+
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+
+import org.argeo.slc.msg.event.SlcEvent;
+import org.argeo.slc.msg.event.SlcEventPublisher;
+import org.springframework.jms.core.JmsTemplate;
+import org.springframework.jms.core.MessagePostProcessor;
+
+public class JmsSlcEventPublisher implements SlcEventPublisher {
+ private Destination eventsDestination;
+ private JmsTemplate jmsTemplate;
+
+ public void publish(final SlcEvent event) {
+ jmsTemplate.convertAndSend(eventsDestination, event,
+ new MessagePostProcessor() {
+
+ public Message postProcessMessage(Message message)
+ throws JMSException {
+ Map<String, String> headers = event.getHeaders();
+ for (String key : headers.keySet()) {
+ message.setStringProperty(key, headers.get(key));
+ }
+ return message;
+ }
+ });
+ // jmsTemplate.send(eventsDestination, new MessageCreator() {
+ // public Message createMessage(Session session) throws JMSException {
+ // TextMessage msg = session.createTextMessage();
+ // // TODO: remove workaround when upgrading to ActiveMQ 5.3
+ // // Workaround for
+ // // https://issues.apache.org/activemq/browse/AMQ-2046
+ // msg.setText("");
+ //
+ // return msg;
+ // }
+ // });
+ }
+
+ public void setEventsDestination(Destination eventsDestination) {
+ this.eventsDestination = eventsDestination;
+ }
+
+ public void setJmsTemplate(JmsTemplate jmsTemplate) {
+ this.jmsTemplate = jmsTemplate;
+ }
+
+}
import javax.jms.MessageListener;
import org.argeo.slc.SlcException;
+import org.argeo.slc.core.runtime.AbstractAgent;
import org.argeo.slc.msg.MsgHandler;
import org.argeo.slc.process.SlcExecution;
import org.argeo.slc.runtime.SlcAgent;
public void onMessage(final Message message) {
try {
String agentId = message
- .getStringProperty(JmsAgent.PROPERTY_SLC_AGENT_ID);
+ .getStringProperty(AbstractAgent.PROPERTY_SLC_AGENT_ID);
final SlcAgent agent = agentFactory.getAgent(agentId);
final SlcExecution slcExecution = (SlcExecution) messageConverter
.fromMessage(message);
private Marshaller marshaller;
private Unmarshaller unmarshaller;
+ /** @return the converted message or null if the message itself is null */
public Object fromMessage(Message message) throws JMSException,
MessageConversionException {
+ if (message == null) {
+ return null;
+ }
+
if (log.isTraceEnabled()) {
Enumeration<String> names = message.getPropertyNames();
while (names.hasMoreElements()) {
if (message instanceof TextMessage) {
String text = ((TextMessage) message).getText();
+
+ if (text == null)
+ throw new SlcException(
+ "Cannot unmarshall message without body: " + message);
+
try {
return unmarshaller.unmarshal(new StringSource(text));
} catch (Exception e) {
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"
default-lazy-init="false">
- <!-- Destinations -->
-
+ <!-- Events -->
+ <bean id="slcJms.destination.events" p:physicalName="events"
+ parent="slcJms.amTopic" />
+
<!-- Agent service -->
<bean id="slcJms.destination.agent.register" p:physicalName="agent.register"
parent="slcJms.amTopic" />
+++ /dev/null
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:amq="http://activemq.apache.org/schema/core" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
- http://activemq.apache.org/schema/core http://activemq.apache.org/schema/core/activemq-core.xsd"
- default-lazy-init="false">
-
- <import resource="classpath:org/argeo/slc/activemq/spring.xml" />
-
- <bean id="slcDefault.jms.agent" class="org.argeo.slc.jms.JmsAgent"
- autowire="byType">
- <property name="jmsTemplate" ref="slcDefault.jms.jmsTemplateCastor" />
- <property name="agentRegister" ref="slcJms.destination.agent.register" />
- <property name="agentUnregister" ref="slcJms.destination.agent.unregister" />
- </bean>
-
- <!-- Templates -->
- <bean id="slcDefault.jms.listener.newExecution" parent="slcTemplate.jms.listenerContainer">
- <property name="connectionFactory" ref="slcDefault.jms.connectionFactory" />
- <property name="destination" ref="slcJms.destination.agent.newExecution" />
- <property name="messageListener">
- <bean parent="slcTemplate.jms.listenerAdapterCastor">
- <constructor-arg ref="slcDefault.jms.agent" />
- <property name="defaultListenerMethod" value="newExecution" />
- </bean>
- </property>
- <property name="messageSelector">
- <bean factory-bean="slcDefault.jms.agent" factory-method="getMessageSelector"/>
- </property>
- </bean>
-
-</beans>
\ No newline at end of file
org.argeo.slc.core.execution;resolution:=optional,
org.argeo.slc.msg;resolution:=optional,
org.argeo.slc.msg.process;resolution:=optional,
+ org.argeo.slc.msg.event;resolution:=optional,
org.argeo.slc.msg.test.tree;resolution:=optional,
org.argeo.slc.detached;resolution:=optional,
org.apache.xml.serialize
<field name="slcExecution" type="org.argeo.slc.process.SlcExecution" />
</class>
+ <!-- EVENTS -->
+
+ <class name="org.argeo.slc.msg.event.SlcEvent">
+ <map-to ns-uri="http://argeo.org/projects/slc/schemas"
+ ns-prefix="slc" />
+ <field name="headers" collection="map">
+ <bind-xml name="header" location="headers">
+ <class name="org.exolab.castor.mapping.MapItem">
+ <map-to ns-uri="http://argeo.org/projects/slc/schemas"
+ ns-prefix="slc" />
+ <field name="key" type="string">
+ <bind-xml name="name" node="attribute" />
+ </field>
+ <field name="value" type="string">
+ <bind-xml node="text" />
+ </field>
+ </class>
+ </bind-xml>
+ </field>
+ </class>
</mapping>
\ No newline at end of file
// private final static Log log = LogFactory.getLog(AbstractAgent.class);
private ExecutionModulesManager modulesManager;
+ public final static String PROPERTY_SLC_AGENT_ID = "slc_agentId";
public void runSlcExecution(final SlcExecution slcExecution) {
modulesManager.process(slcExecution);
--- /dev/null
+package org.argeo.slc.msg.event;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class SlcEvent {
+ public final static String EVENT_TYPE = "slc_eventType";
+ public final static String EVENT_FILTER = "slc_eventFilter";
+
+ private Map<String, String> headers = new HashMap<String, String>();
+
+ public SlcEvent() {
+ }
+
+ public SlcEvent(String eventType) {
+ headers.put(EVENT_TYPE, eventType);
+ }
+
+ public Map<String, String> getHeaders() {
+ return headers;
+ }
+
+ public void setHeaders(Map<String, String> headers) {
+ this.headers = headers;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.msg.event;
+
+public interface SlcEventListener {
+ /**
+ * Blocks until an event is received or timeout is reached
+ *
+ * @return the event received or null if timeout was reached before
+ * receiving one
+ */
+ public SlcEvent listen(SlcEventListenerRegister register, Long timeout);
+}
--- /dev/null
+package org.argeo.slc.msg.event;
+
+import java.io.Serializable;
+
+public class SlcEventListenerDescriptor implements Serializable {
+ static final long serialVersionUID = 1l;
+
+ private final String eventType;
+ private final String filter;
+
+ public SlcEventListenerDescriptor(String eventType, String filter) {
+ super();
+ this.eventType = eventType;
+ this.filter = filter;
+ }
+
+ public String getEventType() {
+ return eventType;
+ }
+
+ public String getFilter() {
+ return filter;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof SlcEventListenerDescriptor) {
+ SlcEventListenerDescriptor eventListenerDescriptor = (SlcEventListenerDescriptor) obj;
+ return eventListenerDescriptor.getEventType()
+ .equals(getEventType());
+ }
+ return false;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.msg.event;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Vector;
+
+public class SlcEventListenerRegister implements Serializable {
+ static final long serialVersionUID = 1l;
+
+ /** Synchronized */
+ private List<SlcEventListenerDescriptor> descriptors = new Vector<SlcEventListenerDescriptor>();
+
+ public synchronized void addEventListenerDescriptor(
+ SlcEventListenerDescriptor eventListenerDescriptor) {
+ if (descriptors.contains(eventListenerDescriptor))
+ descriptors.remove(eventListenerDescriptor);
+ descriptors.add(eventListenerDescriptor);
+ }
+
+ public synchronized void removeEventListenerDescriptor(
+ SlcEventListenerDescriptor eventListenerDescriptor) {
+ descriptors.remove(eventListenerDescriptor);
+ }
+
+ public synchronized List<SlcEventListenerDescriptor> getDescriptorsCopy() {
+ return new ArrayList<SlcEventListenerDescriptor>(descriptors);
+ }
+}
--- /dev/null
+package org.argeo.slc.msg.event;
+
+public interface SlcEventPublisher {
+ public void publish(SlcEvent event);
+}
Require-Bundle:
org.argeo.slc.specs,
org.argeo.slc.server,
+ org.argeo.slc.support.simple,
org.argeo.slc.support.activemq,
org.springframework.core,
org.springframework.context,
bean-name="jmsTransactionManager" />
<reference id="agentFactory" interface="org.argeo.slc.runtime.SlcAgentFactory" />
+
+ <service ref="jmsEventListener" interface="org.argeo.slc.msg.event.SlcEventListener" />
+ <service ref="jmsEventPublisher" interface="org.argeo.slc.msg.event.SlcEventPublisher" />
</beans:beans>
\ No newline at end of file
<import resource="classpath:org/argeo/slc/activemq/spring.xml" />
+ <!-- Events -->
+ <bean id="jmsEventListener" class="org.argeo.slc.jms.JmsSlcEventListener">
+ <property name="jmsConnectionFactory" ref="jmsConnectionFactory" />
+ <property name="eventsDestination" ref="slcJms.destination.events" />
+ <property name="messageConverter" ref="slcDefault.jms.castorMessageConverter" />
+ </bean>
+
+ <bean id="jmsEventPublisher" class="org.argeo.slc.jms.JmsSlcEventPublisher">
+ <property name="jmsTemplate" ref="jmsTemplate" />
+ <property name="eventsDestination" ref="slcJms.destination.events" />
+ </bean>
+
<!-- Agent Service -->
<bean id="agentService.jmsContainer.register" parent="listenerContainer">
<property name="destination" ref="slcJms.destination.agent.register" />
</property> </bean>
-->
+ <!-- Common -->
+ <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
+ <property name="messageConverter" ref="slcDefault.jms.castorMessageConverter" />
+ <property name="connectionFactory" ref="jmsConnectionFactory" />
+ </bean>
+
<!-- Templates -->
<bean id="listenerContainer"
class="org.springframework.jms.listener.DefaultMessageListenerContainer"
<reference id="agentFactory" interface="org.argeo.slc.runtime.SlcAgentFactory" />
+ <list id="eventPublishers" interface="org.argeo.slc.msg.event.SlcEventPublisher"
+ cardinality="0..N" />
+
</beans:beans>
\ No newline at end of file
</property>
</bean>
+ <!-- Events -->
+ <aop:aspectj-autoproxy />
+
+ <bean id="eventPublisherAspect" class="org.argeo.slc.services.EventPublisherAspect">
+ <property name="eventPublishers" ref="eventPublishers" />
+ </bean>
+
<!-- Services -->
<bean id="testManagerService" class="org.argeo.slc.services.impl.test.TestManagerServiceImpl">
<constructor-arg ref="testResultDao" />
org.hibernate.jdbc,
org.springframework.aop,
org.springframework.aop.framework,
+ org.springframework.aop.scope,
+ net.sf.cglib.proxy,
+ net.sf.cglib.core,
+ net.sf.cglib.reflect,
org.springframework.orm.hibernate3.support,
org.springframework.osgi.web.context.support,
org.springframework.oxm.castor,
org.springframework.transaction,
+ org.springframework.beans.factory.support,
org.springframework.web.context,
org.springframework.web.context.support,
+ org.springframework.web.context.request,
org.springframework.web.servlet,
org.springframework.web.servlet.handler,
org.springframework.web.servlet.view,
\r
<reference id="agentFactory" interface="org.argeo.slc.runtime.SlcAgentFactory" />\r
\r
+ <reference id="eventListener" interface="org.argeo.slc.msg.event.SlcEventListener" />\r
+\r
</beans:beans>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
- xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
+ xsi:schemaLocation="
+ http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
+ http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<import resource="classpath:/org/argeo/slc/castor/spring/applicationContext.xml" />
<property name="agentFactory" ref="agentFactory" />
</bean>
+ <!-- Events -->
+ <bean name="/addEventListener.service"
+ class="org.argeo.slc.web.mvc.event.AddEventListenerController">
+ <property name="eventListenerRegister" ref="eventListenerRegister" />
+ </bean>
+
+ <bean name="/removeEventListener.service"
+ class="org.argeo.slc.web.mvc.event.RemoveEventListenerController">
+ <property name="eventListenerRegister" ref="eventListenerRegister" />
+ </bean>
+
+ <bean name="/pollEvent.service" class="org.argeo.slc.web.mvc.event.PollEventController">
+ <property name="eventListenerRegister" ref="eventListenerRegister" />
+ <property name="eventListener" ref="eventListener" />
+ </bean>
+
+ <bean name="eventListenerRegister" class="org.argeo.slc.msg.event.SlcEventListenerRegister"
+ scope="session">
+ <aop:scoped-proxy />
+ </bean>
+
<bean id="handlerMapping"
class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping">
<property name="interceptors">
projects / gpl / argeo-slc.git / commitdiff