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
16 gControlData *Control
\r
17 gChan_RicControlReq_handle = make(chan *rc.RicControlGrpcReq, 2000) //Make it configurable
\r
20 func NewControl() Control {
\r
22 file := "/opt/rc.log"
\r
23 logFile, err := os.OpenFile(file, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0766)
\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
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
37 make(chan *xapp.RMRParams, 1000), //Make it configurable
\r
43 func ReadyCB(i interface{}) {
\r
44 gControlData = i.(*Control)
\r
48 //Start gRPC Server for Receiving messages
\r
50 go StartgRPCRCControlCommServerRoutine()
\r
51 xapp.Logger.Info("StartgRPCRCControlCommServerRoutine done")
\r
53 //To Handle RIC Control Message
\r
54 go StartHandleControlReqRoutine()
\r
58 func (aControlData *Control) Run() {
\r
59 xapp.SetReadyCB(ReadyCB, aControlData)
\r
60 xapp.Run(aControlData)
\r
63 func (aControlData *Control) Consume(rp *xapp.RMRParams) (err error) {
\r
64 gControlData.rcChan <- rp
\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
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
86 func controlLoop() {
\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
93 go HandleControlResponse(msg)
\r
95 go HandleControlFailure(msg)
\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
104 func StartHandleControlReqRoutine() {
\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
109 _, ok := <-gChan_RicControlReq_handle
\r
111 xapp.Logger.Error("Invalid grpc request received, dont process further")
\r
114 HandlegRPCRICControlMsgReq(<-gChan_RicControlReq_handle)
\r
116 xapp.Logger.Debug("StartHandleControlReqRoutine Done")
\r
119 func HandlegRPCRICControlMsgReq(aPtrRicControlGrpcReq *rc.RicControlGrpcReq) {
\r
121 lRicHoControlMsg := RicHoControlMsg{}
\r
122 lRicHoControlMsg.RicControlGrpcReqPtr = aPtrRicControlGrpcReq
\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
140 lRicHoControlMsg.GetSequenceNumber()
\r
142 go lRicHoControlMsg.SendRicControlRequest(lRicHoControlMsg.GetSequenceNumber())
\r
147 func (aRicHoControlMsg *RicHoControlMsg) GetSequenceNumber() int {
\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
154 return gControlData.ricRequestInstanceID
\r
157 func (aRicHoControlMsg *RicHoControlMsg) setEventRicControlCreateExpiredTimer(aSeqNum int) {
\r
159 gControlData.eventRicControlReqExpiredMu.Lock()
\r
160 gControlData.eventRicControlReqExpiredMap[aSeqNum] = false
\r
161 gControlData.eventRicControlReqExpiredMu.Unlock()
\r
163 timer := time.NewTimer(time.Duration(gControlData.eventRicControlReqTimePeriod) * time.Second)
\r
164 go func(t *time.Timer) {
\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
171 gControlData.eventRicControlReqExpiredMu.Lock()
\r
172 isResponsed := gControlData.eventRicControlReqExpiredMap[aSeqNum]
\r
173 delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)
\r
174 gControlData.eventRicControlReqExpiredMu.Unlock()
\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
182 gControlData.eventRicControlReqExpiredMu.Lock()
\r
183 flag := gControlData.eventRicControlReqExpiredMap[aSeqNum]
\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
191 gControlData.eventRicControlReqExpiredMu.Unlock()
\r
194 time.Sleep(100 * time.Millisecond)
\r
198 func (aRicHoControlMsg *RicHoControlMsg) SendRicControlRequest(aRequestSN int) (err error) {
\r
202 xapp.Logger.Info("SendRicControlRequest Enter for RanName = %s", aRicHoControlMsg.RicControlGrpcReqPtr.RanName)
\r
204 if aRicHoControlMsg.RicControlGrpcReqPtr == nil {
\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
212 lUeIdBuf := []byte(aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
\r
214 xapp.Logger.Debug("UEID:%s, lUeIdBuf: %v", aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID, lUeIdBuf)
\r
216 var lRicControlHeader []byte = make([]byte, 256) //Check the Size
\r
217 lRicControlHeaderEncoded, err := e2sm.SetRicControlHeader(lRicControlHeader, lUeIdBuf, lRicControlStyleType, lRicControlActionID)
\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
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
228 fmt.Fprintf(os.Stderr, "\n")
\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
235 lNrOrEUtraCellType := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal
\r
236 lTargetCellVal := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID
\r
237 lTargetCellValBuf := []byte(lTargetCellVal)
\r
239 var lRicControlMessage []byte = make([]byte, 1024)
\r
240 lRicControlMessageEncoded, err := e2sm.SetRicControlMessage(lRicControlMessage, lTargetPrimaryCell, lTargetCell, lNrCGIOrECGI, int64(lNrOrEUtraCellType), lTargetCellValBuf)
\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
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
251 fmt.Fprintf(os.Stderr, "\n")
\r
254 lParams := &xapp.RMRParams{}
\r
255 lParams.Mtype = 12040 //RIC_CONTROL_REQ
\r
258 var lRequestorId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID)
\r
259 var lFuncId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId)
\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
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
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
274 fmt.Fprintf(os.Stderr, "\n")
\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
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
284 xapp.Logger.Debug("Sending RIC Control message to RanName: %s, UEID: %s ", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)
\r
286 err = gControlData.rmrSend(lParams)
\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
293 xapp.Logger.Info("Sending RIC Control message to RanName: %s, UEID: %s Success", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)
\r
295 aRicHoControlMsg.setEventRicControlCreateExpiredTimer(aRequestSN) //TODO check if this is required as we are not expecting Control ACK
\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
307 func HandleControlFailure(params *xapp.RMRParams) (err error) {
\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