From 01a4c49324392003717106267c56126275b9058b Mon Sep 17 00:00:00 2001 From: Juha Hyttinen Date: Tue, 4 Feb 2020 19:29:26 +0200 Subject: [PATCH] Cleaning and bug fixes Using temporary c buffer while packing asn1 message. In some cases at least in unittests, some go strings were corrupted during subscription delete request pack. Root cause was not found, but after using c buffer things did stablized. Change-Id: I22b0af72209e2958a9844113f1d35a0d31213b92 Signed-off-by: Juha Hyttinen --- Dockerfile | 24 +- e2ap/pkg/e2ap/e2ap_packerif.go | 174 +------ e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscription.go | 69 +-- .../e2ap/e2ap_tests/msg_e2ap_subscriptiondelete.go | 69 +-- e2ap/pkg/e2ap_wrapper/packer_e2ap.go | 502 +++++++++------------ e2ap/pkg/packer/packer.go | 58 +-- pkg/control/e2ap.go | 72 +-- pkg/control/ut_messaging_test.go | 10 +- pkg/control/ut_stub_e2term_test.go | 88 ++-- pkg/control/ut_stub_xapp_test.go | 142 +++--- pkg/control/ut_test.go | 24 +- 11 files changed, 426 insertions(+), 806 deletions(-) diff --git a/Dockerfile b/Dockerfile index 3f9ad1c..969abcb 100644 --- a/Dockerfile +++ b/Dockerfile @@ -22,7 +22,7 @@ # FROM nexus3.o-ran-sc.org:10004/bldr-ubuntu18-c-go:3-u18.04-nng as submgrprebuild -RUN apt update && apt install -y iputils-ping net-tools curl tcpdump gdb +RUN apt update && apt install -y iputils-ping net-tools curl tcpdump gdb valgrind WORKDIR /tmp @@ -32,10 +32,6 @@ RUN wget --content-disposition https://packagecloud.io/o-ran-sc/staging/packages # Install RMr development header files RUN wget --content-disposition https://packagecloud.io/o-ran-sc/staging/packages/debian/stretch/rmr-dev_${RMRVERSION}_amd64.deb/download.deb && dpkg -i rmr-dev_${RMRVERSION}_amd64.deb && rm -rf rmr-dev_${RMRVERSION}_amd64.deb -# "PULLING LOG and COMPILING LOG" -#RUN git clone "https://gerrit.o-ran-sc.org/r/com/log" /opt/log && cd /opt/log && \ -# ./autogen.sh && ./configure && make install && ldconfig - # "Installing Swagger" RUN cd /usr/local/go/bin \ && wget --quiet https://github.com/go-swagger/go-swagger/releases/download/v0.19.0/swagger_linux_amd64 \ @@ -43,6 +39,10 @@ RUN cd /usr/local/go/bin \ && chmod +x swagger +ENV GOPATH=/root/.go +ENV PATH=$PATH:/root/.go/bin +RUN /usr/local/go/bin/go get -u github.com/go-delve/delve/cmd/dlv + WORKDIR /opt/submgr RUN mkdir pkg @@ -55,16 +55,16 @@ ENV CGO_CFLAGS="-DASN_DISABLE_OER_SUPPORT" COPY 3rdparty 3rdparty RUN cd 3rdparty/libe2ap && \ - gcc -c ${CFLAGS} -I. -fPIC *.c && \ - gcc *.o -shared -o libe2ap.so && \ + gcc -c ${CFLAGS} -I. -g -fPIC *.c && \ + gcc *.o -g -shared -o libe2ap.so && \ cp libe2ap.so /usr/local/lib/ && \ cp *.h /usr/local/include/ && \ ldconfig COPY e2ap e2ap RUN cd e2ap/libe2ap_wrapper && \ - gcc -c ${CFLAGS} -fPIC *.c && \ - gcc *.o -shared -o libe2ap_wrapper.so && \ + gcc -c ${CFLAGS} -g -fPIC *.c && \ + gcc *.o -g -shared -o libe2ap_wrapper.so && \ cp libe2ap_wrapper.so /usr/local/lib/ && \ cp *.h /usr/local/include/ && \ ldconfig @@ -119,13 +119,17 @@ RUN /usr/local/go/bin/go mod tidy COPY test/config-file.json test/config-file.json ENV CFG_FILE=/opt/submgr/test/config-file.json -RUN /usr/local/go/bin/go test -test.coverprofile /tmp/submgr_cover.out -count=1 -v ./pkg/control +RUN /usr/local/go/bin/go test -test.coverprofile /tmp/submgr_cover.out -count=1 -v ./pkg/control + +#-c -o submgr_test +#RUN ./submgr_test -test.coverprofile /tmp/submgr_cover.out RUN /usr/local/go/bin/go tool cover -html=/tmp/submgr_cover.out -o /tmp/submgr_cover.html # test formating (not important) RUN test -z "$(/usr/local/go/bin/gofmt -l pkg/control/*.go)" + # # # diff --git a/e2ap/pkg/e2ap/e2ap_packerif.go b/e2ap/pkg/e2ap/e2ap_packerif.go index 23e5b0a..6a9c80d 100644 --- a/e2ap/pkg/e2ap/e2ap_packerif.go +++ b/e2ap/pkg/e2ap/e2ap_packerif.go @@ -20,71 +20,63 @@ package e2ap import ( - "fmt" "gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer" ) -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -type E2APMsgPackerIf interface { - Pack(*packer.PackedData) (error, *packer.PackedData) - UnPack(msg *packer.PackedData) error - String() string -} - //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- type E2APMsgPackerSubscriptionRequestIf interface { - E2APMsgPackerIf - Set(*E2APSubscriptionRequest) error - Get() (error, *E2APSubscriptionRequest) + Pack(*E2APSubscriptionRequest) (error, *packer.PackedData) + UnPack(msg *packer.PackedData) (error, *E2APSubscriptionRequest) + String() string } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- type E2APMsgPackerSubscriptionResponseIf interface { - E2APMsgPackerIf - Set(*E2APSubscriptionResponse) error - Get() (error, *E2APSubscriptionResponse) + Pack(*E2APSubscriptionResponse) (error, *packer.PackedData) + UnPack(msg *packer.PackedData) (error, *E2APSubscriptionResponse) + String() string } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- type E2APMsgPackerSubscriptionFailureIf interface { - E2APMsgPackerIf - Set(*E2APSubscriptionFailure) error - Get() (error, *E2APSubscriptionFailure) + Pack(*E2APSubscriptionFailure) (error, *packer.PackedData) + UnPack(msg *packer.PackedData) (error, *E2APSubscriptionFailure) + String() string } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- type E2APMsgPackerSubscriptionDeleteRequestIf interface { - E2APMsgPackerIf - Set(*E2APSubscriptionDeleteRequest) error - Get() (error, *E2APSubscriptionDeleteRequest) + Pack(*E2APSubscriptionDeleteRequest) (error, *packer.PackedData) + Pack21(*E2APSubscriptionDeleteRequest) (error, *packer.PackedData) + Pack22(*E2APSubscriptionDeleteRequest) (error, *packer.PackedData) + UnPack(msg *packer.PackedData) (error, *E2APSubscriptionDeleteRequest) + String() string } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- type E2APMsgPackerSubscriptionDeleteResponseIf interface { - E2APMsgPackerIf - Set(*E2APSubscriptionDeleteResponse) error - Get() (error, *E2APSubscriptionDeleteResponse) + Pack(*E2APSubscriptionDeleteResponse) (error, *packer.PackedData) + UnPack(msg *packer.PackedData) (error, *E2APSubscriptionDeleteResponse) + String() string } //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- type E2APMsgPackerSubscriptionDeleteFailureIf interface { - E2APMsgPackerIf - Set(*E2APSubscriptionDeleteFailure) error - Get() (error, *E2APSubscriptionDeleteFailure) + Pack(*E2APSubscriptionDeleteFailure) (error, *packer.PackedData) + UnPack(msg *packer.PackedData) (error, *E2APSubscriptionDeleteFailure) + String() string } //----------------------------------------------------------------------------- @@ -97,128 +89,6 @@ type E2APPackerIf interface { NewPackerSubscriptionDeleteRequest() E2APMsgPackerSubscriptionDeleteRequestIf NewPackerSubscriptionDeleteResponse() E2APMsgPackerSubscriptionDeleteResponseIf NewPackerSubscriptionDeleteFailure() E2APMsgPackerSubscriptionDeleteFailureIf - MessageInfo(msg *packer.PackedData) *packer.MessageInfo -} - -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -type E2APAutoPacker struct { - packer E2APPackerIf -} - -func NewE2APAutoPacker(packer E2APPackerIf) *E2APAutoPacker { - return &E2APAutoPacker{packer: packer} -} - -// TODO improve openasn handling to reuse PDU etc... -// Now practically decodes two times each E2/X2 message, as first round solves message type -func (autopacker *E2APAutoPacker) UnPack(msg *packer.PackedData) (error, interface{}) { - var err error = nil - msgInfo := autopacker.packer.MessageInfo(msg) - if msgInfo != nil { - switch msgInfo.MsgType { - case E2AP_InitiatingMessage: - switch msgInfo.MsgId { - case E2AP_RICSubscriptionRequest: - unpa := autopacker.packer.NewPackerSubscriptionRequest() - err = unpa.UnPack(msg) - if err == nil { - return unpa.Get() - } - case E2AP_RICSubscriptionDeleteRequest: - unpa := autopacker.packer.NewPackerSubscriptionDeleteRequest() - err = unpa.UnPack(msg) - if err == nil { - return unpa.Get() - } - default: - err = fmt.Errorf("MsgType: E2AP_InitiatingMessage => MsgId:%d unknown", msgInfo.MsgId) - } - case E2AP_SuccessfulOutcome: - switch msgInfo.MsgId { - case E2AP_RICSubscriptionResponse: - unpa := autopacker.packer.NewPackerSubscriptionResponse() - err = unpa.UnPack(msg) - if err == nil { - return unpa.Get() - } - case E2AP_RICSubscriptionDeleteResponse: - unpa := autopacker.packer.NewPackerSubscriptionDeleteResponse() - err = unpa.UnPack(msg) - if err == nil { - return unpa.Get() - } - default: - err = fmt.Errorf("MsgType: E2AP_SuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId) - } - case E2AP_UnsuccessfulOutcome: - switch msgInfo.MsgId { - case E2AP_RICSubscriptionFailure: - unpa := autopacker.packer.NewPackerSubscriptionFailure() - err = unpa.UnPack(msg) - if err == nil { - return unpa.Get() - } - case E2AP_RICSubscriptionDeleteFailure: - unpa := autopacker.packer.NewPackerSubscriptionDeleteFailure() - err = unpa.UnPack(msg) - if err == nil { - return unpa.Get() - } - default: - err = fmt.Errorf("MsgType: E2AP_UnsuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId) - } - default: - err = fmt.Errorf("MsgType: %d and MsgId:%d unknown", msgInfo.MsgType, msgInfo.MsgId) - } - } else { - err = fmt.Errorf("MsgInfo not received") - } - return err, nil -} - -func (autopacker *E2APAutoPacker) Pack(data interface{}, trg *packer.PackedData) (error, *packer.PackedData) { - var err error = nil - switch themsg := data.(type) { - case *E2APSubscriptionRequest: - pa := autopacker.packer.NewPackerSubscriptionRequest() - err = pa.Set(themsg) - if err == nil { - return pa.Pack(trg) - } - case *E2APSubscriptionResponse: - pa := autopacker.packer.NewPackerSubscriptionResponse() - err = pa.Set(themsg) - if err == nil { - return pa.Pack(trg) - } - case *E2APSubscriptionFailure: - pa := autopacker.packer.NewPackerSubscriptionFailure() - err = pa.Set(themsg) - if err == nil { - return pa.Pack(trg) - } - case *E2APSubscriptionDeleteRequest: - pa := autopacker.packer.NewPackerSubscriptionDeleteRequest() - err = pa.Set(themsg) - if err == nil { - return pa.Pack(trg) - } - case *E2APSubscriptionDeleteResponse: - pa := autopacker.packer.NewPackerSubscriptionDeleteResponse() - err = pa.Set(themsg) - if err == nil { - return pa.Pack(trg) - } - case *E2APSubscriptionDeleteFailure: - pa := autopacker.packer.NewPackerSubscriptionDeleteFailure() - err = pa.Set(themsg) - if err == nil { - return pa.Pack(trg) - } - default: - err = fmt.Errorf("unknown message") - } - return err, nil + //UnPack(*packer.PackedData) (error, interface{}) + //Pack(interface{}, *packer.PackedData) (error, *packer.PackedData) } diff --git a/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscription.go b/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscription.go index dd4f460..d865703 100644 --- a/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscription.go +++ b/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscription.go @@ -34,30 +34,20 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionRequestWithData(t *testing.T, testCtxt.testPrint("########## ##########") testCtxt.testPrint("init") - seterr := e2SubsReq.Set(areqenc) - if seterr != nil { - testCtxt.testError(t, "set err: %s", seterr.Error()) - return - } - testCtxt.testPrint("print:\n%s", e2SubsReq.String()) testCtxt.testPrint("pack") - err, packedMsg := e2SubsReq.Pack(nil) + err, packedMsg := e2SubsReq.Pack(areqenc) if err != nil { testCtxt.testError(t, "Pack failed: %s", err.Error()) return } + testCtxt.testPrint("print:\n%s", e2SubsReq.String()) testCtxt.testPrint("unpack") - err = e2SubsReq.UnPack(packedMsg) + err, areqdec := e2SubsReq.UnPack(packedMsg) if err != nil { testCtxt.testError(t, "UnPack failed: %s", err.Error()) return } testCtxt.testPrint("print:\n%s", e2SubsReq.String()) - geterr, areqdec := e2SubsReq.Get() - if geterr != nil { - testCtxt.testError(t, "get nil: %s", geterr.Error()) - return - } testCtxt.testValueEquality(t, "msg", areqenc, areqdec) testCtxt.testValueEquality(t, "EventTriggerDefinition", &areqenc.EventTriggerDefinition, &areqdec.EventTriggerDefinition) } @@ -142,30 +132,20 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionResponse(t *testing.T) { arespenc.ActionNotAdmittedList.Items = append(arespenc.ActionNotAdmittedList.Items, item) } - seterr := e2SubsResp.Set(&arespenc) - if seterr != nil { - testCtxt.testError(t, "set err: %s", seterr.Error()) - return - } - testCtxt.testPrint("print:\n%s", e2SubsResp.String()) testCtxt.testPrint("pack") - err, packedMsg := e2SubsResp.Pack(nil) + err, packedMsg := e2SubsResp.Pack(&arespenc) if err != nil { testCtxt.testError(t, "Pack failed: %s", err.Error()) return } + testCtxt.testPrint("print:\n%s", e2SubsResp.String()) testCtxt.testPrint("unpack") - err = e2SubsResp.UnPack(packedMsg) + err, arespdec := e2SubsResp.UnPack(packedMsg) if err != nil { testCtxt.testError(t, "UnPack failed: %s", err.Error()) return } testCtxt.testPrint("print:\n%s", e2SubsResp.String()) - geterr, arespdec := e2SubsResp.Get() - if geterr != nil { - testCtxt.testError(t, "get nil: %s", geterr.Error()) - return - } testCtxt.testValueEquality(t, "msg", &arespenc, arespdec) } @@ -205,30 +185,20 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionFailure(t *testing.T) { // afailenc.CriticalityDiagnostics.CriticalityDiagnosticsIEList.Items = append(afailenc.CriticalityDiagnostics.CriticalityDiagnosticsIEList.Items, ieitem) // } - seterr := e2SubsFail.Set(&afailenc) - if seterr != nil { - testCtxt.testError(t, "set err: %s", seterr.Error()) - return - } - testCtxt.testPrint("print:\n%s", e2SubsFail.String()) testCtxt.testPrint("pack") - err, packedMsg := e2SubsFail.Pack(nil) + err, packedMsg := e2SubsFail.Pack(&afailenc) if err != nil { testCtxt.testError(t, "Pack failed: %s", err.Error()) return } + testCtxt.testPrint("print:\n%s", e2SubsFail.String()) testCtxt.testPrint("unpack") - err = e2SubsFail.UnPack(packedMsg) + err, afaildec := e2SubsFail.UnPack(packedMsg) if err != nil { testCtxt.testError(t, "UnPack failed: %s", err.Error()) return } testCtxt.testPrint("print:\n%s", e2SubsFail.String()) - geterr, afaildec := e2SubsFail.Get() - if geterr != nil { - testCtxt.testError(t, "get nil: %s", geterr.Error()) - return - } testCtxt.testValueEquality(t, "msg", &afailenc, afaildec) } @@ -240,16 +210,11 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionRequestBuffers(t *testing.T) { return } e2SubResp := testCtxt.packerif.NewPackerSubscriptionRequest() - err := e2SubResp.UnPack(packedData) + err, _ := e2SubResp.UnPack(packedData) if err != nil { testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer) return } - err, _ = e2SubResp.Get() - if err != nil { - testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer) - return - } testCtxt.testPrint("OK [%s]", buffer) } @@ -265,16 +230,11 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionResponseBuffers(t *testing.T) return } e2SubResp := testCtxt.packerif.NewPackerSubscriptionResponse() - err := e2SubResp.UnPack(packedData) + err, _ := e2SubResp.UnPack(packedData) if err != nil { testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer) return } - err, _ = e2SubResp.Get() - if err != nil { - testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer) - return - } testCtxt.testPrint("OK [%s]", buffer) } @@ -292,16 +252,11 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionFailureBuffers(t *testing.T) { return } e2SubResp := testCtxt.packerif.NewPackerSubscriptionFailure() - err := e2SubResp.UnPack(packedData) + err, _ := e2SubResp.UnPack(packedData) if err != nil { testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer) return } - err, _ = e2SubResp.Get() - if err != nil { - testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer) - return - } testCtxt.testPrint("OK [%s]", buffer) } diff --git a/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscriptiondelete.go b/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscriptiondelete.go index aa0fc39..9eeccff 100644 --- a/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscriptiondelete.go +++ b/e2ap/pkg/e2ap/e2ap_tests/msg_e2ap_subscriptiondelete.go @@ -42,30 +42,20 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionDeleteRequest(t *testing.T) { areqenc.RequestId.Seq = 22 areqenc.FunctionId = 33 - seterr := e2SubsReq.Set(&areqenc) - if seterr != nil { - testCtxt.testError(t, "set err: %s", seterr.Error()) - return - } - testCtxt.testPrint("print:\n%s", e2SubsReq.String()) testCtxt.testPrint("pack") - err, packedMsg := e2SubsReq.Pack(nil) + err, packedMsg := e2SubsReq.Pack(&areqenc) if err != nil { testCtxt.testError(t, "Pack failed: %s", err.Error()) return } + testCtxt.testPrint("print:\n%s", e2SubsReq.String()) testCtxt.testPrint("unpack") - err = e2SubsReq.UnPack(packedMsg) + err, areqdec := e2SubsReq.UnPack(packedMsg) if err != nil { testCtxt.testError(t, "UnPack failed: %s", err.Error()) return } testCtxt.testPrint("print:\n%s", e2SubsReq.String()) - geterr, areqdec := e2SubsReq.Get() - if geterr != nil { - testCtxt.testError(t, "get nil: %s", geterr.Error()) - return - } testCtxt.testValueEquality(t, "msg", &areqenc, areqdec) } @@ -83,30 +73,20 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionDeleteResponse(t *testing.T) { arespenc.RequestId.Seq = 22 arespenc.FunctionId = 33 - seterr := e2SubsResp.Set(&arespenc) - if seterr != nil { - testCtxt.testError(t, "set err: %s", seterr.Error()) - return - } - testCtxt.testPrint("print:\n%s", e2SubsResp.String()) testCtxt.testPrint("pack") - err, packedMsg := e2SubsResp.Pack(nil) + err, packedMsg := e2SubsResp.Pack(&arespenc) if err != nil { testCtxt.testError(t, "Pack failed: %s", err.Error()) return } + testCtxt.testPrint("print:\n%s", e2SubsResp.String()) testCtxt.testPrint("unpack") - err = e2SubsResp.UnPack(packedMsg) + err, arespdec := e2SubsResp.UnPack(packedMsg) if err != nil { testCtxt.testError(t, "UnPack failed: %s", err.Error()) return } testCtxt.testPrint("print:\n%s", e2SubsResp.String()) - geterr, arespdec := e2SubsResp.Get() - if geterr != nil { - testCtxt.testError(t, "get nil: %s", geterr.Error()) - return - } testCtxt.testValueEquality(t, "msg", &arespenc, arespdec) } @@ -141,30 +121,20 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionDeleteFailure(t *testing.T) { // afailenc.CriticalityDiagnostics.CriticalityDiagnosticsIEList.Items = append(afailenc.CriticalityDiagnostics.CriticalityDiagnosticsIEList.Items, ieitem) // } - seterr := e2SubsFail.Set(&afailenc) - if seterr != nil { - testCtxt.testError(t, "set err: %s", seterr.Error()) - return - } - testCtxt.testPrint("print:\n%s", e2SubsFail.String()) testCtxt.testPrint("pack") - err, packedMsg := e2SubsFail.Pack(nil) + err, packedMsg := e2SubsFail.Pack(&afailenc) if err != nil { testCtxt.testError(t, "Pack failed: %s", err.Error()) return } + testCtxt.testPrint("print:\n%s", e2SubsFail.String()) testCtxt.testPrint("unpack") - err = e2SubsFail.UnPack(packedMsg) + err, afaildec := e2SubsFail.UnPack(packedMsg) if err != nil { testCtxt.testError(t, "UnPack failed: %s", err.Error()) return } testCtxt.testPrint("print:\n%s", e2SubsFail.String()) - geterr, afaildec := e2SubsFail.Get() - if geterr != nil { - testCtxt.testError(t, "get nil: %s", geterr.Error()) - return - } testCtxt.testValueEquality(t, "msg", &afailenc, afaildec) } @@ -176,16 +146,11 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionDeleteRequestBuffers(t *testin return } e2SubResp := testCtxt.packerif.NewPackerSubscriptionDeleteRequest() - err := e2SubResp.UnPack(packedData) + err, _ := e2SubResp.UnPack(packedData) if err != nil { testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer) return } - err, _ = e2SubResp.Get() - if err != nil { - testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer) - return - } testCtxt.testPrint("OK [%s]", buffer) } @@ -214,16 +179,11 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionDeleteResponseBuffers(t *testi return } e2SubResp := testCtxt.packerif.NewPackerSubscriptionDeleteResponse() - err := e2SubResp.UnPack(packedData) + err, _ := e2SubResp.UnPack(packedData) if err != nil { testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer) return } - err, _ = e2SubResp.Get() - if err != nil { - testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer) - return - } testCtxt.testPrint("OK [%s]", buffer) } @@ -240,16 +200,11 @@ func (testCtxt *E2ApTests) E2ApTestMsgSubscriptionDeleteFailureBuffers(t *testin return } e2SubResp := testCtxt.packerif.NewPackerSubscriptionDeleteFailure() - err := e2SubResp.UnPack(packedData) + err, _ := e2SubResp.UnPack(packedData) if err != nil { testCtxt.testError(t, "UnPack() Failed: %s [%s]", err.Error(), buffer) return } - err, _ = e2SubResp.Get() - if err != nil { - testCtxt.testError(t, "Get() Failed: %s [%s]", err.Error(), buffer) - return - } testCtxt.testPrint("OK [%s]", buffer) } diff --git a/e2ap/pkg/e2ap_wrapper/packer_e2ap.go b/e2ap/pkg/e2ap_wrapper/packer_e2ap.go index 868c344..a312964 100644 --- a/e2ap/pkg/e2ap_wrapper/packer_e2ap.go +++ b/e2ap/pkg/e2ap_wrapper/packer_e2ap.go @@ -55,6 +55,9 @@ import ( "unsafe" ) +const cMsgBufferMaxSize = 40960 +const cMsgBufferExtra = 512 + //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- @@ -471,14 +474,6 @@ func (e2apMsg *e2apMessage) MessageInfo() *packer.MessageInfo { return nil } -func (e2apMsg *e2apMessage) UnPack(msg *packer.PackedData) *packer.MessageInfo { - err := packer.PduPackerUnPack(e2apMsg, msg) - if err != nil { - return nil - } - return e2apMsg.MessageInfo() -} - func (e2apMsg *e2apMessage) String() string { msgInfo := e2apMsg.MessageInfo() if msgInfo == nil { @@ -496,48 +491,69 @@ type e2apMsgSubscriptionRequest struct { msgC *C.RICSubscriptionRequest_t } -func (e2apMsg *e2apMsgSubscriptionRequest) Set(data *e2ap.E2APSubscriptionRequest) error { +func (e2apMsg *e2apMsgSubscriptionRequest) PduPack(logBuf []byte) (error, *packer.PackedData) { + p := C.malloc(C.size_t(cMsgBufferMaxSize)) + defer C.free(p) + plen := C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra + errorNro := C.packRICSubscriptionRequest(&plen, (*C.uchar)(p), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))), nil + } + return nil, &packer.PackedData{C.GoBytes(p, C.int(plen))} +} +func (e2apMsg *e2apMsgSubscriptionRequest) PduUnPack(logBuf []byte, data *packer.PackedData) error { e2apMsg.msgC = &C.RICSubscriptionRequest_t{} C.initSubsRequest(e2apMsg.msgC) + e2apMsg.e2apMessage.PduUnPack(logBuf, data) + if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2InitiatingMessage || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICSubscriptionRequest { + return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) + } + errorNro := C.getRICSubscriptionRequestData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) + } + return nil +} - e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) +func (e2apMsg *e2apMsgSubscriptionRequest) Pack(data *e2ap.E2APSubscriptionRequest) (error, *packer.PackedData) { + e2apMsg.msgC = &C.RICSubscriptionRequest_t{} + C.initSubsRequest(e2apMsg.msgC) + e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { - return err + return err, nil } if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition}).set(&data.EventTriggerDefinition); err != nil { - return err + return err, nil } - if len(data.ActionSetups) > 16 { - return fmt.Errorf("IndicationMessage.InterfaceMessage: too long %d while allowed %d", len(data.ActionSetups), 16) + return fmt.Errorf("IndicationMessage.InterfaceMessage: too long %d while allowed %d", len(data.ActionSetups), 16), nil } - e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength = 0 for i := 0; i < len(data.ActionSetups); i++ { item := &e2apEntryActionToBeSetupItem{entry: &e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.ricActionToBeSetupItem[e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength]} e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength += 1 if err := item.set(&data.ActionSetups[i]); err != nil { - return err + return err, nil } } - return nil -} -func (e2apMsg *e2apMsgSubscriptionRequest) Get() (error, *e2ap.E2APSubscriptionRequest) { + return packer.PduPackerPack(e2apMsg) +} +func (e2apMsg *e2apMsgSubscriptionRequest) UnPack(msg *packer.PackedData) (error, *e2ap.E2APSubscriptionRequest) { data := &e2ap.E2APSubscriptionRequest{} - + if err := packer.PduPackerUnPack(e2apMsg, msg); err != nil { + return err, data + } data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) - if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { return err, data } if err := (&e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition}).get(&data.EventTriggerDefinition); err != nil { return err, data } - conlen := (int)(e2apMsg.msgC.ricSubscription.ricActionToBeSetupItemIEs.contentLength) data.ActionSetups = make([]e2ap.ActionToBeSetupItem, conlen) for i := 0; i < conlen; i++ { @@ -550,57 +566,6 @@ func (e2apMsg *e2apMsgSubscriptionRequest) Get() (error, *e2ap.E2APSubscriptionR } -func (e2apMsg *e2apMsgSubscriptionRequest) PduPack(logBuf []byte, data *packer.PackedData) error { - /* - Not needed anymore - - evtTrig := e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition} - if err := evtTrig.pack(); err != nil { - return err - } - */ - var buflen uint32 = (uint32)(len(data.Buf)) - errorNro := C.packRICSubscriptionRequest((*C.size_t)(unsafe.Pointer(&buflen)), (*C.uchar)(unsafe.Pointer(&data.Buf[0])), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - data.Buf = data.Buf[0:buflen] - return nil - -} - -func (e2apMsg *e2apMsgSubscriptionRequest) PduUnPack(logBuf []byte, data *packer.PackedData) error { - - e2apMsg.msgC = &C.RICSubscriptionRequest_t{} - C.initSubsRequest(e2apMsg.msgC) - - e2apMsg.e2apMessage.PduUnPack(logBuf, data) - if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2InitiatingMessage || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICSubscriptionRequest { - return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) - } - errorNro := C.getRICSubscriptionRequestData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - /* - Not needed anymore - - evtTrig := e2apEntryEventTrigger{entry: &e2apMsg.msgC.ricSubscription.ricEventTriggerDefinition} - if err := evtTrig.unpack(); err != nil { - return err - } - */ - return nil -} - -func (e2apMsg *e2apMsgSubscriptionRequest) Pack(trg *packer.PackedData) (error, *packer.PackedData) { - return packer.PduPackerPackAllocTrg(e2apMsg, trg) -} - -func (e2apMsg *e2apMsgSubscriptionRequest) UnPack(msg *packer.PackedData) error { - return packer.PduPackerUnPack(e2apMsg, msg) -} - func (e2apMsg *e2apMsgSubscriptionRequest) String() string { var b bytes.Buffer fmt.Fprintln(&b, "ricSubscriptionRequest.") @@ -664,85 +629,72 @@ type e2apMsgSubscriptionResponse struct { msgC *C.RICSubscriptionResponse_t } -func (e2apMsg *e2apMsgSubscriptionResponse) Set(data *e2ap.E2APSubscriptionResponse) error { +func (e2apMsg *e2apMsgSubscriptionResponse) PduPack(logBuf []byte) (error, *packer.PackedData) { + p := C.malloc(C.size_t(cMsgBufferMaxSize)) + defer C.free(p) + plen := C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra + errorNro := C.packRICSubscriptionResponse(&plen, (*C.uchar)(p), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))), nil + } + return nil, &packer.PackedData{C.GoBytes(p, C.int(plen))} +} +func (e2apMsg *e2apMsgSubscriptionResponse) PduUnPack(logBuf []byte, data *packer.PackedData) error { e2apMsg.msgC = &C.RICSubscriptionResponse_t{} C.initSubsResponse(e2apMsg.msgC) - e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) + e2apMsg.e2apMessage.PduUnPack(logBuf, data) + if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2SuccessfulOutcome || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICSubscriptionResponse { + return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) + } + errorNro := C.getRICSubscriptionResponseData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) + } + return nil +} +func (e2apMsg *e2apMsgSubscriptionResponse) Pack(data *e2ap.E2APSubscriptionResponse) (error, *packer.PackedData) { + e2apMsg.msgC = &C.RICSubscriptionResponse_t{} + C.initSubsResponse(e2apMsg.msgC) + e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { - return err + return err, nil } - if err := (&e2apEntryAdmittedList{entry: &e2apMsg.msgC.ricActionAdmittedList}).set(&data.ActionAdmittedList); err != nil { - return err + return err, nil } - e2apMsg.msgC.ricActionNotAdmittedListPresent = false if len(data.ActionNotAdmittedList.Items) > 0 { e2apMsg.msgC.ricActionNotAdmittedListPresent = true if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).set(&data.ActionNotAdmittedList); err != nil { - return err + return err, nil } } - return nil + return packer.PduPackerPack(e2apMsg) } -func (e2apMsg *e2apMsgSubscriptionResponse) Get() (error, *e2ap.E2APSubscriptionResponse) { - +func (e2apMsg *e2apMsgSubscriptionResponse) UnPack(msg *packer.PackedData) (error, *e2ap.E2APSubscriptionResponse) { data := &e2ap.E2APSubscriptionResponse{} - data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) + if err := packer.PduPackerUnPack(e2apMsg, msg); err != nil { + return err, data + } + data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { return err, data } - if err := (&e2apEntryAdmittedList{entry: &e2apMsg.msgC.ricActionAdmittedList}).get(&data.ActionAdmittedList); err != nil { return err, data } - if e2apMsg.msgC.ricActionNotAdmittedListPresent == true { if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).get(&data.ActionNotAdmittedList); err != nil { return err, data } } return nil, data - -} - -func (e2apMsg *e2apMsgSubscriptionResponse) PduPack(logBuf []byte, data *packer.PackedData) error { - var buflen uint32 = (uint32)(len(data.Buf)) - errorNro := C.packRICSubscriptionResponse((*C.size_t)(unsafe.Pointer(&buflen)), (*C.uchar)(unsafe.Pointer(&data.Buf[0])), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - data.Buf = data.Buf[0:buflen] - return nil -} - -func (e2apMsg *e2apMsgSubscriptionResponse) PduUnPack(logBuf []byte, data *packer.PackedData) error { - e2apMsg.msgC = &C.RICSubscriptionResponse_t{} - C.initSubsResponse(e2apMsg.msgC) - - e2apMsg.e2apMessage.PduUnPack(logBuf, data) - if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2SuccessfulOutcome || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICSubscriptionResponse { - return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) - } - errorNro := C.getRICSubscriptionResponseData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - return nil -} - -func (e2apMsg *e2apMsgSubscriptionResponse) Pack(trg *packer.PackedData) (error, *packer.PackedData) { - return packer.PduPackerPackAllocTrg(e2apMsg, trg) -} - -func (e2apMsg *e2apMsgSubscriptionResponse) UnPack(msg *packer.PackedData) error { - return packer.PduPackerUnPack(e2apMsg, msg) } func (e2apMsg *e2apMsgSubscriptionResponse) String() string { @@ -783,91 +735,73 @@ type e2apMsgSubscriptionFailure struct { msgC *C.RICSubscriptionFailure_t } -func (e2apMsg *e2apMsgSubscriptionFailure) Set(data *e2ap.E2APSubscriptionFailure) error { +func (e2apMsg *e2apMsgSubscriptionFailure) PduPack(logBuf []byte) (error, *packer.PackedData) { + p := C.malloc(C.size_t(cMsgBufferMaxSize)) + defer C.free(p) + plen := C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra + errorNro := C.packRICSubscriptionFailure(&plen, (*C.uchar)(p), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))), nil + } + return nil, &packer.PackedData{C.GoBytes(p, C.int(plen))} +} +func (e2apMsg *e2apMsgSubscriptionFailure) PduUnPack(logBuf []byte, data *packer.PackedData) error { e2apMsg.msgC = &C.RICSubscriptionFailure_t{} C.initSubsFailure(e2apMsg.msgC) + e2apMsg.e2apMessage.PduUnPack(logBuf, data) + if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2UnsuccessfulOutcome || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICSubscriptionFailure { + return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) + } + errorNro := C.getRICSubscriptionFailureData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) + } + return nil - e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) +} +func (e2apMsg *e2apMsgSubscriptionFailure) Pack(data *e2ap.E2APSubscriptionFailure) (error, *packer.PackedData) { + e2apMsg.msgC = &C.RICSubscriptionFailure_t{} + C.initSubsFailure(e2apMsg.msgC) + e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { - return err + return err, nil } - if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).set(&data.ActionNotAdmittedList); err != nil { - return err + return err, nil } - e2apMsg.msgC.criticalityDiagnosticsPresent = false if data.CriticalityDiagnostics.Present { e2apMsg.msgC.criticalityDiagnosticsPresent = true if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).set(&data.CriticalityDiagnostics); err != nil { - return err + return err, nil } } - - return nil + return packer.PduPackerPack(e2apMsg) } -func (e2apMsg *e2apMsgSubscriptionFailure) Get() (error, *e2ap.E2APSubscriptionFailure) { - +func (e2apMsg *e2apMsgSubscriptionFailure) UnPack(msg *packer.PackedData) (error, *e2ap.E2APSubscriptionFailure) { data := &e2ap.E2APSubscriptionFailure{} - + if err := packer.PduPackerUnPack(e2apMsg, msg); err != nil { + return err, data + } data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) - if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { return err, data } - if err := (&e2apEntryNotAdmittedList{entry: &e2apMsg.msgC.ricActionNotAdmittedList}).get(&data.ActionNotAdmittedList); err != nil { return err, data } - if e2apMsg.msgC.criticalityDiagnosticsPresent == true { data.CriticalityDiagnostics.Present = true if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&data.CriticalityDiagnostics); err != nil { return err, data } } - return nil, data } -func (e2apMsg *e2apMsgSubscriptionFailure) PduPack(logBuf []byte, data *packer.PackedData) error { - var buflen uint32 = (uint32)(len(data.Buf)) - errorNro := C.packRICSubscriptionFailure((*C.size_t)(unsafe.Pointer(&buflen)), (*C.uchar)(unsafe.Pointer(&data.Buf[0])), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - data.Buf = data.Buf[0:buflen] - return nil -} - -func (e2apMsg *e2apMsgSubscriptionFailure) PduUnPack(logBuf []byte, data *packer.PackedData) error { - - e2apMsg.msgC = &C.RICSubscriptionFailure_t{} - C.initSubsFailure(e2apMsg.msgC) - - e2apMsg.e2apMessage.PduUnPack(logBuf, data) - if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2UnsuccessfulOutcome || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICSubscriptionFailure { - return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) - } - errorNro := C.getRICSubscriptionFailureData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - return nil - -} - -func (e2apMsg *e2apMsgSubscriptionFailure) Pack(trg *packer.PackedData) (error, *packer.PackedData) { - return packer.PduPackerPackAllocTrg(e2apMsg, trg) -} - -func (e2apMsg *e2apMsgSubscriptionFailure) UnPack(msg *packer.PackedData) error { - return packer.PduPackerUnPack(e2apMsg, msg) -} - func (e2apMsg *e2apMsgSubscriptionFailure) String() string { var b bytes.Buffer fmt.Fprintln(&b, "ricSubscriptionFailure.") @@ -918,48 +852,20 @@ type e2apMsgSubscriptionDeleteRequest struct { msgC *C.RICSubscriptionDeleteRequest_t } -func (e2apMsg *e2apMsgSubscriptionDeleteRequest) Set(data *e2ap.E2APSubscriptionDeleteRequest) error { - - e2apMsg.msgC = &C.RICSubscriptionDeleteRequest_t{} - C.initSubsDeleteRequest(e2apMsg.msgC) - - e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) - - if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { - return err - } - return nil -} - -func (e2apMsg *e2apMsgSubscriptionDeleteRequest) Get() (error, *e2ap.E2APSubscriptionDeleteRequest) { - - data := &e2ap.E2APSubscriptionDeleteRequest{} - - data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) - - if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { - return err, data - } - - return nil, data -} - -func (e2apMsg *e2apMsgSubscriptionDeleteRequest) PduPack(logBuf []byte, data *packer.PackedData) error { - var buflen uint32 = (uint32)(len(data.Buf)) - errorNro := C.packRICSubscriptionDeleteRequest((*C.size_t)(unsafe.Pointer(&buflen)), (*C.uchar)(unsafe.Pointer(&data.Buf[0])), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) +func (e2apMsg *e2apMsgSubscriptionDeleteRequest) PduPack(logBuf []byte) (error, *packer.PackedData) { + p := C.malloc(C.size_t(cMsgBufferMaxSize)) + defer C.free(p) + plen := C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra + errorNro := C.packRICSubscriptionDeleteRequest(&plen, (*C.uchar)(p), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))), nil } - data.Buf = data.Buf[0:buflen] - return nil - + return nil, &packer.PackedData{C.GoBytes(p, C.int(plen))} } func (e2apMsg *e2apMsgSubscriptionDeleteRequest) PduUnPack(logBuf []byte, data *packer.PackedData) error { - e2apMsg.msgC = &C.RICSubscriptionDeleteRequest_t{} C.initSubsDeleteRequest(e2apMsg.msgC) - e2apMsg.e2apMessage.PduUnPack(logBuf, data) if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2InitiatingMessage || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICSubscriptionDeleteRequest { return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) @@ -971,12 +877,41 @@ func (e2apMsg *e2apMsgSubscriptionDeleteRequest) PduUnPack(logBuf []byte, data * return nil } -func (e2apMsg *e2apMsgSubscriptionDeleteRequest) Pack(trg *packer.PackedData) (error, *packer.PackedData) { - return packer.PduPackerPackAllocTrg(e2apMsg, trg) +func (e2apMsg *e2apMsgSubscriptionDeleteRequest) Pack(data *e2ap.E2APSubscriptionDeleteRequest) (error, *packer.PackedData) { + e2apMsg.msgC = &C.RICSubscriptionDeleteRequest_t{} + C.initSubsDeleteRequest(e2apMsg.msgC) + e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) + if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { + return err, nil + } + return packer.PduPackerPack(e2apMsg) } -func (e2apMsg *e2apMsgSubscriptionDeleteRequest) UnPack(msg *packer.PackedData) error { - return packer.PduPackerUnPack(e2apMsg, msg) +func (e2apMsg *e2apMsgSubscriptionDeleteRequest) Pack21(data *e2ap.E2APSubscriptionDeleteRequest) (error, *packer.PackedData) { + e2apMsg.msgC = &C.RICSubscriptionDeleteRequest_t{} + C.initSubsDeleteRequest(e2apMsg.msgC) + e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) + if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { + return err, nil + } + return nil, nil +} + +func (e2apMsg *e2apMsgSubscriptionDeleteRequest) Pack22(data *e2ap.E2APSubscriptionDeleteRequest) (error, *packer.PackedData) { + return packer.PduPackerPack(e2apMsg) +} + +func (e2apMsg *e2apMsgSubscriptionDeleteRequest) UnPack(msg *packer.PackedData) (error, *e2ap.E2APSubscriptionDeleteRequest) { + data := &e2ap.E2APSubscriptionDeleteRequest{} + if err := packer.PduPackerUnPack(e2apMsg, msg); err != nil { + return err, data + } + data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) + if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { + return err, data + } + return nil, data + } func (e2apMsg *e2apMsgSubscriptionDeleteRequest) String() string { @@ -997,45 +932,20 @@ type e2apMsgSubscriptionDeleteResponse struct { msgC *C.RICSubscriptionDeleteResponse_t } -func (e2apMsg *e2apMsgSubscriptionDeleteResponse) Set(data *e2ap.E2APSubscriptionDeleteResponse) error { - - e2apMsg.msgC = &C.RICSubscriptionDeleteResponse_t{} - C.initSubsDeleteResponse(e2apMsg.msgC) - - e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) - - if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { - return err - } - return nil -} - -func (e2apMsg *e2apMsgSubscriptionDeleteResponse) Get() (error, *e2ap.E2APSubscriptionDeleteResponse) { - - data := &e2ap.E2APSubscriptionDeleteResponse{} - - data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) - - if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { - return err, data - } - - return nil, data -} -func (e2apMsg *e2apMsgSubscriptionDeleteResponse) PduPack(logBuf []byte, data *packer.PackedData) error { - var buflen uint32 = (uint32)(len(data.Buf)) - errorNro := C.packRICSubscriptionDeleteResponse((*C.size_t)(unsafe.Pointer(&buflen)), (*C.uchar)(unsafe.Pointer(&data.Buf[0])), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) +func (e2apMsg *e2apMsgSubscriptionDeleteResponse) PduPack(logBuf []byte) (error, *packer.PackedData) { + p := C.malloc(C.size_t(cMsgBufferMaxSize)) + defer C.free(p) + plen := C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra + errorNro := C.packRICSubscriptionDeleteResponse(&plen, (*C.uchar)(p), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))), nil } - data.Buf = data.Buf[0:buflen] - return nil + return nil, &packer.PackedData{C.GoBytes(p, C.int(plen))} } func (e2apMsg *e2apMsgSubscriptionDeleteResponse) PduUnPack(logBuf []byte, data *packer.PackedData) error { e2apMsg.msgC = &C.RICSubscriptionDeleteResponse_t{} C.initSubsDeleteResponse(e2apMsg.msgC) - e2apMsg.e2apMessage.PduUnPack(logBuf, data) if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2SuccessfulOutcome || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICsubscriptionDeleteResponse { return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) @@ -1047,12 +957,26 @@ func (e2apMsg *e2apMsgSubscriptionDeleteResponse) PduUnPack(logBuf []byte, data return nil } -func (e2apMsg *e2apMsgSubscriptionDeleteResponse) Pack(trg *packer.PackedData) (error, *packer.PackedData) { - return packer.PduPackerPackAllocTrg(e2apMsg, trg) +func (e2apMsg *e2apMsgSubscriptionDeleteResponse) Pack(data *e2ap.E2APSubscriptionDeleteResponse) (error, *packer.PackedData) { + e2apMsg.msgC = &C.RICSubscriptionDeleteResponse_t{} + C.initSubsDeleteResponse(e2apMsg.msgC) + e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) + if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { + return err, nil + } + return packer.PduPackerPack(e2apMsg) } -func (e2apMsg *e2apMsgSubscriptionDeleteResponse) UnPack(msg *packer.PackedData) error { - return packer.PduPackerUnPack(e2apMsg, msg) +func (e2apMsg *e2apMsgSubscriptionDeleteResponse) UnPack(msg *packer.PackedData) (error, *e2ap.E2APSubscriptionDeleteResponse) { + data := &e2ap.E2APSubscriptionDeleteResponse{} + if err := packer.PduPackerUnPack(e2apMsg, msg); err != nil { + return err, data + } + data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) + if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { + return err, data + } + return nil, data } func (e2apMsg *e2apMsgSubscriptionDeleteResponse) String() string { @@ -1073,43 +997,63 @@ type e2apMsgSubscriptionDeleteFailure struct { msgC *C.RICSubscriptionDeleteFailure_t } -func (e2apMsg *e2apMsgSubscriptionDeleteFailure) Set(data *e2ap.E2APSubscriptionDeleteFailure) error { +func (e2apMsg *e2apMsgSubscriptionDeleteFailure) PduPack(logBuf []byte) (error, *packer.PackedData) { + p := C.malloc(C.size_t(cMsgBufferMaxSize)) + defer C.free(p) + plen := C.size_t(cMsgBufferMaxSize) - cMsgBufferExtra + errorNro := C.packRICSubscriptionDeleteFailure(&plen, (*C.uchar)(p), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))), nil + } + return nil, &packer.PackedData{C.GoBytes(p, C.int(plen))} +} +func (e2apMsg *e2apMsgSubscriptionDeleteFailure) PduUnPack(logBuf []byte, data *packer.PackedData) error { e2apMsg.msgC = &C.RICSubscriptionDeleteFailure_t{} C.initSubsDeleteFailure(e2apMsg.msgC) + e2apMsg.e2apMessage.PduUnPack(logBuf, data) + if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2UnsuccessfulOutcome || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICsubscriptionDeleteFailure { + return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) + } + errorNro := C.getRICSubscriptionDeleteFailureData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) + if errorNro != C.e2err_OK { + return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) + } + return nil - e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) +} +func (e2apMsg *e2apMsgSubscriptionDeleteFailure) Pack(data *e2ap.E2APSubscriptionDeleteFailure) (error, *packer.PackedData) { + e2apMsg.msgC = &C.RICSubscriptionDeleteFailure_t{} + C.initSubsDeleteFailure(e2apMsg.msgC) + e2apMsg.msgC.ranFunctionID = (C.uint16_t)(data.FunctionId) if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).set(&data.RequestId); err != nil { - return err + return err, nil } - e2apMsg.msgC.ricCause.content = (C.uchar)(data.Cause.Content) e2apMsg.msgC.ricCause.cause = (C.uchar)(data.Cause.CauseVal) - e2apMsg.msgC.criticalityDiagnosticsPresent = false if data.CriticalityDiagnostics.Present { e2apMsg.msgC.criticalityDiagnosticsPresent = true if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).set(&data.CriticalityDiagnostics); err != nil { - return err + return err, nil } } - return nil -} -func (e2apMsg *e2apMsgSubscriptionDeleteFailure) Get() (error, *e2ap.E2APSubscriptionDeleteFailure) { + return packer.PduPackerPack(e2apMsg) +} +func (e2apMsg *e2apMsgSubscriptionDeleteFailure) UnPack(msg *packer.PackedData) (error, *e2ap.E2APSubscriptionDeleteFailure) { data := &e2ap.E2APSubscriptionDeleteFailure{} - + if err := packer.PduPackerUnPack(e2apMsg, msg); err != nil { + return err, data + } data.FunctionId = (e2ap.FunctionId)(e2apMsg.msgC.ranFunctionID) - if err := (&e2apEntryRequestID{entry: &e2apMsg.msgC.ricRequestID}).get(&data.RequestId); err != nil { return err, data } - data.Cause.Content = (uint8)(e2apMsg.msgC.ricCause.content) data.Cause.CauseVal = (uint8)(e2apMsg.msgC.ricCause.cause) - if e2apMsg.msgC.criticalityDiagnosticsPresent == true { data.CriticalityDiagnostics.Present = true if err := (&e2apEntryCriticalityDiagnostic{entry: &e2apMsg.msgC.criticalityDiagnostics}).get(&data.CriticalityDiagnostics); err != nil { @@ -1119,41 +1063,6 @@ func (e2apMsg *e2apMsgSubscriptionDeleteFailure) Get() (error, *e2ap.E2APSubscri return nil, data } -func (e2apMsg *e2apMsgSubscriptionDeleteFailure) PduPack(logBuf []byte, data *packer.PackedData) error { - var buflen uint32 = (uint32)(len(data.Buf)) - errorNro := C.packRICSubscriptionDeleteFailure((*C.size_t)(unsafe.Pointer(&buflen)), (*C.uchar)(unsafe.Pointer(&data.Buf[0])), (*C.char)(unsafe.Pointer(&logBuf[0])), e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - data.Buf = data.Buf[0:buflen] - return nil -} - -func (e2apMsg *e2apMsgSubscriptionDeleteFailure) PduUnPack(logBuf []byte, data *packer.PackedData) error { - - e2apMsg.msgC = &C.RICSubscriptionDeleteFailure_t{} - C.initSubsDeleteFailure(e2apMsg.msgC) - - e2apMsg.e2apMessage.PduUnPack(logBuf, data) - if e2apMsg.e2apMessage.messageInfo.messageType != C.cE2UnsuccessfulOutcome || e2apMsg.e2apMessage.messageInfo.messageId != C.cRICsubscriptionDeleteFailure { - return fmt.Errorf("unpackE2AP_pdu failed -> %s", e2apMsg.e2apMessage.String()) - } - errorNro := C.getRICSubscriptionDeleteFailureData(e2apMsg.e2apMessage.pdu, e2apMsg.msgC) - if errorNro != C.e2err_OK { - return fmt.Errorf("%s", C.GoString(C.getE2ErrorString(errorNro))) - } - return nil - -} - -func (e2apMsg *e2apMsgSubscriptionDeleteFailure) Pack(trg *packer.PackedData) (error, *packer.PackedData) { - return packer.PduPackerPackAllocTrg(e2apMsg, trg) -} - -func (e2apMsg *e2apMsgSubscriptionDeleteFailure) UnPack(msg *packer.PackedData) error { - return packer.PduPackerUnPack(e2apMsg, msg) -} - func (e2apMsg *e2apMsgSubscriptionDeleteFailure) String() string { var b bytes.Buffer fmt.Fprintln(&b, "ricSubscriptionDeleteFailure.") @@ -1216,11 +1125,6 @@ func (*cppasn1E2APPacker) NewPackerSubscriptionDeleteFailure() e2ap.E2APMsgPacke return &e2apMsgSubscriptionDeleteFailure{} } -func (*cppasn1E2APPacker) MessageInfo(msg *packer.PackedData) *packer.MessageInfo { - e2apMsg := &e2apMessage{} - return e2apMsg.UnPack(msg) -} - func NewAsn1E2Packer() e2ap.E2APPackerIf { return &cppasn1E2APPacker{} } diff --git a/e2ap/pkg/packer/packer.go b/e2ap/pkg/packer/packer.go index ab2ac96..9eeefaf 100644 --- a/e2ap/pkg/packer/packer.go +++ b/e2ap/pkg/packer/packer.go @@ -24,42 +24,41 @@ import ( "strings" ) -const cLogBufferMaxSize = 1024 -const cMsgBufferMaxSize = 2048 +const cLogBufferMaxSize = 40960 //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -type PduPackerIf interface { - PduPack(logBuf []byte, data *PackedData) error +type PduLoggerBuf struct { + logBuffer []byte } -func PduPackerPack(entry PduPackerIf, trgBuf *PackedData) error { +func (lb *PduLoggerBuf) String() string { + return "logbuffer(" + string(lb.logBuffer[:strings.Index(string(lb.logBuffer[:]), "\000")]) + ")" +} - var logBuffer []byte = make([]byte, cLogBufferMaxSize) - logBuffer[0] = 0 +func NewPduLoggerBuf() *PduLoggerBuf { + lb := &PduLoggerBuf{} + lb.logBuffer = make([]byte, cLogBufferMaxSize) + lb.logBuffer[0] = 0 + return lb +} - if trgBuf != nil { - trgBuf.Buf = make([]byte, cMsgBufferMaxSize) - } - err := entry.PduPack(logBuffer, trgBuf) - if err == nil { - return nil - } - return fmt.Errorf("Pack failed: err: %s, logbuffer: %s", err.Error(), logBuffer[:strings.Index(string(logBuffer[:]), "\000")]) +//----------------------------------------------------------------------------- +// +//----------------------------------------------------------------------------- +type PduPackerIf interface { + PduPack(logBuf []byte) (error, *PackedData) } -func PduPackerPackAllocTrg(entry PduPackerIf, trgBuf *PackedData) (error, *PackedData) { - dataPacked := trgBuf - if dataPacked == nil { - dataPacked = &PackedData{} - } - err := PduPackerPack(entry, dataPacked) - if err != nil { - return err, nil +func PduPackerPack(entry PduPackerIf) (error, *PackedData) { + lb := NewPduLoggerBuf() + err, buf := entry.PduPack(lb.logBuffer) + if err == nil { + return nil, buf } - return nil, dataPacked + return fmt.Errorf("Pack failed: err(%s), %s", err.Error(), lb.String()), nil } //----------------------------------------------------------------------------- @@ -71,12 +70,13 @@ type PduUnPackerIf interface { } func PduPackerUnPack(entry PduUnPackerIf, data *PackedData) error { - var logBuffer []byte = make([]byte, cLogBufferMaxSize) - - logBuffer[0] = 0 - err := entry.PduUnPack(logBuffer, data) + if data == nil { + return fmt.Errorf("Unpack failed: data is nil") + } + lb := NewPduLoggerBuf() + err := entry.PduUnPack(lb.logBuffer, data) if err == nil { return nil } - return fmt.Errorf("Unpack failed: err: %s, logbuffer: %s", err.Error(), logBuffer[:strings.Index(string(logBuffer[:]), "\000")]) + return fmt.Errorf("Unpack failed: err(%s), %s", err.Error(), lb.String()) } diff --git a/pkg/control/e2ap.go b/pkg/control/e2ap.go index f564c48..f0b3381 100644 --- a/pkg/control/e2ap.go +++ b/pkg/control/e2ap.go @@ -47,11 +47,7 @@ func (c *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscription e2SubReq := packerif.NewPackerSubscriptionRequest() packedData := &packer.PackedData{} packedData.Buf = payload - err := e2SubReq.UnPack(packedData) - if err != nil { - return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) - } - err, subReq := e2SubReq.Get() + err, subReq := e2SubReq.UnPack(packedData) if err != nil { return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) } @@ -60,11 +56,7 @@ func (c *E2ap) UnpackSubscriptionRequest(payload []byte) (*e2ap.E2APSubscription func (c *E2ap) PackSubscriptionRequest(req *e2ap.E2APSubscriptionRequest) (int, *packer.PackedData, error) { e2SubReq := packerif.NewPackerSubscriptionRequest() - err := e2SubReq.Set(req) - if err != nil { - return 0, nil, err - } - err, packedData := e2SubReq.Pack(nil) + err, packedData := e2SubReq.Pack(req) if err != nil { return 0, nil, err } @@ -78,11 +70,7 @@ func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptio e2SubResp := packerif.NewPackerSubscriptionResponse() packedData := &packer.PackedData{} packedData.Buf = payload - err := e2SubResp.UnPack(packedData) - if err != nil { - return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) - } - err, subResp := e2SubResp.Get() + err, subResp := e2SubResp.UnPack(packedData) if err != nil { return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) } @@ -91,11 +79,7 @@ func (c *E2ap) UnpackSubscriptionResponse(payload []byte) (*e2ap.E2APSubscriptio func (c *E2ap) PackSubscriptionResponse(req *e2ap.E2APSubscriptionResponse) (int, *packer.PackedData, error) { e2SubResp := packerif.NewPackerSubscriptionResponse() - err := e2SubResp.Set(req) - if err != nil { - return 0, nil, err - } - err, packedData := e2SubResp.Pack(nil) + err, packedData := e2SubResp.Pack(req) if err != nil { return 0, nil, err } @@ -109,11 +93,7 @@ func (c *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscription e2SubFail := packerif.NewPackerSubscriptionFailure() packedData := &packer.PackedData{} packedData.Buf = payload - err := e2SubFail.UnPack(packedData) - if err != nil { - return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) - } - err, subFail := e2SubFail.Get() + err, subFail := e2SubFail.UnPack(packedData) if err != nil { return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) } @@ -122,11 +102,7 @@ func (c *E2ap) UnpackSubscriptionFailure(payload []byte) (*e2ap.E2APSubscription func (c *E2ap) PackSubscriptionFailure(req *e2ap.E2APSubscriptionFailure) (int, *packer.PackedData, error) { e2SubFail := packerif.NewPackerSubscriptionFailure() - err := e2SubFail.Set(req) - if err != nil { - return 0, nil, err - } - err, packedData := e2SubFail.Pack(nil) + err, packedData := e2SubFail.Pack(req) if err != nil { return 0, nil, err } @@ -140,11 +116,7 @@ func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscr e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest() packedData := &packer.PackedData{} packedData.Buf = payload - err := e2SubDelReq.UnPack(packedData) - if err != nil { - return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) - } - err, subDelReq := e2SubDelReq.Get() + err, subDelReq := e2SubDelReq.UnPack(packedData) if err != nil { return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) } @@ -153,11 +125,7 @@ func (c *E2ap) UnpackSubscriptionDeleteRequest(payload []byte) (*e2ap.E2APSubscr func (c *E2ap) PackSubscriptionDeleteRequest(req *e2ap.E2APSubscriptionDeleteRequest) (int, *packer.PackedData, error) { e2SubDelReq := packerif.NewPackerSubscriptionDeleteRequest() - err := e2SubDelReq.Set(req) - if err != nil { - return 0, nil, err - } - err, packedData := e2SubDelReq.Pack(nil) + err, packedData := e2SubDelReq.Pack(req) if err != nil { return 0, nil, err } @@ -171,11 +139,7 @@ func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubsc e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse() packedData := &packer.PackedData{} packedData.Buf = payload - err := e2SubDelResp.UnPack(packedData) - if err != nil { - return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) - } - err, subDelResp := e2SubDelResp.Get() + err, subDelResp := e2SubDelResp.UnPack(packedData) if err != nil { return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) } @@ -184,11 +148,7 @@ func (c *E2ap) UnpackSubscriptionDeleteResponse(payload []byte) (*e2ap.E2APSubsc func (c *E2ap) PackSubscriptionDeleteResponse(req *e2ap.E2APSubscriptionDeleteResponse) (int, *packer.PackedData, error) { e2SubDelResp := packerif.NewPackerSubscriptionDeleteResponse() - err := e2SubDelResp.Set(req) - if err != nil { - return 0, nil, err - } - err, packedData := e2SubDelResp.Pack(nil) + err, packedData := e2SubDelResp.Pack(req) if err != nil { return 0, nil, err } @@ -202,11 +162,7 @@ func (c *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscr e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure() packedData := &packer.PackedData{} packedData.Buf = payload - err := e2SubDelFail.UnPack(packedData) - if err != nil { - return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) - } - err, subDelFail := e2SubDelFail.Get() + err, subDelFail := e2SubDelFail.UnPack(packedData) if err != nil { return nil, fmt.Errorf("%s buf[%s]", err.Error(), hex.EncodeToString(payload)) } @@ -215,11 +171,7 @@ func (c *E2ap) UnpackSubscriptionDeleteFailure(payload []byte) (*e2ap.E2APSubscr func (c *E2ap) PackSubscriptionDeleteFailure(req *e2ap.E2APSubscriptionDeleteFailure) (int, *packer.PackedData, error) { e2SubDelFail := packerif.NewPackerSubscriptionDeleteFailure() - err := e2SubDelFail.Set(req) - if err != nil { - return 0, nil, err - } - err, packedData := e2SubDelFail.Pack(nil) + err, packedData := e2SubDelFail.Pack(req) if err != nil { return 0, nil, err } diff --git a/pkg/control/ut_messaging_test.go b/pkg/control/ut_messaging_test.go index 2e8bc0e..1bec316 100644 --- a/pkg/control/ut_messaging_test.go +++ b/pkg/control/ut_messaging_test.go @@ -288,7 +288,7 @@ func TestSubDelReqCollision(t *testing.T) { // Subs Delete colliding seqBef := mainCtrl.get_msgcounter(t) - deltranscol2 := xappConn1.newXappTransaction(nil, "RAN_NAME_1") + deltranscol2 := xappConn1.newXappTransaction("", "RAN_NAME_1") xappConn1.handle_xapp_subs_del_req(t, deltranscol2, e2SubsId) //Colliding SubDelReq mainCtrl.wait_msgcounter_change(t, seqBef, 10) @@ -438,21 +438,21 @@ func TestSameSubsDiffRan(t *testing.T) { xapp.Logger.Info("TestSameSubsDiffRan") //Req1 - cretrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1") + cretrans1 := xappConn1.newXappTransaction("", "RAN_NAME_1") xappConn1.handle_xapp_subs_req(t, nil, cretrans1) crereq1, cremsg1 := e2termConn.handle_e2term_subs_req(t) e2termConn.handle_e2term_subs_resp(t, crereq1, cremsg1) e2SubsId1 := xappConn1.handle_xapp_subs_resp(t, cretrans1) //Req2 - cretrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2") + cretrans2 := xappConn1.newXappTransaction("", "RAN_NAME_2") xappConn1.handle_xapp_subs_req(t, nil, cretrans2) crereq2, cremsg2 := e2termConn.handle_e2term_subs_req(t) e2termConn.handle_e2term_subs_resp(t, crereq2, cremsg2) e2SubsId2 := xappConn1.handle_xapp_subs_resp(t, cretrans2) //Del1 - deltrans1 := xappConn1.newXappTransaction(nil, "RAN_NAME_1") + deltrans1 := xappConn1.newXappTransaction("", "RAN_NAME_1") xappConn1.handle_xapp_subs_del_req(t, deltrans1, e2SubsId1) delreq1, delmsg1 := e2termConn.handle_e2term_subs_del_req(t) e2termConn.handle_e2term_subs_del_resp(t, delreq1, delmsg1) @@ -461,7 +461,7 @@ func TestSameSubsDiffRan(t *testing.T) { mainCtrl.wait_subs_clean(t, e2SubsId1, 10) //Del2 - deltrans2 := xappConn1.newXappTransaction(nil, "RAN_NAME_2") + deltrans2 := xappConn1.newXappTransaction("", "RAN_NAME_2") xappConn1.handle_xapp_subs_del_req(t, deltrans2, e2SubsId2) delreq2, delmsg2 := e2termConn.handle_e2term_subs_del_req(t) e2termConn.handle_e2term_subs_del_resp(t, delreq2, delmsg2) diff --git a/pkg/control/ut_stub_e2term_test.go b/pkg/control/ut_stub_e2term_test.go index 273d159..840c98e 100644 --- a/pkg/control/ut_stub_e2term_test.go +++ b/pkg/control/ut_stub_e2term_test.go @@ -58,12 +58,12 @@ func (tc *testingE2termStub) Consume(params *xapp.RMRParams) (err error) { msg := &RMRParams{params} if params.Mtype == 55555 { - xapp.Logger.Info("(%s) Testing message ignore %s", tc.desc, msg.String()) + xapp.Logger.Info("(%s) Testing message ignore %s", tc.GetDesc(), msg.String()) tc.active = true return } - xapp.Logger.Info("(%s) Consume %s", tc.desc, msg.String()) + xapp.Logger.Info("(%s) Consume %s", tc.GetDesc(), msg.String()) tc.rmrConChan <- msg return } @@ -72,7 +72,7 @@ func (tc *testingE2termStub) Consume(params *xapp.RMRParams) (err error) { // //----------------------------------------------------------------------------- func (e2termConn *testingE2termStub) handle_e2term_subs_req(t *testing.T) (*e2ap.E2APSubscriptionRequest, *RMRParams) { - xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.desc) + xapp.Logger.Info("(%s) handle_e2term_subs_req", e2termConn.GetDesc()) e2SubsReq := e2t_e2asnpacker.NewPackerSubscriptionRequest() //--------------------------------- @@ -82,35 +82,31 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_req(t *testing.T) (*e2ap case msg := <-e2termConn.rmrConChan: e2termConn.DecMsgCnt() if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] { - testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype]) + testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.GetDesc(), "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype]) } else { - xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.desc) + xapp.Logger.Info("(%s) Recv Subs Req", e2termConn.GetDesc()) packedData := &packer.PackedData{} packedData.Buf = msg.Payload - unpackerr := e2SubsReq.UnPack(packedData) + unpackerr, req := e2SubsReq.UnPack(packedData) if unpackerr != nil { - testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error()) - } - geterr, req := e2SubsReq.Get() - if geterr != nil { - testError(t, "(%s) RIC_SUB_REQ get failed err: %s", e2termConn.desc, geterr.Error()) + testError(t, "(%s) RIC_SUB_REQ unpack failed err: %s", e2termConn.GetDesc(), unpackerr.Error()) } return req, msg } case <-time.After(15 * time.Second): - testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.desc) + testError(t, "(%s) Not Received RIC_SUB_REQ within 15 secs", e2termConn.GetDesc()) } return nil, nil } func (e2termConn *testingE2termStub) handle_e2term_subs_resp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *RMRParams) { - xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.desc) + xapp.Logger.Info("(%s) handle_e2term_subs_resp", e2termConn.GetDesc()) e2SubsResp := e2t_e2asnpacker.NewPackerSubscriptionResponse() //--------------------------------- // e2term activity: Send Subs Resp //--------------------------------- - xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.desc) + xapp.Logger.Info("(%s) Send Subs Resp", e2termConn.GetDesc()) resp := &e2ap.E2APSubscriptionResponse{} @@ -131,12 +127,11 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_resp(t *testing.T, req * resp.ActionNotAdmittedList.Items = append(resp.ActionNotAdmittedList.Items, item) } - e2SubsResp.Set(resp) - xapp.Logger.Debug("(%s) %s", e2termConn.desc, e2SubsResp.String()) - packerr, packedMsg := e2SubsResp.Pack(nil) + packerr, packedMsg := e2SubsResp.Pack(resp) if packerr != nil { - testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error()) + testError(t, "(%s) pack NOK %s", e2termConn.GetDesc(), packerr.Error()) } + xapp.Logger.Debug("(%s) %s", e2termConn.GetDesc(), e2SubsResp.String()) params := &RMRParams{&xapp.RMRParams{}} params.Mtype = xapp.RIC_SUB_RESP @@ -149,7 +144,7 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_resp(t *testing.T, req * snderr := e2termConn.RmrSend(params) if snderr != nil { - testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.GetDesc(), snderr.Error()) } } @@ -189,20 +184,19 @@ func (p *test_subs_fail_params) SetCauseVal(ind int, content uint8, causeval uin } func (e2termConn *testingE2termStub) handle_e2term_subs_fail(t *testing.T, fparams *test_subs_fail_params, msg *RMRParams) { - xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.desc) + xapp.Logger.Info("(%s) handle_e2term_subs_fail", e2termConn.GetDesc()) e2SubsFail := e2t_e2asnpacker.NewPackerSubscriptionFailure() //--------------------------------- // e2term activity: Send Subs Fail //--------------------------------- - xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.desc) + xapp.Logger.Info("(%s) Send Subs Fail", e2termConn.GetDesc()) - e2SubsFail.Set(fparams.fail) - xapp.Logger.Debug("(%s) %s", e2termConn.desc, e2SubsFail.String()) - packerr, packedMsg := e2SubsFail.Pack(nil) + packerr, packedMsg := e2SubsFail.Pack(fparams.fail) if packerr != nil { - testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error()) + testError(t, "(%s) pack NOK %s", e2termConn.GetDesc(), packerr.Error()) } + xapp.Logger.Debug("(%s) %s", e2termConn.GetDesc(), e2SubsFail.String()) params := &RMRParams{&xapp.RMRParams{}} params.Mtype = xapp.RIC_SUB_FAILURE @@ -214,7 +208,7 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_fail(t *testing.T, fpara snderr := e2termConn.RmrSend(params) if snderr != nil { - testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.GetDesc(), snderr.Error()) } } @@ -222,7 +216,7 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_fail(t *testing.T, fpara // //----------------------------------------------------------------------------- func (e2termConn *testingE2termStub) handle_e2term_subs_del_req(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *RMRParams) { - xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.desc) + xapp.Logger.Info("(%s) handle_e2term_subs_del_req", e2termConn.GetDesc()) e2SubsDelReq := e2t_e2asnpacker.NewPackerSubscriptionDeleteRequest() //--------------------------------- @@ -232,24 +226,20 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_del_req(t *testing.T) (* case msg := <-e2termConn.rmrConChan: e2termConn.DecMsgCnt() if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] { - testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.desc, "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype]) + testError(t, "(%s) Received wrong mtype expected %s got %s, error", e2termConn.GetDesc(), "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype]) } else { - xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.desc) + xapp.Logger.Info("(%s) Recv Subs Del Req", e2termConn.GetDesc()) packedData := &packer.PackedData{} packedData.Buf = msg.Payload - unpackerr := e2SubsDelReq.UnPack(packedData) + unpackerr, req := e2SubsDelReq.UnPack(packedData) if unpackerr != nil { - testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.desc, unpackerr.Error()) - } - geterr, req := e2SubsDelReq.Get() - if geterr != nil { - testError(t, "(%s) RIC_SUB_DEL_REQ get failed err: %s", e2termConn.desc, geterr.Error()) + testError(t, "(%s) RIC_SUB_DEL_REQ unpack failed err: %s", e2termConn.GetDesc(), unpackerr.Error()) } return req, msg } case <-time.After(15 * time.Second): - testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.desc) + testError(t, "(%s) Not Received RIC_SUB_DEL_REQ within 15 secs", e2termConn.GetDesc()) } return nil, nil } @@ -262,25 +252,24 @@ func handle_e2term_recv_empty() bool { } func (e2termConn *testingE2termStub) handle_e2term_subs_del_resp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) { - xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.desc) + xapp.Logger.Info("(%s) handle_e2term_subs_del_resp", e2termConn.GetDesc()) e2SubsDelResp := e2t_e2asnpacker.NewPackerSubscriptionDeleteResponse() //--------------------------------- // e2term activity: Send Subs Del Resp //--------------------------------- - xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.desc) + xapp.Logger.Info("(%s) Send Subs Del Resp", e2termConn.GetDesc()) resp := &e2ap.E2APSubscriptionDeleteResponse{} resp.RequestId.Id = req.RequestId.Id resp.RequestId.Seq = req.RequestId.Seq resp.FunctionId = req.FunctionId - e2SubsDelResp.Set(resp) - xapp.Logger.Debug("(%s) %s", e2termConn.desc, e2SubsDelResp.String()) - packerr, packedMsg := e2SubsDelResp.Pack(nil) + packerr, packedMsg := e2SubsDelResp.Pack(resp) if packerr != nil { - testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error()) + testError(t, "(%s) pack NOK %s", e2termConn.GetDesc(), packerr.Error()) } + xapp.Logger.Debug("(%s) %s", e2termConn.GetDesc(), e2SubsDelResp.String()) params := &RMRParams{&xapp.RMRParams{}} params.Mtype = xapp.RIC_SUB_DEL_RESP @@ -292,7 +281,7 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_del_resp(t *testing.T, r snderr := e2termConn.RmrSend(params) if snderr != nil { - testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.GetDesc(), snderr.Error()) } } @@ -300,13 +289,13 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_del_resp(t *testing.T, r // //----------------------------------------------------------------------------- func (e2termConn *testingE2termStub) handle_e2term_subs_del_fail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *RMRParams) { - xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.desc) + xapp.Logger.Info("(%s) handle_e2term_del_subs_fail", e2termConn.GetDesc()) e2SubsDelFail := e2t_e2asnpacker.NewPackerSubscriptionDeleteFailure() //--------------------------------- // e2term activity: Send Subs Del Fail //--------------------------------- - xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.desc) + xapp.Logger.Info("(%s) Send Subs Del Fail", e2termConn.GetDesc()) resp := &e2ap.E2APSubscriptionDeleteFailure{} resp.RequestId.Id = req.RequestId.Id @@ -315,12 +304,11 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_del_fail(t *testing.T, r resp.Cause.Content = 3 // CauseMisc resp.Cause.CauseVal = 4 // unspecified - e2SubsDelFail.Set(resp) - xapp.Logger.Debug("(%s) %s", e2termConn.desc, e2SubsDelFail.String()) - packerr, packedMsg := e2SubsDelFail.Pack(nil) + packerr, packedMsg := e2SubsDelFail.Pack(resp) if packerr != nil { - testError(t, "(%s) pack NOK %s", e2termConn.desc, packerr.Error()) + testError(t, "(%s) pack NOK %s", e2termConn.GetDesc(), packerr.Error()) } + xapp.Logger.Debug("(%s) %s", e2termConn.GetDesc(), e2SubsDelFail.String()) params := &RMRParams{&xapp.RMRParams{}} params.Mtype = xapp.RIC_SUB_DEL_FAILURE @@ -332,6 +320,6 @@ func (e2termConn *testingE2termStub) handle_e2term_subs_del_fail(t *testing.T, r snderr := e2termConn.RmrSend(params) if snderr != nil { - testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.desc, snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s", e2termConn.GetDesc(), snderr.Error()) } } diff --git a/pkg/control/ut_stub_xapp_test.go b/pkg/control/ut_stub_xapp_test.go index ac72b76..c9c297d 100644 --- a/pkg/control/ut_stub_xapp_test.go +++ b/pkg/control/ut_stub_xapp_test.go @@ -39,11 +39,14 @@ var xapp_e2asnpacker e2ap.E2APPackerIf = e2ap_wrapper.NewAsn1E2Packer() // //----------------------------------------------------------------------------- type xappTransaction struct { - tc *testingXappStub xid string meid *xapp.RMRMeid } +func (trans *xappTransaction) String() string { + return "trans(" + trans.xid + "/" + trans.meid.RanName + ")" +} + type testingXappStub struct { testingRmrStubControl xid_seq uint64 @@ -62,25 +65,16 @@ func createNewXappStub(desc string, rtfile string, port string, stat string) *te //----------------------------------------------------------------------------- // //----------------------------------------------------------------------------- -func (tc *testingXappStub) newXid() string { - var xid string - xid = tc.desc + "_XID_" + strconv.FormatUint(uint64(tc.xid_seq), 10) - tc.xid_seq++ - return xid -} - -//----------------------------------------------------------------------------- -// -//----------------------------------------------------------------------------- -func (tc *testingXappStub) newXappTransaction(xid *string, ranname string) *xappTransaction { +func (tc *testingXappStub) newXappTransaction(xid string, ranname string) *xappTransaction { trans := &xappTransaction{} - trans.tc = tc - if xid == nil { - trans.xid = tc.newXid() + if len(xid) == 0 { + trans.xid = tc.GetDesc() + "_XID_" + strconv.FormatUint(uint64(tc.xid_seq), 10) + tc.xid_seq++ } else { - trans.xid = *xid + trans.xid = xid } trans.meid = &xapp.RMRMeid{RanName: ranname} + xapp.Logger.Info("(%s) New test %s", tc.GetDesc(), trans.String()) return trans } @@ -93,17 +87,17 @@ func (tc *testingXappStub) Consume(params *xapp.RMRParams) (err error) { msg := &RMRParams{params} if params.Mtype == 55555 { - xapp.Logger.Info("(%s) Testing message ignore %s", tc.desc, msg.String()) + xapp.Logger.Info("(%s) Testing message ignore %s", tc.GetDesc(), msg.String()) tc.active = true return } - if strings.Contains(msg.Xid, tc.desc) { - xapp.Logger.Info("(%s) Consume %s", tc.desc, msg.String()) + if strings.Contains(msg.Xid, tc.GetDesc()) { + xapp.Logger.Info("(%s) Consume %s", tc.GetDesc(), msg.String()) tc.IncMsgCnt() tc.rmrConChan <- msg } else { - xapp.Logger.Info("(%s) Ignore %s", tc.desc, msg.String()) + xapp.Logger.Info("(%s) Ignore %s", tc.GetDesc(), msg.String()) } return } @@ -147,13 +141,19 @@ func (p *test_subs_req_params) Init() { } func (xappConn *testingXappStub) handle_xapp_subs_req(t *testing.T, rparams *test_subs_req_params, oldTrans *xappTransaction) *xappTransaction { - xapp.Logger.Info("(%s) handle_xapp_subs_req", xappConn.desc) + + trans := oldTrans + if oldTrans == nil { + trans = xappConn.newXappTransaction("", "RAN_NAME_1") + } + + xapp.Logger.Info("(%s) handle_xapp_subs_req %s", xappConn.GetDesc(), trans.String()) e2SubsReq := xapp_e2asnpacker.NewPackerSubscriptionRequest() //--------------------------------- // xapp activity: Send Subs Req //--------------------------------- - xapp.Logger.Info("(%s) Send Subs Req", xappConn.desc) + xapp.Logger.Info("(%s) Send Subs Req %s", xappConn.GetDesc(), trans.String()) myparams := rparams @@ -162,18 +162,12 @@ func (xappConn *testingXappStub) handle_xapp_subs_req(t *testing.T, rparams *tes myparams.Init() } - e2SubsReq.Set(myparams.req) - xapp.Logger.Debug("%s", e2SubsReq.String()) - err, packedMsg := e2SubsReq.Pack(nil) + err, packedMsg := e2SubsReq.Pack(myparams.req) if err != nil { - testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error()) + testError(t, "(%s) pack NOK %s %s", xappConn.GetDesc(), trans.String(), err.Error()) return nil } - - var trans *xappTransaction = oldTrans - if trans == nil { - trans = xappConn.newXappTransaction(nil, "RAN_NAME_1") - } + xapp.Logger.Debug("(%s) %s %s", xappConn.GetDesc(), trans.String(), e2SubsReq.String()) params := &RMRParams{&xapp.RMRParams{}} params.Mtype = xapp.RIC_SUB_REQ @@ -185,7 +179,7 @@ func (xappConn *testingXappStub) handle_xapp_subs_req(t *testing.T, rparams *tes snderr := xappConn.RmrSend(params) if snderr != nil { - testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s %s", xappConn.GetDesc(), trans.String(), snderr.Error()) return nil } return trans @@ -195,7 +189,7 @@ func (xappConn *testingXappStub) handle_xapp_subs_req(t *testing.T, rparams *tes // //----------------------------------------------------------------------------- func (xappConn *testingXappStub) handle_xapp_subs_resp(t *testing.T, trans *xappTransaction) uint32 { - xapp.Logger.Info("(%s) handle_xapp_subs_resp", xappConn.desc) + xapp.Logger.Info("(%s) handle_xapp_subs_resp", xappConn.GetDesc()) e2SubsResp := xapp_e2asnpacker.NewPackerSubscriptionResponse() var e2SubsId uint32 @@ -206,10 +200,10 @@ func (xappConn *testingXappStub) handle_xapp_subs_resp(t *testing.T, trans *xapp case msg := <-xappConn.rmrConChan: xappConn.DecMsgCnt() if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_RESP"] { - testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype]) + testError(t, "(%s) Received RIC_SUB_RESP wrong mtype expected %s got %s, error", xappConn.GetDesc(), "RIC_SUB_RESP", xapp.RicMessageTypeToName[msg.Mtype]) return 0 } else if msg.Xid != trans.xid { - testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid) + testError(t, "(%s) Received RIC_SUB_RESP wrong xid expected %s got %s, error", xappConn.GetDesc(), trans.xid, msg.Xid) return 0 } else { packedData := &packer.PackedData{} @@ -219,21 +213,15 @@ func (xappConn *testingXappStub) handle_xapp_subs_resp(t *testing.T, trans *xapp } else { e2SubsId = 0 } - unpackerr := e2SubsResp.UnPack(packedData) - + unpackerr, resp := e2SubsResp.UnPack(packedData) if unpackerr != nil { - testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error()) + testError(t, "(%s) RIC_SUB_RESP unpack failed err: %s", xappConn.GetDesc(), unpackerr.Error()) } - geterr, resp := e2SubsResp.Get() - if geterr != nil { - testError(t, "(%s) RIC_SUB_RESP get failed err: %s", xappConn.desc, geterr.Error()) - } - - xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq) + xapp.Logger.Info("(%s) Recv Subs Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.GetDesc(), msg.Xid, msg.SubId, resp.RequestId.Seq) return e2SubsId } case <-time.After(15 * time.Second): - testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.desc) + testError(t, "(%s) Not Received RIC_SUB_RESP within 15 secs", xappConn.GetDesc()) return 0 } return 0 @@ -243,7 +231,7 @@ func (xappConn *testingXappStub) handle_xapp_subs_resp(t *testing.T, trans *xapp // //----------------------------------------------------------------------------- func (xappConn *testingXappStub) handle_xapp_subs_fail(t *testing.T, trans *xappTransaction) uint32 { - xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.desc) + xapp.Logger.Info("(%s) handle_xapp_subs_fail", xappConn.GetDesc()) e2SubsFail := xapp_e2asnpacker.NewPackerSubscriptionFailure() var e2SubsId uint32 @@ -254,10 +242,10 @@ func (xappConn *testingXappStub) handle_xapp_subs_fail(t *testing.T, trans *xapp case msg := <-xappConn.rmrConChan: xappConn.DecMsgCnt() if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_FAILURE"] { - testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype]) + testError(t, "(%s) Received RIC_SUB_FAILURE wrong mtype expected %s got %s, error", xappConn.GetDesc(), "RIC_SUB_FAILURE", xapp.RicMessageTypeToName[msg.Mtype]) return 0 } else if msg.Xid != trans.xid { - testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid) + testError(t, "(%s) Received RIC_SUB_FAILURE wrong xid expected %s got %s, error", xappConn.GetDesc(), trans.xid, msg.Xid) return 0 } else { packedData := &packer.PackedData{} @@ -267,21 +255,15 @@ func (xappConn *testingXappStub) handle_xapp_subs_fail(t *testing.T, trans *xapp } else { e2SubsId = 0 } - unpackerr := e2SubsFail.UnPack(packedData) - + unpackerr, resp := e2SubsFail.UnPack(packedData) if unpackerr != nil { - testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.desc, unpackerr.Error()) - } - geterr, resp := e2SubsFail.Get() - if geterr != nil { - testError(t, "(%s) RIC_SUB_FAILURE get failed err: %s", xappConn.desc, geterr.Error()) + testError(t, "(%s) RIC_SUB_FAILURE unpack failed err: %s", xappConn.GetDesc(), unpackerr.Error()) } - - xapp.Logger.Info("(%s) Recv Subs Fail rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq) + xapp.Logger.Info("(%s) Recv Subs Fail rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.GetDesc(), msg.Xid, msg.SubId, resp.RequestId.Seq) return e2SubsId } case <-time.After(15 * time.Second): - testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.desc) + testError(t, "(%s) Not Received RIC_SUB_FAILURE within 15 secs", xappConn.GetDesc()) return 0 } return 0 @@ -291,31 +273,30 @@ func (xappConn *testingXappStub) handle_xapp_subs_fail(t *testing.T, trans *xapp // //----------------------------------------------------------------------------- func (xappConn *testingXappStub) handle_xapp_subs_del_req(t *testing.T, oldTrans *xappTransaction, e2SubsId uint32) *xappTransaction { - xapp.Logger.Info("(%s) handle_xapp_subs_del_req", xappConn.desc) - e2SubsDelReq := xapp_e2asnpacker.NewPackerSubscriptionDeleteRequest() + trans := oldTrans + if oldTrans == nil { + trans = xappConn.newXappTransaction("", "RAN_NAME_1") + } + + xapp.Logger.Info("(%s) handle_xapp_subs_del_req %s", xappConn.GetDesc(), trans.String()) + e2SubsDelReq := xapp_e2asnpacker.NewPackerSubscriptionDeleteRequest() //--------------------------------- // xapp activity: Send Subs Del Req //--------------------------------- - xapp.Logger.Info("(%s) Send Subs Del Req", xappConn.desc) + xapp.Logger.Info("(%s) Send Subs Del Req %s", xappConn.GetDesc(), trans.String()) req := &e2ap.E2APSubscriptionDeleteRequest{} req.RequestId.Id = 1 req.RequestId.Seq = e2SubsId req.FunctionId = 1 - e2SubsDelReq.Set(req) - xapp.Logger.Debug("%s", e2SubsDelReq.String()) - err, packedMsg := e2SubsDelReq.Pack(nil) + err, packedMsg := e2SubsDelReq.Pack(req) if err != nil { - testError(t, "(%s) pack NOK %s", xappConn.desc, err.Error()) + testError(t, "(%s) pack NOK %s %s", xappConn.GetDesc(), trans.String(), err.Error()) return nil } - - var trans *xappTransaction = oldTrans - if trans == nil { - trans = xappConn.newXappTransaction(nil, "RAN_NAME_1") - } + xapp.Logger.Debug("(%s) %s %s", xappConn.GetDesc(), trans.String(), e2SubsDelReq.String()) params := &RMRParams{&xapp.RMRParams{}} params.Mtype = xapp.RIC_SUB_DEL_REQ @@ -326,8 +307,9 @@ func (xappConn *testingXappStub) handle_xapp_subs_del_req(t *testing.T, oldTrans params.Mbuf = nil snderr := xappConn.RmrSend(params) + if snderr != nil { - testError(t, "(%s) RMR SEND FAILED: %s", xappConn.desc, snderr.Error()) + testError(t, "(%s) RMR SEND FAILED: %s %s", xappConn.GetDesc(), trans.String(), snderr.Error()) return nil } return trans @@ -337,7 +319,7 @@ func (xappConn *testingXappStub) handle_xapp_subs_del_req(t *testing.T, oldTrans // //----------------------------------------------------------------------------- func (xappConn *testingXappStub) handle_xapp_subs_del_resp(t *testing.T, trans *xappTransaction) { - xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.desc) + xapp.Logger.Info("(%s) handle_xapp_subs_del_resp", xappConn.GetDesc()) e2SubsDelResp := xapp_e2asnpacker.NewPackerSubscriptionDeleteResponse() //--------------------------------- @@ -347,26 +329,22 @@ func (xappConn *testingXappStub) handle_xapp_subs_del_resp(t *testing.T, trans * case msg := <-xappConn.rmrConChan: xappConn.DecMsgCnt() if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_RESP"] { - testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", xappConn.desc, "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype]) + testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong mtype expected %s got %s, error", xappConn.GetDesc(), "RIC_SUB_DEL_RESP", xapp.RicMessageTypeToName[msg.Mtype]) return } else if trans != nil && msg.Xid != trans.xid { - testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.desc, trans.xid, msg.Xid) + testError(t, "(%s) Received RIC_SUB_DEL_RESP wrong xid expected %s got %s, error", xappConn.GetDesc(), trans.xid, msg.Xid) return } else { packedData := &packer.PackedData{} packedData.Buf = msg.Payload - unpackerr := e2SubsDelResp.UnPack(packedData) + unpackerr, resp := e2SubsDelResp.UnPack(packedData) if unpackerr != nil { - testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.desc, unpackerr.Error()) - } - geterr, resp := e2SubsDelResp.Get() - if geterr != nil { - testError(t, "(%s) RIC_SUB_DEL_RESP get failed err: %s", xappConn.desc, geterr.Error()) + testError(t, "(%s) RIC_SUB_DEL_RESP unpack failed err: %s", xappConn.GetDesc(), unpackerr.Error()) } - xapp.Logger.Info("(%s) Recv Subs Del Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.desc, msg.Xid, msg.SubId, resp.RequestId.Seq) + xapp.Logger.Info("(%s) Recv Subs Del Resp rmr: xid=%s subid=%d, asn: seqnro=%d", xappConn.GetDesc(), msg.Xid, msg.SubId, resp.RequestId.Seq) return } case <-time.After(15 * time.Second): - testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.desc) + testError(t, "(%s) Not Received RIC_SUB_DEL_RESP within 15 secs", xappConn.GetDesc()) } } diff --git a/pkg/control/ut_test.go b/pkg/control/ut_test.go index 23e4374..151619d 100644 --- a/pkg/control/ut_test.go +++ b/pkg/control/ut_test.go @@ -25,6 +25,7 @@ import ( "io/ioutil" "os" "strings" + "sync" "testing" "time" ) @@ -34,11 +35,24 @@ import ( //----------------------------------------------------------------------------- type testingRmrControl struct { desc string + mutex sync.Mutex syncChan chan struct{} } +func (tc *testingRmrControl) Lock() { + tc.mutex.Lock() +} + +func (tc *testingRmrControl) Unlock() { + tc.mutex.Unlock() +} + +func (tc *testingRmrControl) GetDesc() string { + return tc.desc +} + func (tc *testingRmrControl) ReadyCB(data interface{}) { - xapp.Logger.Info("testingRmrControl(%s) ReadyCB", tc.desc) + xapp.Logger.Info("testingRmrControl(%s) ReadyCB", tc.GetDesc()) tc.syncChan <- struct{}{} return } @@ -83,7 +97,7 @@ func (tc *testingRmrStubControl) DecMsgCnt() { func (tc *testingRmrStubControl) TestMsgCnt(t *testing.T) { if tc.GetMsgCnt() > 0 { - testError(t, "(%s) message count expected 0 but is %d", tc.desc, tc.GetMsgCnt()) + testError(t, "(%s) message count expected 0 but is %d", tc.GetDesc(), tc.GetMsgCnt()) } } @@ -91,18 +105,18 @@ func (tc *testingRmrStubControl) RmrSend(params *RMRParams) (err error) { // //NOTE: Do this way until xapp-frame sending is improved // - xapp.Logger.Info("(%s) RmrSend %s", tc.desc, params.String()) + xapp.Logger.Info("(%s) RmrSend %s", tc.GetDesc(), params.String()) status := false i := 1 for ; i <= 10 && status == false; i++ { status = tc.rmrClientTest.SendMsg(params.RMRParams) if status == false { - xapp.Logger.Info("(%s) RmrSend failed. Retry count %v, %s", tc.desc, i, params.String()) + xapp.Logger.Info("(%s) RmrSend failed. Retry count %v, %s", tc.GetDesc(), i, params.String()) time.Sleep(500 * time.Millisecond) } } if status == false { - err = fmt.Errorf("(%s) RmrSend failed. Retry count %v, %s", tc.desc, i, params.String()) + err = fmt.Errorf("(%s) RmrSend failed. Retry count %v, %s", tc.GetDesc(), i, params.String()) xapp.Rmr.Free(params.Mbuf) } return -- 2.16.6