How to write a known Extension Object

[jackchenjc]

Hope I'm not asking a dumb question.

There are some known structs generated in extobjs_gen.go, but how to create an ExtensionObject with NewExtensionObject for one of these types?

The ExtensionObjectTypeID function only accepts a value whose type has already been registered in the TypeRegistry, but I am not supposed to create a struct with matched type at this point.

There are two approaches that I can only come up with:
Take the KeyValuePair (i=14533) for example

1. This is a bad way. Create a large switch statement and turn the value (interface{}) into KeyValuePair struct by the given data type node id (i=14533) and then using the NewExtensionObject function.
2. Maybe we can leverage the TypeRegistry to get an instance of the matched type, but its types prop is private at the moment, there is no method for us to get the instance of the matched type.

I have searched for that and found this, which is specific to the custom extension object I guess?
I have also got this discussion, but still need some example to know how to implement it.

I would like to know if there is any example or suggestion about how to do that.
Any help would be appreciated!

[jackchenjc]

Hi @magiconair,

Do you have any thought or tip on this? Thanks.

[magiconair]

You can register a new extension object with the ua.RegisterExtensionObject method. See the udt example for details. https://github.com/gopcua/opcua/blob/main/examples/udt/udt.go#L95-L96

[jackchenjc]

Thanks @magiconair,

Sorry for the confusion if I didn't explain the question clearly.

I know that there is a RegisterExtensionObject method for us to register a new extension object (the known one or the custom one).
And I also notice that this library will register a bunch of extension objects here while initializing.
However, I have no idea how to access these registered types and get their struct instance to create an extension object.

Apparently, the ua.NewExtensionObject method needs the value whose type has already been registered in the TypeRegistry.
But just like I have mentioned in the question, I am not supposed to create a struct with matched type at this point.

Let's say we can get a json object from the client along with it's data type node id (take the KeyValuePair (i=14533) for example),
and we have to parse the json object to the go struct defined here, so that we can safely invoke the ua.NewExtensionObject to get *ExtensionObject.

Did you suggest that register all these extension objects from here by ourselves in a new TypeRegistry instance, so that we can invoke it's New method to get a new instance of the type with the given id?

Hope I have described the question clearly this time.
Thanks.

[magiconair]

I'm still not entirely sure what problem you are trying to solve. Right now all types you want to use and that should be decoded by gopcua have to be defined at compile time and then registered at runtime. This way the gopcua codec knows how to encode and decode an extension object of a given type.

My best guess is that you want to be able to read an arbitrary extension object without defining and registering it at compile time. This is currently not possible but I have been working on something like this.

Basically, there are type definitions stored on the server. The library would have to pull the ua.StructureDefinition of the type with the node id i=14533 from the server, create a Go type at runtime and decode into that.

Below is some code that I have written for our internal library which works but isn't fully tested. So this would be a starting point to be able to read any extension object from the server without defining them at compile time.

The Gopcua library would need some work to know that it should just generate an anonymous type since there is no/nil/none/zilch/zero type information in the OPC/UA binary protocol.

Does that help?

package schema

import (
	"fmt"
	"reflect"
	"time"

	"github.com/gopcua/opcua/ua"
	"github.com/pascaldekloe/name"
)

// Serializable checks if the Go struct t can be serialized into the UA type name.
func Serializable(t reflect.Type, id string, types map[string]*ua.StructureDefinition) error {
	uatyp, err := uaType(id, types)
	if err != nil {
		return err
	}
	uadef, godef := GoString(uatyp), GoString(anonType(t))
	if uadef != godef {
		return fmt.Errorf(`schema: Go type "%s" is not serializable into UA type "%s" (%s)`, godef, uadef, id)
	}
	return nil
}

// GoString returns a Go-syntax representation of the type of the value.
func GoString(t reflect.Type) string {
	return fmt.Sprintf("%T", reflect.New(t).Interface())
}

// anonType returns the struct without the name.
func anonType(t reflect.Type) reflect.Type {
	switch {
	// do not unpack time.Time
	case isTime(t):
		return t
	case t.Kind() == reflect.Slice:
		return reflect.SliceOf(anonType(t.Elem()))
	case t.Kind() == reflect.Struct:
		return reflect.StructOf(structFields(t))
	default:
		return t
	}
}

// structFields returns the fields of a struct as an array.
// it panics if t is not a struct.
func structFields(t reflect.Type) []reflect.StructField {
	if t.Kind() != reflect.Struct {
		panic(fmt.Sprintf("%s is not a struct", t.Name()))
	}
	var fields []reflect.StructField
	for i := 0; i < t.NumField(); i++ {
		f := t.Field(i)
		f.Name = goname.Format(f.Name, true)
		f.Type = anonType(f.Type)
		fields = append(fields, f)
	}
	return fields
}

// uaType returns an anonymous Go representation of the OPC/UA struct definition
// with the NodeID 'id'.
func uaType(id string, types map[string]*ua.StructureDefinition) (reflect.Type, error) {
	t := types[id]
	if t == nil {
		return nil, fmt.Errorf("schema: ua type %q not defined", id)
	}

	// we don't support structs with optional fields or unions (yet or maybe never)
	if t.StructureType != ua.StructureTypeStructure {
		return nil, fmt.Errorf("schema: ua type %q has unsupported structure type %s", id, t.StructureType)
	}

	var fields []reflect.StructField
	for _, f := range t.Fields {
		if len(f.ArrayDimensions) > 1 {
			return nil, fmt.Errorf("schema: ua type %s.%s is a multi-dimensional array: %v", id, f.Name, f.ArrayDimensions)
		}

		var elem reflect.Type
		switch f.DataType.String() {
		case "i=1":
			elem = reflect.TypeOf(bool(false))
		case "i=2":
			elem = reflect.TypeOf(int8(0))
		case "i=3":
			elem = reflect.TypeOf(uint8(0))
		case "i=4":
			elem = reflect.TypeOf(int16(0))
		case "i=5":
			elem = reflect.TypeOf(uint16(0))
		case "i=6":
			elem = reflect.TypeOf(int32(0))
		case "i=7":
			elem = reflect.TypeOf(uint32(0))
		case "i=8":
			elem = reflect.TypeOf(int64(0))
		case "i=9":
			elem = reflect.TypeOf(uint64(0))
		case "i=10":
			elem = reflect.TypeOf(float32(0))
		case "i=11":
			elem = reflect.TypeOf(float64(0))
		case "i=12":
			// todo(fs): maybe encode length constrained strings as []rune
			// if f.MaxStringLength > 0 {
			// 	elem = reflect.TypeOf(make([]rune, f.MaxStringLength))
			// }
			elem = reflect.TypeOf(string(""))
		case "i=13":
			elem = reflect.TypeOf(time.Time{})
		default:
			fid := f.DataType.String()
			ft := types[fid]
			switch {
			case ft.BaseDataType.String() == "i=22":
				var err error
				elem, err = uaType(fid, types)
				if err != nil {
					return nil, err
				}
			default:
				return nil, fmt.Errorf("schema: invalid data type %s", fid)
			}
		}

		typ := elem
		for rank := f.ValueRank; rank > 0; rank-- {
			typ = reflect.SliceOf(typ)
		}

		fname := name.CamelCase(f.Name, true)
		fields = append(fields, reflect.StructField{Name: fname, Type: typ})
	}

	return reflect.StructOf(fields), nil
}

func isTime(t reflect.Type) bool { return t == reflect.TypeOf(time.Time{}) }

[jackchenjc]

It's seems that we are not on the same page, but thanks again for your quick reply and the sample code!

Here are more contexts.
I'm working on a OPC UA client web application, and I want to write a value to a variable node whose data type is an extension Object.
The go backend will get an json object from the frontend (which has type map[string]interface{} as default), and I would like to turn this value into a Variant.
The question is, how may I do that?

Below is some minimal sample code, hope we can be in sync.

func WriteValue(id *ua.NodeID, input interface{}) error {
        // get the DataType of the node
	variableNode := c.Client.Node(id)
	dataTypeNodeId, err := getDataType(variableNode, ctx)
	if err != nil {
		return fmt.Errorf("failed to get the DataType of node id \"%s\": %w", nodeId, err)
	}

        // just assume that we identified that the data type node id is i=14533, which is a extension object
        // get the converted value to create new variant
        validValue := toExtensionObject(input)

        v, err := ua.NewVariant(validValue)
	if err != nil {
		log.Fatalf("invalid value: %v", err)
	}

	req := &ua.WriteRequest{
		NodesToWrite: []*ua.WriteValue{
			{
				NodeID:      id,
				AttributeID: ua.AttributeIDValue,
				Value: &ua.DataValue{
					EncodingMask: ua.DataValueValue,
					Value:        v,
				},
			},
		},
	}

        resp, err := c.Client.Write(ctx, req)
	if err != nil {
		return fmt.Errorf("write value to node id=%s failed, error: %v", nodeId, err)
	}
}
	
// toExtensionObject converts the given input value to ExtensionObject
func toExtensionObject(input interface{}) *ua.ExtensionObject {
	fmt.Printf("input value: %v, data type: %T", input, input)
	// How to convert the input value to KeyValuePair struct
	// so that I can get a valid ExtensionObject with correct TypeID?
	return ua.NewExtensionObject(input)
}

// standard output => input value: map[Key:test Value:123], data type: map[string]interface {}
// error => write value to node id=ns=3;i=1020 failed, error: opcua: unsupported type: map[string]interface {}

The toExtensionObject function should work if I can parse the input as a KeyValuePair struct, but I have no idea how to do that.

If I have made a mistake or written something incorrectly, please let me know.
Thanks again for your help!

[jackchenjc]

Hi @magiconair,

Would you have a look at this comment when you have time? Thanks a lot.

[jackchenjc]

Hi @alexbrdn,

Since I found this discussion, and I suppose that you are able to give me some advices about writing value to a node with ExtensionObject data type.
Would you have a look at this when you have time? Very appreciate.

[alexbrdn]

Hi @jackchenjc,

I am afraid I cannot be of much help here. I haven't had an opportunity to work with OPC-UA for quite a long time now and all that detailed knowledge has been purged from my brain's cache.

[magiconair]

We don’t have support for sending a generic map but that might be a good idea. I think there are two options:

1. Create an anonymous struct similar to the code I’ve shown above. This will show you how to create a type at runtime but you’d still have to walk the map.

2. You enhance the encoder to serialize a map. We would still have to register a type id.

I have to think about this