legacy/runtime/org.argeo.slc.support.activemq/src/main/java/org/argeo/slc/jms/JmsTreeTestResultListener.java

   1 /*
   2  * Copyright (C) 2007-2012 Mathieu Baudier
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.argeo.slc.jms;
  17
  18 import javax.jms.Destination;
  19
  20 import org.apache.commons.logging.Log;
  21 import org.apache.commons.logging.LogFactory;
  22 import org.argeo.slc.SlcException;
  23 import org.argeo.slc.core.attachment.Attachment;
  24 import org.argeo.slc.core.attachment.SimpleAttachment;
  25 import org.argeo.slc.core.test.tree.TreeTestResult;
  26 import org.argeo.slc.core.test.tree.TreeTestResultListener;
  27 import org.argeo.slc.msg.test.tree.AddTreeTestResultAttachmentRequest;
  28 import org.argeo.slc.msg.test.tree.CloseTreeTestResultRequest;
  29 import org.argeo.slc.msg.test.tree.CreateTreeTestResultRequest;
  30 import org.argeo.slc.msg.test.tree.ResultPartRequest;
  31 import org.argeo.slc.test.TestResultPart;
  32 import org.springframework.jms.JmsException;
  33 import org.springframework.jms.core.JmsTemplate;
  34
  35 /** JMS based tree test result listener implementation. */
  36 public class JmsTreeTestResultListener implements TreeTestResultListener {
  37         private final Log log = LogFactory.getLog(getClass());
  38
  39         private Boolean onlyOnClose = false;
  40         private JmsTemplate jmsTemplate;
  41
  42         private Destination executionEventDestination;
  43
  44         public void resultPartAdded(TreeTestResult testResult,
  45                         TestResultPart testResultPart) {
  46                 if (onlyOnClose)
  47                         return;
  48
  49                 try {
  50                         if (testResult.getResultParts().size() == 1
  51                                         && testResult.getResultParts().values().iterator().next()
  52                                                         .getParts().size() == 1) {
  53                                 CreateTreeTestResultRequest req = new CreateTreeTestResultRequest(
  54                                                 testResult);
  55
  56                                 if (log.isTraceEnabled())
  57                                         log.trace("Send create result request for result "
  58                                                         + testResult.getUuid());
  59
  60                                 jmsTemplate.convertAndSend(executionEventDestination, req);
  61                         } else {
  62                                 ResultPartRequest req = new ResultPartRequest(testResult);
  63
  64                                 if (log.isTraceEnabled())
  65                                         log.trace("Send result parts for result "
  66                                                         + testResult.getUuid());
  67
  68                                 jmsTemplate.convertAndSend(executionEventDestination, req);
  69                         }
  70                 } catch (JmsException e) {
  71                         log.warn("Could not notify result part to server: "
  72                                         + e.getMessage());
  73                         if (log.isTraceEnabled())
  74                                 log.debug("Original error.", e);
  75                 } catch (Exception e) {
  76                         throw new SlcException("Could not notify to JMS", e);
  77                 }
  78         }
  79
  80         public void close(TreeTestResult testResult) {
  81                 try {
  82                         if (onlyOnClose) {
  83                                 CreateTreeTestResultRequest req = new CreateTreeTestResultRequest(
  84                                                 testResult);
  85
  86                                 if (log.isTraceEnabled())
  87                                         log.trace("Send onClose create result request for result "
  88                                                         + testResult.getUuid());
  89
  90                                 jmsTemplate.convertAndSend(executionEventDestination, req);
  91                         } else {
  92                                 CloseTreeTestResultRequest req = new CloseTreeTestResultRequest(
  93                                                 testResult);
  94
  95                                 if (log.isTraceEnabled())
  96                                         log.trace("Send close result request for result "
  97                                                         + testResult.getUuid());
  98
  99                                 jmsTemplate.convertAndSend(executionEventDestination, req);
 100
 101                         }
 102                 } catch (JmsException e) {
 103                         log.warn("Could not notify result close to server: "
 104                                         + e.getMessage());
 105                         if (log.isTraceEnabled())
 106                                 log.debug("Original error.", e);
 107                 } catch (Exception e) {
 108                         throw new SlcException("Could not notify to JMS", e);
 109                 }
 110         }
 111
 112         public void addAttachment(TreeTestResult testResult, Attachment attachment) {
 113                 if (onlyOnClose)
 114                         return;
 115
 116                 try {
 117                         AddTreeTestResultAttachmentRequest req = new AddTreeTestResultAttachmentRequest();
 118                         req.setResultUuid(testResult.getUuid());
 119                         req.setAttachment((SimpleAttachment) attachment);
 120                         jmsTemplate.convertAndSend(executionEventDestination, req);
 121
 122                 } catch (JmsException e) {
 123                         log
 124                                         .warn("Could not notify attachment to server: "
 125                                                         + e.getMessage());
 126                         if (log.isTraceEnabled())
 127                                 log.debug("Original error.", e);
 128                 } catch (Exception e) {
 129                         throw new SlcException("Could not notify to JMS", e);
 130                 }
 131
 132         }
 133
 134         /** Publishes the test result only when it gets closed. */
 135         public void setOnlyOnClose(Boolean onlyOnClose) {
 136                 this.onlyOnClose = onlyOnClose;
 137         }
 138
 139         public void setJmsTemplate(JmsTemplate jmsTemplate) {
 140                 this.jmsTemplate = jmsTemplate;
 141         }
 142
 143         public void setExecutionEventDestination(
 144                         Destination executionEventDestination) {
 145                 this.executionEventDestination = executionEventDestination;
 146         }
 147
 148 }