#
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
# 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 \
&& 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
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
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)"
+
#
#
#
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
}
//-----------------------------------------------------------------------------
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)
}
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)
}
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)
}
// 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)
}
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)
}
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)
}
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)
}
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)
}
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)
}
// 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)
}
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)
}
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)
}
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)
}
"unsafe"
)
+const cMsgBufferMaxSize = 40960
+const cMsgBufferExtra = 512
+
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
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 {
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++ {
}
-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.")
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 {
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.")
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())
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 {
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())
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 {
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 {
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.")
return &e2apMsgSubscriptionDeleteFailure{}
}
-func (*cppasn1E2APPacker) MessageInfo(msg *packer.PackedData) *packer.MessageInfo {
- e2apMsg := &e2apMessage{}
- return e2apMsg.UnPack(msg)
-}
-
func NewAsn1E2Packer() e2ap.E2APPackerIf {
return &cppasn1E2APPacker{}
}
"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
}
//-----------------------------------------------------------------------------
}
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())
}
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))
}
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
}
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))
}
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
}
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))
}
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
}
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))
}
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
}
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))
}
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
}
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))
}
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
}
// 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)
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)
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)
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
}
//
//-----------------------------------------------------------------------------
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()
//---------------------------------
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{}
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
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())
}
}
}
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
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())
}
}
//
//-----------------------------------------------------------------------------
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()
//---------------------------------
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
}
}
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
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())
}
}
//
//-----------------------------------------------------------------------------
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
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
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())
}
}
//
//-----------------------------------------------------------------------------
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
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
-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
}
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
}
}
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
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
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
//
//-----------------------------------------------------------------------------
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
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{}
} 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
//
//-----------------------------------------------------------------------------
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
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{}
} 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
//
//-----------------------------------------------------------------------------
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
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
//
//-----------------------------------------------------------------------------
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()
//---------------------------------
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())
}
}
"io/ioutil"
"os"
"strings"
+ "sync"
"testing"
"time"
)
//-----------------------------------------------------------------------------
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
}
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())
}
}
//
//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
Code Review / ric-plt / submgr.git / commitdiff