2 ==================================================================================
4 Copyright (c) 2021 Samsung
6 Licensed under the Apache License, Version 2.0 (the "License");
7 you may not use this file except in compliance with the License.
8 You may obtain a copy of the License at
10 http://www.apache.org/licenses/LICENSE-2.0
12 Unless required by applicable law or agreed to in writing, software
13 distributed under the License is distributed on an "AS IS" BASIS,
14 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 See the License for the specific language governing permissions and
16 limitations under the License.
18 This source code is part of the near-RT RIC (RAN Intelligent Controller)
19 platform project (RICP).
21 ==================================================================================
33 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
34 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
35 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/policy"
36 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/restapi/operations/a1_mediator"
37 "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/rmr"
38 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
39 "github.com/santhosh-tekuri/jsonschema/v5"
44 a1PolicyPrefix = "a1.policy_type."
45 a1MediatorNs = "A1m_ns"
46 a1InstancePrefix = "a1.policy_instance."
47 a1NotificationDestinationPrefix = "a1.policy_notification_destination."
48 a1InstanceMetadataPrefix = "a1.policy_inst_metadata."
49 a1HandlerPrefix = "a1.policy_handler."
50 a1PolicyRequest = 20010
51 a1EIDataDelivery = 20017
54 var typeAlreadyError = errors.New("Policy Type already exists")
55 var InstanceAlreadyError = errors.New("Policy Instance already exists")
56 var typeMismatchError = errors.New("Policytype Mismatch")
57 var invalidJsonSchema = errors.New("Invalid Json ")
58 var policyInstanceNotFoundError = errors.New("Policy Instance Not Found")
59 var policyTypeNotFoundError = errors.New("Policy Type Not Found")
60 var policyTypeCanNotBeDeletedError = errors.New("tried to delete a type that isn't empty")
61 var policyInstanceCanNotBeDeletedError = errors.New("tried to delete a Instance that isn't empty")
63 func (rh *Resthook) CanPolicyInstanceBeDeleted(err error) bool {
64 return err == policyInstanceCanNotBeDeletedError
67 func (rh *Resthook) CanPolicyTypeBeDeleted(err error) bool {
68 return err == policyTypeCanNotBeDeletedError
71 func (rh *Resthook) IsPolicyTypeNotFound(err error) bool {
72 return err == policyTypeNotFoundError
75 func (rh *Resthook) IsPolicyInstanceNotFound(err error) bool {
76 return err == policyInstanceNotFoundError
79 func (rh *Resthook) IsTypeAlready(err error) bool {
80 return err == typeAlreadyError
82 func (rh *Resthook) IsInstanceAlready(err error) bool {
83 return err == InstanceAlreadyError
85 func (rh *Resthook) IsTypeMismatch(err error) bool {
86 return err == typeMismatchError
89 func (rh *Resthook) IsValidJson(err error) bool {
90 return err == invalidJsonSchema
92 func NewResthook() *Resthook {
93 sdl := sdlgo.NewSyncStorage()
94 policyManager := policy.NewPolicyManager(sdl)
95 return createResthook(sdl, rmr.NewRMRSender(policyManager))
98 func createResthook(sdlInst iSdl, rmrSenderInst rmr.IRmrSender) *Resthook {
101 iRmrSenderInst: rmrSenderInst,
107 func (rh *Resthook) GetA1Health() bool {
108 _, err := rh.db.GetAll("A1m_ns")
110 a1.Logger.Error("error in connecting to the database. err: %v", err)
113 a1.Logger.Debug("A1 is healthy")
117 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
119 var policyTypeIDs []models.PolicyTypeID
121 keys, err := rh.db.GetAll("A1m_ns")
124 a1.Logger.Error("error in retrieving policy. err: %v", err)
127 a1.Logger.Debug("keys : %+v", keys)
129 for _, key := range keys {
130 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
131 pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
132 ptii, _ := strconv.ParseInt(pti, 10, 64)
133 policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
137 a1.Logger.Debug("return : %+v", policyTypeIDs)
141 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
142 a1.Logger.Debug("GetPolicyType1")
144 var policytypeschema *models.PolicyTypeSchema
147 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
150 a1.Logger.Debug("key : %+v", key)
152 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
154 a1.Logger.Debug("policytype map : %+v", valmap)
156 if len(valmap) == 0 {
157 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
158 return policytypeschema
162 a1.Logger.Error("error in retrieving policy type. err: %v", err)
166 if valmap[key] == nil {
167 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
168 return policytypeschema
171 a1.Logger.Debug("keysmap : %+v", valmap[key])
173 var item models.PolicyTypeSchema
174 valStr := fmt.Sprint(valmap[key])
176 a1.Logger.Debug("Policy type for %+v : %+v", key, valStr)
177 valkey := "`" + valStr + "`"
178 valToUnmarshall, err := strconv.Unquote(valkey)
180 a1.Logger.Error("unquote error : %+v", err)
184 a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
186 errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
188 a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
189 a1.Logger.Debug("Policy type Name : %v", (item.Name))
194 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
195 a1.Logger.Debug("CreatePolicyType function")
196 if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
198 a1.Logger.Debug("Policytype Mismatch")
199 return typeMismatchError
201 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
202 a1.Logger.Debug("key %+v ", key)
203 if data, err := httprequest.MarshalBinary(); err == nil {
204 a1.Logger.Debug("Marshaled String : %+v", string(data))
205 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
206 a1.Logger.Info("success:%+v", success)
208 a1.Logger.Error("error :%+v", err1)
212 a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
213 return typeAlreadyError
219 func toStringKeys(val interface{}) (interface{}, error) {
221 switch val := val.(type) {
222 case map[interface{}]interface{}:
223 m := make(map[string]interface{})
224 for k, v := range val {
227 return nil, errors.New("found non-string key")
229 m[k], err = toStringKeys(v)
236 var l = make([]interface{}, len(val))
237 for i, v := range val {
238 l[i], err = toStringKeys(v)
249 func validate(httpBodyString string, schemaString string) bool {
251 err := yaml.Unmarshal([]byte(httpBodyString), &m)
253 a1.Logger.Error("Unmarshal error : %+v", err)
255 m, err = toStringKeys(m)
257 a1.Logger.Error("Conversion to string error : %+v", err)
260 compiler := jsonschema.NewCompiler()
261 if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
262 a1.Logger.Error("string reader error : %+v", err)
265 schema, err := compiler.Compile("schema.json")
267 a1.Logger.Error("schema json compile error : %+v", err)
270 if err := schema.Validate(m); err != nil {
271 a1.Logger.Error("schema validation error : %+v", err)
274 a1.Logger.Debug("validation successfull")
278 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}, notificationDestination string) (string, error) {
280 operation := "CREATE"
281 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
284 a1.Logger.Debug("key1 : %+v", typekey)
286 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
288 a1.Logger.Error("policy type error : %+v", err)
290 a1.Logger.Debug("policytype map : %+v", valmap)
291 if valmap[typekey] == nil {
292 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
293 return operation, policyTypeNotFoundError
295 // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
297 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
298 notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
300 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
302 a1.Logger.Error("policy type error : %v", err)
304 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
306 if instanceMap[instancekey] != nil {
308 a1.Logger.Debug("UPDATE")
309 data, _ := json.Marshal(httpBody)
310 a1.Logger.Debug("Marshaled String : %+v", string(data))
311 a1.Logger.Debug("key : %+v", instancekey)
312 success, err := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
314 a1.Logger.Error("error2 :%+v", err)
315 return operation, err
318 a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
319 return operation, InstanceAlreadyError
322 if len(notificationDestination) > 0 {
323 if err = rh.db.Set(a1MediatorNs, notificationDestinationkey, notificationDestination); err != nil {
324 a1.Logger.Error("error3 :%+v", err)
325 return operation, err
329 data, _ := json.Marshal(httpBody)
330 a1.Logger.Debug("Marshaled String : %+v", string(data))
331 a1.Logger.Debug("key : %+v", instancekey)
333 var instance_map []interface{}
334 instance_map = append(instance_map, instancekey, string(data))
335 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
336 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
338 if err = rh.db.Set(a1MediatorNs, instancekey, string(data)); err != nil {
339 a1.Logger.Error("error4 :%+v", err)
340 return operation, err
342 if len(notificationDestination) > 0 {
343 if err := rh.db.Set(a1MediatorNs, notificationDestinationkey, notificationDestination); err != nil {
344 a1.Logger.Error("error :%+v", err)
345 return operation, err
349 a1.Logger.Debug("Policy Instance created ")
350 return operation, nil
353 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
355 creation_timestamp := time.Now()
356 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
358 a1.Logger.Debug("key : %+v", instanceMetadataKey)
360 var metadatajson []interface{}
361 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
362 metadata, _ := json.Marshal(metadatajson)
364 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
366 err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
369 a1.Logger.Error("error :%+v", err)
373 a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
378 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}, notificationDestination string) error {
379 a1.Logger.Debug("CreatePolicyInstance function")
380 // validate the PUT against the schema
381 var policyTypeSchema *models.PolicyTypeSchema
382 policyTypeSchema = rh.GetPolicyType(policyTypeId)
383 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
385 a1.Logger.Error("Json Marshal error : %+v", err)
388 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
389 a1.Logger.Debug("httpbody to validate %+v", httpBody)
390 schemaString := fmt.Sprint(string(schemaStr))
391 httpBodyMarshal, err := json.Marshal(httpBody)
392 httpBodyString := string((httpBodyMarshal))
393 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
394 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
395 isvalid := validate(httpBodyString, schemaString)
398 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody, notificationDestination)
400 a1.Logger.Error("error :%+v", err)
403 a1.Logger.Debug("policy instance :%+v", operation)
404 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
405 if errmetadata != nil {
406 a1.Logger.Error("error :%+v", errmetadata)
410 a1.Logger.Debug("policy instance metadata created")
413 message := rmr.Message{}
414 rmrMessage, err := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
416 a1.Logger.Error("error : %v", err)
419 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest, int(policyTypeId))
421 a1.Logger.Debug("rmrSendToXapp : message sent")
423 a1.Logger.Debug("rmrSendToXapp : message not sent")
427 a1.Logger.Error("%+v", invalidJsonSchema)
428 return invalidJsonSchema
434 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
435 a1.Logger.Debug("GetPolicyInstance1")
439 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
442 a1.Logger.Debug("key1 : %+v", typekey)
444 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
445 if len(valmap) == 0 {
446 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
447 return map[string]interface{}{}, policyTypeNotFoundError
451 a1.Logger.Error("error in retrieving policy type. err: %v", err)
452 return map[string]interface{}{}, err
455 if valmap[typekey] == nil {
456 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
457 return map[string]interface{}{}, policyTypeNotFoundError
460 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
462 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
463 a1.Logger.Debug("key2 : %+v", instancekey)
464 keys[0] = instancekey
465 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
467 a1.Logger.Error("policy instance error : %v", err)
469 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
471 if instanceMap[instancekey] == nil {
472 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
473 return map[string]interface{}{}, policyInstanceNotFoundError
476 var valStr map[string]interface{}
477 err = json.Unmarshal([]byte(instanceMap[instancekey].(string)), &valStr)
479 fmt.Println("error:", err)
485 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
486 a1.Logger.Debug("GetAllPolicyInstance")
487 var policyTypeInstances = []models.PolicyInstanceID{}
489 keys, err := rh.db.GetAll("A1m_ns")
492 a1.Logger.Error("error in retrieving policy. err: %v", err)
493 return policyTypeInstances, err
495 a1.Logger.Debug("keys : %+v", keys)
496 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
498 for _, key := range keys {
499 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
500 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
501 a1.Logger.Debug("pti %+v", pti)
502 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
506 if len(policyTypeInstances) == 0 {
507 a1.Logger.Debug("policy instance Not Present ")
510 a1.Logger.Debug("return : %+v", policyTypeInstances)
511 return policyTypeInstances, nil
514 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
515 a1.Logger.Debug("DeletePolicyType")
517 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
519 a1.Logger.Error("error in retrieving policy. err: %v", err)
524 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
526 if len(policyinstances) == 0 {
527 err := rh.db.Remove(a1MediatorNs, keys[:])
529 a1.Logger.Error("error in deleting policy type err: %v", err)
533 a1.Logger.Error("tried to delete a type that isn't empty")
534 return policyTypeCanNotBeDeletedError
539 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
542 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
545 a1.Logger.Debug("key1 : %+v", typekey)
546 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
548 a1.Logger.Error("error in retrieving policytype err: %v", err)
551 if len(valmap) == 0 {
552 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
553 return policyTypeNotFoundError
558 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
559 err := rh.typeValidity(policyTypeId)
563 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
565 a1.Logger.Error("policy instance error : %v", err)
568 if policyTypeInstances == nil {
569 a1.Logger.Debug("policy instance Not Present ")
570 return policyInstanceNotFoundError
575 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
576 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
577 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
579 keys[0] = instanceMetadataKey
580 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
582 a1.Logger.Error("policy instance error : %v", err)
584 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
585 if instanceMetadataMap[instanceMetadataKey] == nil {
586 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
587 return map[string]interface{}{}, policyInstanceNotFoundError
589 return instanceMetadataMap, nil
592 func (rh *Resthook) getPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
593 instancehandlerKey := a1HandlerPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
595 keys[0] = instancehandlerKey
596 resp, err := rh.db.Get(a1MediatorNs, keys[:])
598 a1.Logger.Error("error1 :%+v", err)
601 for _, key := range resp {
609 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
610 err := rh.instanceValidity(policyTypeId, policyInstanceID)
611 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
612 policyInstanceStatus.EnforceStatus = "NOT_ENFORCED"
613 policyInstanceStatus.EnforceReason = "OTHER_REASON"
614 if err != nil && (err == policyInstanceNotFoundError || err == policyTypeNotFoundError) {
615 return &policyInstanceStatus, err
617 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
618 a1.Logger.Debug(" metadata %v", metadata)
620 a1.Logger.Error("policy instance error : %v", err)
621 return &policyInstanceStatus, err
623 jsonbody, err := json.Marshal(metadata)
625 a1.Logger.Error("marshal error : %v", err)
626 return &policyInstanceStatus, err
629 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
630 a1.Logger.Error("unmarshal error : %v", err)
631 //this error maps to 503 error but can be mapped to 500: internal error
632 return &policyInstanceStatus, err
634 enforced, err := rh.getPolicyInstanceStatus(policyTypeId, policyInstanceID)
635 if err != nil || (err == nil && !enforced) {
636 a1.Logger.Error("marshal error : %v", err)
637 return &policyInstanceStatus, err
639 policyInstanceStatus.EnforceStatus = "ENFORCED"
640 policyInstanceStatus.EnforceReason = ""
641 return &policyInstanceStatus, nil
644 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
645 deleted_timestamp := time.Now()
647 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
649 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
651 var metadatajson interface{}
652 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
653 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
654 deletedmetadata, err := json.Marshal(metadatajson)
656 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
658 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
659 a1.Logger.Debug("deletemetadatacreated")
661 a1.Logger.Error("error :%+v", err)
665 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
670 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
672 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
673 keys[0] = instancekey
674 err := rh.db.Remove(a1MediatorNs, keys[:])
676 a1.Logger.Error("error in deleting policy instance err: %v", err)
682 func (rh *Resthook) deleteNotificationDestination(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
684 notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
685 keys[0] = notificationDestinationkey
686 err := rh.db.Remove(a1MediatorNs, keys[:])
688 a1.Logger.Error("error in deleting notificationDestination err: %v", err)
695 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
697 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
699 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
700 keys[0] = instanceMetadataKey
701 err := rh.db.Remove(a1MediatorNs, keys[:])
703 a1.Logger.Error("error in deleting policy metadata err: %v", err)
709 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
710 err := rh.instanceValidity(policyTypeId, policyInstanceID)
712 a1.Logger.Error("policy instance error : %v", err)
713 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
718 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
720 a1.Logger.Error("error : %v", err)
723 a1.Logger.Debug(" created metadata %v", createdmetadata)
724 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
725 creation_metadata := createdmetadata[instanceMetadataKey]
726 var metadata map[string]interface{}
727 creation_metadata_string := creation_metadata.(string)
728 creation_metadata_string = strings.TrimRight(creation_metadata_string, "]")
729 creation_metadata_string = strings.TrimLeft(creation_metadata_string, "[")
730 if err = json.Unmarshal([]byte(creation_metadata_string), &metadata); err != nil {
731 a1.Logger.Error("unmarshal error : %v", err)
735 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
736 creation_timestamp := metadata["created_at"]
738 rh.deleteMetadata(policyTypeId, policyInstanceID)
740 rh.deleteInstancedata(policyTypeId, policyInstanceID)
742 rh.deleteNotificationDestination(policyTypeId, policyInstanceID)
744 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
746 message := rmr.Message{}
747 rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
749 a1.Logger.Error("error : %v", err1)
752 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest, int(policyTypeId))
754 a1.Logger.Debug("rmrSendToXapp : message sent")
756 //TODO:if message not sent need to return error or just log it or retry sending
757 a1.Logger.Error("rmrSendToXapp : message not sent")
763 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
764 a1.Logger.Debug("httpbody : %+v", httpBody)
765 mymap := httpBody.(map[string]interface{})
766 message := rmr.Message{}
767 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
769 a1.Logger.Error("error : %v", err)
772 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
773 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery, rmr.DefaultSubId)
775 a1.Logger.Debug("rmrSendToXapp : message sent")
777 a1.Logger.Error("rmrSendToXapp : message not sent")