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 _, err := rh.db.GetAll("A1m_ns")
107 a1.Logger.Error("error in connecting to the database. err: %v", err)
110 a1.Logger.Debug("A1 is healthy")
114 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
116 var policyTypeIDs []models.PolicyTypeID
118 keys, err := rh.db.GetAll("A1m_ns")
121 a1.Logger.Error("error in retrieving policy. err: %v", err)
124 a1.Logger.Debug("keys : %+v", keys)
126 for _, key := range keys {
127 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
128 pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
129 ptii, _ := strconv.ParseInt(pti, 10, 64)
130 policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
134 a1.Logger.Debug("return : %+v", policyTypeIDs)
138 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
139 a1.Logger.Debug("GetPolicyType1")
141 var policytypeschema *models.PolicyTypeSchema
144 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
147 a1.Logger.Debug("key : %+v", key)
149 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
151 a1.Logger.Debug("policytype map : %+v", valmap)
153 if len(valmap) == 0 {
154 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
155 return policytypeschema
159 a1.Logger.Error("error in retrieving policy type. err: %v", err)
163 if valmap[key] == nil {
164 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
165 return policytypeschema
168 a1.Logger.Debug("keysmap : %+v", valmap[key])
170 var item models.PolicyTypeSchema
171 valStr := fmt.Sprint(valmap[key])
173 a1.Logger.Debug("Policy type for %+v : %+v", key, valStr)
174 valkey := "`" + valStr + "`"
175 valToUnmarshall, err := strconv.Unquote(valkey)
177 a1.Logger.Error("unquote error : %+v", err)
181 a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
183 errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
185 a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
186 a1.Logger.Debug("Policy type Name : %v", (item.Name))
191 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
192 a1.Logger.Debug("CreatePolicyType function")
193 if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
195 a1.Logger.Debug("Policytype Mismatch")
196 return typeMismatchError
198 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
199 a1.Logger.Debug("key %+v ", key)
200 if data, err := httprequest.MarshalBinary(); err == nil {
201 a1.Logger.Debug("Marshaled String : %+v", string(data))
202 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
203 a1.Logger.Info("success:%+v", success)
205 a1.Logger.Error("error :%+v", err1)
209 a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
210 return typeAlreadyError
216 func toStringKeys(val interface{}) (interface{}, error) {
218 switch val := val.(type) {
219 case map[interface{}]interface{}:
220 m := make(map[string]interface{})
221 for k, v := range val {
224 return nil, errors.New("found non-string key")
226 m[k], err = toStringKeys(v)
233 var l = make([]interface{}, len(val))
234 for i, v := range val {
235 l[i], err = toStringKeys(v)
246 func validate(httpBodyString string, schemaString string) bool {
248 err := yaml.Unmarshal([]byte(httpBodyString), &m)
250 a1.Logger.Error("Unmarshal error : %+v", err)
252 m, err = toStringKeys(m)
254 a1.Logger.Error("Conversion to string error : %+v", err)
257 compiler := jsonschema.NewCompiler()
258 if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
259 a1.Logger.Error("string reader error : %+v", err)
262 schema, err := compiler.Compile("schema.json")
264 a1.Logger.Error("schema json compile error : %+v", err)
267 if err := schema.Validate(m); err != nil {
268 a1.Logger.Error("schema validation error : %+v", err)
271 a1.Logger.Debug("validation successfull")
275 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
277 operation := "CREATE"
278 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
281 a1.Logger.Debug("key1 : %+v", typekey)
283 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
285 a1.Logger.Error("policy type error : %+v", err)
287 a1.Logger.Debug("policytype map : %+v", valmap)
288 if valmap[typekey] == nil {
289 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
290 return operation, policyTypeNotFoundError
292 // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
294 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
296 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
298 a1.Logger.Error("policy type error : %v", err)
300 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
302 if instanceMap[instancekey] != nil {
304 a1.Logger.Debug("UPDATE")
305 data, _ := json.Marshal(httpBody)
306 a1.Logger.Debug("Marshaled String : %+v", string(data))
307 a1.Logger.Debug("key : %+v", instancekey)
308 success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
310 a1.Logger.Error("error2 :%+v", err1)
311 return operation, err1
314 a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
315 return operation, InstanceAlreadyError
318 data, _ := json.Marshal(httpBody)
319 a1.Logger.Debug("Marshaled String : %+v", string(data))
320 a1.Logger.Debug("key : %+v", instancekey)
322 var instance_map []interface{}
323 instance_map = append(instance_map, instancekey, string(data))
324 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
325 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
327 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
329 a1.Logger.Error("error1 :%+v", err1)
330 return operation, err1
333 a1.Logger.Debug("Policy Instance created ")
334 return operation, nil
337 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
339 creation_timestamp := time.Now()
340 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
342 a1.Logger.Debug("key : %+v", instanceMetadataKey)
344 var metadatajson []interface{}
345 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
346 metadata, _ := json.Marshal(metadatajson)
348 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
350 err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
353 a1.Logger.Error("error :%+v", err)
357 a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
362 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
363 a1.Logger.Debug("CreatePolicyInstance function")
364 // validate the PUT against the schema
365 var policyTypeSchema *models.PolicyTypeSchema
366 policyTypeSchema = rh.GetPolicyType(policyTypeId)
367 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
369 a1.Logger.Error("Json Marshal error : %+v", err)
372 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
373 a1.Logger.Debug("httpbody to validate %+v", httpBody)
374 schemaString := fmt.Sprint(string(schemaStr))
375 httpBodyMarshal, err := json.Marshal(httpBody)
376 httpBodyString := string((httpBodyMarshal))
377 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
378 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
379 isvalid := validate(httpBodyString, schemaString)
382 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
384 a1.Logger.Error("error :%+v", err)
387 a1.Logger.Debug("policy instance :%+v", operation)
388 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
389 if errmetadata != nil {
390 a1.Logger.Error("error :%+v", errmetadata)
394 a1.Logger.Debug("policy instance metadata created")
397 message := rmr.Message{}
398 rmrMessage, err := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
400 a1.Logger.Error("error : %v", err)
403 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest, int(policyTypeId))
405 a1.Logger.Debug("rmrSendToXapp : message sent")
407 a1.Logger.Debug("rmrSendToXapp : message not sent")
411 a1.Logger.Error("%+v", invalidJsonSchema)
412 return invalidJsonSchema
418 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
419 a1.Logger.Debug("GetPolicyInstance1")
423 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
426 a1.Logger.Debug("key1 : %+v", typekey)
428 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
429 if len(valmap) == 0 {
430 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
431 return map[string]interface{}{}, policyTypeNotFoundError
435 a1.Logger.Error("error in retrieving policy type. err: %v", err)
436 return map[string]interface{}{}, err
439 if valmap[typekey] == nil {
440 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
441 return map[string]interface{}{}, policyTypeNotFoundError
444 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
446 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
447 a1.Logger.Debug("key2 : %+v", instancekey)
448 keys[0] = instancekey
449 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
451 a1.Logger.Error("policy instance error : %v", err)
453 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
455 if instanceMap[instancekey] == nil {
456 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
457 return map[string]interface{}{}, policyInstanceNotFoundError
460 var valStr map[string]interface{}
461 err = json.Unmarshal([]byte(instanceMap[instancekey].(string)), &valStr)
463 fmt.Println("error:", err)
469 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
470 a1.Logger.Debug("GetAllPolicyInstance")
471 var policyTypeInstances = []models.PolicyInstanceID{}
473 keys, err := rh.db.GetAll("A1m_ns")
476 a1.Logger.Error("error in retrieving policy. err: %v", err)
477 return policyTypeInstances, err
479 a1.Logger.Debug("keys : %+v", keys)
480 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
482 for _, key := range keys {
483 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
484 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
485 a1.Logger.Debug("pti %+v", pti)
486 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
490 if len(policyTypeInstances) == 0 {
491 a1.Logger.Debug("policy instance Not Present ")
494 a1.Logger.Debug("return : %+v", policyTypeInstances)
495 return policyTypeInstances, nil
498 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
499 a1.Logger.Debug("DeletePolicyType")
501 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
503 a1.Logger.Error("error in retrieving policy. err: %v", err)
508 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
510 if len(policyinstances) == 0 {
511 err := rh.db.Remove(a1MediatorNs, keys[:])
513 a1.Logger.Error("error in deleting policy type err: %v", err)
517 a1.Logger.Error("tried to delete a type that isn't empty")
518 return policyTypeCanNotBeDeletedError
523 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
526 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
529 a1.Logger.Debug("key1 : %+v", typekey)
530 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
532 a1.Logger.Error("error in retrieving policytype err: %v", err)
535 if len(valmap) == 0 {
536 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
537 return policyTypeNotFoundError
542 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
543 err := rh.typeValidity(policyTypeId)
547 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
549 a1.Logger.Error("policy instance error : %v", err)
552 if policyTypeInstances == nil {
553 a1.Logger.Debug("policy instance Not Present ")
554 return policyInstanceNotFoundError
559 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
560 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
561 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
563 keys[0] = instanceMetadataKey
564 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
566 a1.Logger.Error("policy instance error : %v", err)
568 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
569 if instanceMetadataMap[instanceMetadataKey] == nil {
570 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
571 return map[string]interface{}{}, policyInstanceNotFoundError
573 return instanceMetadataMap, nil
576 func (rh *Resthook) getPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
577 instancehandlerKey := a1HandlerPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
579 keys[0] = instancehandlerKey
580 resp, err := rh.db.Get(a1MediatorNs, keys[:])
582 a1.Logger.Error("error1 :%+v", err)
585 for _, key := range resp {
593 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
594 err := rh.instanceValidity(policyTypeId, policyInstanceID)
595 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
596 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
597 if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
598 return &policyInstanceStatus, err
600 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
601 a1.Logger.Debug(" metadata %v", metadata)
603 a1.Logger.Error("policy instance error : %v", err)
604 return &policyInstanceStatus, err
606 jsonbody, err := json.Marshal(metadata)
608 a1.Logger.Error("marshal error : %v", err)
609 return &policyInstanceStatus, err
612 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
613 a1.Logger.Error("unmarshal error : %v", err)
614 //this error maps to 503 error but can be mapped to 500: internal error
615 return &policyInstanceStatus, err
617 resp, err := rh.getPolicyInstanceStatus(policyTypeId, policyInstanceID)
618 if err != nil || (err == nil && resp == false) {
619 a1.Logger.Error("marshal error : %v", err)
620 return &policyInstanceStatus, err
621 } else if policyInstanceStatus.HasBeenDeleted == true {
622 policyInstanceStatus.InstanceStatus = "IN EFFECT"
624 return &policyInstanceStatus, nil
627 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
628 deleted_timestamp := time.Now()
630 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
632 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
634 var metadatajson interface{}
635 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
636 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
637 deletedmetadata, err := json.Marshal(metadatajson)
639 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
641 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
642 a1.Logger.Debug("deletemetadatacreated")
644 a1.Logger.Error("error :%+v", err)
648 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
653 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
655 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
656 keys[0] = instancekey
657 err := rh.db.Remove(a1MediatorNs, keys[:])
659 a1.Logger.Error("error in deleting policy type err: %v", err)
665 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
667 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
669 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
670 keys[0] = instanceMetadataKey
671 err := rh.db.Remove(a1MediatorNs, keys[:])
673 a1.Logger.Error("error in deleting policy metadata err: %v", err)
679 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
680 err := rh.instanceValidity(policyTypeId, policyInstanceID)
682 a1.Logger.Error("policy instance error : %v", err)
683 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
688 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
690 a1.Logger.Error("error : %v", err)
693 a1.Logger.Debug(" created metadata %v", createdmetadata)
694 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
695 creation_metadata := createdmetadata[instanceMetadataKey]
696 var metadata map[string]interface{}
697 creation_metadata_string := creation_metadata.(string)
698 creation_metadata_string = strings.TrimRight(creation_metadata_string, "]")
699 creation_metadata_string = strings.TrimLeft(creation_metadata_string, "[")
700 if err = json.Unmarshal([]byte(creation_metadata_string), &metadata); err != nil {
701 a1.Logger.Error("unmarshal error : %v", err)
705 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
706 creation_timestamp := metadata["created_at"]
708 rh.deleteMetadata(policyTypeId, policyInstanceID)
710 rh.deleteInstancedata(policyTypeId, policyInstanceID)
712 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
714 message := rmr.Message{}
715 rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
717 a1.Logger.Error("error : %v", err1)
720 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest, int(policyTypeId))
722 a1.Logger.Debug("rmrSendToXapp : message sent")
724 //TODO:if message not sent need to return error or just log it or retry sending
725 a1.Logger.Error("rmrSendToXapp : message not sent")
731 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
732 a1.Logger.Debug("httpbody : %+v", httpBody)
733 mymap := httpBody.(map[string]interface{})
734 message := rmr.Message{}
735 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
737 a1.Logger.Error("error : %v", err)
740 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
741 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery, rmr.DefaultSubId)
743 a1.Logger.Debug("rmrSendToXapp : message sent")
745 a1.Logger.Error("rmrSendToXapp : message not sent")