a1-go/pkg/resthooks/resthooks.go

   1 /*
   2 ==================================================================================
   3   Copyright (c) 2021 Samsung
   4
   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
   8
   9        http://www.apache.org/licenses/LICENSE-2.0
  10
  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.
  16
  17    This source code is part of the near-RT RIC (RAN Intelligent Controller)
  18    platform project (RICP).
  19 ==================================================================================
  20 */
  21 package resthooks
  22
  23 import (
  24         "encoding/json"
  25         "errors"
  26         "fmt"
  27         "strconv"
  28         "strings"
  29         "time"
  30
  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"
  36         "gopkg.in/yaml.v2"
  37 )
  38
  39 const (
  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
  47 )
  48
  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")
  57
  58 func (rh *Resthook) CanPolicyInstanceBeDeleted(err error) bool {
  59         return err == policyInstanceCanNotBeDeletedError
  60 }
  61
  62 func (rh *Resthook) CanPolicyTypeBeDeleted(err error) bool {
  63         return err == policyTypeCanNotBeDeletedError
  64 }
  65
  66 func (rh *Resthook) IsPolicyTypePresent(err error) bool {
  67         return err == policyTypeNotFoundError
  68 }
  69
  70 func (rh *Resthook) IsPolicyInstanceNotFound(err error) bool {
  71         return err == policyInstanceNotFoundError
  72 }
  73
  74 func (rh *Resthook) IsTypeAlready(err error) bool {
  75         return err == typeAlreadyError
  76 }
  77 func (rh *Resthook) IsInstanceAlready(err error) bool {
  78         return err == InstanceAlreadyError
  79 }
  80 func (rh *Resthook) IsTypeMismatch(err error) bool {
  81         return err == typeMismatchError
  82 }
  83
  84 func (rh *Resthook) IsValidJson(err error) bool {
  85         return err == invalidJsonSchema
  86 }
  87 func NewResthook() *Resthook {
  88         return createResthook(sdlgo.NewSyncStorage(), rmr.NewRMRSender())
  89 }
  90
  91 func createResthook(sdlInst iSdl, rmrSenderInst rmr.IRmrSender) *Resthook {
  92         return &Resthook{
  93                 db:             sdlInst,
  94                 iRmrSenderInst: rmrSenderInst,
  95         }
  96 }
  97
  98 func (rh *Resthook) GetA1Health() bool {
  99         data, _ := rh.db.GetAll(a1MediatorNs)
 100         if data != nil {
 101                 a1.Logger.Debug("Database connected and A1 is healthy")
 102                 return true
 103         }
 104         return false
 105 }
 106
 107 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
 108
 109         var policyTypeIDs []models.PolicyTypeID
 110
 111         keys, err := rh.db.GetAll("A1m_ns")
 112
 113         if err != nil {
 114                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 115                 return policyTypeIDs
 116         }
 117         a1.Logger.Debug("keys : %+v", keys)
 118
 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))
 124                 }
 125         }
 126
 127         a1.Logger.Debug("return : %+v", policyTypeIDs)
 128         return policyTypeIDs
 129 }
 130
 131 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
 132         a1.Logger.Debug("GetPolicyType1")
 133
 134         var policytypeschema *models.PolicyTypeSchema
 135         var keys [1]string
 136
 137         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 138         keys[0] = key
 139
 140         a1.Logger.Debug("key : %+v", key)
 141
 142         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 143
 144         a1.Logger.Debug("policytype map : %+v", valmap)
 145
 146         if len(valmap) == 0 {
 147                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 148                 return policytypeschema
 149         }
 150
 151         if err != nil {
 152                 a1.Logger.Error("error in retrieving policy type. err: %v", err)
 153                 return nil
 154         }
 155
 156         if valmap[key] == nil {
 157                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 158                 return policytypeschema
 159         }
 160
 161         a1.Logger.Debug("keysmap : %+v", valmap[key])
 162
 163         var item models.PolicyTypeSchema
 164         valStr := fmt.Sprint(valmap[key])
 165
 166         a1.Logger.Debug("Policy type for %+v :  %+v", key, valStr)
 167         valkey := "`" + valStr + "`"
 168         valToUnmarshall, err := strconv.Unquote(valkey)
 169         if err != nil {
 170                 a1.Logger.Error("unquote error : %+v", err)
 171                 return nil
 172         }
 173
 174         a1.Logger.Debug("Policy type for %+v :  %+v", key, string(valToUnmarshall))
 175
 176         errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
 177
 178         a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
 179         a1.Logger.Debug("Policy type Name :  %v", (item.Name))
 180
 181         return &item
 182 }
 183
 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) {
 187                 //error message
 188                 a1.Logger.Debug("Policytype Mismatch")
 189                 return typeMismatchError
 190         }
 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)
 197                 if err1 != nil {
 198                         a1.Logger.Error("error :%+v", err1)
 199                         return err1
 200                 }
 201                 if !success {
 202                         a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
 203                         return typeAlreadyError
 204                 }
 205         }
 206         return nil
 207 }
 208
 209 func toStringKeys(val interface{}) (interface{}, error) {
 210         var err error
 211         switch val := val.(type) {
 212         case map[interface{}]interface{}:
 213                 m := make(map[string]interface{})
 214                 for k, v := range val {
 215                         k, ok := k.(string)
 216                         if !ok {
 217                                 return nil, errors.New("found non-string key")
 218                         }
 219                         m[k], err = toStringKeys(v)
 220                         if err != nil {
 221                                 return nil, err
 222                         }
 223                 }
 224                 return m, nil
 225         case []interface{}:
 226                 var l = make([]interface{}, len(val))
 227                 for i, v := range val {
 228                         l[i], err = toStringKeys(v)
 229                         if err != nil {
 230                                 return nil, err
 231                         }
 232                 }
 233                 return l, nil
 234         default:
 235                 return val, nil
 236         }
 237 }
 238
 239 func validate(httpBodyString string, schemaString string) bool {
 240         var m interface{}
 241         err := yaml.Unmarshal([]byte(httpBodyString), &m)
 242         if err != nil {
 243                 a1.Logger.Error("Unmarshal error : %+v", err)
 244         }
 245         m, err = toStringKeys(m)
 246         if err != nil {
 247                 a1.Logger.Error("Conversion to string error : %+v", err)
 248                 return false
 249         }
 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)
 253                 return false
 254         }
 255         schema, err := compiler.Compile("schema.json")
 256         if err != nil {
 257                 a1.Logger.Error("schema json compile error : %+v", err)
 258                 return false
 259         }
 260         if err := schema.Validate(m); err != nil {
 261                 a1.Logger.Error("schema validation error : %+v", err)
 262                 return false
 263         }
 264         a1.Logger.Debug("validation successfull")
 265         return true
 266 }
 267
 268 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
 269         var keys [1]string
 270         operation := "CREATE"
 271         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 272         keys[0] = typekey
 273
 274         a1.Logger.Debug("key1 : %+v", typekey)
 275
 276         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 277         if err != nil {
 278                 a1.Logger.Error("policy type error : %+v", err)
 279         }
 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
 284         }
 285         // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
 286
 287         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 288         keys[0] = typekey
 289         instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
 290         if err != nil {
 291                 a1.Logger.Error("policy type error : %v", err)
 292         }
 293         a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
 294
 295         if instanceMap[instancekey] != nil {
 296                 operation = "UPDATE"
 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))
 302                 if err1 != nil {
 303                         a1.Logger.Error("error2 :%+v", err1)
 304                         return operation, err1
 305                 }
 306                 if !success {
 307                         a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
 308                         return operation, InstanceAlreadyError
 309                 }
 310         } else {
 311                 data, _ := json.Marshal(httpBody)
 312                 a1.Logger.Debug("Marshaled String : %+v", string(data))
 313                 a1.Logger.Debug("key   : %+v", instancekey)
 314
 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)
 319
 320                 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
 321                 if err1 != nil {
 322                         a1.Logger.Error("error1 :%+v", err1)
 323                         return operation, err1
 324                 }
 325         }
 326         a1.Logger.Debug("Policy Instance created ")
 327         return operation, nil
 328 }
 329
 330 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
 331
 332         creation_timestamp := time.Now()
 333         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 334
 335         a1.Logger.Debug("key : %+v", instanceMetadataKey)
 336
 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)
 340
 341         a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
 342
 343         err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
 344
 345         if err != nil {
 346                 a1.Logger.Error("error :%+v", err)
 347                 return false, err
 348         }
 349
 350         a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
 351
 352         return true, nil
 353 }
 354
 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)
 361         if err != nil {
 362                 a1.Logger.Error("Json Marshal error : %+v", err)
 363                 return err
 364         }
 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)
 373         if isvalid {
 374                 var operation string
 375                 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
 376                 if err != nil {
 377                         a1.Logger.Error("error :%+v", err)
 378                         return err
 379                 }
 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)
 384                         return errmetadata
 385                 }
 386                 if iscreated {
 387                         a1.Logger.Debug("policy instance metadata created")
 388                 }
 389
 390                 message := rmr.Message{}
 391                 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
 392                 if err != nil {
 393                         a1.Logger.Error("error : %v", err)
 394                         return err
 395                 }
 396                 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
 397                 if isSent {
 398                         a1.Logger.Debug("rmrSendToXapp : message sent")
 399                 } else {
 400                         a1.Logger.Debug("rmrSendToXapp : message not sent")
 401                 }
 402
 403         } else {
 404                 a1.Logger.Error("%+v", invalidJsonSchema)
 405                 return invalidJsonSchema
 406         }
 407
 408         return nil
 409 }
 410
 411 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (interface{}, error) {
 412         a1.Logger.Debug("GetPolicyInstance1")
 413
 414         var keys [1]string
 415
 416         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 417         keys[0] = typekey
 418
 419         a1.Logger.Debug("key1 : %+v", typekey)
 420
 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
 425         }
 426
 427         if err != nil {
 428                 a1.Logger.Error("error in retrieving policy type. err: %v", err)
 429                 return "{}", err
 430         }
 431
 432         if valmap[typekey] == nil {
 433                 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
 434                 return "{}", policyTypeNotFoundError
 435         }
 436
 437         a1.Logger.Debug("keysmap : %+v", valmap[typekey])
 438
 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[:])
 443         if err != nil {
 444                 a1.Logger.Error("policy instance error : %v", err)
 445         }
 446         a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
 447
 448         if instanceMap[instancekey] == nil {
 449                 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
 450                 return "{}", policyInstanceNotFoundError
 451         }
 452
 453         valStr := fmt.Sprint(instanceMap[instancekey])
 454         return valStr, nil
 455 }
 456
 457 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
 458         a1.Logger.Debug("GetAllPolicyInstance")
 459         var policyTypeInstances = []models.PolicyInstanceID{}
 460
 461         keys, err := rh.db.GetAll("A1m_ns")
 462
 463         if err != nil {
 464                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 465                 return policyTypeInstances, err
 466         }
 467         a1.Logger.Debug("keys : %+v", keys)
 468         typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
 469
 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))
 475                 }
 476         }
 477
 478         if len(policyTypeInstances) == 0 {
 479                 a1.Logger.Debug("policy instance Not Present  ")
 480         }
 481
 482         a1.Logger.Debug("return : %+v", policyTypeInstances)
 483         return policyTypeInstances, nil
 484 }
 485
 486 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
 487         a1.Logger.Debug("DeletePolicyType")
 488
 489         policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
 490         if err != nil {
 491                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 492                 return err
 493         }
 494
 495         var keys [1]string
 496         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 497         keys[0] = key
 498         if len(policyinstances) == 0 {
 499                 err := rh.db.Remove(a1MediatorNs, keys[:])
 500                 if err != nil {
 501                         a1.Logger.Error("error in deleting policy type err: %v", err)
 502                         return err
 503                 }
 504         } else {
 505                 a1.Logger.Error("tried to delete a type that isn't empty")
 506                 return policyTypeCanNotBeDeletedError
 507         }
 508         return nil
 509 }
 510
 511 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
 512         var keys [1]string
 513
 514         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 515         keys[0] = typekey
 516
 517         a1.Logger.Debug("key1 : %+v", typekey)
 518         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 519         if err != nil {
 520                 a1.Logger.Error("error in retrieving policytype err: %v", err)
 521                 return err
 522         }
 523         if len(valmap) == 0 {
 524                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 525                 return policyTypeNotFoundError
 526         }
 527 }
 528
 529 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 530         err := rh.typeValidity(policyTypeId)
 531         if err != nil {
 532                 return err
 533         }
 534         policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
 535         if err != nil {
 536                 a1.Logger.Error("policy instance error : %v", err)
 537                 return err
 538         }
 539         if len(policyTypeInstances.(string)) == 0 {
 540                 a1.Logger.Debug("policy instance Not Present  ")
 541                 return policyInstanceNotFoundError
 542         }
 543 }
 544
 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)
 548         var keys [1]string
 549         keys[0] = instanceMetadataKey
 550         instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
 551         if err != nil {
 552                 a1.Logger.Error("policy instance error : %v", err)
 553         }
 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
 558         }
 559         return instanceMetadataMap, nil
 560 }
 561
 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
 567         }
 568         policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
 569         metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
 570         a1.Logger.Debug(" metadata %v", metadata)
 571         if err != nil {
 572                 a1.Logger.Error("policy instance error : %v", err)
 573                 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
 574                 return &policyInstanceStatus, err
 575         }
 576         jsonbody, err := json.Marshal(metadata)
 577         if err != nil {
 578                 a1.Logger.Error("marshal error : %v", err)
 579                 return &policyInstanceStatus, err
 580         }
 581
 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
 586         }
 587         if policyInstanceStatus.HasBeenDeleted == false {
 588                 policyInstanceStatus.InstanceStatus = "IN EFFECT"
 589         } else {
 590                 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
 591         }
 592         return &policyInstanceStatus, nil
 593 }
 594
 595 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
 596         deleted_timestamp := time.Now()
 597
 598         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 599
 600         a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
 601
 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)
 606
 607         a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
 608
 609         err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
 610         a1.Logger.Debug("deletemetadatacreated")
 611         if err != nil {
 612                 a1.Logger.Error("error :%+v", err)
 613                 return err
 614         }
 615
 616         a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
 617
 618         return nil
 619 }
 620
 621 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 622         var keys [1]string
 623         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 624         keys[0] = instancekey
 625         err := rh.db.Remove(a1MediatorNs, keys[:])
 626         if err != nil {
 627                 a1.Logger.Error("error in deleting policy type err: %v", err)
 628                 return err
 629         }
 630         return nil
 631 }
 632
 633 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 634         var keys [1]string
 635         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 636
 637         a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
 638         keys[0] = instanceMetadataKey
 639         err := rh.db.Remove(a1MediatorNs, keys[:])
 640         if err != nil {
 641                 a1.Logger.Error("error in deleting policy metadata err: %v", err)
 642                 return err
 643         }
 644         return nil
 645 }
 646
 647 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 648         err := rh.instanceValidity(policyTypeId, policyInstanceID)
 649         if err != nil {
 650                 a1.Logger.Error("policy instance error : %v", err)
 651                 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
 652                         return err
 653                 }
 654         }
 655
 656         createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
 657         if err != nil {
 658                 a1.Logger.Error("error : %v", err)
 659                 return err
 660         }
 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)
 667                 return err
 668         }
 669
 670         a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
 671         creation_timestamp := metadata["created_at"]
 672
 673         rh.deleteMetadata(policyTypeId, policyInstanceID)
 674
 675         rh.deleteInstancedata(policyTypeId, policyInstanceID)
 676
 677         rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
 678
 679         message := rmr.Message{}
 680         rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
 681         if err != nil {
 682                 a1.Logger.Error("error : %v", err)
 683                 return err
 684         }
 685         isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
 686         if isSent {
 687                 a1.Logger.Debug("rmrSendToXapp : message sent")
 688         } else {
 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")
 691         }
 692
 693         return nil
 694 }
 695
 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))
 701         if err != nil {
 702                 a1.Logger.Error("error : %v", err)
 703                 return err
 704         }
 705         a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
 706         isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
 707         if isSent {
 708                 a1.Logger.Debug("rmrSendToXapp : message sent")
 709         } else {
 710                 a1.Logger.Error("rmrSendToXapp : message not sent")
 711         }
 712         return nil
 713 }