Examples with MessageListener javax.jms.MessageListener used on opensource projects

Example 1 with MessageListener

use of javax.jms.MessageListener in project ACS by ACS-Community.

the class LaserComponent method initialize.

public void initialize() {
    this.logger = corbaServer.getLogger();
    defaultTopicConnectionFactory = new ACSJMSTopicConnectionFactory(alSysContSvcs);
    TopicConnection tc;
    TopicSession ts = null;
    try {
        tc = defaultTopicConnectionFactory.createTopicConnection();
        ts = tc.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
        Topic topicAdminCacheLoader = new ACSJMSTopic("CMW.ALARM_SYSTEM.ADMIN_CACHE_LOADER");
        subscriberAdminCacheLoader = ts.createSubscriber(topicAdminCacheLoader);
        subscriberAdminCacheLoader.setMessageListener(new MessageListener() {

            public void onMessage(Message message) {
                if (message instanceof TextMessage) {
                    logger.log(AcsLogLevel.DEBUG, "Received a JMS message");
                } else {
                    logger.log(AcsLogLevel.WARNING, "Received a non text JMS message");
                }
                try {
                    alarmMessageProcessor.process(message);
                } catch (Throwable t) {
                    logger.log(AcsLogLevel.ERROR, "Exception processing a message: " + t.getMessage(), t);
                // There is nothing to do at this level: log the exception
                // and be ready to process the next message
                }
            }
        });
        logger.log(AcsLogLevel.DEBUG, "JMS initialized");
    } catch (Throwable t) {
        System.err.println("Error initing JMS, " + t.getMessage());
        t.printStackTrace(System.err);
        logger.log(AcsLogLevel.ERROR, "Error initializing JMS", t);
        coreAlarms.add(LaserCoreFaultCodes.JMS_INIT);
    }
    ConfigurationAccessor conf = null;
    try {
        conf = ConfigurationAccessorFactory.getInstance(alSysContSvcs);
    } catch (Throwable t) {
        System.err.println("Error getting CDB: " + t.getMessage());
        t.printStackTrace(System.err);
        logger.log(AcsLogLevel.WARNING, "Error getting CDB", t);
        coreAlarms.add(LaserCoreFaultCodes.CDB_UNAVAILABLE);
    }
    adminUserDAO = new ACSAdminUserDAOImpl();
    alarmDAO = new ACSAlarmDAOImpl(logger);
    alarmDAO.setConfAccessor(conf);
    categoryDAO = new ACSCategoryDAOImpl(logger, alarmDAO);
    categoryDAO.setConfAccessor(conf);
    responsiblePersonDAO = new ACSResponsiblePersonDAOImpl();
    try {
        alarmDAO.loadAlarms();
    } catch (Throwable t) {
        System.err.println("Error loading alarms: " + t.getMessage());
        t.printStackTrace(System.err);
        logger.log(AcsLogLevel.CRITICAL, "Error loading alarms from CDB", t);
        coreAlarms.add(LaserCoreFaultCodes.ALARMS_CDB);
    }
    try {
        categoryDAO.loadCategories();
    } catch (Throwable t) {
        System.err.println("Error loading categories: " + t.getMessage());
        t.printStackTrace(System.err);
        logger.log(AcsLogLevel.CRITICAL, "Error loading categories from CDB", t);
        coreAlarms.add(LaserCoreFaultCodes.CATEGORIES_CDB);
    }
    sourceDAO = new ACSSourceDAOImpl(logger, alarmDAO.getSources());
    sourceDAO.setConfAccessor(conf);
    sourceDAO.setLaserSourceId("LASER");
    sourceDAO.setAlarmDAO(alarmDAO);
    sourceDAO.setResponsiblePersonDAO(responsiblePersonDAO);
    adminUserDefinitionService = new AdminUserDefinitionServiceImpl();
    alarmCacheServer = new AlarmCacheServerImpl(logger);
    alarmDefinitionService = new AlarmDefinitionServiceImpl();
    sourcesListener = new AlarmSourcesListenerCached(alSysContSvcs, logger, this);
    statisticsCalculator = new StatsCalculator(this.logger, sourcesListener);
    alarmMessageProcessor = new AlarmMessageProcessorImpl(this, logger, statisticsCalculator);
    alarmPublisher = new AlarmPublisherImpl(logger);
    alarmSourceMonitor = new AlarmSourceMonitorImpl();
    categoryDefinitionService = new CategoryDefinitionServiceImpl();
    coreService = new CoreServiceImpl();
    heartbeat = new HeartbeatImpl();
    mailAndSmsServer = new ACSMailAndSmsServer(logger);
    sourceDefinitionService = new SourceDefinitionServiceImpl();
    alarmCacheListener = new AlarmCacheListenerImpl(alarmCacheServer);
    alarmCache = new ACSAlarmCacheImpl(alarmDAO, categoryDAO, alarmCacheListener, logger);
    statisticsCalculator.start();
    alarmDAO.setSurveillanceAlarmId("SURVEILLANCE:SOURCE:1");
    alarmDAO.setResponsiblePersonDAO(responsiblePersonDAO);
    //		categoryDAO.setCategoryTreeRoot("ACS");
    categoryDAO.setCategoryTreeRoot("ROOT");
    categoryDAO.setSurveillanceCategoryPath("ACS.SURVEILLANCE");
    responsiblePersonDAO.setAlarmDAO(alarmDAO);
    adminUserDefinitionService.setCategoryDAO(categoryDAO);
    adminUserDefinitionService.setAdminUserDAO(adminUserDAO);
    alarmCacheServer.setAlarmDAO(alarmDAO);
    alarmCacheServer.setAlarmPublisher(alarmPublisher);
    alarmCacheServer.setMailAndSmsServer(mailAndSmsServer);
    alarmDefinitionService.setAlarmCache(alarmCache);
    alarmDefinitionService.setAdminUserDAO(adminUserDAO);
    alarmDefinitionService.setAlarmDAO(alarmDAO);
    alarmDefinitionService.setCategoryDAO(categoryDAO);
    alarmDefinitionService.setResponsiblePersonDAO(responsiblePersonDAO);
    alarmDefinitionService.setSourceDAO(sourceDAO);
    alarmDefinitionService.setAlarmMessageProcessor(alarmMessageProcessor);
    alarmDefinitionService.setAlarmPublisher(alarmPublisher);
    alarmMessageProcessor.setAlarmCache(alarmCache);
    alarmMessageProcessor.setSourceDAO(sourceDAO);
    alarmPublisher.setTopicConnectionFactory(defaultTopicConnectionFactory);
    alarmPublisher.setCategoryRootTopic("CMW.ALARM_SYSTEM.CATEGORIES");
    alarmSourceMonitor.setSourceDAO(sourceDAO);
    alarmSourceMonitor.setAlarmMessageProcessor(alarmMessageProcessor);
    alarmSourceMonitor.setSourceMonitorFrequency(60000);
    categoryDefinitionService.setAlarmCache(alarmCache);
    categoryDefinitionService.setAdminUserDAO(adminUserDAO);
    categoryDefinitionService.setAlarmDAO(alarmDAO);
    categoryDefinitionService.setCategoryDAO(categoryDAO);
    coreService.setAlarmCache(alarmCache);
    coreService.setResponsiblePersonDAO(responsiblePersonDAO);
    coreService.setSourceDAO(sourceDAO);
    coreService.setAlarmDAO(alarmDAO);
    coreService.setCategoryDAO(categoryDAO);
    coreService.setAlarmPublisher(alarmPublisher);
    // coreService.setDataSource(defaultDataSource);
    coreService.setClientRootTopic("CMW.ALARM_SYSTEM.CLIENTS");
    coreService.setRootCategoryPK(2064926);
    coreService.setHeartbeatTopic("CMW.ALARM_SYSTEM.HEARTBEAT");
    coreService.setHeartbeatFrequency(60000);
    coreService.setSearchRootTopic("CMW.ALARM_SYSTEM.SEARCH");
    heartbeat.setCoreService(coreService);
    heartbeat.setTopicConnectionFactory(defaultTopicConnectionFactory);
    sourceDefinitionService.setAlarmCache(alarmCache);
    sourceDefinitionService.setAdminUserDAO(adminUserDAO);
    sourceDefinitionService.setAlarmDAO(alarmDAO);
    sourceDefinitionService.setCategoryDAO(categoryDAO);
    sourceDefinitionService.setResponsiblePersonDAO(responsiblePersonDAO);
    sourceDefinitionService.setSourceDAO(sourceDAO);
    sourceDefinitionService.setAlarmDefinitionService(alarmDefinitionService);
    alarmDAO.setAlarmProcessor(alarmMessageProcessor);
    // Subscribe the source listener to all the source NCs
    try {
        sourcesListener.connectSources(sourceDAO.getAllSourceIDs());
        logger.log(AcsLogLevel.DEBUG, "Successfully connected to sources NCs");
    } catch (Throwable t) {
        System.err.println("Error setting source listener: " + t.getMessage());
        t.printStackTrace(System.err);
        logger.log(AcsLogLevel.WARNING, "Error setting the source listener", t);
        coreAlarms.add(LaserCoreFaultCodes.SOURCE_LISTENER);
    }
    sourcesListener.start();
}

Example 2 with MessageListener

use of javax.jms.MessageListener in project camel by apache.

the class SjmsConsumer method createConsumer.

/**
     * Creates a {@link MessageConsumerResources} with a dedicated
     * {@link Session} required for transacted and InOut consumers.
     */
private MessageConsumerResources createConsumer() throws Exception {
    MessageConsumerResources answer;
    ConnectionResource connectionResource = getOrCreateConnectionResource();
    Connection conn = connectionResource.borrowConnection();
    try {
        Session session = conn.createSession(isTransacted(), isTransacted() ? Session.SESSION_TRANSACTED : Session.AUTO_ACKNOWLEDGE);
        MessageConsumer messageConsumer = getEndpoint().getJmsObjectFactory().createMessageConsumer(session, getEndpoint());
        MessageListener handler = createMessageHandler(session);
        messageConsumer.setMessageListener(handler);
        answer = new MessageConsumerResources(session, messageConsumer);
    } catch (Exception e) {
        log.error("Unable to create the MessageConsumer", e);
        throw e;
    } finally {
        connectionResource.returnConnection(conn);
    }
    return answer;
}

Example 3 with MessageListener

use of javax.jms.MessageListener in project qpid-broker-j by apache.

the class ConsumerParticipant method startTest.

@Override
public void startTest(String registeredClientName, ResultReporter resultReporter) throws Exception {
    final int acknowledgeMode = _jmsDelegate.getAcknowledgeMode(_command.getSessionName());
    final String providerVersion = _jmsDelegate.getProviderVersion(_command.getSessionName());
    final String protocolVersion = _jmsDelegate.getProtocolVersion(_command.getSessionName());
    if (_command.isSynchronous()) {
        synchronousRun();
    } else {
        LOGGER.debug("Consumer {} registering listener", getName());
        _jmsDelegate.registerListener(_command.getParticipantName(), new MessageListener() {

            @Override
            public void onMessage(Message message) {
                processAsyncMessage(message);
            }
        });
        waitUntilMsgListenerHasFinished();
        rethrowAnyAsyncMessageListenerException();
    }
    Date end = new Date();
    final Date start = new Date(_startTime);
    int numberOfMessagesReceived = _totalNumberOfMessagesReceived.get();
    long totalPayloadSize = _totalPayloadSizeOfAllMessagesReceived.get();
    int payloadSize = getPayloadSizeForResultIfConstantOrZeroOtherwise(_allConsumedPayloadSizes);
    LOGGER.info("Consumer {} finished consuming. Number of messages consumed: {}", getName(), numberOfMessagesReceived);
    ParticipantResult result = _resultFactory.createForConsumer(getName(), registeredClientName, _command, acknowledgeMode, numberOfMessagesReceived, payloadSize, totalPayloadSize, start, end, _messageLatencies, providerVersion, protocolVersion);
    resultReporter.reportResult(result);
}

Example 4 with MessageListener

use of javax.jms.MessageListener in project qpid-broker-j by apache.

the class ControllerJmsDelegate method start.

public void start() {
    try {
        createControllerQueue();
        final MessageConsumer consumer = _controllerQueueListenerSession.createConsumer(_controllerQueue);
        consumer.setMessageListener(new MessageListener() {

            @Override
            public void onMessage(final Message message) {
                try {
                    String jmsMessageID = message.getJMSMessageID();
                    LOGGER.debug("Received message ID {}", jmsMessageID);
                    final Command command = JmsMessageAdaptor.messageToCommand(message);
                    LOGGER.debug("Converted message ID {} into command {}", jmsMessageID, command);
                    processCommandWithFirstSupportingListener(command);
                    LOGGER.debug("Finished processing command for message ID", jmsMessageID);
                } catch (Exception t) {
                    LOGGER.error("Can't handle JMS message", t);
                }
            }
        });
    } catch (final JMSException e) {
        throw new DistributedTestException(e);
    }
}

Example 5 with MessageListener

use of javax.jms.MessageListener in project wso2-axis2-transports by wso2.

the class MockEchoEndpoint method setUp.

@Setup
@SuppressWarnings("unused")
private void setUp(JMSTestEnvironment env, JMSRequestResponseChannel channel) throws Exception {
    Destination destination = channel.getDestination();
    Destination replyDestination = channel.getReplyDestination();
    connection = env.getConnectionFactory().createConnection();
    connection.setExceptionListener(this);
    connection.start();
    replyConnection = env.getConnectionFactory().createConnection();
    replyConnection.setExceptionListener(this);
    final Session replySession = replyConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    final MessageProducer producer = replySession.createProducer(replyDestination);
    MessageConsumer consumer = connection.createSession(false, Session.AUTO_ACKNOWLEDGE).createConsumer(destination);
    consumer.setMessageListener(new MessageListener() {

        public void onMessage(Message message) {
            try {
                log.info("Message received: ID = " + message.getJMSMessageID());
                Message reply;
                if (message instanceof BytesMessage) {
                    reply = replySession.createBytesMessage();
                    IOUtils.copy(new BytesMessageInputStream((BytesMessage) message), new BytesMessageOutputStream((BytesMessage) reply));
                } else if (message instanceof TextMessage) {
                    reply = replySession.createTextMessage();
                    ((TextMessage) reply).setText(((TextMessage) message).getText());
                } else {
                    // TODO
                    throw new UnsupportedOperationException("Unsupported message type");
                }
                reply.setJMSCorrelationID(message.getJMSMessageID());
                reply.setStringProperty(BaseConstants.CONTENT_TYPE, message.getStringProperty(BaseConstants.CONTENT_TYPE));
                producer.send(reply);
                log.info("Message sent: ID = " + reply.getJMSMessageID());
            } catch (Throwable ex) {
                fireEndpointError(ex);
            }
        }
    });
}