Subscription Manager is a basic platform service in RIC. It is responsible for managing E2 subscriptions from xApps to the
E2 Node (eNodeB or gNodeB).
-xApp can subscribe and unsubscribe messages from E2 Node through Subscription Manager. Subscription Manager manages subscriptions
-and message routing of the subscribed messages between E2 Termination and xApps. If one xApp has already made a subscription
-and then another xApp initiates identical subscription, Subscription Manager does not forward the subscription to E2 Node but merges the
-subscriptions internally. In merge case Subscription Manager just updates the message routing information to Routing Manager and
-sends response to xApp.
+xApp can make subscriptions to E2 Node through Subscription Manager. xApp can subscribe REPORT, INSERT, CONTROL and POLICY type services
+from E2 Node. For some of those subscription types E2 Node sends E2 Indication messages back to xApp. For those messages there need to be
+created route between E2 Termination and xApp. Subscription Manager manages E2 subscriptions and message request routing of the subscribed
+messages from Routing Manager. If one xApp has already made a subscription and then another xApp initiates identical subscription, Subscription
+Manager does not forward the subscription to E2 Node but merges the subscriptions internally and request Routing Manager to create route also
+for the second xApp and sends response to xApp. xApp can indicate in the request should Subscription Manager send request for Routing Manager
+to create route for the E2 subscription in the request.
Interface between xApp and Subscription Manager is HTTP based REST interface. Interface codes are generated with help of Swagger from a
-yaml definition file. REST interface is used also between Subscription Manager and Routing Manager. Subscription Manager and
-E2 Termination interface is based on RMR messages. xApp should use also Swagger generated code when it implements subscription REST
-interface towards Subscription Manager.
+yaml definition file. REST interface is used also between Subscription Manager and Routing Manager. Subscription Manager and E2 Termination
+interface is based on RMR messages. xApp should use also Swagger generated code when it implements subscription REST interface towards Subscription
+Manager.
.. image:: images/PlaceInRICSoftwareArchitecture.png
:width: 600
:alt: Place in RIC's software architecture picture
-One xApp generated REST subscription message can contain multiple E2 subscriptions. For every E2 subscription in the message there is also
-xApp generated xApp instance id. In E2 interface there can be only one ongoing E2 subscription or subscription delete procedure towards
+One xApp generated REST subscription request message can contain multiple E2 subscriptions. For every E2 subscription in the message there must be
+also xApp generated xApp instance id. In E2 interface there can be only one ongoing E2 subscription or subscription delete procedure towards
E2 Node at any time. That is because Subscription Manager is able to merge new E2 subscriptions only which those it has already received
-successful response from E2 Node. E2 subscriptions and delete subscriptions may be therefore queued in Subscription Manager.
+successful response from E2 Node. E2 subscriptions and delete subscriptions may be therefore queued for a moment in Subscription Manager.
Subscription Manager may need to do reties towards E2 Node during subscribe or subscription delete procedure. Retries will increase completion
time of the procedure. This needs to be considered in xApp's implementation. Subscription Manager sends REST notification to xApp for every
-completed E2 subscription procedure regardless is the E2 subscription successful or not. Notification is not sent for E2 subscription delete
+completed E2 subscription procedure. That is regardless was the E2 subscription successful or not. Notification is not sent for E2 subscription delete
procedures. Subscription Manager allocates globally unique REST request id for each new REST subscription request. That is returned to xApp in
response. When xApp wants to delete REST subscription, xApp need to use the same id in deletion request.
-Subscription Manager allocates unique id also for the E2 subscriptions (E2 instance id). The id called 'InstanceId' in E2 specification.
+Subscription Manager allocates also unique id for every E2 subscriptions (E2 instance id). The id called 'InstanceId' in E2 specification.
In successful case the REST notification contains the id generated for the REST request, xApp instance id and E2 instance id. From xApp point
-of view xApp instance id identifies received REST notification for the E2 subscription in the REST request. REST notification contains also Subscription
+of view xApp instance id identifies response REST notification for the E2 subscription in the REST request. REST notification contains also Subscription
Manager generated E2 instance id. xApp can use that to map received E2 Indication message to E2 subscription. If E2 subscription procedure is unsuccessful
-then E2 instance id is 0 and the notification contains non-zero error cause string.
+then E2 instance id is 0 and the notification contains non-zero error cause string and source of that error information.
xApp need to be able preserve Subscription Manager allocated REST request id over xApp restart. The id is needed for deletion of the REST
subscription and if there is need to resend the same REST request.
-Three different type of subscriptions are supported. REPORT, POLICY and INSERT. REPORT and INSERT works the same way from subscription point of view.
-REPORT and INSERT type REST subscription request can contain content for multiple E2 subscriptions. POLICY subscription can also contain content for multiple
-E2 subscriptions but using in that way may not be feasible. REPORT, POLICY and INSERT type subscriptions in the same REST request are not supported supported
-in Subscription Manager.
+Three different type subscriptions are supported. REPORT, POLICY and INSERT. REPORT and INSERT works the same way from subscription point of view.
+REPORT and INSERT type REST subscription request can contain multiple E2 subscriptions. POLICY subscription can also contain multiple E2 subscriptions but
+using it in that way may not be feasible. REPORT, POLICY and INSERT type subscriptions in the same REST request are not supported supported in Subscription Manager.
-REPORT and INSERT type subscription can contain content for multiple E2 subscriptions. If there is need to resend the same REST request, the request must
-contain Subscription Manager allocated id for the REST request, which was returned to xApp when the request was sent first time. The request must also
-contain the same content as first time. Reason for xApp to resend the same request could be timeout or some failure which is not permanent in E2 Node or
-xApp restart. In retry cases Subscription Manager retries the E2 subscriptions which does not exist in its records. For others Subscription Manager
-returns successful REST notification without sending any messages to E2 Node. One REST Subscription request can contain E2 subscriptions to only one E2 Node.
+REPORT and INSERT type subscription can contain multiple E2 subscriptions. If xApp needs to resend the same REST request, the request must contain Subscription
+Manager allocated id for the REST request, which was returned to xApp when the request was sent first time. The request must also contain the same content as
+first time. Reason for xApp to resend the same request could be timeout or some failure which is not permanent like E2 interface connection break or xApp restart.
+In retry case Subscription Manager retries the E2 subscriptions towards to E2 Node in the request message which it does not have record. For subscriptions
+which record is found Subscription Manager returns successful REST notification to xApp without forwarding request to E2 Node. One REST Subscription request can
+contain E2 subscriptions only for one E2 Node.
+
+Subscription Manager indicates to xApp in response notification if there has happened any error or timeout. xApp can send retry based on that information but
+resending should happen after Subscription Manager has processed the previous request completely otherwise the request is rejected. If timeout happens response
+notification contains information where it happened. Timeout can happen in E2, Routing Manager and SDL interface.
If there is need to change REPORT or INSERT type subscription then previously made subscription need to be deleted first. If there are any REPORT or INSERT
type E2 subscription which need to change frequently, it is not good idea to bundle them with other REPORT or INSERT type E2 subscriptions in the same REST
subscription request.
-POLICY type subscription can contain content for multiple E2 subscriptions but it may not be feasible as POLICY subscription may change. Idea in POLICY
-subscription is that xApp can send changed contend to E2 Node without making new subscription but just send update. In such case it is not good idea to bundle
-the POLICY type E2 subscription with any other POLICY type E2 subscriptions in the same REST subscription request.
+POLICY type subscription can contain multiple E2 subscriptions but it may not be feasible as POLICY subscription may change. Idea in POLICY subscription is that
+xApp can send changed contend to E2 Node without making new subscription but just send update. Message contend can be changed frequently. In such case it may not
+be good idea to bundle the POLICY type E2 subscription with any other POLICY type E2 subscriptions in the same REST subscription request.
+
+xApp must be able to preserve is the Subscription Manager allocated REST requests ids over restart or send the same request as was sent restart. If xApp is able
+to send exactly the same requests then Subscription manager can identify the request and send same responses back to xApp. This way xApp can restore the identifies
+related to existing subscriptions. Another alternative is store needed information in database. Subscription manager calculates md5 sum over the REST Subscription
+request message. That is how it can detect identical request coming from a specific xApp.
-In xApp restart case only mandatory thing what is required xApp to be able preserve is the Subscription Manager allocated REST requests ids. That is if xApp
-can generate the equal requests otherwise as were done first time before restart. xApp can resent the same REST requests to Subscription Manager as first time
-before restart. REST request id must be placed in the REST request. That is the only way for Subscription Manager to identify already made subscriptions in it
-records and work as expected, i.e. not run into problems and return successful REST notifications to xApp without sending any messages to E2 Node.
+xApp can set in the request how many times Subscription Manager will retry subscription in E2 interface if there is timeout. xApp can also set time Subscription
+Manager Will wait response from E2 Node. xApp may need to update POLICY type subscription frequently. In such case it is not necessary feasible that
+Subscription Manager retries outdated subscription. By default Subscription Manager retries twice and response waiting time is two seconds.
+
+In error case REST notification contains source of error. Source of error can be Subscription Manager, Routing Manager, E2 Node, ASN1 encoding/decoding and DBAAS/SDL.
+The error information received from these sources is directly copied in the response.
Architecture
------------
of the xApp who makes the first subscription. E2 Node uses Subscription Manager allocated RIC Requestor ID in all RIC Indication messages it sends
to RIC for the subscription. In merge case subscription in E2 Node is created only for the first requestor.
+ More information about Routing manager, how routes are created and related signaling can be found from here (Note that there is still
+ RMR based interface between xApp and Subscription Manager in the pictures on those pages):
+
+ `<https://wiki.o-ran-sc.org/display/RICP/Routing+Manager+Architecture>`_
+
+ `<https://wiki.o-ran-sc.org/display/RICP/Routing+Manager+and+Subscription+Manager>`_
+
+
+ * Subscription Request message
+
+ .. image:: images/REST_Subscription_Request.png
+ :width: 600
+ :alt: Subscription Request message
+
+
+ * Subscription RESTRequest Response message
+
+ .. image:: images/REST_Subscription_Response.png
+ :width: 600
+ :alt: REST Subscription Request Response message
+
+
+ * Subscription Request Notification message
+
+ .. image:: images/REST_Subscription_Notification.png
+ :width: 600
+ :alt: REST Subscription Notification message
+
+ * Routing Manager REST interface messages
+
+ .. image:: images/Routing_Manager_REST_interface_messages.png
+ :width: 600
+ :alt: Routing Manager REST interface messages
+
+
* Subscription procedure
* Successful case
Example: curl -s GET "http://10.244.0.181:8080/ric/v1/metrics"
- Get subscriptions
+ Get REST subscriptions
+
+ .. code-block:: none
+
+ Example: curl -X GET "http://10.244.0.181:8080/ric/v1/restsubscriptions"
+
+ Get E2 subscriptions
.. code-block:: none
Example: curl -X GET "http://10.244.0.181:8088/ric/v1/subscriptions"
- Delete single subscription from db
+ Delete single E2 subscription from db
.. code-block:: none
E2AP_TimeToWaitW2ms uint64 = 2
E2AP_TimeToWaitW5ms uint64 = 3
E2AP_TimeToWaitW10ms uint64 = 4
- E2AP_TimeToWaitW20ms uint64 = 4
- E2AP_TimeToWaitW30ms uint64 = 5
- E2AP_TimeToWaitW40ms uint64 = 6
- E2AP_TimeToWaitW50ms uint64 = 7
- E2AP_TimeToWaitW100ms uint64 = 8
- E2AP_TimeToWaitW200ms uint64 = 9
- E2AP_TimeToWaitW500ms uint64 = 10
- E2AP_TimeToWaitW1s uint64 = 11
- E2AP_TimeToWaitW2s uint64 = 12
- E2AP_TimeToWaitW5s uint64 = 13
- E2AP_TimeToWaitW10s uint64 = 14
- E2AP_TimeToWaitW20s uint64 = 15
- E2AP_TimeToWaitW60 uint64 = 16
+ E2AP_TimeToWaitW20ms uint64 = 5
+ E2AP_TimeToWaitW30ms uint64 = 6
+ E2AP_TimeToWaitW40ms uint64 = 7
+ E2AP_TimeToWaitW50ms uint64 = 8
+ E2AP_TimeToWaitW100ms uint64 = 9
+ E2AP_TimeToWaitW200ms uint64 = 10
+ E2AP_TimeToWaitW500ms uint64 = 11
+ E2AP_TimeToWaitW1s uint64 = 12
+ E2AP_TimeToWaitW2s uint64 = 13
+ E2AP_TimeToWaitW5s uint64 = 14
+ E2AP_TimeToWaitW10s uint64 = 15
+ E2AP_TimeToWaitW20s uint64 = 16
+ E2AP_TimeToWaitW60 uint64 = 17
)
var E2AP_TimeToWaitStrMap = map[string]uint64{
replace gerrit.o-ran-sc.org/r/ric-plt/sdlgo => gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.7.0
-replace gerrit.o-ran-sc.org/r/ric-plt/xapp-frame => gerrit.o-ran-sc.org/r/ric-plt/xapp-frame.git v0.8.3
+replace gerrit.o-ran-sc.org/r/ric-plt/xapp-frame => gerrit.o-ran-sc.org/r/ric-plt/xapp-frame.git v0.8.5
replace gerrit.o-ran-sc.org/r/com/golog => gerrit.o-ran-sc.org/r/com/golog.git v0.0.2
gerrit.o-ran-sc.org/r/ric-plt/e2ap v0.0.0-00010101000000-000000000000
gerrit.o-ran-sc.org/r/ric-plt/sdlgo v0.7.0
gerrit.o-ran-sc.org/r/ric-plt/xapp-frame v0.0.0-00010101000000-000000000000
- github.com/go-openapi/errors v0.19.3
github.com/go-openapi/runtime v0.19.4
github.com/go-openapi/strfmt v0.19.4
- github.com/go-openapi/swag v0.19.7
- github.com/go-openapi/validate v0.19.6
github.com/gorilla/mux v1.7.1
github.com/segmentio/ksuid v1.0.3
github.com/spf13/viper v1.4.0
gerrit.o-ran-sc.org/r/ric-plt/sdlgo.git v0.7.0/go.mod h1:KCHu4JkWnw2Ro6P747wU9S2t7zxFLmBNCiYvGZo3CHo=
gerrit.o-ran-sc.org/r/ric-plt/xapp-frame.git v0.8.3 h1:C5nhnmSZLdysSiQ7vMkpNaKrooPwiBZ79dcXWRVtZTU=
gerrit.o-ran-sc.org/r/ric-plt/xapp-frame.git v0.8.3/go.mod h1:MRTeTBLROgTA2t91SXYjTbRsxoOhMMvvkK/ChLVRZUU=
+gerrit.o-ran-sc.org/r/ric-plt/xapp-frame.git v0.8.5 h1:PEc4Lv6cn8hQM1Ak3wE3MwhCa4v7triRjdhXwsTUMUw=
+gerrit.o-ran-sc.org/r/ric-plt/xapp-frame.git v0.8.5/go.mod h1:Z9SajRPqZ7N1/y+Lzp5lUzq24fvrcjQg3cMBXRQVkiM=
github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE=
github.com/go-openapi/analysis v0.19.5/go.mod h1:hkEAkxagaIvIP7VTn8ygJNkd4kAYON2rCu0v0ObL0AU=
github.com/go-openapi/errors v0.17.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0=
github.com/go-openapi/errors v0.18.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0=
+github.com/go-openapi/errors v0.19.2 h1:a2kIyV3w+OS3S97zxUndRVD46+FhGOUBDFY7nmu4CsY=
github.com/go-openapi/errors v0.19.2/go.mod h1:qX0BLWsyaKfvhluLejVpVNwNRdXZhEbTA4kxxpKBC94=
github.com/go-openapi/errors v0.19.3 h1:7MGZI1ibQDLasvAz8HuhvYk9eNJbJkCOXWsSjjMS+Zc=
github.com/go-openapi/errors v0.19.3/go.mod h1:qX0BLWsyaKfvhluLejVpVNwNRdXZhEbTA4kxxpKBC94=
"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
rtmgrclient "gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/rtmgr_client"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
+ "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/restapi/operations/common"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
httptransport "github.com/go-openapi/runtime/client"
"github.com/go-openapi/strfmt"
CntRecvMsg uint64
ResetTestFlag bool
Counters map[string]xapp.Counter
- LoggerLevel uint32
+ LoggerLevel int
}
type RMRMeid struct {
type SubmgrRestartTestEvent struct{}
type SubmgrRestartUpEvent struct{}
+type PackSubscriptionRequestErrortEvent struct {
+ ErrorInfo ErrorInfo
+}
+
+func (p *PackSubscriptionRequestErrortEvent) SetEvent(errorInfo *ErrorInfo) {
+ p.ErrorInfo = *errorInfo
+}
+
+type SDLWriteErrortEvent struct {
+ ErrorInfo ErrorInfo
+}
+
+func (s *SDLWriteErrortEvent) SetEvent(errorInfo *ErrorInfo) {
+ s.ErrorInfo = *errorInfo
+}
func init() {
- xapp.Logger.Info("SUBMGR")
+ xapp.Logger.Debug("SUBMGR")
viper.AutomaticEnv()
viper.SetEnvPrefix("submgr")
viper.AllowEmptyEnv(true)
xapp.Resource.InjectRoute("/ric/v1/restsubscriptions", c.GetAllRestSubscriptions, "GET")
xapp.Resource.InjectRoute("/ric/v1/symptomdata", c.SymptomDataHandler, "GET")
- go xapp.Subscription.Listen(c.SubscriptionHandler, c.QueryHandler, c.SubscriptionDeleteHandlerCB)
+ go xapp.Subscription.Listen(c.RESTSubscriptionHandler, c.RESTQueryHandler, c.RESTSubscriptionDeleteHandler)
if readSubsFromDb == "false" {
return c
//
//-------------------------------------------------------------------
func (c *Control) GetAllRestSubscriptions(w http.ResponseWriter, r *http.Request) {
- xapp.Logger.Info("GetAllRestSubscriptions() called")
+ xapp.Logger.Debug("GetAllRestSubscriptions() called")
response := c.registry.GetAllRestSubscriptions()
w.Write(response)
}
var subIds []uint32
var register map[uint32]*Subscription
for i := 0; dbRetryForever == "true" || i < dbTryCount; i++ {
- xapp.Logger.Info("Reading E2 subscriptions from db")
+ xapp.Logger.Debug("Reading E2 subscriptions from db")
subIds, register, err = c.ReadAllSubscriptionsFromSdl()
if err != nil {
xapp.Logger.Error("%v", err)
return nil
}
}
- xapp.Logger.Info("Continuing without retring")
+ xapp.Logger.Debug("Continuing without retring")
return err
}
var err error
var restSubscriptions map[string]*RESTSubscription
for i := 0; dbRetryForever == "true" || i < dbTryCount; i++ {
- xapp.Logger.Info("Reading REST subscriptions from db")
+ xapp.Logger.Debug("Reading REST subscriptions from db")
restSubscriptions, err = c.ReadAllRESTSubscriptionsFromSdl()
if err != nil {
xapp.Logger.Error("%v", err)
return nil
}
}
- xapp.Logger.Info("Continuing without retring")
+ xapp.Logger.Debug("Continuing without retring")
return err
}
//-------------------------------------------------------------------
func (c *Control) ReadConfigParameters(f string) {
+ c.LoggerLevel = int(xapp.Logger.GetLevel())
+ xapp.Logger.Debug("LoggerLevel %v", c.LoggerLevel)
+
// viper.GetDuration returns nanoseconds
e2tSubReqTimeout = viper.GetDuration("controls.e2tSubReqTimeout_ms") * 1000000
if e2tSubReqTimeout == 0 {
e2tSubReqTimeout = 2000 * 1000000
}
- xapp.Logger.Info("e2tSubReqTimeout %v", e2tSubReqTimeout)
+ xapp.Logger.Debug("e2tSubReqTimeout %v", e2tSubReqTimeout)
+
e2tSubDelReqTime = viper.GetDuration("controls.e2tSubDelReqTime_ms") * 1000000
if e2tSubDelReqTime == 0 {
e2tSubDelReqTime = 2000 * 1000000
}
- xapp.Logger.Info("e2tSubDelReqTime %v", e2tSubDelReqTime)
+ xapp.Logger.Debug("e2tSubDelReqTime %v", e2tSubDelReqTime)
e2tRecvMsgTimeout = viper.GetDuration("controls.e2tRecvMsgTimeout_ms") * 1000000
if e2tRecvMsgTimeout == 0 {
e2tRecvMsgTimeout = 2000 * 1000000
}
- xapp.Logger.Info("e2tRecvMsgTimeout %v", e2tRecvMsgTimeout)
+ xapp.Logger.Debug("e2tRecvMsgTimeout %v", e2tRecvMsgTimeout)
e2tMaxSubReqTryCount = viper.GetUint64("controls.e2tMaxSubReqTryCount")
if e2tMaxSubReqTryCount == 0 {
e2tMaxSubReqTryCount = 1
}
- xapp.Logger.Info("e2tMaxSubReqTryCount %v", e2tMaxSubReqTryCount)
+ xapp.Logger.Debug("e2tMaxSubReqTryCount %v", e2tMaxSubReqTryCount)
e2tMaxSubDelReqTryCount = viper.GetUint64("controls.e2tMaxSubDelReqTryCount")
if e2tMaxSubDelReqTryCount == 0 {
e2tMaxSubDelReqTryCount = 1
}
- xapp.Logger.Info("e2tMaxSubDelReqTryCount %v", e2tMaxSubDelReqTryCount)
+ xapp.Logger.Debug("e2tMaxSubDelReqTryCount %v", e2tMaxSubDelReqTryCount)
readSubsFromDb = viper.GetString("controls.readSubsFromDb")
if readSubsFromDb == "" {
readSubsFromDb = "true"
}
- xapp.Logger.Info("readSubsFromDb %v", readSubsFromDb)
+ xapp.Logger.Debug("readSubsFromDb %v", readSubsFromDb)
dbTryCount = viper.GetInt("controls.dbTryCount")
if dbTryCount == 0 {
dbTryCount = 200
}
- xapp.Logger.Info("dbTryCount %v", dbTryCount)
+ xapp.Logger.Debug("dbTryCount %v", dbTryCount)
dbRetryForever = viper.GetString("controls.dbRetryForever")
if dbRetryForever == "" {
dbRetryForever = "true"
}
- xapp.Logger.Info("dbRetryForever %v", dbRetryForever)
-
- c.LoggerLevel = viper.GetUint32("logger.level")
- if c.LoggerLevel == 0 {
- c.LoggerLevel = 3
- }
- xapp.Logger.Info("LoggerLevel %v", c.LoggerLevel)
+ xapp.Logger.Debug("dbRetryForever %v", dbRetryForever)
// Internal cfg parameter, used to define a wait time for RMR route clean-up. None default
// value 100ms used currently only in unittests.
if waitRouteCleanup_ms == 0 {
waitRouteCleanup_ms = 5000 * 1000000
}
- xapp.Logger.Info("waitRouteCleanup %v", waitRouteCleanup_ms)
+ xapp.Logger.Debug("waitRouteCleanup %v", waitRouteCleanup_ms)
}
//-------------------------------------------------------------------
xapp.Logger.Debug("HandleUncompletedSubscriptions. len(register) = %v", len(register))
for subId, subs := range register {
if subs.SubRespRcvd == false {
- subs.NoRespToXapp = true
- xapp.Logger.Debug("SendSubscriptionDeleteReq. subId = %v", subId)
- c.SendSubscriptionDeleteReq(subs)
+ // If policy subscription has already been made successfully unsuccessful update should not be deleted.
+ if subs.PolicyUpdate == false {
+ subs.NoRespToXapp = true
+ xapp.Logger.Debug("SendSubscriptionDeleteReq. subId = %v", subId)
+ c.SendSubscriptionDeleteReq(subs)
+ }
}
}
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) GetOrCreateRestSubscription(p *models.SubscriptionParams, md5sum string, xAppRmrEndpoint string) (*RESTSubscription, string, error) {
+func (c *Control) GetOrCreateRestSubscription(p *models.SubscriptionParams, md5sum string, xAppRmrEndpoint string) (*RESTSubscription, string, string, error) {
var restSubId string
var restSubscription *RESTSubscription
prevRestSubsId, exists := restDuplicateCtrl.GetLastKnownRestSubsIdBasedOnMd5sum(md5sum)
if p.SubscriptionID == "" {
+ // Subscription does not contain REST subscription Id
if exists {
restSubscription, err = c.registry.GetRESTSubscription(prevRestSubsId, false)
if restSubscription != nil {
+ // Subscription not found
restSubId = prevRestSubsId
if err == nil {
- xapp.Logger.Info("Existing restSubId %s found by MD5sum %s for a request without subscription ID - using previous subscription", prevRestSubsId, md5sum)
+ xapp.Logger.Debug("Existing restSubId %s found by MD5sum %s for a request without subscription ID - using previous subscription", prevRestSubsId, md5sum)
} else {
- xapp.Logger.Info("Existing restSubId %s found by MD5sum %s for a request without subscription ID - Note: %s", prevRestSubsId, md5sum, err.Error())
+ xapp.Logger.Debug("Existing restSubId %s found by MD5sum %s for a request without subscription ID - Note: %s", prevRestSubsId, md5sum, err.Error())
}
} else {
- xapp.Logger.Info("None existing restSubId %s referred by MD5sum %s for a request without subscription ID - deleting cached entry", prevRestSubsId, md5sum)
+ xapp.Logger.Debug("None existing restSubId %s referred by MD5sum %s for a request without subscription ID - deleting cached entry", prevRestSubsId, md5sum)
restDuplicateCtrl.DeleteLastKnownRestSubsIdBasedOnMd5sum(md5sum)
}
}
if restSubscription == nil {
restSubId = ksuid.New().String()
- restSubscription, err = c.registry.CreateRESTSubscription(&restSubId, &xAppRmrEndpoint, p.Meid)
- if err != nil {
- xapp.Logger.Error("%s", err.Error())
- c.UpdateCounter(cRestSubFailToXapp)
- return nil, "", err
- }
+ restSubscription = c.registry.CreateRESTSubscription(&restSubId, &xAppRmrEndpoint, p.Meid)
}
} else {
+ // Subscription contains REST subscription Id
restSubId = p.SubscriptionID
- xapp.Logger.Info("RestSubscription ID %s provided via REST request", restSubId)
-
+ xapp.Logger.Debug("RestSubscription ID %s provided via REST request", restSubId)
restSubscription, err = c.registry.GetRESTSubscription(restSubId, false)
if err != nil {
+ // Subscription with id in REST request does not exist
xapp.Logger.Error("%s", err.Error())
c.UpdateCounter(cRestSubFailToXapp)
- return nil, "", err
+ return nil, "", models.SubscriptionInstanceRejectCauseRESTSubscriptionWithGivenIDDoesNotExist, err
}
if !exists {
- xapp.Logger.Info("Existing restSubscription found for ID %s, new request based on md5sum", restSubId)
+ xapp.Logger.Debug("Existing restSubscription found for ID %s, new request based on md5sum", restSubId)
} else {
- xapp.Logger.Info("Existing restSubscription found for ID %s(%s), re-transmission based on md5sum match with previous request", prevRestSubsId, restSubId)
+ xapp.Logger.Debug("Existing restSubscription found for ID %s(%s), re-transmission based on md5sum match with previous request", prevRestSubsId, restSubId)
}
}
- return restSubscription, restSubId, nil
+ return restSubscription, restSubId, "", nil
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) SubscriptionHandler(params interface{}) (*models.SubscriptionResponse, error) {
+func (c *Control) RESTSubscriptionHandler(params interface{}) (*models.SubscriptionResponse, int) {
c.CntRecvMsg++
c.UpdateCounter(cRestSubReqFromXapp)
}
if p.ClientEndpoint == nil {
- xapp.Logger.Error("ClientEndpoint == nil")
+ err := fmt.Errorf("ClientEndpoint == nil")
+ xapp.Logger.Error("%v", err)
c.UpdateCounter(cRestSubFailToXapp)
- return nil, fmt.Errorf("")
+ return c.GetSubscriptionResponse(models.SubscriptionInstanceRejectCauseInvalidRESTRequestMessage, err.Error(), "SUBMGR", ""), common.SubscribeBadRequestCode
}
_, xAppRmrEndpoint, err := ConstructEndpointAddresses(*p.ClientEndpoint)
if err != nil {
xapp.Logger.Error("%s", err.Error())
c.UpdateCounter(cRestSubFailToXapp)
- return nil, err
+ return c.GetSubscriptionResponse(models.SubscriptionInstanceRejectCauseInvalidRESTRequestMessage, err.Error(), "SUBMGR", ""), common.SubscribeBadRequestCode
}
md5sum, err := CalculateRequestMd5sum(params)
xapp.Logger.Error("Failed to generate md5sum from incoming request - %s", err.Error())
}
- restSubscription, restSubId, err := c.GetOrCreateRestSubscription(p, md5sum, xAppRmrEndpoint)
+ restSubscription, restSubId, rejectCause, err := c.GetOrCreateRestSubscription(p, md5sum, xAppRmrEndpoint)
if err != nil {
xapp.Logger.Error("Failed to get/allocate REST subscription")
- return nil, err
+ return c.GetSubscriptionResponse(rejectCause, err.Error(), "SUBMGR", ""), common.SubscribeBadRequestCode
}
subResp.SubscriptionID = &restSubId
restDuplicateCtrl.DeleteLastKnownRestSubsIdBasedOnMd5sum(md5sum)
c.registry.DeleteRESTSubscription(&restSubId)
c.UpdateCounter(cRestSubFailToXapp)
- return nil, err
+ return c.GetSubscriptionResponse(models.SubscriptionInstanceRejectCauseInvalidRESTRequestMessage, err.Error(), "SUBMGR", ""), common.SubscribeBadRequestCode
}
duplicate := restDuplicateCtrl.IsDuplicateToOngoingTransaction(restSubId, md5sum)
if duplicate {
- xapp.Logger.Info("Retransmission blocker direct ACK for request of restSubsId %s restSubId MD5sum %s as retransmission", restSubId, md5sum)
+ err := fmt.Errorf("Retransmission blocker direct ACK for request of restSubsId %s restSubId MD5sum %s as retransmission", restSubId, md5sum)
+ xapp.Logger.Debug("%s", err)
c.UpdateCounter(cRestSubRespToXapp)
- return &subResp, nil
+ return &subResp, common.SubscribeCreatedCode
}
c.WriteRESTSubscriptionToDb(restSubId, restSubscription)
-
- go c.processSubscriptionRequests(restSubscription, &subReqList, p.ClientEndpoint, p.Meid, &restSubId, xAppRmrEndpoint, md5sum)
+ e2SubscriptionDirectives, err := c.GetE2SubscriptionDirectives(p)
+ if err != nil {
+ xapp.Logger.Error("%s", err)
+ return c.GetSubscriptionResponse(models.SubscriptionInstanceRejectCauseInvalidRESTRequestMessage, err.Error(), "SUBMGR", ""), common.SubscribeBadRequestCode
+ }
+ go c.processSubscriptionRequests(restSubscription, &subReqList, p.ClientEndpoint, p.Meid, &restSubId, xAppRmrEndpoint, md5sum, e2SubscriptionDirectives)
c.UpdateCounter(cRestSubRespToXapp)
- return &subResp, nil
+ return &subResp, common.SubscribeCreatedCode
+}
+
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) GetE2SubscriptionDirectives(p *models.SubscriptionParams) (*E2SubscriptionDirectives, error) {
+
+ e2SubscriptionDirectives := &E2SubscriptionDirectives{}
+ if p == nil || p.E2SubscriptionDirectives == nil {
+ e2SubscriptionDirectives.E2TimeoutTimerValue = e2tSubReqTimeout
+ e2SubscriptionDirectives.E2MaxTryCount = int64(e2tMaxSubReqTryCount)
+ e2SubscriptionDirectives.CreateRMRRoute = true
+ xapp.Logger.Debug("p == nil || p.E2SubscriptionDirectives == nil. Using default values for E2TimeoutTimerValue = %v and E2RetryCount = %v RMRRoutingNeeded = true", e2tSubReqTimeout, e2tMaxSubReqTryCount)
+ } else {
+ if p.E2SubscriptionDirectives.E2TimeoutTimerValue >= 1 && p.E2SubscriptionDirectives.E2TimeoutTimerValue <= 10 {
+ e2SubscriptionDirectives.E2TimeoutTimerValue = time.Duration(p.E2SubscriptionDirectives.E2TimeoutTimerValue) * 1000000000 // Duration type cast returns nano seconds
+ } else {
+ return nil, fmt.Errorf("p.E2SubscriptionDirectives.E2TimeoutTimerValue out of range (1-10 seconds): %v", p.E2SubscriptionDirectives.E2TimeoutTimerValue)
+ }
+ if p.E2SubscriptionDirectives.E2RetryCount == nil {
+ xapp.Logger.Error("p.E2SubscriptionDirectives.E2RetryCount == nil. Using default value")
+ e2SubscriptionDirectives.E2MaxTryCount = int64(e2tMaxSubReqTryCount)
+ } else {
+ if *p.E2SubscriptionDirectives.E2RetryCount >= 0 && *p.E2SubscriptionDirectives.E2RetryCount <= 10 {
+ e2SubscriptionDirectives.E2MaxTryCount = *p.E2SubscriptionDirectives.E2RetryCount + 1 // E2MaxTryCount = First sending plus two retries
+ } else {
+ return nil, fmt.Errorf("p.E2SubscriptionDirectives.E2RetryCount out of range (0-10): %v", *p.E2SubscriptionDirectives.E2RetryCount)
+ }
+ }
+ if p.E2SubscriptionDirectives.RMRRoutingNeeded == nil {
+ xapp.Logger.Error("p.E2SubscriptionDirectives.RMRRoutingNeeded == nil")
+ e2SubscriptionDirectives.CreateRMRRoute = true
+ } else {
+ e2SubscriptionDirectives.CreateRMRRoute = *p.E2SubscriptionDirectives.RMRRoutingNeeded
+ }
+ }
+ xapp.Logger.Debug("e2SubscriptionDirectives.E2TimeoutTimerValue: %v", e2SubscriptionDirectives.E2TimeoutTimerValue)
+ xapp.Logger.Debug("e2SubscriptionDirectives.E2MaxTryCount: %v", e2SubscriptionDirectives.E2MaxTryCount)
+ xapp.Logger.Debug("e2SubscriptionDirectives.CreateRMRRoute: %v", e2SubscriptionDirectives.CreateRMRRoute)
+ return e2SubscriptionDirectives, nil
+}
+
+//-------------------------------------------------------------------
+//
+//-------------------------------------------------------------------
+func (c *Control) GetSubscriptionResponse(rejectCause string, errorCause string, errorSource string, timeoutType string) *models.SubscriptionResponse {
+ subResp := models.SubscriptionResponse{}
+ subscriptionInstance := models.SubscriptionInstance{}
+ subscriptionInstance.RejectCause = &rejectCause
+ subscriptionInstance.ErrorCause = &errorCause
+ subscriptionInstance.ErrorSource = &errorSource
+ if timeoutType != "" {
+ subscriptionInstance.TimeoutType = &timeoutType
+ }
+ subResp.SubscriptionInstances = append(subResp.SubscriptionInstances, &subscriptionInstance)
+ xapp.Logger.Error("etSubscriptionResponse() %+v", subscriptionInstance)
+
+ return &subResp
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
func (c *Control) processSubscriptionRequests(restSubscription *RESTSubscription, subReqList *e2ap.SubscriptionRequestList,
- clientEndpoint *models.SubscriptionParamsClientEndpoint, meid *string, restSubId *string, xAppRmrEndpoint string, md5sum string) {
+ clientEndpoint *models.SubscriptionParamsClientEndpoint, meid *string, restSubId *string, xAppRmrEndpoint string, md5sum string, e2SubscriptionDirectives *E2SubscriptionDirectives) {
- xapp.Logger.Info("Subscription Request count=%v ", len(subReqList.E2APSubscriptionRequests))
+ xapp.Logger.Debug("Subscription Request count=%v ", len(subReqList.E2APSubscriptionRequests))
var xAppEventInstanceID int64
var e2EventInstanceID int64
+ errorInfo := &ErrorInfo{}
defer restDuplicateCtrl.SetMd5sumFromLastOkRequest(*restSubId, md5sum)
if trans == nil {
// Send notification to xApp that prosessing of a Subscription Request has failed.
err := fmt.Errorf("Tracking failure")
- c.sendUnsuccesfullResponseNotification(restSubId, restSubscription, xAppEventInstanceID, err, clientEndpoint, trans)
+ errorInfo.ErrorCause = err.Error()
+ c.sendUnsuccesfullResponseNotification(restSubId, restSubscription, xAppEventInstanceID, err, clientEndpoint, trans, errorInfo)
continue
}
- xapp.Logger.Info("Handle SubscriptionRequest index=%v, %s", index, idstring(nil, trans))
+ xapp.Logger.Debug("Handle SubscriptionRequest index=%v, %s", index, idstring(nil, trans))
- subRespMsg, err := c.handleSubscriptionRequest(trans, &subReqMsg, meid, *restSubId)
+ subRespMsg, errorInfo, err := c.handleSubscriptionRequest(trans, &subReqMsg, meid, *restSubId, e2SubscriptionDirectives)
- xapp.Logger.Info("Handled SubscriptionRequest index=%v, %s", index, idstring(nil, trans))
+ xapp.Logger.Debug("Handled SubscriptionRequest index=%v, %s", index, idstring(nil, trans))
if err != nil {
- c.sendUnsuccesfullResponseNotification(restSubId, restSubscription, xAppEventInstanceID, err, clientEndpoint, trans)
+ c.sendUnsuccesfullResponseNotification(restSubId, restSubscription, xAppEventInstanceID, err, clientEndpoint, trans, errorInfo)
} else {
e2EventInstanceID = (int64)(subRespMsg.RequestId.InstanceId)
restSubscription.AddMd5Sum(md5sum)
- xapp.Logger.Info("SubscriptionRequest index=%v processed successfullyfor %s. endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
+ xapp.Logger.Debug("SubscriptionRequest index=%v processed successfullyfor %s. endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
index, *restSubId, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
c.sendSuccesfullResponseNotification(restSubId, restSubscription, xAppEventInstanceID, e2EventInstanceID, clientEndpoint, trans)
}
//
//------------------------------------------------------------------
func (c *Control) handleSubscriptionRequest(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest, meid *string,
- restSubId string) (*e2ap.E2APSubscriptionResponse, error) {
+ restSubId string, e2SubscriptionDirectives *E2SubscriptionDirectives) (*e2ap.E2APSubscriptionResponse, *ErrorInfo, error) {
+
+ errorInfo := ErrorInfo{}
err := c.tracker.Track(trans)
if err != nil {
xapp.Logger.Error("XAPP-SubReq Tracking error: %s", idstring(err, trans))
+ errorInfo.ErrorCause = err.Error()
err = fmt.Errorf("Tracking failure")
- return nil, err
+ return nil, &errorInfo, err
}
- subs, err := c.registry.AssignToSubscription(trans, subReqMsg, c.ResetTestFlag, c)
+ subs, errorInfo, err := c.registry.AssignToSubscription(trans, subReqMsg, c.ResetTestFlag, c, e2SubscriptionDirectives.CreateRMRRoute)
if err != nil {
xapp.Logger.Error("XAPP-SubReq Assign error: %s", idstring(err, trans))
- return nil, err
+ return nil, &errorInfo, err
}
//
// Wake subs request
//
- go c.handleSubscriptionCreate(subs, trans)
+ go c.handleSubscriptionCreate(subs, trans, e2SubscriptionDirectives)
event, _ := trans.WaitEvent(0) //blocked wait as timeout is handled in subs side
err = nil
switch themsg := event.(type) {
case *e2ap.E2APSubscriptionResponse:
trans.Release()
- return themsg, nil
+ return themsg, &errorInfo, nil
case *e2ap.E2APSubscriptionFailure:
err = fmt.Errorf("E2 SubscriptionFailure received")
- return nil, err
+ errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
+ return nil, &errorInfo, err
+ case *PackSubscriptionRequestErrortEvent:
+ err = fmt.Errorf("E2 SubscriptionRequest pack failure")
+ return nil, &themsg.ErrorInfo, err
+ case *SDLWriteErrortEvent:
+ err = fmt.Errorf("SDL write failure")
+ return nil, &themsg.ErrorInfo, err
default:
- err = fmt.Errorf("unexpected E2 subscription response received")
+ err = fmt.Errorf("Unexpected E2 subscription response received")
+ errorInfo.SetInfo(err.Error(), models.SubscriptionInstanceErrorSourceE2Node, "")
break
}
} else {
err = fmt.Errorf("E2 subscription response timeout")
+ errorInfo.SetInfo(err.Error(), "", models.SubscriptionInstanceTimeoutTypeE2Timeout)
+ if subs.PolicyUpdate == true {
+ return nil, &errorInfo, err
+ }
}
xapp.Logger.Error("XAPP-SubReq E2 subscription failed %s", idstring(err, trans, subs))
c.registry.RemoveFromSubscription(subs, trans, waitRouteCleanup_ms, c)
- return nil, err
+ return nil, &errorInfo, err
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
func (c *Control) sendUnsuccesfullResponseNotification(restSubId *string, restSubscription *RESTSubscription, xAppEventInstanceID int64, err error,
- clientEndpoint *models.SubscriptionParamsClientEndpoint, trans *TransactionXapp) {
+ clientEndpoint *models.SubscriptionParamsClientEndpoint, trans *TransactionXapp, errorInfo *ErrorInfo) {
// Send notification to xApp that prosessing of a Subscription Request has failed.
e2EventInstanceID := (int64)(0)
- errorCause := err.Error()
+ if errorInfo.ErrorSource == "" {
+ // Submgr is default source of error
+ errorInfo.ErrorSource = models.SubscriptionInstanceErrorSourceSUBMGR
+ }
resp := &models.SubscriptionResponse{
SubscriptionID: restSubId,
SubscriptionInstances: []*models.SubscriptionInstance{
&models.SubscriptionInstance{E2EventInstanceID: &e2EventInstanceID,
- ErrorCause: &errorCause,
+ ErrorCause: &errorInfo.ErrorCause,
+ ErrorSource: &errorInfo.ErrorSource,
+ TimeoutType: &errorInfo.TimeoutType,
XappEventInstanceID: &xAppEventInstanceID},
},
}
restSubscription.SetProcessed(err)
c.UpdateRESTSubscriptionInDB(*restSubId, restSubscription, false)
if trans != nil {
- xapp.Logger.Info("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
- errorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
+ xapp.Logger.Debug("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
+ errorInfo.ErrorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
} else {
- xapp.Logger.Info("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v",
- errorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID)
+ xapp.Logger.Debug("Sending unsuccessful REST notification (cause %s) to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v",
+ errorInfo.ErrorCause, clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID)
}
c.UpdateCounter(cRestSubFailNotifToXapp)
// Mark REST subscription request processesd.
restSubscription.SetProcessed(nil)
c.UpdateRESTSubscriptionInDB(*restSubId, restSubscription, false)
- xapp.Logger.Info("Sending successful REST notification to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
+ xapp.Logger.Debug("Sending successful REST notification to endpoint=%v:%v, XappEventInstanceID=%v, E2EventInstanceID=%v, %s",
clientEndpoint.Host, *clientEndpoint.HTTPPort, xAppEventInstanceID, e2EventInstanceID, idstring(nil, trans))
c.UpdateCounter(cRestSubNotifToXapp)
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) SubscriptionDeleteHandlerCB(restSubId string) error {
+func (c *Control) RESTSubscriptionDeleteHandler(restSubId string) int {
c.CntRecvMsg++
c.UpdateCounter(cRestSubDelReqFromXapp)
- xapp.Logger.Info("SubscriptionDeleteRequest from XAPP")
+ xapp.Logger.Debug("SubscriptionDeleteRequest from XAPP")
restSubscription, err := c.registry.GetRESTSubscription(restSubId, true)
if err != nil {
xapp.Logger.Error("%s", err.Error())
if restSubscription == nil {
// Subscription was not found
- return nil
+ return common.UnsubscribeNoContentCode
} else {
if restSubscription.SubReqOngoing == true {
err := fmt.Errorf("Handling of the REST Subscription Request still ongoing %s", restSubId)
xapp.Logger.Error("%s", err.Error())
- return err
+ return common.UnsubscribeBadRequestCode
} else if restSubscription.SubDelReqOngoing == true {
// Previous request for same restSubId still ongoing
- return nil
+ return common.UnsubscribeBadRequestCode
}
}
}
xAppRmrEndPoint := restSubscription.xAppRmrEndPoint
go func() {
- xapp.Logger.Info("Deleteting handler: processing instances = %v", restSubscription.InstanceIds)
+ xapp.Logger.Debug("Deleteting handler: processing instances = %v", restSubscription.InstanceIds)
for _, instanceId := range restSubscription.InstanceIds {
xAppEventInstanceID, err := c.SubscriptionDeleteHandler(&restSubId, &xAppRmrEndPoint, &restSubscription.Meid, instanceId)
if err != nil {
xapp.Logger.Error("%s", err.Error())
- //return err
}
- xapp.Logger.Info("Deleteting instanceId = %v", instanceId)
+ xapp.Logger.Debug("Deleteting instanceId = %v", instanceId)
restSubscription.DeleteXappIdToE2Id(xAppEventInstanceID)
restSubscription.DeleteE2InstanceId(instanceId)
}
c.UpdateCounter(cRestSubDelRespToXapp)
- return nil
+ return common.UnsubscribeNoContentCode
}
//-------------------------------------------------------------------
var xAppEventInstanceID int64
subs, err := c.registry.GetSubscriptionFirstMatch([]uint32{instanceId})
if err != nil {
- xapp.Logger.Info("Subscription Delete Handler subscription for restSubId=%v, E2EventInstanceID=%v not found %s",
+ xapp.Logger.Debug("Subscription Delete Handler subscription for restSubId=%v, E2EventInstanceID=%v not found %s",
restSubId, instanceId, idstring(err, nil))
return xAppEventInstanceID, nil
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) QueryHandler() (models.SubscriptionList, error) {
- xapp.Logger.Info("QueryHandler() called")
+func (c *Control) RESTQueryHandler() (models.SubscriptionList, error) {
+ xapp.Logger.Debug("RESTQueryHandler() called")
c.CntRecvMsg++
}
func (c *Control) TestRestHandler(w http.ResponseWriter, r *http.Request) {
- xapp.Logger.Info("TestRestHandler() called")
+ xapp.Logger.Debug("RESTTestRestHandler() called")
pathParams := mux.Vars(r)
s := pathParams["testId"]
if contains := strings.Contains(s, "deletesubid="); contains == true {
var splits = strings.Split(s, "=")
if subId, err := strconv.ParseInt(splits[1], 10, 64); err == nil {
- xapp.Logger.Info("RemoveSubscriptionFromSdl() called. subId = %v", subId)
+ xapp.Logger.Debug("RemoveSubscriptionFromSdl() called. subId = %v", subId)
c.RemoveSubscriptionFromSdl(uint32(subId))
return
}
// This can be used to remove all subscriptions db from
if s == "emptydb" {
- xapp.Logger.Info("RemoveAllSubscriptionsFromSdl() called")
+ xapp.Logger.Debug("RemoveAllSubscriptionsFromSdl() called")
c.RemoveAllSubscriptionsFromSdl()
c.RemoveAllRESTSubscriptionsFromSdl()
return
// This is meant to cause submgr's restart in testing
if s == "restart" {
- xapp.Logger.Info("os.Exit(1) called")
+ xapp.Logger.Debug("os.Exit(1) called")
os.Exit(1)
}
- xapp.Logger.Info("Unsupported rest command received %s", s)
+ xapp.Logger.Debug("Unsupported rest command received %s", s)
}
//-------------------------------------------------------------------
params.PayloadLen = len(trans.Payload.Buf)
params.Payload = trans.Payload.Buf
params.Mbuf = nil
- xapp.Logger.Info("MSG to E2T: %s %s %s", desc, trans.String(), params.String())
+ xapp.Logger.Debug("MSG to E2T: %s %s %s", desc, trans.String(), params.String())
err = c.SendWithRetry(params, false, 5)
if err != nil {
xapp.Logger.Error("rmrSendToE2T: Send failed: %+v", err)
params.PayloadLen = len(trans.Payload.Buf)
params.Payload = trans.Payload.Buf
params.Mbuf = nil
- xapp.Logger.Info("MSG to XAPP: %s %s %s", desc, trans.String(), params.String())
+ xapp.Logger.Debug("MSG to XAPP: %s %s %s", desc, trans.String(), params.String())
err = c.SendWithRetry(params, false, 5)
if err != nil {
xapp.Logger.Error("rmrSendToXapp: Send failed: %+v", err)
case xapp.RIC_SUB_DEL_FAILURE:
go c.handleE2TSubscriptionDeleteFailure(msg)
default:
- xapp.Logger.Info("Unknown Message Type '%d', discarding", msg.Mtype)
+ xapp.Logger.Debug("Unknown Message Type '%d', discarding", msg.Mtype)
}
return
}
// handle from XAPP Subscription Request
//------------------------------------------------------------------
func (c *Control) handleXAPPSubscriptionRequest(params *xapp.RMRParams) {
- xapp.Logger.Info("MSG from XAPP: %s", params.String())
+ xapp.Logger.Debug("MSG from XAPP: %s", params.String())
c.UpdateCounter(cSubReqFromXapp)
subReqMsg, err := c.e2ap.UnpackSubscriptionRequest(params.Payload)
}
//TODO handle subscription toward e2term inside AssignToSubscription / hide handleSubscriptionCreate in it?
- subs, err := c.registry.AssignToSubscription(trans, subReqMsg, c.ResetTestFlag, c)
+ subs, _, err := c.registry.AssignToSubscription(trans, subReqMsg, c.ResetTestFlag, c, true)
if err != nil {
xapp.Logger.Error("XAPP-SubReq: %s", idstring(err, trans))
return
//------------------------------------------------------------------
func (c *Control) wakeSubscriptionRequest(subs *Subscription, trans *TransactionXapp) {
- go c.handleSubscriptionCreate(subs, trans)
+ e2SubscriptionDirectives, _ := c.GetE2SubscriptionDirectives(nil)
+ go c.handleSubscriptionCreate(subs, trans, e2SubscriptionDirectives)
event, _ := trans.WaitEvent(0) //blocked wait as timeout is handled in subs side
var err error
if event != nil {
break
}
}
- xapp.Logger.Info("XAPP-SubReq: failed %s", idstring(err, trans, subs))
+ xapp.Logger.Debug("XAPP-SubReq: failed %s", idstring(err, trans, subs))
//c.registry.RemoveFromSubscription(subs, trans, 5*time.Second)
}
// handle from XAPP Subscription Delete Request
//------------------------------------------------------------------
func (c *Control) handleXAPPSubscriptionDeleteRequest(params *xapp.RMRParams) {
- xapp.Logger.Info("MSG from XAPP: %s", params.String())
+ xapp.Logger.Debug("MSG from XAPP: %s", params.String())
c.UpdateCounter(cSubDelReqFromXapp)
subDelReqMsg, err := c.e2ap.UnpackSubscriptionDeleteRequest(params.Payload)
if subs.NoRespToXapp == true {
// Do no send delete responses to xapps due to submgr restart is deleting uncompleted subscriptions
+ xapp.Logger.Debug("XAPP-SubDelReq: subs.NoRespToXapp == true")
return
}
//-------------------------------------------------------------------
// SUBS CREATE Handling
//-------------------------------------------------------------------
-func (c *Control) handleSubscriptionCreate(subs *Subscription, parentTrans *TransactionXapp) {
+func (c *Control) handleSubscriptionCreate(subs *Subscription, parentTrans *TransactionXapp, e2SubscriptionDirectives *E2SubscriptionDirectives) {
+ var event interface{} = nil
var removeSubscriptionFromDb bool = false
trans := c.tracker.NewSubsTransaction(subs)
subs.WaitTransactionTurn(trans)
subRfMsg, valid := subs.GetCachedResponse()
if subRfMsg == nil && valid == true {
- event := c.sendE2TSubscriptionRequest(subs, trans, parentTrans)
+ event = c.sendE2TSubscriptionRequest(subs, trans, parentTrans, e2SubscriptionDirectives)
switch event.(type) {
case *e2ap.E2APSubscriptionResponse:
subRfMsg, valid = subs.SetCachedResponse(event, true)
case *e2ap.E2APSubscriptionFailure:
removeSubscriptionFromDb = true
subRfMsg, valid = subs.SetCachedResponse(event, false)
- xapp.Logger.Info("SUBS-SubReq: internal delete due failure event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
+ xapp.Logger.Debug("SUBS-SubReq: internal delete due failure event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
case *SubmgrRestartTestEvent:
// This simulates that no response has been received and after restart subscriptions are restored from db
xapp.Logger.Debug("Test restart flag is active. Dropping this transaction to test restart case")
- return
+ case *PackSubscriptionRequestErrortEvent, *SDLWriteErrortEvent:
+ subRfMsg, valid = subs.SetCachedResponse(event, false)
default:
- xapp.Logger.Info("SUBS-SubReq: internal delete due default event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
- removeSubscriptionFromDb = true
- subRfMsg, valid = subs.SetCachedResponse(nil, false)
- c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
+ if subs.PolicyUpdate == false {
+ xapp.Logger.Debug("SUBS-SubReq: internal delete due default event(%s) %s", typeofSubsMessage(event), idstring(nil, trans, subs, parentTrans))
+ removeSubscriptionFromDb = true
+ subRfMsg, valid = subs.SetCachedResponse(nil, false)
+ c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
+ }
}
xapp.Logger.Debug("SUBS-SubReq: Handling (e2t response %s) %s", typeofSubsMessage(subRfMsg), idstring(nil, trans, subs, parentTrans))
} else {
xapp.Logger.Debug("SUBS-SubReq: Handling (cached response %s) %s", typeofSubsMessage(subRfMsg), idstring(nil, trans, subs, parentTrans))
}
+ err := c.UpdateSubscriptionInDB(subs, removeSubscriptionFromDb)
+ if err != nil {
+ subRfMsg, valid = subs.SetCachedResponse(event, false)
+ c.sendE2TSubscriptionDeleteRequest(subs, trans, parentTrans)
+ }
+
//Now RemoveFromSubscription in here to avoid race conditions (mostly concerns delete)
if valid == false {
c.registry.RemoveFromSubscription(subs, parentTrans, waitRouteCleanup_ms, c)
}
- c.UpdateSubscriptionInDB(subs, removeSubscriptionFromDb)
parentTrans.SendEvent(subRfMsg, 0)
}
//-------------------------------------------------------------------
// send to E2T Subscription Request
//-------------------------------------------------------------------
-func (c *Control) sendE2TSubscriptionRequest(subs *Subscription, trans *TransactionSubs, parentTrans *TransactionXapp) interface{} {
+func (c *Control) sendE2TSubscriptionRequest(subs *Subscription, trans *TransactionSubs, parentTrans *TransactionXapp, e2SubscriptionDirectives *E2SubscriptionDirectives) interface{} {
var err error
var event interface{} = nil
var timedOut bool = false
trans.Mtype, trans.Payload, err = c.e2ap.PackSubscriptionRequest(subReqMsg)
if err != nil {
xapp.Logger.Error("SUBS-SubReq: %s", idstring(err, trans, subs, parentTrans))
- return event
+ return &PackSubscriptionRequestErrortEvent{
+ ErrorInfo{
+ ErrorSource: models.SubscriptionInstanceErrorSourceASN1,
+ ErrorCause: err.Error(),
+ },
+ }
}
// Write uncompleted subscrition in db. If no response for subscrition it need to be re-processed (deleted) after restart
- c.WriteSubscriptionToDb(subs)
+ err = c.WriteSubscriptionToDb(subs)
+ if err != nil {
+ return &SDLWriteErrortEvent{
+ ErrorInfo{
+ ErrorSource: models.SubscriptionInstanceErrorSourceDBAAS,
+ ErrorCause: err.Error(),
+ },
+ }
+ }
- for retries := uint64(0); retries < e2tMaxSubReqTryCount; retries++ {
+ for retries := int64(0); retries < e2SubscriptionDirectives.E2MaxTryCount; retries++ {
desc := fmt.Sprintf("(retry %d)", retries)
if retries == 0 {
c.UpdateCounter(cSubReqToE2)
}
c.rmrSendToE2T(desc, subs, trans)
if subs.DoNotWaitSubResp == false {
- event, timedOut = trans.WaitEvent(e2tSubReqTimeout)
+ event, timedOut = trans.WaitEvent(e2SubscriptionDirectives.E2TimeoutTimerValue)
if timedOut {
c.UpdateCounter(cSubReqTimerExpiry)
continue
} else {
// Simulating case where subscrition request has been sent but response has not been received before restart
event = &SubmgrRestartTestEvent{}
+ xapp.Logger.Debug("Restart event, DoNotWaitSubResp == true")
}
break
}
// handle from E2T Subscription Response
//-------------------------------------------------------------------
func (c *Control) handleE2TSubscriptionResponse(params *xapp.RMRParams) {
- xapp.Logger.Info("MSG from E2T: %s", params.String())
+ xapp.Logger.Debug("MSG from E2T: %s", params.String())
c.UpdateCounter(cSubRespFromE2)
subRespMsg, err := c.e2ap.UnpackSubscriptionResponse(params.Payload)
// handle from E2T Subscription Failure
//-------------------------------------------------------------------
func (c *Control) handleE2TSubscriptionFailure(params *xapp.RMRParams) {
- xapp.Logger.Info("MSG from E2T: %s", params.String())
+ xapp.Logger.Debug("MSG from E2T: %s", params.String())
c.UpdateCounter(cSubFailFromE2)
subFailMsg, err := c.e2ap.UnpackSubscriptionFailure(params.Payload)
if err != nil {
// handle from E2T Subscription Delete Response
//-------------------------------------------------------------------
func (c *Control) handleE2TSubscriptionDeleteResponse(params *xapp.RMRParams) (err error) {
- xapp.Logger.Info("MSG from E2T: %s", params.String())
+ xapp.Logger.Debug("MSG from E2T: %s", params.String())
c.UpdateCounter(cSubDelRespFromE2)
subDelRespMsg, err := c.e2ap.UnpackSubscriptionDeleteResponse(params.Payload)
if err != nil {
// handle from E2T Subscription Delete Failure
//-------------------------------------------------------------------
func (c *Control) handleE2TSubscriptionDeleteFailure(params *xapp.RMRParams) {
- xapp.Logger.Info("MSG from E2T: %s", params.String())
+ xapp.Logger.Debug("MSG from E2T: %s", params.String())
c.UpdateCounter(cSubDelFailFromE2)
subDelFailMsg, err := c.e2ap.UnpackSubscriptionDeleteFailure(params.Payload)
if err != nil {
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) WriteSubscriptionToDb(subs *Subscription) {
+func (c *Control) WriteSubscriptionToDb(subs *Subscription) error {
xapp.Logger.Debug("WriteSubscriptionToDb() subId = %v", subs.ReqId.InstanceId)
err := c.WriteSubscriptionToSdl(subs.ReqId.InstanceId, subs)
if err != nil {
xapp.Logger.Error("%v", err)
+ return err
}
+ return nil
}
//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
-func (c *Control) UpdateSubscriptionInDB(subs *Subscription, removeSubscriptionFromDb bool) {
+func (c *Control) UpdateSubscriptionInDB(subs *Subscription, removeSubscriptionFromDb bool) error {
if removeSubscriptionFromDb == true {
// Subscription was written in db already when subscription request was sent to BTS, except for merged request
} else {
// Update is needed for successful response and merge case here
if subs.RetryFromXapp == false {
- c.WriteSubscriptionToDb(subs)
+ err := c.WriteSubscriptionToDb(subs)
+ return err
}
}
subs.RetryFromXapp = false
+ return nil
}
//-------------------------------------------------------------------
xapp.Logger.Debug("Sending subscription delete due to restart. subId = %v", subs.ReqId.InstanceId)
// Send delete for every endpoint in the subscription
- subDelReqMsg := &e2ap.E2APSubscriptionDeleteRequest{}
- subDelReqMsg.RequestId = subs.GetReqId().RequestId
- subDelReqMsg.RequestId.Id = ricRequestorId
- subDelReqMsg.FunctionId = subs.SubReqMsg.FunctionId
- mType, payload, err := c.e2ap.PackSubscriptionDeleteRequest(subDelReqMsg)
- if err != nil {
- xapp.Logger.Error("SendSubscriptionDeleteReq() %s", idstring(err))
- return
- }
- for _, endPoint := range subs.EpList.Endpoints {
- params := &xapp.RMRParams{}
- params.Mtype = mType
- params.SubId = int(subs.GetReqId().InstanceId)
- params.Xid = ""
- params.Meid = subs.Meid
- params.Src = endPoint.String()
- params.PayloadLen = len(payload.Buf)
- params.Payload = payload.Buf
- params.Mbuf = nil
- subs.DeleteFromDb = true
- c.handleXAPPSubscriptionDeleteRequest(params)
+ if subs.PolicyUpdate == false {
+ subDelReqMsg := &e2ap.E2APSubscriptionDeleteRequest{}
+ subDelReqMsg.RequestId = subs.GetReqId().RequestId
+ subDelReqMsg.RequestId.Id = ricRequestorId
+ subDelReqMsg.FunctionId = subs.SubReqMsg.FunctionId
+ mType, payload, err := c.e2ap.PackSubscriptionDeleteRequest(subDelReqMsg)
+ if err != nil {
+ xapp.Logger.Error("SendSubscriptionDeleteReq() %s", idstring(err))
+ return
+ }
+ for _, endPoint := range subs.EpList.Endpoints {
+ params := &xapp.RMRParams{}
+ params.Mtype = mType
+ params.SubId = int(subs.GetReqId().InstanceId)
+ params.Xid = ""
+ params.Meid = subs.Meid
+ params.Src = endPoint.String()
+ params.PayloadLen = len(payload.Buf)
+ params.Payload = payload.Buf
+ params.Mbuf = nil
+ subs.DeleteFromDb = true
+ c.handleXAPPSubscriptionDeleteRequest(params)
+ }
}
}
fmt.Println(" Meid = nil")
}
+ if p.E2SubscriptionDirectives == nil {
+ fmt.Println(" E2SubscriptionDirectives = nil")
+ } else {
+ fmt.Println(" E2SubscriptionDirectives")
+ if p.E2SubscriptionDirectives.E2RetryCount == nil {
+ fmt.Println(" E2RetryCount == nil")
+ } else {
+ fmt.Printf(" E2RetryCount = %v\n", *p.E2SubscriptionDirectives.E2RetryCount)
+ }
+ fmt.Printf(" E2TimeoutTimerValue = %v\n", p.E2SubscriptionDirectives.E2TimeoutTimerValue)
+ if p.E2SubscriptionDirectives.RMRRoutingNeeded == nil {
+ fmt.Println(" RMRRoutingNeeded == nil")
+ } else {
+ fmt.Printf(" RMRRoutingNeeded = %v\n", *p.E2SubscriptionDirectives.RMRRoutingNeeded)
+ }
+ }
for _, subscriptionDetail := range p.SubscriptionDetails {
if p.RANFunctionID != nil {
fmt.Printf(" RANFunctionID = %v\n", *p.RANFunctionID)
if !exists {
if md5sum == "" {
- xapp.Logger.Info("Attempted to delete a cached md5sum, md5sum not set yet")
+ xapp.Logger.Debug("Attempted to delete a cached md5sum, md5sum not set yet")
} else {
xapp.Logger.Error("Attempted to delete a cached md5sum %s, but the value was not found", md5sum)
}
entry, present := d.ongoingRequestMap[md5sum]
if present {
- xapp.Logger.Info("Collision detected. REST subs ID %s has ongoing transaction with md5sum : %s started at %s\n", entry.restSubsId, md5sum, entry.startTime.Format(time.ANSIC))
+ xapp.Logger.Debug("Collision detected. REST subs ID %s has ongoing transaction with md5sum : %s started at %s\n", entry.restSubsId, md5sum, entry.startTime.Format(time.ANSIC))
d.collCount++
return true
}
//
//-----------------------------------------------------------------------------
func (c *E2ap) FillSubscriptionReqMsgs(params interface{}, subreqList *e2ap.SubscriptionRequestList, restSubscription *RESTSubscription) error {
- xapp.Logger.Info("FillSubscriptionReqMsgs")
+ xapp.Logger.Debug("FillSubscriptionReqMsgs")
p := params.(*models.SubscriptionParams)
import (
"encoding/json"
"fmt"
+ "strings"
"sync"
"time"
return restSubscriptionsJson
}
-func (r *Registry) CreateRESTSubscription(restSubId *string, xAppRmrEndPoint *string, maid *string) (*RESTSubscription, error) {
+func (r *Registry) CreateRESTSubscription(restSubId *string, xAppRmrEndPoint *string, maid *string) *RESTSubscription {
r.mutex.Lock()
defer r.mutex.Unlock()
newRestSubscription := RESTSubscription{}
newRestSubscription.SubDelReqOngoing = false
r.restSubscriptions[*restSubId] = &newRestSubscription
newRestSubscription.xAppIdToE2Id = make(map[int64]int64)
- xapp.Logger.Info("Registry: Created REST subscription successfully. restSubId=%v, subscriptionCount=%v, e2apSubscriptionCount=%v", *restSubId, len(r.restSubscriptions), len(r.register))
- return &newRestSubscription, nil
+ xapp.Logger.Debug("Registry: Created REST subscription successfully. restSubId=%v, subscriptionCount=%v, e2apSubscriptionCount=%v", *restSubId, len(r.restSubscriptions), len(r.register))
+ return &newRestSubscription
}
func (r *Registry) DeleteRESTSubscription(restSubId *string) {
r.mutex.Lock()
defer r.mutex.Unlock()
delete(r.restSubscriptions, *restSubId)
- xapp.Logger.Info("Registry: Deleted REST subscription successfully. restSubId=%v, subscriptionCount=%v", *restSubId, len(r.restSubscriptions))
+ xapp.Logger.Debug("Registry: Deleted REST subscription successfully. restSubId=%v, subscriptionCount=%v", *restSubId, len(r.restSubscriptions))
}
func (r *Registry) GetRESTSubscription(restSubId string, IsDelReqOngoing bool) (*RESTSubscription, error) {
} else {
return restSubscription, fmt.Errorf("Registry: REST request is still ongoing for the endpoint=%v, restSubId=%v, SubDelReqOngoing=%v, SubReqOngoing=%v", restSubscription, restSubId, restSubscription.SubDelReqOngoing, restSubscription.SubReqOngoing)
}
- return restSubscription, nil
}
return nil, fmt.Errorf("Registry: No valid subscription found with restSubId=%v", restSubId)
}
return resp, nil
}
-func (r *Registry) allocateSubs(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest, resetTestFlag bool) (*Subscription, error) {
+func (r *Registry) allocateSubs(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest, resetTestFlag bool, rmrRoutecreated bool) (*Subscription, error) {
if len(r.subIds) > 0 {
subId := r.subIds[0]
r.subIds = r.subIds[1:]
subs := &Subscription{
registry: r,
Meid: trans.Meid,
+ RMRRouteCreated: rmrRoutecreated,
SubReqMsg: subReqMsg,
valid: true,
+ PolicyUpdate: false,
RetryFromXapp: false,
SubRespRcvd: false,
DeleteFromDb: false,
}
subs.ReqId.Id = subReqMsg.RequestId.Id
subs.ReqId.InstanceId = subId
- if resetTestFlag == true {
- subs.DoNotWaitSubResp = true
- }
+ r.SetResetTestFlag(resetTestFlag, subs)
if subs.EpList.AddEndpoint(trans.GetEndpoint()) == false {
r.subIds = append(r.subIds, subs.ReqId.InstanceId)
return nil, false
}
-func (r *Registry) AssignToSubscription(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest, resetTestFlag bool, c *Control) (*Subscription, error) {
+func (r *Registry) AssignToSubscription(trans *TransactionXapp, subReqMsg *e2ap.E2APSubscriptionRequest, resetTestFlag bool, c *Control, createRMRRoute bool) (*Subscription, ErrorInfo, error) {
var err error
var newAlloc bool
+ errorInfo := ErrorInfo{}
r.mutex.Lock()
defer r.mutex.Unlock()
//
actionType, err := r.CheckActionTypes(subReqMsg)
if err != nil {
- xapp.Logger.Info("CREATE %s", err)
+ xapp.Logger.Debug("CREATE %s", err)
err = fmt.Errorf("E2 content validation failed")
- return nil, err
+ return nil, errorInfo, err
}
//
xapp.Logger.Debug("CREATE %s. Existing subscription for Policy found.", subs.String())
// Update message data to subscription
subs.SubReqMsg = subReqMsg
+ subs.PolicyUpdate = true
subs.SetCachedResponse(nil, true)
- return subs, nil
+ r.SetResetTestFlag(resetTestFlag, subs)
+ return subs, errorInfo, nil
}
}
subs, endPointFound := r.findExistingSubs(trans, subReqMsg)
if subs == nil {
- if subs, err = r.allocateSubs(trans, subReqMsg, resetTestFlag); err != nil {
+ if subs, err = r.allocateSubs(trans, subReqMsg, resetTestFlag, createRMRRoute); err != nil {
xapp.Logger.Error("%s", err.Error())
err = fmt.Errorf("subscription not allocated")
- return nil, err
+ return nil, errorInfo, err
}
newAlloc = true
} else if endPointFound == true {
subs.RetryFromXapp = true
xapp.Logger.Debug("CREATE subReqMsg.InstanceId=%v. Same subscription %s already exists.", subReqMsg.InstanceId, subs.String())
c.UpdateCounter(cDuplicateE2SubReq)
- return subs, nil
+ return subs, errorInfo, nil
}
//
defer subs.mutex.Unlock()
epamount := subs.EpList.Size()
- xapp.Logger.Info("AssignToSubscription subs.EpList.Size()=%v", subs.EpList.Size())
+ xapp.Logger.Debug("AssignToSubscription subs.EpList.Size()=%v", subs.EpList.Size())
r.mutex.Unlock()
//
// Subscription route updates
//
- if epamount == 1 {
- err = r.RouteCreate(subs, c)
+ if createRMRRoute == true {
+ if epamount == 1 {
+ errorInfo, err = r.RouteCreate(subs, c)
+ } else {
+ errorInfo, err = r.RouteCreateUpdate(subs, c)
+ }
} else {
- err = r.RouteCreateUpdate(subs, c)
+ xapp.Logger.Debug("RMR route not created: createRMRRoute=%v", createRMRRoute)
}
r.mutex.Lock()
}
// Delete already added endpoint for the request
subs.EpList.DelEndpoint(trans.GetEndpoint())
- return nil, err
+ return nil, errorInfo, err
}
if newAlloc {
}
xapp.Logger.Debug("CREATE %s", subs.String())
xapp.Logger.Debug("Registry: substable=%v", r.register)
- return subs, nil
+ return subs, errorInfo, nil
}
-func (r *Registry) RouteCreate(subs *Subscription, c *Control) error {
+func (r *Registry) RouteCreate(subs *Subscription, c *Control) (ErrorInfo, error) {
+ errorInfo := ErrorInfo{}
subRouteAction := SubRouteInfo{subs.EpList, uint16(subs.ReqId.InstanceId)}
err := r.rtmgrClient.SubscriptionRequestCreate(subRouteAction)
if err != nil {
+ if strings.Contains(err.Error(), "status 400") {
+ errorInfo.TimeoutType = models.SubscriptionInstanceTimeoutTypeRTMGRTimeout
+ } else {
+ errorInfo.ErrorSource = models.SubscriptionInstanceErrorSourceRTMGR
+ }
+ errorInfo.ErrorCause = err.Error()
c.UpdateCounter(cRouteCreateFail)
xapp.Logger.Error("%s", err.Error())
err = fmt.Errorf("RTMGR route create failure")
}
- return err
+ return errorInfo, err
}
-func (r *Registry) RouteCreateUpdate(subs *Subscription, c *Control) error {
+func (r *Registry) RouteCreateUpdate(subs *Subscription, c *Control) (ErrorInfo, error) {
+ errorInfo := ErrorInfo{}
subRouteAction := SubRouteInfo{subs.EpList, uint16(subs.ReqId.InstanceId)}
err := r.rtmgrClient.SubscriptionRequestUpdate(subRouteAction)
if err != nil {
+ if strings.Contains(err.Error(), "status 400") {
+ errorInfo.TimeoutType = models.SubscriptionInstanceTimeoutTypeRTMGRTimeout
+ } else {
+ errorInfo.ErrorSource = models.SubscriptionInstanceErrorSourceRTMGR
+ }
+ errorInfo.ErrorCause = err.Error()
c.UpdateCounter(cRouteCreateUpdateFail)
xapp.Logger.Error("%s", err.Error())
err = fmt.Errorf("RTMGR route update failure")
- return err
+ return errorInfo, err
}
c.UpdateCounter(cMergedSubscriptions)
- return err
+ return errorInfo, err
}
func (r *Registry) CheckActionTypes(subReqMsg *e2ap.E2APSubscriptionRequest) (uint64, error) {
subs.mutex.Lock()
defer subs.mutex.Unlock()
- xapp.Logger.Info("CLEAN %s", subs.String())
+ xapp.Logger.Debug("CLEAN %s", subs.String())
if epamount == 0 {
//
// Subscription route delete
//
- r.RouteDelete(subs, trans, c)
+ if subs.RMRRouteCreated == true {
+ r.RouteDelete(subs, trans, c)
+ }
//
// Subscription release
//
// Subscription route update
//
- r.RouteDeleteUpdate(subs, c)
+ if subs.RMRRouteCreated == true {
+ r.RouteDeleteUpdate(subs, c)
+ }
}
}()
}
return nil, fmt.Errorf("No valid subscription found with subIds %v", subIds)
}
+
+func (r *Registry) SetResetTestFlag(resetTestFlag bool, subs *Subscription) {
+ if resetTestFlag == true {
+ // This is used in submgr restart unit tests
+ xapp.Logger.Debug("resetTestFlag == true")
+ subs.DoNotWaitSubResp = true
+ } else {
+ xapp.Logger.Debug("resetTestFlag == false")
+ }
+}
xAppRMREndPoint = host + ":" + strconv.FormatInt(*clientEndpoint.RMRPort, 10)
}
- xapp.Logger.Info("xAppHttpEndPoint=%v, xAppRrmEndPoint=%v", xAppHTTPEndPoint, xAppRMREndPoint)
+ xapp.Logger.Debug("xAppHttpEndPoint=%v, xAppRrmEndPoint=%v", xAppHTTPEndPoint, xAppRMREndPoint)
return xAppHTTPEndPoint, xAppRMREndPoint, nil
}
)
type SubscriptionInfo struct {
- Valid bool
- ReqId RequestId
- Meid xapp.RMRMeid
- EpList xapp.RmrEndpointList
- SubReqMsg e2ap.E2APSubscriptionRequest
- SubRespMsg e2ap.E2APSubscriptionResponse
- SubRespRcvd string
+ Valid bool
+ ReqId RequestId
+ Meid xapp.RMRMeid
+ EpList xapp.RmrEndpointList
+ SubReqMsg e2ap.E2APSubscriptionRequest
+ SubRespMsg e2ap.E2APSubscriptionResponse
+ SubRespRcvd string
+ PolicyUpdate bool
}
func CreateSdl() Sdlnterface {
subscriptionInfo.Meid = *subs.Meid
subscriptionInfo.EpList = subs.EpList
subscriptionInfo.SubReqMsg = *subs.SubReqMsg
+ subscriptionInfo.PolicyUpdate = subs.PolicyUpdate
if typeofSubsMessage(subs.SubRFMsg) == "SubResp" {
subscriptionInfo.SubRespRcvd = "SubResp"
subReq := e2ap.E2APSubscriptionRequest{}
subReq = subscriptionInfo.SubReqMsg
subs.SubReqMsg = &subReq
+ subs.PolicyUpdate = subscriptionInfo.PolicyUpdate
if subscriptionInfo.SubRespRcvd == "SubResp" {
subs.SubRespRcvd = true
"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
- //"reflect"
"sync"
)
valid bool // valid
registry *Registry // Registry
ReqId RequestId // ReqId (Requestor Id + Seq Nro a.k.a subsid)
- Meid *xapp.RMRMeid // Meid/ RanName
+ Meid *xapp.RMRMeid // Meid/RanName
EpList xapp.RmrEndpointList // Endpoints
+ RMRRouteCreated bool // Does subscription have RMR route
TransLock sync.Mutex // Lock transactions, only one executed per time for subs
TheTrans TransactionIf // Ongoing transaction
SubReqMsg *e2ap.E2APSubscriptionRequest // Subscription information
SubRFMsg interface{} // Subscription information
+ PolicyUpdate bool // This is true when policy subscrition is being updated. Used not to send delete for update after timeout or restart
RetryFromXapp bool // Retry form xApp for subscription that already exist
SubRespRcvd bool // Subscription response received
- DeleteFromDb bool // Delete subscription form db
+ DeleteFromDb bool // Delete subscription from db
NoRespToXapp bool // Send no response for subscription delete to xApp after restart
DoNotWaitSubResp bool // Test flag. Response is not waited for Subscription Request
}
return false
}
}
- //reflect.DeepEqual(acts.ActionDefinitionChoice, actt.ActionDefinitionChoice)
-
if acts.SubsequentAction.Present != actt.SubsequentAction.Present ||
acts.SubsequentAction.Type != actt.SubsequentAction.Type ||
acts.SubsequentAction.TimetoWait != actt.SubsequentAction.TimetoWait {
}
}
}
-
return true
}
package control
import (
+ "time"
+
"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap"
)
Remove(keys []string) error
RemoveAll() error
}
+
+type E2SubscriptionDirectives struct {
+ // How many times E2 subscription request is retried
+ // Required: true
+ // Maximum: 10
+ // Minimum: 0
+ E2MaxTryCount int64
+
+ // How long time response is waited from E2 node
+ // Maximum: 10s
+ // Minimum: 1s
+ E2TimeoutTimerValue time.Duration
+
+ // Subscription needs RMR route from E2Term to xApp
+ CreateRMRRoute bool
+}
+
+type ErrorInfo struct {
+ ErrorCause string
+ ErrorSource string
+ TimeoutType string
+}
+
+func (e *ErrorInfo) SetInfo(errorCause string, errorSource string, timeoutType string) {
+ e.ErrorCause = errorCause
+ e.ErrorSource = errorSource
+ e.TimeoutType = timeoutType
+}
mainCtrl = &testingSubmgrControl{}
mainCtrl.RmrControl.Init("SUBMGRCTL", srcId, rtgSvc)
mainCtrl.c = NewControl()
+ mainCtrl.c.LoggerLevel = int(xapp.Logger.GetLevel())
+ xapp.Logger.Debug("Test: LoggerLevel %v", mainCtrl.c.LoggerLevel)
xapp.Logger.Debug("Replacing real db with test db")
mainCtrl.c.e2SubsDb = CreateMock() // This overrides real E2 Subscription database for testing
mainCtrl.c.restSubsDb = CreateRestSubsDbMock() // This overrides real REST Subscription database for testing
if err != nil {
mc.TestError(t, "%v", err)
} else {
- mainCtrl.c.registry.register = nil
mainCtrl.c.registry.subIds = subIds
mainCtrl.c.registry.register = register
-
- mc.TestLog(t, "register:")
- for subId, subs := range register {
- mc.TestLog(t, " subId=%v", subId)
- mc.TestLog(t, " subs.SubRespRcvd=%v", subs.SubRespRcvd)
- mc.TestLog(t, " subs=%v\n", subs)
- }
-
mc.TestLog(t, "mainCtrl.c.registry.register:")
for subId, subs := range mainCtrl.c.registry.register {
mc.TestLog(t, " subId=%v", subId)
mc.TestLog(t, " subs=%v\n", subs)
}
}
+ restSubscriptions, err := mainCtrl.c.ReadAllRESTSubscriptionsFromSdl()
+ if err != nil {
+ mc.TestError(t, "%v", err)
+ } else {
+ mainCtrl.c.registry.restSubscriptions = restSubscriptions
+ mc.TestLog(t, "mainCtrl.c.registry.restSubscriptions:")
+ for restSubId, restSubs := range mainCtrl.c.registry.restSubscriptions {
+ mc.TestLog(t, " restSubId=%v", restSubId)
+ mc.TestLog(t, " restSubs=%v\n", restSubs)
+ }
+ }
+
go mainCtrl.c.HandleUncompletedSubscriptions(mainCtrl.c.registry.register)
}
}
time.Sleep(100 * time.Millisecond)
}
- mc.TestError(t, "(submgr) no registry empty within %d secs: %d", secs, cnt)
+ mc.TestError(t, "(submgr) no registry empty within %d secs: %d, register: %v", secs, cnt, mc.c.registry.register)
return false
}
}
func (mc *testingSubmgrControl) VerifyCounterValues(t *testing.T) {
+
+ // Check that expected counters are added ok
currentCountersMap := mc.GetCurrentCounterValues(t, toBeAddedCountersMap)
for _, toBeAddedCounter := range toBeAddedCountersMap {
if currentCounter, ok := currentCountersMap[toBeAddedCounter.Name]; ok == true {
}
}
+ // Check that not any unexpected counter are added
+ for _, currentCounter := range currentCountersMap {
+ if _, ok := toBeAddedCountersMap[currentCounter.Name]; ok == false {
+ if beforeCounter, ok := countersBeforeMap[currentCounter.Name]; ok == true {
+ if currentCounter.Value != beforeCounter.Value {
+ mc.TestError(t, "Error: unexpected counter value added: counterName %v, current value %v, expected value %v",
+ currentCounter.Name, beforeCounter.Value, beforeCounter.Value)
+
+ //fmt.Printf("beforeCounter.Value=%v, toBeAddedCounter.Value=%v, \n",beforeCounter.Value, toBeAddedCounter.Value)
+ }
+ } else {
+ mc.TestError(t, "Counter %v not in countersBeforeMap", beforeCounter.Name)
+ }
+ }
+ }
+
// Make map empty
//fmt.Printf("toBeAddedCountersMap=%v\n",toBeAddedCountersMap)
toBeAddedCountersMap = make(map[string]Counter)
mainCtrl.SimulateRestart(t)
xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ // Submgr send delete for uncompleted subscription
delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
})
const subReqCount int = 1
+
// Add delay for rtmgt HTTP handling so that HTTP response is received before notify on XAPP side
waiter := rtmgrHttp.AllocNextSleep(50, false)
newSubsId := mainCtrl.get_registry_next_subid(t)
waiter.WaitResult(t)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
// Del
xappConn1.SendRESTSubsDelReq(t, &restSubId)
params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
params.SetMeid("RAN_NAME_1")
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for second subscriber : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for second subscriber : %v", restSubId2)
xappConn2.ExpectRESTNotificationNok(t, restSubId2, "allFail")
waiter.WaitResult(t)
// e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2) - TOD: missing delete
// Subs Create
const subReqCount int = 1
+ // const e2Timeout int64 = 2
+ // const e2RetryCount int64 = 2
+ // const routingNeeded bool = true
// In order to force both XAPP's to create their own subscriptions, force rtmgr to block a while so that 2nd create
// gets into execution before the rtmgrg responds for the first one.
waiter := rtmgrHttp.AllocNextSleep(10, true)
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
+ // params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
restSubId1 := xappConn1.SendRESTSubsReq(t, params)
xappConn2.SendRESTSubsReq(t, params)
e2termConn1.SendSubsResp(t, crereq, cremsg)
e2SubsIdA := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+ xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
// Del1
xappConn1.SendRESTSubsDelReq(t, &restSubId1)
//Req1
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
restSubId1 := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
//Req2
params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
crereq2, cremsg2 := e2termConn1.RecvSubsReq(t)
e2termConn1.SendSubsResp(t, crereq2, cremsg2)
e2SubsIdA := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+ xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
e2SubsIdB := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
+ xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
//Del1
deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send 1st REST subscriber request for subscriberId : %v", restSubId1)
params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
params.SetMeid("RAN_NAME_2")
restSubId2, e2SubsId2 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send 2nd REST subscriber request for subscriberId : %v", restSubId2)
//Del1
deleteSubscription(t, xappConn1, e2termConn1, &restSubId1)
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
// Catch the first message and ignore it
crereq, cremsg := e2termConn1.RecvSubsReq(t)
- xapp.Logger.Info("Ignore REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore REST subscriber request for subscriber : %v", restSubId)
// The second request is being handled normally
crereq, cremsg = e2termConn1.RecvSubsReq(t)
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsReq(t)
- xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsReq(t)
- xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsReq(t)
- xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsReq(t)
- xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsDelReq(t)
- xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
e2termConn1.RecvSubsDelReq(t)
- xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsReq(t)
- xapp.Logger.Info("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 1st REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsReq(t)
- xapp.Logger.Info("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 2nd REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsDelReq(t)
- xapp.Logger.Info("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 1st INTERNAL delete request for subscriber : %v", restSubId)
xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
e2termConn1.RecvSubsDelReq(t)
- xapp.Logger.Info("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Ignore 2nd INTERNAL delete request for subscriber : %v", restSubId)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
// REST subscription sill there to be deleted
xappConn1.SendRESTSubsDelReq(t, &restSubId)
waiter := rtmgrHttp.AllocNextSleep(10, true)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
waiter.WaitResult(t)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
- xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
e2SubsIdA := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+ xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
e2SubsIdB := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
+ xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
// Del1
xappConn1.SendRESTSubsDelReq(t, &restSubId1)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
e2SubsIdA := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Info("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
+ xapp.Logger.Debug("TEST: 1.st XAPP notification received e2SubsId=%v", e2SubsIdA)
e2SubsIdB := <-xappConn1.ListedRESTNotifications
- xapp.Logger.Info("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
+ xapp.Logger.Debug("TEST: 2.nd XAPP notification received e2SubsId=%v", e2SubsIdB)
// Del1
xappConn1.SendRESTSubsDelReq(t, &restSubId1)
Counter{cRestSubDelRespToXapp, 1},
})
- const subReqCount int = 1
-
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
+ xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
xappConn1.ExpectRESTNotification(t, restSubId)
e2termConn1.SendSubsResp(t, crereq1, cremsg1)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
xappConn1.SendRESTSubsDelReq(t, &restSubId)
delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
})
const subReqCount int = 1
+ const e2Timeout int64 = 1
+ const e2RetryCount int64 = 0
+ const routingNeeded bool = true
// Req
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
// Policy change
- // GetRESTSubsReqPolicyParams sets some coutners on tc side.
+ // GetRESTSubsReqPolicyParams sets some counters on tc side.
params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
params.SetSubscriptionID(&restSubId)
params.SetTimeToWait("w200ms")
restSubId, e2SubsId = createSubscription(t, xappConn1, e2termConn1, params)
// | RESTSubReq | |
// |---------------->| |
// | | |
-// | RESTSubUpdateFail |
+// | RESTSubUpdateFail(400 Bad request)
// | | |
// | RESTSubDelReq | |
// |---------------->| |
Counter{cRestSubDelRespToXapp, 1},
})
- const subReqCount int = 1
-
// Req
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
// Policy change
-
params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
- restSubIdUpd := strings.ToUpper(restSubId)
+ restSubIdUpd := strings.ToUpper(restSubId) // This makes RESTSubReq to fail
params.SetSubscriptionID(&restSubIdUpd)
params.SetTimeToWait("w200ms")
xappConn1.ExpectRESTNotification(t, restSubId1)
e2termConn1.SendSubsResp(t, crereq1, cremsg1)
e2SubsId1 := xappConn1.WaitRESTNotification(t, restSubId1)
- xapp.Logger.Info("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId1=%v", e2SubsId1)
// Resp2
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn2.SendSubsResp(t, crereq2, cremsg2)
e2SubsId2 := xappConn2.WaitRESTNotification(t, restSubId2)
- xapp.Logger.Info("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId2=%v", e2SubsId2)
// Delete1
xappConn1.SendRESTSubsDelReq(t, &restSubId1)
func TestRESTSubReqAsn1EncodeFail(t *testing.T) {
CaseBegin("TestRESTSubReqAsn1EncodeFail")
- xapp.Logger.Info("Xapp-frame, v0.8.1 sufficient REST API validation")
+ xapp.Logger.Debug("Xapp-frame, v0.8.1 sufficient REST API validation")
}
//Req
mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
e2termConn1.RecvSubsReq(t)
// Create subscription
restSubId, e2SubsId := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriber : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriber : %v", restSubId)
// Check subscription
queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
- // When SDL support for the REST Interface is added
- // the submgr restart statement below should be removed
- // from the comment.
-
- // mainCtrl.SimulateRestart(t)
- // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ mainCtrl.SimulateRestart(t)
+ xapp.Logger.Debug("mainCtrl.SimulateRestart done")
// Check subscription
queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
// Create subscription 1
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriber 1 : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriber 1 : %v", restSubId1)
// Create subscription 2 with same action
params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
xappConn2.ExpectAnyNotification(t)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
e2SubsId2 := xappConn2.WaitAnyRESTNotification(t)
- xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId2)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId2)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560", "localhost:13660"})
- // When SDL support for the REST Interface is added
- // the submgr restart statement below should be removed
- // from the comment.
-
- // mainCtrl.SimulateRestart(t)
- // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ mainCtrl.SimulateRestart(t)
+ xapp.Logger.Debug("mainCtrl.SimulateRestart done")
// Delete subscription 1, and wait until it has removed the first endpoint
subepcnt := mainCtrl.get_subs_entrypoint_cnt(t, e2SubsId1)
xappConn1.SendRESTSubsDelReq(t, &restSubId1)
mainCtrl.wait_subs_entrypoint_cnt_change(t, e2SubsId1, subepcnt, 10)
- // When SDL support for the REST Interface is added
- // the submgr restart statement below should be removed
- // from the comment.
-
- // mainCtrl.SimulateRestart(t)
- // xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+ mainCtrl.SimulateRestart(t)
+ xapp.Logger.Debug("mainCtrl.SimulateRestart done")
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13660"})
// Delete subscription 2
func TestRESTReportSubReqAndSubDelOk(t *testing.T) {
CaseBegin("TestRESTReportSubReqAndSubDelOk")
- subReqCount := 1
+ const subReqCount int = 1
testIndex := 1
RESTReportSubReqAndSubDelOk(t, subReqCount, testIndex)
}
func RESTReportSubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
- xapp.Logger.Info("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
+ xapp.Logger.Debug("TEST: TestRESTReportSubReqAndSubDelOk with testIndex %v", testIndex)
// Req
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsResp(t, crereq, cremsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
e2SubsId = append(e2SubsId, instanceId)
resp, _ := xapp.Subscription.QuerySubscriptions()
assert.Equal(t, resp[i].SubscriptionID, (int64)(instanceId))
}
*/
func RESTPolicySubReqAndSubDelOk(t *testing.T, subReqCount int, testIndex int) {
- xapp.Logger.Info("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
+ xapp.Logger.Debug("TEST: TestRESTPolicySubReqAndSubDelOk with testIndex %v", testIndex)
// Req
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
- //params := xappConn1.GetRESTSubsReqPolicyParams1(subReqCount)
- //restSubId := xappConn1.SendRESTPolicySubsReq(t, params)
var e2SubsId []uint32
for i := 0; i < subReqCount; i++ {
xappConn1.ExpectRESTNotification(t, restSubId)
e2termConn1.SendSubsResp(t, crereq, cremsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
e2SubsId = append(e2SubsId, instanceId)
}
func TestRESTTwoPolicySubReqAndSubDelOk(t *testing.T) {
- subReqCount := 2
-
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 1},
Counter{cRestSubRespToXapp, 1},
Counter{cRestSubDelRespToXapp, 1},
})
+ const subReqCount int = 2
+
// Req
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
}
func TestRESTPolicySubReqAndSubDelOkFullAmount(t *testing.T) {
- subReqCount := 19
-
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 1},
Counter{cRestSubRespToXapp, 1},
Counter{cRestSubDelRespToXapp, 1},
})
+ const subReqCount int = 19
// Req
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
mainCtrl.VerifyCounterValues(t)
}
+
func TestRESTTwoReportSubReqAndSubDelOk(t *testing.T) {
subReqCount := 2
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
params.SetSubEventTriggerDefinition(eventTriggerDefinition)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
params.AppendActionToActionToBeSetupList(actionId, actionType, actionDefinition, subsequestActionType, timeToWait)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
params.SetSubActionIDs(int64(2))
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
Counter{cRestSubDelRespToXapp, 2},
})
+ const e2Timeout int64 = 2
+ const e2RetryCount int64 = 2
+ const routingNeeded bool = true
+
// Req1
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
// Req2
params = xappConn2.GetRESTSubsReqReportParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
params.SetMeid("RAN_NAME_1")
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
Counter{cRestSubDelRespToXapp, 2},
})
+ const e2Timeout int64 = 2
+ const e2RetryCount int64 = 2
+ const routingNeeded bool = true
+
// Req1
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
// Req2
params = xappConn2.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
params.SetMeid("RAN_NAME_1")
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
params.SetSubActionDefinition(actionDefinition)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
params.SetSubActionDefinition(actionDefinition)
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
//Subs Create
restSubId1, e2SubsId1 := createSubscription(t, xappConn1, e2termConn1, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId1)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId1)
queryXappSubscription(t, int64(e2SubsId1), "RAN_NAME_1", []string{"localhost:13560"})
params.SetMeid("RAN_NAME_1")
params.SetTimeToWait("w200ms")
restSubId2 := xappConn2.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId2)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId2)
crereq, cremsg := e2termConn1.RecvSubsReq(t)
xappConn2.ExpectRESTNotification(t, restSubId2)
e2termConn1.SendSubsResp(t, crereq, cremsg)
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionResponseDecodeFail(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
- subReqCount := 1
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseDecodeFail")
+ const subReqCount int = 1
// Req
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionResponseUnknownInstanceId(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
- subReqCount := 1
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseUnknownInstanceId")
+ const subReqCount int = 1
// Req
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, orgInstanceId, 10)
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionResponseNoTransaction(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
- subReqCount := 1
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionResponseNoTransaction")
+ const subReqCount int = 1
// Req
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionFailureDecodeFail(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
- subReqCount := 1
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureDecodeFail")
+ const subReqCount int = 1
// Req
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionFailureUnknownInstanceId(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
- subReqCount := 1
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureUnknownInstanceId")
+ const subReqCount int = 1
// Req
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionFailureNoTransaction(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
- subReqCount := 1
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionFailureNoTransaction")
+ const subReqCount int = 1
// Req
params := xappConn1.GetRESTSubsReqReportParams(subReqCount)
e2termConn1.SendSubsDelResp(t, delreq, delmsg)
instanceId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", instanceId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", instanceId)
// Wait that subs is cleaned
mainCtrl.wait_subs_clean(t, crereq.RequestId.InstanceId, 10)
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionDeleteResponseDecodeFail(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseDecodeFail")
// Req
var params *teststube2ap.RESTSubsReqParams = nil
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseUnknownInstanceId")
// Req
var params *teststube2ap.RESTSubsReqParams = nil
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionDeleteResponseNoTransaction(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteResponseNoTransaction")
// Req
var params *teststube2ap.RESTSubsReqParams = nil
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionDeleteFailureDecodeFail(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureDecodeFail")
// Req
var params *teststube2ap.RESTSubsReqParams = nil
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteailureUnknownInstanceId")
// Req
var params *teststube2ap.RESTSubsReqParams = nil
//
//-----------------------------------------------------------------------------
func TestRESTUnpackSubscriptionDeleteFailureNoTransaction(t *testing.T) {
- xapp.Logger.Info("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
+ xapp.Logger.Debug("TEST: TestRESTUnpackSubscriptionDeleteFailureNoTransaction")
// Req
var params *teststube2ap.RESTSubsReqParams = nil
mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
Counter{cRestSubReqFromXapp, 1},
Counter{cRestSubRespToXapp, 1},
- Counter{cSubDelReqToE2, 1},
- Counter{cSubDelFailFromE2, 1},
Counter{cRestSubFailNotifToXapp, 1},
})
- subReqCount := 1
+ const subReqCount int = 1
var params *teststube2ap.RESTSubsReqParams = nil
params = xappConn1.GetRESTSubsReqReportParams(subReqCount)
// Req
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
// E2t: Receive SubsDelReq
- delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
xappConn1.ExpectRESTNotificationNok(t, restSubId, "allFail")
- // Subscription does not exist in in E2 Node.
- e2termConn1.SendSubsDelFail(t, delreq, delmsg)
-
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
e2ap_wrapper.AllowE2apToProcess(e2ap_wrapper.SUB_REQ, true)
// Wait that subs is cleaned
mainCtrl.VerifyCounterValues(t)
}
+func TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction(t *testing.T) {
+ CaseBegin("TestRESTSubReqPolicyUpdateTimeoutAndSubDelOkSameAction")
+
+ mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+ Counter{cRestSubReqFromXapp, 2},
+ Counter{cRestSubRespToXapp, 2},
+ Counter{cSubReqToE2, 2},
+ Counter{cSubRespFromE2, 1},
+ Counter{cRestSubNotifToXapp, 1},
+ Counter{cRestSubFailNotifToXapp, 1},
+ Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cSubDelReqToE2, 1},
+ Counter{cSubDelRespFromE2, 1},
+ Counter{cRestSubDelRespToXapp, 1},
+ })
+
+ const e2Timeout int64 = 1
+ const e2RetryCount int64 = 0
+ const routingNeeded bool = false
+
+ // Req1
+ params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+
+ // Subs Create
+ restSubId := xappConn1.SendRESTSubsReq(t, params)
+ xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+ crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
+ xappConn1.ExpectRESTNotification(t, restSubId)
+ e2termConn1.SendSubsResp(t, crereq1, cremsg1)
+ e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
+
+ // Policy change
+ params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+ params.SetSubscriptionID(&restSubId)
+ params.SetTimeToWait("w200ms")
+ restSubId = xappConn1.SendRESTSubsReq(t, params)
+ xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+ crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
+ xappConn1.ExpectRESTNotification(t, restSubId)
+ // SubsResp is missing
+ e2SubsId = xappConn1.WaitRESTNotification(t, restSubId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
+
+ // Del
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+ delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+ e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+ waitSubsCleanup(t, e2SubsId, 10)
+
+ mainCtrl.VerifyCounterValues(t)
+}
+
+//-----------------------------------------------------------------------------
+// TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle
+//
+// stub stub
+// +-------+ +---------+ +---------+
+// | xapp | | submgr | | e2term |
+// +-------+ +---------+ +---------+
+// | | |
+// | RESTSubReq | |
+// |---------------->| |
+// | | |
+// | RESTSubResp | |
+// |<----------------| |
+// | | SubReq |
+// | |------------->|
+// | | |
+// | | SubResp |
+// | |<-------------|
+// | | |
+// | RESTNotif | |
+// |<----------------| |
+// | | |
+// | RESTSubReq | |
+// |---------------->| |
+// | | |
+// | RESTSubResp | |
+// |<----------------| |
+// | | SubReq |
+// | |------------->|
+// | |
+// | Submgr restart |
+// | | |
+// | RESTSubDelReq | |
+// |---------------->| |
+// | | |
+// | | SubDelReq |
+// | |------------->|
+// | | |
+// | | SubDelResp |
+// | |<-------------|
+// | | |
+// | RESTSubDelResp | |
+// |<----------------| |
+//
+//-----------------------------------------------------------------------------
+
+func TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle(t *testing.T) {
+ CaseBegin("TestPolicyUpdateRESTSubReqAndSubDelOkWithRestartInMiddle")
+
+ mainCtrl.CounterValuesToBeVeriefied(t, CountersToBeAdded{
+ Counter{cRestSubReqFromXapp, 2},
+ Counter{cRestSubRespToXapp, 2},
+ Counter{cSubReqToE2, 2},
+ Counter{cSubRespFromE2, 1},
+ Counter{cRestSubNotifToXapp, 1},
+ Counter{cRestSubNotifToXapp, 1},
+ Counter{cRestSubDelReqFromXapp, 1},
+ Counter{cSubDelReqToE2, 1},
+ Counter{cRestSubDelRespToXapp, 1},
+ })
+
+ // Remove possible existing subscription
+ mainCtrl.removeExistingSubscriptions(t)
+
+ const e2Timeout int64 = 1
+ const e2RetryCount int64 = 0
+ const routingNeeded bool = false
+
+ // Req1
+ params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+ // Create subscription
+ restSubId := xappConn1.SendRESTSubsReq(t, params)
+ xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+ crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
+ xappConn1.ExpectRESTNotification(t, restSubId)
+ e2termConn1.SendSubsResp(t, crereq1, cremsg1)
+ e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
+
+ // Check subscription
+ queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+ // Policy change
+ params = xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
+ params.SetSubscriptionDirectives(e2Timeout, e2RetryCount, routingNeeded)
+ params.SetSubscriptionID(&restSubId)
+ params.SetTimeToWait("w200ms")
+ mainCtrl.SetResetTestFlag(t, true) // subs.DoNotWaitSubResp will be set TRUE for the subscription
+ restSubId = xappConn1.SendRESTSubsReq(t, params)
+ xapp.Logger.Debug("Send REST subscribe request for subscriberId : %v", restSubId)
+
+ crereq1, cremsg1 = e2termConn1.RecvSubsReq(t)
+ mainCtrl.SetResetTestFlag(t, false)
+
+ // SubsResp is missing due to submgr restart
+
+ mainCtrl.SimulateRestart(t)
+ xapp.Logger.Debug("mainCtrl.SimulateRestart done")
+
+ // Check subscription
+ queryXappSubscription(t, int64(e2SubsId), "RAN_NAME_1", []string{"localhost:13560"})
+
+ xapp.Logger.Debug("Here 1")
+ //<-time.After(3 * time.Second)
+ xapp.Logger.Debug("Here 2")
+
+ // Delete subscription
+ xappConn1.SendRESTSubsDelReq(t, &restSubId)
+ delreq, delmsg := e2termConn1.RecvSubsDelReq(t)
+ e2termConn1.SendSubsDelResp(t, delreq, delmsg)
+
+ //Wait that subs is cleaned
+ waitSubsCleanup(t, e2SubsId, 10)
+
+ mainCtrl.VerifyCounterValues(t)
+}
+
////////////////////////////////////////////////////////////////////////////////////
// Services for UT cases
////////////////////////////////////////////////////////////////////////////////////
params = fromXappConn.GetRESTSubsReqReportParams(subReqCount)
}
restSubId := fromXappConn.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
crereq1, cremsg1 := toE2termConn.RecvSubsReq(t)
fromXappConn.ExpectRESTNotification(t, restSubId)
toE2termConn.SendSubsResp(t, crereq1, cremsg1)
e2SubsId := fromXappConn.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
return restSubId, e2SubsId
}
xapp.Subscription.SetResponseCB(xappConn2.SubscriptionRespHandler)
restSubId := xappConn2.SendRESTSubsReq(t, params)
xappConn2.ExpectRESTNotification(t, restSubId)
- xapp.Logger.Info("Send REST subscriber request for subscriberId : %v", restSubId)
+ xapp.Logger.Debug("Send REST subscriber request for subscriberId : %v", restSubId)
e2SubsId := xappConn2.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
return restSubId, e2SubsId
}
func createXapp1PolicySubscription(t *testing.T) (string, uint32) {
+
params := xappConn1.GetRESTSubsReqPolicyParams(subReqCount)
restSubId := xappConn1.SendRESTSubsReq(t, params)
- xapp.Logger.Info("Send REST Policy subscriber request for subscriberId : %v", restSubId)
+ xapp.Logger.Debug("Send REST Policy subscriber request for subscriberId : %v", restSubId)
crereq1, cremsg1 := e2termConn1.RecvSubsReq(t)
xappConn1.ExpectRESTNotification(t, restSubId)
e2termConn1.SendSubsResp(t, crereq1, cremsg1)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("REST notification received e2SubsId=%v", e2SubsId)
return restSubId, e2SubsId
}
xappConn1.ExpectRESTNotification(t, restSubId)
e2termConn1.SendSubsDelResp(t, delreq1, delmsg1)
e2SubsId := xappConn1.WaitRESTNotification(t, restSubId)
- xapp.Logger.Info("TEST: REST notification received e2SubsId=%v", e2SubsId)
+ xapp.Logger.Debug("TEST: REST notification received e2SubsId=%v", e2SubsId)
return restSubId, e2SubsId
}
var e2SubsId []uint32
for i := 0; i < count; i++ {
- xapp.Logger.Info("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
+ xapp.Logger.Debug("TEST: %d ===================================== BEGIN CRE ============================================", i+1)
crereq, cremsg := toE2termConn.RecvSubsReq(t)
fromXappConn.ExpectRESTNotification(t, restSubId)
toE2termConn.SendSubsResp(t, crereq, cremsg)
instanceId := fromXappConn.WaitRESTNotification(t, restSubId)
e2SubsId = append(e2SubsId, instanceId)
- xapp.Logger.Info("TEST: %v", e2SubsId)
- xapp.Logger.Info("TEST: %d ===================================== END CRE ============================================", i+1)
+ xapp.Logger.Debug("TEST: %v", e2SubsId)
+ xapp.Logger.Debug("TEST: %d ===================================== END CRE ============================================", i+1)
<-time.After(100 * time.Millisecond)
}
return e2SubsId
func sendAndReceiveMultipleE2DelReqs(t *testing.T, e2SubsIds []uint32, toE2termConn *teststube2ap.E2Stub) {
for i := 0; i < len(e2SubsIds); i++ {
- xapp.Logger.Info("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
+ xapp.Logger.Debug("TEST: %d ===================================== BEGIN DEL ============================================", i+1)
delreq, delmsg := toE2termConn.RecvSubsDelReq(t)
toE2termConn.SendSubsDelResp(t, delreq, delmsg)
<-time.After(1 * time.Second)
- xapp.Logger.Info("TEST: %d ===================================== END DEL ============================================", i+1)
+ xapp.Logger.Debug("TEST: %d ===================================== END DEL ============================================", i+1)
<-time.After(100 * time.Millisecond)
}
if err != nil {
tc.Error("%s", err.Error())
}
- tc.Info("handling SubscriptionID=%d Address=%s Port=%d", *req.SubscriptionID, *req.Address, *req.Port)
+ tc.Debug("handling SubscriptionID=%d Address=%s Port=%d", *req.SubscriptionID, *req.Address, *req.Port)
id = *req.SubscriptionID
}
if r.Method == http.MethodPut {
if err != nil {
tc.Error("%s", err.Error())
}
- tc.Info("handling put")
+ tc.Debug("handling put")
}
var code int = 0
}
if tc.eventWaiter.sleep != 0 {
<-time.After(time.Duration(tc.eventWaiter.sleep) * time.Millisecond)
- tc.Info("sleeping done, %v", id)
+ tc.Debug("sleeping done, %v", id)
}
}
case http.MethodDelete:
if waiter != nil {
waiter.SetResult(true)
}
- tc.Info("Method=%s Reply with code %d", r.Method, code)
+ tc.Debug("Method=%s Reply with code %d", r.Method, code)
w.WriteHeader(code)
}
//-----------------------------------------------------------------------------
func CaseBegin(desc string) *teststub.TestWrapper {
tent := teststub.NewTestWrapper(desc)
- tent.Info(desc)
+ tent.Debug(desc)
return tent
}
defer os.Remove(cfgfilename)
os.Setenv("CFG_FILE", cfgfilename)
*/
- tent.Info("Using cfg file %s", os.Getenv("CFG_FILE"))
+ tent.Debug("Using cfg file %s", os.Getenv("CFG_FILE"))
//---------------------------------
// Static routetable for rmr
rt.AddMeid(e2term2src.String(), []string{"RAN_NAME_11", "RAN_NAME_12"})
rt.Enable()
- tent.Info("rttable[%s]", rt.Table())
+ tent.Debug("rttable[%s]", rt.Table())
//---------------------------------
//
//---------------------------------
- tent.Info("### submgr ctrl run ###")
+ tent.Debug("### submgr ctrl run ###")
mainCtrl = createSubmgrControl(mainsrc, teststub.RmrRtgSvc{})
//
//env variables. Re-create rt info.
for i := 0; i < int(10)*2; i++ {
if os.Getenv("RMR_SEED_RT") == rt.FileName() {
- tent.Info("Waiting that alarm alternates RMR_SEED_RT=%s", os.Getenv("RMR_SEED_RT"))
+ tent.Debug("Waiting that alarm alternates RMR_SEED_RT=%s", os.Getenv("RMR_SEED_RT"))
time.Sleep(500 * time.Millisecond)
} else {
- tent.Info("Alarm has alternated RMR_SEED_RT=%s, so waiting 0.5 secs before restoring it", os.Getenv("RMR_SEED_RT"))
+ tent.Debug("Alarm has alternated RMR_SEED_RT=%s, so waiting 0.5 secs before restoring it", os.Getenv("RMR_SEED_RT"))
time.Sleep(500 * time.Millisecond)
rt.Enable()
- tent.Info("rttable[%s]", rt.Table())
+ tent.Debug("rttable[%s]", rt.Table())
break
}
}
//---------------------------------
//
//---------------------------------
- tent.Info("### xapp1 stub run ###")
+ tent.Debug("### xapp1 stub run ###")
xappConn1 = teststube2ap.CreateNewE2Stub("xappstub1", xapp1src, teststub.RmrRtgSvc{}, "RMRXAPP1STUB", teststubPortSeed, "RAN_NAME_1", "localhost", 13560, 8080)
//---------------------------------
//
//---------------------------------
- tent.Info("### xapp2 stub run ###")
+ tent.Debug("### xapp2 stub run ###")
xappConn2 = teststube2ap.CreateNewE2Stub("xappstub2", xapp2src, teststub.RmrRtgSvc{}, "RMRXAPP2STUB", teststubPortSeed, "RAN_NAME_2", "localhost", 13660, 8080)
//---------------------------------
//
//---------------------------------
- tent.Info("### e2term1 stub run ###")
+ tent.Debug("### e2term1 stub run ###")
e2termConn1 = teststube2ap.CreateNewE2termStub("e2termstub1", e2term1src, teststub.RmrRtgSvc{}, "RMRE2TERMSTUB1", teststubPortSeed)
//---------------------------------
//
//---------------------------------
- tent.Info("### e2term2 stub run ###")
+ tent.Debug("### e2term2 stub run ###")
e2termConn2 = teststube2ap.CreateNewE2termStub("e2termstub2", e2term2src, teststub.RmrRtgSvc{}, "RMRE2TERMSTUB2", teststubPortSeed)
//---------------------------------
// Just to test dummy stub
//---------------------------------
- tent.Info("### dummy stub run ###")
+ tent.Debug("### dummy stub run ###")
dummystub = teststubdummy.CreateNewRmrDummyStub("dummystub", dummysrc, teststub.RmrRtgSvc{}, "DUMMYSTUB", teststubPortSeed)
//---------------------------------
}
func (tc *RmrControl) TestLog(t *testing.T, pattern string, args ...interface{}) {
- tc.Info(fmt.Sprintf(pattern, args...))
+ tc.Debug(fmt.Sprintf(pattern, args...))
t.Logf(fmt.Sprintf(pattern, args...))
}
msg.PayloadLen = len(cPay)
if msg.Mtype == tc.InitMsg {
- tc.Info("Testing message ignore %s", msg.String())
+ tc.Debug("Testing message ignore %s", msg.String())
tc.SetActive()
return
}
if tc.IsCheckXid() == true && strings.Contains(msg.Xid, tc.GetDesc()) == false {
- tc.Info("Ignore %s", msg.String())
+ tc.Debug("Ignore %s", msg.String())
return
}
- tc.Info("Consume %s", msg.String())
+ tc.Debug("Consume %s", msg.String())
tc.PushMsg(msg)
return
}
params.Mbuf = nil
if len(allRmrStubs) == 0 {
- tent.Info("No rmr stubs so no need to wait those to be alive")
+ tent.Debug("No rmr stubs so no need to wait those to be alive")
return true
}
status := false
i := 1
for ; i <= seconds*2 && status == false; i++ {
- tent.Info("SEND TESTPING: %s", params.String())
+ tent.Debug("SEND TESTPING: %s", params.String())
rmr.SendWithRetry(params, false, 0)
status = true
if status == true {
break
}
- tent.Info("Sleep 0.5 secs and try routes again")
+ tent.Debug("Sleep 0.5 secs and try routes again")
time.Sleep(500 * time.Millisecond)
}
}
os.Setenv("RMR_SEED_RT", rrt.tmpfile)
os.Setenv("RMR_RTG_SVC", "-1")
- xapp.Logger.Info("Using rt file %s", os.Getenv("RMR_SEED_RT"))
+ xapp.Logger.Debug("Using rt file %s", os.Getenv("RMR_SEED_RT"))
}
func (rrt *RmrRouteTable) Disable() {
os.Unsetenv("RMR_SEED_RT")
os.Unsetenv("RMR_RTG_SVC")
rrt.tmpfile = ""
- xapp.Logger.Info("Not using rt file ")
+ xapp.Logger.Debug("Not using rt file ")
}
}
func (rsi *RmrSrcId) Enable() {
if rsi.Port > 0 {
os.Setenv("RMR_SRC_ID", rsi.String())
- xapp.Logger.Info("Using src id %s", os.Getenv("RMR_SRC_ID"))
+ xapp.Logger.Debug("Using src id %s", os.Getenv("RMR_SRC_ID"))
}
}
func (rsi *RmrSrcId) Disable() {
os.Unsetenv("RMR_SRC_ID")
- xapp.Logger.Info("Not using Using src id")
+ xapp.Logger.Debug("Not using Using src id")
}
//-----------------------------------------------------------------------------
func (rrs *RmrRtgSvc) Enable() {
if rrs.Port > 0 {
os.Setenv("RMR_RTG_SVC", rrs.String())
- xapp.Logger.Info("Using rtg svc %s", os.Getenv("RMR_SRC_ID"))
+ xapp.Logger.Debug("Using rtg svc %s", os.Getenv("RMR_SRC_ID"))
}
}
func (rrs *RmrRtgSvc) Disable() {
os.Unsetenv("RMR_RTG_SVC")
- xapp.Logger.Info("Not using Using rtg svc")
+ xapp.Logger.Debug("Not using Using rtg svc")
}
//
//-----------------------------------------------------------------------------
func (tw *TestWrapper) TestLog(t *testing.T, pattern string, args ...interface{}) {
- tw.Info(fmt.Sprintf(pattern, args...))
+ tw.Debug(fmt.Sprintf(pattern, args...))
t.Logf(fmt.Sprintf(pattern, args...))
}
//-----------------------------------------------------------------------------
func (tc *RmrDummyStub) SendReq(t *testing.T, plen int) {
- tc.Info("SendReq")
+ tc.Debug("SendReq")
len := plen
if len == 0 {
len = 100
}
func (tc *RmrDummyStub) SendResp(t *testing.T, plen int) {
- tc.Info("SendReq")
+ tc.Debug("SendReq")
len := plen
if len == 0 {
len = 100
}
func (tc *RmrDummyStub) RecvReq(t *testing.T) bool {
- tc.Info("RecvReq")
+ tc.Debug("RecvReq")
msg := tc.WaitMsg(15)
if msg != nil {
}
func (tc *RmrDummyStub) RecvResp(t *testing.T) bool {
- tc.Info("RecvResp")
+ tc.Debug("RecvResp")
msg := tc.WaitMsg(15)
if msg != nil {
"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/e2ap_wrapper"
"gerrit.o-ran-sc.org/r/ric-plt/submgr/pkg/teststub"
clientmodel "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/clientmodel"
+ //"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
)
}
type E2RestIds struct {
- RestSubsId string
- E2SubsId uint32
- ErrorCause string
+ RestSubsId string
+ E2SubsId uint32
+ ErrorCause string
+ ErrorSource string
+ TimeoutType string
}
func (trans *RmrTransactionId) String() string {
trans.xid = xid
}
trans.meid = &xapp.RMRMeid{RanName: ranname}
- tc.Info("New test %s", trans.String())
+ tc.Debug("New test %s", trans.String())
return trans
}
trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
}
- tc.Info("SendSubsReq %s", trans.String())
+ tc.Debug("SendSubsReq %s", trans.String())
e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
//---------------------------------
params.Xid = trans.xid
params.Mbuf = nil
- tc.Info("SEND SUB REQ: %s", params.String())
+ tc.Debug("SEND SUB REQ: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsReq(t *testing.T) (*e2ap.E2APSubscriptionRequest, *xapp.RMRParams) {
- tc.Info("RecvSubsReq")
+ tc.Debug("RecvSubsReq")
e2SubsReq := e2asnpacker.NewPackerSubscriptionRequest()
//---------------------------------
if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_REQ"] {
tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_REQ", xapp.RicMessageTypeToName[msg.Mtype])
} else {
- tc.Info("Recv Subs Req")
+ tc.Debug("Recv Subs Req")
packedData := &e2ap.PackedData{}
packedData.Buf = msg.Payload
unpackerr, req := e2SubsReq.UnPack(packedData)
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsResp(t *testing.T, req *e2ap.E2APSubscriptionRequest, msg *xapp.RMRParams) {
- tc.Info("SendSubsResp")
+ tc.Debug("SendSubsResp")
e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
//---------------------------------
//params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB RESP: %s", params.String())
+ tc.Debug("SEND SUB RESP: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
params.Mbuf = nil
if params.Mtype == xapp.RIC_SUB_RESP {
- tc.Info("SEND INVALID ASN.1 SUB RESP")
+ tc.Debug("SEND INVALID ASN.1 SUB RESP")
} else if params.Mtype == xapp.RIC_SUB_FAILURE {
- tc.Info("SEND INVALID ASN.1 SUB FAILURE")
+ tc.Debug("SEND INVALID ASN.1 SUB FAILURE")
} else if params.Mtype == xapp.RIC_SUB_DEL_RESP {
- tc.Info("SEND INVALID ASN.1 SUB DEL RESP")
+ tc.Debug("SEND INVALID ASN.1 SUB DEL RESP")
} else if params.Mtype == xapp.RIC_SUB_DEL_FAILURE {
- tc.Info("SEND INVALID ASN.1 SUB DEL FAILURE")
+ tc.Debug("SEND INVALID ASN.1 SUB DEL FAILURE")
}
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsResp(t *testing.T, trans *RmrTransactionId) uint32 {
- tc.Info("RecvSubsResp")
+ tc.Debug("RecvSubsResp")
e2SubsResp := e2asnpacker.NewPackerSubscriptionResponse()
var e2SubsId uint32
if unpackerr != nil {
tc.TestError(t, "RIC_SUB_RESP unpack failed err: %s", unpackerr.Error())
}
- tc.Info("Recv Subs Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
+ tc.Debug("Recv Subs Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
return e2SubsId
}
} else {
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsFail(t *testing.T, fparams *E2StubSubsFailParams, msg *xapp.RMRParams) {
- tc.Info("SendSubsFail")
+ tc.Debug("SendSubsFail")
e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
//---------------------------------
params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB FAIL: %s", params.String())
+ tc.Debug("SEND SUB FAIL: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsFail(t *testing.T, trans *RmrTransactionId) uint32 {
- tc.Info("RecvSubsFail")
+ tc.Debug("RecvSubsFail")
e2SubsFail := e2asnpacker.NewPackerSubscriptionFailure()
var e2SubsId uint32
if unpackerr != nil {
tc.TestError(t, "RIC_SUB_FAILURE unpack failed err: %s", unpackerr.Error())
}
- tc.Info("Recv Subs Fail rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
+ tc.Debug("Recv Subs Fail rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
return e2SubsId
}
} else {
trans = tc.NewRmrTransactionId("", "RAN_NAME_1")
}
- tc.Info("SendSubsDelReq %s", trans.String())
+ tc.Debug("SendSubsDelReq %s", trans.String())
e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
//---------------------------------
// xapp activity: Send Subs Del Req
params.Xid = trans.xid
params.Mbuf = nil
- tc.Info("SEND SUB DEL REQ: %s", params.String())
+ tc.Debug("SEND SUB DEL REQ: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s %s", trans.String(), snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsDelReq(t *testing.T) (*e2ap.E2APSubscriptionDeleteRequest, *xapp.RMRParams) {
- tc.Info("RecvSubsDelReq")
+ tc.Debug("RecvSubsDelReq")
e2SubsDelReq := e2asnpacker.NewPackerSubscriptionDeleteRequest()
//---------------------------------
if msg.Mtype != xapp.RICMessageTypes["RIC_SUB_DEL_REQ"] {
tc.TestError(t, "Received wrong mtype expected %s got %s, error", "RIC_SUB_DEL_REQ", xapp.RicMessageTypeToName[msg.Mtype])
} else {
- tc.Info("Recv Subs Del Req")
+ tc.Debug("Recv Subs Del Req")
packedData := &e2ap.PackedData{}
packedData.Buf = msg.Payload
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsDelResp(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
- tc.Info("SendSubsDelResp")
+ tc.Debug("SendSubsDelResp")
e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
//---------------------------------
params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB DEL RESP: %s", params.String())
+ tc.Debug("SEND SUB DEL RESP: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) RecvSubsDelResp(t *testing.T, trans *RmrTransactionId) {
- tc.Info("RecvSubsDelResp")
+ tc.Debug("RecvSubsDelResp")
e2SubsDelResp := e2asnpacker.NewPackerSubscriptionDeleteResponse()
//---------------------------------
if unpackerr != nil {
tc.TestError(t, "RIC_SUB_DEL_RESP unpack failed err: %s", unpackerr.Error())
}
- tc.Info("Recv Subs Del Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
+ tc.Debug("Recv Subs Del Resp rmr: xid=%s subid=%d, asn: instanceid=%d", msg.Xid, msg.SubId, resp.RequestId.InstanceId)
return
}
} else {
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendSubsDelFail(t *testing.T, req *e2ap.E2APSubscriptionDeleteRequest, msg *xapp.RMRParams) {
- tc.Info("SendSubsDelFail")
+ tc.Debug("SendSubsDelFail")
e2SubsDelFail := e2asnpacker.NewPackerSubscriptionDeleteFailure()
//---------------------------------
params.Xid = msg.Xid
params.Mbuf = nil
- tc.Info("SEND SUB DEL FAIL: %s", params.String())
+ tc.Debug("SEND SUB DEL FAIL: %s", params.String())
snderr := tc.SendWithRetry(params, false, 5)
if snderr != nil {
tc.TestError(t, "RMR SEND FAILED: %s", snderr.Error())
func (tc *E2Stub) SubscriptionRespHandler(resp *clientmodel.SubscriptionResponse) {
if tc.subscriptionId == "SUBSCRIPTIONID NOT SET" {
- tc.Info("REST notification received for %v while no SubscriptionID was not set for E2EventInstanceID=%v, XappEventInstanceID=%v (%v)",
+ tc.Debug("REST notification received for %v while no SubscriptionID was not set for E2EventInstanceID=%v, XappEventInstanceID=%v (%v)",
*resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID, tc)
tc.CallBackNotification <- *resp.SubscriptionInstances[0].E2EventInstanceID
} else if tc.subscriptionId == *resp.SubscriptionID {
- tc.Info("REST notification received SubscriptionID=%s, E2EventInstanceID=%v, RequestorID=%v (%v)",
+ tc.Debug("REST notification received SubscriptionID=%s, E2EventInstanceID=%v, RequestorID=%v (%v)",
*resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID, tc)
tc.CallBackNotification <- *resp.SubscriptionInstances[0].E2EventInstanceID
} else {
- tc.Info("MISMATCHING REST notification received SubscriptionID=%s<>%s, E2EventInstanceID=%v, XappEventInstanceID=%v (%v)",
+ tc.Debug("MISMATCHING REST notification received SubscriptionID=%s<>%s, E2EventInstanceID=%v, XappEventInstanceID=%v (%v)",
tc.subscriptionId, *resp.SubscriptionID, *resp.SubscriptionInstances[0].E2EventInstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID, tc)
}
}
func (tc *E2Stub) expectNotification(t *testing.T, restSubsId string, expectError string) {
- tc.Info("### Started to wait REST notification for %v on port %v f(RMR port %v), %v responses expected", restSubsId, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort, tc.requestCount)
+ tc.Debug("### Started to wait REST notification for %v on port %v f(RMR port %v), %v responses expected", restSubsId, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort, tc.requestCount)
tc.restSubsIdList = []string{restSubsId}
xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler)
if tc.requestCount == 0 {
} 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.TestError(t, "### Unexpected error cause (%s) received from REST notifications |%s:%s| (%v)", e2Ids.ErrorCause, e2Ids.RestSubsId, restSubsId, tc)
+ tc.TestError(t, "### Unexpected ErrorCause: (%s), ErrorSource: (%s), TimeoutType: (%s) received from REST notifications |%s:%s| (%v)", e2Ids.ErrorCause, e2Ids.ErrorSource, e2Ids.TimeoutType, e2Ids.RestSubsId, restSubsId, tc)
} else {
tc.requestCount--
if tc.requestCount == 0 {
- tc.Info("### All expected REST notifications received for %s (%v)", e2Ids.RestSubsId, tc)
+ tc.Debug("### All expected REST notifications received for %s (%v)", e2Ids.RestSubsId, tc)
} else {
- tc.Info("### Expected REST notifications received for %s, (%v)", e2Ids.RestSubsId, tc)
+ tc.Debug("### Expected REST notifications received for %s, (%v)", e2Ids.RestSubsId, tc)
}
if e2Ids.ErrorCause != "" && expectError == "allFail" {
- tc.Info("### REST Notification: %s, ErrorCause: %v", e2Ids.RestSubsId, e2Ids.ErrorCause)
+ tc.Debug("### REST Notification: RestSubsId: %s, ErrorCause: %s, ErrorSource: (%s), TimeoutType: (%s)", e2Ids.RestSubsId, e2Ids.ErrorCause, e2Ids.ErrorSource, e2Ids.TimeoutType)
}
- tc.Info("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
+ tc.Debug("### REST Notification received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
tc.ListedRESTNotifications <- e2Ids
if len(tc.ListedRESTNotifications) > 1 {
panic("expectNotification - ListedRESTNotifications stacking up")
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)
+ tc.Debug("### 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 notification %s received, expected %s for endpoint=%s, (%v)", e2SubsId.RestSubsId, restSubsId, tc.clientEndpoint, tc)
- xapp.Logger.Info("CALL STACK:\n %s", stack)
+ xapp.Logger.Debug("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)
+ xapp.Logger.Debug("CALL STACK:\n %s", stack)
panic("WaitRESTNotification - timeout error")
}
}
// Note, this function should be followed by a handling of <-xappConn1.RESTNotification.
func (tc *E2Stub) ExpectAnyNotification(t *testing.T) {
go func() {
- tc.Info("### Started waiting ANY REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc)
+ tc.Debug("### Started waiting ANY REST notifications received for endpoint=%s, (%v)", tc.clientEndpoint, tc)
select {
case e2SubsId := <-tc.CallBackNotification:
- tc.Info("### ANY REST notifications received e2SubsId %v for endpoint=%s, (%v) via CallBackNotification", e2SubsId, tc.clientEndpoint, tc)
+ tc.Debug("### 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 ANY REST notification")
select {
case e2SubsId := <-tc.RESTNotification:
- tc.Info("### Expected ANY REST notification received - e2SubsId %v for endpoint=%s, (%v)", e2SubsId, tc.clientEndpoint, tc)
+ tc.Debug("### Expected ANY REST notification received - e2SubsId %v for endpoint=%s, (%v)", e2SubsId, tc.clientEndpoint, tc)
return e2SubsId
case <-time.After(15 * time.Second):
} else {
for i, subsId := range tc.restSubsIdList {
if *resp.SubscriptionID == subsId {
- //tc.Info("Listed REST notifications received SubscriptionID=%s, InstanceID=%v, XappEventInstanceID=%v",
+ //tc.Debug("Listed REST notifications received SubscriptionID=%s, InstanceID=%v, XappEventInstanceID=%v",
// *resp.SubscriptionID, *resp.SubscriptionInstances[0].InstanceID, *resp.SubscriptionInstances[0].XappEventInstanceID)
tc.restSubsIdList = append(tc.restSubsIdList[:i], tc.restSubsIdList[i+1:]...)
- //tc.Info("Removed %s from Listed REST notifications, %v entries left", *resp.SubscriptionID, len(tc.restSubsIdList))
+ //tc.Debug("Removed %s from Listed REST notifications, %v entries left", *resp.SubscriptionID, len(tc.restSubsIdList))
- if resp.SubscriptionInstances[0].ErrorCause != nil {
- tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].E2EventInstanceID), *resp.SubscriptionInstances[0].ErrorCause}
- } else {
- tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].E2EventInstanceID), ""}
- }
+ // if resp.SubscriptionInstances[0].ErrorCause != nil {
+ tc.CallBackListedNotifications <- *tc.GetE2RestIds(resp)
+ // } else {
+ // tc.CallBackListedNotifications <- E2RestIds{*resp.SubscriptionID, uint32(*resp.SubscriptionInstances[0].E2EventInstanceID), "", "", ""}
+ // }
if len(tc.restSubsIdList) == 0 {
- tc.Info("All listed REST notifications received for endpoint=%s", tc.clientEndpoint)
+ tc.Debug("All listed REST notifications received for endpoint=%s", tc.clientEndpoint)
}
return
}
}
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (tc *E2Stub) GetE2RestIds(resp *clientmodel.SubscriptionResponse) *E2RestIds {
+
+ e2RestIds := &E2RestIds{}
+ if resp != nil {
+ if resp.SubscriptionID != nil {
+ e2RestIds.RestSubsId = *resp.SubscriptionID
+ }
+ if resp.SubscriptionInstances != nil {
+ if resp.SubscriptionInstances[0].E2EventInstanceID != nil {
+ e2RestIds.E2SubsId = uint32(*resp.SubscriptionInstances[0].E2EventInstanceID)
+ }
+ if resp.SubscriptionInstances[0].ErrorCause != nil {
+ e2RestIds.ErrorCause = *resp.SubscriptionInstances[0].ErrorCause
+ } else {
+ e2RestIds.ErrorCause = "nil"
+ }
+ if resp.SubscriptionInstances[0].ErrorSource != nil {
+ e2RestIds.ErrorSource = *resp.SubscriptionInstances[0].ErrorSource
+ } else {
+ e2RestIds.ErrorSource = "nil"
+ }
+ if resp.SubscriptionInstances[0].TimeoutType != nil {
+ e2RestIds.TimeoutType = *resp.SubscriptionInstances[0].TimeoutType
+ } else {
+ e2RestIds.TimeoutType = "nil"
+ }
+ }
+ }
+ return e2RestIds
+}
+
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) WaitListedRestNotifications(t *testing.T, restSubsIds []string) {
- tc.Info("Started to wait REST notifications %v on port %v f(RMR port %v)", restSubsIds, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort)
+ tc.Debug("Started to wait REST notifications %v on port %v f(RMR port %v)", restSubsIds, *tc.clientEndpoint.HTTPPort, *tc.clientEndpoint.RMRPort)
tc.restSubsIdList = restSubsIds
xapp.Subscription.SetResponseCB(tc.ListedRestNotifHandler)
go func() {
select {
case e2Ids := <-tc.CallBackListedNotifications:
- tc.Info("Listed Notification waiter received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
+ tc.Debug("Listed Notification waiter received Notif for %s : %v", e2Ids.RestSubsId, e2Ids.E2SubsId)
tc.ListedRESTNotifications <- e2Ids
case <-time.After(15 * time.Second):
err := fmt.Errorf("Timeout 15s expired while waiting Listed REST notification")
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
-func (tc *E2Stub) SendRESTSubsReq(t *testing.T, params *RESTSubsReqParams) string { // This need to be edited according to new specification
- tc.Info("======== Posting REST Report subscriptions to Submgr ======")
+func (tc *E2Stub) SendRESTSubsReq(t *testing.T, params *RESTSubsReqParams) string {
+ tc.Debug("======== Posting REST subscriptions to Submgr ======")
if params == nil {
- tc.Info("SendRESTReportSubsReq: params == nil")
+ tc.Debug("SendRESTReportSubsReq: params == nil")
return ""
}
if err != nil {
// Swagger generated code makes checks for the values that are inserted the subscription function
// If error cause is unknown and POST is not done, the problem is in the inserted values
- tc.Error("======== REST report subscriptions failed %s ========", err.Error())
+ tc.Error("======== REST subscription request failed %s ========", err.Error())
+ if resp != nil {
+ tc.PrintSubscriptionInsctanceErrorInfo(resp)
+ } else {
+ tc.Error("Subscribe resp == nil")
+ }
return ""
}
tc.subscriptionId = *resp.SubscriptionID
- tc.Info("======== REST report subscriptions posted successfully. SubscriptionID = %s, RequestCount = %v ========", *resp.SubscriptionID, tc.requestCount)
+ tc.Debug("======== REST subscriptions posted successfully. SubscriptionID = %s, RequestCount = %v ========", *resp.SubscriptionID, tc.requestCount)
return *resp.SubscriptionID
}
+//-----------------------------------------------------------------------------
+//
+//-----------------------------------------------------------------------------
+func (tc *E2Stub) PrintSubscriptionInsctanceErrorInfo(resp *clientmodel.SubscriptionResponse) {
+ for _, subscriptionInstance := range resp.SubscriptionInstances {
+ if subscriptionInstance != nil {
+ if subscriptionInstance.RejectCause != nil {
+ tc.Error("subscriptionInstance.RejectCause= %s", *subscriptionInstance.RejectCause)
+ }
+ if subscriptionInstance.ErrorCause != nil {
+ tc.Error("subscriptionInstance.ErrorCause= %s", *subscriptionInstance.ErrorCause)
+ }
+ if subscriptionInstance.ErrorSource != nil {
+ tc.Error("subscriptionInstance.ErrorSource= %s", *subscriptionInstance.ErrorSource)
+ }
+ if subscriptionInstance.TimeoutType != nil {
+ tc.Error("subscriptionInstance.TimeoutType = %s", *subscriptionInstance.TimeoutType)
+ }
+ }
+ }
+}
+
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
var rANFunctionID int64 = 33
p.SubsReqParams.RANFunctionID = &rANFunctionID
- // reqId := int64(1)
- //seqId := int64(1)
actionId := int64(1)
actionType := "report"
subsequestActioType := "continue"
if p.SubsReqParams.ClientEndpoint.Host != "" {
if p.SubsReqParams.ClientEndpoint.Host != host {
- // Renaming toto, print something tc.Info("Posting REST subscription request to Submgr")
+ // Renaming toto, print something tc.Debug("Posting REST subscription request to Submgr")
err := fmt.Errorf("hostname change attempt: %s -> %s", p.SubsReqParams.ClientEndpoint.Host, host)
panic(err)
}
}
}
+func (p *RESTSubsReqParams) SetE2SubscriptionDirectives(E2RetryCount int64, E2TimeoutTimerValue int64, RMRRoutingNeeded bool) {
+
+ E2SubscriptionDirectives := &clientmodel.SubscriptionParamsE2SubscriptionDirectives{}
+ p.SubsReqParams.E2SubscriptionDirectives = E2SubscriptionDirectives
+ p.SubsReqParams.E2SubscriptionDirectives.E2RetryCount = &E2RetryCount
+ p.SubsReqParams.E2SubscriptionDirectives.E2TimeoutTimerValue = E2TimeoutTimerValue
+ p.SubsReqParams.E2SubscriptionDirectives.RMRRoutingNeeded = &RMRRoutingNeeded
+}
+
+func (p *RESTSubsReqParams) RemoveE2SubscriptionDirectives() {
+
+ p.SubsReqParams.E2SubscriptionDirectives = nil
+}
+
func (p *RESTSubsReqParams) SetSubActionTypes(actionType string) {
for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
p.SubsReqParams.SubscriptionID = *SubscriptionID
}
+func (p *RESTSubsReqParams) SetXappEventInstanceID(xappEventInstanceId int64) {
+
+ for _, subDetail := range p.SubsReqParams.SubscriptionDetails {
+ if subDetail != nil {
+ subDetail.XappEventInstanceID = &xappEventInstanceId
+ }
+ }
+}
+
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
func (tc *E2Stub) SendRESTSubsDelReq(t *testing.T, subscriptionID *string) {
- tc.Info("======== Posting REST DELETE subscription(s) to Submgr ======")
+ tc.Debug("======== Posting REST DELETE subscription(s) to Submgr ======")
if *subscriptionID == "" {
tc.Error("REST error in deleting subscriptions. Empty SubscriptionID = %s", *subscriptionID)
}
- tc.Info("REST deleting E2 subscriptions. SubscriptionID = %s", *subscriptionID)
+ tc.Debug("REST deleting E2 subscriptions. SubscriptionID = %s", *subscriptionID)
err := xapp.Subscription.Unsubscribe(*subscriptionID)
if err != nil {
tc.Error("REST Delete subscription failed %s", err.Error())
}
- tc.Info("REST delete subscription pushed to submgr successfully. SubscriptionID = %s", *subscriptionID)
+ tc.Debug("REST delete subscription pushed to submgr successfully. SubscriptionID = %s", *subscriptionID)
}
//-----------------------------------------------------------------------------
p.SubsReqParams.Meid = meid
var rANFunctionID int64 = 33
p.SubsReqParams.RANFunctionID = &rANFunctionID
-
- // reqId := int64(1)
- //seqId := int64(1)
actionId := int64(1)
actionType := "policy"
subsequestActioType := "continue"
}
p.SubsReqParams.SubscriptionDetails = append(p.SubsReqParams.SubscriptionDetails, subscriptionDetail)
}
+}
+
+func (p *RESTSubsReqParams) SetSubscriptionDirectives(e2Timeout int64, e2RetryCount int64, routingNeeded bool) {
+
+ e2SubscriptionDirectives := &clientmodel.SubscriptionParamsE2SubscriptionDirectives{}
+ e2SubscriptionDirectives.E2TimeoutTimerValue = e2Timeout
+ e2SubscriptionDirectives.E2RetryCount = &e2RetryCount
+ e2SubscriptionDirectives.RMRRoutingNeeded = &routingNeeded
+ p.SubsReqParams.E2SubscriptionDirectives = e2SubscriptionDirectives
}
Code Review / ric-plt / submgr.git / commitdiff
