Пример #1
0
 public Message createMessage(Session session) throws JMSException {
   MapMessage msg = session.createMapMessage();
   msg.setString("JID", JID);
   msg.setString("URL", URL);
   msg.setString("DESC", DESC);
   return msg;
 }
Пример #2
0
  @PreRemove
  void onPreRemove(Object entity) {
    String entityName = entity.getClass().getName();

    if (TrackedEntityUtils.isTrackedEntity(entityName)) {
      try {
        Session session = createSession();

        MapMessage message = session.createMapMessage();
        message.setLong("time", System.currentTimeMillis());
        message.setString("entity", entityName);
        message.setString("eventType", EventType.Delete.name());
        message.setObject("id", getEntityId(entity));

        Long loggedUserId = getLoggedUserId();
        if (loggedUserId != null) message.setLong("loggedUserId", loggedUserId);

        sendMessage(session, message);
      } catch (JMSException e) {
        throw new EventException(e);
      } catch (NamingException e) {
        throw new EventException(e);
      }
    }
  }
Пример #3
0
  /**
   * @param dataFile the byte data
   * @param entryType created, modified or deleted file
   * @param ID filename
   * @param session
   * @return Message object
   * @throws JMSException
   */
  protected Message createByteArrayMessage(
      byte[] fileByteArray,
      String ID,
      String checksum,
      String domain,
      String projectName,
      String entryType,
      String dateTime,
      Session session)
      throws JMSException, XMLStreamException {

    /** Can replace this with XML string for parameters: entryType, ID and dateTime */
    MapMessage message;

    message = session.createMapMessage();
    String msgParam =
        createXMLParameter(ID, checksum, entryType, projectName, dateTime, domain, "");
    message.setBytes("dataFile", fileByteArray);
    message.setString("msgParamXML", msgParam);
    // message.setString("checksum", msgParam);

    // message.setString("entryType", entryType);
    // message.setString("entryID", ID);
    return message;
  }
 public Message toMessage(Object object, Session session)
     throws JMSException, MessageConversionException {
   Person person = (Person) object;
   MapMessage message = session.createMapMessage();
   message.setString("name", person.getName());
   message.setInt("age", person.getAge());
   return message;
 }
Пример #5
0
  /**
   * @param fileURL the url of the file uploaded to fedora
   * @param ID
   * @param entryType
   * @param dateTime
   * @param session
   * @return
   * @throws JMSException
   * @throws XMLStreamException
   */
  protected Message createNewExperimentMessage(String experimentXMLString)
      throws JMSException, XMLStreamException {

    MapMessage message = session.createMapMessage();
    message.setString("msgParamXML", experimentXMLString);

    return message;
  }
  /**
   * Set
   *
   * @param name The name
   * @param value The value
   * @throws JMSException Thrown if an error occurs
   */
  @Override
  public void setString(final String name, final String value) throws JMSException {
    if (ActiveMQRAMapMessage.trace) {
      ActiveMQRALogger.LOGGER.trace("setString(" + name + ", " + value + ")");
    }

    ((MapMessage) message).setString(name, value);
  }
Пример #7
0
 @Override
 public void widgetSelected(SelectionEvent ev) {
   SendMapMessage sender = new SendMapMessage();
   try {
     sender.startSender();
     MapMessage message = sender.getSessionMessageObject();
     PropertyList properties = messageTable.getPropertyList();
     Vector<Property> propertyList = properties.getProperties();
     ListIterator<Property> it = propertyList.listIterator();
     while (it.hasNext()) {
       Property p = (Property) it.next();
       message.setString(p.getProperty(), p.getValue());
     }
     int count;
     try {
       count = Integer.parseInt(_countField.getText());
     } catch (NumberFormatException e) {
       count = 1;
     }
     if (count == 1) {
       message.setString("EVENTTIME", (_jmsDateFormat.format(Calendar.getInstance().getTime())));
       sender.sendMessage(_topicField.getText());
     } else {
       for (int i = 0; i < count; i++) {
         String name = message.getString("NAME");
         String[] nameParts = name.split("_");
         name = nameParts[0] + "_" + i;
         message.setString("NAME", name);
         message.setString(
             "EVENTTIME", (_jmsDateFormat.format(Calendar.getInstance().getTime())));
         sender.sendMessage(_topicField.getText());
       }
     }
   } catch (Exception e) {
     MessageDialog.openError(null, "JMS Sender", "Error sending JMS message: " + e.getMessage());
   } finally {
     try {
       sender.stopSender();
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }
Пример #8
0
  public Message toMessage(Object obj, Session session)
      throws JMSException, MessageConversionException {
    if (!(obj instanceof OperationLog)) {
      throw new MessageConversionException("Object isn't a WorkState");
    }

    OperationLog optLog = (OperationLog) obj;
    MapMessage msg = session.createMapMessage();
    DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    msg.setInt("mainType", optLog.getMainType().intValue());
    msg.setInt("minorType", optLog.getMinorType().intValue());
    msg.setInt("ctrlUnitId", optLog.getCtrlUnitId().intValue());
    msg.setInt("userId", optLog.getUserId().intValue());
    msg.setString("triggerTime", dateFormat.format(optLog.getTriggerTime()));
    msg.setInt("resourceId", optLog.getResourceId().intValue());
    msg.setString("logTxt", optLog.getLogTxt());

    return msg;
  }
Пример #9
0
  public void sendMessage(final Map<String, Serializable> properties, final String bodyId)
      throws JMSException {
    final MapMessage message = session.createMapMessage();

    for (final Map.Entry<String, Serializable> property : properties.entrySet()) {
      message.setObjectProperty(property.getKey(), property.getValue());
    }
    message.setString("body-id", bodyId);
    message.setJMSExpiration(System.currentTimeMillis() + timeout);

    producer.send(message);
  }
Пример #10
0
  public boolean send(@NotNull Value value, @Optional JMSQueue replyTo) throws JMSException {
    Message message = null;

    if (value.isArray()) {
      message = _session.createMapMessage();

      ArrayValue array = (ArrayValue) value;

      Set<Map.Entry<Value, Value>> entrySet = array.entrySet();

      for (Map.Entry<Value, Value> entry : entrySet) {
        if (entry.getValue() instanceof BinaryValue) {
          byte[] bytes = ((BinaryValue) entry.getValue()).toBytes();

          ((MapMessage) message).setBytes(entry.getKey().toString(), bytes);
        } else {
          // every primitive except for bytes can be translated from a string
          ((MapMessage) message).setString(entry.getKey().toString(), entry.getValue().toString());
        }
      }
    } else if (value instanceof BinaryValue) {
      message = _session.createBytesMessage();

      byte[] bytes = ((BinaryValue) value).toBytes();

      ((BytesMessage) message).writeBytes(bytes);
    } else if (value.isLongConvertible()) {
      message = _session.createStreamMessage();

      ((StreamMessage) message).writeLong(value.toLong());
    } else if (value.isDoubleConvertible()) {
      message = _session.createStreamMessage();

      ((StreamMessage) message).writeDouble(value.toDouble());
    } else if (value.toJavaObject() instanceof String) {
      message = _session.createTextMessage();

      ((TextMessage) message).setText(value.toString());
    } else if (value.toJavaObject() instanceof Serializable) {
      message = _session.createObjectMessage();

      ((ObjectMessage) message).setObject((Serializable) value.toJavaObject());
    } else {
      return false;
    }

    if (replyTo != null) message.setJMSReplyTo(replyTo._destination);

    _producer.send(message);

    return true;
  }
Пример #11
0
  @org.junit.Ignore
  public void testSendMapToQueue() throws Exception {
    final TestRunner runner = TestRunners.newTestRunner(GetJMSQueue.class);
    runner.setProperty(JmsProperties.JMS_PROVIDER, JmsProperties.ACTIVEMQ_PROVIDER);
    runner.setProperty(JmsProperties.URL, "tcp://localhost:61616");
    runner.setProperty(JmsProperties.DESTINATION_TYPE, JmsProperties.DESTINATION_TYPE_QUEUE);
    runner.setProperty(JmsProperties.DESTINATION_NAME, "queue.testing");
    runner.setProperty(JmsProperties.ACKNOWLEDGEMENT_MODE, JmsProperties.ACK_MODE_AUTO);
    WrappedMessageProducer wrappedProducer =
        JmsFactory.createMessageProducer(runner.getProcessContext(), true);
    final Session jmsSession = wrappedProducer.getSession();
    final MessageProducer producer = wrappedProducer.getProducer();

    final MapMessage message = jmsSession.createMapMessage();
    message.setString("foo!", "bar");
    message.setString("bacon", "meat");

    producer.send(message);
    jmsSession.commit();
    producer.close();
    jmsSession.close();
  }
Пример #12
0
  public static void sendMessage() {
    Connection topicConnection = null;
    Session session = null;
    MapMessage message = null;
    MessageProducer producer = null;

    try {
      topicConnection = topicFactory.createConnection();
      session = topicConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);

      producer = session.createProducer(topic);

      message = session.createMapMessage();
      message.setString("lastname", "Smith");
      message.setString("firstname", "John");
      message.setString("id", "0100");

      producer.send(message);

      System.out.println("sent a message");
    } catch (Exception e) {
      log.log(Level.SEVERE, "Topic client exception: ", e);
    }
  }
 /**
  * @param type
  * @throws JMSException
  */
 private Object createBodySendAndReceive(JmsMessageType type) throws JMSException {
   Object res = null;
   Message msg = null;
   switch (type) {
     case BYTE:
       BytesMessage mByte = queueProducerSession.createBytesMessage();
       final int size = 20;
       byte[] resByte = new byte[size];
       for (int i = 0; i < size; i++) {
         resByte[i] = (byte) i;
         mByte.writeByte((byte) i);
       }
       msg = mByte;
       res = resByte;
       break;
     case TEXT:
       res = "JMS2";
       msg = queueProducerSession.createTextMessage("JMS2");
       break;
     case STREAM:
       msg = queueProducerSession.createStreamMessage();
       break;
     case OBJECT:
       res = new Double(37.6);
       msg = queueProducerSession.createObjectMessage(new Double(37.6));
       break;
     case MAP:
       MapMessage msg1 = queueProducerSession.createMapMessage();
       msg1.setInt("int", 13);
       msg1.setLong("long", 37L);
       msg1.setString("string", "crocodile");
       msg = msg1;
       Map<String, Object> map = new HashMap<String, Object>();
       map.put("int", Integer.valueOf(13));
       map.put("long", Long.valueOf(37L));
       map.put("string", "crocodile");
       res = map;
       break;
     default:
       Assert.fail("no default...");
   }
   Assert.assertNotNull(msg);
   msg.setStringProperty("type", type.toString());
   queueProducer.send(msg);
   return res;
 }
 /**
  * Create message initialized with basic alarm & application info
  *
  * @param text TEXT property
  * @return MapMessage
  * @throws Exception on error.
  */
 private MapMessage createMapMessage(final String text) throws Exception {
   final MapMessage map = createMapMessage();
   map.setString(JMSLogMessage.TYPE, JMSAlarmMessage.TYPE_ALARM);
   map.setString(JMSAlarmMessage.CONFIG, model.getConfigurationName());
   map.setString(JMSLogMessage.TEXT, text);
   map.setString(JMSLogMessage.APPLICATION_ID, APPLICATION);
   map.setString(JMSLogMessage.HOST, host);
   User loggedUser = SecurityFacade.getInstance().getCurrentUser();
   if (loggedUser == null) // if no user logged in...
   user = System.getProperty("user.name"); // $NON-NLS-1$
   else user = loggedUser.getUsername();
   map.setString(JMSLogMessage.USER, user);
   return map;
 }
Пример #15
0
 @Override
 public JMSProducer send(Destination destination, Map<String, Object> body) {
   MapMessage message = context.createMapMessage();
   if (body != null) {
     try {
       for (Entry<String, Object> entry : body.entrySet()) {
         final String name = entry.getKey();
         final Object v = entry.getValue();
         if (v instanceof String) {
           message.setString(name, (String) v);
         } else if (v instanceof Long) {
           message.setLong(name, (Long) v);
         } else if (v instanceof Double) {
           message.setDouble(name, (Double) v);
         } else if (v instanceof Integer) {
           message.setInt(name, (Integer) v);
         } else if (v instanceof Character) {
           message.setChar(name, (Character) v);
         } else if (v instanceof Short) {
           message.setShort(name, (Short) v);
         } else if (v instanceof Boolean) {
           message.setBoolean(name, (Boolean) v);
         } else if (v instanceof Float) {
           message.setFloat(name, (Float) v);
         } else if (v instanceof Byte) {
           message.setByte(name, (Byte) v);
         } else if (v instanceof byte[]) {
           byte[] array = (byte[]) v;
           message.setBytes(name, array, 0, array.length);
         } else {
           message.setObject(name, v);
         }
       }
     } catch (JMSException e) {
       throw new MessageFormatRuntimeException(e.getMessage());
     }
   }
   send(destination, message);
   return this;
 }
  protected Message createStockMessage(String stock, Session session) throws JMSException {
    Double value = LAST_PRICES.get(stock);
    if (value == null) {
      value = new Double(Math.random() * 100);
    }

    // lets mutate the value by some percentage
    double oldPrice = value.doubleValue();
    value = new Double(mutatePrice(oldPrice));
    LAST_PRICES.put(stock, value);
    double price = value.doubleValue();

    double offer = price * 1.001;

    boolean up = (price > oldPrice);
    MapMessage message = session.createMapMessage();
    message.setString("stock", stock);
    message.setDouble("price", price);
    message.setDouble("offer", offer);
    message.setBoolean("up", up);
    return message;
  }
Пример #17
0
  public static void main(String[] args) {
    MapMessage outMessage;
    JMSConsumer orderConfirmReceiver;
    MapMessage inMessage;

    if (args.length != 1) {
      System.out.println("Error: Program takes numerical argument.");
      System.exit(1);
    }

    quantity = (new Integer(args[0])).intValue();
    System.out.println("Retailer: Quantity to be ordered is " + quantity);
    /*
     * Create non-transacted context and sender for
     * vendor order queue.
     * Create message to vendor, setting item and
     * quantity values.
     * Send message.
     * Create receiver for retailer confirmation queue.
     * Get message and report result.
     * Send an end-of-message-stream message so vendor
     * will stop processing orders.
     */
    try (JMSContext context = connectionFactory.createContext(); ) {
      outMessage = context.createMapMessage();
      outMessage.setString("Item", "Computer(s)");
      outMessage.setInt("Quantity", quantity);
      outMessage.setJMSReplyTo(retailerConfirmQueue);
      context.createProducer().send(vendorOrderQueue, outMessage);
      System.out.println("Retailer: Ordered " + quantity + " computer(s)");

      orderConfirmReceiver = context.createConsumer(retailerConfirmQueue);
      inMessage = (MapMessage) orderConfirmReceiver.receive();

      if (inMessage.getBoolean("OrderAccepted") == true) {
        System.out.println("Retailer: Order filled");
      } else {
        System.out.println("Retailer: Order not filled");
      }

      System.out.println("Retailer: Placing another order");
      outMessage.setInt("Quantity", quantity * 2);
      context.createProducer().send(vendorOrderQueue, outMessage);
      System.out.println("Retailer: Ordered " + outMessage.getInt("Quantity") + " computer(s)");
      inMessage = (MapMessage) orderConfirmReceiver.receive();

      if (inMessage.getBoolean("OrderAccepted") == true) {
        System.out.println("Retailer: Order filled");
      } else {
        System.out.println("Retailer: Order not filled");
      }

      /*
       * Send a non-text control message indicating end
       * of messages.
       */
      context.createProducer().send(vendorOrderQueue, context.createMessage());
    } catch (JMSException e) {
      System.err.println("Retailer: Exception occurred: " + e.toString());
    }
  }