E2Manager/controllers/nodeb_controller.go

   1 //
   2 // Copyright 2019 AT&T Intellectual Property
   3 // Copyright 2019 Nokia
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the "License");
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //      http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17
  18 package controllers
  19
  20 import (
  21         "e2mgr/logger"
  22         "e2mgr/models"
  23         "e2mgr/rNibWriter"
  24         "e2mgr/services"
  25         "e2mgr/utils"
  26         "encoding/json"
  27         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/common"
  28         "gerrit.o-ran-sc.org/r/ric-plt/nodeb-rnib.git/reader"
  29         "github.com/golang/protobuf/jsonpb"
  30         "github.com/gorilla/mux"
  31         "net/http"
  32         "time"
  33 )
  34
  35 const (
  36         validationErrorCode       int = 402
  37         notFoundErrorCode         int = 404
  38         internalErrorCode         int = 501
  39         validationFailedMessage       = "Validation failed"
  40         notFoundErrorMessage          = "Resource not found"
  41         internalErrorMessage          = "Internal Server Error. Please try again later"
  42 )
  43
  44 var messageChannel chan *models.E2RequestMessage
  45 var errorChannel chan error
  46
  47 type INodebController interface {
  48         GetNodebIdList (writer http.ResponseWriter, request *http.Request)
  49         GetNodeb(writer http.ResponseWriter, request *http.Request)
  50         HandleHealthCheckRequest(writer http.ResponseWriter, request *http.Request)
  51 }
  52
  53 type NodebController struct {
  54         rmrService         *services.RmrService
  55         Logger             *logger.Logger
  56         rnibReaderProvider func() reader.RNibReader
  57         rnibWriterProvider func() rNibWriter.RNibWriter
  58 }
  59
  60 func NewNodebController(logger *logger.Logger, rmrService *services.RmrService, rnibReaderProvider func() reader.RNibReader, rnibWriterProvider func() rNibWriter.RNibWriter) *NodebController {
  61         messageChannel = make(chan *models.E2RequestMessage)
  62         errorChannel = make(chan error)
  63         return &NodebController{
  64                 rmrService:         rmrService,
  65                 Logger:             logger,
  66                 rnibReaderProvider: rnibReaderProvider,
  67                 rnibWriterProvider: rnibWriterProvider,
  68         }
  69 }
  70
  71 func (rc NodebController) GetNodebIdList (writer http.ResponseWriter, request *http.Request) {
  72         startTime := time.Now()
  73         rnibReaderService := services.NewRnibReaderService(rc.rnibReaderProvider)
  74         nodebIdList, rnibError := rnibReaderService.GetNodebIdList()
  75
  76         if rnibError != nil {
  77                 rc.Logger.Errorf("%v", rnibError);
  78                 httpStatusCode, errorCode, errorMessage := rnibErrorToHttpError(rnibError)
  79                 handleErrorResponse(rc.Logger, httpStatusCode, errorCode, errorMessage, writer, startTime)
  80                 return;
  81         }
  82
  83         pmList := utils.ConvertNodebIdListToProtoMessageList(nodebIdList)
  84         result, err := utils.MarshalProtoMessageListToJsonArray(pmList)
  85
  86         if err != nil {
  87                 rc.Logger.Errorf("%v", err);
  88                 handleErrorResponse(rc.Logger, http.StatusInternalServerError, internalErrorCode, internalErrorMessage, writer, startTime)
  89                 return;
  90         }
  91
  92         writer.Header().Set("Content-Type", "application/json")
  93         rc.Logger.Infof("[E2 Manager -> Client] #nodeb_controller.GetNodebIdList - response: %s", result)
  94         writer.Write([]byte(result))
  95 }
  96
  97 func (rc NodebController) GetNodeb(writer http.ResponseWriter, request *http.Request) {
  98         startTime := time.Now()
  99         vars := mux.Vars(request)
 100         ranName := vars["ranName"]
 101         // WAS: respondingNode, rnibError := reader.GetRNibReader().GetNodeb(ranName)
 102         rnibReaderService := services.NewRnibReaderService(rc.rnibReaderProvider)
 103         respondingNode, rnibError := rnibReaderService.GetNodeb(ranName)
 104         if rnibError != nil {
 105                 rc.Logger.Errorf("%v", rnibError)
 106                 httpStatusCode, errorCode, errorMessage := rnibErrorToHttpError(rnibError)
 107                 handleErrorResponse(rc.Logger, httpStatusCode, errorCode, errorMessage, writer, startTime)
 108                 return
 109         }
 110
 111         m := jsonpb.Marshaler{}
 112         result, err := m.MarshalToString(respondingNode)
 113
 114         if err != nil {
 115                 rc.Logger.Errorf("%v", err)
 116                 handleErrorResponse(rc.Logger, http.StatusInternalServerError, internalErrorCode, internalErrorMessage, writer, startTime)
 117                 return
 118         }
 119
 120         writer.Header().Set("Content-Type", "application/json")
 121         rc.Logger.Infof("[E2 Manager -> Client] #nodeb_controller.GetNodeb - response: %s", result)
 122         writer.Write([]byte(result))
 123 }
 124
 125 func (rc NodebController) HandleHealthCheckRequest(writer http.ResponseWriter, request *http.Request) {
 126         //fmt.Println("[X-APP -> Client] #HandleHealthCheckRequest - http status: 200")
 127         writer.WriteHeader(http.StatusOK)
 128 }
 129
 130 func handleErrorResponse(logger *logger.Logger, httpStatus int, errorCode int, errorMessage string, writer http.ResponseWriter, startTime time.Time) {
 131         errorResponseDetails := models.ErrorResponse{errorCode, errorMessage}
 132         errorResponse, _ := json.Marshal(errorResponseDetails)
 133         printHandlingRequestElapsedTimeInMs(logger, startTime)
 134         logger.Infof("[E2 Manager -> Client] #nodeb_controller.handleErrorResponse - http status: %d, error response: %+v", httpStatus, errorResponseDetails)
 135         writer.Header().Set("Content-Type", "application/json")
 136         writer.WriteHeader(httpStatus)
 137         _, err := writer.Write(errorResponse)
 138
 139         if err != nil {
 140                 logger.Errorf("#nodeb_controller.handleErrorResponse - Cannot send response. writer:%v", writer)
 141         }
 142 }
 143
 144 func printHandlingRequestElapsedTimeInMs(logger *logger.Logger, startTime time.Time) {
 145         logger.Infof("Summary: #nodeb_controller.printElapsedTimeInMs - Elapsed time for handling request from client to E2 termination: %f ms",
 146                 float64(time.Since(startTime))/float64(time.Millisecond))
 147 }
 148
 149 func rnibErrorToHttpError(rnibError error) (int, int, string) {
 150         switch rnibError.(type) {
 151         case *common.ResourceNotFoundError:
 152                 return http.StatusNotFound, notFoundErrorCode, notFoundErrorMessage
 153         case *common.InternalError:
 154                 return http.StatusInternalServerError, internalErrorCode, internalErrorMessage
 155         case *common.ValidationError:
 156                 return http.StatusBadRequest, validationErrorCode, validationFailedMessage
 157         default:
 158                 return http.StatusInternalServerError, internalErrorCode, internalErrorMessage
 159         }
 160 }