2 ==================================================================================
3 Copyright (c) 2021 Samsung
5 Licensed under the Apache License, Version 2.0 (the "License");
6 you may not use this file except in compliance with the License.
7 You may obtain a copy of the License at
9 http://www.apache.org/licenses/LICENSE-2.0
11 Unless required by applicable law or agreed to in writing, software
12 distributed under the License is distributed on an "AS IS" BASIS,
13 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 See the License for the specific language governing permissions and
15 limitations under the License.
17 This source code is part of the near-RT RIC (RAN Intelligent Controller)
18 platform project (RICP).
19 ==================================================================================
31 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
32 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
33 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/policy"
34 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/restapi/operations/a1_mediator"
35 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/rmr"
36 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
37 "github.com/santhosh-tekuri/jsonschema/v5"
42 a1PolicyPrefix = "a1.policy_type."
43 a1MediatorNs = "A1m_ns"
44 a1InstancePrefix = "a1.policy_instance."
45 a1InstanceMetadataPrefix = "a1.policy_inst_metadata."
46 a1HandlerPrefix = "a1.policy_handler."
47 a1PolicyRequest = 20010
48 a1EIDataDelivery = 20017
51 var typeAlreadyError = errors.New("Policy Type already exists")
52 var InstanceAlreadyError = errors.New("Policy Instance already exists")
53 var typeMismatchError = errors.New("Policytype Mismatch")
54 var invalidJsonSchema = errors.New("Invalid Json ")
55 var policyInstanceNotFoundError = errors.New("Policy Instance Not Found")
56 var policyTypeNotFoundError = errors.New("Policy Type Not Found")
57 var policyTypeCanNotBeDeletedError = errors.New("tried to delete a type that isn't empty")
58 var policyInstanceCanNotBeDeletedError = errors.New("tried to delete a Instance that isn't empty")
60 func (rh *Resthook) CanPolicyInstanceBeDeleted(err error) bool {
61 return err == policyInstanceCanNotBeDeletedError
64 func (rh *Resthook) CanPolicyTypeBeDeleted(err error) bool {
65 return err == policyTypeCanNotBeDeletedError
68 func (rh *Resthook) IsPolicyTypePresent(err error) bool {
69 return err == policyTypeNotFoundError
72 func (rh *Resthook) IsPolicyInstanceNotFound(err error) bool {
73 return err == policyInstanceNotFoundError
76 func (rh *Resthook) IsTypeAlready(err error) bool {
77 return err == typeAlreadyError
79 func (rh *Resthook) IsInstanceAlready(err error) bool {
80 return err == InstanceAlreadyError
82 func (rh *Resthook) IsTypeMismatch(err error) bool {
83 return err == typeMismatchError
86 func (rh *Resthook) IsValidJson(err error) bool {
87 return err == invalidJsonSchema
89 func NewResthook() *Resthook {
90 sdl := sdlgo.NewSyncStorage()
91 policyManager := policy.NewPolicyManager(sdl)
92 return createResthook(sdl, rmr.NewRMRSender(policyManager))
95 func createResthook(sdlInst iSdl, rmrSenderInst rmr.IRmrSender) *Resthook {
98 iRmrSenderInst: rmrSenderInst,
104 func (rh *Resthook) GetA1Health() bool {
105 data, _ := rh.db.GetAll(a1MediatorNs)
107 a1.Logger.Debug("Database connected and A1 is healthy")
113 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
115 var policyTypeIDs []models.PolicyTypeID
117 keys, err := rh.db.GetAll("A1m_ns")
120 a1.Logger.Error("error in retrieving policy. err: %v", err)
123 a1.Logger.Debug("keys : %+v", keys)
125 for _, key := range keys {
126 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
127 pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
128 ptii, _ := strconv.ParseInt(pti, 10, 64)
129 policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
133 a1.Logger.Debug("return : %+v", policyTypeIDs)
137 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
138 a1.Logger.Debug("GetPolicyType1")
140 var policytypeschema *models.PolicyTypeSchema
143 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
146 a1.Logger.Debug("key : %+v", key)
148 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
150 a1.Logger.Debug("policytype map : %+v", valmap)
152 if len(valmap) == 0 {
153 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
154 return policytypeschema
158 a1.Logger.Error("error in retrieving policy type. err: %v", err)
162 if valmap[key] == nil {
163 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
164 return policytypeschema
167 a1.Logger.Debug("keysmap : %+v", valmap[key])
169 var item models.PolicyTypeSchema
170 valStr := fmt.Sprint(valmap[key])
172 a1.Logger.Debug("Policy type for %+v : %+v", key, valStr)
173 valkey := "`" + valStr + "`"
174 valToUnmarshall, err := strconv.Unquote(valkey)
176 a1.Logger.Error("unquote error : %+v", err)
180 a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
182 errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
184 a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
185 a1.Logger.Debug("Policy type Name : %v", (item.Name))
190 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
191 a1.Logger.Debug("CreatePolicyType function")
192 if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
194 a1.Logger.Debug("Policytype Mismatch")
195 return typeMismatchError
197 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
198 a1.Logger.Debug("key %+v ", key)
199 if data, err := httprequest.MarshalBinary(); err == nil {
200 a1.Logger.Debug("Marshaled String : %+v", string(data))
201 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
202 a1.Logger.Info("success:%+v", success)
204 a1.Logger.Error("error :%+v", err1)
208 a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
209 return typeAlreadyError
215 func toStringKeys(val interface{}) (interface{}, error) {
217 switch val := val.(type) {
218 case map[interface{}]interface{}:
219 m := make(map[string]interface{})
220 for k, v := range val {
223 return nil, errors.New("found non-string key")
225 m[k], err = toStringKeys(v)
232 var l = make([]interface{}, len(val))
233 for i, v := range val {
234 l[i], err = toStringKeys(v)
245 func validate(httpBodyString string, schemaString string) bool {
247 err := yaml.Unmarshal([]byte(httpBodyString), &m)
249 a1.Logger.Error("Unmarshal error : %+v", err)
251 m, err = toStringKeys(m)
253 a1.Logger.Error("Conversion to string error : %+v", err)
256 compiler := jsonschema.NewCompiler()
257 if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
258 a1.Logger.Error("string reader error : %+v", err)
261 schema, err := compiler.Compile("schema.json")
263 a1.Logger.Error("schema json compile error : %+v", err)
266 if err := schema.Validate(m); err != nil {
267 a1.Logger.Error("schema validation error : %+v", err)
270 a1.Logger.Debug("validation successfull")
274 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
276 operation := "CREATE"
277 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
280 a1.Logger.Debug("key1 : %+v", typekey)
282 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
284 a1.Logger.Error("policy type error : %+v", err)
286 a1.Logger.Debug("policytype map : %+v", valmap)
287 if valmap[typekey] == nil {
288 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
289 return operation, policyTypeNotFoundError
291 // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
293 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
295 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
297 a1.Logger.Error("policy type error : %v", err)
299 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
301 if instanceMap[instancekey] != nil {
303 a1.Logger.Debug("UPDATE")
304 data, _ := json.Marshal(httpBody)
305 a1.Logger.Debug("Marshaled String : %+v", string(data))
306 a1.Logger.Debug("key : %+v", instancekey)
307 success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
309 a1.Logger.Error("error2 :%+v", err1)
310 return operation, err1
313 a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
314 return operation, InstanceAlreadyError
317 data, _ := json.Marshal(httpBody)
318 a1.Logger.Debug("Marshaled String : %+v", string(data))
319 a1.Logger.Debug("key : %+v", instancekey)
321 var instance_map []interface{}
322 instance_map = append(instance_map, instancekey, string(data))
323 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
324 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
326 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
328 a1.Logger.Error("error1 :%+v", err1)
329 return operation, err1
332 a1.Logger.Debug("Policy Instance created ")
333 return operation, nil
336 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
338 creation_timestamp := time.Now()
339 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
341 a1.Logger.Debug("key : %+v", instanceMetadataKey)
343 var metadatajson []interface{}
344 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
345 metadata, _ := json.Marshal(metadatajson)
347 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
349 err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
352 a1.Logger.Error("error :%+v", err)
356 a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
361 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
362 a1.Logger.Debug("CreatePolicyInstance function")
363 // validate the PUT against the schema
364 var policyTypeSchema *models.PolicyTypeSchema
365 policyTypeSchema = rh.GetPolicyType(policyTypeId)
366 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
368 a1.Logger.Error("Json Marshal error : %+v", err)
371 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
372 a1.Logger.Debug("httpbody to validate %+v", httpBody)
373 schemaString := fmt.Sprint(string(schemaStr))
374 httpBodyMarshal, err := json.Marshal(httpBody)
375 httpBodyString := string((httpBodyMarshal))
376 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
377 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
378 isvalid := validate(httpBodyString, schemaString)
381 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
383 a1.Logger.Error("error :%+v", err)
386 a1.Logger.Debug("policy instance :%+v", operation)
387 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
388 if errmetadata != nil {
389 a1.Logger.Error("error :%+v", errmetadata)
393 a1.Logger.Debug("policy instance metadata created")
396 message := rmr.Message{}
397 rmrMessage, err := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
399 a1.Logger.Error("error : %v", err)
402 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
404 a1.Logger.Debug("rmrSendToXapp : message sent")
406 a1.Logger.Debug("rmrSendToXapp : message not sent")
410 a1.Logger.Error("%+v", invalidJsonSchema)
411 return invalidJsonSchema
417 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
418 a1.Logger.Debug("GetPolicyInstance1")
422 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
425 a1.Logger.Debug("key1 : %+v", typekey)
427 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
428 if len(valmap) == 0 {
429 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
430 return map[string]interface{}{}, policyTypeNotFoundError
434 a1.Logger.Error("error in retrieving policy type. err: %v", err)
435 return map[string]interface{}{}, err
438 if valmap[typekey] == nil {
439 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
440 return map[string]interface{}{}, policyTypeNotFoundError
443 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
445 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
446 a1.Logger.Debug("key2 : %+v", instancekey)
447 keys[0] = instancekey
448 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
450 a1.Logger.Error("policy instance error : %v", err)
452 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
454 if instanceMap[instancekey] == nil {
455 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
456 return map[string]interface{}{}, policyInstanceNotFoundError
459 var valStr map[string]interface{}
460 err = json.Unmarshal([]byte(instanceMap[instancekey].(string)), &valStr)
462 fmt.Println("error:", err)
468 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
469 a1.Logger.Debug("GetAllPolicyInstance")
470 var policyTypeInstances = []models.PolicyInstanceID{}
472 keys, err := rh.db.GetAll("A1m_ns")
475 a1.Logger.Error("error in retrieving policy. err: %v", err)
476 return policyTypeInstances, err
478 a1.Logger.Debug("keys : %+v", keys)
479 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
481 for _, key := range keys {
482 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
483 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
484 a1.Logger.Debug("pti %+v", pti)
485 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
489 if len(policyTypeInstances) == 0 {
490 a1.Logger.Debug("policy instance Not Present ")
493 a1.Logger.Debug("return : %+v", policyTypeInstances)
494 return policyTypeInstances, nil
497 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
498 a1.Logger.Debug("DeletePolicyType")
500 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
502 a1.Logger.Error("error in retrieving policy. err: %v", err)
507 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
509 if len(policyinstances) == 0 {
510 err := rh.db.Remove(a1MediatorNs, keys[:])
512 a1.Logger.Error("error in deleting policy type err: %v", err)
516 a1.Logger.Error("tried to delete a type that isn't empty")
517 return policyTypeCanNotBeDeletedError
522 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
525 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
528 a1.Logger.Debug("key1 : %+v", typekey)
529 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
531 a1.Logger.Error("error in retrieving policytype err: %v", err)
534 if len(valmap) == 0 {
535 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
536 return policyTypeNotFoundError
541 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
542 err := rh.typeValidity(policyTypeId)
546 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
548 a1.Logger.Error("policy instance error : %v", err)
551 if policyTypeInstances == nil {
552 a1.Logger.Debug("policy instance Not Present ")
553 return policyInstanceNotFoundError
558 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
559 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
560 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
562 keys[0] = instanceMetadataKey
563 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
565 a1.Logger.Error("policy instance error : %v", err)
567 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
568 if instanceMetadataMap[instanceMetadataKey] == nil {
569 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
570 return map[string]interface{}{}, policyInstanceNotFoundError
572 return instanceMetadataMap, nil
575 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
576 err := rh.instanceValidity(policyTypeId, policyInstanceID)
577 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
578 if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
579 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
580 return &policyInstanceStatus, err
582 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
583 a1.Logger.Debug(" metadata %v", metadata)
585 a1.Logger.Error("policy instance error : %v", err)
586 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
587 return &policyInstanceStatus, err
589 jsonbody, err := json.Marshal(metadata)
591 a1.Logger.Error("marshal error : %v", err)
592 return &policyInstanceStatus, err
595 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
596 a1.Logger.Error("unmarshal error : %v", err)
597 //this error maps to 503 error but can be mapped to 500: internal error
598 return &policyInstanceStatus, err
600 if policyInstanceStatus.HasBeenDeleted == false {
601 policyInstanceStatus.InstanceStatus = "IN EFFECT"
603 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
605 return &policyInstanceStatus, nil
608 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
609 deleted_timestamp := time.Now()
611 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
613 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
615 var metadatajson interface{}
616 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
617 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
618 deletedmetadata, err := json.Marshal(metadatajson)
620 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
622 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
623 a1.Logger.Debug("deletemetadatacreated")
625 a1.Logger.Error("error :%+v", err)
629 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
634 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
636 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
637 keys[0] = instancekey
638 err := rh.db.Remove(a1MediatorNs, keys[:])
640 a1.Logger.Error("error in deleting policy type err: %v", err)
646 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
648 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
650 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
651 keys[0] = instanceMetadataKey
652 err := rh.db.Remove(a1MediatorNs, keys[:])
654 a1.Logger.Error("error in deleting policy metadata err: %v", err)
660 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
661 err := rh.instanceValidity(policyTypeId, policyInstanceID)
663 a1.Logger.Error("policy instance error : %v", err)
664 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
669 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
671 a1.Logger.Error("error : %v", err)
674 a1.Logger.Debug(" created metadata %v", createdmetadata)
675 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
676 creation_metadata := createdmetadata[instanceMetadataKey]
677 var metadata map[string]interface{}
678 creation_metadata_string := creation_metadata.(string)
679 creation_metadata_string = strings.TrimRight(creation_metadata_string, "]")
680 creation_metadata_string = strings.TrimLeft(creation_metadata_string, "[")
681 if err = json.Unmarshal([]byte(creation_metadata_string), &metadata); err != nil {
682 a1.Logger.Error("unmarshal error : %v", err)
686 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
687 creation_timestamp := metadata["created_at"]
689 rh.deleteMetadata(policyTypeId, policyInstanceID)
691 rh.deleteInstancedata(policyTypeId, policyInstanceID)
693 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
695 message := rmr.Message{}
696 rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
698 a1.Logger.Error("error : %v", err1)
701 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
703 a1.Logger.Debug("rmrSendToXapp : message sent")
705 //TODO:if message not sent need to return error or just log it or retry sending
706 a1.Logger.Error("rmrSendToXapp : message not sent")
712 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
713 a1.Logger.Debug("httpbody : %+v", httpBody)
714 mymap := httpBody.(map[string]interface{})
715 message := rmr.Message{}
716 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
718 a1.Logger.Error("error : %v", err)
721 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
722 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
724 a1.Logger.Debug("rmrSendToXapp : message sent")
726 a1.Logger.Error("rmrSendToXapp : message not sent")