httpMsgHandlerProvider := httpmsghandlerprovider.NewIncomingRequestHandlerProvider(logger, rmrSender, config, rnibDataService, ranSetupManager, e2tInstancesManager)
rootController := controllers.NewRootController(rnibDataService)
nodebController := controllers.NewNodebController(logger, httpMsgHandlerProvider)
- _ = httpserver.Run(logger, config.Http.Port, rootController, nodebController)
+ e2tController := controllers.NewE2TController(logger, httpMsgHandlerProvider)
+ _ = httpserver.Run(logger, config.Http.Port, rootController, nodebController, e2tController)
}
\ No newline at end of file
--- /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 controllers
+
+import (
+ "e2mgr/e2managererrors"
+ "e2mgr/logger"
+ "e2mgr/models"
+ "e2mgr/providers/httpmsghandlerprovider"
+ "encoding/json"
+ "net/http"
+ "net/http/httputil"
+ "strings"
+)
+
+type IE2TController interface {
+ GetE2TInstances(writer http.ResponseWriter, r *http.Request)
+}
+
+type E2TController struct {
+ logger *logger.Logger
+ handlerProvider *httpmsghandlerprovider.IncomingRequestHandlerProvider
+}
+
+func NewE2TController(logger *logger.Logger, handlerProvider *httpmsghandlerprovider.IncomingRequestHandlerProvider) *E2TController {
+ return &E2TController{
+ logger: logger,
+ handlerProvider: handlerProvider,
+ }
+}
+
+func (c *E2TController) GetE2TInstances(writer http.ResponseWriter, r *http.Request) {
+ c.logger.Infof("[Client -> E2 Manager] #E2TController.GetE2TInstances - request: %v", c.prettifyRequest(r))
+ c.handleRequest(writer, &r.Header, httpmsghandlerprovider.GetE2TInstancesRequest, nil, false)
+}
+
+func (c *E2TController) handleRequest(writer http.ResponseWriter, header *http.Header, requestName httpmsghandlerprovider.IncomingRequest, request models.Request, validateHeader bool) {
+
+ handler, err := c.handlerProvider.GetHandler(requestName)
+
+ if err != nil {
+ c.handleErrorResponse(err, writer)
+ return
+ }
+
+ response, err := handler.Handle(request)
+
+ if err != nil {
+ c.handleErrorResponse(err, writer)
+ return
+ }
+
+ if response == nil {
+ writer.WriteHeader(http.StatusNoContent)
+ c.logger.Infof("[E2 Manager -> Client] #E2TController.handleRequest - status response: %v", http.StatusNoContent)
+ return
+ }
+
+ result, err := response.Marshal()
+
+ if err != nil {
+ c.handleErrorResponse(err, writer)
+ return
+ }
+
+ c.logger.Infof("[E2 Manager -> Client] #E2TController.handleRequest - response: %s", result)
+ writer.Header().Set("Content-Type", "application/json")
+ writer.Write(result)
+}
+
+func (c *E2TController) handleErrorResponse(err error, writer http.ResponseWriter) {
+
+ var errorResponseDetails models.ErrorResponse
+ var httpError int
+
+ if err != nil {
+ switch err.(type) {
+ case *e2managererrors.RnibDbError:
+ e2Error, _ := err.(*e2managererrors.RnibDbError)
+ errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message}
+ httpError = http.StatusInternalServerError
+ default:
+ e2Error := e2managererrors.NewInternalError()
+ errorResponseDetails = models.ErrorResponse{Code: e2Error.Code, Message: e2Error.Message}
+ httpError = http.StatusInternalServerError
+ }
+ }
+
+ errorResponse, _ := json.Marshal(errorResponseDetails)
+
+ c.logger.Errorf("[E2 Manager -> Client] #E2TController.handleErrorResponse - http status: %d, error response: %+v", httpError, errorResponseDetails)
+
+ writer.Header().Set("Content-Type", "application/json")
+ writer.WriteHeader(httpError)
+ _, err = writer.Write(errorResponse)
+
+ if err != nil {
+ c.logger.Errorf("#E2TController.handleErrorResponse - Cannot send response. writer:%v", writer)
+ }
+}
+
+func (c *E2TController) prettifyRequest(request *http.Request) string {
+ dump, _ := httputil.DumpRequest(request, true)
+ requestPrettyPrint := strings.Replace(string(dump), "\r\n", " ", -1)
+ return strings.Replace(requestPrettyPrint, "\n", "", -1)
+}
c.logger.Infof("[E2 Manager -> Client] #NodebController.handleRequest - response: %s", result)
writer.Header().Set("Content-Type", "application/json")
- writer.Write([]byte(result))
+ writer.Write(result)
}
func (c *NodebController) validateRequestHeader(header *http.Header) error {
--- /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 httpmsghandlers
+
+import (
+ "e2mgr/logger"
+ "e2mgr/managers"
+ "e2mgr/models"
+)
+
+type GetE2TInstancesRequestHandler struct {
+ e2tInstancesManager managers.IE2TInstancesManager
+ logger *logger.Logger
+}
+
+func NewGetE2TInstancesRequestHandler(logger *logger.Logger, e2tInstancesManager managers.IE2TInstancesManager) *GetE2TInstancesRequestHandler {
+ return &GetE2TInstancesRequestHandler{
+ logger: logger,
+ e2tInstancesManager: e2tInstancesManager,
+ }
+}
+
+func (h *GetE2TInstancesRequestHandler) Handle(request models.Request) (models.IResponse, error) {
+
+ e2tInstances, err := h.e2tInstancesManager.GetE2TInstances()
+
+ if err != nil {
+ h.logger.Errorf("#GetE2TInstancesRequestHandler.Handle - Error fetching E2T instances from rNib: %s", err)
+ return nil, err
+ }
+
+ mapped := make([]*models.E2TInstanceResponseModel, len(e2tInstances))
+
+ for i, v := range e2tInstances {
+ mapped[i] = models.NewE2TInstanceResponseModel(v.Address, v.AssociatedRanList)
+ }
+
+ return models.E2TInstancesResponse(mapped), nil
+}
--- /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 httpmsghandlers
+
+import (
+ "e2mgr/configuration"
+ "e2mgr/managers"
+ "e2mgr/mocks"
+ "e2mgr/models"
+ "e2mgr/services"
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/entities"
+ "github.com/pkg/errors"
+ "github.com/stretchr/testify/assert"
+
+ "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
+ "testing"
+)
+
+const E2TAddress2 = "10.0.2.15:3213"
+
+func setupGetE2TInstancesListRequestHandlerTest(t *testing.T) (*GetE2TInstancesRequestHandler, *mocks.RnibReaderMock) {
+ log := initLog(t)
+ config := &configuration.Configuration{RnibRetryIntervalMs: 10, MaxRnibConnectionAttempts: 3}
+ readerMock := &mocks.RnibReaderMock{}
+ rnibDataService := services.NewRnibDataService(log, config, readerMock, nil)
+ e2tInstancesManager := managers.NewE2TInstancesManager(rnibDataService, log)
+ handler := NewGetE2TInstancesRequestHandler(log, e2tInstancesManager)
+ return handler, readerMock
+}
+
+func TestGetE2TInstancesFailure(t *testing.T) {
+ handler, rnibReaderMock := setupGetE2TInstancesListRequestHandlerTest(t)
+ rnibReaderMock.On("GetE2TAddresses").Return([]string{}, common.NewInternalError(errors.New("error")))
+ _, err := handler.Handle(nil)
+ assert.NotNil(t, err)
+}
+
+func TestGetE2TInstancesNoInstances(t *testing.T) {
+ handler, rnibReaderMock := setupGetE2TInstancesListRequestHandlerTest(t)
+ rnibReaderMock.On("GetE2TAddresses").Return([]string{}, nil)
+ resp, err := handler.Handle(nil)
+ assert.Nil(t, err)
+ assert.IsType(t, models.E2TInstancesResponse{}, resp)
+ assert.Len(t, resp, 0)
+}
+
+func TestGetE2TInstancesSuccess(t *testing.T) {
+ handler, rnibReaderMock := setupGetE2TInstancesListRequestHandlerTest(t)
+
+ e2tAddresses := []string{E2TAddress, E2TAddress2}
+ rnibReaderMock.On("GetE2TAddresses").Return(e2tAddresses, nil)
+ e2tInstance := entities.E2TInstance{Address: E2TAddress, AssociatedRanList: []string{"test1", "test2"}}
+ e2tInstance2 := entities.E2TInstance{Address: E2TAddress2, AssociatedRanList: []string{"test3", "test4", "test5"}}
+
+ rnibReaderMock.On("GetE2TInstances", e2tAddresses).Return([]*entities.E2TInstance{&e2tInstance, &e2tInstance2}, nil)
+ resp, err := handler.Handle(nil)
+ assert.Nil(t, err)
+ assert.IsType(t, models.E2TInstancesResponse{}, resp)
+ assert.Len(t, resp, 2)
+}
"net/http"
)
-func Run(log *logger.Logger, port int, controller controllers.IRootController, newController controllers.INodebController) error {
+func Run(log *logger.Logger, port int, rootController controllers.IRootController, nodebController controllers.INodebController, e2tController controllers.IE2TController) error {
router := mux.NewRouter();
- initializeRoutes(router, controller, newController)
+ initializeRoutes(router, rootController, nodebController, e2tController)
addr := fmt.Sprintf(":%d", port)
return err
}
-func initializeRoutes(router *mux.Router, rootController controllers.IRootController, nodebController controllers.INodebController) {
+func initializeRoutes(router *mux.Router, rootController controllers.IRootController, nodebController controllers.INodebController, e2tController controllers.IE2TController) {
r := router.PathPrefix("/v1").Subrouter()
r.HandleFunc("/health", rootController.HandleHealthCheckRequest).Methods("GET")
rr.HandleFunc("/{ranName}/reset", nodebController.X2Reset).Methods("PUT")
rr.HandleFunc("/x2-setup", nodebController.X2Setup).Methods("POST")
rr.HandleFunc("/endc-setup", nodebController.EndcSetup).Methods("POST")
+
+ rrr := r.PathPrefix("/e2t").Subrouter()
+ rrr.HandleFunc("/list", e2tController.GetE2TInstances).Methods("GET")
}
"time"
)
-func setupRouterAndMocks() (*mux.Router, *mocks.ControllerMock, *mocks.NodebControllerMock) {
- controllerMock := &mocks.ControllerMock{}
- controllerMock.On("Shutdown").Return(nil)
- controllerMock.On("X2Reset").Return(nil)
- controllerMock.On("X2Setup").Return(nil)
- controllerMock.On("EndcSetup").Return(nil)
- controllerMock.On("GetNodeb").Return(nil)
- controllerMock.On("GetNodebIdList").Return(nil)
-
-
+func setupRouterAndMocks() (*mux.Router, *mocks.RootControllerMock, *mocks.NodebControllerMock, *mocks.E2TControllerMock) {
+ rootControllerMock := &mocks.RootControllerMock{}
+ rootControllerMock.On("HandleHealthCheckRequest").Return(nil)
nodebControllerMock := &mocks.NodebControllerMock{}
+ nodebControllerMock.On("Shutdown").Return(nil)
+ nodebControllerMock.On("X2Reset").Return(nil)
+ nodebControllerMock.On("X2Setup").Return(nil)
+ nodebControllerMock.On("EndcSetup").Return(nil)
+ nodebControllerMock.On("GetNodeb").Return(nil)
nodebControllerMock.On("GetNodebIdList").Return(nil)
- nodebControllerMock.On("GetNodeb").Return(nil) // TODO: remove
- nodebControllerMock.On("HandleHealthCheckRequest").Return(nil)
+
+ e2tControllerMock := &mocks.E2TControllerMock{}
+
+ e2tControllerMock.On("GetE2TInstances").Return(nil)
router := mux.NewRouter()
- initializeRoutes(router, nodebControllerMock, controllerMock)
- return router, controllerMock, nodebControllerMock
+ initializeRoutes(router, rootControllerMock, nodebControllerMock, e2tControllerMock)
+ return router, rootControllerMock, nodebControllerMock, e2tControllerMock
}
func TestRoutePostEndcSetup(t *testing.T) {
- router, controllerMock, _ := setupRouterAndMocks()
+ router, _, nodebControllerMock, _ := setupRouterAndMocks()
req, err := http.NewRequest("POST", "/v1/nodeb/endc-setup", nil)
if err != nil {
rr := httptest.NewRecorder()
router.ServeHTTP(rr, req)
- controllerMock.AssertNumberOfCalls(t,"EndcSetup", 1)
+ nodebControllerMock.AssertNumberOfCalls(t, "EndcSetup", 1)
}
func TestRoutePostX2Setup(t *testing.T) {
- router, controllerMock, _ := setupRouterAndMocks()
+ router, _, nodebControllerMock, _ := setupRouterAndMocks()
req, err := http.NewRequest("POST", "/v1/nodeb/x2-setup", nil)
if err != nil {
rr := httptest.NewRecorder()
router.ServeHTTP(rr, req)
- controllerMock.AssertNumberOfCalls(t,"X2Setup", 1)
+ nodebControllerMock.AssertNumberOfCalls(t, "X2Setup", 1)
}
func TestRouteGetNodebIds(t *testing.T) {
- router, controllerMock, _ := setupRouterAndMocks()
+ router, _, nodebControllerMock, _ := setupRouterAndMocks()
req, err := http.NewRequest("GET", "/v1/nodeb/ids", nil)
if err != nil {
rr := httptest.NewRecorder()
router.ServeHTTP(rr, req)
- controllerMock.AssertNumberOfCalls(t, "GetNodebIdList", 1)
+ nodebControllerMock.AssertNumberOfCalls(t, "GetNodebIdList", 1)
}
func TestRouteGetNodebRanName(t *testing.T) {
- router, controllerMock,_ := setupRouterAndMocks()
+ router, _, nodebControllerMock, _ := setupRouterAndMocks()
req, err := http.NewRequest("GET", "/v1/nodeb/ran1", nil)
if err != nil {
assert.Equal(t, http.StatusOK, rr.Code, "handler returned wrong status code")
assert.Equal(t, "ran1", rr.Body.String(), "handler returned wrong body")
- controllerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
+ nodebControllerMock.AssertNumberOfCalls(t, "GetNodeb", 1)
}
func TestRouteGetHealth(t *testing.T) {
- router, _, nodebControllerMock := setupRouterAndMocks()
+ router, rootControllerMock, _, _ := setupRouterAndMocks()
req, err := http.NewRequest("GET", "/v1/health", nil)
if err != nil {
rr := httptest.NewRecorder()
router.ServeHTTP(rr, req)
- nodebControllerMock.AssertNumberOfCalls(t, "HandleHealthCheckRequest", 1)
+ rootControllerMock.AssertNumberOfCalls(t, "HandleHealthCheckRequest", 1)
}
func TestRoutePutNodebShutdown(t *testing.T) {
- router, controllerMock, _ := setupRouterAndMocks()
+ router, _, nodebControllerMock, _ := setupRouterAndMocks()
req, err := http.NewRequest("PUT", "/v1/nodeb/shutdown", nil)
if err != nil {
rr := httptest.NewRecorder()
router.ServeHTTP(rr, req)
- controllerMock.AssertNumberOfCalls(t, "Shutdown", 1)
+ nodebControllerMock.AssertNumberOfCalls(t, "Shutdown", 1)
}
func TestRoutePutNodebResetRanName(t *testing.T) {
- router, controllerMock, _ := setupRouterAndMocks()
+ router, _, nodebControllerMock, _ := setupRouterAndMocks()
req, err := http.NewRequest("PUT", "/v1/nodeb/ran1/reset", nil)
if err != nil {
assert.Equal(t, http.StatusOK, rr.Code, "handler returned wrong status code")
assert.Equal(t, "ran1", rr.Body.String(), "handler returned wrong body")
- controllerMock.AssertNumberOfCalls(t, "X2Reset", 1)
+ nodebControllerMock.AssertNumberOfCalls(t, "X2Reset", 1)
}
func TestRouteNotFound(t *testing.T) {
- router, _, _ := setupRouterAndMocks()
+ router, _, _,_ := setupRouterAndMocks()
req, err := http.NewRequest("GET", "/v1/no/such/route", nil)
if err != nil {
func TestRunError(t *testing.T) {
log := initLog(t)
- err := Run(log, 1234567, &mocks.NodebControllerMock{}, &mocks.ControllerMock{})
+ err := Run(log, 1234567, &mocks.RootControllerMock{}, &mocks.NodebControllerMock{}, &mocks.E2TControllerMock{})
assert.NotNil(t, err)
}
func TestRun(t *testing.T) {
log := initLog(t)
- _, controllerMock, nodebControllerMock := setupRouterAndMocks()
- go Run(log,11223, nodebControllerMock, controllerMock)
+ _, rootControllerMock, nodebControllerMock, e2tControllerMock := setupRouterAndMocks()
+ go Run(log, 11223, rootControllerMock, nodebControllerMock, e2tControllerMock)
time.Sleep(time.Millisecond * 100)
resp, err := http.Get("http://localhost:11223/v1/health")
t.Errorf("#initLog test - failed to initialize logger, error: %s", err)
}
return log
-}
\ No newline at end of file
+}
if !ok {
m.logger.Errorf("#E2TInstancesManager.GetE2TInstancesNoLogs - Failed retrieving E2T addresses. error: %s", err)
+ return nil, e2managererrors.NewRnibDbError()
}
- return nil, err
+
+ return []*entities.E2TInstance{}, nil
}
if len(e2tAddresses) == 0 {
e2tAddresses, err := m.rnibDataService.GetE2TAddresses()
if err != nil {
- m.logger.Errorf("#E2TInstancesManager.GetE2TInstances - Failed retrieving E2T addresses. error: %s", err)
- return nil, err
+
+ _, ok := err.(*common.ResourceNotFoundError)
+
+ if !ok {
+ m.logger.Errorf("#E2TInstancesManager.GetE2TInstances - Failed retrieving E2T addresses. error: %s", err)
+ return nil, e2managererrors.NewRnibDbError()
+ }
+
+ m.logger.Infof("#E2TInstancesManager.GetE2TInstances - Empty E2T addresses list")
+ return []*entities.E2TInstance{}, nil
}
if len(e2tAddresses) == 0 {
if err != nil {
m.logger.Errorf("#E2TInstancesManager.GetE2TInstances - Failed retrieving E2T instances list. error: %s", err)
- return e2tInstances, err
+ return e2tInstances, e2managererrors.NewRnibDbError()
}
if len(e2tInstances) == 0 {
e2tInstances, err := m.GetE2TInstances()
if err != nil {
- return "", e2managererrors.NewRnibDbError()
+ return "", err
}
if len(e2tInstances) == 0 {
+++ /dev/null
-package mocks
-
-import (
- "github.com/gorilla/mux"
- "github.com/stretchr/testify/mock"
- "net/http"
-)
-
-type ControllerMock struct {
- mock.Mock
-}
-
-func (c *ControllerMock) GetNodeb(writer http.ResponseWriter, r *http.Request){
- writer.Header().Set("Content-Type", "application/json")
- writer.WriteHeader(http.StatusOK)
-
- vars := mux.Vars(r)
- ranName := vars["ranName"]
-
- writer.Write([]byte(ranName))
-
- c.Called()
-}
-
-func (c *ControllerMock) GetNodebIdList(writer http.ResponseWriter, r *http.Request){
- c.Called()
-}
-
-
-func (c *ControllerMock) Shutdown(writer http.ResponseWriter, r *http.Request){
- c.Called()
-}
-
-func (c *ControllerMock) X2Reset(writer http.ResponseWriter, r *http.Request){
- writer.Header().Set("Content-Type", "application/json")
- writer.WriteHeader(http.StatusOK)
-
- vars := mux.Vars(r)
- ranName := vars["ranName"]
-
- writer.Write([]byte(ranName))
-
- c.Called()
-}
-
-func (c *ControllerMock) X2Setup(writer http.ResponseWriter, r *http.Request){
- writer.Header().Set("Content-Type", "application/json")
- writer.WriteHeader(http.StatusOK)
-
- c.Called()
-}
-
-func (c *ControllerMock) EndcSetup(writer http.ResponseWriter, r *http.Request){
- writer.Header().Set("Content-Type", "application/json")
- writer.WriteHeader(http.StatusOK)
-
- c.Called()
-}
\ No newline at end of file
--- /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 mocks
+
+import (
+ "github.com/stretchr/testify/mock"
+ "net/http"
+)
+
+type E2TControllerMock struct {
+ mock.Mock
+}
+
+func (m *E2TControllerMock) HandleRequest(writer http.ResponseWriter, request *http.Request) {
+ m.Called()
+}
+
+func (m *E2TControllerMock) GetE2TInstances(writer http.ResponseWriter, request *http.Request) {
+ m.Called()
+}
+++ /dev/null
-package mocks
-
-import (
- "github.com/gorilla/mux"
- "github.com/stretchr/testify/mock"
- "net/http"
-)
-
-type NodebControllerMock struct {
- mock.Mock
-}
-
-func (rc *NodebControllerMock) HandleRequest(writer http.ResponseWriter, request *http.Request) {
- rc.Called()
-}
-
-func (rc *NodebControllerMock) GetNodebIdList (writer http.ResponseWriter, request *http.Request) {
- rc.Called()
-}
-
-func (rc *NodebControllerMock) GetNodeb(writer http.ResponseWriter, request *http.Request) {
- writer.Header().Set("Content-Type", "application/json")
- writer.WriteHeader(http.StatusOK)
-
- vars := mux.Vars(request)
- ranName := vars["ranName"]
-
- writer.Write([]byte(ranName))
-
- rc.Called()
-}
-
-func (rc *NodebControllerMock) HandleHealthCheckRequest(writer http.ResponseWriter, request *http.Request) {
- rc.Called()
-}
--- /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 mocks
+
+import (
+ "github.com/gorilla/mux"
+ "github.com/stretchr/testify/mock"
+ "net/http"
+)
+
+type NodebControllerMock struct {
+ mock.Mock
+}
+
+func (c *NodebControllerMock) GetNodeb(writer http.ResponseWriter, r *http.Request) {
+ writer.Header().Set("Content-Type", "application/json")
+ writer.WriteHeader(http.StatusOK)
+
+ vars := mux.Vars(r)
+ ranName := vars["ranName"]
+
+ writer.Write([]byte(ranName))
+ c.Called()
+}
+
+func (c *NodebControllerMock) GetNodebIdList(writer http.ResponseWriter, r *http.Request) {
+ c.Called()
+}
+
+func (c *NodebControllerMock) Shutdown(writer http.ResponseWriter, r *http.Request) {
+ c.Called()
+}
+
+func (c *NodebControllerMock) X2Reset(writer http.ResponseWriter, r *http.Request) {
+ writer.Header().Set("Content-Type", "application/json")
+ writer.WriteHeader(http.StatusOK)
+
+ vars := mux.Vars(r)
+ ranName := vars["ranName"]
+
+ writer.Write([]byte(ranName))
+
+ c.Called()
+}
+
+func (c *NodebControllerMock) X2Setup(writer http.ResponseWriter, r *http.Request) {
+ writer.Header().Set("Content-Type", "application/json")
+ writer.WriteHeader(http.StatusOK)
+
+ c.Called()
+}
+
+func (c *NodebControllerMock) EndcSetup(writer http.ResponseWriter, r *http.Request) {
+ writer.Header().Set("Content-Type", "application/json")
+ writer.WriteHeader(http.StatusOK)
+
+ c.Called()
+}
--- /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 mocks
+
+import (
+ "github.com/stretchr/testify/mock"
+ "net/http"
+)
+
+type RootControllerMock struct {
+ mock.Mock
+}
+
+func (rc *RootControllerMock) HandleHealthCheckRequest(writer http.ResponseWriter, request *http.Request) {
+ rc.Called()
+}
--- /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 models
+
+import (
+ "e2mgr/e2managererrors"
+ "encoding/json"
+)
+
+type E2TInstancesResponse []*E2TInstanceResponseModel
+
+type E2TInstanceResponseModel struct {
+ E2TAddress string `json:"e2tAddress"`
+ RanNames []string `json:"ranNames"`
+}
+
+func NewE2TInstanceResponseModel(e2tAddress string, ranNames []string) *E2TInstanceResponseModel {
+ return &E2TInstanceResponseModel{
+ E2TAddress: e2tAddress,
+ RanNames: ranNames,
+ }
+}
+
+func (response E2TInstancesResponse) Marshal() ([]byte, error) {
+
+ data, err := json.Marshal(response)
+
+ if err != nil {
+ return nil, e2managererrors.NewInternalError()
+ }
+
+ return data, nil
+
+}
}
}
-func (response *GetNodebIdListResponse) Marshal() (string, error) {
+func (response *GetNodebIdListResponse) Marshal() ([]byte, error) {
pmList := utils.ConvertNodebIdListToProtoMessageList(response.nodebIdList)
result, err := utils.MarshalProtoMessageListToJsonArray(pmList)
if err != nil {
- return "", e2managererrors.NewInternalError();
+ return nil, e2managererrors.NewInternalError();
}
- return result, nil
+ return []byte(result), nil
}
}
}
-func (response *GetNodebResponse) Marshal() (string, error) {
+func (response *GetNodebResponse) Marshal() ([]byte, error) {
m := jsonpb.Marshaler{}
result, err := m.MarshalToString(response.nodebInfo)
if err != nil {
- return "", e2managererrors.NewInternalError()
+ return nil, e2managererrors.NewInternalError()
}
- return result, nil
+ return []byte(result), nil
}
package models
type IResponse interface {
- Marshal() (string, error)
+ Marshal() ([]byte, error)
}
type IncomingRequest string
const (
- ShutdownRequest IncomingRequest = "Shutdown"
- ResetRequest IncomingRequest = "Reset"
- X2SetupRequest IncomingRequest = "X2SetupRequest"
- EndcSetupRequest IncomingRequest = "EndcSetupRequest"
- GetNodebRequest IncomingRequest = "GetNodebRequest"
- GetNodebIdListRequest IncomingRequest = "GetNodebIdListRequest"
+ ShutdownRequest IncomingRequest = "Shutdown"
+ ResetRequest IncomingRequest = "Reset"
+ X2SetupRequest IncomingRequest = "X2SetupRequest"
+ EndcSetupRequest IncomingRequest = "EndcSetupRequest"
+ GetNodebRequest IncomingRequest = "GetNodebRequest"
+ GetNodebIdListRequest IncomingRequest = "GetNodebIdListRequest"
+ GetE2TInstancesRequest IncomingRequest = "GetE2TInstancesRequest"
)
type IncomingRequestHandlerProvider struct {
}
}
-func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager,e2tInstancesManager managers.IE2TInstancesManager) map[IncomingRequest]httpmsghandlers.RequestHandler {
+func initRequestHandlerMap(logger *logger.Logger, rmrSender *rmrsender.RmrSender, config *configuration.Configuration, rNibDataService services.RNibDataService, ranSetupManager *managers.RanSetupManager, e2tInstancesManager managers.IE2TInstancesManager) map[IncomingRequest]httpmsghandlers.RequestHandler {
return map[IncomingRequest]httpmsghandlers.RequestHandler{
- ShutdownRequest: httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService), //TODO change to pointer
- ResetRequest: httpmsghandlers.NewX2ResetRequestHandler(logger, rmrSender, rNibDataService),
- X2SetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, e2tInstancesManager),
- EndcSetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, e2tInstancesManager),
- GetNodebRequest: httpmsghandlers.NewGetNodebRequestHandler(logger, rNibDataService),
- GetNodebIdListRequest: httpmsghandlers.NewGetNodebIdListRequestHandler(logger, rNibDataService),
+ ShutdownRequest: httpmsghandlers.NewDeleteAllRequestHandler(logger, rmrSender, config, rNibDataService), //TODO change to pointer
+ ResetRequest: httpmsghandlers.NewX2ResetRequestHandler(logger, rmrSender, rNibDataService),
+ X2SetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_X2_SETUP_REQUEST, e2tInstancesManager),
+ EndcSetupRequest: httpmsghandlers.NewSetupRequestHandler(logger, rNibDataService, ranSetupManager, entities.E2ApplicationProtocol_ENDC_X2_SETUP_REQUEST, e2tInstancesManager),
+ GetNodebRequest: httpmsghandlers.NewGetNodebRequestHandler(logger, rNibDataService),
+ GetNodebIdListRequest: httpmsghandlers.NewGetNodebIdListRequestHandler(logger, rNibDataService),
+ GetE2TInstancesRequest: httpmsghandlers.NewGetE2TInstancesRequestHandler(logger, e2tInstancesManager),
}
}
Code Review / ric-plt / e2mgr.git / commitdiff