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 //TODO : Add database healthcheck
106 a1.Logger.Debug("A1 is healthy")
110 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
112 var policyTypeIDs []models.PolicyTypeID
114 keys, err := rh.db.GetAll("A1m_ns")
117 a1.Logger.Error("error in retrieving policy. err: %v", err)
120 a1.Logger.Debug("keys : %+v", keys)
122 for _, key := range keys {
123 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
124 pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
125 ptii, _ := strconv.ParseInt(pti, 10, 64)
126 policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
130 a1.Logger.Debug("return : %+v", policyTypeIDs)
134 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
135 a1.Logger.Debug("GetPolicyType1")
137 var policytypeschema *models.PolicyTypeSchema
140 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
143 a1.Logger.Debug("key : %+v", key)
145 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
147 a1.Logger.Debug("policytype map : %+v", valmap)
149 if len(valmap) == 0 {
150 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
151 return policytypeschema
155 a1.Logger.Error("error in retrieving policy type. err: %v", err)
159 if valmap[key] == nil {
160 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
161 return policytypeschema
164 a1.Logger.Debug("keysmap : %+v", valmap[key])
166 var item models.PolicyTypeSchema
167 valStr := fmt.Sprint(valmap[key])
169 a1.Logger.Debug("Policy type for %+v : %+v", key, valStr)
170 valkey := "`" + valStr + "`"
171 valToUnmarshall, err := strconv.Unquote(valkey)
173 a1.Logger.Error("unquote error : %+v", err)
177 a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
179 errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
181 a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
182 a1.Logger.Debug("Policy type Name : %v", (item.Name))
187 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
188 a1.Logger.Debug("CreatePolicyType function")
189 if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
191 a1.Logger.Debug("Policytype Mismatch")
192 return typeMismatchError
194 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
195 a1.Logger.Debug("key %+v ", key)
196 if data, err := httprequest.MarshalBinary(); err == nil {
197 a1.Logger.Debug("Marshaled String : %+v", string(data))
198 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
199 a1.Logger.Info("success:%+v", success)
201 a1.Logger.Error("error :%+v", err1)
205 a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
206 return typeAlreadyError
212 func toStringKeys(val interface{}) (interface{}, error) {
214 switch val := val.(type) {
215 case map[interface{}]interface{}:
216 m := make(map[string]interface{})
217 for k, v := range val {
220 return nil, errors.New("found non-string key")
222 m[k], err = toStringKeys(v)
229 var l = make([]interface{}, len(val))
230 for i, v := range val {
231 l[i], err = toStringKeys(v)
242 func validate(httpBodyString string, schemaString string) bool {
244 err := yaml.Unmarshal([]byte(httpBodyString), &m)
246 a1.Logger.Error("Unmarshal error : %+v", err)
248 m, err = toStringKeys(m)
250 a1.Logger.Error("Conversion to string error : %+v", err)
253 compiler := jsonschema.NewCompiler()
254 if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
255 a1.Logger.Error("string reader error : %+v", err)
258 schema, err := compiler.Compile("schema.json")
260 a1.Logger.Error("schema json compile error : %+v", err)
263 if err := schema.Validate(m); err != nil {
264 a1.Logger.Error("schema validation error : %+v", err)
267 a1.Logger.Debug("validation successfull")
271 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
273 operation := "CREATE"
274 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
277 a1.Logger.Debug("key1 : %+v", typekey)
279 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
281 a1.Logger.Error("policy type error : %+v", err)
283 a1.Logger.Debug("policytype map : %+v", valmap)
284 if valmap[typekey] == nil {
285 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
286 return operation, policyTypeNotFoundError
288 // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
290 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
292 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
294 a1.Logger.Error("policy type error : %v", err)
296 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
298 if instanceMap[instancekey] != nil {
300 a1.Logger.Debug("UPDATE")
301 data, _ := json.Marshal(httpBody)
302 a1.Logger.Debug("Marshaled String : %+v", string(data))
303 a1.Logger.Debug("key : %+v", instancekey)
304 success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
306 a1.Logger.Error("error2 :%+v", err1)
307 return operation, err1
310 a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
311 return operation, InstanceAlreadyError
314 data, _ := json.Marshal(httpBody)
315 a1.Logger.Debug("Marshaled String : %+v", string(data))
316 a1.Logger.Debug("key : %+v", instancekey)
318 var instance_map []interface{}
319 instance_map = append(instance_map, instancekey, string(data))
320 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
321 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
323 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
325 a1.Logger.Error("error1 :%+v", err1)
326 return operation, err1
329 a1.Logger.Debug("Policy Instance created ")
330 return operation, nil
333 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
335 creation_timestamp := time.Now()
336 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
338 a1.Logger.Debug("key : %+v", instanceMetadataKey)
340 var metadatajson []interface{}
341 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
342 metadata, _ := json.Marshal(metadatajson)
344 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
346 err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
349 a1.Logger.Error("error :%+v", err)
353 a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
358 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
359 a1.Logger.Debug("CreatePolicyInstance function")
360 // validate the PUT against the schema
361 var policyTypeSchema *models.PolicyTypeSchema
362 policyTypeSchema = rh.GetPolicyType(policyTypeId)
363 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
365 a1.Logger.Error("Json Marshal error : %+v", err)
368 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
369 a1.Logger.Debug("httpbody to validate %+v", httpBody)
370 schemaString := fmt.Sprint(string(schemaStr))
371 httpBodyMarshal, err := json.Marshal(httpBody)
372 httpBodyString := string((httpBodyMarshal))
373 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
374 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
375 isvalid := validate(httpBodyString, schemaString)
378 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
380 a1.Logger.Error("error :%+v", err)
383 a1.Logger.Debug("policy instance :%+v", operation)
384 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
385 if errmetadata != nil {
386 a1.Logger.Error("error :%+v", errmetadata)
390 a1.Logger.Debug("policy instance metadata created")
393 message := rmr.Message{}
394 rmrMessage, err := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
396 a1.Logger.Error("error : %v", err)
399 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
401 a1.Logger.Debug("rmrSendToXapp : message sent")
403 a1.Logger.Debug("rmrSendToXapp : message not sent")
407 a1.Logger.Error("%+v", invalidJsonSchema)
408 return invalidJsonSchema
414 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
415 a1.Logger.Debug("GetPolicyInstance1")
419 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
422 a1.Logger.Debug("key1 : %+v", typekey)
424 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
425 if len(valmap) == 0 {
426 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
427 return map[string]interface{}{}, policyTypeNotFoundError
431 a1.Logger.Error("error in retrieving policy type. err: %v", err)
432 return map[string]interface{}{}, err
435 if valmap[typekey] == nil {
436 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
437 return map[string]interface{}{}, policyTypeNotFoundError
440 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
442 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
443 a1.Logger.Debug("key2 : %+v", instancekey)
444 keys[0] = instancekey
445 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
447 a1.Logger.Error("policy instance error : %v", err)
449 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
451 if instanceMap[instancekey] == nil {
452 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
453 return map[string]interface{}{}, policyInstanceNotFoundError
456 var valStr map[string]interface{}
457 err = json.Unmarshal([]byte(instanceMap[instancekey].(string)), &valStr)
459 fmt.Println("error:", err)
465 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
466 a1.Logger.Debug("GetAllPolicyInstance")
467 var policyTypeInstances = []models.PolicyInstanceID{}
469 keys, err := rh.db.GetAll("A1m_ns")
472 a1.Logger.Error("error in retrieving policy. err: %v", err)
473 return policyTypeInstances, err
475 a1.Logger.Debug("keys : %+v", keys)
476 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
478 for _, key := range keys {
479 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
480 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
481 a1.Logger.Debug("pti %+v", pti)
482 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
486 if len(policyTypeInstances) == 0 {
487 a1.Logger.Debug("policy instance Not Present ")
490 a1.Logger.Debug("return : %+v", policyTypeInstances)
491 return policyTypeInstances, nil
494 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
495 a1.Logger.Debug("DeletePolicyType")
497 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
499 a1.Logger.Error("error in retrieving policy. err: %v", err)
504 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
506 if len(policyinstances) == 0 {
507 err := rh.db.Remove(a1MediatorNs, keys[:])
509 a1.Logger.Error("error in deleting policy type err: %v", err)
513 a1.Logger.Error("tried to delete a type that isn't empty")
514 return policyTypeCanNotBeDeletedError
519 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
522 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
525 a1.Logger.Debug("key1 : %+v", typekey)
526 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
528 a1.Logger.Error("error in retrieving policytype err: %v", err)
531 if len(valmap) == 0 {
532 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
533 return policyTypeNotFoundError
538 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
539 err := rh.typeValidity(policyTypeId)
543 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
545 a1.Logger.Error("policy instance error : %v", err)
548 if policyTypeInstances == nil {
549 a1.Logger.Debug("policy instance Not Present ")
550 return policyInstanceNotFoundError
555 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
556 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
557 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
559 keys[0] = instanceMetadataKey
560 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
562 a1.Logger.Error("policy instance error : %v", err)
564 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
565 if instanceMetadataMap[instanceMetadataKey] == nil {
566 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
567 return map[string]interface{}{}, policyInstanceNotFoundError
569 return instanceMetadataMap, nil
572 func (rh *Resthook) getPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
573 instancehandlerKey := a1HandlerPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
575 keys[0] = instancehandlerKey
576 resp, err := rh.db.Get(a1MediatorNs, keys[:])
578 a1.Logger.Error("error1 :%+v", err)
581 for _, key := range resp {
589 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
590 err := rh.instanceValidity(policyTypeId, policyInstanceID)
591 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
592 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
593 if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
594 return &policyInstanceStatus, err
596 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
597 a1.Logger.Debug(" metadata %v", metadata)
599 a1.Logger.Error("policy instance error : %v", err)
600 return &policyInstanceStatus, err
602 jsonbody, err := json.Marshal(metadata)
604 a1.Logger.Error("marshal error : %v", err)
605 return &policyInstanceStatus, err
608 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
609 a1.Logger.Error("unmarshal error : %v", err)
610 //this error maps to 503 error but can be mapped to 500: internal error
611 return &policyInstanceStatus, err
613 resp, err := rh.getPolicyInstanceStatus(policyTypeId, policyInstanceID)
614 if err != nil || (err == nil && resp == false) {
615 a1.Logger.Error("marshal error : %v", err)
616 return &policyInstanceStatus, err
617 } else if policyInstanceStatus.HasBeenDeleted == true {
618 policyInstanceStatus.InstanceStatus = "IN EFFECT"
620 return &policyInstanceStatus, nil
623 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
624 deleted_timestamp := time.Now()
626 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
628 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
630 var metadatajson interface{}
631 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
632 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
633 deletedmetadata, err := json.Marshal(metadatajson)
635 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
637 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
638 a1.Logger.Debug("deletemetadatacreated")
640 a1.Logger.Error("error :%+v", err)
644 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
649 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
651 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
652 keys[0] = instancekey
653 err := rh.db.Remove(a1MediatorNs, keys[:])
655 a1.Logger.Error("error in deleting policy type err: %v", err)
661 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
663 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
665 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
666 keys[0] = instanceMetadataKey
667 err := rh.db.Remove(a1MediatorNs, keys[:])
669 a1.Logger.Error("error in deleting policy metadata err: %v", err)
675 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
676 err := rh.instanceValidity(policyTypeId, policyInstanceID)
678 a1.Logger.Error("policy instance error : %v", err)
679 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
684 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
686 a1.Logger.Error("error : %v", err)
689 a1.Logger.Debug(" created metadata %v", createdmetadata)
690 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
691 creation_metadata := createdmetadata[instanceMetadataKey]
692 var metadata map[string]interface{}
693 creation_metadata_string := creation_metadata.(string)
694 creation_metadata_string = strings.TrimRight(creation_metadata_string, "]")
695 creation_metadata_string = strings.TrimLeft(creation_metadata_string, "[")
696 if err = json.Unmarshal([]byte(creation_metadata_string), &metadata); err != nil {
697 a1.Logger.Error("unmarshal error : %v", err)
701 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
702 creation_timestamp := metadata["created_at"]
704 rh.deleteMetadata(policyTypeId, policyInstanceID)
706 rh.deleteInstancedata(policyTypeId, policyInstanceID)
708 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
710 message := rmr.Message{}
711 rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
713 a1.Logger.Error("error : %v", err1)
716 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
718 a1.Logger.Debug("rmrSendToXapp : message sent")
720 //TODO:if message not sent need to return error or just log it or retry sending
721 a1.Logger.Error("rmrSendToXapp : message not sent")
727 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
728 a1.Logger.Debug("httpbody : %+v", httpBody)
729 mymap := httpBody.(map[string]interface{})
730 message := rmr.Message{}
731 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
733 a1.Logger.Error("error : %v", err)
736 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
737 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
739 a1.Logger.Debug("rmrSendToXapp : message sent")
741 a1.Logger.Error("rmrSendToXapp : message not sent")