Add MQSET implementation

Author: ibmmqmet

CHANGELOG.md

@@ -7,7 +7,8 @@
 * Update MQI header files for MQ V9.1.1 and give more platform variations
 * Add support for MQSTAT and MQSUBRQ functions
 * Add support and sample for Message Property functions
-* Add InqMap as alternative (simpler) MQINQ operation
+* Add InqMap as alternative (simpler) MQINQ operation. Inq() should be considered deprecated
+* Add support for MQSET function
 
 ## November 2018 - v3.1.0
 * Added functions to mqmetric to issue DISPLAY QSTATUS for additional stats

README.md

@@ -123,12 +123,10 @@ At this point, you should have a compiled copy of the program in `$GOPATH/bin`.
 
 ## Limitations
 
-Not all of the MQI verbs are available through the `ibmmq` package. This
-implementation concentrates on the core API calls needed to put and get messages.
+Almost all of the MQI verbs are now available through the `ibmmq` package.
 Currently unavailable verbs include:
 
-* MQSET
-* MQCB
+* MQCB/MQCTL
 
 There are also no structure handlers for message headers such as MQRFH2 or MQDLH.
 

ibmmq/mqi.go

@@ -598,9 +598,9 @@ how long each field in that buffer will be.
 The caller passes in how many integer selectors are expected to be
 returned, as well as the maximum length of the char buffer to be returned
 
-This function is a direct mapping of the MQI C function. It should be considered
+Deprecated: This function is a direct mapping of the MQI C function. It should be considered
 deprecated. In preference, use the InqMap function which provides a more convenient
-API.
+API. In a future version of this package, Inq will be replaced by InqMap
 */
 func (object MQObject) Inq(goSelectors []int32, intAttrCount int, charAttrLen int) ([]int32,
 	[]byte, error) {
@@ -656,6 +656,8 @@ func (object MQObject) Inq(goSelectors []int32, intAttrCount int, charAttrLen in
  * and the return value consists of a map whose elements are
  * a) accessed via the selector
  * b) varying datatype (integer, string, string array) based on the selector
+ * In a future breaking update, this function will become the default Inq()
+ * implementation.
  */
 func (object MQObject) InqMap(goSelectors []int32) (map[int32]interface{}, error) {
 	var mqrc C.MQLONG
@@ -701,7 +703,7 @@ func (object MQObject) InqMap(goSelectors []int32) (map[int32]interface{}, error
 		return nil, &mqreturn
 	}
 
-  // Create a map of the selectors to the returned values
+	// Create a map of the selectors to the returned values
 	returnedMap := make(map[int32]interface{})
 
 	// Get access to the returned character data
@@ -736,7 +738,7 @@ func (object MQObject) InqMap(goSelectors []int32) (map[int32]interface{}, error
 					charLength = C.MQ_OBJECT_NAME_LENGTH
 					names := make([]string, c)
 					for j := 0; j < c; j++ {
-						name := string(goCharAttrs[charOffset:charOffset+charLength])
+						name := string(goCharAttrs[charOffset : charOffset+charLength])
 						idx := strings.IndexByte(name, 0)
 						if idx != -1 {
 							name = name[0:idx]
@@ -750,7 +752,7 @@ func (object MQObject) InqMap(goSelectors []int32) (map[int32]interface{}, error
 				}
 			} else {
 				charLength = getAttrLength(s)
-				name := string(goCharAttrs[charOffset:charOffset+charLength])
+				name := string(goCharAttrs[charOffset : charOffset+charLength])
 				idx := strings.IndexByte(name, 0)
 				if idx != -1 {
 					name = name[0:idx]
@@ -765,6 +767,108 @@ func (object MQObject) InqMap(goSelectors []int32) (map[int32]interface{}, error
 	return returnedMap, nil
 }
 
+/*
+ * Set is the function that wraps MQSET. The single parameter is a map whose
+ * elements contain an MQIA/MQCA selector with either a string or an int32 for
+ * the value.
+ */
+func (object MQObject) Set(goSelectors map[int32]interface{}) error {
+	var mqrc C.MQLONG
+	var mqcc C.MQLONG
+
+	var charAttrs []byte
+	var charAttrsPtr C.PMQCHAR
+	var intAttrs []int32
+	var intAttrsPtr C.PMQLONG
+	var charOffset int
+	var charLength int
+
+	// Pass through the map twice. First time lets us
+	// create an array of selector names from map keys which is then
+	// used to calculate the character buffer that's needed
+	selectors := make([]int32, len(goSelectors))
+	i := 0
+	for k, _ := range goSelectors {
+		selectors[i] = k
+		i++
+	}
+
+	intAttrCount, _, charAttrLen := getAttrInfo(selectors)
+
+	// Create the areas to be used for the separate char and int values
+	if intAttrCount > 0 {
+		intAttrs = make([]int32, intAttrCount)
+		intAttrsPtr = (C.PMQLONG)(unsafe.Pointer(&intAttrs[0]))
+	} else {
+		intAttrsPtr = nil
+	}
+
+	if charAttrLen > 0 {
+		charAttrs = make([]byte, charAttrLen)
+		charAttrsPtr = (C.PMQCHAR)(unsafe.Pointer(&charAttrs[0]))
+	} else {
+		charAttrsPtr = nil
+	}
+
+	// Walk through the map a second time
+	charOffset = 0
+	intAttr := 0
+	for i := 0; i < len(selectors); i++ {
+		s := selectors[i]
+		if s >= C.MQCA_FIRST && s <= C.MQCA_LAST {
+			// The character processing is a bit OTT since there is in reality
+			// only a single attribute that can ever be SET. But a general purpose
+			// function looks more like the MQINQ operation
+			v := goSelectors[s].(string)
+			charLength = getAttrLength(s)
+			vBytes := []byte(v)
+			b := byte(0)
+			for j := 0; j < charLength; j++ {
+				if j < len(vBytes) {
+					b = vBytes[j]
+				} else {
+					b = 0
+				}
+				charAttrs[charOffset+j] = b
+			}
+			charOffset += charLength
+		} else if s >= C.MQIA_FIRST && s <= C.MQIA_LAST {
+			vv := int32(0)
+			v := goSelectors[s]
+			// Force the returned value from the map to be int32 because we
+			// can't check it at compile time.
+			if _,ok := v.(int32);ok {
+				vv = v.(int32)
+			} else if _,ok := v.(int);ok {
+				vv = int32(v.(int))
+			}
+			intAttrs[intAttr] = vv
+			intAttr++
+		}
+	}
+
+	// Pass in the selectors
+	C.MQSET(object.qMgr.hConn, object.hObj,
+		C.MQLONG(len(selectors)),
+		C.PMQLONG(unsafe.Pointer(&selectors[0])),
+		C.MQLONG(intAttrCount),
+		intAttrsPtr,
+		C.MQLONG(charAttrLen),
+		charAttrsPtr,
+		&mqcc, &mqrc)
+
+	mqreturn := MQReturn{MQCC: int32(mqcc),
+		MQRC: int32(mqrc),
+		verb: "MQSET",
+	}
+
+	if mqcc != C.MQCC_OK {
+		return &mqreturn
+	}
+
+	return nil
+}
+
 /*********** Message Handles and Properties  ****************/
 
 /*

ibmmq/mqiattrs.go

@@ -64,7 +64,7 @@ var mqInqLength = map[int32]int32{
 	C.MQCA_LU_NAME:               C.MQ_LU_NAME_LENGTH,
 	C.MQCA_NAMELIST_DESC:         C.MQ_NAMELIST_DESC_LENGTH,
 	C.MQCA_NAMELIST_NAME:         C.MQ_NAMELIST_NAME_LENGTH,
-	C.MQCA_NAMES:                 C.MQ_OBJECT_NAME_LENGTH * 256, // TODO: split these out
+	C.MQCA_NAMES:                 C.MQ_OBJECT_NAME_LENGTH * 256, // Maximum length to allocate
 	C.MQCA_PARENT:                C.MQ_Q_MGR_NAME_LENGTH,
 	C.MQCA_PROCESS_DESC:          C.MQ_PROCESS_DESC_LENGTH,
 	C.MQCA_PROCESS_NAME:          C.MQ_PROCESS_NAME_LENGTH,

samples/amqsinq.go

@@ -51,11 +51,11 @@ func inquire(obj ibmmq.MQObject, selectors []int32) {
 		fmt.Printf("----------- %s ----------\n", obj.Name)
 		for s, v := range values {
 			// Having got the values, print the selector number and name, along with the value
-			ss := ibmmq.MQItoString("CA",int(s))
+			ss := ibmmq.MQItoString("CA", int(s))
 			if ss == "" {
-				ss = ibmmq.MQItoString("IA",int(s))
+				ss = ibmmq.MQItoString("IA", int(s))
 			}
-			fmt.Printf("%-4d %-32.32s\t'%v'\n", s, ss,v)
+			fmt.Printf("%-4d %-32.32s\t'%v'\n", s, ss, v)
 		}
 	}
 }
@@ -142,7 +142,6 @@ func main() {
 		}
 	}
 
-
 	// Open of another object - a namelist. This has the ability to extract
 	// the list of queues it refers to.
 	if err == nil {

samples/amqsset.go

@@ -0,0 +1,126 @@
+/*
+ * This is an example of a Go program to set some attributes of an IBM MQ
+ * queue through the MQSET verb. The attributes that can be set are limited;
+ * those limitations are described in the MQSET documentation.
+ *
+ * The queue and queue manager name can be given as parameters on the
+ * command line. Defaults are coded in the program.
+ *
+ *
+ */
+package main
+
+/*
+  Copyright (c) IBM Corporation 2018
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the license.
+
+   Contributors:
+     Mark Taylor - Initial Contribution
+*/
+
+import (
+	"fmt"
+	"os"
+	"time"
+
+	"github.com/ibm-messaging/mq-golang/ibmmq"
+)
+
+var qMgrObject ibmmq.MQObject
+var object ibmmq.MQObject
+
+/*
+ * This is an example of how to call MQSET
+ */
+func setAttributes(obj ibmmq.MQObject) {
+  // Create a map containing the selectors and their values. The values must be
+	// a string (for MQCA attributes) or an int/int32 for the MQIA values.
+
+	// The value being set in the TRIGDATA attribute has a timestamp so you can
+	// see if it is successfully changed
+	selectors := map[int32]interface{}{
+		ibmmq.MQIA_INHIBIT_PUT: ibmmq.MQQA_PUT_INHIBITED,
+		ibmmq.MQIA_TRIGGER_CONTROL:     ibmmq.MQTC_ON,
+		ibmmq.MQCA_TRIGGER_DATA:    "Data set at " + time.Now().Format(time.RFC3339)}
+
+  // And call the MQI
+	err := obj.Set(selectors)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Println("Object attributes successfully changed")
+	}
+}
+
+func main() {
+	// The default queue manager and a queue to be used. These can be overridden on command line.
+	qMgrName := "QM1"
+	qName := "DEV.QUEUE.1"
+
+	qMgrConnected := false
+
+	fmt.Println("Sample AMQSSET.GO start")
+
+	// Get the object names from command line for overriding
+	// the defaults. Parameters are not required.
+	if len(os.Args) >= 2 {
+		qName = os.Args[1]
+	}
+
+	if len(os.Args) >= 3 {
+		qMgrName = os.Args[2]
+	}
+
+	qMgrObject, err := ibmmq.Conn(qMgrName)
+	if err != nil {
+		fmt.Println(err)
+	} else {
+		qMgrConnected = true
+		fmt.Printf("Connected to queue manager %s\n", qMgrName)
+	}
+
+	// Open a queue with the option to say it will be modified
+	if err == nil {
+		// Create the Object Descriptor that allows us to give the object name
+		mqod := ibmmq.NewMQOD()
+
+		// We have to say how we are going to use this object. The MQOO_SET flag
+		// says that it will be used for an MQSET operation
+		openOptions := ibmmq.MQOO_FAIL_IF_QUIESCING + ibmmq.MQOO_SET
+		mqod.ObjectType = ibmmq.MQOT_Q
+		mqod.ObjectName = qName
+
+		object, err = qMgrObject.Open(mqod, openOptions)
+		if err != nil {
+			fmt.Println(err)
+		} else {
+			setAttributes(object)
+			object.Close(0)
+		}
+	}
+
+	// Disconnect from the queue manager
+	if qMgrConnected {
+		err = qMgrObject.Disc()
+		fmt.Printf("Disconnected from queue manager %s\n", qMgrName)
+	}
+
+	// Exit with any return code extracted from the failing MQI call.
+	if err == nil {
+		os.Exit(0)
+	} else {
+		mqret := err.(*ibmmq.MQReturn)
+		os.Exit((int)(mqret.MQCC))
+	}
+}