blob: c112b202e76c3f460a103dc56920fbabb53f5f5e [file] [log] [blame]
/*
==================================================================================
Copyright (c) 2022 Samsung
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
This source code is part of the near-RT RIC (RAN Intelligent Controller)
platform project (RICP).
==================================================================================
*/
package rmr
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"strconv"
"gerrit.o-ran-sc.org/r/ric-plt/a1/config"
"gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
"gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
"gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/policy"
"gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/xapp"
)
const (
a1SourceName = "service-ricplt-a1mediator-http"
a1PolicyRequest = 20010
ecsServiceHost = "http://ecs-service:8083"
ecsEiTypePath = ecsServiceHost + "/A1-EI/v1/eitypes"
ecsEiJobPath = ecsServiceHost + "/A1-EI/v1/eijobs/"
a1EiQueryAllResp = 20014
a1EiCreateJobResp = 20016
jobCreationData = `{"ei_job_id": %s.}`
DefaultSubId = -1
)
type RmrSender struct {
rmrclient *xapp.RMRClient
policyManager *policy.PolicyManager
}
type IRmrSender interface {
RmrSendToXapp(httpBodyString string, messagetype int, subid int) bool
}
func NewRMRSender(policyManager *policy.PolicyManager) IRmrSender {
config := config.ParseConfiguration()
RMRclient := xapp.NewRMRClientWithParams(&xapp.RMRClientParams{
StatDesc: "",
RmrData: xapp.PortData{
Name: config.Name,
MaxSize: config.MaxSize,
ThreadType: config.ThreadType,
LowLatency: config.LowLatency,
FastAck: config.FastAck,
MaxRetryOnFailure: config.MaxRetryOnFailure,
Port: config.Port,
},
})
rmrsender := &RmrSender{
rmrclient: RMRclient,
policyManager: policyManager,
}
rmrsender.RmrRecieveStart()
return rmrsender
}
var RICMessageTypes = map[string]int{
"A1_POLICY_REQ": 20010,
"A1_POLICY_RESP": 20011,
"A1_POLICY_QUERY": 20012,
"A1_EI_QUERY_ALL": 20013,
"AI_EI_QUERY_ALL_RESP": 20014,
"A1_EI_CREATE_JOB": 20015,
"A1_EI_CREATE_JOB_RESP": 20016,
"A1_EI_DATA_DELIVERY": 20017,
}
func (rmr *RmrSender) GetRicMessageName(id int) (s string) {
for k, v := range RICMessageTypes {
if id == v {
return k
}
}
return
}
func (rmr *RmrSender) RmrSendToXapp(httpBodyString string, messagetype int, subid int) bool {
params := &xapp.RMRParams{}
params.Mtype = messagetype
params.SubId = subid
params.Xid = ""
params.Meid = &xapp.RMRMeid{}
params.Src = a1SourceName
params.PayloadLen = len([]byte(httpBodyString))
params.Payload = []byte(httpBodyString)
a1.Logger.Debug("MSG to XAPP: %s ", params.String())
a1.Logger.Debug("len payload %+v", len(params.Payload))
s := rmr.rmrclient.SendMsg(params)
a1.Logger.Debug("rmrSendToXapp: sending: %+v", s)
return s
}
func (rmr *RmrSender) Consume(msg *xapp.RMRParams) (err error) {
a1.Logger.Debug("In the Consume function")
id := rmr.GetRicMessageName(msg.Mtype)
a1.Logger.Debug("Message received: name=%s meid=%s subId=%d txid=%s len=%d", id, msg.Meid.RanName, msg.SubId, msg.Xid, msg.PayloadLen)
switch id {
case "A1_POLICY_RESP":
a1.Logger.Debug("Recived policy responose")
payload := msg.Payload
a1.Logger.Debug("message recieved : %s", payload)
var result map[string]interface{}
err := json.Unmarshal([]byte(payload), &result)
if err != nil {
a1.Logger.Error("Unmarshal error : %+v", err)
return err
}
policyTypeId := int(result["policy_type_id"].(float64))
policyInstanceId := result["policy_instance_id"].(string)
policyHandlerId := result["handler_id"].(string)
policyStatus := result["status"].(string)
a1.Logger.Debug("message recieved for %d and %s with status : %s", policyTypeId, policyInstanceId, policyStatus)
rmr.policyManager.SetPolicyInstanceStatus(policyTypeId, policyInstanceId, policyStatus)
err = rmr.policyManager.SendPolicyStatusNotification(policyTypeId, policyInstanceId, policyHandlerId, policyStatus)
if err != nil {
a1.Logger.Debug("failed to send policy status notification %v+", err)
}
case "A1_POLICY_QUERY":
a1.Logger.Debug("Recived policy query")
a1.Logger.Debug("message recieved ", msg.Payload)
payload := msg.Payload
var result map[string]interface{}
json.Unmarshal([]byte(payload), &result)
a1.Logger.Debug("message recieved : %s for %d and %d", result, result["policy_type_id"], result["policy_instance_id"])
policytypeid := (result["policy_type_id"].(float64))
instanceList, err1 := rmr.policyManager.GetAllPolicyInstance(int(policytypeid))
if err1 != nil {
a1.Logger.Error("Error : %+v", err1)
return err1
}
a1.Logger.Debug("instanceList ", instanceList)
a1.Logger.Debug("Received a query for a known policy type: %d", policytypeid)
for _, policyinstanceid := range instanceList {
policyinstance, err2 := rmr.policyManager.GetPolicyInstance(models.PolicyTypeID(policytypeid), policyinstanceid)
if err2 != nil {
a1.Logger.Error("Error : %+v", err2)
return err2
}
a1.Logger.Debug("policyinstance ", policyinstance.(string))
message := Message{}
rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policytypeid)), 10), string(policyinstanceid), policyinstance.(string), "CREATE")
if err1 != nil {
a1.Logger.Error("error : %v", err1)
return err1
}
a1.Logger.Debug("rmrMessage ", rmrMessage)
isSent := rmr.RmrSendToXapp(rmrMessage, a1PolicyRequest, int(policytypeid))
if isSent {
a1.Logger.Debug("rmrSendToXapp : message sent")
} else {
a1.Logger.Error("rmrSendToXapp : message not sent")
}
}
case "A1_EI_QUERY_ALL":
a1.Logger.Debug("message recieved ", msg.Payload)
resp, err := http.Get(ecsEiTypePath)
if err != nil {
a1.Logger.Error("Received error while fetching health info: %v", err)
}
if resp.StatusCode != http.StatusOK {
a1.Logger.Warning("Received no reponse from A1-EI service1")
}
a1.Logger.Debug("response from A1-EI service : ", resp)
defer resp.Body.Close()
respByte, err := ioutil.ReadAll(resp.Body)
if err != nil {
a1.Logger.Debug("error in response: %+v", respByte)
}
a1.Logger.Debug("response : %+v", string(respByte))
isSent := rmr.RmrSendToXapp(string(respByte), a1EiQueryAllResp, DefaultSubId)
if isSent {
a1.Logger.Debug("rmrSendToXapp : message sent")
} else {
a1.Logger.Error("rmrSendToXapp : message not sent")
}
case "A1_EI_CREATE_JOB":
payload := msg.Payload
a1.Logger.Debug("message recieved : %s", payload)
var result map[string]interface{}
err := json.Unmarshal([]byte(payload), &result)
if err != nil {
a1.Logger.Error("Unmarshal error : %+v", err)
return err
}
a1.Logger.Debug("Unmarshaled message recieved : %s ", result)
jobIdStr := strconv.FormatInt((int64(result["job-id"].(float64))), 10)
jsonReq, err := json.Marshal(result)
if err != nil {
a1.Logger.Error("marshal error : %v", err)
return err
}
a1.Logger.Debug("url to send to :", ecsEiJobPath+jobIdStr)
req, err := http.NewRequest(http.MethodPut, ecsEiJobPath+jobIdStr, bytes.NewBuffer(jsonReq))
if err != nil {
a1.Logger.Error("http error : %v", err)
return err
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
client := &http.Client{}
resp, err3 := client.Do(req)
if err3 != nil {
a1.Logger.Error("error:", err3)
return err
}
defer resp.Body.Close()
a1.Logger.Debug("response status : ", resp.StatusCode)
if resp.StatusCode == 200 || resp.StatusCode == 201 {
a1.Logger.Debug("received successful response for ei-job-id : ", jobIdStr)
rmrData := fmt.Sprintf(jobCreationData, jobIdStr)
a1.Logger.Debug("rmr_Data to send: ", rmrData)
isSent := rmr.RmrSendToXapp(rmrData, a1EiCreateJobResp, DefaultSubId)
if isSent {
a1.Logger.Debug("rmrSendToXapp : message sent")
} else {
a1.Logger.Error("rmrSendToXapp : message not sent")
}
} else {
a1.Logger.Warning("failed to create EIJOB ")
}
default:
xapp.Logger.Error("Unknown message type '%d', discarding", msg.Mtype)
}
defer func() {
rmr.rmrclient.Free(msg.Mbuf)
msg.Mbuf = nil
}()
return
}
func (rmr *RmrSender) RmrRecieveStart() {
a1.Logger.Debug("Inside RmrRecieveStart function ")
go rmr.rmrclient.Start(rmr)
a1.Logger.Debug("Reciever started")
}