Beispiel #1
0
 public Object getObjectProperty(Message jmsMessage, String name) throws JMSException {
   // try a direct lookup first
   Object answer = jmsMessage.getObjectProperty(name);
   if (answer == null) {
     // then encode the key and do another lookup
     String key = jmsKeyFormatStrategy.encodeKey(name);
     answer = jmsMessage.getObjectProperty(key);
   }
   return answer;
 }
  public void invalidateObject(Session session, javax.jms.Message msg)
      throws javax.jms.JMSException {
    String tableName = msg.getStringProperty("TABLE");
    if (tableName == null) {
      return;
    }
    Class baseClass = (Class) tableNameToClass.get(tableName);
    if (baseClass == null) {
      return;
    }
    Vector pkFieldNames = (Vector) tableNameToPkFieldNames.get(tableName);
    if (pkFieldNames == null) {
      return;
    }

    // create DatabaseRecord corresponding to the message
    DatabaseRecord row = new DatabaseRecord(pkFieldNames.size());
    for (int i = 0; i < pkFieldNames.size(); i++) {
      String fieldName = (String) pkFieldNames.elementAt(i);
      Object value = msg.getObjectProperty(fieldName);
      row.put(fieldName, value);
    }

    // invalidate in TopLink cache the object corresponding to the row and the baseClass
    session.getIdentityMapAccessor().invalidateObject(row, baseClass);
  }
  public static Hashtable getDataTable(Message message) throws JMSException {
    if (!message.propertyExists(MessagePropertyNames.DATA_TABLE)) {
      return DATA_TABLE_DEF;
    }

    return (Hashtable) message.getObjectProperty(MessagePropertyNames.DATA_TABLE);
  }
  @Override
  public MessageDetails createMessageDetailsFor(Destination incomingDestination, Message message) {
    try {
      Destination replyTo = message.getJMSReplyTo();
      String correlationId = message.getJMSCorrelationID();
      Map<String, String> customHeaders = null;

      if (correlationId != null && replyTo != null) {
        customHeaders = new HashMap<String, String>(3, 1.0f);
        Enumeration<String> enumeration = message.getPropertyNames();
        while (enumeration.hasMoreElements()) {
          String key = enumeration.nextElement();
          customHeaders.put(key, String.valueOf(message.getObjectProperty(key)));
        }
      }

      return new MessageDetails.Builder<Destination>()
          .withDestination(incomingDestination)
          .withCorrelationId(correlationId)
          .withReplyTo(replyTo)
          .withCustomHeaders(customHeaders)
          .build();
    } catch (JMSException e) {
      throw new RuntimeException("Unable to parse incoming message", e);
    }
  }
  protected JBossMessage(final Message foreign, final byte type, final ClientSession session)
      throws JMSException {
    this(type, session);

    setJMSTimestamp(foreign.getJMSTimestamp());

    try {
      byte[] corrIDBytes = foreign.getJMSCorrelationIDAsBytes();
      setJMSCorrelationIDAsBytes(corrIDBytes);
    } catch (JMSException e) {
      // specified as String
      String corrIDString = foreign.getJMSCorrelationID();
      if (corrIDString != null) {
        setJMSCorrelationID(corrIDString);
      }
    }

    setJMSReplyTo(foreign.getJMSReplyTo());
    setJMSDestination(foreign.getJMSDestination());
    setJMSDeliveryMode(foreign.getJMSDeliveryMode());
    setJMSExpiration(foreign.getJMSExpiration());
    setJMSPriority(foreign.getJMSPriority());
    setJMSType(foreign.getJMSType());

    // We can't avoid a cast warning here since getPropertyNames() is on the JMS API
    for (Enumeration<String> props = foreign.getPropertyNames(); props.hasMoreElements(); ) {
      String name = (String) props.nextElement();

      Object prop = foreign.getObjectProperty(name);

      this.setObjectProperty(name, prop);
    }
  }
  static Map<String, Object> mockAttributes(Message message) throws JMSException {
    final Map<String, Object> mockMap = new HashMap<String, Object>();
    mockMap.put("test-string", "test-value");
    mockMap.put("test-int", Integer.valueOf(1));

    when(message.getPropertyNames())
        .thenReturn(
            new Enumeration<String>() {
              Iterator<String> iter = mockMap.keySet().iterator();

              public boolean hasMoreElements() {
                return iter.hasNext();
              }

              public String nextElement() {
                return iter.next();
              }
            });

    when(message.getObjectProperty(
            argThat(
                new BaseMatcher<String>() {
                  public boolean matches(Object val) {
                    return "test-string".equals(val);
                  }

                  public void describeTo(Description desc) {
                    // do nothing
                  }
                })))
        .thenReturn(mockMap.get("test-string"));

    when(message.getObjectProperty(
            argThat(
                new BaseMatcher<String>() {
                  public boolean matches(Object val) {
                    return "test-int".equals(val);
                  }

                  public void describeTo(Description desc) {
                    // do nothing
                  }
                })))
        .thenReturn(mockMap.get("test-int"));
    return mockMap;
  }
  /**
   * Get property
   *
   * @param name The name
   * @return The value
   * @throws JMSException Thrown if an error occurs
   */
  @Override
  public Object getObjectProperty(final String name) throws JMSException {
    if (ActiveMQRAMessage.trace) {
      ActiveMQRALogger.LOGGER.trace("getObjectProperty(" + name + ")");
    }

    return message.getObjectProperty(name);
  }
 public static Hashtable getAttachments(Message message) throws JMSException {
   if (!message.propertyExists(MessagePropertyNames.ATTACHMENT_TABLE)) {
     return ATTACHMENT_TABLE_DEF;
   }
   Hashtable attachments = new Hashtable();
   attachments.putAll((Map) message.getObjectProperty(MessagePropertyNames.ATTACHMENT_TABLE));
   return attachments;
 }
  public static Object getDataEntry(Message message, Object name) throws JMSException {
    if (!message.propertyExists(MessagePropertyNames.DATA_TABLE)) {
      return DATA_PROP_DEF;
    }

    Hashtable datTable = (Hashtable) message.getObjectProperty(MessagePropertyNames.DATA_TABLE);

    return datTable.get(name);
  }
  public static Object getAttachment(Message message, String name) throws JMSException {
    if (!message.propertyExists(MessagePropertyNames.ATTACHMENT_TABLE)) {
      return ATTACHMENT_PROP_DEF;
    }

    Hashtable attachmentTable;
    attachmentTable = (Hashtable) message.getObjectProperty(MessagePropertyNames.ATTACHMENT_TABLE);
    return attachmentTable.get(name);
  }
  public static Object getPropertyValue(String propertyName, Message jmsMessage)
      throws JMSException {
    if (jmsMessage == null) {
      return null;
    }

    if (propertyName == null) {
      return null;
    }

    return jmsMessage.getObjectProperty(propertyName);
  }
Beispiel #12
0
 @SuppressWarnings("unchecked")
 private static Map<String, Object> properties(final javax.jms.Message message)
     throws JMSException {
   final HashMap<String, Object> result = new HashMap<>();
   final Enumeration<String> propertyNames = message.getPropertyNames();
   while (propertyNames.hasMoreElements()) {
     final String propertyName = propertyNames.nextElement();
     result.put(propertyName, message.getObjectProperty(propertyName));
   }
   result.put(JMS_MESSAGE_TYPE, getJmsMessageType(message));
   return result;
 }
  protected HornetQMessage(final Message foreign, final byte type, final ClientSession session)
      throws JMSException {
    this(type, session);

    setJMSTimestamp(foreign.getJMSTimestamp());

    String value =
        System.getProperty(
            HornetQJMSConstants.JMS_HORNETQ_ENABLE_BYTE_ARRAY_JMS_CORRELATION_ID_PROPERTY_NAME);

    boolean supportBytesId = !"false".equals(value);

    if (supportBytesId) {
      try {
        byte[] corrIDBytes = foreign.getJMSCorrelationIDAsBytes();
        setJMSCorrelationIDAsBytes(corrIDBytes);
      } catch (JMSException e) {
        // specified as String
        String corrIDString = foreign.getJMSCorrelationID();
        if (corrIDString != null) {
          setJMSCorrelationID(corrIDString);
        }
      }
    } else {
      // Some providers, like WSMQ do automatic conversions between native byte[] correlation id
      // and String correlation id. This makes it impossible for HQ to guarantee to return the
      // correct
      // type as set by the user
      // So we allow the behaviour to be overridden by a system property
      // https://jira.jboss.org/jira/browse/HORNETQ-356
      // https://jira.jboss.org/jira/browse/HORNETQ-332
      String corrIDString = foreign.getJMSCorrelationID();
      if (corrIDString != null) {
        setJMSCorrelationID(corrIDString);
      }
    }

    setJMSReplyTo(foreign.getJMSReplyTo());
    setJMSDestination(foreign.getJMSDestination());
    setJMSDeliveryMode(foreign.getJMSDeliveryMode());
    setJMSExpiration(foreign.getJMSExpiration());
    setJMSPriority(foreign.getJMSPriority());
    setJMSType(foreign.getJMSType());

    // We can't avoid a cast warning here since getPropertyNames() is on the JMS API
    for (Enumeration<String> props = foreign.getPropertyNames(); props.hasMoreElements(); ) {
      String name = props.nextElement();

      Object prop = foreign.getObjectProperty(name);

      setObjectProperty(name, prop);
    }
  }
Beispiel #14
0
 public Map<String, Object> getPropertiesMap() throws JMSException {
   Map<String, Object> answer = new HashMap<String, Object>();
   Message aMessage = getMessage();
   Enumeration iter = aMessage.getPropertyNames();
   while (iter.hasMoreElements()) {
     String name = (String) iter.nextElement();
     Object value = aMessage.getObjectProperty(name);
     if (value != null) {
       answer.put(name, value);
     }
   }
   return answer;
 }
 /**
  * Test that a <code>null</code> value is returned by the <code>Message.getObjectProperty()</code>
  * method if a property by the specified name does not exits.
  */
 @Test
 public void testGetObjectProperty() {
   try {
     Message message = senderSession.createMessage();
     Assert.assertEquals(
         "sec. 3.5.5 A null value is returned [by the getObjectProperty method] if a property by the specified "
             + "name does not exits.\n",
         null,
         message.getObjectProperty("prop"));
   } catch (JMSException e) {
     fail(e);
   }
 }
Beispiel #16
0
  public Map<String, Object> extractHeadersFromJms(Message jmsMessage, Exchange exchange) {
    Map<String, Object> map = new HashMap<String, Object>();
    if (jmsMessage != null) {
      // lets populate the standard JMS message headers
      try {
        map.put("JMSCorrelationID", jmsMessage.getJMSCorrelationID());
        map.put("JMSDeliveryMode", jmsMessage.getJMSDeliveryMode());
        map.put("JMSDestination", jmsMessage.getJMSDestination());
        map.put("JMSExpiration", jmsMessage.getJMSExpiration());
        map.put("JMSMessageID", jmsMessage.getJMSMessageID());
        map.put("JMSPriority", jmsMessage.getJMSPriority());
        map.put("JMSRedelivered", jmsMessage.getJMSRedelivered());
        map.put("JMSTimestamp", jmsMessage.getJMSTimestamp());

        map.put("JMSReplyTo", JmsMessageHelper.getJMSReplyTo(jmsMessage));
        map.put("JMSType", JmsMessageHelper.getJMSType(jmsMessage));

        // this works around a bug in the ActiveMQ property handling
        map.put("JMSXGroupID", jmsMessage.getStringProperty("JMSXGroupID"));
      } catch (JMSException e) {
        throw new RuntimeCamelException(e);
      }

      Enumeration names;
      try {
        names = jmsMessage.getPropertyNames();
      } catch (JMSException e) {
        throw new RuntimeCamelException(e);
      }
      while (names.hasMoreElements()) {
        String name = names.nextElement().toString();
        try {
          Object value = jmsMessage.getObjectProperty(name);
          if (headerFilterStrategy != null
              && headerFilterStrategy.applyFilterToExternalHeaders(name, value, exchange)) {
            continue;
          }

          // must decode back from safe JMS header name to original header name
          // when storing on this Camel JmsMessage object.
          String key = jmsKeyFormatStrategy.decodeKey(name);
          map.put(key, value);
        } catch (JMSException e) {
          throw new RuntimeCamelException(name, e);
        }
      }
    }

    return map;
  }
Beispiel #17
0
  public void onMessage(Message m) {
    _logger.info("Failover exchange notified cluster membership change");

    String currentBrokerIP = "";
    try {
      currentBrokerIP = InetAddress.getByName(_currentBrokerDetail.getHost()).getHostAddress();
    } catch (Exception e) {
      _logger.warn("Unable to resolve current broker host name", e);
    }

    List<BrokerDetails> brokerList = new ArrayList<BrokerDetails>();
    try {
      List<String> list = (List<String>) m.getObjectProperty("amq.failover");
      for (String brokerEntry : list) {
        String[] urls = brokerEntry.substring(5).split(",");
        // Iterate until you find the correct transport
        // Need to reconsider the logic when the C++ broker supports
        // SSL URLs.
        for (String url : urls) {
          String[] tokens = url.split(":");
          if (tokens[0].equalsIgnoreCase(_originalBrokerDetail.getTransport())) {
            BrokerDetails broker = new AMQBrokerDetails();
            broker.setTransport(tokens[0]);
            broker.setHost(tokens[1]);
            broker.setPort(Integer.parseInt(tokens[2]));
            broker.setProperties(_originalBrokerDetail.getProperties());
            broker.setSSLConfiguration(_originalBrokerDetail.getSSLConfiguration());
            brokerList.add(broker);

            if (currentBrokerIP.equals(broker.getHost())
                && _currentBrokerDetail.getPort() == broker.getPort()) {
              _currentBrokerIndex = brokerList.indexOf(broker);
            }

            break;
          }
        }
      }
    } catch (JMSException e) {
      _logger.error("Error parsing the message sent by failover exchange", e);
    }

    synchronized (_brokerListLock) {
      _connectionDetails.setBrokerDetails(brokerList);
    }

    _logger.info("============================================================");
    _logger.info("Updated cluster membership details " + _connectionDetails);
    _logger.info("============================================================");
  }
  public static byte[] getBytesData(Message message) throws JMSException {
    if (message instanceof BytesMessage) {
      BytesMessage bytesMessage = (BytesMessage) message;
      byte bytes[] = new byte[(int) bytesMessage.getBodyLength()];
      bytesMessage.readBytes(bytes);
      return bytes;
    }

    if (!message.propertyExists(MessagePropertyNames.BYTES_DATA)) {
      return BYTES_DATA_DEF;
    }

    return (byte[]) message.getObjectProperty(MessagePropertyNames.BYTES_DATA);
  }
Beispiel #19
0
 public String send(
     final T message,
     final Message correlatedMessage,
     final String correlationId,
     final URI dvbEndpointSelector,
     final String jmsGroupId,
     final Destination replyQueue) {
   try {
     final M jmsMessage = this.messageHandler.createEmptyMessage(this.sessionDelegate);
     jmsMessage.setJMSCorrelationID(determineCorrelationId(correlationId, correlatedMessage));
     Destination replyTo =
         replyQueue == null ? this.defaultReplyDestinationDelegate.delegate() : replyQueue;
     if (replyTo != null) {
       jmsMessage.setJMSReplyTo(replyTo);
     }
     final URI temp = DataUtilities.coalesce(dvbEndpointSelector, this.defaultEndpoint);
     if (temp != null) {
       jmsMessage.setStringProperty(
           JMSMessageSender.ENDPOINT_NAMESPACE, dvbEndpointSelector.toASCIIString());
     }
     if (correlatedMessage != null && this.copyPropertyPattern != null) {
       //noinspection unchecked
       for (final String name :
           Collections.list((Enumeration<String>) correlatedMessage.getPropertyNames())) {
         if (this.copyPropertyPattern.matcher(name).matches()) {
           if (correlatedMessage.getStringProperty(name) != null) {
             jmsMessage.setStringProperty(name, correlatedMessage.getStringProperty(name));
           } else {
             jmsMessage.setObjectProperty(name, correlatedMessage.getObjectProperty(name));
           }
         }
       }
     }
     this.messageHandler.fillMessage(message, jmsMessage);
     if (jmsGroupId != null) {
       jmsMessage.setStringProperty(JMSMessageSender.JMSX_GROUP_ID, jmsGroupId);
     }
     Delegate<MessageProducer> producer = this.producerDelegate;
     if (correlatedMessage != null && correlatedMessage.getJMSReplyTo() != null) {
       producer =
           new JMSMessageProducerDelegate(
               sessionDelegate, new UnmodifiableDelegate<>(correlatedMessage.getJMSReplyTo()));
     }
     producer.delegate().send(jmsMessage);
     return jmsMessage.getJMSMessageID();
   } catch (final JMSException e) {
     throw DelegatedException.delegate(e);
   }
 }
  public static void addDataEntry(Message message, Object name, Object value) throws JMSException {
    Hashtable dataTable = null;

    if (!message.propertyExists(MessagePropertyNames.DATA_TABLE)) {
      dataTable = new Hashtable();
    } else {
      dataTable = (Hashtable) message.getObjectProperty(MessagePropertyNames.DATA_TABLE);
    }

    dataTable.put(name, value);

    if (!message.propertyExists(MessagePropertyNames.DATA_TABLE)) {
      message.setObjectProperty(MessagePropertyNames.DATA_TABLE, dataTable);
    }
  }
  public static void addAttachment(Message message, Object name, Object value) throws JMSException {
    Hashtable headerTable = null;

    if (!message.propertyExists(MessagePropertyNames.ATTACHMENT_TABLE)) {
      headerTable = new Hashtable();
    } else {
      headerTable = (Hashtable) message.getObjectProperty(MessagePropertyNames.ATTACHMENT_TABLE);
    }

    headerTable.put(name, value);

    if (!message.propertyExists(MessagePropertyNames.ATTACHMENT_TABLE)) {
      message.setObjectProperty(MessagePropertyNames.ATTACHMENT_TABLE, headerTable);
    }
  }
Beispiel #22
0
  /*
   * JMS does not let you add a property on received message without first
   * calling clearProperties, so we need to save and re-add all the old properties so we
   * don't lose them!!
   */
  private static void copyProperties(final Message msg) throws JMSException {
    @SuppressWarnings("unchecked")
    Enumeration<String> en = msg.getPropertyNames();

    Map<String, Object> oldProps = null;

    while (en.hasMoreElements()) {
      String propName = en.nextElement();

      if (oldProps == null) {
        oldProps = new HashMap<String, Object>();
      }

      oldProps.put(propName, msg.getObjectProperty(propName));
    }

    msg.clearProperties();

    if (oldProps != null) {
      Iterator<Entry<String, Object>> oldPropsIter = oldProps.entrySet().iterator();

      while (oldPropsIter.hasNext()) {
        Entry<String, Object> entry = oldPropsIter.next();

        String propName = entry.getKey();

        Object val = entry.getValue();

        if (val instanceof byte[] == false) {
          // Can't set byte[] array props through the JMS API - if we're bridging a HornetQ message
          // it might have such props
          msg.setObjectProperty(propName, entry.getValue());
        } else if (msg instanceof HornetQMessage) {
          ((HornetQMessage) msg).getCoreMessage().putBytesProperty(propName, (byte[]) val);
        }
      }
    }
  }
Beispiel #23
0
  private void convertMessageProperties(
      final javax.jms.Message message, final MessageImpl replacementMessage) throws JMSException {
    Enumeration propertyNames = message.getPropertyNames();
    while (propertyNames.hasMoreElements()) {
      String propertyName = String.valueOf(propertyNames.nextElement());
      // TODO: Shouldn't need to check for JMS properties here as don't think getPropertyNames()
      // should return them
      if (!propertyName.startsWith("JMSX_")) {
        Object value = message.getObjectProperty(propertyName);
        replacementMessage.setObjectProperty(propertyName, value);
      }
    }

    replacementMessage.setJMSDeliveryMode(message.getJMSDeliveryMode());

    if (message.getJMSReplyTo() != null) {
      replacementMessage.setJMSReplyTo(message.getJMSReplyTo());
    }

    replacementMessage.setJMSType(message.getJMSType());

    replacementMessage.setJMSCorrelationID(message.getJMSCorrelationID());
  }
 /** {@inheritDoc} */
 @Override
 public void mapFrom(JMSBindingData source, Context context) throws Exception {
   Message message = source.getMessage();
   Enumeration<?> e = message.getPropertyNames();
   while (e.hasMoreElements()) {
     String key = e.nextElement().toString();
     if (matches(key)) {
       Object value = null;
       try {
         value = message.getObjectProperty(key);
       } catch (JMSException pce) {
         // ignore and keep going (here just to keep checkstyle happy)
         pce.getMessage();
       }
       if (value != null) {
         // JMS Message properties -> Context EXCHANGE properties
         context
             .setProperty(key, value, Scope.EXCHANGE)
             .addLabels(JCAComposition.JCA_MESSAGE_PROPERTY);
       }
     }
   }
 }
  @SuppressWarnings("unchecked")
  public void onMessage(Message message) {
    log.debug("Receiving a message on {} : {}", SyncJMSMessageProducer.QUEUE_NAME, message);
    try {

      String topic = message.getJMSType();
      String groupId = (String) message.getStringProperty("path");

      String operation = "UNKNOWN";

      // A group was DELETED
      if ("org/sakaiproject/nakamura/lite/authorizables/DELETE".equals(topic)
          && config.getDeletesEnabled()) {
        Map<String, Object> attributes =
            (Map<String, Object>) message.getObjectProperty(StoreListener.BEFORE_EVENT_PROPERTY);
        grouperManager.deleteGroup(groupId, attributes);
        operation = "DELETED";
      }

      // A new group was ADDED or an existing group was UPDATED
      if ("org/sakaiproject/nakamura/lite/authorizables/ADDED".equals(topic)
          || "org/sakaiproject/nakamura/lite/authorizables/UPDATED".equals(topic)) {
        // These events should be under org/sakaiproject/nakamura/lite/authorizables/UPDATED
        // http://jira.sakaiproject.org/browse/KERN-1795
        String membersAdded =
            (String) message.getStringProperty(GrouperEventUtils.MEMBERS_ADDED_PROP);
        if (membersAdded != null) {
          // membership adds can be attached to the same event for the group add.
          grouperManager.createGroup(groupId, config.getGroupTypes());
          grouperManager.addMemberships(
              groupId, Arrays.asList(StringUtils.split(membersAdded, ",")));
          operation = "ADD_MEMBERS";
        }

        String membersRemoved =
            (String) message.getStringProperty(GrouperEventUtils.MEMBERS_REMOVED_PROP);
        if (membersRemoved != null) {
          grouperManager.removeMemberships(
              groupId, Arrays.asList(StringUtils.split(membersRemoved, ",")));
          operation = "REMOVE_MEMBERS";
        }

        if (membersAdded == null && membersRemoved == null) {
          org.sakaiproject.nakamura.api.lite.Session repositorySession =
              repository.loginAdministrative();
          AuthorizableManager am = repositorySession.getAuthorizableManager();
          Group group = (Group) am.findAuthorizable(groupId);
          repositorySession.logout();

          if (groupId.startsWith(ContactsGrouperNameProviderImpl.CONTACTS_GROUPID_PREFIX)) {
            // TODO Why are we not getting added and removed properties on the Message
            grouperManager.createGroup(groupId, null);
            grouperManager.addMemberships(groupId, Arrays.asList(group.getMembers()));
            operation = "UPDATE CONTACTS";
          } else {
            grouperManager.createGroup(groupId, config.getGroupTypes());
            grouperManager.addMemberships(groupId, Arrays.asList(group.getMembers()));
            operation = "CREATE";
          }
        }
      }

      // The message was processed successfully. No exceptions were thrown.
      // We acknowledge the message and its removed from the queue
      message.acknowledge();

      // We got a message that we didn't know what to do with.
      if (operation.equals("UNKNOWN")) {
        log.error(
            "I don't know what to do with this topic: {}. Turn on debug logs to see the message.",
            topic);
        log.debug(message.toString());
      } else {
        log.info("Successfully processed and acknowledged. {}, {}", operation, groupId);
        log.debug(message.toString());
      }

    } catch (JMSException jmse) {
      log.error("JMSException while processing message.", jmse);
    } catch (Exception e) {
      log.error("Exception while processing message.", e);
    }
  }
  @SuppressWarnings("unchecked")
  public void onMessage(Message message) {
    try {
      LOGGER.debug("Started handling email jms message.");

      String nodePath = message.getStringProperty(NODE_PATH_PROPERTY);
      String contentPath = message.getStringProperty(CONTENT_PATH_PROPERTY);
      Object objRcpt = message.getObjectProperty(RECIPIENTS);
      List<String> recipients = null;

      if (objRcpt instanceof List<?>) {
        recipients = (List<String>) objRcpt;
      } else if (objRcpt instanceof String) {
        recipients = new LinkedList<String>();
        String[] rcpts = StringUtils.split((String) objRcpt, ',');
        for (String rcpt : rcpts) {
          recipients.add(rcpt);
        }
      }

      if (contentPath != null && contentPath.length() > 0) {
        javax.jcr.Session adminSession = repository.loginAdministrative(null);
        org.sakaiproject.nakamura.api.lite.Session sparseSession =
            StorageClientUtils.adaptToSession(adminSession);

        try {
          ContentManager contentManager = sparseSession.getContentManager();
          Content messageContent = contentManager.get(contentPath);

          if (objRcpt != null) {
            // validate the message
            if (messageContent != null) {
              if (messageContent.hasProperty(MessageConstants.PROP_SAKAI_MESSAGEBOX)
                  && (MessageConstants.BOX_OUTBOX.equals(
                          messageContent.getProperty(MessageConstants.PROP_SAKAI_MESSAGEBOX))
                      || MessageConstants.BOX_PENDING.equals(
                          messageContent.getProperty(MessageConstants.PROP_SAKAI_MESSAGEBOX)))) {
                if (messageContent.hasProperty(MessageConstants.PROP_SAKAI_MESSAGEERROR)) {
                  // We're retrying this message, so clear the errors
                  messageContent.setProperty(
                      MessageConstants.PROP_SAKAI_MESSAGEERROR, (String) null);
                }
                if (messageContent.hasProperty(MessageConstants.PROP_SAKAI_TO)
                    && messageContent.hasProperty(MessageConstants.PROP_SAKAI_FROM)) {
                  // make a commons-email message from the message
                  MultiPartEmail email = null;
                  try {
                    email =
                        constructMessage(messageContent, recipients, adminSession, sparseSession);

                    email.setSmtpPort(smtpPort);
                    email.setHostName(smtpServer);

                    email.send();
                  } catch (EmailException e) {
                    String exMessage = e.getMessage();
                    Throwable cause = e.getCause();

                    setError(messageContent, exMessage);
                    LOGGER.warn("Unable to send email: " + exMessage);

                    // Get the SMTP error code
                    // There has to be a better way to do this
                    boolean rescheduled = false;
                    if (cause != null && cause.getMessage() != null) {
                      String smtpError = cause.getMessage().trim();
                      try {
                        int errorCode = Integer.parseInt(smtpError.substring(0, 3));
                        // All retry-able SMTP errors should have codes starting
                        // with 4
                        scheduleRetry(errorCode, messageContent);
                        rescheduled = true;
                      } catch (NumberFormatException nfe) {
                        // smtpError didn't start with an error code, let's dig for
                        // it
                        String searchFor = "response:";
                        int rindex = smtpError.indexOf(searchFor);
                        if (rindex > -1 && (rindex + searchFor.length()) < smtpError.length()) {
                          int errorCode =
                              Integer.parseInt(
                                  smtpError.substring(searchFor.length(), searchFor.length() + 3));
                          scheduleRetry(errorCode, messageContent);
                          rescheduled = true;
                        }
                      }
                    }
                    if (rescheduled) {
                      LOGGER.info("Email {} rescheduled for redelivery. ", nodePath);
                    } else {
                      LOGGER.error("Unable to reschedule email for delivery: " + e.getMessage(), e);
                    }
                  }
                } else {
                  setError(messageContent, "Message must have a to and from set");
                }
              } else {
                setError(messageContent, "Not an outbox");
              }
              if (!messageContent.hasProperty(MessageConstants.PROP_SAKAI_MESSAGEERROR)) {
                messageContent.setProperty(
                    MessageConstants.PROP_SAKAI_MESSAGEBOX, MessageConstants.BOX_SENT);
              }
            }
          } else {
            String retval = "null";
            setError(
                messageContent,
                "Expected recipients to be String or List<String>.  Found " + retval);
          }
        } finally {
          if (adminSession != null) {
            adminSession.logout();
          }
        }
      }
    } catch (PathNotFoundException e) {
      LOGGER.error(e.getMessage(), e);
    } catch (RepositoryException e) {
      LOGGER.error(e.getMessage(), e);
    } catch (JMSException e) {
      LOGGER.error(e.getMessage(), e);
    } catch (EmailDeliveryException e) {
      LOGGER.error(e.getMessage());
    } catch (ClientPoolException e) {
      LOGGER.error(e.getMessage(), e);
    } catch (StorageClientException e) {
      LOGGER.error(e.getMessage(), e);
    } catch (AccessDeniedException e) {
      LOGGER.error(e.getMessage(), e);
    }
  }
  /** {@inheritDoc} */
  @Override
  public void mapFrom(JMSBindingData source, Context context) throws Exception {
    super.mapFrom(source, context);

    Message message = source.getMessage();

    // process JMS headers
    if (matches(HEADER_JMS_DESTINATION)) {
      context
          .setProperty(HEADER_JMS_DESTINATION, message.getJMSDestination())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_DELIVERY_MODE)) {
      context
          .setProperty(HEADER_JMS_DELIVERY_MODE, message.getJMSDeliveryMode())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_EXPIRATION)) {
      context
          .setProperty(HEADER_JMS_EXPIRATION, message.getJMSExpiration())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_PRIORITY)) {
      context
          .setProperty(HEADER_JMS_PRIORITY, message.getJMSPriority())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_MESSAGE_ID)) {
      context
          .setProperty(HEADER_JMS_MESSAGE_ID, message.getJMSMessageID())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_TIMESTAMP)) {
      context
          .setProperty(HEADER_JMS_TIMESTAMP, message.getJMSTimestamp())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_CORRELATION_ID)) {
      context
          .setProperty(HEADER_JMS_CORRELATION_ID, message.getJMSCorrelationID())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_REPLY_TO)) {
      context
          .setProperty(HEADER_JMS_REPLY_TO, message.getJMSReplyTo())
          .addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_TYPE)) {
      context.setProperty(HEADER_JMS_TYPE, message.getJMSType()).addLabels(JMS_HEADER_LABELS);
    }
    if (matches(HEADER_JMS_REDELIVERED)) {
      context
          .setProperty(HEADER_JMS_REDELIVERED, message.getJMSRedelivered())
          .addLabels(JMS_HEADER_LABELS);
    }

    // process JMS properties
    Enumeration<?> e = message.getPropertyNames();
    while (e.hasMoreElements()) {
      String key = e.nextElement().toString();
      if (matches(key)) {
        Object value = null;
        try {
          value = message.getObjectProperty(key);
        } catch (JMSException pce) {
          // ignore and keep going (here just to keep checkstyle happy)
          pce.getMessage();
        }
        if (value != null) {
          context.setProperty(key, value).addLabels(JMS_PROPERTY_LABELS);
        }
      } else if (matches(key, getIncludeRegexes(), new ArrayList<Pattern>())) {
        Object value = null;
        try {
          value = message.getObjectProperty(key);
        } catch (JMSException pce) {
          // ignore and keep going (here just to keep checkstyle happy)
          pce.getMessage();
        }
        if (value != null) {
          context.setProperty(key, value).addLabels(JMS_PROPERTY_LABELS);
        }
      }
    }
  }