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, error) {
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, policyTypeNotFoundError
162 a1.Logger.Error("error in retrieving policy type. err: %v", err)
163 return nil,policyTypeNotFoundError
166 if valmap[key] == nil {
167 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
168 return policytypeschema,policyTypeNotFoundError
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)
181 return nil,policyTypeNotFoundError
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)
299 keys[0] = instancekey
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, err := rh.GetPolicyType(policyTypeId)
384 a1.Logger.Error("error : %+v", err)
387 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
389 a1.Logger.Error("Json Marshal error : %+v", err)
392 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
393 a1.Logger.Debug("httpbody to validate %+v", httpBody)
394 schemaString := fmt.Sprint(string(schemaStr))
395 httpBodyMarshal, err := json.Marshal(httpBody)
396 httpBodyString := string((httpBodyMarshal))
397 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
398 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
399 isvalid := validate(httpBodyString, schemaString)
402 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody, notificationDestination)
404 a1.Logger.Error("error :%+v", err)
407 a1.Logger.Debug("policy instance :%+v", operation)
408 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
409 if errmetadata != nil {
410 a1.Logger.Error("error :%+v", errmetadata)
414 a1.Logger.Debug("policy instance metadata created")
417 message := rmr.Message{}
418 rmrMessage, err := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
420 a1.Logger.Error("error : %v", err)
423 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest, int(policyTypeId))
425 a1.Logger.Debug("rmrSendToXapp : message sent")
427 a1.Logger.Debug("rmrSendToXapp : message not sent")
431 a1.Logger.Error("%+v", invalidJsonSchema)
432 return invalidJsonSchema
438 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
439 a1.Logger.Debug("GetPolicyInstance1")
443 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
446 a1.Logger.Debug("key1 : %+v", typekey)
448 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
449 if len(valmap) == 0 {
450 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
451 return map[string]interface{}{}, policyTypeNotFoundError
455 a1.Logger.Error("error in retrieving policy type. err: %v", err)
456 return map[string]interface{}{}, err
459 if valmap[typekey] == nil {
460 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
461 return map[string]interface{}{}, policyTypeNotFoundError
464 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
466 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
467 a1.Logger.Debug("key2 : %+v", instancekey)
468 keys[0] = instancekey
469 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
471 a1.Logger.Error("policy instance error : %v", err)
473 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
475 if instanceMap[instancekey] == nil {
476 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
477 return map[string]interface{}{}, policyInstanceNotFoundError
480 var valStr map[string]interface{}
481 err = json.Unmarshal([]byte(instanceMap[instancekey].(string)), &valStr)
483 fmt.Println("error:", err)
489 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
490 a1.Logger.Debug("GetAllPolicyInstance")
491 var policyTypeInstances = []models.PolicyInstanceID{}
493 keys, err := rh.db.GetAll("A1m_ns")
496 a1.Logger.Error("error in retrieving policy. err: %v", err)
497 return policyTypeInstances, err
499 a1.Logger.Debug("keys : %+v", keys)
500 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
502 for _, key := range keys {
503 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
504 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
505 a1.Logger.Debug("pti %+v", pti)
506 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
510 if len(policyTypeInstances) == 0 {
511 a1.Logger.Debug("policy instance Not Present ")
514 a1.Logger.Debug("return : %+v", policyTypeInstances)
515 return policyTypeInstances, nil
518 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
519 a1.Logger.Debug("DeletePolicyType")
521 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
523 a1.Logger.Error("error in retrieving policy. err: %v", err)
528 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
530 if len(policyinstances) == 0 {
531 err := rh.db.Remove(a1MediatorNs, keys[:])
533 a1.Logger.Error("error in deleting policy type err: %v", err)
537 a1.Logger.Error("tried to delete a type that isn't empty")
538 return policyTypeCanNotBeDeletedError
543 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
546 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
549 a1.Logger.Debug("key1 : %+v", typekey)
550 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
552 a1.Logger.Error("error in retrieving policytype err: %v", err)
555 if len(valmap) == 0 {
556 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
557 return policyTypeNotFoundError
562 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
563 err := rh.typeValidity(policyTypeId)
567 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
569 a1.Logger.Error("policy instance error : %v", err)
572 if policyTypeInstances == nil {
573 a1.Logger.Debug("policy instance Not Present ")
574 return policyInstanceNotFoundError
579 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
580 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
581 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
583 keys[0] = instanceMetadataKey
584 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
586 a1.Logger.Error("policy instance error : %v", err)
588 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
589 if instanceMetadataMap[instanceMetadataKey] == nil {
590 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
591 return map[string]interface{}{}, policyInstanceNotFoundError
593 return instanceMetadataMap, nil
596 func (rh *Resthook) getPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
597 instancehandlerKey := a1HandlerPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
599 keys[0] = instancehandlerKey
600 resp, err := rh.db.Get(a1MediatorNs, keys[:])
602 a1.Logger.Error("error1 :%+v", err)
605 for _, key := range resp {
613 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
614 err := rh.instanceValidity(policyTypeId, policyInstanceID)
615 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
616 policyInstanceStatus.EnforceStatus = "NOT_ENFORCED"
617 policyInstanceStatus.EnforceReason = "OTHER_REASON"
618 if err != nil && (err == policyInstanceNotFoundError || err == policyTypeNotFoundError) {
619 return &policyInstanceStatus, err
621 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
622 a1.Logger.Debug(" metadata %v", metadata)
624 a1.Logger.Error("policy instance error : %v", err)
625 return &policyInstanceStatus, err
627 jsonbody, err := json.Marshal(metadata)
629 a1.Logger.Error("marshal error : %v", err)
630 return &policyInstanceStatus, err
633 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
634 a1.Logger.Error("unmarshal error : %v", err)
635 //this error maps to 503 error but can be mapped to 500: internal error
636 return &policyInstanceStatus, err
638 enforced, err := rh.getPolicyInstanceStatus(policyTypeId, policyInstanceID)
639 if err != nil || (err == nil && !enforced) {
640 a1.Logger.Error("marshal error : %v", err)
641 return &policyInstanceStatus, err
643 policyInstanceStatus.EnforceStatus = "ENFORCED"
644 policyInstanceStatus.EnforceReason = ""
645 return &policyInstanceStatus, nil
648 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
649 deleted_timestamp := time.Now()
651 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
653 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
655 var metadatajson interface{}
656 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
657 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
658 deletedmetadata, err := json.Marshal(metadatajson)
660 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
662 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
663 a1.Logger.Debug("deletemetadatacreated")
665 a1.Logger.Error("error :%+v", err)
669 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
674 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
676 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
677 keys[0] = instancekey
678 err := rh.db.Remove(a1MediatorNs, keys[:])
680 a1.Logger.Error("error in deleting policy instance err: %v", err)
686 func (rh *Resthook) deleteNotificationDestination(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
688 notificationDestinationkey := a1NotificationDestinationPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
689 keys[0] = notificationDestinationkey
690 err := rh.db.Remove(a1MediatorNs, keys[:])
692 a1.Logger.Error("error in deleting notificationDestination err: %v", err)
699 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
701 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
703 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
704 keys[0] = instanceMetadataKey
705 err := rh.db.Remove(a1MediatorNs, keys[:])
707 a1.Logger.Error("error in deleting policy metadata err: %v", err)
713 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
714 err := rh.instanceValidity(policyTypeId, policyInstanceID)
716 a1.Logger.Error("policy instance error : %v", err)
717 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
722 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
724 a1.Logger.Error("error : %v", err)
727 a1.Logger.Debug(" created metadata %v", createdmetadata)
728 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
729 creation_metadata := createdmetadata[instanceMetadataKey]
730 var metadata map[string]interface{}
731 creation_metadata_string := creation_metadata.(string)
732 creation_metadata_string = strings.TrimRight(creation_metadata_string, "]")
733 creation_metadata_string = strings.TrimLeft(creation_metadata_string, "[")
734 if err = json.Unmarshal([]byte(creation_metadata_string), &metadata); err != nil {
735 a1.Logger.Error("unmarshal error : %v", err)
739 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
740 creation_timestamp := metadata["created_at"]
742 rh.deleteMetadata(policyTypeId, policyInstanceID)
744 rh.deleteInstancedata(policyTypeId, policyInstanceID)
746 rh.deleteNotificationDestination(policyTypeId, policyInstanceID)
748 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
750 message := rmr.Message{}
751 rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
753 a1.Logger.Error("error : %v", err1)
756 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest, int(policyTypeId))
758 a1.Logger.Debug("rmrSendToXapp : message sent")
760 //TODO:if message not sent need to return error or just log it or retry sending
761 a1.Logger.Error("rmrSendToXapp : message not sent")
767 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
768 a1.Logger.Debug("httpbody : %+v", httpBody)
769 mymap := httpBody.(map[string]interface{})
770 message := rmr.Message{}
771 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
773 a1.Logger.Error("error : %v", err)
776 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
777 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery, rmr.DefaultSubId)
779 a1.Logger.Debug("rmrSendToXapp : message sent")
781 a1.Logger.Error("rmrSendToXapp : message not sent")