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) GetA1Health() bool {
99 data, _ := rh.db.GetAll(a1MediatorNs)
101 a1.Logger.Debug("Database connected and A1 is healthy")
107 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
109 var policyTypeIDs []models.PolicyTypeID
111 keys, err := rh.db.GetAll("A1m_ns")
114 a1.Logger.Error("error in retrieving policy. err: %v", err)
117 a1.Logger.Debug("keys : %+v", keys)
119 for _, key := range keys {
120 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
121 pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
122 ptii, _ := strconv.ParseInt(pti, 10, 64)
123 policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
127 a1.Logger.Debug("return : %+v", policyTypeIDs)
131 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
132 a1.Logger.Debug("GetPolicyType1")
134 var policytypeschema *models.PolicyTypeSchema
137 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
140 a1.Logger.Debug("key : %+v", key)
142 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
144 a1.Logger.Debug("policytype map : %+v", valmap)
146 if len(valmap) == 0 {
147 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
148 return policytypeschema
152 a1.Logger.Error("error in retrieving policy type. err: %v", err)
156 if valmap[key] == nil {
157 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
158 return policytypeschema
161 a1.Logger.Debug("keysmap : %+v", valmap[key])
163 var item models.PolicyTypeSchema
164 valStr := fmt.Sprint(valmap[key])
166 a1.Logger.Debug("Policy type for %+v : %+v", key, valStr)
167 valkey := "`" + valStr + "`"
168 valToUnmarshall, err := strconv.Unquote(valkey)
170 a1.Logger.Error("unquote error : %+v", err)
174 a1.Logger.Debug("Policy type for %+v : %+v", key, string(valToUnmarshall))
176 errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
178 a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
179 a1.Logger.Debug("Policy type Name : %v", (item.Name))
184 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
185 a1.Logger.Debug("CreatePolicyType function")
186 if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
188 a1.Logger.Debug("Policytype Mismatch")
189 return typeMismatchError
191 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
192 a1.Logger.Debug("key %+v ", key)
193 if data, err := httprequest.MarshalBinary(); err == nil {
194 a1.Logger.Debug("Marshaled String : %+v", string(data))
195 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
196 a1.Logger.Info("success:%+v", success)
198 a1.Logger.Error("error :%+v", err1)
202 a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
203 return typeAlreadyError
209 func toStringKeys(val interface{}) (interface{}, error) {
211 switch val := val.(type) {
212 case map[interface{}]interface{}:
213 m := make(map[string]interface{})
214 for k, v := range val {
217 return nil, errors.New("found non-string key")
219 m[k], err = toStringKeys(v)
226 var l = make([]interface{}, len(val))
227 for i, v := range val {
228 l[i], err = toStringKeys(v)
239 func validate(httpBodyString string, schemaString string) bool {
241 err := yaml.Unmarshal([]byte(httpBodyString), &m)
243 a1.Logger.Error("Unmarshal error : %+v", err)
245 m, err = toStringKeys(m)
247 a1.Logger.Error("Conversion to string error : %+v", err)
250 compiler := jsonschema.NewCompiler()
251 if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
252 a1.Logger.Error("string reader error : %+v", err)
255 schema, err := compiler.Compile("schema.json")
257 a1.Logger.Error("schema json compile error : %+v", err)
260 if err := schema.Validate(m); err != nil {
261 a1.Logger.Error("schema validation error : %+v", err)
264 a1.Logger.Debug("validation successfull")
268 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
270 operation := "CREATE"
271 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
274 a1.Logger.Debug("key1 : %+v", typekey)
276 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
278 a1.Logger.Error("policy type error : %+v", err)
280 a1.Logger.Debug("policytype map : %+v", valmap)
281 if valmap[typekey] == nil {
282 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
283 return operation, policyTypeNotFoundError
285 // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
287 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
289 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
291 a1.Logger.Error("policy type error : %v", err)
293 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
295 if instanceMap[instancekey] != nil {
297 a1.Logger.Debug("UPDATE")
298 data, _ := json.Marshal(httpBody)
299 a1.Logger.Debug("Marshaled String : %+v", string(data))
300 a1.Logger.Debug("key : %+v", instancekey)
301 success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
303 a1.Logger.Error("error2 :%+v", err1)
304 return operation, err1
307 a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
308 return operation, InstanceAlreadyError
311 data, _ := json.Marshal(httpBody)
312 a1.Logger.Debug("Marshaled String : %+v", string(data))
313 a1.Logger.Debug("key : %+v", instancekey)
315 var instance_map []interface{}
316 instance_map = append(instance_map, instancekey, string(data))
317 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
318 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
320 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
322 a1.Logger.Error("error1 :%+v", err1)
323 return operation, err1
326 a1.Logger.Debug("Policy Instance created ")
327 return operation, nil
330 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
332 creation_timestamp := time.Now()
333 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
335 a1.Logger.Debug("key : %+v", instanceMetadataKey)
337 var metadatajson []interface{}
338 metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
339 metadata, _ := json.Marshal(metadatajson)
341 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
343 err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
346 a1.Logger.Error("error :%+v", err)
350 a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
355 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
356 a1.Logger.Debug("CreatePolicyInstance function")
357 // validate the PUT against the schema
358 var policyTypeSchema *models.PolicyTypeSchema
359 policyTypeSchema = rh.GetPolicyType(policyTypeId)
360 schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
362 a1.Logger.Error("Json Marshal error : %+v", err)
365 a1.Logger.Debug("schema to validate %+v", string(schemaStr))
366 a1.Logger.Debug("httpbody to validate %+v", httpBody)
367 schemaString := fmt.Sprint(string(schemaStr))
368 httpBodyMarshal, err := json.Marshal(httpBody)
369 httpBodyString := string((httpBodyMarshal))
370 a1.Logger.Debug("schema to validate sprint %+v", (schemaString))
371 a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
372 isvalid := validate(httpBodyString, schemaString)
375 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
377 a1.Logger.Error("error :%+v", err)
380 a1.Logger.Debug("policy instance :%+v", operation)
381 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
382 if errmetadata != nil {
383 a1.Logger.Error("error :%+v", errmetadata)
387 a1.Logger.Debug("policy instance metadata created")
390 message := rmr.Message{}
391 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
393 a1.Logger.Error("error : %v", err)
396 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
398 a1.Logger.Debug("rmrSendToXapp : message sent")
400 a1.Logger.Debug("rmrSendToXapp : message not sent")
404 a1.Logger.Error("%+v", invalidJsonSchema)
405 return invalidJsonSchema
411 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (interface{}, error) {
412 a1.Logger.Debug("GetPolicyInstance1")
416 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
419 a1.Logger.Debug("key1 : %+v", typekey)
421 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
422 if len(valmap) == 0 {
423 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
424 return "{}", policyTypeNotFoundError
428 a1.Logger.Error("error in retrieving policy type. err: %v", err)
432 if valmap[typekey] == nil {
433 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
434 return "{}", policyTypeNotFoundError
437 a1.Logger.Debug("keysmap : %+v", valmap[typekey])
439 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
440 a1.Logger.Debug("key2 : %+v", instancekey)
441 keys[0] = instancekey
442 instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
444 a1.Logger.Error("policy instance error : %v", err)
446 a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
448 if instanceMap[instancekey] == nil {
449 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
450 return "{}", policyInstanceNotFoundError
453 valStr := fmt.Sprint(instanceMap[instancekey])
457 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
458 a1.Logger.Debug("GetAllPolicyInstance")
459 var policyTypeInstances = []models.PolicyInstanceID{}
461 keys, err := rh.db.GetAll("A1m_ns")
464 a1.Logger.Error("error in retrieving policy. err: %v", err)
465 return policyTypeInstances, err
467 a1.Logger.Debug("keys : %+v", keys)
468 typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
470 for _, key := range keys {
471 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
472 pti := strings.Split(strings.Trim(key, " "), typekey)[1]
473 a1.Logger.Debug("pti %+v", pti)
474 policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
478 if len(policyTypeInstances) == 0 {
479 a1.Logger.Debug("policy instance Not Present ")
482 a1.Logger.Debug("return : %+v", policyTypeInstances)
483 return policyTypeInstances, nil
486 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
487 a1.Logger.Debug("DeletePolicyType")
489 policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
491 a1.Logger.Error("error in retrieving policy. err: %v", err)
496 key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
498 if len(policyinstances) == 0 {
499 err := rh.db.Remove(a1MediatorNs, keys[:])
501 a1.Logger.Error("error in deleting policy type err: %v", err)
505 a1.Logger.Error("tried to delete a type that isn't empty")
506 return policyTypeCanNotBeDeletedError
511 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
514 typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
517 a1.Logger.Debug("key1 : %+v", typekey)
518 valmap, err := rh.db.Get(a1MediatorNs, keys[:])
520 a1.Logger.Error("error in retrieving policytype err: %v", err)
523 if len(valmap) == 0 {
524 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
525 return policyTypeNotFoundError
529 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
530 err := rh.typeValidity(policyTypeId)
534 policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
536 a1.Logger.Error("policy instance error : %v", err)
539 if len(policyTypeInstances.(string)) == 0 {
540 a1.Logger.Debug("policy instance Not Present ")
541 return policyInstanceNotFoundError
545 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
546 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
547 a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
549 keys[0] = instanceMetadataKey
550 instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
552 a1.Logger.Error("policy instance error : %v", err)
554 a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
555 if instanceMetadataMap[instanceMetadataKey] == nil {
556 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
557 return map[string]interface{}{}, policyInstanceNotFoundError
559 return instanceMetadataMap, nil
562 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
563 err := rh.instanceValidity(policyTypeId, policyInstanceID)
564 if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
565 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
566 return &policyInstanceStatus, err
568 policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
569 metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
570 a1.Logger.Debug(" metadata %v", metadata)
572 a1.Logger.Error("policy instance error : %v", err)
573 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
574 return &policyInstanceStatus, err
576 jsonbody, err := json.Marshal(metadata)
578 a1.Logger.Error("marshal error : %v", err)
579 return &policyInstanceStatus, err
582 if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
583 a1.Logger.Error("unmarshal error : %v", err)
584 //this error maps to 503 error but can be mapped to 500: internal error
585 return &policyInstanceStatus, err
587 if policyInstanceStatus.HasBeenDeleted == false {
588 policyInstanceStatus.InstanceStatus = "IN EFFECT"
590 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
592 return &policyInstanceStatus, nil
595 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
596 deleted_timestamp := time.Now()
598 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
600 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
602 var metadatajson interface{}
603 metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
604 a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
605 deletedmetadata, err := json.Marshal(metadatajson)
607 a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
609 err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
610 a1.Logger.Debug("deletemetadatacreated")
612 a1.Logger.Error("error :%+v", err)
616 a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
621 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
623 instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
624 keys[0] = instancekey
625 err := rh.db.Remove(a1MediatorNs, keys[:])
627 a1.Logger.Error("error in deleting policy type err: %v", err)
633 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
635 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
637 a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
638 keys[0] = instanceMetadataKey
639 err := rh.db.Remove(a1MediatorNs, keys[:])
641 a1.Logger.Error("error in deleting policy metadata err: %v", err)
647 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
648 err := rh.instanceValidity(policyTypeId, policyInstanceID)
650 a1.Logger.Error("policy instance error : %v", err)
651 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
656 createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
658 a1.Logger.Error("error : %v", err)
661 a1.Logger.Debug(" created metadata %v", createdmetadata)
662 instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
663 creation_metadata := createdmetadata[instanceMetadataKey]
664 var metadata map[string]interface{}
665 if err = json.Unmarshal([]byte(creation_metadata.(string)), &metadata); err != nil {
666 a1.Logger.Error("unmarshal error : %v", err)
670 a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
671 creation_timestamp := metadata["created_at"]
673 rh.deleteMetadata(policyTypeId, policyInstanceID)
675 rh.deleteInstancedata(policyTypeId, policyInstanceID)
677 rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
679 message := rmr.Message{}
680 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
682 a1.Logger.Error("error : %v", err)
685 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
687 a1.Logger.Debug("rmrSendToXapp : message sent")
689 //TODO:if message not sent need to return error or just log it or retry sending
690 a1.Logger.Error("rmrSendToXapp : message not sent")
696 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
697 a1.Logger.Debug("httpbody : %+v", httpBody)
698 mymap := httpBody.(map[string]interface{})
699 message := rmr.Message{}
700 rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
702 a1.Logger.Error("error : %v", err)
705 a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
706 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
708 a1.Logger.Debug("rmrSendToXapp : message sent")
710 a1.Logger.Error("rmrSendToXapp : message not sent")