"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
"github.com/julienschmidt/httprouter"
"net/http"
- "time"
)
const (
}
func (c *Controller) X2ResetHandler(writer http.ResponseWriter, r *http.Request, params httprouter.Params){
- startTime := time.Now()
c.logger.Infof("[Client -> E2 Manager] #controller.X2ResetHandler - request: %v", prettifyRequest(r))
request:= models.ResetRequest{}
ranName:= params.ByName(ParamRanName)
return
}
request.RanName = ranName
- request.StartTime = startTime
c.handleRequest(writer, &r.Header, providers.ResetRequest, request, false, http.StatusNoContent)
}
if err := decoder.Decode(request); err != nil {
if err != nil {
c.logger.Errorf("[Client -> E2 Manager] #controller.extractJsonBody - unable to extract json body - error: %s", err)
- c.handleErrorResponse(e2managererrors.NewRequestValidationError(), writer)
+ c.handleErrorResponse(e2managererrors.NewInvalidJsonError(), writer)
return false
}
}
func (c *Controller) handleRequest(writer http.ResponseWriter, header *http.Header, requestName providers.IncomingRequest,
request models.Request, validateHeader bool, httpStatusResponse int) {
- c.logger.Infof("[Client -> E2 Manager] #controller.handleRequest - request: %v", requestName) //TODO print request if exist
-
if validateHeader {
err := c.validateRequestHeader(header)
e2Error, _ := err.(*e2managererrors.RequestValidationError)
errorResponseDetails = models.ErrorResponse{Code: e2Error.Err.Code, Message: e2Error.Err.Message}
httpError = http.StatusBadRequest
+ case *e2managererrors.InvalidJsonError:
+ e2Error, _ := err.(*e2managererrors.InvalidJsonError)
+ errorResponseDetails = models.ErrorResponse{Code: e2Error.Err.Code, Message: e2Error.Err.Message}
+ httpError = http.StatusBadRequest
case *e2managererrors.RmrError:
e2Error, _ := err.(*e2managererrors.RmrError)
errorResponseDetails = models.ErrorResponse{Code: e2Error.Err.Code, Message: e2Error.Err.Message}
controller.X2ResetHandler(writer, req, []httprouter.Param {param})
assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
- v, ok := rmrService.E2sessions[ranName]
- assert.True(t, ok)
-
- assert.Equal(t, v.Request.RanName, ranName)
}
func TestX2ResetHandleSuccessfulRequestedDefault(t *testing.T){
controller.X2ResetHandler(writer, req, []httprouter.Param {param})
assert.Equal(t, http.StatusNoContent, writer.Result().StatusCode)
- v, ok := rmrService.E2sessions[ranName]
- assert.True(t, ok)
-
- assert.Equal(t, v.Request.RanName, ranName)
}
func TestX2ResetHandleFailureInvalidBody(t *testing.T){
assert.Equal(t, http.StatusUnsupportedMediaType, writer.Result().StatusCode)
writer = httptest.NewRecorder()
- controller.handleErrorResponse(e2managererrors.NewWrongStateError(""),writer)
+ controller.handleErrorResponse(e2managererrors.NewWrongStateError("",""),writer)
assert.Equal(t, http.StatusBadRequest, writer.Result().StatusCode)
writer = httptest.NewRecorder()
--- /dev/null
+//
+// Copyright 2019 AT&T Intellectual Property
+// Copyright 2019 Nokia
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package e2managererrors
+
+
+type InvalidJsonError struct {
+ Err BaseError
+}
+
+func NewInvalidJsonError() *InvalidJsonError {
+ return &InvalidJsonError{
+ BaseError{
+ Code: 401,
+ Message: "corrupted json",
+ },
+ }
+}
+
+func (e *InvalidJsonError) Error() string {
+ return e.Err.Message
+}
+
Err BaseError
}
-func NewWrongStateError(state string) *WrongStateError {
+func NewWrongStateError(activityName string, state string) *WrongStateError {
return &WrongStateError{
BaseError{
Code: 403,
- Message: fmt.Sprintf("The RAN state <%s> isn’t in the appropriate state.", state) ,
+ Message: fmt.Sprintf("Activity <%s> rejected. RAN current state <%s> does not allow its execution ", activityName, state) ,
},
}
}
//
package handlers
+
import (
"e2mgr/configuration"
"e2mgr/e2managererrors"
"e2mgr/rNibWriter"
"e2mgr/rmrCgo"
"e2mgr/services"
- "e2mgr/sessions"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
)
+const (
+ X2_RESET_ACTIVITIY_NAME = "X2_RESET"
+)
type X2ResetRequestHandler struct {
readerProvider func() reader.RNibReader
writerProvider func() rNibWriter.RNibWriter
if nodeb.ConnectionStatus != entities.ConnectionStatus_CONNECTED {
logger.Errorf("#reset_request_handler.Handle - RAN: %s in wrong state (%s)", resetRequest.RanName, entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)])
- return e2managererrors.NewWrongStateError(entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)])
+ return e2managererrors.NewWrongStateError(X2_RESET_ACTIVITIY_NAME,entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)])
}
- transactionId := resetRequest.RanName
- handler.rmrService.E2sessions[transactionId] = sessions.E2SessionDetails{SessionStart: resetRequest.StartTime, Request: &models.RequestDetails{RanName: resetRequest.RanName}}
response := models.NotificationResponse{MgsType: rmrCgo.RIC_X2_RESET, RanName: resetRequest.RanName, Payload: payload}
if err:= handler.rmrService.SendRmrMessage(&response); err != nil {
logger.Errorf("#reset_request_handler.Handle - failed to send reset message to RMR: %s", err)
- delete(handler.rmrService.E2sessions, transactionId)
return e2managererrors.NewRmrError()
}
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/mock"
"testing"
- "time"
)
func TestHandleSuccessfulDefaultCause(t *testing.T){
log := initLog(t)
- curTime := time.Now()
ranName := "test1"
readerMock := &mocks.RnibReaderMock{}
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , StartTime: curTime})
+ actual := handler.Handle(log, models.ResetRequest{RanName: ranName})
assert.Nil(t, actual)
- v, ok := rmrService.E2sessions[ranName]
- assert.True(t, ok)
-
- assert.Equal(t, v.Request.RanName, ranName)
-
- assert.Equal(t, v.SessionStart ,curTime)
}
func TestHandleSuccessfulRequestedCause(t *testing.T){
log := initLog(t)
- curTime := time.Now()
ranName := "test1"
readerMock := &mocks.RnibReaderMock{}
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"protocol:transfer-syntax-error", StartTime: curTime})
+ actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"protocol:transfer-syntax-error"})
assert.Nil(t, actual)
-
- v, ok := rmrService.E2sessions[ranName]
- assert.True(t, ok)
-
- assert.Equal(t, v.Request.RanName, ranName)
-
- assert.Equal(t, v.SessionStart ,curTime)
}
func TestHandleFailureUnknownCause(t *testing.T){
log := initLog(t)
- curTime := time.Now()
ranName := "test1"
readerMock := &mocks.RnibReaderMock{}
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"XXX", StartTime: curTime})
+ actual := handler.Handle(log, models.ResetRequest{RanName: ranName , Cause:"XXX"})
assert.IsType(t, e2managererrors.NewRequestValidationError(), actual)
- _, ok := rmrService.E2sessions[ranName]
- assert.False(t, ok)
}
func TestHandleFailureWrongState(t *testing.T){
log := initLog(t)
- curTime := time.Now()
ranName := "test1"
readerMock := &mocks.RnibReaderMock{}
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_DISCONNECTED }
readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , StartTime: curTime})
+ actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
- assert.IsType(t, e2managererrors.NewWrongStateError(entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)]), actual)
+ assert.IsType(t, e2managererrors.NewWrongStateError(X2_RESET_ACTIVITIY_NAME, entities.ConnectionStatus_name[int32(nodeb.ConnectionStatus)]), actual)
- _, ok := rmrService.E2sessions[ranName]
- assert.False(t, ok)
}
func TestHandleFailureRanNotFound(t *testing.T){
log := initLog(t)
- curTime := time.Now()
ranName := "test1"
readerMock := &mocks.RnibReaderMock{}
readerMock.On("GetNodeb",ranName).Return(&entities.NodebInfo{}, common.NewResourceNotFoundError(fmt.Errorf("nodeb not found")))
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , StartTime: curTime})
+ actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
assert.IsType(t, e2managererrors.NewResourceNotFoundError(), actual)
- _, ok := rmrService.E2sessions[ranName]
- assert.False(t, ok)
}
func TestHandleFailureRnibError(t *testing.T){
log := initLog(t)
- curTime := time.Now()
ranName := "test1"
readerMock := &mocks.RnibReaderMock{}
readerMock.On("GetNodeb",ranName).Return(&entities.NodebInfo{}, common.NewInternalError(fmt.Errorf("internal error")))
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , StartTime: curTime})
+ actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
assert.IsType(t, e2managererrors.NewRnibDbError(), actual)
- _, ok := rmrService.E2sessions[ranName]
- assert.False(t, ok)
}
func TestHandleFailureRmrError(t *testing.T){
log := initLog(t)
- curTime := time.Now()
ranName := "test1"
readerMock := &mocks.RnibReaderMock{}
var nodeb = &entities.NodebInfo{ConnectionStatus: entities.ConnectionStatus_CONNECTED }
readerMock.On("GetNodeb",ranName).Return(nodeb, nil)
- actual := handler.Handle(log, models.ResetRequest{RanName: ranName , StartTime: curTime})
+ actual := handler.Handle(log, models.ResetRequest{RanName: ranName })
assert.IsType(t, e2managererrors.NewRmrError(), actual)
- _, ok := rmrService.E2sessions[ranName]
- assert.False(t, ok)
}
"e2mgr/logger"
"e2mgr/models"
"e2mgr/sessions"
- "fmt"
"gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
)
-type X2ResetResponseHandler struct{
+type X2ResetResponseHandler struct {
rnibReaderProvider func() reader.RNibReader
}
func (src X2ResetResponseHandler) Handle(logger *logger.Logger, e2Sessions sessions.E2Sessions,
request *models.NotificationRequest, messageChannel chan<- *models.NotificationResponse) {
- request.TransactionId = request.RanName
- logger.Debugf("#x2ResetResponseHandler.Handle - transactionId %s: received reset response. Payload: %s", request.TransactionId, request.Payload)
+ logger.Infof("#x2ResetResponseHandler.Handle - received reset response. Payload: %x", request.Payload)
if nb, rNibErr := src.rnibReaderProvider().GetNodeb(request.RanName); rNibErr != nil {
- logger.Errorf("#x2ResetResponseHandler.Handle - transactionId %s: failed to retrieve nb entity. RanName: %s. Error: %s", request.TransactionId, request.RanName, rNibErr.Error())
+ logger.Errorf("#x2ResetResponseHandler.Handle - failed to retrieve nb entity. RanName: %s. Error: %s", request.RanName, rNibErr.Error())
} else {
- logger.Debugf("#x2ResetResponseHandler.Handle - transactionId %s: nb entity retrieved. RanName %s, ConnectionStatus %s", request.TransactionId, nb.RanName, nb.ConnectionStatus)
+ logger.Debugf("#x2ResetResponseHandler.Handle - nb entity retrieved. RanName %s, ConnectionStatus %s", nb.RanName, nb.ConnectionStatus)
refinedMessage, err := unpackX2apPduAndRefine(logger, MaxAsn1CodecAllocationBufferSize /*allocation buffer*/, request.Len, request.Payload, MaxAsn1CodecMessageBufferSize /*message buffer*/)
if err != nil {
- logger.Errorf("#x2ResetResponseHandler.Handle - transactionId %s: failed to unpack reset response message. RanName %s, Payload: %s", request.TransactionId , request.RanName, request.Payload)
+ logger.Errorf("#x2ResetResponseHandler.Handle - failed to unpack reset response message. RanName %s, Payload: %s", request.RanName, request.Payload)
} else {
- logger.Debugf("#x2ResetResponseHandler.Handle - transactionId %s: reset response message payload unpacked. RanName %s, Message: %s", request.TransactionId , request.RanName, refinedMessage.pduPrint)
+ logger.Debugf("#x2ResetResponseHandler.Handle - reset response message payload unpacked. RanName %s, Message: %s", request.RanName, refinedMessage.pduPrint)
}
}
- e2session, ok := e2Sessions[request.TransactionId]
- if ok {
- printHandlingSetupResponseElapsedTimeInMs(logger, fmt.Sprintf("#x2ResetResponseHandler.Handle- Summary: Total roundtrip elapsed time for transactionId %s", request.TransactionId), e2session.SessionStart)
- delete(e2Sessions, request.TransactionId)
- }
-}
\ No newline at end of file
+}
h.Handle(log,e2Sessions, ¬ificationRequest, messageChannel)
- if _, ok := e2Sessions[string(xaction)]; ok {
- t.Errorf("want: no session entry, got: session entry for: %s", string(xaction) )
- }
+ //TODO:Nothing to verify
}
func TestX2ResetResponseReaderFailure(t *testing.T) {
h.Handle(log,e2Sessions, ¬ificationRequest, messageChannel)
- if _, ok := e2Sessions[string(xaction)]; ok {
- t.Errorf("want: no session entry, got: session entry for: %s", string(xaction) )
- }
+ //TODO:Nothing to verify
}
func TestX2ResetResponseUnpackFailure(t *testing.T) {
h.Handle(log,e2Sessions, ¬ificationRequest, messageChannel)
- if _, ok := e2Sessions[string(xaction)]; ok {
- t.Errorf("want: no session entry, got: session entry for: %s", string(xaction) )
- }
+ //TODO:Nothing to verify
}
package models
-import "time"
-
type ResetRequest struct {
- StartTime time.Time
RanName string
Cause string `json:"cause"`
}
state := allocatedCMBuf.state
if state != RMR_OK {
errorMessage := fmt.Sprintf("#rmrCgoApi.SendMsg - Failed to get allocated message. state: %v - %s", state, states[int(state)])
- ctx.Logger.Errorf(errorMessage)
return nil, errors.New(errorMessage)
}
if state != RMR_OK {
errorMessage := fmt.Sprintf("#rmrCgoApi.SendMsg - Failed to send message. state: %v - %s", state, states[int(state)])
- ctx.Logger.Errorf(errorMessage)
return nil, errors.New(errorMessage)
}
_, err := (*r.Messenger).SendMsg(msg, r.Config.MaxMsgSize)
if err != nil {
- r.Config.Logger.Errorf("#rmr_service.SendRmrMessage - error: %#v\n", err)
return err
}
return nil
}
r.Config.Logger.Debugf("#rmr_service.SendResponse - Going to send message: %#v\n", response)
- r.SendRmrMessage(response)
+ if err := r.SendRmrMessage(response); err != nil {
+ r.Config.Logger.Errorf("#rmr_service.SendResponse - error: %#v\n", err)
+ }
}
}