xAppRmrEndPoint := restSubscription.xAppRmrEndPoint
go func() {
- xapp.Logger.Info("Deleteting instances = %v", restSubscription.InstanceIds)
+ xapp.Logger.Info("Deleteting handler: processing instances = %v", restSubscription.InstanceIds)
for _, instanceId := range restSubscription.InstanceIds {
xAppEventInstanceID, err := c.SubscriptionDeleteHandler(&restSubId, &xAppRmrEndPoint, &restSubscription.Meid, instanceId)
fmt.Println("CRESTSubscriptionRequest")
+ if p == nil {
+ return
+ }
+
if p.SubscriptionID != "" {
fmt.Println(" SubscriptionID = ", p.SubscriptionID)
} else {
var xAppHTTPEndPoint string
var xAppRMREndPoint string
- if host == "" || (HTTP_port == 0 && RMR_port == 0) {
+ if host == "" {
+ err := fmt.Errorf("ClientEndpoint provided without HOST name")
+ return "", "", err
+ }
+
+ if HTTP_port == 0 && RMR_port == 0 {
err := fmt.Errorf("ClientEndpoint provided without PORT numbers")
return "INVALID_HTTP_ADDRESS:" + host + (string)(*clientEndpoint.HTTPPort),
"INVALID_RMR_ADDRESS:" + host + (string)(*clientEndpoint.RMRPort),
params2.SetSubscriptionID(&restSubId)
xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
- xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
+ xappConn1.ExpectAnyNotification(t)
// Resend the original request with an additional e2 subscription (detail), this time with restsubsid
restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+ e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+ assert.Equal(t, e2SubsId, e2SubsId1)
crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
+ xappConn1.DecrementRequestCount()
xappConn1.ExpectRESTNotification(t, restSubId_resend)
e2termConn1.SendSubsResp(t, crereq2, cremsg2)
e2SubsId2 := xappConn1.WaitRESTNotification(t, restSubId_resend)
xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
params.SetSubscriptionID(&restSubId)
- xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
+ xappConn1.ExpectAnyNotification(t)
// Resend the original request again with only one e2 subscription (detail), this time with restsubsid
restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
assert.Equal(t, restSubId_resend, restSubId_resend2)
+ e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
+ assert.Equal(t, e2SubsId, e2SubsId1)
+
// Delete both e2 subscriptions
xappConn1.SendRESTSubsDelReq(t, &restSubId)
e2SubsIds := []uint32{e2SubsId, e2SubsId2}
params2.SetSubscriptionID(&restSubId)
xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
- xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
+ xappConn1.ExpectAnyNotification(t)
// Resend the original request with an additional e2 subscription (detail), this time with restsubsid
restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+ e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+ assert.Equal(t, e2SubsId, e2SubsId1)
+ // The first E2 subscription returns immediately, manually decrement expected request count for the remaining request handling
+ xappConn1.DecrementRequestCount()
+
crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
xappConn1.ExpectRESTNotification(t, restSubId_resend)
xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
- xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
+ xappConn1.ExpectAnyNotification(t)
// Resend the original request again with only one e2 subscription (detail), WITHOUT restsubsid
// md5sum shall find the original request
restSubId_resend2 := xappConn1.SendRESTSubsReq(t, params)
assert.Equal(t, restSubId_resend, restSubId_resend2)
+ e2SubsId1 = xappConn1.WaitAnyRESTNotification(t)
+ assert.Equal(t, e2SubsId, e2SubsId1)
+
// Delete both e2 subscriptions
xappConn1.SendRESTSubsDelReq(t, &restSubId)
e2SubsIds := []uint32{e2SubsId, e2SubsId2}
params2.SetSubscriptionID(&restSubId)
xapp.Subscription.SetResponseCB(xappConn1.SubscriptionRespHandler)
- xappConn1.WaitRESTNotificationForAnySubscriptionId(t)
+ xappConn1.ExpectAnyNotification(t)
// Resend the original request with an additional e2 subscription (detail), this time with restsubsid
restSubId_resend := xappConn1.SendRESTSubsReq(t, params2)
+ e2SubsId1 := xappConn1.WaitAnyRESTNotification(t)
+ assert.Equal(t, e2SubsId, e2SubsId1)
+
crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
xappConn1.ExpectRESTNotification(t, restSubId_resend)
params.SetMeid("RAN_NAME_1")
xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
- xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
+ xappConn2.ExpectAnyNotification(t)
waiter := rtmgrHttp.AllocNextSleep(10, true)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
waiter.WaitResult(t)
xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
- e2SubsId2 := <-xappConn2.RESTNotification
+ e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
params.SetMeid("RAN_NAME_1")
xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
- xappConn2.WaitRESTNotificationForAnySubscriptionId(t)
+ xappConn2.ExpectAnyNotification(t)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
- e2SubsId2 := <-xappConn2.RESTNotification
+ e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
import (
"fmt"
+ "runtime/debug"
"strconv"
"testing"
"time"
if tc.requestCount == 0 {
tc.TestError(t, "### REST notification count unexpectedly ZERO for %s (%v)", restSubsId, tc)
} else if e2Ids.RestSubsId != restSubsId {
- tc.TestError(t, "### Unexpected REST notifications received |%s:%s| (%v)", e2Ids.RestSubsId, restSubsId, tc)
+ tc.TestError(t, "### Unexpected REST notifications received, expected %s bunt got %s instead| (%v)", e2Ids.RestSubsId, restSubsId, tc)
} else if e2Ids.ErrorCause == "" && expectError == "allFail" {
tc.TestError(t, "### Unexpected ok cause received from REST notifications |%s:%s| (%v)", e2Ids.RestSubsId, restSubsId, tc)
} else if e2Ids.ErrorCause != "" && expectError == "allOk" {
}
tc.Info("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
tc.ListedRESTNotifications <- e2Ids
+ if len(tc.ListedRESTNotifications) > 1 {
+ panic("expectNotification - ListedRESTNotifications stacking up")
+ }
}
case <-time.After(15 * time.Second):
err := fmt.Errorf("### Timeout 15s expired while expecting REST notification for subsId: %v", restSubsId)
}
func (tc *E2Stub) WaitRESTNotification(t *testing.T, restSubsId string) uint32 {
+
+ stack := string(debug.Stack())
+
select {
case e2SubsId := <-tc.ListedRESTNotifications:
if e2SubsId.RestSubsId == restSubsId {
tc.Info("### Expected REST notifications received %s, e2SubsId %v for endpoint=%s, (%v)", e2SubsId.RestSubsId, e2SubsId.E2SubsId, tc.clientEndpoint, tc)
return e2SubsId.E2SubsId
} else {
- tc.TestError(t, "### Unexpected REST notifications received %s, expected %s for endpoint=%s, (%v)", e2SubsId.RestSubsId, restSubsId, tc.clientEndpoint, tc)
+ tc.TestError(t, "### Unexpected REST notification %s received, expected %s for endpoint=%s, (%v)", e2SubsId.RestSubsId, restSubsId, tc.clientEndpoint, tc)
+ xapp.Logger.Info("CALL STACK:\n %s", stack)
return 0
}
case <-time.After(15 * time.Second):
err := fmt.Errorf("### Timeout 15s expired while waiting REST notification for subsId: %v", restSubsId)
tc.TestError(t, "%s", err.Error())
+ xapp.Logger.Info("CALL STACK:\n %s", stack)
panic("WaitRESTNotification - timeout error")
}
- return 0
}
-func (tc *E2Stub) WaitRESTNotificationForAnySubscriptionId(t *testing.T) {
+// Note, this function should be followed by a handling of <-xappConn1.RESTNotification.
+func (tc *E2Stub) ExpectAnyNotification(t *testing.T) {
go func() {
- tc.Info("### REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc)
+ tc.Info("### Started waiting ANY REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc)
select {
case e2SubsId := <-tc.CallBackNotification:
- tc.Info("### REST notifications received e2SubsId %v for endpoint=%s, (%v)", e2SubsId, tc.clientEndpoint, tc)
+ tc.Info("### ANY REST notifications received e2SubsId %v for endpoint=%s, (%v) via CallBackNotification", e2SubsId, tc.clientEndpoint, tc)
tc.RESTNotification <- (uint32)(e2SubsId)
case <-time.After(15 * time.Second):
- err := fmt.Errorf("### Timeout 15s expired while waiting REST notification")
+ err := fmt.Errorf("### Timeout 15s expired while waiting ANY REST notification")
tc.TestError(t, "%s", err.Error())
tc.RESTNotification <- 0
}
}()
}
+func (tc *E2Stub) WaitAnyRESTNotification(t *testing.T) uint32 {
+
+ select {
+ case e2SubsId := <-tc.RESTNotification:
+ tc.Info("### Expected ANY REST notification received - e2SubsId %v for endpoint=%s, (%v)", e2SubsId, tc.clientEndpoint, tc)
+ return e2SubsId
+
+ case <-time.After(15 * time.Second):
+ err := fmt.Errorf("### Timeout 15s expired while waiting ANY REST notification")
+ tc.TestError(t, "%s", err.Error())
+ panic("WaitRESTNotification - timeout error")
+ }
+}
+
func (tc *E2Stub) ListedRestNotifHandler(resp *clientmodel.SubscriptionResponse) {
if len(tc.restSubsIdList) == 0 {
}
if len(tc.restSubsIdList) == 0 {
- //tc.Info("All listed REST notifications received for endpoint=%s", tc.clientEndpoint)
+ tc.Info("All listed REST notifications received for endpoint=%s", tc.clientEndpoint)
}
return
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendRESTSubsDelReq(t *testing.T, subscriptionID *string) {
+ tc.Info("======== Posting REST DELETE subscription(s) to Submgr ======")
+
if *subscriptionID == "" {
tc.Error("REST error in deleting subscriptions. Empty SubscriptionID = %s", *subscriptionID)
}
return &policyParams
}
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (tc *E2Stub) DecrementRequestCount() {
+ if tc.requestCount > 0 {
+ tc.requestCount -= 1
+ } else {
+ tc.Error("FAILED to decrement request count, count already ZERO")
+ }
+}
+
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------