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/rmr"
34 "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
35 "github.com/santhosh-tekuri/jsonschema/v5"
40 a1PolicyPrefix = "a1.policy_type."
41 a1MediatorNs = "A1m_ns"
42 a1InstancePrefix = "a1.policy_instance."
43 a1InstanceMetadataPrefix = "a1.policy_inst_metadata."
44 a1HandlerPrefix = "a1.policy_handler."
45 a1PolicyRequest = 20010
46 a1EIDataDelivery = 20017
49 var typeAlreadyError = errors.New("Policy Type already exists")
50 var InstanceAlreadyError = errors.New("Policy Instance already exists")
51 var typeMismatchError = errors.New("Policytype Mismatch")
52 var invalidJsonSchema = errors.New("Invalid Json ")
53 var policyInstanceNotFoundError = errors.New("Policy Instance Not Found")
54 var policyTypeNotFoundError = errors.New("Policy Type Not Found")
55 var policyTypeCanNotBeDeletedError = errors.New("tried to delete a type that isn't empty")
56 var policyInstanceCanNotBeDeletedError = errors.New("tried to delete a Instance that isn't empty")
58 func (rh *Resthook) CanPolicyInstanceBeDeleted(err error) bool {
59 return err == policyInstanceCanNotBeDeletedError
62 func (rh *Resthook) CanPolicyTypeBeDeleted(err error) bool {
63 return err == policyTypeCanNotBeDeletedError
66 func (rh *Resthook) IsPolicyTypePresent(err error) bool {
67 return err == policyTypeNotFoundError
70 func (rh *Resthook) IsPolicyInstanceNotFound(err error) bool {
71 return err == policyInstanceNotFoundError
74 func (rh *Resthook) IsTypeAlready(err error) bool {
75 return err == typeAlreadyError
77 func (rh *Resthook) IsInstanceAlready(err error) bool {
78 return err == InstanceAlreadyError
80 func (rh *Resthook) IsTypeMismatch(err error) bool {
81 return err == typeMismatchError
84 func (rh *Resthook) IsValidJson(err error) bool {
85 return err == invalidJsonSchema
87 func NewResthook() *Resthook {
88 return createResthook(sdlgo.NewSyncStorage(), rmr.NewRMRSender())
91 func createResthook(sdlInst iSdl, rmrSenderInst rmr.IRmrSender) *Resthook {
94 iRmrSenderInst: rmrSenderInst,
98 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
100 var policyTypeIDs []models.PolicyTypeID
102 keys, err := rh.db.GetAll("A1m_ns")
105 a1.Logger.Error("error in retrieving policy. err: %v", err)
108 a1.Logger.Debug("keys : %+v", keys)
110 for _, key := range keys {
111 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
112 pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
113 ptii, _ := strconv.ParseInt(pti, 10, 64)
114 policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
118 a1.Logger.Debug("return : %+v", policyTypeIDs)
122 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
123 a1.Logger.Debug("GetPolicyType1")
125 var policytypeschema *models.PolicyTypeSchema
128 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
131 a1.Logger.Debug("key : %+v", key)
133 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
135 a1.Logger.Debug("policytype map : %+v", valmap)
137 if len(valmap) == 0 {
138 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
139 return policytypeschema
143 a1.Logger.Error("error in retrieving policy type. err: %v", err)
147 if valmap[key] == nil {
148 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
149 return policytypeschema
152 a1.Logger.Debug("keysmap : %+v", valmap[key])
154 var item models.PolicyTypeSchema
155 valStr := fmt.Sprint(valmap[key])
157 a1.Logger.Debug("Policy type for %+v : %+v", key, valStr)
158 valkey := "`" + valStr + "`"
159 valToUnmarshall, err := strconv.Unquote(valkey)
161 a1.Logger.Error("unquote error : %+v", err)
165 a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
167 errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
169 a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
170 a1.Logger.Debug("Policy type Name : %v", (item.Name))
175 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
176 a1.Logger.Debug("CreatePolicyType function")
177 if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
179 a1.Logger.Debug("Policytype Mismatch")
180 return typeMismatchError
182 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
183 a1.Logger.Debug("key %+v ", key)
184 if data, err := httprequest.MarshalBinary(); err == nil {
185 a1.Logger.Debug("Marshaled String : %+v", string(data))
186 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
187 a1.Logger.Info("success:%+v", success)
189 a1.Logger.Error("error :%+v", err1)
193 a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
194 return typeAlreadyError
200 func toStringKeys(val interface{}) (interface{}, error) {
202 switch val := val.(type) {
203 case map[interface{}]interface{}:
204 m := make(map[string]interface{})
205 for k, v := range val {
208 return nil, errors.New("found non-string key")
210 m[k], err = toStringKeys(v)
217 var l = make([]interface{}, len(val))
218 for i, v := range val {
219 l[i], err = toStringKeys(v)
230 func validate(httpBodyString string, schemaString string) bool {
232 err := yaml.Unmarshal([]byte(httpBodyString), &m)
234 a1.Logger.Error("Unmarshal error : %+v", err)
236 m, err = toStringKeys(m)
238 a1.Logger.Error("Conversion to string error : %+v", err)
241 compiler := jsonschema.NewCompiler()
242 if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
243 a1.Logger.Error("string reader error : %+v", err)
246 schema, err := compiler.Compile("schema.json")
248 a1.Logger.Error("schema json compile error : %+v", err)
251 if err := schema.Validate(m); err != nil {
252 a1.Logger.Error("schema validation error : %+v", err)
255 a1.Logger.Debug("validation successfull")
259 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
261 operation := "CREATE"
262 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
265 a1.Logger.Debug("key1 : %+v", typekey)
267 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
269 a1.Logger.Error("policy type error : %+v", err)
271 a1.Logger.Debug("policytype map : %+v", valmap)
272 if valmap[typekey] == nil {
273 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
274 return operation, policyTypeNotFoundError
276 // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
278 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
280 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
282 a1.Logger.Error("policy type error : %v", err)
284 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
286 if instanceMap[instancekey] != nil {
288 a1.Logger.Debug("UPDATE")
289 data, _ := json.Marshal(httpBody)
290 a1.Logger.Debug("Marshaled String : %+v", string(data))
291 a1.Logger.Debug("key : %+v", instancekey)
292 success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
294 a1.Logger.Error("error2 :%+v", err1)
295 return operation, err1
298 a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
299 return operation, InstanceAlreadyError
302 data, _ := json.Marshal(httpBody)
303 a1.Logger.Debug("Marshaled String : %+v", string(data))
304 a1.Logger.Debug("key : %+v", instancekey)
306 var instance_map []interface{}
307 instance_map = append(instance_map, instancekey, string(data))
308 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
309 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
311 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
313 a1.Logger.Error("error1 :%+v", err1)
314 return operation, err1
317 a1.Logger.Debug("Policy Instance created ")
318 return operation, nil
321 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
323 creation_timestamp := time.Now()
324 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
326 a1.Logger.Debug("key : %+v", instanceMetadataKey)
328 var metadatajson []interface{}
329 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
330 metadata, _ := json.Marshal(metadatajson)
332 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
334 err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
337 a1.Logger.Error("error :%+v", err)
341 a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
346 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
347 a1.Logger.Debug("CreatePolicyInstance function")
348 // validate the PUT against the schema
349 var policyTypeSchema *models.PolicyTypeSchema
350 policyTypeSchema = rh.GetPolicyType(policyTypeId)
351 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
353 a1.Logger.Error("Json Marshal error : %+v", err)
356 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
357 a1.Logger.Debug("httpbody to validate %+v", httpBody)
358 schemaString := fmt.Sprint(string(schemaStr))
359 httpBodyMarshal, err := json.Marshal(httpBody)
360 httpBodyString := string((httpBodyMarshal))
361 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
362 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
363 isvalid := validate(httpBodyString, schemaString)
366 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
368 a1.Logger.Error("error :%+v", err)
371 a1.Logger.Debug("policy instance :%+v", operation)
372 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
373 if errmetadata != nil {
374 a1.Logger.Error("error :%+v", errmetadata)
378 a1.Logger.Debug("policy instance metadata created")
381 message := rmr.Message{}
382 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
384 a1.Logger.Error("error : %v", err)
387 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
389 a1.Logger.Debug("rmrSendToXapp : message sent")
391 a1.Logger.Debug("rmrSendToXapp : message not sent")
395 a1.Logger.Error("%+v", invalidJsonSchema)
396 return invalidJsonSchema
402 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (interface{}, error) {
403 a1.Logger.Debug("GetPolicyInstance1")
407 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
410 a1.Logger.Debug("key1 : %+v", typekey)
412 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
413 if len(valmap) == 0 {
414 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
415 return "{}", policyTypeNotFoundError
419 a1.Logger.Error("error in retrieving policy type. err: %v", err)
423 if valmap[typekey] == nil {
424 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
425 return "{}", policyTypeNotFoundError
428 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
430 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
431 a1.Logger.Debug("key2 : %+v", instancekey)
432 keys[0] = instancekey
433 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
435 a1.Logger.Error("policy instance error : %v", err)
437 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
439 if instanceMap[instancekey] == nil {
440 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
441 return "{}", policyInstanceNotFoundError
444 valStr := fmt.Sprint(instanceMap[instancekey])
448 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
449 a1.Logger.Debug("GetAllPolicyInstance")
450 var policyTypeInstances = []models.PolicyInstanceID{}
452 keys, err := rh.db.GetAll("A1m_ns")
455 a1.Logger.Error("error in retrieving policy. err: %v", err)
456 return policyTypeInstances, err
458 a1.Logger.Debug("keys : %+v", keys)
459 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
461 for _, key := range keys {
462 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
463 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
464 a1.Logger.Debug("pti %+v", pti)
465 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
469 if len(policyTypeInstances) == 0 {
470 a1.Logger.Debug("policy instance Not Present ")
473 a1.Logger.Debug("return : %+v", policyTypeInstances)
474 return policyTypeInstances, nil
477 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
478 a1.Logger.Debug("DeletePolicyType")
480 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
482 a1.Logger.Error("error in retrieving policy. err: %v", err)
487 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
489 if len(policyinstances) == 0 {
490 err := rh.db.Remove(a1MediatorNs, keys[:])
492 a1.Logger.Error("error in deleting policy type err: %v", err)
496 a1.Logger.Error("tried to delete a type that isn't empty")
497 return policyTypeCanNotBeDeletedError
502 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
505 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
508 a1.Logger.Debug("key1 : %+v", typekey)
509 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
511 a1.Logger.Error("error in retrieving policytype err: %v", err)
514 if len(valmap) == 0 {
515 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
516 return policyTypeNotFoundError
520 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
521 err := rh.typeValidity(policyTypeId)
525 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
527 a1.Logger.Error("policy instance error : %v", err)
530 if len(policyTypeInstances.(string)) == 0 {
531 a1.Logger.Debug("policy instance Not Present ")
532 return policyInstanceNotFoundError
536 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
537 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
538 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
540 keys[0] = instanceMetadataKey
541 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
543 a1.Logger.Error("policy instance error : %v", err)
545 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
546 if instanceMetadataMap[instanceMetadataKey] == nil {
547 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
548 return map[string]interface{}{}, policyInstanceNotFoundError
550 return instanceMetadataMap, nil
553 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
554 err := rh.instanceValidity(policyTypeId, policyInstanceID)
555 if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
556 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
557 return &policyInstanceStatus, err
559 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
560 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
561 a1.Logger.Debug(" metadata %v", metadata)
563 a1.Logger.Error("policy instance error : %v", err)
564 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
565 return &policyInstanceStatus, err
567 jsonbody, err := json.Marshal(metadata)
569 a1.Logger.Error("marshal error : %v", err)
570 return &policyInstanceStatus, err
573 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
574 a1.Logger.Error("unmarshal error : %v", err)
575 //this error maps to 503 error but can be mapped to 500: internal error
576 return &policyInstanceStatus, err
578 if policyInstanceStatus.HasBeenDeleted == false {
579 policyInstanceStatus.InstanceStatus = "IN EFFECT"
581 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
583 return &policyInstanceStatus, nil
586 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
587 deleted_timestamp := time.Now()
589 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
591 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
593 var metadatajson interface{}
594 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
595 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
596 deletedmetadata, err := json.Marshal(metadatajson)
598 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
600 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
601 a1.Logger.Debug("deletemetadatacreated")
603 a1.Logger.Error("error :%+v", err)
607 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
612 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
614 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
615 keys[0] = instancekey
616 err := rh.db.Remove(a1MediatorNs, keys[:])
618 a1.Logger.Error("error in deleting policy type err: %v", err)
624 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
626 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
628 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
629 keys[0] = instanceMetadataKey
630 err := rh.db.Remove(a1MediatorNs, keys[:])
632 a1.Logger.Error("error in deleting policy metadata err: %v", err)
638 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
639 err := rh.instanceValidity(policyTypeId, policyInstanceID)
641 a1.Logger.Error("policy instance error : %v", err)
642 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
647 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
649 a1.Logger.Error("error : %v", err)
652 a1.Logger.Debug(" created metadata %v", createdmetadata)
653 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
654 creation_metadata := createdmetadata[instanceMetadataKey]
655 var metadata map[string]interface{}
656 if err = json.Unmarshal([]byte(creation_metadata.(string)), &metadata); err != nil {
657 a1.Logger.Error("unmarshal error : %v", err)
661 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
662 creation_timestamp := metadata["created_at"]
664 rh.deleteMetadata(policyTypeId, policyInstanceID)
666 rh.deleteInstancedata(policyTypeId, policyInstanceID)
668 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
670 message := rmr.Message{}
671 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
673 a1.Logger.Error("error : %v", err)
676 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
678 a1.Logger.Debug("rmrSendToXapp : message sent")
680 //TODO:if message not sent need to return error or just log it or retry sending
681 a1.Logger.Error("rmrSendToXapp : message not sent")
687 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
688 a1.Logger.Debug("httpbody : %+v", httpBody)
689 mymap := httpBody.(map[string]interface{})
690 message := rmr.Message{}
691 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
693 a1.Logger.Error("error : %v", err)
696 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
697 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
699 a1.Logger.Debug("rmrSendToXapp : message sent")
701 a1.Logger.Error("rmrSendToXapp : message not sent")