control/rcControl.go

   1 package control\r
   2 \r
   3 import (\r
   4         "errors"\r
   5         "fmt"\r
   6         "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"\r
   7         "gerrit.o-ran-sc.org/r/ric-app/rc/protocol/grpc/ricmsgcommrpc/rc"\r
   8         "log"\r
   9         "os"\r
  10         "strconv"\r
  11         "sync"\r
  12         "time"\r
  13 )\r
  14 \r
  15 var (\r
  16         gControlData               *Control\r
  17         gChan_RicControlReq_handle = make(chan *rc.RicControlGrpcReq, 2000) //Make it configurable\r
  18 )\r
  19 \r
  20 func NewControl() Control {\r
  21 \r
  22         file := "/opt/rc.log"\r
  23         logFile, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)\r
  24         if err != nil {\r
  25                 panic(err)\r
  26         }\r
  27         log.SetOutput(logFile)\r
  28         log.SetPrefix("[qSkipTool]")\r
  29         log.SetFlags(log.LstdFlags | log.Lshortfile | log.LUTC)\r
  30         logLevel := xapp.Config.GetInt("controls.logLevel")\r
  31         xapp.Logger.SetLevel(logLevel)\r
  32 \r
  33         xapp.Logger.Debug("GRPC Server Port = %v ", xapp.Config.GetString("controls.ricHOControlgRpcServerPort"))\r
  34         xapp.Logger.Debug("Log Level = %d ", xapp.Config.GetInt("controls.logLevel"))\r
  35 \r
  36         return Control{5,\r
  37                 make(chan *xapp.RMRParams, 1000), //Make it configurable\r
  38                 make(map[int]bool),\r
  39                 &sync.Mutex{},\r
  40                 0}\r
  41 }\r
  42 \r
  43 func ReadyCB(i interface{}) {\r
  44         gControlData = i.(*Control)\r
  45 \r
  46         go controlLoop()\r
  47 \r
  48         //Start gRPC Server for Receiving messages\r
  49 \r
  50         go StartgRPCRCControlCommServerRoutine()\r
  51         xapp.Logger.Info("StartgRPCRCControlCommServerRoutine done")\r
  52 \r
  53         //To Handle RIC Control Message\r
  54         go StartHandleControlReqRoutine()\r
  55 \r
  56 }\r
  57 \r
  58 func (aControlData *Control) Run() {\r
  59         xapp.SetReadyCB(ReadyCB, aControlData)\r
  60         xapp.Run(aControlData)\r
  61 }\r
  62 \r
  63 func (aControlData *Control) Consume(rp *xapp.RMRParams) (err error) {\r
  64         gControlData.rcChan <- rp\r
  65         return\r
  66 }\r
  67 \r
  68 func (aControlData *Control) rmrSend(params *xapp.RMRParams) (err error) {\r
  69         if !xapp.Rmr.Send(params, false) {\r
  70                 err = errors.New("rmr.Send() failed")\r
  71                 xapp.Logger.Error("Failed to rmrSend to %v", err)\r
  72                 log.Printf("Failed to rmrSend to %v", err)\r
  73         }\r
  74         return\r
  75 }\r
  76 \r
  77 func (aControlData *Control) rmrReplyToSender(params *xapp.RMRParams) (err error) {\r
  78         if !xapp.Rmr.Send(params, true) {\r
  79                 err = errors.New("rmr.Send() failed")\r
  80                 xapp.Logger.Error("Failed to rmrReplyToSender to %v", err)\r
  81                 log.Printf("Failed to rmrReplyToSender to %v", err)\r
  82         }\r
  83         return\r
  84 }\r
  85 \r
  86 func controlLoop() {\r
  87         for {\r
  88                 msg := <-gControlData.rcChan\r
  89                 xapp.Logger.Debug("Received message type: %d", msg.Mtype)\r
  90                 log.Printf("Received message type: %d", msg.Mtype)\r
  91                 switch msg.Mtype {\r
  92                 case 12041:\r
  93                         go HandleControlResponse(msg)\r
  94                 case 12042:\r
  95                         go HandleControlFailure(msg)\r
  96                 default:\r
  97                         err := errors.New("Message Type " + strconv.Itoa(msg.Mtype) + " is discarded")\r
  98                         xapp.Logger.Error("Unknown message type: %v", err)\r
  99                         log.Printf("Unknown message type: %v", err)\r
 100                 }\r
 101         }\r
 102 }\r
 103 \r
 104 func StartHandleControlReqRoutine() {\r
 105 \r
 106         log.Printf("Starting Go Routine for Handling GRPC RIC Control msg ")\r
 107         xapp.Logger.Info("Starting Go Routine for Handling GRPC RIC Control msg ")\r
 108         for {\r
 109                 _, ok := <-gChan_RicControlReq_handle\r
 110                 if ok == false {\r
 111                         xapp.Logger.Error("Invalid grpc request received, dont process further")\r
 112                         break\r
 113                 }\r
 114                 HandlegRPCRICControlMsgReq(<-gChan_RicControlReq_handle)\r
 115         }\r
 116         xapp.Logger.Debug("StartHandleControlReqRoutine Done")\r
 117 }\r
 118 \r
 119 func HandlegRPCRICControlMsgReq(aPtrRicControlGrpcReq *rc.RicControlGrpcReq) {\r
 120 \r
 121         lRicHoControlMsg := RicHoControlMsg{}\r
 122         lRicHoControlMsg.RicControlGrpcReqPtr = aPtrRicControlGrpcReq\r
 123 \r
 124         lUEID := lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID\r
 125         xapp.Logger.Debug("HandlegRPCRICControlMsgReq UEID = %s ", lUEID)\r
 126         //Mandatory parameters validation\r
 127         if lRicHoControlMsg.RicControlGrpcReqPtr.E2NodeID == "" ||\r
 128                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID == "" ||\r
 129                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID == "" ||\r
 130                 lRicHoControlMsg.RicControlGrpcReqPtr.PlmnID == "" ||\r
 131                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlActionId < 0 ||\r
 132                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlStyle < 0 ||\r
 133                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal < 0 ||\r
 134                 lRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID < 0 ||\r
 135                 lRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId < 0 {\r
 136                 xapp.Logger.Error("Mandaroty parameters missing, dont send control request ")\r
 137                 return\r
 138         }\r
 139 \r
 140         lRicHoControlMsg.GetSequenceNumber()\r
 141 \r
 142         go lRicHoControlMsg.SendRicControlRequest(lRicHoControlMsg.GetSequenceNumber())\r
 143 \r
 144         return\r
 145 }\r
 146 \r
 147 func (aRicHoControlMsg *RicHoControlMsg) GetSequenceNumber() int {\r
 148 \r
 149         //Incrementing the RIC Requestor Instance Id to make the request unique and traceable.\r
 150         gControlData.eventRicControlReqExpiredMu.Lock()\r
 151         gControlData.ricRequestInstanceID = gControlData.ricRequestInstanceID + 1\r
 152         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 153 \r
 154         return gControlData.ricRequestInstanceID\r
 155 }\r
 156 \r
 157 func (aRicHoControlMsg *RicHoControlMsg) setEventRicControlCreateExpiredTimer(aSeqNum int) {\r
 158 \r
 159         gControlData.eventRicControlReqExpiredMu.Lock()\r
 160         gControlData.eventRicControlReqExpiredMap[aSeqNum] = false\r
 161         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 162 \r
 163         timer := time.NewTimer(time.Duration(gControlData.eventRicControlReqTimePeriod) * time.Second)\r
 164         go func(t *time.Timer) {\r
 165                 defer t.Stop()\r
 166                 xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: Waiting for RIC_CONTROL_RESP...", aSeqNum)\r
 167                 log.Printf("RIC_CONTROL_REQ[%s]: Waiting for RIC_CONTROL_RESP...", aSeqNum)\r
 168                 for {\r
 169                         select {\r
 170                         case <-t.C:\r
 171                                 gControlData.eventRicControlReqExpiredMu.Lock()\r
 172                                 isResponsed := gControlData.eventRicControlReqExpiredMap[aSeqNum]\r
 173                                 delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)\r
 174                                 gControlData.eventRicControlReqExpiredMu.Unlock()\r
 175                                 if !isResponsed {\r
 176                                         xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: RIC Event Create Timer experied!", aSeqNum)\r
 177                                         log.Printf("RIC_CONTROL_REQ[%s]: RIC Event Create Timer experied!", aSeqNum)\r
 178                                         //Send ErrorIndication message on Timeout\r
 179                                         return\r
 180                                 }\r
 181                         default:\r
 182                                 gControlData.eventRicControlReqExpiredMu.Lock()\r
 183                                 flag := gControlData.eventRicControlReqExpiredMap[aSeqNum]\r
 184                                 if flag {\r
 185                                         delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)\r
 186                                         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 187                                         xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: RIC Event Create Timer canceled!", aSeqNum)\r
 188                                         log.Printf("RIC_CONTROL_REQ[%s]: RIC Event Create Timer canceled!", aSeqNum)\r
 189                                         return\r
 190                                 } else {\r
 191                                         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 192                                 }\r
 193                         }\r
 194                         time.Sleep(100 * time.Millisecond)\r
 195                 }\r
 196         }(timer)\r
 197 }\r
 198 func (aRicHoControlMsg *RicHoControlMsg) SendRicControlRequest(aRequestSN int) (err error) {\r
 199         var e2ap *E2ap\r
 200         var e2sm *E2sm\r
 201 \r
 202         xapp.Logger.Info("SendRicControlRequest Enter for RanName = %s", aRicHoControlMsg.RicControlGrpcReqPtr.RanName)\r
 203 \r
 204         if aRicHoControlMsg.RicControlGrpcReqPtr == nil {\r
 205                 return err\r
 206         }\r
 207 \r
 208         var lRicControlStyleType int64 = aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlStyle\r
 209         var lRicControlActionID int64 = aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlActionId\r
 210         lUEID := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID\r
 211 \r
 212         lUeIdBuf := []byte(aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 213 \r
 214         xapp.Logger.Debug("UEID:%s, lUeIdBuf: %v", aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID, lUeIdBuf)\r
 215 \r
 216         var lRicControlHeader []byte = make([]byte, 256) //Check the Size\r
 217         lRicControlHeaderEncoded, err := e2sm.SetRicControlHeader(lRicControlHeader, lUeIdBuf, lRicControlStyleType, lRicControlActionID)\r
 218         if err != nil {\r
 219                 xapp.Logger.Error("SetRicControlHeader Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 220                 log.Printf("SetRicControlHeader Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 221                 return err\r
 222         } else {\r
 223                 xapp.Logger.Info("SetRicControlHeader is success: %x", lRicControlHeaderEncoded)\r
 224                 fmt.Fprintf(os.Stderr, "Encoded RIC Control Header PDU:\n")\r
 225                 for i := 0; i < len(lRicControlHeaderEncoded); i++ {\r
 226                         fmt.Fprintf(os.Stderr, " %02x", lRicControlHeaderEncoded[i])\r
 227                 }\r
 228                 fmt.Fprintf(os.Stderr, "\n")\r
 229         }\r
 230 \r
 231         var lTargetPrimaryCell int64 = RIC_CONTROL_TARGET_PRIMARY_CELL\r
 232         var lTargetCell int64 = RIC_CONTROL_TARGET_CELL\r
 233         var lNrCGIOrECGI int64 = RIC_CONTROL_CGI_TYPE\r
 234 \r
 235         lNrOrEUtraCellType := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal\r
 236         lTargetCellVal := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID\r
 237         lTargetCellValBuf := []byte(lTargetCellVal)\r
 238 \r
 239         var lRicControlMessage []byte = make([]byte, 1024) \r
 240         lRicControlMessageEncoded, err := e2sm.SetRicControlMessage(lRicControlMessage, lTargetPrimaryCell, lTargetCell, lNrCGIOrECGI, int64(lNrOrEUtraCellType), lTargetCellValBuf)\r
 241         if err != nil {\r
 242                 xapp.Logger.Error("SetRicControlMessage Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 243                 log.Printf("SetRicControlMessage Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 244                 return err\r
 245         } else {\r
 246                 xapp.Logger.Debug("SetRicControlMessage is success: %x", lRicControlMessageEncoded)\r
 247                 fmt.Fprintf(os.Stderr, "Encoded RIC Control Message PDU:\n")\r
 248                 for i := 0; i < len(lRicControlMessageEncoded); i++ {\r
 249                         fmt.Fprintf(os.Stderr, " %02x", lRicControlMessageEncoded[i])\r
 250                 }\r
 251                 fmt.Fprintf(os.Stderr, "\n")\r
 252         }\r
 253 \r
 254         lParams := &xapp.RMRParams{}\r
 255         lParams.Mtype = 12040 //RIC_CONTROL_REQ\r
 256         lParams.SubId = -1\r
 257 \r
 258         var lRequestorId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID)\r
 259         var lFuncId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId)\r
 260 \r
 261         lParams.Payload = make([]byte, 2048)\r
 262         lParams.Payload, err = e2ap.SetRicControlRequestPayload(lParams.Payload, lRequestorId, uint16(aRequestSN), lFuncId,\r
 263                 lRicControlHeaderEncoded, lRicControlMessageEncoded)\r
 264         if err != nil {\r
 265                 xapp.Logger.Error("SetRicControlRequestPayload Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 266                 log.Printf("SetRicControlRequestPayload Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 267                 return err\r
 268         } else {\r
 269                 xapp.Logger.Debug("Encoding RicControlRequestPayload is success. UEID: %s, Payload: %x", lUEID, lParams.Payload)\r
 270                 fmt.Fprintf(os.Stderr, "Encoded RIC Control Req PDU:\n")\r
 271                 for i := 0; i < len(lParams.Payload); i++ {\r
 272                         fmt.Fprintf(os.Stderr, " %02x", lParams.Payload[i])\r
 273                 }\r
 274                 fmt.Fprintf(os.Stderr, "\n")\r
 275         }\r
 276 \r
 277         valEnbId := aRicHoControlMsg.RicControlGrpcReqPtr.E2NodeID\r
 278         valRanName := aRicHoControlMsg.RicControlGrpcReqPtr.RanName\r
 279         valPlmnId := aRicHoControlMsg.RicControlGrpcReqPtr.PlmnID\r
 280         lParams.Meid = &xapp.RMRMeid{PlmnID: valPlmnId, EnbID: valEnbId, RanName: valRanName}\r
 281 \r
 282         xapp.Logger.Debug("The RIC Control RMR message to be sent is with MsgType:%d  SubId=%d, lParams.Meid: %v, UEID: %s", lParams.Mtype, lParams.SubId, lParams.Meid, lUEID)\r
 283 \r
 284         xapp.Logger.Debug("Sending RIC Control message to RanName: %s, UEID: %s  ", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)\r
 285 \r
 286         err = gControlData.rmrSend(lParams)\r
 287         if err != nil {\r
 288                 xapp.Logger.Error("Failed to send RIC_CONTROL_REQ: %v", err)\r
 289                 log.Printf("Failed to send RIC_CONTROL_REQ: %v", err)\r
 290                 return err\r
 291         }\r
 292 \r
 293         xapp.Logger.Info("Sending RIC Control message to RanName: %s, UEID: %s  Success", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)\r
 294 \r
 295         aRicHoControlMsg.setEventRicControlCreateExpiredTimer(aRequestSN) //TODO check if this is required as we are not expecting Control ACK\r
 296 \r
 297         return nil\r
 298 }\r
 299 \r
 300 func HandleControlResponse(params *xapp.RMRParams) (err error) {\r
 301         xapp.Logger.Debug("The SubId in RIC_CONTROL_RESP is %d", params.SubId)\r
 302         log.Printf("The SubId in RIC_CONTROL_RESP is %d", params.SubId)\r
 303 \r
 304         return nil\r
 305 }\r
 306 \r
 307 func HandleControlFailure(params *xapp.RMRParams) (err error) {\r
 308 \r
 309         xapp.Logger.Debug("The SubId in RIC_CONTROL_FAILURE is %d", params.SubId)\r
 310         log.Printf("The SubId in RIC_CONTROL_FAILURE is %d", params.SubId)\r
 311 \r
 312         return nil\r
 313 }\r