"fmt"
"strconv"
"strings"
+ "time"
"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/a1/pkg/restapi/operations/a1_mediator"
+ "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/rmr"
"gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
+ "github.com/santhosh-tekuri/jsonschema/v5"
+ "gopkg.in/yaml.v2"
)
const (
- a1PolicyPrefix = "a1.policy_type."
- a1MediatorNs = "A1m_ns"
+ a1PolicyPrefix = "a1.policy_type."
+ a1MediatorNs = "A1m_ns"
+ a1InstancePrefix = "a1.policy_instance."
+ a1InstanceMetadataPrefix = "a1.policy_inst_metadata."
+ a1HandlerPrefix = "a1.policy_handler."
+ a1PolicyRequest = 20010
+ a1EIDataDelivery = 20017
)
var typeAlreadyError = errors.New("Policy Type already exists")
+var InstanceAlreadyError = errors.New("Policy Instance already exists")
var typeMismatchError = errors.New("Policytype Mismatch")
+var invalidJsonSchema = errors.New("Invalid Json ")
+var policyInstanceNotFoundError = errors.New("Policy Instance Not Found")
+var policyTypeNotFoundError = errors.New("Policy Type Not Found")
+var policyTypeCanNotBeDeletedError = errors.New("tried to delete a type that isn't empty")
+var policyInstanceCanNotBeDeletedError = errors.New("tried to delete a Instance that isn't empty")
+
+func (rh *Resthook) CanPolicyInstanceBeDeleted(err error) bool {
+ return err == policyInstanceCanNotBeDeletedError
+}
+
+func (rh *Resthook) CanPolicyTypeBeDeleted(err error) bool {
+ return err == policyTypeCanNotBeDeletedError
+}
+
+func (rh *Resthook) IsPolicyTypePresent(err error) bool {
+ return err == policyTypeNotFoundError
+}
+
+func (rh *Resthook) IsPolicyInstanceNotFound(err error) bool {
+ return err == policyInstanceNotFoundError
+}
func (rh *Resthook) IsTypeAlready(err error) bool {
return err == typeAlreadyError
}
+func (rh *Resthook) IsInstanceAlready(err error) bool {
+ return err == InstanceAlreadyError
+}
func (rh *Resthook) IsTypeMismatch(err error) bool {
return err == typeMismatchError
}
+
+func (rh *Resthook) IsValidJson(err error) bool {
+ return err == invalidJsonSchema
+}
func NewResthook() *Resthook {
- return createResthook(sdlgo.NewSyncStorage())
+ sdl := sdlgo.NewSyncStorage()
+ policyManager := policy.NewPolicyManager(sdl)
+ return createResthook(sdl, rmr.NewRMRSender(policyManager))
+}
+
+func createResthook(sdlInst iSdl, rmrSenderInst rmr.IRmrSender) *Resthook {
+ rh := &Resthook{
+ db: sdlInst,
+ iRmrSenderInst: rmrSenderInst,
+ }
+
+ return rh
}
-func createResthook(sdlInst iSdl) *Resthook {
- return &Resthook{
- db: sdlInst,
+func (rh *Resthook) GetA1Health() bool {
+ data, _ := rh.db.GetAll(a1MediatorNs)
+ if data != nil {
+ a1.Logger.Debug("Database connected and A1 is healthy")
+ return true
}
+ return false
}
func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
valmap, err := rh.db.Get(a1MediatorNs, keys[:])
- a1.Logger.Debug("policytype map : ", valmap)
+ a1.Logger.Debug("policytype map : %+v", valmap)
if len(valmap) == 0 {
a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
if err != nil {
a1.Logger.Error("error in retrieving policy type. err: %v", err)
- return policytypeschema
+ return nil
}
if valmap[key] == nil {
valkey := "`" + valStr + "`"
valToUnmarshall, err := strconv.Unquote(valkey)
if err != nil {
- panic(err)
+ a1.Logger.Error("unquote error : %+v", err)
+ return nil
}
- a1.Logger.Debug("Policy type for %+v : %+v", key, string(b))
+ a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
+
errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
}
return nil
}
+
+func toStringKeys(val interface{}) (interface{}, error) {
+ var err error
+ switch val := val.(type) {
+ case map[interface{}]interface{}:
+ m := make(map[string]interface{})
+ for k, v := range val {
+ k, ok := k.(string)
+ if !ok {
+ return nil, errors.New("found non-string key")
+ }
+ m[k], err = toStringKeys(v)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return m, nil
+ case []interface{}:
+ var l = make([]interface{}, len(val))
+ for i, v := range val {
+ l[i], err = toStringKeys(v)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return l, nil
+ default:
+ return val, nil
+ }
+}
+
+func validate(httpBodyString string, schemaString string) bool {
+ var m interface{}
+ err := yaml.Unmarshal([]byte(httpBodyString), &m)
+ if err != nil {
+ a1.Logger.Error("Unmarshal error : %+v", err)
+ }
+ m, err = toStringKeys(m)
+ if err != nil {
+ a1.Logger.Error("Conversion to string error : %+v", err)
+ return false
+ }
+ compiler := jsonschema.NewCompiler()
+ if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
+ a1.Logger.Error("string reader error : %+v", err)
+ return false
+ }
+ schema, err := compiler.Compile("schema.json")
+ if err != nil {
+ a1.Logger.Error("schema json compile error : %+v", err)
+ return false
+ }
+ if err := schema.Validate(m); err != nil {
+ a1.Logger.Error("schema validation error : %+v", err)
+ return false
+ }
+ a1.Logger.Debug("validation successfull")
+ return true
+}
+
+func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
+ var keys [1]string
+ operation := "CREATE"
+ typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ keys[0] = typekey
+
+ a1.Logger.Debug("key1 : %+v", typekey)
+
+ valmap, err := rh.db.Get(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("policy type error : %+v", err)
+ }
+ a1.Logger.Debug("policytype map : %+v", valmap)
+ if valmap[typekey] == nil {
+ a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
+ return operation, policyTypeNotFoundError
+ }
+ // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
+
+ instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ keys[0] = typekey
+ instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("policy type error : %v", err)
+ }
+ a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
+
+ if instanceMap[instancekey] != nil {
+ operation = "UPDATE"
+ a1.Logger.Debug("UPDATE")
+ data, _ := json.Marshal(httpBody)
+ a1.Logger.Debug("Marshaled String : %+v", string(data))
+ a1.Logger.Debug("key : %+v", instancekey)
+ success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
+ if err1 != nil {
+ a1.Logger.Error("error2 :%+v", err1)
+ return operation, err1
+ }
+ if !success {
+ a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
+ return operation, InstanceAlreadyError
+ }
+ } else {
+ data, _ := json.Marshal(httpBody)
+ a1.Logger.Debug("Marshaled String : %+v", string(data))
+ a1.Logger.Debug("key : %+v", instancekey)
+
+ var instance_map []interface{}
+ instance_map = append(instance_map, instancekey, string(data))
+ a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
+ a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
+
+ err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
+ if err1 != nil {
+ a1.Logger.Error("error1 :%+v", err1)
+ return operation, err1
+ }
+ }
+ a1.Logger.Debug("Policy Instance created ")
+ return operation, nil
+}
+
+func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
+
+ creation_timestamp := time.Now()
+ instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+
+ a1.Logger.Debug("key : %+v", instanceMetadataKey)
+
+ var metadatajson []interface{}
+ metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
+ metadata, _ := json.Marshal(metadatajson)
+
+ a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
+
+ err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
+
+ if err != nil {
+ a1.Logger.Error("error :%+v", err)
+ return false, err
+ }
+
+ a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
+
+ return true, nil
+}
+
+func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
+ a1.Logger.Debug("CreatePolicyInstance function")
+ // validate the PUT against the schema
+ var policyTypeSchema *models.PolicyTypeSchema
+ policyTypeSchema = rh.GetPolicyType(policyTypeId)
+ schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
+ if err != nil {
+ a1.Logger.Error("Json Marshal error : %+v", err)
+ return err
+ }
+ a1.Logger.Debug("schema to validate %+v", string(schemaStr))
+ a1.Logger.Debug("httpbody to validate %+v", httpBody)
+ schemaString := fmt.Sprint(string(schemaStr))
+ httpBodyMarshal, err := json.Marshal(httpBody)
+ httpBodyString := string((httpBodyMarshal))
+ a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
+ a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
+ isvalid := validate(httpBodyString, schemaString)
+ if isvalid {
+ var operation string
+ operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
+ if err != nil {
+ a1.Logger.Error("error :%+v", err)
+ return err
+ }
+ a1.Logger.Debug("policy instance :%+v", operation)
+ iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
+ if errmetadata != nil {
+ a1.Logger.Error("error :%+v", errmetadata)
+ return errmetadata
+ }
+ if iscreated {
+ a1.Logger.Debug("policy instance metadata created")
+ }
+
+ message := rmr.Message{}
+ rmrMessage, err := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
+ if err != nil {
+ a1.Logger.Error("error : %v", err)
+ return err
+ }
+ isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
+ if isSent {
+ a1.Logger.Debug("rmrSendToXapp : message sent")
+ } else {
+ a1.Logger.Debug("rmrSendToXapp : message not sent")
+ }
+
+ } else {
+ a1.Logger.Error("%+v", invalidJsonSchema)
+ return invalidJsonSchema
+ }
+
+ return nil
+}
+
+func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (interface{}, error) {
+ a1.Logger.Debug("GetPolicyInstance1")
+
+ var keys [1]string
+
+ typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ keys[0] = typekey
+
+ a1.Logger.Debug("key1 : %+v", typekey)
+
+ valmap, err := rh.db.Get(a1MediatorNs, keys[:])
+ if len(valmap) == 0 {
+ a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
+ return "{}", policyTypeNotFoundError
+ }
+
+ if err != nil {
+ a1.Logger.Error("error in retrieving policy type. err: %v", err)
+ return "{}", err
+ }
+
+ if valmap[typekey] == nil {
+ a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
+ return "{}", policyTypeNotFoundError
+ }
+
+ a1.Logger.Debug("keysmap : %+v", valmap[typekey])
+
+ instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ a1.Logger.Debug("key2 : %+v", instancekey)
+ keys[0] = instancekey
+ instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("policy instance error : %v", err)
+ }
+ a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
+
+ if instanceMap[instancekey] == nil {
+ a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
+ return "{}", policyInstanceNotFoundError
+ }
+
+ valStr := fmt.Sprint(instanceMap[instancekey])
+ return valStr, nil
+}
+
+func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
+ a1.Logger.Debug("GetAllPolicyInstance")
+ var policyTypeInstances = []models.PolicyInstanceID{}
+
+ keys, err := rh.db.GetAll("A1m_ns")
+
+ if err != nil {
+ a1.Logger.Error("error in retrieving policy. err: %v", err)
+ return policyTypeInstances, err
+ }
+ a1.Logger.Debug("keys : %+v", keys)
+ typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
+
+ for _, key := range keys {
+ if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
+ pti := strings.Split(strings.Trim(key, " "), typekey)[1]
+ a1.Logger.Debug("pti %+v", pti)
+ policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
+ }
+ }
+
+ if len(policyTypeInstances) == 0 {
+ a1.Logger.Debug("policy instance Not Present ")
+ }
+
+ a1.Logger.Debug("return : %+v", policyTypeInstances)
+ return policyTypeInstances, nil
+}
+
+func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
+ a1.Logger.Debug("DeletePolicyType")
+
+ policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
+ if err != nil {
+ a1.Logger.Error("error in retrieving policy. err: %v", err)
+ return err
+ }
+
+ var keys [1]string
+ key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ keys[0] = key
+ if len(policyinstances) == 0 {
+ err := rh.db.Remove(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("error in deleting policy type err: %v", err)
+ return err
+ }
+ } else {
+ a1.Logger.Error("tried to delete a type that isn't empty")
+ return policyTypeCanNotBeDeletedError
+ }
+ return nil
+}
+
+func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
+ var keys [1]string
+
+ typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
+ keys[0] = typekey
+
+ a1.Logger.Debug("key1 : %+v", typekey)
+ valmap, err := rh.db.Get(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("error in retrieving policytype err: %v", err)
+ return err
+ }
+ if len(valmap) == 0 {
+ a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
+ return policyTypeNotFoundError
+ }
+}
+
+func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
+ err := rh.typeValidity(policyTypeId)
+ if err != nil {
+ return err
+ }
+ policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
+ if err != nil {
+ a1.Logger.Error("policy instance error : %v", err)
+ return err
+ }
+ if len(policyTypeInstances.(string)) == 0 {
+ a1.Logger.Debug("policy instance Not Present ")
+ return policyInstanceNotFoundError
+ }
+}
+
+func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
+ instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
+ var keys [1]string
+ keys[0] = instanceMetadataKey
+ instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("policy instance error : %v", err)
+ }
+ a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
+ if instanceMetadataMap[instanceMetadataKey] == nil {
+ a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
+ return map[string]interface{}{}, policyInstanceNotFoundError
+ }
+ return instanceMetadataMap, nil
+}
+
+func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
+ err := rh.instanceValidity(policyTypeId, policyInstanceID)
+ if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
+ policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
+ return &policyInstanceStatus, err
+ }
+ policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
+ metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
+ a1.Logger.Debug(" metadata %v", metadata)
+ if err != nil {
+ a1.Logger.Error("policy instance error : %v", err)
+ policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
+ return &policyInstanceStatus, err
+ }
+ jsonbody, err := json.Marshal(metadata)
+ if err != nil {
+ a1.Logger.Error("marshal error : %v", err)
+ return &policyInstanceStatus, err
+ }
+
+ if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
+ a1.Logger.Error("unmarshal error : %v", err)
+ //this error maps to 503 error but can be mapped to 500: internal error
+ return &policyInstanceStatus, err
+ }
+ if policyInstanceStatus.HasBeenDeleted == false {
+ policyInstanceStatus.InstanceStatus = "IN EFFECT"
+ } else {
+ policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
+ }
+ return &policyInstanceStatus, nil
+}
+
+func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
+ deleted_timestamp := time.Now()
+
+ instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+
+ a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
+
+ var metadatajson interface{}
+ metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
+ a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
+ deletedmetadata, err := json.Marshal(metadatajson)
+
+ a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
+
+ err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
+ a1.Logger.Debug("deletemetadatacreated")
+ if err != nil {
+ a1.Logger.Error("error :%+v", err)
+ return err
+ }
+
+ a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
+
+ return nil
+}
+
+func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
+ var keys [1]string
+ instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ keys[0] = instancekey
+ err := rh.db.Remove(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("error in deleting policy type err: %v", err)
+ return err
+ }
+ return nil
+}
+
+func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
+ var keys [1]string
+ instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+
+ a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
+ keys[0] = instanceMetadataKey
+ err := rh.db.Remove(a1MediatorNs, keys[:])
+ if err != nil {
+ a1.Logger.Error("error in deleting policy metadata err: %v", err)
+ return err
+ }
+ return nil
+}
+
+func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
+ err := rh.instanceValidity(policyTypeId, policyInstanceID)
+ if err != nil {
+ a1.Logger.Error("policy instance error : %v", err)
+ if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
+ return err
+ }
+ }
+
+ createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
+ if err != nil {
+ a1.Logger.Error("error : %v", err)
+ return err
+ }
+ a1.Logger.Debug(" created metadata %v", createdmetadata)
+ instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
+ creation_metadata := createdmetadata[instanceMetadataKey]
+ var metadata map[string]interface{}
+ if err = json.Unmarshal([]byte(creation_metadata.(string)), &metadata); err != nil {
+ a1.Logger.Error("unmarshal error : %v", err)
+ return err
+ }
+
+ a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
+ creation_timestamp := metadata["created_at"]
+
+ rh.deleteMetadata(policyTypeId, policyInstanceID)
+
+ rh.deleteInstancedata(policyTypeId, policyInstanceID)
+
+ rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
+
+ message := rmr.Message{}
+ rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
+ if err1 != nil {
+ a1.Logger.Error("error : %v", err1)
+ return err1
+ }
+ isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
+ if isSent {
+ a1.Logger.Debug("rmrSendToXapp : message sent")
+ } else {
+ //TODO:if message not sent need to return error or just log it or retry sending
+ a1.Logger.Error("rmrSendToXapp : message not sent")
+ }
+
+ return nil
+}
+
+func (rh *Resthook) DataDelivery(httpBody interface{}) error {
+ a1.Logger.Debug("httpbody : %+v", httpBody)
+ mymap := httpBody.(map[string]interface{})
+ message := rmr.Message{}
+ rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
+ if err != nil {
+ a1.Logger.Error("error : %v", err)
+ return err
+ }
+ a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
+ isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
+ if isSent {
+ a1.Logger.Debug("rmrSendToXapp : message sent")
+ } else {
+ a1.Logger.Error("rmrSendToXapp : message not sent")
+ }
+ return nil
+}
Code Review / ric-plt / a1.git / blobdiff