Support for message string properties - #39

Author: matrober-uk

jms20subset/Message.go

@@ -47,4 +47,7 @@ type Message interface {
 	// Typical values returned by this method include
 	// jms20subset.DeliveryMode_PERSISTENT and jms20subset.DeliveryMode_NON_PERSISTENT
 	GetJMSDeliveryMode() int
+
+	SetStringProperty(name string, value string) JMSException
+	GetStringProperty(name string) *string
 }

messageproperties_test.go

@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) IBM Corporation 2021
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package main
+
+import (
+	"testing"
+
+	"github.com/ibm-messaging/mq-golang-jms20/jms20subset"
+	"github.com/ibm-messaging/mq-golang-jms20/mqjms"
+	"github.com/stretchr/testify/assert"
+)
+
+/*
+ * mq-golang: SetMP, DltMP, InqMP
+ * https://github.com/ibm-messaging/mq-golang/blob/95e9b8b09a1fc167747de7d066c49adb86e14dda/ibmmq/mqi.go#L1080
+ *
+ * mq-golang sample application to set properties
+ * https://github.com/ibm-messaging/mq-golang/blob/master/samples/amqsprop.go#L49
+ *
+ * JMS: SetStringProperty, GetStringProperty,
+ * https://github.com/eclipse-ee4j/messaging/blob/master/api/src/main/java/jakarta/jms/Message.java#L1119
+ *
+ * JMS: PropertyExists, ClearProperties, GetPropertyNames
+ */
+
+/*
+ * Test the creation of a text message with a string property.
+ */
+func TestStringPropertyTextMsg(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and applicationApiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	// Create a TextMessage and check that we can populate it
+	msgBody := "RequestMsg"
+	txtMsg := context.CreateTextMessage()
+	txtMsg.SetText(msgBody)
+
+	propName := "myProperty"
+	propValue := "myValue"
+
+	// Test the empty value before the property is set.
+	// TODO - it would be nicer if this was nil rather than empty string, however it
+	//   doesn't look like that is supported by the mq-golang library itself.
+	assert.Equal(t, "", *txtMsg.GetStringProperty(propName))
+
+	// Test the ability to set properties before the message is sent.
+	retErr := txtMsg.SetStringProperty(propName, propValue)
+	assert.Nil(t, retErr)
+	assert.Equal(t, propValue, *txtMsg.GetStringProperty(propName))
+	assert.Equal(t, msgBody, *txtMsg.GetText())
+
+	// Set up objects for send/receive
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	consumer, errCons := context.CreateConsumer(queue)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+	assert.Nil(t, errCons)
+
+	// Now send the message and get it back again, to check that it roundtripped.
+	errSend := context.CreateProducer().SetTimeToLive(10000).Send(queue, txtMsg)
+	assert.Nil(t, errSend)
+
+	rcvMsg, errRvc := consumer.ReceiveNoWait()
+	assert.Nil(t, errRvc)
+	assert.NotNil(t, rcvMsg)
+
+	switch msg := rcvMsg.(type) {
+	case jms20subset.TextMessage:
+		assert.Equal(t, msgBody, *msg.GetText())
+	default:
+		assert.Fail(t, "Got something other than a text message")
+	}
+
+	// Check property is available on received message.
+	assert.Equal(t, propValue, *rcvMsg.GetStringProperty(propName))
+
+}
+
+/*
+ * Test send and receive of a text message with a string property and no content.
+ */
+func TestStringPropertyTextMessageNilBody(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and applicationApiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	// Create a TextMessage, and check it has nil content.
+	msg := context.CreateTextMessage()
+	assert.Nil(t, msg.GetText())
+
+	propName := "myProperty2"
+	propValue := "myValue2"
+	retErr := msg.SetStringProperty(propName, propValue)
+	assert.Nil(t, retErr)
+
+	// Now send the message and get it back again, to check that it roundtripped.
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	errSend := context.CreateProducer().SetTimeToLive(10000).Send(queue, msg)
+	assert.Nil(t, errSend)
+
+	consumer, errCons := context.CreateConsumer(queue)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+	assert.Nil(t, errCons)
+
+	rcvMsg, errRvc := consumer.ReceiveNoWait()
+	assert.Nil(t, errRvc)
+	assert.NotNil(t, rcvMsg)
+
+	switch msg := rcvMsg.(type) {
+	case jms20subset.TextMessage:
+		assert.Nil(t, msg.GetText())
+	default:
+		assert.Fail(t, "Got something other than a text message")
+	}
+
+	// Check property is available on received message.
+	assert.Equal(t, propValue, *rcvMsg.GetStringProperty(propName))
+
+}
+
+/*
+ * Test the behaviour for send/receive of a text message with an empty string
+ * body. It's difficult to distinguish nil and empty string so we are expecting
+ * that the received message will contain a nil body.
+ */
+func TestStringPropertyTextMessageEmptyBody(t *testing.T) {
+
+	// Loads CF parameters from connection_info.json and applicationApiKey.json in the Downloads directory
+	cf, cfErr := mqjms.CreateConnectionFactoryFromDefaultJSONFiles()
+	assert.Nil(t, cfErr)
+
+	// Creates a connection to the queue manager, using defer to close it automatically
+	// at the end of the function (if it was created successfully)
+	context, ctxErr := cf.CreateContext()
+	assert.Nil(t, ctxErr)
+	if context != nil {
+		defer context.Close()
+	}
+
+	// Create a TextMessage
+	msg := context.CreateTextMessageWithString("")
+	assert.Equal(t, "", *msg.GetText())
+
+	propAName := "myPropertyA"
+	propAValue := "myValueA"
+	retErr := msg.SetStringProperty(propAName, propAValue)
+	assert.Nil(t, retErr)
+
+	propBName := "myPropertyB"
+	propBValue := "myValueB"
+	retErr = msg.SetStringProperty(propBName, propBValue)
+	assert.Nil(t, retErr)
+
+	// Now send the message and get it back again.
+	queue := context.CreateQueue("DEV.QUEUE.1")
+	errSend := context.CreateProducer().Send(queue, msg)
+	assert.Nil(t, errSend)
+
+	consumer, errCons := context.CreateConsumer(queue)
+	assert.Nil(t, errCons)
+	if consumer != nil {
+		defer consumer.Close()
+	}
+
+	rcvMsg, errRvc := consumer.ReceiveNoWait()
+	assert.Nil(t, errRvc)
+	assert.NotNil(t, rcvMsg)
+
+	switch msg := rcvMsg.(type) {
+	case jms20subset.TextMessage:
+
+		// It's difficult to distinguish between empty string and no string (nil)
+		// so we settle for giving back a nil, so that messages containing empty
+		// string are equivalent to messages containing no string at all.
+		assert.Nil(t, msg.GetText())
+	default:
+		assert.Fail(t, "Got something other than a text message")
+	}
+
+	// Check property is available on received message.
+	assert.Equal(t, propAValue, *rcvMsg.GetStringProperty(propAName))
+	assert.Equal(t, propBValue, *rcvMsg.GetStringProperty(propBName))
+
+}

mqjms/ConsumerImpl.go

@@ -81,6 +81,12 @@ func (consumer ConsumerImpl) receiveInternal(gmo *ibmmq.MQGMO) (jms20subset.Mess
 	gmo.Options |= syncpointSetting
 	gmo.Options |= ibmmq.MQGMO_FAIL_IF_QUIESCING
 
+	// Include the message properties in the msgHandle
+	gmo.Options |= ibmmq.MQGMO_PROPERTIES_IN_HANDLE
+	cmho := ibmmq.NewMQCMHO()
+	thisMsgHandle, _ := consumer.ctx.qMgr.CrtMH(cmho)
+	gmo.MsgHandle = thisMsgHandle
+
 	// Apply the selector if one has been specified in the Consumer
 	err := applySelector(consumer.selector, getmqmd, gmo)
 	if err != nil {
@@ -106,8 +112,11 @@ func (consumer ConsumerImpl) receiveInternal(gmo *ibmmq.MQGMO) (jms20subset.Mess
 			}
 
 			msg = &TextMessageImpl{
-				bodyStr:     msgBodyStr,
-				MessageImpl: MessageImpl{mqmd: getmqmd},
+				bodyStr: msgBodyStr,
+				MessageImpl: MessageImpl{
+					mqmd:      getmqmd,
+					msgHandle: &thisMsgHandle,
+				},
 			}
 
 		} else {
@@ -120,8 +129,11 @@ func (consumer ConsumerImpl) receiveInternal(gmo *ibmmq.MQGMO) (jms20subset.Mess
 
 			// Not a string, so fall back to BytesMessage
 			msg = &BytesMessageImpl{
-				bodyBytes:   &trimmedBuffer,
-				MessageImpl: MessageImpl{mqmd: getmqmd},
+				bodyBytes: &trimmedBuffer,
+				MessageImpl: MessageImpl{
+					mqmd:      getmqmd,
+					msgHandle: &thisMsgHandle,
+				},
 			}
 		}
 

mqjms/ContextImpl.go

@@ -114,27 +114,71 @@ func (ctx ContextImpl) CreateConsumerWithSelector(dest jms20subset.Destination,
 
 // CreateTextMessage is a JMS standard mechanism for creating a TextMessage.
 func (ctx ContextImpl) CreateTextMessage() jms20subset.TextMessage {
-	return &TextMessageImpl{}
+
+	var bodyStr *string
+	thisMsgHandle := createMsgHandle(ctx.qMgr)
+
+	return &TextMessageImpl{
+		bodyStr: bodyStr,
+		MessageImpl: MessageImpl{
+			msgHandle: &thisMsgHandle,
+		},
+	}
+}
+
+// createMsgHandle creates a new message handle object that can be used to
+// store and retrieve message properties.
+func createMsgHandle(qMgr ibmmq.MQQueueManager) ibmmq.MQMessageHandle {
+
+	// TODO - error handling on CrtMH
+	cmho := ibmmq.NewMQCMHO()
+	thisMsgHandle, _ := qMgr.CrtMH(cmho)
+
+	return thisMsgHandle
+
 }
 
 // CreateTextMessageWithString is a JMS standard mechanism for creating a TextMessage
 // and initialise it with the chosen text string.
 func (ctx ContextImpl) CreateTextMessageWithString(txt string) jms20subset.TextMessage {
-	msg := TextMessageImpl{}
-	msg.SetText(txt)
-	return &msg
+
+	thisMsgHandle := createMsgHandle(ctx.qMgr)
+
+	msg := &TextMessageImpl{
+		bodyStr: &txt,
+		MessageImpl: MessageImpl{
+			msgHandle: &thisMsgHandle,
+		},
+	}
+
+	return msg
 }
 
 // CreateBytesMessage is a JMS standard mechanism for creating a BytesMessage.
 func (ctx ContextImpl) CreateBytesMessage() jms20subset.BytesMessage {
-	return &BytesMessageImpl{}
+
+	var thisBodyBytes *[]byte
+	thisMsgHandle := createMsgHandle(ctx.qMgr)
+
+	return &BytesMessageImpl{
+		bodyBytes: thisBodyBytes,
+		MessageImpl: MessageImpl{
+			msgHandle: &thisMsgHandle,
+		},
+	}
 }
 
 // CreateBytesMessageWithBytes is a JMS standard mechanism for creating a BytesMessage.
 func (ctx ContextImpl) CreateBytesMessageWithBytes(bytes []byte) jms20subset.BytesMessage {
-	msg := BytesMessageImpl{}
-	msg.WriteBytes(bytes)
-	return &msg
+
+	thisMsgHandle := createMsgHandle(ctx.qMgr)
+
+	return &BytesMessageImpl{
+		bodyBytes: &bytes,
+		MessageImpl: MessageImpl{
+			msgHandle: &thisMsgHandle,
+		},
+	}
 }
 
 // Commit confirms all messages that were sent under this transaction.