You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2023/07/28 09:36:08 UTC
[plc4x] 01/03: feat(plc4go/opcua): implement keepalive and connect event
This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit fb1a6d6bab895bb6083758a9456dea91b906a9af
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Jul 28 07:46:41 2023 +0200
feat(plc4go/opcua): implement keepalive and connect event
---
plc4go/internal/opcua/MessageCodec.go | 31 +++++-
plc4go/internal/opcua/SecureChannel.go | 182 ++++++++++++++++++++++++++++++---
2 files changed, 198 insertions(+), 15 deletions(-)
diff --git a/plc4go/internal/opcua/MessageCodec.go b/plc4go/internal/opcua/MessageCodec.go
index 82b45c155e..12e9bcc5b2 100644
--- a/plc4go/internal/opcua/MessageCodec.go
+++ b/plc4go/internal/opcua/MessageCodec.go
@@ -22,12 +22,14 @@ package opcua
import (
"context"
"encoding/binary"
+ "sync"
+ "time"
+
readWriteModel "github.com/apache/plc4x/plc4go/protocols/opcua/readwrite/model"
"github.com/apache/plc4x/plc4go/spi"
"github.com/apache/plc4x/plc4go/spi/default"
"github.com/apache/plc4x/plc4go/spi/options"
"github.com/apache/plc4x/plc4go/spi/transports"
- "sync"
"github.com/pkg/errors"
"github.com/rs/zerolog"
@@ -39,6 +41,9 @@ type MessageCodec struct {
channel *SecureChannel
+ connectEvent chan struct{}
+ connectTimeout time.Duration // TODO: do we need to have that in general, where to get that from
+
stateChange sync.Mutex
passLogToModel bool `ignore:"true"`
@@ -50,6 +55,8 @@ func NewMessageCodec(transportInstance transports.TransportInstance, channel *Se
customLogger := options.ExtractCustomLoggerOrDefaultToGlobal(_options...)
codec := &MessageCodec{
channel: channel,
+ connectEvent: make(chan struct{}),
+ connectTimeout: 5 * time.Second,
passLogToModel: passLoggerToModel,
log: customLogger,
}
@@ -71,9 +78,31 @@ func (m *MessageCodec) ConnectWithContext(ctx context.Context) error {
}
m.log.Debug().Msg("Opcua Driver running in ACTIVE mode.")
m.channel.onConnect(ctx, m)
+
+ connectTimeout := time.NewTimer(m.connectTimeout)
+ select {
+ case <-m.connectEvent:
+ m.log.Info().Msg("connected")
+ case <-connectTimeout.C:
+ return errors.Errorf("timeout after %s", m.connectTimeout)
+ }
return nil
}
+func (m *MessageCodec) fireConnected() {
+ close(m.connectEvent)
+}
+
+func (m *MessageCodec) Disconnect() error {
+ // TODO: implement me, e.g. wait group above or something
+ // TODO: on Disconecct
+ return m.DefaultCodec.Disconnect()
+}
+
+func (m *MessageCodec) fireDisconnected() {
+ // TODO: implement me, e.g. wait group above or something
+}
+
func (m *MessageCodec) Send(message spi.Message) error {
m.log.Trace().Msgf("Sending message\n%s", message)
// Cast the message to the correct type of struct
diff --git a/plc4go/internal/opcua/SecureChannel.go b/plc4go/internal/opcua/SecureChannel.go
index 127c497a06..3d909a50b7 100644
--- a/plc4go/internal/opcua/SecureChannel.go
+++ b/plc4go/internal/opcua/SecureChannel.go
@@ -23,23 +23,25 @@ import (
"bytes"
"context"
"encoding/binary"
- "github.com/apache/plc4x/plc4go/spi"
- "github.com/pkg/errors"
- "github.com/rs/zerolog"
- "golang.org/x/exp/slices"
+ "math"
"math/rand"
"net"
"net/url"
"regexp"
"strconv"
+ "sync"
"sync/atomic"
"time"
apiModel "github.com/apache/plc4x/plc4go/pkg/api/model"
readWriteModel "github.com/apache/plc4x/plc4go/protocols/opcua/readwrite/model"
+ "github.com/apache/plc4x/plc4go/spi"
"github.com/apache/plc4x/plc4go/spi/utils"
"github.com/dchest/uniuri"
+ "github.com/pkg/errors"
+ "github.com/rs/zerolog"
+ "golang.org/x/exp/slices"
)
const (
@@ -83,7 +85,7 @@ var (
APPLICATION_URI = readWriteModel.NewPascalString("urn:apache:plc4x:client")
PRODUCT_URI = readWriteModel.NewPascalString("urn:apache:plc4x:client")
APPLICATION_TEXT = readWriteModel.NewPascalString("OPCUA client for the Apache PLC4X:PLC4J project")
- DEFAULT_CONNECTION_LIFETIME = 36000000
+ DEFAULT_CONNECTION_LIFETIME = uint32(36000000)
)
type SecureChannel struct {
@@ -114,8 +116,10 @@ type SecureChannel struct {
authenticationToken readWriteModel.NodeIdTypeDefinition
codec *MessageCodec
channelTransactionManager *SecureChannelTransactionManager
- lifetime int
- keepAlive func()
+ lifetime uint32
+ keepAliveStateChange sync.Mutex
+ keepAliveIndicator atomic.Bool
+ keepAliveWg sync.WaitGroup
sendBufferSize int
maxMessageSize int
endpoints []string
@@ -226,8 +230,7 @@ func (s *SecureChannel) submit(ctx context.Context, codec *MessageCodec, errorDi
messageBuffer = opcuaResponse.GetMessage()
if !(s.senderSequenceNumber.Add(1) == (opcuaResponse.GetSequenceNumber())) {
s.log.Error().Msgf("Sequence number isn't as expected, we might have missed a packet. - %d != %d", s.senderSequenceNumber.Add(1), opcuaResponse.GetSequenceNumber())
- // TODO: where to dispatch the disconnect too
- // codec.fireDisconnected()
+ codec.fireDisconnected()
}
}
return true
@@ -654,8 +657,8 @@ func (s *SecureChannel) onConnectActivateSessionRequest(ctx context.Context, cod
}
// Send an event that connection setup is complete.
- s.keepAlive = s.createKeepAlive()
- // codec.fireConnected()// TODO: how to do that
+ s.keepAlive()
+ codec.fireConnected()
} else {
serviceFault := unknownExtensionObject.(readWriteModel.ServiceFault)
header := serviceFault.GetResponseHeader().(readWriteModel.ResponseHeader)
@@ -676,9 +679,160 @@ func (s *SecureChannel) getRequestHandle() uint32 {
return s.requestHandleGenerator.Add(1)
}
-func (s *SecureChannel) createKeepAlive() func() {
- //TODO big wip: look for keepalive method not sure how to implement that properly
- return nil
+func (s *SecureChannel) keepAlive() {
+ s.keepAliveStateChange.Lock()
+ defer s.keepAliveStateChange.Unlock()
+ if s.keepAliveIndicator.Load() {
+ s.log.Warn().Msg("keepalive already running")
+ return
+ }
+ s.keepAliveWg.Add(1)
+ go func() {
+ defer s.keepAliveWg.Done()
+ s.keepAliveIndicator.Store(true)
+ defer s.keepAliveIndicator.Store(false)
+ ctx := context.Background()
+ for s.codec == nil || s.codec.IsRunning() {
+ sleepTime := time.Duration(math.Ceil(float64(s.lifetime)*0.75)) * time.Millisecond
+ s.log.Trace().Dur("sleepTime", sleepTime).Msg("Sleeping")
+ time.Sleep(sleepTime)
+
+ transactionId := s.channelTransactionManager.getTransactionIdentifier()
+
+ requestHeader := readWriteModel.NewRequestHeader(readWriteModel.NewNodeId(s.authenticationToken),
+ s.getCurrentDateTime(),
+ 0, //RequestHandle
+ 0,
+ NULL_STRING,
+ REQUEST_TIMEOUT_LONG,
+ NULL_EXTENSION_OBJECT)
+
+ var openSecureChannelRequest readWriteModel.OpenSecureChannelRequest
+ if s.isEncrypted {
+ openSecureChannelRequest = readWriteModel.NewOpenSecureChannelRequest(
+ requestHeader,
+ VERSION,
+ readWriteModel.SecurityTokenRequestType_securityTokenRequestTypeIssue,
+ readWriteModel.MessageSecurityMode_messageSecurityModeSignAndEncrypt,
+ readWriteModel.NewPascalByteString(int32(len(s.clientNonce)), s.clientNonce),
+ uint32(s.lifetime))
+ } else {
+ openSecureChannelRequest = readWriteModel.NewOpenSecureChannelRequest(
+ requestHeader,
+ VERSION,
+ readWriteModel.SecurityTokenRequestType_securityTokenRequestTypeIssue,
+ readWriteModel.MessageSecurityMode_messageSecurityModeNone,
+ NULL_BYTE_STRING,
+ uint32(s.lifetime))
+ }
+ identifier, err := strconv.ParseUint(openSecureChannelRequest.GetIdentifier(), 10, 16)
+ if err != nil {
+ s.log.Error().Err(err).Msg("error parsing identifier")
+ return
+ }
+
+ expandedNodeId := readWriteModel.NewExpandedNodeId(false, //Namespace Uri Specified
+ false, //Server Index Specified
+ readWriteModel.NewNodeIdFourByte(0, uint16(identifier)),
+ nil,
+ nil)
+
+ extObject := readWriteModel.NewExtensionObject(
+ expandedNodeId,
+ nil,
+ openSecureChannelRequest,
+ false,
+ )
+
+ buffer := utils.NewWriteBufferByteBased(utils.WithByteOrderForByteBasedBuffer(binary.LittleEndian))
+ if err := extObject.SerializeWithWriteBuffer(ctx, buffer); err != nil {
+ s.log.Error().Err(err).Msg("error serializing")
+ return
+ }
+
+ openRequest := readWriteModel.NewOpcuaOpenRequest(
+ FINAL_CHUNK,
+ 0,
+ readWriteModel.NewPascalString(s.securityPolicy),
+ s.publicCertificate,
+ s.thumbprint,
+ transactionId,
+ transactionId,
+ buffer.GetBytes(),
+ )
+
+ var apu readWriteModel.OpcuaAPU
+
+ if s.isEncrypted {
+ apu, err = readWriteModel.OpcuaAPUParse(ctx, s.encryptionHandler.encodeMessage(openRequest, buffer.GetBytes()), false)
+ if err != nil {
+ s.log.Error().Err(err).Msg("error parsing")
+ return
+ }
+ } else {
+ apu = readWriteModel.NewOpcuaAPU(openRequest, false)
+ }
+
+ requestConsumer := func(transactionId int32) {
+ if err := s.codec.SendRequest(
+ ctx,
+ apu,
+ func(message spi.Message) bool {
+ opcuaAPU, ok := message.(readWriteModel.OpcuaAPUExactly)
+ if !ok {
+ s.log.Debug().Type("type", message).Msg("Not relevant")
+ return false
+ }
+ messagePDU := opcuaAPU.GetMessage()
+ openResponse, ok := messagePDU.(readWriteModel.OpcuaOpenResponseExactly)
+ if !ok {
+ s.log.Debug().Type("type", messagePDU).Msg("Not relevant")
+ return false
+ }
+ return openResponse.GetRequestId() == transactionId
+ },
+ func(message spi.Message) error {
+ opcuaAPU := message.(readWriteModel.OpcuaAPU)
+ messagePDU := opcuaAPU.GetMessage()
+ opcuaOpenResponse := messagePDU.(readWriteModel.OpcuaOpenResponse)
+ readBuffer := utils.NewReadBufferByteBased(opcuaOpenResponse.GetMessage(), utils.WithByteOrderForReadBufferByteBased(binary.LittleEndian))
+ extensionObject, err := readWriteModel.ExtensionObjectParseWithBuffer(ctx, readBuffer, false)
+ if err != nil {
+ return errors.Wrap(err, "error parsing")
+ }
+
+ if fault, ok := extensionObject.GetBody().(readWriteModel.ServiceFaultExactly); ok {
+ statusCode := fault.GetResponseHeader().(readWriteModel.ResponseHeader).GetServiceResult().GetStatusCode()
+ statusCodeByValue, _ := readWriteModel.OpcuaStatusCodeByValue(statusCode)
+ s.log.Error().Msgf("Failed to connect to opc ua server for the following reason:- %v, %v",
+ statusCode,
+ statusCodeByValue)
+ } else {
+ s.log.Debug().Msg("Got Secure Response Connection Response")
+ openSecureChannelResponse := extensionObject.GetBody().(readWriteModel.OpenSecureChannelResponse)
+ token := openSecureChannelResponse.GetSecurityToken().(readWriteModel.ChannelSecurityToken)
+ s.tokenId.Store(int32(token.GetTokenId())) // TODO: strange that int32 and uint32 missmatch
+ s.channelId.Store(int32(token.GetChannelId()))
+ s.lifetime = token.GetRevisedLifetime()
+ }
+ return nil
+ },
+ func(err error) error {
+ s.log.Debug().Err(err).Msg("error submitting")
+ return nil
+ },
+ REQUEST_TIMEOUT,
+ ); err != nil {
+ s.log.Debug().Err(err).Msg("a error")
+ }
+ }
+ s.log.Debug().Msgf("Submitting OpenSecureChannel with id of %d", transactionId)
+ if err := s.channelTransactionManager.submit(requestConsumer, transactionId); err != nil {
+ s.log.Debug().Err(err).Msg("error submitting")
+ }
+ }
+ }()
+ return
}
func (s *SecureChannel) selectEndpoint(sessionResponse readWriteModel.CreateSessionResponse) {