control/rcControl.go

   1 pnackage 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                 HandlegRPCRICControlMsgReq(<-gChan_RicControlReq_handle)\r
 110         }\r
 111         xapp.Logger.Debug("StartHandleControlReqRoutine Done")\r
 112 }\r
 113 \r
 114 func HandlegRPCRICControlMsgReq(aPtrRicControlGrpcReq *rc.RicControlGrpcReq) {\r
 115 \r
 116         lRicHoControlMsg := RicHoControlMsg{}\r
 117         lRicHoControlMsg.RicControlGrpcReqPtr = aPtrRicControlGrpcReq\r
 118 \r
 119         lUEID := lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID\r
 120         xapp.Logger.Debug("HandlegRPCRICControlMsgReq UEID = %s ", lUEID)\r
 121         //Mandatory parameters validation\r
 122         if lRicHoControlMsg.RicControlGrpcReqPtr.E2NodeID == "" ||\r
 123                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID == "" ||\r
 124                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID == "" ||\r
 125                 lRicHoControlMsg.RicControlGrpcReqPtr.PlmnID == "" ||\r
 126                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlActionId < 0 ||\r
 127                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlStyle < 0 ||\r
 128                 lRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal < 0 ||\r
 129                 lRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID < 0 ||\r
 130                 lRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId < 0 {\r
 131                 xapp.Logger.Error("Mandaroty parameters missing, dont send control request ")\r
 132                 return\r
 133         }\r
 134 \r
 135         lRicHoControlMsg.GetSequenceNumber()\r
 136 \r
 137         go lRicHoControlMsg.SendRicControlRequest(lRicHoControlMsg.GetSequenceNumber())\r
 138 \r
 139         return\r
 140 }\r
 141 \r
 142 func (aRicHoControlMsg *RicHoControlMsg) GetSequenceNumber() int {\r
 143 \r
 144         //Incrementing the RIC Requestor Instance Id to make the request unique and traceable.\r
 145         gControlData.eventRicControlReqExpiredMu.Lock()\r
 146         gControlData.ricRequestInstanceID = gControlData.ricRequestInstanceID + 1\r
 147         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 148 \r
 149         return gControlData.ricRequestInstanceID\r
 150 }\r
 151 \r
 152 func (aRicHoControlMsg *RicHoControlMsg) setEventRicControlCreateExpiredTimer(aSeqNum int) {\r
 153 \r
 154         gControlData.eventRicControlReqExpiredMu.Lock()\r
 155         gControlData.eventRicControlReqExpiredMap[aSeqNum] = false\r
 156         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 157 \r
 158         timer := time.NewTimer(time.Duration(gControlData.eventRicControlReqTimePeriod) * time.Second)\r
 159         go func(t *time.Timer) {\r
 160                 defer t.Stop()\r
 161                 xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: Waiting for RIC_CONTROL_RESP...", aSeqNum)\r
 162                 log.Printf("RIC_CONTROL_REQ[%s]: Waiting for RIC_CONTROL_RESP...", aSeqNum)\r
 163                 for {\r
 164                         select {\r
 165                         case <-t.C:\r
 166                                 gControlData.eventRicControlReqExpiredMu.Lock()\r
 167                                 isResponsed := gControlData.eventRicControlReqExpiredMap[aSeqNum]\r
 168                                 delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)\r
 169                                 gControlData.eventRicControlReqExpiredMu.Unlock()\r
 170                                 if !isResponsed {\r
 171                                         xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: RIC Event Create Timer experied!", aSeqNum)\r
 172                                         log.Printf("RIC_CONTROL_REQ[%s]: RIC Event Create Timer experied!", aSeqNum)\r
 173                                         //Send ErrorIndication message on Timeout\r
 174                                         return\r
 175                                 }\r
 176                         default:\r
 177                                 gControlData.eventRicControlReqExpiredMu.Lock()\r
 178                                 flag := gControlData.eventRicControlReqExpiredMap[aSeqNum]\r
 179                                 if flag {\r
 180                                         delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)\r
 181                                         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 182                                         xapp.Logger.Debug("RIC_CONTROL_REQ[%s]: RIC Event Create Timer canceled!", aSeqNum)\r
 183                                         log.Printf("RIC_CONTROL_REQ[%s]: RIC Event Create Timer canceled!", aSeqNum)\r
 184                                         return\r
 185                                 } else {\r
 186                                         gControlData.eventRicControlReqExpiredMu.Unlock()\r
 187                                 }\r
 188                         }\r
 189                         time.Sleep(100 * time.Millisecond)\r
 190                 }\r
 191         }(timer)\r
 192 }\r
 193 func (aRicHoControlMsg *RicHoControlMsg) SendRicControlRequest(aRequestSN int) (err error) {\r
 194         var e2ap *E2ap\r
 195         var e2sm *E2sm\r
 196 \r
 197         xapp.Logger.Info("SendRicControlRequest Enter for RanName = %s", aRicHoControlMsg.RicControlGrpcReqPtr.RanName)\r
 198 \r
 199         if aRicHoControlMsg.RicControlGrpcReqPtr == nil {\r
 200                 return err\r
 201         }\r
 202 \r
 203         var lRicControlStyleType int64 = aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlStyle\r
 204         var lRicControlActionID int64 = aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.ControlActionId\r
 205         lUEID := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID\r
 206 \r
 207         lUeIdBuf := []byte(aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 208 \r
 209         xapp.Logger.Debug("UEID:%s, lUeIdBuf: %v", aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID, lUeIdBuf)\r
 210 \r
 211         var lRicControlHeader []byte = make([]byte, 256) //Check the Size\r
 212         lRicControlHeaderEncoded, err := e2sm.SetRicControlHeader(lRicControlHeader, lUeIdBuf, lRicControlStyleType, lRicControlActionID)\r
 213         if err != nil {\r
 214                 xapp.Logger.Error("SetRicControlHeader Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 215                 log.Printf("SetRicControlHeader Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 216                 return err\r
 217         } else {\r
 218                 xapp.Logger.Info("SetRicControlHeader is success: %x", lRicControlHeaderEncoded)\r
 219                 fmt.Fprintf(os.Stderr, "Encoded RIC Control Header PDU:\n")\r
 220                 for i := 0; i < len(lRicControlHeaderEncoded); i++ {\r
 221                         fmt.Fprintf(os.Stderr, " %02x", lRicControlHeaderEncoded[i])\r
 222                 }\r
 223                 fmt.Fprintf(os.Stderr, "\n")\r
 224         }\r
 225 \r
 226         var lTargetPrimaryCell int64 = RIC_CONTROL_TARGET_PRIMARY_CELL\r
 227         var lTargetCell int64 = RIC_CONTROL_TARGET_CELL\r
 228         var lNrCGIOrECGI int64 = RIC_CONTROL_CGI_TYPE\r
 229 \r
 230         lNrOrEUtraCellType := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal\r
 231         lTargetCellVal := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID\r
 232         lTargetCellValBuf := []byte(lTargetCellVal)\r
 233 \r
 234         var lRicControlMessage []byte = make([]byte, 1024) \r
 235         lRicControlMessageEncoded, err := e2sm.SetRicControlMessage(lRicControlMessage, lTargetPrimaryCell, lTargetCell, lNrCGIOrECGI, int64(lNrOrEUtraCellType), lTargetCellValBuf)\r
 236         if err != nil {\r
 237                 xapp.Logger.Error("SetRicControlMessage Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 238                 log.Printf("SetRicControlMessage Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 239                 return err\r
 240         } else {\r
 241                 xapp.Logger.Debug("SetRicControlMessage is success: %x", lRicControlMessageEncoded)\r
 242                 fmt.Fprintf(os.Stderr, "Encoded RIC Control Message PDU:\n")\r
 243                 for i := 0; i < len(lRicControlMessageEncoded); i++ {\r
 244                         fmt.Fprintf(os.Stderr, " %02x", lRicControlMessageEncoded[i])\r
 245                 }\r
 246                 fmt.Fprintf(os.Stderr, "\n")\r
 247         }\r
 248 \r
 249         lParams := &xapp.RMRParams{}\r
 250         lParams.Mtype = 12040 //RIC_CONTROL_REQ\r
 251         lParams.SubId = -1\r
 252 \r
 253         var lRequestorId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID)\r
 254         var lFuncId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId)\r
 255 \r
 256         lParams.Payload = make([]byte, 2048)\r
 257         lParams.Payload, err = e2ap.SetRicControlRequestPayload(lParams.Payload, lRequestorId, uint16(aRequestSN), lFuncId,\r
 258                 lRicControlHeaderEncoded, lRicControlMessageEncoded)\r
 259         if err != nil {\r
 260                 xapp.Logger.Error("SetRicControlRequestPayload Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 261                 log.Printf("SetRicControlRequestPayload Failed: %v, UEID:%s", err, aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)\r
 262                 return err\r
 263         } else {\r
 264                 xapp.Logger.Debug("Encoding RicControlRequestPayload is success. UEID: %s, Payload: %x", lUEID, lParams.Payload)\r
 265                 fmt.Fprintf(os.Stderr, "Encoded RIC Control Req PDU:\n")\r
 266                 for i := 0; i < len(lParams.Payload); i++ {\r
 267                         fmt.Fprintf(os.Stderr, " %02x", lParams.Payload[i])\r
 268                 }\r
 269                 fmt.Fprintf(os.Stderr, "\n")\r
 270         }\r
 271 \r
 272         valEnbId := aRicHoControlMsg.RicControlGrpcReqPtr.E2NodeID\r
 273         valRanName := aRicHoControlMsg.RicControlGrpcReqPtr.RanName\r
 274         valPlmnId := aRicHoControlMsg.RicControlGrpcReqPtr.PlmnID\r
 275         lParams.Meid = &xapp.RMRMeid{PlmnID: valPlmnId, EnbID: valEnbId, RanName: valRanName}\r
 276 \r
 277         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
 278 \r
 279         xapp.Logger.Debug("Sending RIC Control message to RanName: %s, UEID: %s  ", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)\r
 280 \r
 281         err = gControlData.rmrSend(lParams)\r
 282         if err != nil {\r
 283                 xapp.Logger.Error("Failed to send RIC_CONTROL_REQ: %v", err)\r
 284                 log.Printf("Failed to send RIC_CONTROL_REQ: %v", err)\r
 285                 return err\r
 286         }\r
 287 \r
 288         xapp.Logger.Info("Sending RIC Control message to RanName: %s, UEID: %s  Success", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)\r
 289 \r
 290         aRicHoControlMsg.setEventRicControlCreateExpiredTimer(aRequestSN) //TODO check if this is required as we are not expecting Control ACK\r
 291 \r
 292         return nil\r
 293 }\r
 294 \r
 295 func HandleControlResponse(params *xapp.RMRParams) (err error) {\r
 296         xapp.Logger.Debug("The SubId in RIC_CONTROL_RESP is %d", params.SubId)\r
 297         log.Printf("The SubId in RIC_CONTROL_RESP is %d", params.SubId)\r
 298 \r
 299         return nil\r
 300 }\r
 301 \r
 302 func HandleControlFailure(params *xapp.RMRParams) (err error) {\r
 303 \r
 304         xapp.Logger.Debug("The SubId in RIC_CONTROL_FAILURE is %d", params.SubId)\r
 305         log.Printf("The SubId in RIC_CONTROL_FAILURE is %d", params.SubId)\r
 306 \r
 307         return nil\r
 308 }\r