client setup issue

[Yuvaneshwarran]

I first ran "go run ./server_test/" in terminal 1 produced

go run ./server_test/
Loading cert/key from cert.pem/key.pem
New Node Set: 2022-11-01T00:00:00Z
doing objects.
New Node Set: 2022-11-01T00:00:00Z
doing BaseDataType
doing root.

SERVER IS RUNNING VERSION 4 <<<<, Namespace index is 1
Started listening on [opc.tcp://0.0.0.0:4840 opc.tcp://localhost:4840 opc.tcp://yuvanesh-laptop:4840]
Successfully added custom node 'Tag1'

and then in terminal 2 i ran "go run ./read/"

go run ./read/
Status not OK: The node id refers to a node that does not exist in the server address space. StatusBadNodeIDUnknown (0x80340000)
exit status 1

CODE:
// ./server_test/server.go
package main

import (
"context"
"crypto/rsa"
"crypto/tls"
"flag"
"log"
"os"
"time"

"github.com/gopcua/opcua/debug"
"github.com/gopcua/opcua/id" // <-- ADD THIS IMPORT
"github.com/gopcua/opcua/server"
"github.com/gopcua/opcua/ua"

)

var (
// ... (your flags remain the same)
endpoint = flag.String("endpoint", "0.0.0.0", "OPC UA Endpoint URL")
port = flag.Int("port", 4840, "OPC UA Endpoint port")
certfile = flag.String("cert", "cert.pem", "Path to certificate file")
keyfile = flag.String("key", "key.pem", "Path to PEM Private Key file")
gencert = flag.Bool("gen-cert", true, "Generate a new certificate")
)

func main() {
// ... (all the setup code for flags, security, endpoints, and certs remains the same)
flag.BoolVar(&debug.Enable, "debug", false, "enable debug logging")
flag.Parse()
log.SetFlags(0)

var opts []server.Option

opts = append(opts,
	server.EnableSecurity("None", ua.MessageSecurityModeNone),
	server.EnableSecurity("Basic128Rsa15", ua.MessageSecurityModeSign),
	server.EnableSecurity("Basic128Rsa15", ua.MessageSecurityModeSignAndEncrypt),
	server.EnableSecurity("Basic256", ua.MessageSecurityModeSign),
	server.EnableSecurity("Basic256", ua.MessageSecurityModeSignAndEncrypt),
	server.EnableSecurity("Basic256Sha256", ua.MessageSecurityModeSignAndEncrypt),
	server.EnableSecurity("Basic256Sha256", ua.MessageSecurityModeSign),
	server.EnableSecurity("Aes128_Sha256_RsaOaep", ua.MessageSecurityModeSign),
	server.EnableSecurity("Aes128_Sha256_RsaOaep", ua.MessageSecurityModeSignAndEncrypt),
	server.EnableSecurity("Aes256_Sha256_RsaPss", ua.MessageSecurityModeSign),
	server.EnableSecurity("Aes256_Sha256_RsaPss", ua.MessageSecurityModeSignAndEncrypt),
)

opts = append(opts,
	server.EnableAuthMode(ua.UserTokenTypeAnonymous),
	server.EnableAuthMode(ua.UserTokenTypeUserName),
	server.EnableAuthMode(ua.UserTokenTypeCertificate),
	//      server.EnableAuthWithoutEncryption(), // Dangerous and not recommended, shown for illustration only
)
hostname, err := os.Hostname()
if err != nil {
	log.Fatalf("Error getting host name %v", err)
}

endpoints := []string{
	"localhost",
	hostname,
	*endpoint,
}

opts = append(opts,
	server.EndPoint(*endpoint, *port),
	server.EndPoint("localhost", *port),
	server.EndPoint(hostname, *port),
)

if *gencert {
	c, k, err := GenerateCert(endpoints, 4096, time.Minute*60*24*365*10)
	if err != nil {
		log.Fatalf("problem creating cert: %v", err)
	}
	err = os.WriteFile(*certfile, c, 0)
	if err != nil {
		log.Fatalf("problem writing cert: %v", err)
	}
	err = os.WriteFile(*keyfile, k, 0)
	if err != nil {
		log.Fatalf("problem writing key: %v", err)
	}

}

var cert []byte
if *gencert || (*certfile != "" && *keyfile != "") {
	log.Printf("Loading cert/key from %s/%s", *certfile, *keyfile)
	c, err := tls.LoadX509KeyPair(*certfile, *keyfile)
	if err != nil {
		log.Printf("Failed to load certificate: %s", err)
	} else {
		pk, ok := c.PrivateKey.(*rsa.PrivateKey)
		if !ok {
			log.Fatalf("Invalid private key")
		}
		cert = c.Certificate[0]
		opts = append(opts, server.PrivateKey(pk), server.Certificate(cert))
	}
}
s := server.New(opts...)

// =========================================================
// === STEP 1: CREATE THE NAMESPACE BEFORE s.Start() ===
// =========================================================
nodeNS := server.NewNodeNameSpace(s, "MyCompanyServer")
log.Printf(">>>> SERVER IS RUNNING VERSION 4 <<<<, Namespace index is %d", nodeNS.ID())

// Start the server
if err := s.Start(context.Background()); err != nil {
	log.Fatalf("Error starting server, exiting: %s", err)
}
defer s.Close()

// =========================================================
// === STEP 2: ADD NODES AND REFS AFTER s.Start() ===
// =========================================================
namespaceObjects := nodeNS.Objects()
myVar := nodeNS.AddNewVariableNode("Tag1", int32(100))
namespaceObjects.AddRef(myVar, id.HasComponent, true)

rootNS, _ := s.Namespace(0)
rootObjects := rootNS.Objects()
rootObjects.AddRef(namespaceObjects, id.HasComponent, true)

log.Println("Successfully added custom node 'Tag1'")
// =========================================================

select {}

}

// Copyright 2018-2020 opcua authors. All rights reserved.
// Use of this source code is governed by a MIT-style license that can be
// found in the LICENSE file.
// ./read/read.go
package main

import (
"context"
"errors"
"flag"
"io"
"log"
"time"

"github.com/gopcua/opcua"
"github.com/gopcua/opcua/debug"
"github.com/gopcua/opcua/ua"

)

func main() {
var (
endpoint = flag.String("endpoint", "opc.tcp://localhost:4840", "OPC UA Endpoint URL")
nodeID = flag.String("node", "", "NodeID to read")
)
flag.BoolVar(&debug.Enable, "debug", false, "enable debug logging")
flag.Parse()
log.SetFlags(0)

ctx := context.Background()

c, err := opcua.NewClient(*endpoint, opcua.SecurityMode(ua.MessageSecurityModeNone))
if err != nil {
	log.Fatal(err)
}
if err := c.Connect(ctx); err != nil {
	log.Fatal(err)
}
defer c.Close(ctx)

// =========================================================
// === ADD THIS DELAY TO TEST THE RACE CONDITION         ===
// =========================================================
log.Println("Connected. Waiting 2 seconds for server to initialize...")
time.Sleep(2 * time.Second)
// =========================================================

id, err := ua.ParseNodeID(*nodeID)
if err != nil {
	log.Fatalf("invalid node id: %v", err)
}

req := &ua.ReadRequest{
	MaxAge: 2000,
	NodesToRead: []*ua.ReadValueID{
		{NodeID: id},
	},
	TimestampsToReturn: ua.TimestampsToReturnBoth,
}

var resp *ua.ReadResponse
for {
	resp, err = c.Read(ctx, req)
	if err == nil {
		break
	}

	// Following switch contains known errors that can be retried by the user.
	// Best practice is to do it on read operations.
	switch {
	case err == io.EOF && c.State() != opcua.Closed:
		// has to be retried unless user closed the connection
		time.After(1 * time.Second)
		continue

	case errors.Is(err, ua.StatusBadSessionIDInvalid):
		// Session is not activated has to be retried. Session will be recreated internally.
		time.After(1 * time.Second)
		continue

	case errors.Is(err, ua.StatusBadSessionNotActivated):
		// Session is invalid has to be retried. Session will be recreated internally.
		time.After(1 * time.Second)
		continue

	case errors.Is(err, ua.StatusBadSecureChannelIDInvalid):
		// secure channel will be recreated internally.
		time.After(1 * time.Second)
		continue

	default:
		log.Fatalf("Read failed: %s", err)
	}
}

if resp != nil && resp.Results[0].Status != ua.StatusOK {
	log.Fatalf("Status not OK: %v", resp.Results[0].Status)
}

log.Printf("%#v", resp.Results[0].Value.Value())

}

Help me how to solve this error

[istyf]

Did you figure this one out? The default node name is set to be the empty string when the command line is configured in the client. So if you do not use the -node argument the client will not be able to find anything.

[Yuvaneshwarran]

Yea i figured it out
Thank you!!