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 2021/10/01 15:31:25 UTC
[plc4x] branch develop updated: plc4go: remove struct reference
from public api part
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
The following commit(s) were added to refs/heads/develop by this push:
new 07349f6 plc4go: remove struct reference from public api part
07349f6 is described below
commit 07349f67343656c0890524d6162bd54f00d677be
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri Oct 1 17:31:18 2021 +0200
plc4go: remove struct reference from public api part
---
.../drivers/tests/manual_bacnet_PcapTest_test.go | 12 +--
.../discovery/hello_world_plc4go_knx_discovery.go | 28 +++---
.../hello_world_plc4go_knx_read_group_address.go | 20 ++--
.../hello_world_plc4go_knx_subscription.go | 18 ++--
plc4go/examples/read/hello_world_plc4go_read.go | 18 ++--
plc4go/examples/write/hello_world_plc4go_write.go | 16 ++--
plc4go/internal/plc4go/ads/Driver.go | 9 +-
plc4go/internal/plc4go/ads/Reader.go | 36 ++++----
plc4go/internal/plc4go/ads/Writer.go | 18 ++--
plc4go/internal/plc4go/bacnetip/Driver.go | 5 +-
plc4go/internal/plc4go/bacnetip/Subscriber.go | 3 +-
plc4go/internal/plc4go/eip/Connection.go | 8 +-
plc4go/internal/plc4go/eip/Driver.go | 9 +-
plc4go/internal/plc4go/eip/Reader.go | 18 ++--
plc4go/internal/plc4go/eip/Writer.go | 20 ++--
plc4go/internal/plc4go/knxnetip/Browser.go | 102 ++++++++++-----------
plc4go/internal/plc4go/knxnetip/Connection.go | 13 +--
plc4go/internal/plc4go/knxnetip/Discoverer.go | 10 +-
plc4go/internal/plc4go/knxnetip/Driver.go | 5 +-
plc4go/internal/plc4go/knxnetip/Reader.go | 2 +-
plc4go/internal/plc4go/knxnetip/Subscriber.go | 2 +-
plc4go/internal/plc4go/knxnetip/Writer.go | 5 +-
plc4go/internal/plc4go/modbus/Connection.go | 8 +-
plc4go/internal/plc4go/modbus/Driver.go | 5 +-
plc4go/internal/plc4go/modbus/Reader.go | 16 ++--
plc4go/internal/plc4go/modbus/Writer.go | 16 ++--
plc4go/internal/plc4go/s7/Connection.go | 10 +-
plc4go/internal/plc4go/s7/Driver.go | 9 +-
plc4go/internal/plc4go/s7/Reader.go | 10 +-
plc4go/internal/plc4go/s7/Writer.go | 12 +--
.../plc4go/spi/default/DefaultConnection.go | 74 ++++++++++++++-
.../interceptors/SingleItemRequestInterceptor.go | 90 +++++++++++++-----
.../plc4go/spi/model/DefaultPlcBrowseEvent.go} | 27 ++++--
...veryEvent.go => DefaultPlcBrowseQueryResult.go} | 45 ++++-----
.../spi/model/DefaultPlcBrowseRequestResult.go} | 22 +++--
.../plc4go/spi/model/DefaultPlcDiscoveryEvent.go | 35 ++++---
.../spi/model/DefaultPlcReadRequestResult.go} | 22 +++--
.../model/DefaultPlcSubscriptionRequestResult.go} | 22 +++--
.../spi/model/DefaultPlcUnsubscriptionRequest.go} | 18 ----
.../DefaultPlcUnsubscriptionRequestResult.go} | 22 +++--
.../spi/model/DefaultPlcUnsubscriptionResponse.go} | 17 +---
.../spi/model/DefaultPlcWriteRequestResult.go} | 22 +++--
.../plc4go/spi/testutils/DriverTestRunner.go | 22 ++---
.../plc4go/spi/testutils/ManualTestRunner.go | 18 ++--
plc4go/pkg/plc4go/connection.go | 40 +++-----
plc4go/pkg/plc4go/driverManager.go | 61 ++++++++----
plc4go/pkg/plc4go/model/plc_browse.go | 32 +++----
plc4go/pkg/plc4go/model/plc_discovery.go | 38 ++++----
plc4go/pkg/plc4go/model/plc_read.go | 8 +-
plc4go/pkg/plc4go/model/plc_subscription.go | 8 +-
plc4go/pkg/plc4go/model/plc_unsubscription.go | 10 +-
plc4go/pkg/plc4go/model/plc_write.go | 8 +-
52 files changed, 624 insertions(+), 500 deletions(-)
diff --git a/plc4go/cmd/main/drivers/tests/manual_bacnet_PcapTest_test.go b/plc4go/cmd/main/drivers/tests/manual_bacnet_PcapTest_test.go
index ea64b17..ee7d378 100644
--- a/plc4go/cmd/main/drivers/tests/manual_bacnet_PcapTest_test.go
+++ b/plc4go/cmd/main/drivers/tests/manual_bacnet_PcapTest_test.go
@@ -47,10 +47,10 @@ func Test(t *testing.T) {
driverManager.RegisterDriver(bacnetip.NewDriver())
driverManager.(spi.TransportAware).RegisterTransport(pcap.NewTransport())
result := <-driverManager.GetConnection("bacnet-ip:pcap://" + file + "?transport-type=udp")
- if result.Err != nil {
- panic(result.Err)
+ if result.GetErr() != nil {
+ panic(result.GetErr())
}
- connection := result.Connection
+ connection := result.GetConnection()
defer connection.Close()
build, err := connection.SubscriptionRequestBuilder().
AddEventQuery("furz", "*/*/*").
@@ -62,10 +62,10 @@ func Test(t *testing.T) {
panic(err)
}
requestResult := <-build.Execute()
- if requestResult.Err != nil {
- panic(requestResult.Err)
+ if requestResult.GetErr() != nil {
+ panic(requestResult.GetErr())
}
- log.Info().Msgf("got response %v", requestResult.Response)
+ log.Info().Msgf("got response %v", requestResult.GetResponse())
//time.Sleep(time.Hour)
}
diff --git a/plc4go/examples/knx/discovery/hello_world_plc4go_knx_discovery.go b/plc4go/examples/knx/discovery/hello_world_plc4go_knx_discovery.go
index 5607186..ed632f9 100644
--- a/plc4go/examples/knx/discovery/hello_world_plc4go_knx_discovery.go
+++ b/plc4go/examples/knx/discovery/hello_world_plc4go_knx_discovery.go
@@ -41,7 +41,7 @@ func main() {
if len(os.Args) < 2 {
// Try to auto-find KNX gateways via broadcast-message discovery
_ = driverManager.Discover(func(event model.PlcDiscoveryEvent) {
- connStr := event.ProtocolCode + "://" + event.TransportUrl.Host
+ connStr := event.GetProtocolCode() + "://" + event.GetTransportUrl().Host
log.Info().Str("connection string", connStr).Msg("Found KNX Gateway")
connectionStrings = append(connectionStrings, connStr)
@@ -60,12 +60,12 @@ func main() {
// Wait for the driver to connect (or not)
connectionResult := <-crc
- if connectionResult.Err != nil {
- log.Error().Msgf("error connecting to PLC: %s", connectionResult.Err.Error())
+ if connectionResult.GetErr() != nil {
+ log.Error().Msgf("error connecting to PLC: %s", connectionResult.GetErr().Error())
return
}
log.Info().Str("connection string", connStr).Msg("Connected")
- connection := connectionResult.Connection
+ connection := connectionResult.GetConnection()
defer connection.BlockingClose()
// Try to find all KNX devices on the current network
@@ -79,7 +79,7 @@ func main() {
return
}
brr := browseRequest.ExecuteWithInterceptor(func(result model.PlcBrowseEvent) bool {
- knxField := result.Result.Field
+ knxField := result.GetResult().GetField()
knxAddress := knxField.GetAddressString()
log.Info().Msgf("Inspecting detected Device at KNX Address: %s", knxAddress)
@@ -93,28 +93,28 @@ func main() {
}
brr := browseRequest.Execute()
browseResult := <-brr
- if browseResult.Err != nil {
- log.Error().Err(err).Msg("error executing the browse request for com-objects")
+ if browseResult.GetErr() != nil {
+ log.Error().Err(browseResult.GetErr()).Msg("error executing the browse request for com-objects")
return false
}
- for _, result := range browseResult.Response.GetQueryResults("comObjects") {
+ for _, result := range browseResult.GetResponse().GetQueryResults("comObjects") {
permissions := ""
- if result.Readable {
+ if result.IsReadable() {
permissions += "R"
} else {
permissions += " "
}
- if result.Writable {
+ if result.IsWritable() {
permissions += "W"
} else {
permissions += " "
}
- if result.Subscribable {
+ if result.IsSubscribable() {
permissions += "S"
} else {
permissions += " "
}
- log.Info().Msgf(" - %15s (%s) %s", result.Field.GetAddressString(), permissions, result.Name)
+ log.Info().Msgf(" - %15s (%s) %s", result.GetField().GetAddressString(), permissions, result.GetName())
}
readRequest, err := connection.ReadRequestBuilder().
@@ -129,11 +129,11 @@ func main() {
rrr := readRequest.Execute()
readRequestResult := <-rrr
- if readRequestResult.Err != nil {
+ if readRequestResult.GetErr() != nil {
log.Error().Msgf("Error executing read request for reading device identification information %s", knxAddress)
return false
}
- readResponse := readRequestResult.Response
+ readResponse := readRequestResult.GetResponse()
var programVersion []byte
if readResponse.GetResponseCode("applicationProgramVersion") == model.PlcResponseCode_OK {
programVersion = utils.PlcValueUint8ListToByteArray(readResponse.GetValue("applicationProgramVersion"))
diff --git a/plc4go/examples/knx/groupAddressRead/hello_world_plc4go_knx_read_group_address.go b/plc4go/examples/knx/groupAddressRead/hello_world_plc4go_knx_read_group_address.go
index a2c0b06..a95e85f 100644
--- a/plc4go/examples/knx/groupAddressRead/hello_world_plc4go_knx_read_group_address.go
+++ b/plc4go/examples/knx/groupAddressRead/hello_world_plc4go_knx_read_group_address.go
@@ -39,11 +39,11 @@ func main() {
// Wait for the driver to connect (or not)
connectionResult := <-crc
- if connectionResult.Err != nil {
- fmt.Printf("error connecting to PLC: %s", connectionResult.Err.Error())
+ if connectionResult.GetErr() != nil {
+ fmt.Printf("error connecting to PLC: %s", connectionResult.GetErr().Error())
return
}
- connection := connectionResult.Connection
+ connection := connectionResult.GetConnection()
// Make sure the connection is closed at the end
defer connection.BlockingClose()
@@ -54,7 +54,7 @@ func main() {
AddQuery("secondFlorTemperatures", "3/[2,3,4,6]/10:DPT_Value_Temp").
Build()
if err != nil {
- fmt.Printf("error preparing read-request: %s", connectionResult.Err.Error())
+ fmt.Printf("error preparing read-request: %s", connectionResult.GetErr().Error())
return
}
@@ -63,19 +63,19 @@ func main() {
// Wait for the response to finish
rrr := <-rrc
- if rrr.Err != nil {
- fmt.Printf("error executing read-request: %s", rrr.Err.Error())
+ if rrr.GetErr() != nil {
+ fmt.Printf("error executing read-request: %s", rrr.GetErr().Error())
return
}
// Do something with the response
- for _, fieldName := range rrr.Response.GetFieldNames() {
- if rrr.Response.GetResponseCode(fieldName) != model.PlcResponseCode_OK {
- fmt.Printf("error an non-ok return code for field %s: %s\n", fieldName, rrr.Response.GetResponseCode(fieldName).GetName())
+ for _, fieldName := range rrr.GetResponse().GetFieldNames() {
+ if rrr.GetResponse().GetResponseCode(fieldName) != model.PlcResponseCode_OK {
+ fmt.Printf("error an non-ok return code for field %s: %s\n", fieldName, rrr.GetResponse().GetResponseCode(fieldName).GetName())
continue
}
- value := rrr.Response.GetValue(fieldName)
+ value := rrr.GetResponse().GetValue(fieldName)
if value == nil {
fmt.Printf("Got nil for field %s\n", fieldName)
} else if value.GetStruct() != nil {
diff --git a/plc4go/examples/knx/subscribe/hello_world_plc4go_knx_subscription.go b/plc4go/examples/knx/subscribe/hello_world_plc4go_knx_subscription.go
index 50eb81d..ecf32ba 100644
--- a/plc4go/examples/knx/subscribe/hello_world_plc4go_knx_subscription.go
+++ b/plc4go/examples/knx/subscribe/hello_world_plc4go_knx_subscription.go
@@ -42,11 +42,11 @@ func main() {
// Wait for the driver to connect (or not)
connectionResult := <-crc
- if connectionResult.Err != nil {
- fmt.Printf("error connecting to PLC: %s", connectionResult.Err.Error())
+ if connectionResult.GetErr() != nil {
+ fmt.Printf("error connecting to PLC: %s", connectionResult.GetErr().Error())
return
}
- connection := connectionResult.Connection
+ connection := connectionResult.GetConnection()
// Make sure the connection is closed at the end
defer connection.BlockingClose()
@@ -96,22 +96,22 @@ func main() {
// Wait for the response to finish
rrr := <-rrc
- if rrr.Err != nil {
- fmt.Printf("error executing subscription-request: %s", rrr.Err.Error())
+ if rrr.GetErr() != nil {
+ fmt.Printf("error executing subscription-request: %s", rrr.GetErr().Error())
return
}
// Do something with the response
- for _, fieldName := range rrr.Response.GetFieldNames() {
- if rrr.Response.GetResponseCode(fieldName) != model.PlcResponseCode_OK {
- fmt.Printf("error an non-ok return code for field %s: %s\n", fieldName, rrr.Response.GetResponseCode(fieldName).GetName())
+ for _, fieldName := range rrr.GetResponse().GetFieldNames() {
+ if rrr.GetResponse().GetResponseCode(fieldName) != model.PlcResponseCode_OK {
+ fmt.Printf("error an non-ok return code for field %s: %s\n", fieldName, rrr.GetResponse().GetResponseCode(fieldName).GetName())
continue
}
}
time.Sleep(time.Minute * 5)
} else {
- fmt.Printf("error preparing subscription-request: %s", connectionResult.Err.Error())
+ fmt.Printf("error preparing subscription-request: %s", connectionResult.GetErr().Error())
return
}
}
diff --git a/plc4go/examples/read/hello_world_plc4go_read.go b/plc4go/examples/read/hello_world_plc4go_read.go
index 18c20c7..a0abb01 100644
--- a/plc4go/examples/read/hello_world_plc4go_read.go
+++ b/plc4go/examples/read/hello_world_plc4go_read.go
@@ -35,11 +35,11 @@ func main() {
// Wait for the driver to connect (or not)
connectionResult := <-crc
- if connectionResult.Err != nil {
- fmt.Printf("error connecting to PLC: %s", connectionResult.Err.Error())
+ if connectionResult.GetErr() != nil {
+ fmt.Printf("error connecting to PLC: %s", connectionResult.GetErr().Error())
return
}
- connection := connectionResult.Connection
+ connection := connectionResult.GetConnection()
// Make sure the connection is closed at the end
defer connection.BlockingClose()
@@ -49,7 +49,7 @@ func main() {
AddQuery("field", "holding-register:26:REAL").
Build()
if err != nil {
- fmt.Printf("error preparing read-request: %s", connectionResult.Err.Error())
+ fmt.Printf("error preparing read-request: %s", connectionResult.GetErr().Error())
return
}
@@ -58,17 +58,17 @@ func main() {
// Wait for the response to finish
rrr := <-rrc
- if rrr.Err != nil {
- fmt.Printf("error executing read-request: %s", rrr.Err.Error())
+ if rrr.GetErr() != nil {
+ fmt.Printf("error executing read-request: %s", rrr.GetErr().Error())
return
}
// Do something with the response
- if rrr.Response.GetResponseCode("field") != model.PlcResponseCode_OK {
- fmt.Printf("error an non-ok return code: %s", rrr.Response.GetResponseCode("field").GetName())
+ if rrr.GetResponse().GetResponseCode("field") != model.PlcResponseCode_OK {
+ fmt.Printf("error an non-ok return code: %s", rrr.GetResponse().GetResponseCode("field").GetName())
return
}
- value := rrr.Response.GetValue("field")
+ value := rrr.GetResponse().GetValue("field")
fmt.Printf("Got result %f", value.GetFloat32())
}
diff --git a/plc4go/examples/write/hello_world_plc4go_write.go b/plc4go/examples/write/hello_world_plc4go_write.go
index 4c2d3da..1ee1c7c 100644
--- a/plc4go/examples/write/hello_world_plc4go_write.go
+++ b/plc4go/examples/write/hello_world_plc4go_write.go
@@ -35,11 +35,11 @@ func main() {
// Wait for the driver to connect (or not)
connectionResult := <-crc
- if connectionResult.Err != nil {
- fmt.Printf("error connecting to PLC: %s", connectionResult.Err.Error())
+ if connectionResult.GetErr() != nil {
+ fmt.Printf("error connecting to PLC: %s", connectionResult.GetErr().Error())
return
}
- connection := connectionResult.Connection
+ connection := connectionResult.GetConnection()
// Make sure the connection is closed at the end
defer connection.BlockingClose()
@@ -49,7 +49,7 @@ func main() {
AddQuery("field", "holding-register:26:REAL", 2.7182818284).
Build()
if err != nil {
- fmt.Printf("error preparing read-request: %s", connectionResult.Err.Error())
+ fmt.Printf("error preparing read-request: %s", connectionResult.GetErr().Error())
return
}
@@ -58,13 +58,13 @@ func main() {
// Wait for the response to finish
wrr := <-wrc
- if wrr.Err != nil {
- fmt.Printf("error executing write-request: %s", wrr.Err.Error())
+ if wrr.GetErr() != nil {
+ fmt.Printf("error executing write-request: %s", wrr.GetErr().Error())
return
}
- if wrr.Response.GetResponseCode("field") != model.PlcResponseCode_OK {
- fmt.Printf("error an non-ok return code: %s", wrr.Response.GetResponseCode("field").GetName())
+ if wrr.GetResponse().GetResponseCode("field") != model.PlcResponseCode_OK {
+ fmt.Printf("error an non-ok return code: %s", wrr.GetResponse().GetResponseCode("field").GetName())
return
}
fmt.Print("Result: SUCCESS\n")
diff --git a/plc4go/internal/plc4go/ads/Driver.go b/plc4go/internal/plc4go/ads/Driver.go
index a45846e..1616b1e 100644
--- a/plc4go/internal/plc4go/ads/Driver.go
+++ b/plc4go/internal/plc4go/ads/Driver.go
@@ -21,6 +21,7 @@ package ads
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ _default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/pkg/plc4go"
apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
@@ -64,7 +65,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't find a transport for scheme %s", transportUrl.Scheme)
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
}()
return ch
}
@@ -75,7 +76,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
if err != nil {
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't create a transport instance for port %#v", options["defaultTcpPort"])
ch := make(chan plc4go.PlcConnectionConnectResult)
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
return ch
}
@@ -87,7 +88,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
if err != nil {
log.Error().Err(err).Msgf("Invalid options")
ch := make(chan plc4go.PlcConnectionConnectResult)
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "invalid configuration"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "invalid configuration"))
return ch
}
@@ -96,7 +97,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
if err != nil {
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "couldn't create connection"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "couldn't create connection"))
}()
return ch
}
diff --git a/plc4go/internal/plc4go/ads/Reader.go b/plc4go/internal/plc4go/ads/Reader.go
index 8fb4e04..e59ef29 100644
--- a/plc4go/internal/plc4go/ads/Reader.go
+++ b/plc4go/internal/plc4go/ads/Reader.go
@@ -72,7 +72,7 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
func (m *Reader) singleRead(readRequest model.PlcReadRequest, result chan model.PlcReadRequestResult) {
if len(readRequest.GetFieldNames()) != 1 {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.New("ads only supports single-item requests"),
@@ -86,7 +86,7 @@ func (m *Reader) singleRead(readRequest model.PlcReadRequest, result chan model.
if needsResolving(field) {
adsField, err := castToSymbolicPlcFieldFromPlcField(field)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -96,7 +96,7 @@ func (m *Reader) singleRead(readRequest model.PlcReadRequest, result chan model.
}
field, err = m.resolveField(adsField)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -107,7 +107,7 @@ func (m *Reader) singleRead(readRequest model.PlcReadRequest, result chan model.
}
adsField, err := castToDirectAdsFieldFromPlcField(field)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -158,7 +158,7 @@ func (m *Reader) multiRead(readRequest model.PlcReadRequest, result chan model.P
for _, fieldName := range readRequest.GetFieldNames() {
field, err := castToAdsFieldFromPlcField(readRequest.GetField(fieldName))
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "error casting field"),
@@ -206,7 +206,7 @@ func (m *Reader) multiRead(readRequest model.PlcReadRequest, result chan model.P
if needsResolving(field) {
adsField, err := castToSymbolicPlcFieldFromPlcField(field)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -216,7 +216,7 @@ func (m *Reader) multiRead(readRequest model.PlcReadRequest, result chan model.P
}
field, err = m.resolveField(adsField)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -227,7 +227,7 @@ func (m *Reader) multiRead(readRequest model.PlcReadRequest, result chan model.P
}
adsField, err := castToDirectAdsFieldFromPlcField(field)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -276,28 +276,28 @@ func (m *Reader) sendOverTheWire(userdata readWriteModel.AmsPacket, readRequest
readResponse, err := m.ToPlc4xReadResponse(*amsTcpPaket, readRequest)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
// TODO: should we return the error here?
return nil
}
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: readResponse,
}
return nil
},
func(err error) error {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "got timeout while waiting for response"),
}
return nil
},
time.Second*1); err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
@@ -340,14 +340,14 @@ func (m *Reader) resolveField(symbolicField SymbolicPlcField) (DirectPlcField, e
}()
// We wait synchronous for the resolution response before we can continue
response := <-result
- if response.Err != nil {
- log.Debug().Err(response.Err).Msg("Error during resolve")
- return DirectPlcField{}, response.Err
+ if response.GetErr() != nil {
+ log.Debug().Err(response.GetErr()).Msg("Error during resolve")
+ return DirectPlcField{}, response.GetErr()
}
- if response.Response.GetResponseCode("dummy") != model.PlcResponseCode_OK {
- return DirectPlcField{}, errors.Errorf("Got a response error %#v", response.Response.GetResponseCode("dummy"))
+ if response.GetResponse().GetResponseCode("dummy") != model.PlcResponseCode_OK {
+ return DirectPlcField{}, errors.Errorf("Got a response error %#v", response.GetResponse().GetResponseCode("dummy"))
}
- handle := response.Response.GetValue("dummy").GetUint32()
+ handle := response.GetResponse().GetValue("dummy").GetUint32()
log.Debug().Uint32("handle", handle).Str("symbolicAddress", symbolicField.SymbolicAddress).Msg("Resolved symbolic address")
directPlcField := DirectPlcField{
IndexGroup: uint32(readWriteModel.ReservedIndexGroups_ADSIGRP_SYM_VALBYHND),
diff --git a/plc4go/internal/plc4go/ads/Writer.go b/plc4go/internal/plc4go/ads/Writer.go
index 204e9c5..6216388 100644
--- a/plc4go/internal/plc4go/ads/Writer.go
+++ b/plc4go/internal/plc4go/ads/Writer.go
@@ -59,7 +59,7 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
go func() {
// If we are requesting only one field, use a
if len(writeRequest.GetFieldNames()) != 1 {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.New("ads only supports single-item requests"),
@@ -73,7 +73,7 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
if needsResolving(field) {
adsField, err := castToSymbolicPlcFieldFromPlcField(field)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -83,7 +83,7 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
}
field, err = m.reader.resolveField(adsField)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -94,7 +94,7 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
}
adsField, err := castToDirectAdsFieldFromPlcField(field)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -106,7 +106,7 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
value := writeRequest.GetValue(fieldName)
io := utils.NewLittleEndianWriteBufferByteBased()
if err := readWriteModel.DataItemSerialize(io, value, adsField.Datatype.DataFormatName(), adsField.StringLength); err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "error serializing value"),
@@ -135,7 +135,7 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
case SymbolicAdsStringField, SymbolicAdsField:
panic("we should never reach this point as symbols are resolved before")
default:
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.New("unsupported field type"),
@@ -172,12 +172,12 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
readResponse, err := m.ToPlc4xWriteResponse(amsTcpPaket, *responseAmsTcpPaket, writeRequest)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
} else {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: readResponse,
}
@@ -185,7 +185,7 @@ func (m *Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWrite
return nil
},
func(err error) error {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.New("got timeout while waiting for response"),
}
diff --git a/plc4go/internal/plc4go/bacnetip/Driver.go b/plc4go/internal/plc4go/bacnetip/Driver.go
index 0ed8beb..77cb573 100644
--- a/plc4go/internal/plc4go/bacnetip/Driver.go
+++ b/plc4go/internal/plc4go/bacnetip/Driver.go
@@ -21,6 +21,7 @@ package bacnetip
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ _default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/pkg/plc4go"
apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
@@ -68,7 +69,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't find a transport for scheme %s", transportUrl.Scheme)
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
}()
return ch
}
@@ -80,7 +81,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't create a transport instance for port %#v", options["defaultUdpPort"])
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
}()
return ch
}
diff --git a/plc4go/internal/plc4go/bacnetip/Subscriber.go b/plc4go/internal/plc4go/bacnetip/Subscriber.go
index e2f6023..5a9a1ff 100644
--- a/plc4go/internal/plc4go/bacnetip/Subscriber.go
+++ b/plc4go/internal/plc4go/bacnetip/Subscriber.go
@@ -21,6 +21,7 @@ package bacnetip
import (
internalModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
+ plc4goModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
)
@@ -51,7 +52,7 @@ func (m *Subscriber) Subscribe(subscriptionRequest apiModel.PlcSubscriptionReque
responseCodes[fieldName] = apiModel.PlcResponseCode_OK
}
- result <- apiModel.PlcSubscriptionRequestResult{
+ result <- &plc4goModel.DefaultPlcSubscriptionRequestResult{
Request: subscriptionRequest,
Response: internalModel.NewDefaultPlcSubscriptionResponse(subscriptionRequest, responseCodes),
Err: nil,
diff --git a/plc4go/internal/plc4go/eip/Connection.go b/plc4go/internal/plc4go/eip/Connection.go
index 7f314dc..53ca872 100644
--- a/plc4go/internal/plc4go/eip/Connection.go
+++ b/plc4go/internal/plc4go/eip/Connection.go
@@ -70,7 +70,7 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
go func() {
err := m.messageCodec.Connect()
if err != nil {
- ch <- plc4go.NewPlcConnectionConnectResult(m, err)
+ ch <- _default.NewDefaultPlcConnectionConnectResult(m, err)
}
// For testing purposes we can skip the waiting for a complete connection
@@ -79,7 +79,7 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
log.Warn().Msg("Connection used in an unsafe way. !!!DON'T USE IN PRODUCTION!!!")
// Here we write directly and don't wait till the connection is "really" connected
// Note: we can't use fireConnected here as it's guarded against m.driverContext.awaitSetupComplete
- ch <- plc4go.NewPlcConnectionConnectResult(m, err)
+ ch <- _default.NewDefaultPlcConnectionConnectResult(m, err)
m.SetConnected(true)
return
}
@@ -153,7 +153,7 @@ func (m *Connection) setupConnection(ch chan plc4go.PlcConnectionConnectResult)
func (m *Connection) fireConnectionError(err error, ch chan<- plc4go.PlcConnectionConnectResult) {
if m.driverContext.awaitSetupComplete {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "Error during connection"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Error during connection"))
} else {
log.Error().Err(err).Msg("awaitSetupComplete set to false and we got a error during connect")
}
@@ -161,7 +161,7 @@ func (m *Connection) fireConnectionError(err error, ch chan<- plc4go.PlcConnecti
func (m *Connection) fireConnected(ch chan<- plc4go.PlcConnectionConnectResult) {
if m.driverContext.awaitSetupComplete {
- ch <- plc4go.NewPlcConnectionConnectResult(m, nil)
+ ch <- _default.NewDefaultPlcConnectionConnectResult(m, nil)
} else {
log.Info().Msg("Successfully connected")
}
diff --git a/plc4go/internal/plc4go/eip/Driver.go b/plc4go/internal/plc4go/eip/Driver.go
index 2a0114e..0cdf7d7 100644
--- a/plc4go/internal/plc4go/eip/Driver.go
+++ b/plc4go/internal/plc4go/eip/Driver.go
@@ -21,6 +21,7 @@ package eip
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ _default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/pkg/plc4go"
apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
@@ -70,7 +71,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't find a transport for scheme %s", transportUrl.Scheme)
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
}()
return ch
}
@@ -82,7 +83,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't create a transport instance for port %#v", options["defaultTcpPort"])
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
}()
return ch
}
@@ -95,7 +96,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Err(err).Msgf("Invalid options")
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
}()
return ch
}
@@ -105,7 +106,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Err(err).Msgf("Invalid options")
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
}()
return ch
}
diff --git a/plc4go/internal/plc4go/eip/Reader.go b/plc4go/internal/plc4go/eip/Reader.go
index 9cc7b49..44c0e5f 100644
--- a/plc4go/internal/plc4go/eip/Reader.go
+++ b/plc4go/internal/plc4go/eip/Reader.go
@@ -65,7 +65,7 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
}
ansi, err := toAnsi(tag)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrapf(err, "Error encoding eip ansi for field %s", fieldName),
@@ -144,27 +144,27 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
readResponse, err := m.ToPlc4xReadResponse(multipleServiceResponse.Parent, readRequest)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
return transaction.EndRequest()
}
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: readResponse,
}
return transaction.EndRequest()
},
func(err error) error {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "got timeout while waiting for response"),
}
return transaction.EndRequest()
},
time.Second*1); err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
@@ -224,27 +224,27 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
readResponse, err := m.ToPlc4xReadResponse(cipReadResponse.Parent, readRequest)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
return transaction.EndRequest()
}
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: readResponse,
}
return transaction.EndRequest()
},
func(err error) error {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "got timeout while waiting for response"),
}
return transaction.EndRequest()
},
time.Second*1); err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
diff --git a/plc4go/internal/plc4go/eip/Writer.go b/plc4go/internal/plc4go/eip/Writer.go
index 1ee4e2d..fddd3b5 100644
--- a/plc4go/internal/plc4go/eip/Writer.go
+++ b/plc4go/internal/plc4go/eip/Writer.go
@@ -77,7 +77,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
requestPathSize := int8(dataLength / 2)
data, err := encodeValue(value, field.GetType(), elements)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrapf(err, "Error encoding value for field %s", fieldName),
@@ -86,7 +86,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
}
ansi, err := toAnsi(tag)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrapf(err, "Error encoding eip ansi for field %s", fieldName),
@@ -147,27 +147,27 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
readResponse, err := m.ToPlc4xWriteResponse(cipWriteResponse.Parent, writeRequest)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
return transaction.EndRequest()
}
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: readResponse,
}
return transaction.EndRequest()
},
func(err error) error {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.New("got timeout while waiting for response"),
}
return transaction.EndRequest()
},
time.Second*1); err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
@@ -244,27 +244,27 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
readResponse, err := m.ToPlc4xWriteResponse(multipleServiceResponse.Parent, writeRequest)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
return transaction.EndRequest()
}
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: readResponse,
}
return transaction.EndRequest()
},
func(err error) error {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.New("got timeout while waiting for response"),
}
return transaction.EndRequest()
},
time.Second*1); err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
diff --git a/plc4go/internal/plc4go/knxnetip/Browser.go b/plc4go/internal/plc4go/knxnetip/Browser.go
index d13ab99..3919aa0 100644
--- a/plc4go/internal/plc4go/knxnetip/Browser.go
+++ b/plc4go/internal/plc4go/knxnetip/Browser.go
@@ -59,7 +59,7 @@ func (m Browser) Browse(browseRequest apiModel.PlcBrowseRequest) <-chan apiModel
func (m Browser) BrowseWithInterceptor(browseRequest apiModel.PlcBrowseRequest, interceptor func(result apiModel.PlcBrowseEvent) bool) <-chan apiModel.PlcBrowseRequestResult {
result := make(chan apiModel.PlcBrowseRequestResult)
sendResult := func(browseResponse apiModel.PlcBrowseResponse, err error) {
- result <- apiModel.PlcBrowseRequestResult{
+ result <- &model.DefaultPlcBrowseRequestResult{
Request: browseRequest,
Response: browseResponse,
Err: err,
@@ -127,7 +127,7 @@ func (m Browser) executeDeviceQuery(field DeviceQueryField, browseRequest apiMod
// If the request returned a connection, process it,
// otherwise just ignore it.
if deviceConnection.connection != nil {
- queryResult := apiModel.PlcBrowseQueryResult{
+ queryResult := &model.DefaultPlcBrowseQueryResult{
Field: NewDeviceQueryField(
strconv.Itoa(int(knxAddress.MainGroup)),
strconv.Itoa(int(knxAddress.MiddleGroup)),
@@ -139,10 +139,10 @@ func (m Browser) executeDeviceQuery(field DeviceQueryField, browseRequest apiMod
// Pass it to the callback
add := true
if interceptor != nil {
- add = interceptor(apiModel.PlcBrowseEvent{
+ add = interceptor(&model.DefaultPlcBrowseEvent{
Request: browseRequest,
QueryName: queryName,
- Result: &queryResult,
+ Result: queryResult,
Err: nil,
})
}
@@ -199,14 +199,14 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
rrr := readRequest.Execute()
readResult := <-rrr
- if readResult.Err != nil {
- return nil, errors.Wrap(readResult.Err, "error reading the group address table starting address:")
+ if readResult.GetErr() != nil {
+ return nil, errors.Wrap(readResult.GetErr(), "error reading the group address table starting address:")
}
- if readResult.Response.GetResponseCode("groupAddressTableAddress") != apiModel.PlcResponseCode_OK {
+ if readResult.GetResponse().GetResponseCode("groupAddressTableAddress") != apiModel.PlcResponseCode_OK {
return nil, errors.Errorf("error reading group address table starting address: %s",
- readResult.Response.GetResponseCode("groupAddressTableAddress").GetName())
+ readResult.GetResponse().GetResponseCode("groupAddressTableAddress").GetName())
}
- groupAddressTableStartAddress := readResult.Response.GetValue("groupAddressTableAddress").GetUint32()
+ groupAddressTableStartAddress := readResult.GetResponse().GetValue("groupAddressTableAddress").GetUint32()
// Then read one byte at the given location.
// This will return the number of entries in the group address table (each 2 bytes)
@@ -226,14 +226,14 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
rrr = readRequest.Execute()
readResult = <-rrr
- if readResult.Err != nil {
- return nil, errors.Wrap(readResult.Err, "error reading the number of group address table entries")
+ if readResult.GetErr() != nil {
+ return nil, errors.Wrap(readResult.GetErr(), "error reading the number of group address table entries")
}
- if readResult.Response.GetResponseCode("numberOfAddressTableEntries") != apiModel.PlcResponseCode_OK {
+ if readResult.GetResponse().GetResponseCode("numberOfAddressTableEntries") != apiModel.PlcResponseCode_OK {
return nil, errors.Errorf("error reading the number of group address table entries: %s",
- readResult.Response.GetResponseCode("numberOfAddressTableEntries").GetName())
+ readResult.GetResponse().GetResponseCode("numberOfAddressTableEntries").GetName())
}
- numGroupAddresses := readResult.Response.GetValue("numberOfAddressTableEntries").GetUint16()
+ numGroupAddresses := readResult.GetResponse().GetValue("numberOfAddressTableEntries").GetUint16()
if m.connection.DeviceConnections[*knxAddress].deviceDescriptor == uint16(0x07B0) /* SystemB */ {
groupAddressTableStartAddress += 2
@@ -257,22 +257,22 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
rrr = readRequest.Execute()
readResult = <-rrr
- if readResult.Err != nil {
- return nil, errors.Wrap(readResult.Err, "error reading the group address table content")
+ if readResult.GetErr() != nil {
+ return nil, errors.Wrap(readResult.GetErr(), "error reading the group address table content")
}
- if (readResult.Response == nil) ||
- (readResult.Response.GetResponseCode("groupAddressTable") != apiModel.PlcResponseCode_OK) {
+ if (readResult.GetResponse() == nil) ||
+ (readResult.GetResponse().GetResponseCode("groupAddressTable") != apiModel.PlcResponseCode_OK) {
return nil, errors.Errorf("error reading the group address table content: %s",
- readResult.Response.GetResponseCode("groupAddressTable").GetName())
+ readResult.GetResponse().GetResponseCode("groupAddressTable").GetName())
}
var knxGroupAddresses []*driverModel.KnxGroupAddress
- if readResult.Response.GetValue("groupAddressTable").IsList() {
- for _, groupAddress := range readResult.Response.GetValue("groupAddressTable").GetList() {
+ if readResult.GetResponse().GetValue("groupAddressTable").IsList() {
+ for _, groupAddress := range readResult.GetResponse().GetValue("groupAddressTable").GetList() {
groupAddress := Uint16ToKnxGroupAddress(groupAddress.GetUint16(), 3)
knxGroupAddresses = append(knxGroupAddresses, groupAddress)
}
} else {
- groupAddress := Uint16ToKnxGroupAddress(readResult.Response.GetValue("groupAddressTable").GetUint16(), 3)
+ groupAddress := Uint16ToKnxGroupAddress(readResult.GetResponse().GetValue("groupAddressTable").GetUint16(), 3)
knxGroupAddresses = append(knxGroupAddresses, groupAddress)
}
@@ -290,15 +290,15 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
rrr = readRequest.Execute()
readResult = <-rrr
- if readResult.Err != nil {
- return nil, errors.Wrap(readResult.Err, "error reading the group address association table address")
+ if readResult.GetErr() != nil {
+ return nil, errors.Wrap(readResult.GetErr(), "error reading the group address association table address")
}
- if (readResult.Response != nil) &&
- (readResult.Response.GetResponseCode("groupAddressAssociationTableAddress") != apiModel.PlcResponseCode_OK) {
+ if (readResult.GetResponse() != nil) &&
+ (readResult.GetResponse().GetResponseCode("groupAddressAssociationTableAddress") != apiModel.PlcResponseCode_OK) {
return nil, errors.Errorf("error reading the group address association table address: %s",
- readResult.Response.GetResponseCode("groupAddressAssociationTableAddress").GetName())
+ readResult.GetResponse().GetResponseCode("groupAddressAssociationTableAddress").GetName())
}
- groupAddressAssociationTableAddress := readResult.Response.GetValue("groupAddressAssociationTableAddress").GetUint16()
+ groupAddressAssociationTableAddress := readResult.GetResponse().GetValue("groupAddressAssociationTableAddress").GetUint16()
// Then read one uint16 at the given location.
// This will return the number of entries in the group address table (each 2 bytes)
@@ -316,15 +316,15 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
rrr = readRequest.Execute()
readResult = <-rrr
- if readResult.Err != nil {
- return nil, errors.Wrap(readResult.Err, "error reading the number of group address association table entries")
+ if readResult.GetErr() != nil {
+ return nil, errors.Wrap(readResult.GetErr(), "error reading the number of group address association table entries")
}
- if (readResult.Response != nil) &&
- (readResult.Response.GetResponseCode("numberOfGroupAddressAssociationTableEntries") != apiModel.PlcResponseCode_OK) {
+ if (readResult.GetResponse() != nil) &&
+ (readResult.GetResponse().GetResponseCode("numberOfGroupAddressAssociationTableEntries") != apiModel.PlcResponseCode_OK) {
return nil, errors.Errorf("error reading the number of group address association table entries: %s",
- readResult.Response.GetResponseCode("numberOfGroupAddressAssociationTableEntries").GetName())
+ readResult.GetResponse().GetResponseCode("numberOfGroupAddressAssociationTableEntries").GetName())
}
- numberOfGroupAddressAssociationTableEntries := readResult.Response.GetValue("numberOfGroupAddressAssociationTableEntries").GetUint16()
+ numberOfGroupAddressAssociationTableEntries := readResult.GetResponse().GetValue("numberOfGroupAddressAssociationTableEntries").GetUint16()
// Read the data in the group address table
readRequestBuilder = m.connection.ReadRequestBuilder()
@@ -345,18 +345,18 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
rrr = readRequest.Execute()
readResult = <-rrr
- if readResult.Err != nil {
- return nil, errors.Wrap(readResult.Err, "error reading the group address association table content")
+ if readResult.GetErr() != nil {
+ return nil, errors.Wrap(readResult.GetErr(), "error reading the group address association table content")
}
- if (readResult.Response != nil) &&
- (readResult.Response.GetResponseCode("groupAddressAssociationTable") != apiModel.PlcResponseCode_OK) {
+ if (readResult.GetResponse() != nil) &&
+ (readResult.GetResponse().GetResponseCode("groupAddressAssociationTable") != apiModel.PlcResponseCode_OK) {
return nil, errors.Errorf("error reading the group address association table content: %s",
- readResult.Response.GetResponseCode("groupAddressAssociationTable").GetName())
+ readResult.GetResponse().GetResponseCode("groupAddressAssociationTable").GetName())
}
// Output the group addresses
groupAddressComObjectNumberMapping := map[*driverModel.KnxGroupAddress]uint16{}
- if readResult.Response.GetValue("groupAddressAssociationTable").IsList() {
- for _, groupAddressAssociation := range readResult.Response.GetValue("groupAddressAssociationTable").GetList() {
+ if readResult.GetResponse().GetValue("groupAddressAssociationTable").IsList() {
+ for _, groupAddressAssociation := range readResult.GetResponse().GetValue("groupAddressAssociationTable").GetList() {
groupAddress, comObjectNumber := m.parseAssociationTable(m.connection.DeviceConnections[*knxAddress].deviceDescriptor,
knxGroupAddresses, groupAddressAssociation)
if groupAddress != nil {
@@ -365,7 +365,7 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
} else {
groupAddress, comObjectNumber := m.parseAssociationTable(m.connection.DeviceConnections[*knxAddress].deviceDescriptor,
- knxGroupAddresses, readResult.Response.GetValue("groupAddressAssociationTable"))
+ knxGroupAddresses, readResult.GetResponse().GetValue("groupAddressAssociationTable"))
if groupAddress != nil {
groupAddressComObjectNumberMapping[groupAddress] = comObjectNumber
}
@@ -392,10 +392,10 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
rrr = readRequest.Execute()
readResult = <-rrr
for groupAddress, comObjectNumber := range groupAddressComObjectNumberMapping {
- if readResult.Response.GetResponseCode(strconv.Itoa(int(comObjectNumber))) != apiModel.PlcResponseCode_OK {
+ if readResult.GetResponse().GetResponseCode(strconv.Itoa(int(comObjectNumber))) != apiModel.PlcResponseCode_OK {
continue
}
- comObjectSettings := readResult.Response.GetValue(strconv.Itoa(int(comObjectNumber))).GetUint16()
+ comObjectSettings := readResult.GetResponse().GetValue(strconv.Itoa(int(comObjectNumber))).GetUint16()
data := []uint8{uint8((comObjectSettings >> 8) & 0xFF), uint8(comObjectSettings & 0xFF)}
rb := utils.NewReadBufferByteBased(data)
descriptor, err := driverModel.GroupObjectDescriptorRealisationTypeBParse(rb)
@@ -428,7 +428,7 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
&fieldType)
}
- results = append(results, apiModel.PlcBrowseQueryResult{
+ results = append(results, &model.DefaultPlcBrowseQueryResult{
Field: field,
Name: fmt.Sprintf("#%d", comObjectNumber),
Readable: readable,
@@ -453,7 +453,7 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
rrr := readRequest.Execute()
readRequestResult := <-rrr
- readResponse := readRequestResult.Response
+ readResponse := readRequestResult.GetResponse()
var programVersionData []byte
if readResponse.GetResponseCode("applicationProgramVersion") == apiModel.PlcResponseCode_OK {
programVersionData = utils.PlcValueUint8ListToByteArray(readResponse.GetValue("applicationProgramVersion"))
@@ -487,8 +487,8 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
rrr = readRequest.Execute()
readResult = <-rrr
- for _, fieldName := range readResult.Response.GetFieldNames() {
- array := utils.PlcValueUint8ListToByteArray(readResult.Response.GetValue(fieldName))
+ for _, fieldName := range readResult.GetResponse().GetFieldNames() {
+ array := utils.PlcValueUint8ListToByteArray(readResult.GetResponse().GetValue(fieldName))
rb := utils.NewReadBufferByteBased(array)
descriptor, err := driverModel.GroupObjectDescriptorRealisationType7Parse(rb)
if err != nil {
@@ -508,7 +508,7 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
for _, groupAddress := range groupAddresses {
field := m.getFieldForGroupAddress(groupAddress, fieldType)
- results = append(results, apiModel.PlcBrowseQueryResult{
+ results = append(results, &model.DefaultPlcBrowseQueryResult{
Field: field,
Name: fmt.Sprintf("#%d", comObjectNumber),
Readable: readable,
@@ -527,8 +527,8 @@ func (m Browser) executeCommunicationObjectQuery(field CommunicationObjectQueryF
}
rrr = readRequest.Execute()
readResult = <-rrr
- if readResult.Response.GetResponseCode("comObjectTableAddress") == apiModel.PlcResponseCode_OK {
- comObjectTableAddress := readResult.Response.GetValue("comObjectTableAddress").GetUint16()
+ if readResult.GetResponse().GetResponseCode("comObjectTableAddress") == apiModel.PlcResponseCode_OK {
+ comObjectTableAddress := readResult.GetResponse().GetValue("comObjectTableAddress").GetUint16()
log.Info().Msgf("Com Object Table Address: %x", comObjectTableAddress)
}
}
diff --git a/plc4go/internal/plc4go/knxnetip/Connection.go b/plc4go/internal/plc4go/knxnetip/Connection.go
index 387117b..339797d 100644
--- a/plc4go/internal/plc4go/knxnetip/Connection.go
+++ b/plc4go/internal/plc4go/knxnetip/Connection.go
@@ -23,6 +23,7 @@ import (
"bytes"
"encoding/hex"
"fmt"
+ _default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
"strconv"
"strings"
"sync"
@@ -195,7 +196,7 @@ func NewConnection(transportInstance transports.TransportInstance, options map[s
func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
result := make(chan plc4go.PlcConnectionConnectResult)
sendResult := func(connection plc4go.PlcConnection, err error) {
- result <- plc4go.NewPlcConnectionConnectResult(connection, err)
+ result <- _default.NewDefaultPlcConnectionConnectResult(connection, err)
}
go func() {
@@ -377,9 +378,9 @@ func (m *Connection) Close() <-chan plc4go.PlcConnectionCloseResult {
// Send a disconnect request from the gateway.
_, err := m.sendGatewayDisconnectionRequest()
if err != nil {
- result <- plc4go.NewPlcConnectionCloseResult(m, errors.Wrap(err, "got an error while disconnecting"))
+ result <- _default.NewDefaultPlcConnectionCloseResult(m, errors.Wrap(err, "got an error while disconnecting"))
} else {
- result <- plc4go.NewPlcConnectionCloseResult(m, nil)
+ result <- _default.NewDefaultPlcConnectionCloseResult(m, nil)
}
}()
@@ -395,7 +396,7 @@ func (m *Connection) IsConnected() bool {
if !ttlTimer.Stop() {
<-ttlTimer.C
}
- return pingResponse.Err == nil
+ return pingResponse.GetErr() == nil
case <-ttlTimer.C:
ttlTimer.Stop()
m.handleTimeout()
@@ -412,9 +413,9 @@ func (m *Connection) Ping() <-chan plc4go.PlcConnectionPingResult {
// Send the connection state request
_, err := m.sendConnectionStateRequest()
if err != nil {
- result <- plc4go.NewPlcConnectionPingResult(errors.Wrap(err, "got an error"))
+ result <- _default.NewDefaultPlcConnectionPingResult(errors.Wrap(err, "got an error"))
} else {
- result <- plc4go.NewPlcConnectionPingResult(nil)
+ result <- _default.NewDefaultPlcConnectionPingResult(nil)
}
return
}()
diff --git a/plc4go/internal/plc4go/knxnetip/Discoverer.go b/plc4go/internal/plc4go/knxnetip/Discoverer.go
index 8e074f5..a994036 100644
--- a/plc4go/internal/plc4go/knxnetip/Discoverer.go
+++ b/plc4go/internal/plc4go/knxnetip/Discoverer.go
@@ -29,6 +29,7 @@ import (
driverModel "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip/readwrite/model"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ internalModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports/udp"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
@@ -162,8 +163,13 @@ func (d *Discoverer) Discover(callback func(event apiModel.PlcDiscoveryEvent), o
}
deviceName := string(bytes.Trim(utils.Int8ArrayToByteArray(
searchResponse.DibDeviceInfo.DeviceFriendlyName), "\x00"))
- discoveryEvent := apiModel.NewPlcDiscoveryEvent(
- "knxnet-ip", "udp", *remoteUrl, nil, deviceName)
+ discoveryEvent := &internalModel.DefaultPlcDiscoveryEvent{
+ ProtocolCode: "knxnet-ip",
+ TransportCode: "udp",
+ TransportUrl: *remoteUrl,
+ Options: nil,
+ Name: deviceName,
+ }
// Pass the event back to the callback
callback(discoveryEvent)
}
diff --git a/plc4go/internal/plc4go/knxnetip/Driver.go b/plc4go/internal/plc4go/knxnetip/Driver.go
index 09c413a..8573c2e 100644
--- a/plc4go/internal/plc4go/knxnetip/Driver.go
+++ b/plc4go/internal/plc4go/knxnetip/Driver.go
@@ -21,6 +21,7 @@ package knxnetip
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ _default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/pkg/plc4go"
apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
@@ -62,7 +63,7 @@ func (m Driver) GetConnection(transportUrl url.URL, transports map[string]transp
if !ok {
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
}()
return ch
}
@@ -73,7 +74,7 @@ func (m Driver) GetConnection(transportUrl url.URL, transports map[string]transp
if err != nil {
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Errorf("couldn't initialize transport configuration for given transport url %#v", transportUrl))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't initialize transport configuration for given transport url %#v", transportUrl))
}()
return ch
}
diff --git a/plc4go/internal/plc4go/knxnetip/Reader.go b/plc4go/internal/plc4go/knxnetip/Reader.go
index 94525b1..0cf52a7 100644
--- a/plc4go/internal/plc4go/knxnetip/Reader.go
+++ b/plc4go/internal/plc4go/knxnetip/Reader.go
@@ -158,7 +158,7 @@ func (m Reader) Read(readRequest apiModel.PlcReadRequest) <-chan apiModel.PlcRea
// Assemble the results
result := internalModel.NewDefaultPlcReadResponse(readRequest, responseCodes, plcValues)
- resultChan <- apiModel.PlcReadRequestResult{
+ resultChan <- &internalModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: result,
Err: nil,
diff --git a/plc4go/internal/plc4go/knxnetip/Subscriber.go b/plc4go/internal/plc4go/knxnetip/Subscriber.go
index e3fea7d..830e893 100644
--- a/plc4go/internal/plc4go/knxnetip/Subscriber.go
+++ b/plc4go/internal/plc4go/knxnetip/Subscriber.go
@@ -56,7 +56,7 @@ func (m *Subscriber) Subscribe(subscriptionRequest apiModel.PlcSubscriptionReque
responseCodes[fieldName] = apiModel.PlcResponseCode_OK
}
- result <- apiModel.PlcSubscriptionRequestResult{
+ result <- &internalModel.DefaultPlcSubscriptionRequestResult{
Request: subscriptionRequest,
Response: internalModel.NewDefaultPlcSubscriptionResponse(subscriptionRequest, responseCodes),
Err: nil,
diff --git a/plc4go/internal/plc4go/knxnetip/Writer.go b/plc4go/internal/plc4go/knxnetip/Writer.go
index 562f593..dd3a93e 100644
--- a/plc4go/internal/plc4go/knxnetip/Writer.go
+++ b/plc4go/internal/plc4go/knxnetip/Writer.go
@@ -23,6 +23,7 @@ import (
"errors"
readWriteModel "github.com/apache/plc4x/plc4go/internal/plc4go/knxnetip/readwrite/model"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ plc4goModel "github.com/apache/plc4x/plc4go/internal/plc4go/spi/model"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
"github.com/apache/plc4x/plc4go/pkg/plc4go/model"
)
@@ -47,7 +48,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
field := writeRequest.GetField(fieldName)
knxNetIpField, err := CastToFieldFromPlcField(field)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.New("invalid field item type"),
@@ -60,7 +61,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
io := utils.NewWriteBufferByteBased()
fieldType := readWriteModel.KnxDatapointTypeByName(knxNetIpField.GetTypeName())
if err := readWriteModel.KnxDatapointSerialize(io, value, fieldType); err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.New("error serializing value: " + err.Error()),
diff --git a/plc4go/internal/plc4go/modbus/Connection.go b/plc4go/internal/plc4go/modbus/Connection.go
index 3ced877..a92700d 100644
--- a/plc4go/internal/plc4go/modbus/Connection.go
+++ b/plc4go/internal/plc4go/modbus/Connection.go
@@ -86,20 +86,20 @@ func (m *Connection) Ping() <-chan plc4go.PlcConnectionPingResult {
if message != nil {
// If we got a valid response (even if it will probably contain an error, we know the remote is available)
log.Trace().Msg("got valid response")
- result <- plc4go.NewPlcConnectionPingResult(nil)
+ result <- _default.NewDefaultPlcConnectionPingResult(nil)
} else {
log.Trace().Msg("got no response")
- result <- plc4go.NewPlcConnectionPingResult(errors.New("no response"))
+ result <- _default.NewDefaultPlcConnectionPingResult(errors.New("no response"))
}
return nil
},
func(err error) error {
log.Trace().Msgf("Received Error")
- result <- plc4go.NewPlcConnectionPingResult(errors.Wrap(err, "got error processing request"))
+ result <- _default.NewDefaultPlcConnectionPingResult(errors.Wrap(err, "got error processing request"))
return nil
},
time.Second*1); err != nil {
- result <- plc4go.NewPlcConnectionPingResult(err)
+ result <- _default.NewDefaultPlcConnectionPingResult(err)
}
}()
return result
diff --git a/plc4go/internal/plc4go/modbus/Driver.go b/plc4go/internal/plc4go/modbus/Driver.go
index 4873626..69d67d9 100644
--- a/plc4go/internal/plc4go/modbus/Driver.go
+++ b/plc4go/internal/plc4go/modbus/Driver.go
@@ -23,6 +23,7 @@ import (
"encoding/json"
"github.com/apache/plc4x/plc4go/internal/plc4go/modbus/readwrite/model"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ _default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/pkg/plc4go"
apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
@@ -67,7 +68,7 @@ func (m Driver) GetConnection(transportUrl url.URL, transports map[string]transp
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't find a transport for scheme %s", transportUrl.Scheme)
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
}()
return ch
}
@@ -79,7 +80,7 @@ func (m Driver) GetConnection(transportUrl url.URL, transports map[string]transp
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't create a transport instance for port %#v", options["defaultTcpPort"])
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
}()
return ch
}
diff --git a/plc4go/internal/plc4go/modbus/Reader.go b/plc4go/internal/plc4go/modbus/Reader.go
index e99463e..eb9d594 100644
--- a/plc4go/internal/plc4go/modbus/Reader.go
+++ b/plc4go/internal/plc4go/modbus/Reader.go
@@ -52,7 +52,7 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
result := make(chan model.PlcReadRequestResult)
go func() {
if len(readRequest.GetFieldNames()) != 1 {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.New("modbus only supports single-item requests"),
@@ -65,7 +65,7 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
field := readRequest.GetField(fieldName)
modbusField, err := CastToModbusFieldFromPlcField(field)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -86,14 +86,14 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
case HoldingRegister:
pdu = readWriteModel.NewModbusPDUReadHoldingRegistersRequest(modbusField.Address, numWords)
case ExtendedRegister:
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.New("modbus currently doesn't support extended register requests"),
}
return
default:
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Errorf("unsupported field type %x", modbusField.FieldType),
@@ -136,28 +136,28 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
readResponse, err := m.ToPlc4xReadResponse(*responseAdu, readRequest)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
// TODO: should we return the error here?
return nil
}
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: readResponse,
}
return nil
},
func(err error) error {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "got timeout while waiting for response"),
}
return nil
},
time.Second*1); err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
diff --git a/plc4go/internal/plc4go/modbus/Writer.go b/plc4go/internal/plc4go/modbus/Writer.go
index 8365f9b..00e9900 100644
--- a/plc4go/internal/plc4go/modbus/Writer.go
+++ b/plc4go/internal/plc4go/modbus/Writer.go
@@ -51,7 +51,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
go func() {
// If we are requesting only one field, use a
if len(writeRequest.GetFieldNames()) != 1 {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.New("modbus only supports single-item requests"),
@@ -64,7 +64,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
field := writeRequest.GetField(fieldName)
modbusField, err := CastToModbusFieldFromPlcField(field)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "invalid field item type"),
@@ -76,7 +76,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
value := writeRequest.GetValue(fieldName)
io := utils.NewWriteBufferByteBased()
if err := readWriteModel.DataItemSerialize(io, value, modbusField.Datatype, modbusField.Quantity); err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "error serializing value"),
@@ -101,14 +101,14 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
numWords,
data)
case ExtendedRegister:
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.New("modbus currently doesn't support extended register requests"),
}
return
default:
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.New("unsupported field type"),
@@ -145,12 +145,12 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
readResponse, err := m.ToPlc4xWriteResponse(requestAdu, *responseAdu, writeRequest)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
} else {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: readResponse,
}
@@ -158,7 +158,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
return nil
},
func(err error) error {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.New("got timeout while waiting for response"),
}
diff --git a/plc4go/internal/plc4go/s7/Connection.go b/plc4go/internal/plc4go/s7/Connection.go
index bdf93bb..0a4bbc5 100644
--- a/plc4go/internal/plc4go/s7/Connection.go
+++ b/plc4go/internal/plc4go/s7/Connection.go
@@ -90,13 +90,13 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
go func() {
err := m.messageCodec.Connect()
if err != nil {
- ch <- plc4go.NewPlcConnectionConnectResult(m, err)
+ ch <- _default.NewDefaultPlcConnectionConnectResult(m, err)
}
// Only on active connections we do a connection
if m.driverContext.PassiveMode {
log.Info().Msg("S7 Driver running in PASSIVE mode.")
- ch <- plc4go.NewPlcConnectionConnectResult(m, nil)
+ ch <- _default.NewDefaultPlcConnectionConnectResult(m, nil)
return
}
@@ -106,7 +106,7 @@ func (m *Connection) Connect() <-chan plc4go.PlcConnectionConnectResult {
log.Warn().Msg("Connection used in an unsafe way. !!!DON'T USE IN PRODUCTION!!!")
// Here we write directly and don't wait till the connection is "really" connected
// Note: we can't use fireConnected here as it's guarded against m.driverContext.awaitSetupComplete
- ch <- plc4go.NewPlcConnectionConnectResult(m, err)
+ ch <- _default.NewDefaultPlcConnectionConnectResult(m, err)
m.SetConnected(true)
return
}
@@ -282,7 +282,7 @@ func (m *Connection) setupConnection(ch chan plc4go.PlcConnectionConnectResult)
func (m *Connection) fireConnectionError(err error, ch chan<- plc4go.PlcConnectionConnectResult) {
if m.driverContext.awaitSetupComplete {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "Error during connection"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Error during connection"))
} else {
log.Error().Err(err).Msg("awaitSetupComplete set to false and we got a error during connect")
}
@@ -290,7 +290,7 @@ func (m *Connection) fireConnectionError(err error, ch chan<- plc4go.PlcConnecti
func (m *Connection) fireConnected(ch chan<- plc4go.PlcConnectionConnectResult) {
if m.driverContext.awaitSetupComplete {
- ch <- plc4go.NewPlcConnectionConnectResult(m, nil)
+ ch <- _default.NewDefaultPlcConnectionConnectResult(m, nil)
} else {
log.Info().Msg("Successfully connected")
}
diff --git a/plc4go/internal/plc4go/s7/Driver.go b/plc4go/internal/plc4go/s7/Driver.go
index 9158e89..c01167d 100644
--- a/plc4go/internal/plc4go/s7/Driver.go
+++ b/plc4go/internal/plc4go/s7/Driver.go
@@ -21,6 +21,7 @@ package s7
import (
"github.com/apache/plc4x/plc4go/internal/plc4go/spi"
+ _default "github.com/apache/plc4x/plc4go/internal/plc4go/spi/default"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/transports"
"github.com/apache/plc4x/plc4go/pkg/plc4go"
apiModel "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
@@ -70,7 +71,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't find a transport for scheme %s", transportUrl.Scheme)
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Errorf("couldn't find transport for given transport url %#v", transportUrl))
}()
return ch
}
@@ -82,7 +83,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Stringer("transportUrl", &transportUrl).Msgf("We couldn't create a transport instance for port %#v", options["defaultTcpPort"])
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.New("couldn't initialize transport configuration for given transport url "+transportUrl.String()))
}()
return ch
}
@@ -95,7 +96,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Err(err).Msgf("Invalid options")
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
}()
return ch
}
@@ -105,7 +106,7 @@ func (m *Driver) GetConnection(transportUrl url.URL, transports map[string]trans
log.Error().Err(err).Msgf("Invalid options")
ch := make(chan plc4go.PlcConnectionConnectResult)
go func() {
- ch <- plc4go.NewPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
+ ch <- _default.NewDefaultPlcConnectionConnectResult(nil, errors.Wrap(err, "Invalid options"))
}()
return ch
}
diff --git a/plc4go/internal/plc4go/s7/Reader.go b/plc4go/internal/plc4go/s7/Reader.go
index 1ccecab..910f0e0 100644
--- a/plc4go/internal/plc4go/s7/Reader.go
+++ b/plc4go/internal/plc4go/s7/Reader.go
@@ -56,7 +56,7 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
field := readRequest.GetField(fieldName)
address, err := encodeS7Address(field)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrapf(err, "Error encoding s7 address for field %s", fieldName),
@@ -124,27 +124,27 @@ func (m *Reader) Read(readRequest model.PlcReadRequest) <-chan model.PlcReadRequ
readResponse, err := m.ToPlc4xReadResponse(*payload, readRequest)
if err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
return transaction.EndRequest()
}
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: readResponse,
}
return transaction.EndRequest()
},
func(err error) error {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Err: errors.Wrap(err, "got timeout while waiting for response"),
}
return transaction.EndRequest()
},
time.Second*1); err != nil {
- result <- model.PlcReadRequestResult{
+ result <- &plc4goModel.DefaultPlcReadRequestResult{
Request: readRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
diff --git a/plc4go/internal/plc4go/s7/Writer.go b/plc4go/internal/plc4go/s7/Writer.go
index 5048982..d4e38fd 100644
--- a/plc4go/internal/plc4go/s7/Writer.go
+++ b/plc4go/internal/plc4go/s7/Writer.go
@@ -55,7 +55,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
plcValue := writeRequest.GetValue(fieldName)
s7Address, err := encodeS7Address(field)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrapf(err, "Error encoding s7 address for field %s", fieldName),
@@ -65,7 +65,7 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
parameterItems[i] = readWriteModel.NewS7VarRequestParameterItemAddress(s7Address)
value, err := serializePlcValue(field, plcValue)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrapf(err, "Error encoding value for field %s", fieldName),
@@ -127,27 +127,27 @@ func (m Writer) Write(writeRequest model.PlcWriteRequest) <-chan model.PlcWriteR
readResponse, err := m.ToPlc4xWriteResponse(*payload, writeRequest)
if err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.Wrap(err, "Error decoding response"),
}
return transaction.EndRequest()
}
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: readResponse,
}
return transaction.EndRequest()
},
func(err error) error {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Err: errors.New("got timeout while waiting for response"),
}
return transaction.EndRequest()
},
time.Second*1); err != nil {
- result <- model.PlcWriteRequestResult{
+ result <- &plc4goModel.DefaultPlcWriteRequestResult{
Request: writeRequest,
Response: nil,
Err: errors.Wrap(err, "error sending message"),
diff --git a/plc4go/internal/plc4go/spi/default/DefaultConnection.go b/plc4go/internal/plc4go/spi/default/DefaultConnection.go
index 3651984..4419f36 100644
--- a/plc4go/internal/plc4go/spi/default/DefaultConnection.go
+++ b/plc4go/internal/plc4go/spi/default/DefaultConnection.go
@@ -75,6 +75,38 @@ type DefaultConnectionMetadata struct {
ProvidesBrowsing bool
}
+type DefaultPlcConnectionConnectResult interface {
+ plc4go.PlcConnectionConnectResult
+}
+
+func NewDefaultPlcConnectionConnectResult(connection plc4go.PlcConnection, err error) DefaultPlcConnectionConnectResult {
+ return &plcConnectionConnectResult{
+ connection: connection,
+ err: err,
+ }
+}
+
+type DefaultPlcConnectionCloseResult interface {
+ plc4go.PlcConnectionCloseResult
+}
+
+func NewDefaultPlcConnectionCloseResult(connection plc4go.PlcConnection, err error) plc4go.PlcConnectionCloseResult {
+ return &plcConnectionCloseResult{
+ connection: connection,
+ err: err,
+ }
+}
+
+type DefaultPlcConnectionPingResult interface {
+ plc4go.PlcConnectionPingResult
+}
+
+func NewDefaultPlcConnectionPingResult(err error) plc4go.PlcConnectionPingResult {
+ return &plcConnectionPingResult{
+ err: err,
+ }
+}
+
///////////////////////////////////////
///////////////////////////////////////
//
@@ -135,6 +167,40 @@ func buildDefaultConnection(requirements DefaultConnectionRequirements, options
}
}
+type plcConnectionConnectResult struct {
+ connection plc4go.PlcConnection
+ err error
+}
+
+func (d *plcConnectionConnectResult) GetConnection() plc4go.PlcConnection {
+ return d.connection
+}
+
+func (d *plcConnectionConnectResult) GetErr() error {
+ return d.err
+}
+
+type plcConnectionCloseResult struct {
+ connection plc4go.PlcConnection
+ err error
+}
+
+func (d *plcConnectionCloseResult) GetConnection() plc4go.PlcConnection {
+ return d.connection
+}
+
+func (d *plcConnectionCloseResult) GetErr() error {
+ return d.err
+}
+
+type plcConnectionPingResult struct {
+ err error
+}
+
+func (d *plcConnectionPingResult) GetErr() error {
+ return d.err
+}
+
//
// Internal section
//
@@ -152,7 +218,7 @@ func (d *defaultConnection) Connect() <-chan plc4go.PlcConnectionConnectResult {
err := d.GetMessageCodec().Connect()
d.SetConnected(true)
connection := d.GetConnection()
- ch <- plc4go.NewPlcConnectionConnectResult(connection, err)
+ ch <- NewDefaultPlcConnectionConnectResult(connection, err)
}()
return ch
}
@@ -179,7 +245,7 @@ func (d *defaultConnection) Close() <-chan plc4go.PlcConnectionCloseResult {
d.SetConnected(false)
ch := make(chan plc4go.PlcConnectionCloseResult)
go func() {
- ch <- plc4go.NewPlcConnectionCloseResult(d.GetConnection(), nil)
+ ch <- NewDefaultPlcConnectionCloseResult(d.GetConnection(), nil)
}()
return ch
}
@@ -192,9 +258,9 @@ func (d *defaultConnection) Ping() <-chan plc4go.PlcConnectionPingResult {
ch := make(chan plc4go.PlcConnectionPingResult)
go func() {
if d.GetConnection().IsConnected() {
- ch <- plc4go.NewPlcConnectionPingResult(nil)
+ ch <- NewDefaultPlcConnectionPingResult(nil)
} else {
- ch <- plc4go.NewPlcConnectionPingResult(errors.New("not connected"))
+ ch <- NewDefaultPlcConnectionPingResult(errors.New("not connected"))
}
}()
return ch
diff --git a/plc4go/internal/plc4go/spi/interceptors/SingleItemRequestInterceptor.go b/plc4go/internal/plc4go/spi/interceptors/SingleItemRequestInterceptor.go
index c79b6df..ebdb121 100644
--- a/plc4go/internal/plc4go/spi/interceptors/SingleItemRequestInterceptor.go
+++ b/plc4go/internal/plc4go/spi/interceptors/SingleItemRequestInterceptor.go
@@ -61,6 +61,54 @@ func NewSingleItemRequestInterceptor(readRequestFactory readRequestFactory, writ
return SingleItemRequestInterceptor{readRequestFactory, writeRequestFactory, readResponseFactory, writeResponseFactory}
}
+///////////////////////////////////////
+///////////////////////////////////////
+//
+// Internal section
+//
+
+type interceptedPlcReadRequestResult struct {
+ Request model.PlcReadRequest
+ Response model.PlcReadResponse
+ Err error
+}
+
+func (d *interceptedPlcReadRequestResult) GetRequest() model.PlcReadRequest {
+ return d.Request
+}
+
+func (d *interceptedPlcReadRequestResult) GetResponse() model.PlcReadResponse {
+ return d.Response
+}
+
+func (d *interceptedPlcReadRequestResult) GetErr() error {
+ return d.Err
+}
+
+type interceptedPlcWriteRequestResult struct {
+ Request model.PlcWriteRequest
+ Response model.PlcWriteResponse
+ Err error
+}
+
+func (d *interceptedPlcWriteRequestResult) GetRequest() model.PlcWriteRequest {
+ return d.Request
+}
+
+func (d *interceptedPlcWriteRequestResult) GetResponse() model.PlcWriteResponse {
+ return d.Response
+}
+
+func (d *interceptedPlcWriteRequestResult) GetErr() error {
+ return d.Err
+}
+
+//
+// Internal section
+//
+///////////////////////////////////////
+///////////////////////////////////////
+
func (m SingleItemRequestInterceptor) InterceptReadRequest(readRequest model.PlcReadRequest) []model.PlcReadRequest {
// If this request just has one field, go the shortcut
if len(readRequest.GetFieldNames()) == 1 {
@@ -94,26 +142,26 @@ func (m SingleItemRequestInterceptor) ProcessReadResponses(readRequest model.Plc
val := map[string]values.PlcValue{}
var err error = nil
for _, readResult := range readResults {
- if readResult.Err != nil {
- log.Debug().Err(readResult.Err).Msgf("Error during read")
+ if readResult.GetErr() != nil {
+ log.Debug().Err(readResult.GetErr()).Msgf("Error during read")
if err == nil {
// Lazy initialization of multi error
- err = utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{readResult.Err}}
+ err = utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{readResult.GetErr()}}
} else {
multiError := err.(utils.MultiError)
- multiError.Errors = append(multiError.Errors, readResult.Err)
+ multiError.Errors = append(multiError.Errors, readResult.GetErr())
}
- } else if readResult.Response != nil {
- if len(readResult.Response.GetRequest().GetFieldNames()) > 1 {
- log.Error().Int("numberOfFields", len(readResult.Response.GetRequest().GetFieldNames())).Msg("We should only get 1")
+ } else if readResult.GetResponse() != nil {
+ if len(readResult.GetResponse().GetRequest().GetFieldNames()) > 1 {
+ log.Error().Int("numberOfFields", len(readResult.GetResponse().GetRequest().GetFieldNames())).Msg("We should only get 1")
}
- for _, fieldName := range readResult.Response.GetRequest().GetFieldNames() {
- responseCodes[fieldName] = readResult.Response.GetResponseCode(fieldName)
- val[fieldName] = readResult.Response.GetValue(fieldName)
+ for _, fieldName := range readResult.GetResponse().GetRequest().GetFieldNames() {
+ responseCodes[fieldName] = readResult.GetResponse().GetResponseCode(fieldName)
+ val[fieldName] = readResult.GetResponse().GetValue(fieldName)
}
}
}
- return model.PlcReadRequestResult{
+ return &interceptedPlcReadRequestResult{
Request: readRequest,
Response: m.readResponseFactory(readRequest, responseCodes, val),
Err: err,
@@ -153,25 +201,25 @@ func (m SingleItemRequestInterceptor) ProcessWriteResponses(writeRequest model.P
responseCodes := map[string]model.PlcResponseCode{}
var err error = nil
for _, writeResult := range writeResults {
- if writeResult.Err != nil {
- log.Debug().Err(writeResult.Err).Msgf("Error during write")
+ if writeResult.GetErr() != nil {
+ log.Debug().Err(writeResult.GetErr()).Msgf("Error during write")
if err == nil {
// Lazy initialization of multi error
- err = utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{writeResult.Err}}
+ err = utils.MultiError{MainError: errors.New("while aggregating results"), Errors: []error{writeResult.GetErr()}}
} else {
multiError := err.(utils.MultiError)
- multiError.Errors = append(multiError.Errors, writeResult.Err)
+ multiError.Errors = append(multiError.Errors, writeResult.GetErr())
}
- } else if writeResult.Response != nil {
- if len(writeResult.Response.GetRequest().GetFieldNames()) > 1 {
- log.Error().Int("numberOfFields", len(writeResult.Response.GetRequest().GetFieldNames())).Msg("We should only get 1")
+ } else if writeResult.GetResponse() != nil {
+ if len(writeResult.GetResponse().GetRequest().GetFieldNames()) > 1 {
+ log.Error().Int("numberOfFields", len(writeResult.GetResponse().GetRequest().GetFieldNames())).Msg("We should only get 1")
}
- for _, fieldName := range writeResult.Response.GetRequest().GetFieldNames() {
- responseCodes[fieldName] = writeResult.Response.GetResponseCode(fieldName)
+ for _, fieldName := range writeResult.GetResponse().GetRequest().GetFieldNames() {
+ responseCodes[fieldName] = writeResult.GetResponse().GetResponseCode(fieldName)
}
}
}
- return model.PlcWriteRequestResult{
+ return &interceptedPlcWriteRequestResult{
Request: writeRequest,
Response: m.writeResponseFactory(writeRequest, responseCodes),
Err: err,
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcBrowseEvent.go
similarity index 61%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcBrowseEvent.go
index 2258b16..0f3aee1 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcBrowseEvent.go
@@ -19,20 +19,27 @@
package model
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
+import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+
+type DefaultPlcBrowseEvent struct {
+ Request model.PlcBrowseRequest
+ QueryName string
+ Result model.PlcBrowseQueryResult
+ Err error
+}
+
+func (d *DefaultPlcBrowseEvent) GetRequest() model.PlcBrowseRequest {
+ return d.Request
}
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
- Err error
+func (d *DefaultPlcBrowseEvent) GetQueryName() string {
+ return d.QueryName
}
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
+func (d *DefaultPlcBrowseEvent) GetResult() model.PlcBrowseQueryResult {
+ return d.Result
}
-type PlcUnsubscriptionResponse struct {
+func (d *DefaultPlcBrowseEvent) GetErr() error {
+ return d.Err
}
diff --git a/plc4go/internal/plc4go/spi/model/DefaultPlcDiscoveryEvent.go b/plc4go/internal/plc4go/spi/model/DefaultPlcBrowseQueryResult.go
similarity index 52%
copy from plc4go/internal/plc4go/spi/model/DefaultPlcDiscoveryEvent.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcBrowseQueryResult.go
index 6073da4..ee13457 100644
--- a/plc4go/internal/plc4go/spi/model/DefaultPlcDiscoveryEvent.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcBrowseQueryResult.go
@@ -19,36 +19,37 @@
package model
-import (
- "net/url"
-)
-
-type DefaultPlcDiscoveryEvent struct {
- protocolCode string
- transportCode string
- transportUrl url.URL
- options map[string][]string
+import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+
+type DefaultPlcBrowseQueryResult struct {
+ Field model.PlcField
+ Name string
+ Readable bool
+ Writable bool
+ Subscribable bool
+ PossibleDataTypes []string
}
-func (d DefaultPlcDiscoveryEvent) GetProtocolCode() string {
- return d.transportCode
+func (d *DefaultPlcBrowseQueryResult) GetField() model.PlcField {
+ return d.Field
}
-func (d DefaultPlcDiscoveryEvent) GetTransportCode() string {
- return d.transportCode
+func (d *DefaultPlcBrowseQueryResult) GetName() string {
+ return d.Name
}
-func (d DefaultPlcDiscoveryEvent) GetTransportUrl() url.URL {
- return d.transportUrl
+func (d *DefaultPlcBrowseQueryResult) IsReadable() bool {
+ return d.Readable
}
-func (d DefaultPlcDiscoveryEvent) GetOptions() map[string][]string {
- return d.options
+func (d *DefaultPlcBrowseQueryResult) IsWritable() bool {
+ return d.Writable
}
-func (d DefaultPlcDiscoveryEvent) GetConnectionString() string {
- if d.options != nil {
- panic("Not implemented")
- }
- return d.protocolCode + ":" + d.transportCode + "//" + d.transportUrl.Host
+func (d *DefaultPlcBrowseQueryResult) IsSubscribable() bool {
+ return d.Subscribable
+}
+
+func (d *DefaultPlcBrowseQueryResult) GetPossibleDataTypes() []string {
+ return d.PossibleDataTypes
}
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcBrowseRequestResult.go
similarity index 66%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcBrowseRequestResult.go
index 2258b16..d5527c9 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcBrowseRequestResult.go
@@ -19,20 +19,22 @@
package model
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
-}
+import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
+type DefaultPlcBrowseRequestResult struct {
+ Request model.PlcBrowseRequest
+ Response model.PlcBrowseResponse
Err error
}
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
+func (d *DefaultPlcBrowseRequestResult) GetRequest() model.PlcBrowseRequest {
+ return d.Request
+}
+
+func (d *DefaultPlcBrowseRequestResult) GetResponse() model.PlcBrowseResponse {
+ return d.Response
}
-type PlcUnsubscriptionResponse struct {
+func (d *DefaultPlcBrowseRequestResult) GetErr() error {
+ return d.Err
}
diff --git a/plc4go/internal/plc4go/spi/model/DefaultPlcDiscoveryEvent.go b/plc4go/internal/plc4go/spi/model/DefaultPlcDiscoveryEvent.go
index 6073da4..477a83f 100644
--- a/plc4go/internal/plc4go/spi/model/DefaultPlcDiscoveryEvent.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcDiscoveryEvent.go
@@ -24,31 +24,36 @@ import (
)
type DefaultPlcDiscoveryEvent struct {
- protocolCode string
- transportCode string
- transportUrl url.URL
- options map[string][]string
+ ProtocolCode string
+ TransportCode string
+ TransportUrl url.URL
+ Options map[string][]string
+ Name string
}
-func (d DefaultPlcDiscoveryEvent) GetProtocolCode() string {
- return d.transportCode
+func (d *DefaultPlcDiscoveryEvent) GetProtocolCode() string {
+ return d.TransportCode
}
-func (d DefaultPlcDiscoveryEvent) GetTransportCode() string {
- return d.transportCode
+func (d *DefaultPlcDiscoveryEvent) GetTransportCode() string {
+ return d.TransportCode
}
-func (d DefaultPlcDiscoveryEvent) GetTransportUrl() url.URL {
- return d.transportUrl
+func (d *DefaultPlcDiscoveryEvent) GetTransportUrl() url.URL {
+ return d.TransportUrl
}
-func (d DefaultPlcDiscoveryEvent) GetOptions() map[string][]string {
- return d.options
+func (d *DefaultPlcDiscoveryEvent) GetOptions() map[string][]string {
+ return d.Options
}
-func (d DefaultPlcDiscoveryEvent) GetConnectionString() string {
- if d.options != nil {
+func (d *DefaultPlcDiscoveryEvent) GetName() string {
+ return d.Name
+}
+
+func (d *DefaultPlcDiscoveryEvent) GetConnectionString() string {
+ if d.Options != nil {
panic("Not implemented")
}
- return d.protocolCode + ":" + d.transportCode + "//" + d.transportUrl.Host
+ return d.ProtocolCode + ":" + d.TransportCode + "//" + d.TransportUrl.Host
}
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcReadRequestResult.go
similarity index 67%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcReadRequestResult.go
index 2258b16..4437487 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcReadRequestResult.go
@@ -19,20 +19,22 @@
package model
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
-}
+import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
+type DefaultPlcReadRequestResult struct {
+ Request model.PlcReadRequest
+ Response model.PlcReadResponse
Err error
}
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
+func (d *DefaultPlcReadRequestResult) GetRequest() model.PlcReadRequest {
+ return d.Request
+}
+
+func (d *DefaultPlcReadRequestResult) GetResponse() model.PlcReadResponse {
+ return d.Response
}
-type PlcUnsubscriptionResponse struct {
+func (d *DefaultPlcReadRequestResult) GetErr() error {
+ return d.Err
}
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcSubscriptionRequestResult.go
similarity index 63%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcSubscriptionRequestResult.go
index 2258b16..8b6e382 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcSubscriptionRequestResult.go
@@ -19,20 +19,22 @@
package model
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
-}
+import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
+type DefaultPlcSubscriptionRequestResult struct {
+ Request model.PlcSubscriptionRequest
+ Response model.PlcSubscriptionResponse
Err error
}
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
+func (d *DefaultPlcSubscriptionRequestResult) GetRequest() model.PlcSubscriptionRequest {
+ return d.Request
+}
+
+func (d *DefaultPlcSubscriptionRequestResult) GetResponse() model.PlcSubscriptionResponse {
+ return d.Response
}
-type PlcUnsubscriptionResponse struct {
+func (d *DefaultPlcSubscriptionRequestResult) GetErr() error {
+ return d.Err
}
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionRequest.go
similarity index 69%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionRequest.go
index 2258b16..3c16592 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionRequest.go
@@ -18,21 +18,3 @@
*/
package model
-
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
-}
-
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
- Err error
-}
-
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
-}
-
-type PlcUnsubscriptionResponse struct {
-}
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionRequestResult.go
similarity index 63%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionRequestResult.go
index 2258b16..fd5f8e3 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionRequestResult.go
@@ -19,20 +19,22 @@
package model
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
-}
+import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
+type DefaultPlcUnsubscriptionRequestResult struct {
+ Request model.PlcUnsubscriptionRequest
+ Response model.PlcUnsubscriptionResponse
Err error
}
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
+func (d *DefaultPlcUnsubscriptionRequestResult) GetRequest() model.PlcUnsubscriptionRequest {
+ return d.Request
+}
+
+func (d *DefaultPlcUnsubscriptionRequestResult) GetResponse() model.PlcUnsubscriptionResponse {
+ return d.Response
}
-type PlcUnsubscriptionResponse struct {
+func (d *DefaultPlcUnsubscriptionRequestResult) GetErr() error {
+ return d.Err
}
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionResponse.go
similarity index 70%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionResponse.go
index 2258b16..df865c7 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcUnsubscriptionResponse.go
@@ -19,20 +19,5 @@
package model
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
-}
-
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
- Err error
-}
-
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
-}
-
-type PlcUnsubscriptionResponse struct {
+type DefaultPlcUnsubscriptionResponse struct {
}
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/internal/plc4go/spi/model/DefaultPlcWriteRequestResult.go
similarity index 66%
copy from plc4go/pkg/plc4go/model/plc_unsubscription.go
copy to plc4go/internal/plc4go/spi/model/DefaultPlcWriteRequestResult.go
index 2258b16..23899f6 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/internal/plc4go/spi/model/DefaultPlcWriteRequestResult.go
@@ -19,20 +19,22 @@
package model
-type PlcUnsubscriptionRequestBuilder interface {
- // TODO: Implement
-}
+import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
+type DefaultPlcWriteRequestResult struct {
+ Request model.PlcWriteRequest
+ Response model.PlcWriteResponse
Err error
}
-type PlcUnsubscriptionRequest interface {
- Execute() <-chan PlcUnsubscriptionRequestResult
- PlcRequest
+func (d *DefaultPlcWriteRequestResult) GetRequest() model.PlcWriteRequest {
+ return d.Request
+}
+
+func (d *DefaultPlcWriteRequestResult) GetResponse() model.PlcWriteResponse {
+ return d.Response
}
-type PlcUnsubscriptionResponse struct {
+func (d *DefaultPlcWriteRequestResult) GetErr() error {
+ return d.Err
}
diff --git a/plc4go/internal/plc4go/spi/testutils/DriverTestRunner.go b/plc4go/internal/plc4go/spi/testutils/DriverTestRunner.go
index 6c4a9e3..b8ca21b 100644
--- a/plc4go/internal/plc4go/spi/testutils/DriverTestRunner.go
+++ b/plc4go/internal/plc4go/spi/testutils/DriverTestRunner.go
@@ -91,8 +91,8 @@ func (m DriverTestsuite) Run(driverManager plc4go.PlcDriverManager, testcase Tes
connectionChan := driverManager.GetConnection(m.driverName + ":test://hurz" + optionsString)
connectionResult := <-connectionChan
- if connectionResult.Err != nil {
- return errors.Wrap(connectionResult.Err, "error getting a connection")
+ if connectionResult.GetConnection() != nil {
+ return errors.Wrap(connectionResult.GetErr(), "error getting a connection")
}
log.Info().Msgf("\n-------------------------------------------------------\nExecuting testcase: %s \n-------------------------------------------------------\n", testcase.name)
@@ -100,7 +100,7 @@ func (m DriverTestsuite) Run(driverManager plc4go.PlcDriverManager, testcase Tes
// Run the setup steps
log.Info().Msgf("\n-------------------------------------------------------\nPerforming setup for: %s \n-------------------------------------------------------\n", testcase.name)
for _, testStep := range m.setupSteps {
- err := m.ExecuteStep(connectionResult.Connection, &testcase, testStep)
+ err := m.ExecuteStep(connectionResult.GetConnection(), &testcase, testStep)
if err != nil {
return errors.Wrap(err, "error in setup step "+testStep.name)
}
@@ -111,7 +111,7 @@ func (m DriverTestsuite) Run(driverManager plc4go.PlcDriverManager, testcase Tes
// Run the actual scenario steps
log.Info().Msgf("\n-------------------------------------------------------\nRunning testcases for: %s \n-------------------------------------------------------\n", testcase.name)
for _, testStep := range testcase.steps {
- err := m.ExecuteStep(connectionResult.Connection, &testcase, testStep)
+ err := m.ExecuteStep(connectionResult.GetConnection(), &testcase, testStep)
if err != nil {
return errors.Wrap(err, "error in step "+testStep.name)
}
@@ -120,7 +120,7 @@ func (m DriverTestsuite) Run(driverManager plc4go.PlcDriverManager, testcase Tes
// Run the teardown steps
log.Info().Msgf("\n-------------------------------------------------------\nPerforming teardown for: %s \n-------------------------------------------------------\n", testcase.name)
for _, testStep := range m.teardownSteps {
- err := m.ExecuteStep(connectionResult.Connection, &testcase, testStep)
+ err := m.ExecuteStep(connectionResult.GetConnection(), &testcase, testStep)
if err != nil {
return errors.Wrap(err, "error in teardown step "+testStep.name)
}
@@ -211,12 +211,12 @@ func (m DriverTestsuite) ExecuteStep(connection plc4go.PlcConnection, testcase *
}
log.Trace().Msg("Waiting for read request result")
readRequestResult := <-testcase.readRequestResultChannel
- if readRequestResult.Err != nil {
- return errors.Wrap(readRequestResult.Err, "error sending response")
+ if readRequestResult.GetErr() != nil {
+ return errors.Wrap(readRequestResult.GetErr(), "error sending response")
}
// Serialize the response to XML
xmlWriteBuffer := utils.NewXmlWriteBuffer()
- err := readRequestResult.Response.(utils.Serializable).Serialize(xmlWriteBuffer)
+ err := readRequestResult.GetResponse().(utils.Serializable).Serialize(xmlWriteBuffer)
if err != nil {
return errors.Wrap(err, "error serializing response")
}
@@ -236,12 +236,12 @@ func (m DriverTestsuite) ExecuteStep(connection plc4go.PlcConnection, testcase *
}
log.Trace().Msg("Waiting for write request result")
writeResponseResult := <-testcase.writeRequestResultChannel
- if writeResponseResult.Err != nil {
- return errors.Wrap(writeResponseResult.Err, "error sending response")
+ if writeResponseResult.GetErr() != nil {
+ return errors.Wrap(writeResponseResult.GetErr(), "error sending response")
}
// Serialize the response to XML
xmlWriteBuffer := utils.NewXmlWriteBuffer()
- err := writeResponseResult.Response.(utils.Serializable).Serialize(xmlWriteBuffer)
+ err := writeResponseResult.GetResponse().(utils.Serializable).Serialize(xmlWriteBuffer)
if err != nil {
return errors.Wrap(err, "error serializing response")
}
diff --git a/plc4go/internal/plc4go/spi/testutils/ManualTestRunner.go b/plc4go/internal/plc4go/spi/testutils/ManualTestRunner.go
index 1a57910..1e23301 100644
--- a/plc4go/internal/plc4go/spi/testutils/ManualTestRunner.go
+++ b/plc4go/internal/plc4go/spi/testutils/ManualTestRunner.go
@@ -59,8 +59,8 @@ func (m *ManualTestSuite) AddTestCase(address string, expectedReadValue interfac
func (m *ManualTestSuite) Run() {
connectionResult := <-m.DriverManager.GetConnection(m.ConnectionString)
- if connectionResult.Err != nil {
- panic(connectionResult.Err)
+ if connectionResult.GetErr() != nil {
+ panic(connectionResult.GetErr())
}
connection := connectionResult
log.Info().Msg("Reading all types in separate requests")
@@ -78,7 +78,7 @@ func (m *ManualTestSuite) Run() {
func (m *ManualTestSuite) runSingleTest(t *testing.T, connection plc4go.PlcConnectionConnectResult, fieldName string, testCase ManualTestCase) {
// Prepare the read-request
- readRequestBuilder := connection.Connection.ReadRequestBuilder()
+ readRequestBuilder := connection.GetConnection().ReadRequestBuilder()
readRequestBuilder.AddQuery(fieldName, testCase.Address)
readRequest, err := readRequestBuilder.Build()
if err != nil {
@@ -87,12 +87,12 @@ func (m *ManualTestSuite) runSingleTest(t *testing.T, connection plc4go.PlcConne
// Execute the read request
readResponseResult := <-readRequest.Execute()
- if readResponseResult.Err != nil {
- t.Errorf("Error getting response %v", err)
+ if readResponseResult.GetErr() != nil {
+ t.Errorf("Error getting response %v", readResponseResult.GetErr())
t.FailNow()
return
}
- readResponse := readResponseResult.Response
+ readResponse := readResponseResult.GetResponse()
// Check the result
assertEquals(t, 1, len(readResponse.GetFieldNames()), fieldName)
@@ -129,7 +129,7 @@ func (m *ManualTestSuite) runBurstTest(t *testing.T, connection plc4go.PlcConnec
}
log.Info().Msgf(" using order: %s", sb.String())
- builder := connection.Connection.ReadRequestBuilder()
+ builder := connection.GetConnection().ReadRequestBuilder()
for _, testCase := range shuffledTestcases {
fieldName := testCase.Address
builder.AddQuery(fieldName, testCase.Address)
@@ -142,11 +142,11 @@ func (m *ManualTestSuite) runBurstTest(t *testing.T, connection plc4go.PlcConnec
// Execute the read request
readResponseResult := <-readRequest.Execute()
- if readResponseResult.Err != nil {
+ if readResponseResult.GetErr() != nil {
t.Errorf("Error getting response %v", err)
return
}
- readResponse := readResponseResult.Response
+ readResponse := readResponseResult.GetResponse()
// Check the result
assertEquals(t, len(shuffledTestcases), len(readResponse.GetFieldNames()))
diff --git a/plc4go/pkg/plc4go/connection.go b/plc4go/pkg/plc4go/connection.go
index c05b486..d2c8820 100644
--- a/plc4go/pkg/plc4go/connection.go
+++ b/plc4go/pkg/plc4go/connection.go
@@ -19,40 +19,22 @@
package plc4go
-import "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+import (
+ "github.com/apache/plc4x/plc4go/pkg/plc4go/model"
+)
-type PlcConnectionConnectResult struct {
- Connection PlcConnection
- Err error
+type PlcConnectionConnectResult interface {
+ GetConnection() PlcConnection
+ GetErr() error
}
-func NewPlcConnectionConnectResult(connection PlcConnection, err error) PlcConnectionConnectResult {
- return PlcConnectionConnectResult{
- Connection: connection,
- Err: err,
- }
+type PlcConnectionCloseResult interface {
+ GetConnection() PlcConnection
+ GetErr() error
}
-type PlcConnectionCloseResult struct {
- Connection PlcConnection
- Err error
-}
-
-func NewPlcConnectionCloseResult(connection PlcConnection, err error) PlcConnectionCloseResult {
- return PlcConnectionCloseResult{
- Connection: connection,
- Err: err,
- }
-}
-
-type PlcConnectionPingResult struct {
- Err error
-}
-
-func NewPlcConnectionPingResult(err error) PlcConnectionPingResult {
- return PlcConnectionPingResult{
- Err: err,
- }
+type PlcConnectionPingResult interface {
+ GetErr() error
}
type PlcConnection interface {
diff --git a/plc4go/pkg/plc4go/driverManager.go b/plc4go/pkg/plc4go/driverManager.go
index a8f0030..73424da 100644
--- a/plc4go/pkg/plc4go/driverManager.go
+++ b/plc4go/pkg/plc4go/driverManager.go
@@ -43,20 +43,45 @@ type PlcDriverManager interface {
Discover(callback func(event model.PlcDiscoveryEvent), options ...model.WithDiscoveryOption) error
}
-type PlcDriverManger struct {
- drivers map[string]PlcDriver
- transports map[string]transports.Transport
-}
-
func NewPlcDriverManager() PlcDriverManager {
log.Trace().Msg("Creating plc driver manager")
- return PlcDriverManger{
+ return &plcDriverManger{
drivers: map[string]PlcDriver{},
transports: map[string]transports.Transport{},
}
}
-func (m PlcDriverManger) RegisterDriver(driver PlcDriver) {
+///////////////////////////////////////
+///////////////////////////////////////
+//
+// Internal section
+//
+
+type plcDriverManger struct {
+ drivers map[string]PlcDriver
+ transports map[string]transports.Transport
+}
+
+type plcConnectionConnectResult struct {
+ connection PlcConnection
+ err error
+}
+
+func (d *plcConnectionConnectResult) GetConnection() PlcConnection {
+ return d.connection
+}
+
+func (d *plcConnectionConnectResult) GetErr() error {
+ return d.err
+}
+
+//
+// Internal section
+//
+///////////////////////////////////////
+///////////////////////////////////////
+
+func (m *plcDriverManger) RegisterDriver(driver PlcDriver) {
if driver == nil {
panic("driver must not be nil")
}
@@ -72,7 +97,7 @@ func (m PlcDriverManger) RegisterDriver(driver PlcDriver) {
log.Info().Str("protocolName", driver.GetProtocolName()).Msgf("Driver for %s registered", driver.GetProtocolName())
}
-func (m PlcDriverManger) ListDriverNames() []string {
+func (m *plcDriverManger) ListDriverNames() []string {
log.Trace().Msg("Listing driver names")
var driverNames []string
for driverName := range m.drivers {
@@ -82,14 +107,14 @@ func (m PlcDriverManger) ListDriverNames() []string {
return driverNames
}
-func (m PlcDriverManger) GetDriver(driverName string) (PlcDriver, error) {
+func (m *plcDriverManger) GetDriver(driverName string) (PlcDriver, error) {
if val, ok := m.drivers[driverName]; ok {
return val, nil
}
return nil, errors.Errorf("couldn't find driver %s", driverName)
}
-func (m PlcDriverManger) RegisterTransport(transport transports.Transport) {
+func (m *plcDriverManger) RegisterTransport(transport transports.Transport) {
if transport == nil {
panic("transport must not be nil")
}
@@ -105,7 +130,7 @@ func (m PlcDriverManger) RegisterTransport(transport transports.Transport) {
log.Info().Str("transportName", transport.GetTransportName()).Msgf("Transport for %s registered", transport.GetTransportName())
}
-func (m PlcDriverManger) ListTransportNames() []string {
+func (m *plcDriverManger) ListTransportNames() []string {
log.Trace().Msg("Listing transport names")
var transportNames []string
for transportName := range m.transports {
@@ -115,7 +140,7 @@ func (m PlcDriverManger) ListTransportNames() []string {
return transportNames
}
-func (m PlcDriverManger) GetTransport(transportName string, _ string, _ map[string][]string) (transports.Transport, error) {
+func (m *plcDriverManger) GetTransport(transportName string, _ string, _ map[string][]string) (transports.Transport, error) {
if val, ok := m.transports[transportName]; ok {
log.Debug().Str("transportName", transportName).Msg("Returning transport")
return val, nil
@@ -123,7 +148,7 @@ func (m PlcDriverManger) GetTransport(transportName string, _ string, _ map[stri
return nil, errors.Errorf("couldn't find transport %s", transportName)
}
-func (m PlcDriverManger) GetConnection(connectionString string) <-chan PlcConnectionConnectResult {
+func (m *plcDriverManger) GetConnection(connectionString string) <-chan PlcConnectionConnectResult {
log.Debug().Str("connectionString", connectionString).Msgf("Getting connection for %s", connectionString)
// Parse the connection string.
connectionUrl, err := url.Parse(connectionString)
@@ -131,7 +156,7 @@ func (m PlcDriverManger) GetConnection(connectionString string) <-chan PlcConnec
log.Error().Err(err).Msg("Error parsing connection")
ch := make(chan PlcConnectionConnectResult)
go func() {
- ch <- NewPlcConnectionConnectResult(nil, errors.Wrap(err, "error parsing connection string"))
+ ch <- &plcConnectionConnectResult{err: errors.Wrap(err, "error parsing connection string")}
}()
return ch
}
@@ -147,7 +172,7 @@ func (m PlcDriverManger) GetConnection(connectionString string) <-chan PlcConnec
log.Err(err).Str("driverName", driverName).Msgf("Couldn't get driver for %s", driverName)
ch := make(chan PlcConnectionConnectResult)
go func() {
- ch <- NewPlcConnectionConnectResult(nil, errors.Wrap(err, "error getting driver for connection string"))
+ ch <- &plcConnectionConnectResult{err: errors.Wrap(err, "error getting driver for connection string")}
}()
return ch
}
@@ -165,7 +190,7 @@ func (m PlcDriverManger) GetConnection(connectionString string) <-chan PlcConnec
log.Err(err).Str("connectionUrl.Opaque", connectionUrl.Opaque).Msg("Couldn't get transport due to parsing error")
ch := make(chan PlcConnectionConnectResult)
go func() {
- ch <- NewPlcConnectionConnectResult(nil, errors.Wrap(err, "error parsing connection string"))
+ ch <- &plcConnectionConnectResult{err: errors.Wrap(err, "error parsing connection string")}
}()
return ch
}
@@ -188,7 +213,7 @@ func (m PlcDriverManger) GetConnection(connectionString string) <-chan PlcConnec
log.Error().Msg("got a empty transport")
ch := make(chan PlcConnectionConnectResult)
go func() {
- ch <- NewPlcConnectionConnectResult(nil, errors.New("no transport specified and no default defined by driver"))
+ ch <- &plcConnectionConnectResult{err: errors.New("no transport specified and no default defined by driver")}
}()
return ch
}
@@ -205,7 +230,7 @@ func (m PlcDriverManger) GetConnection(connectionString string) <-chan PlcConnec
return driver.GetConnection(transportUrl, m.transports, configOptions)
}
-func (m PlcDriverManger) Discover(callback func(event model.PlcDiscoveryEvent), options ...model.WithDiscoveryOption) error {
+func (m *plcDriverManger) Discover(callback func(event model.PlcDiscoveryEvent), options ...model.WithDiscoveryOption) error {
// Check if we've got at least one option to restrict to certain protocols only.
// If there is at least one, we only check that protocol, if there are none, all
// available protocols are checked.
diff --git a/plc4go/pkg/plc4go/model/plc_browse.go b/plc4go/pkg/plc4go/model/plc_browse.go
index cae5939..e7f9bc3 100644
--- a/plc4go/pkg/plc4go/model/plc_browse.go
+++ b/plc4go/pkg/plc4go/model/plc_browse.go
@@ -24,13 +24,13 @@ type PlcBrowseRequestBuilder interface {
Build() (PlcBrowseRequest, error)
}
-type PlcBrowseQueryResult struct {
- Field PlcField
- Name string
- Readable bool
- Writable bool
- Subscribable bool
- PossibleDataTypes []string
+type PlcBrowseQueryResult interface {
+ GetField() PlcField
+ GetName() string
+ IsReadable() bool
+ IsWritable() bool
+ IsSubscribable() bool
+ GetPossibleDataTypes() []string
}
type PlcBrowseRequest interface {
@@ -50,15 +50,15 @@ type PlcBrowseResponse interface {
PlcResponse
}
-type PlcBrowseRequestResult struct {
- Request PlcBrowseRequest
- Response PlcBrowseResponse
- Err error
+type PlcBrowseRequestResult interface {
+ GetRequest() PlcBrowseRequest
+ GetResponse() PlcBrowseResponse
+ GetErr() error
}
-type PlcBrowseEvent struct {
- Request PlcBrowseRequest
- QueryName string
- Result *PlcBrowseQueryResult
- Err error
+type PlcBrowseEvent interface {
+ GetRequest() PlcBrowseRequest
+ GetQueryName() string
+ GetResult() PlcBrowseQueryResult
+ GetErr() error
}
diff --git a/plc4go/pkg/plc4go/model/plc_discovery.go b/plc4go/pkg/plc4go/model/plc_discovery.go
index 98edb02..4527621 100644
--- a/plc4go/pkg/plc4go/model/plc_discovery.go
+++ b/plc4go/pkg/plc4go/model/plc_discovery.go
@@ -21,22 +21,12 @@ package model
import "net/url"
-type PlcDiscoveryEvent struct {
- ProtocolCode string
- TransportCode string
- TransportUrl url.URL
- Options map[string][]string
- Name string
-}
-
-func NewPlcDiscoveryEvent(protocolCode string, transportCode string, transportUrl url.URL, options map[string][]string, name string) PlcDiscoveryEvent {
- return PlcDiscoveryEvent{
- ProtocolCode: protocolCode,
- TransportCode: transportCode,
- TransportUrl: transportUrl,
- Options: options,
- Name: name,
- }
+type PlcDiscoveryEvent interface {
+ GetProtocolCode() string
+ GetTransportCode() string
+ GetTransportUrl() url.URL
+ GetOptions() map[string][]string
+ GetName() string
}
func WithDiscoveryOptionProtocol(protocolName string) WithDiscoveryOption {
@@ -69,14 +59,16 @@ func WithDiscoveryOptionRemoteAddress(remoteAddress string) WithDiscoveryOption
}
}
-/////////////////////////////////////////////////////////////////////////////////////////7
-// Internal
-/////////////////////////////////////////////////////////////////////////////////////////7
-
type WithDiscoveryOption interface {
IsDiscoveryOption() bool
}
+///////////////////////////////////////
+///////////////////////////////////////
+//
+// Internal section
+//
+
type discoveryOption struct {
}
@@ -233,3 +225,9 @@ type discoveryOptionRemoteAddress struct {
func (d *discoveryOptionRemoteAddress) GetRemoteAddress() string {
return d.remoteAddress
}
+
+//
+// Internal section
+//
+///////////////////////////////////////
+///////////////////////////////////////
diff --git a/plc4go/pkg/plc4go/model/plc_read.go b/plc4go/pkg/plc4go/model/plc_read.go
index 02990c6..ed1dd52 100644
--- a/plc4go/pkg/plc4go/model/plc_read.go
+++ b/plc4go/pkg/plc4go/model/plc_read.go
@@ -27,10 +27,10 @@ type PlcReadRequestBuilder interface {
Build() (PlcReadRequest, error)
}
-type PlcReadRequestResult struct {
- Request PlcReadRequest
- Response PlcReadResponse
- Err error
+type PlcReadRequestResult interface {
+ GetRequest() PlcReadRequest
+ GetResponse() PlcReadResponse
+ GetErr() error
}
type PlcReadRequest interface {
diff --git a/plc4go/pkg/plc4go/model/plc_subscription.go b/plc4go/pkg/plc4go/model/plc_subscription.go
index 73d6cd1..90f58e7 100644
--- a/plc4go/pkg/plc4go/model/plc_subscription.go
+++ b/plc4go/pkg/plc4go/model/plc_subscription.go
@@ -46,10 +46,10 @@ type PlcSubscriptionRequestBuilder interface {
Build() (PlcSubscriptionRequest, error)
}
-type PlcSubscriptionRequestResult struct {
- Request PlcSubscriptionRequest
- Response PlcSubscriptionResponse
- Err error
+type PlcSubscriptionRequestResult interface {
+ GetRequest() PlcSubscriptionRequest
+ GetResponse() PlcSubscriptionResponse
+ GetErr() error
}
type PlcSubscriptionRequest interface {
diff --git a/plc4go/pkg/plc4go/model/plc_unsubscription.go b/plc4go/pkg/plc4go/model/plc_unsubscription.go
index 2258b16..ac48091 100644
--- a/plc4go/pkg/plc4go/model/plc_unsubscription.go
+++ b/plc4go/pkg/plc4go/model/plc_unsubscription.go
@@ -23,10 +23,10 @@ type PlcUnsubscriptionRequestBuilder interface {
// TODO: Implement
}
-type PlcUnsubscriptionRequestResult struct {
- Request PlcUnsubscriptionRequest
- Response PlcUnsubscriptionResponse
- Err error
+type PlcUnsubscriptionRequestResult interface {
+ GetRequest() PlcUnsubscriptionRequest
+ GetResponse() PlcUnsubscriptionResponse
+ GetErr() error
}
type PlcUnsubscriptionRequest interface {
@@ -34,5 +34,5 @@ type PlcUnsubscriptionRequest interface {
PlcRequest
}
-type PlcUnsubscriptionResponse struct {
+type PlcUnsubscriptionResponse interface {
}
diff --git a/plc4go/pkg/plc4go/model/plc_write.go b/plc4go/pkg/plc4go/model/plc_write.go
index 68b9670..52ec80d 100644
--- a/plc4go/pkg/plc4go/model/plc_write.go
+++ b/plc4go/pkg/plc4go/model/plc_write.go
@@ -27,10 +27,10 @@ type PlcWriteRequestBuilder interface {
Build() (PlcWriteRequest, error)
}
-type PlcWriteRequestResult struct {
- Request PlcWriteRequest
- Response PlcWriteResponse
- Err error
+type PlcWriteRequestResult interface {
+ GetRequest() PlcWriteRequest
+ GetResponse() PlcWriteResponse
+ GetErr() error
}
type PlcWriteRequest interface {