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 HandlegRPCRICControlMsgReq(<-gChan_RicControlReq_handle)
\r
111 xapp.Logger.Debug("StartHandleControlReqRoutine Done")
\r
114 func HandlegRPCRICControlMsgReq(aPtrRicControlGrpcReq *rc.RicControlGrpcReq) {
\r
116 lRicHoControlMsg := RicHoControlMsg{}
\r
117 lRicHoControlMsg.RicControlGrpcReqPtr = aPtrRicControlGrpcReq
\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
135 lRicHoControlMsg.GetSequenceNumber()
\r
137 go lRicHoControlMsg.SendRicControlRequest(lRicHoControlMsg.GetSequenceNumber())
\r
142 func (aRicHoControlMsg *RicHoControlMsg) GetSequenceNumber() int {
\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
149 return gControlData.ricRequestInstanceID
\r
152 func (aRicHoControlMsg *RicHoControlMsg) setEventRicControlCreateExpiredTimer(aSeqNum int) {
\r
154 gControlData.eventRicControlReqExpiredMu.Lock()
\r
155 gControlData.eventRicControlReqExpiredMap[aSeqNum] = false
\r
156 gControlData.eventRicControlReqExpiredMu.Unlock()
\r
158 timer := time.NewTimer(time.Duration(gControlData.eventRicControlReqTimePeriod) * time.Second)
\r
159 go func(t *time.Timer) {
\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
166 gControlData.eventRicControlReqExpiredMu.Lock()
\r
167 isResponsed := gControlData.eventRicControlReqExpiredMap[aSeqNum]
\r
168 delete(gControlData.eventRicControlReqExpiredMap, aSeqNum)
\r
169 gControlData.eventRicControlReqExpiredMu.Unlock()
\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
177 gControlData.eventRicControlReqExpiredMu.Lock()
\r
178 flag := gControlData.eventRicControlReqExpiredMap[aSeqNum]
\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
186 gControlData.eventRicControlReqExpiredMu.Unlock()
\r
189 time.Sleep(100 * time.Millisecond)
\r
193 func (aRicHoControlMsg *RicHoControlMsg) SendRicControlRequest(aRequestSN int) (err error) {
\r
197 xapp.Logger.Info("SendRicControlRequest Enter for RanName = %s", aRicHoControlMsg.RicControlGrpcReqPtr.RanName)
\r
199 if aRicHoControlMsg.RicControlGrpcReqPtr == nil {
\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
207 lUeIdBuf := []byte(aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID)
\r
209 xapp.Logger.Debug("UEID:%s, lUeIdBuf: %v", aRicHoControlMsg.RicControlGrpcReqPtr.RICControlHeaderData.UEID, lUeIdBuf)
\r
211 var lRicControlHeader []byte = make([]byte, 256) //Check the Size
\r
212 lRicControlHeaderEncoded, err := e2sm.SetRicControlHeader(lRicControlHeader, lUeIdBuf, lRicControlStyleType, lRicControlActionID)
\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
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
223 fmt.Fprintf(os.Stderr, "\n")
\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
230 lNrOrEUtraCellType := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.RICControlCellTypeVal
\r
231 lTargetCellVal := aRicHoControlMsg.RicControlGrpcReqPtr.RICControlMessageData.TargetCellID
\r
232 lTargetCellValBuf := []byte(lTargetCellVal)
\r
234 var lRicControlMessage []byte = make([]byte, 1024)
\r
235 lRicControlMessageEncoded, err := e2sm.SetRicControlMessage(lRicControlMessage, lTargetPrimaryCell, lTargetCell, lNrCGIOrECGI, int64(lNrOrEUtraCellType), lTargetCellValBuf)
\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
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
246 fmt.Fprintf(os.Stderr, "\n")
\r
249 lParams := &xapp.RMRParams{}
\r
250 lParams.Mtype = 12040 //RIC_CONTROL_REQ
\r
253 var lRequestorId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RICRequestorID)
\r
254 var lFuncId uint16 = uint16(aRicHoControlMsg.RicControlGrpcReqPtr.RICE2APHeaderData.RanFuncId)
\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
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
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
269 fmt.Fprintf(os.Stderr, "\n")
\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
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
279 xapp.Logger.Debug("Sending RIC Control message to RanName: %s, UEID: %s ", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)
\r
281 err = gControlData.rmrSend(lParams)
\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
288 xapp.Logger.Info("Sending RIC Control message to RanName: %s, UEID: %s Success", aRicHoControlMsg.RicControlGrpcReqPtr.RanName, lUEID)
\r
290 aRicHoControlMsg.setEventRicControlCreateExpiredTimer(aRequestSN) //TODO check if this is required as we are not expecting Control ACK
\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
302 func HandleControlFailure(params *xapp.RMRParams) (err error) {
\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