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/policy"
  34         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/restapi/operations/a1_mediator"
  35         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/rmr"
  36         "gerrit.o-ran-sc.org/r/ric-plt/sdlgo"
  37         "github.com/santhosh-tekuri/jsonschema/v5"
  38         "gopkg.in/yaml.v2"
  39 )
  40
  41 const (
  42         a1PolicyPrefix           = "a1.policy_type."
  43         a1MediatorNs             = "A1m_ns"
  44         a1InstancePrefix         = "a1.policy_instance."
  45         a1InstanceMetadataPrefix = "a1.policy_inst_metadata."
  46         a1HandlerPrefix          = "a1.policy_handler."
  47         a1PolicyRequest          = 20010
  48         a1EIDataDelivery         = 20017
  49 )
  50
  51 var typeAlreadyError = errors.New("Policy Type already exists")
  52 var InstanceAlreadyError = errors.New("Policy Instance already exists")
  53 var typeMismatchError = errors.New("Policytype Mismatch")
  54 var invalidJsonSchema = errors.New("Invalid Json ")
  55 var policyInstanceNotFoundError = errors.New("Policy Instance Not Found")
  56 var policyTypeNotFoundError = errors.New("Policy Type Not Found")
  57 var policyTypeCanNotBeDeletedError = errors.New("tried to delete a type that isn't empty")
  58 var policyInstanceCanNotBeDeletedError = errors.New("tried to delete a Instance that isn't empty")
  59
  60 func (rh *Resthook) CanPolicyInstanceBeDeleted(err error) bool {
  61         return err == policyInstanceCanNotBeDeletedError
  62 }
  63
  64 func (rh *Resthook) CanPolicyTypeBeDeleted(err error) bool {
  65         return err == policyTypeCanNotBeDeletedError
  66 }
  67
  68 func (rh *Resthook) IsPolicyTypePresent(err error) bool {
  69         return err == policyTypeNotFoundError
  70 }
  71
  72 func (rh *Resthook) IsPolicyInstanceNotFound(err error) bool {
  73         return err == policyInstanceNotFoundError
  74 }
  75
  76 func (rh *Resthook) IsTypeAlready(err error) bool {
  77         return err == typeAlreadyError
  78 }
  79 func (rh *Resthook) IsInstanceAlready(err error) bool {
  80         return err == InstanceAlreadyError
  81 }
  82 func (rh *Resthook) IsTypeMismatch(err error) bool {
  83         return err == typeMismatchError
  84 }
  85
  86 func (rh *Resthook) IsValidJson(err error) bool {
  87         return err == invalidJsonSchema
  88 }
  89 func NewResthook() *Resthook {
  90         sdl := sdlgo.NewSyncStorage()
  91         policyManager := policy.NewPolicyManager(sdl)
  92         return createResthook(sdl, rmr.NewRMRSender(policyManager))
  93 }
  94
  95 func createResthook(sdlInst iSdl, rmrSenderInst rmr.IRmrSender) *Resthook {
  96         rh := &Resthook{
  97                 db:             sdlInst,
  98                 iRmrSenderInst: rmrSenderInst,
  99         }
 100
 101         return rh
 102 }
 103
 104 func (rh *Resthook) GetA1Health() bool {
 105         data, _ := rh.db.GetAll(a1MediatorNs)
 106         if data != nil {
 107                 a1.Logger.Debug("Database connected and A1 is healthy")
 108                 return true
 109         }
 110         return false
 111 }
 112
 113 func (rh *Resthook) GetAllPolicyType() []models.PolicyTypeID {
 114
 115         var policyTypeIDs []models.PolicyTypeID
 116
 117         keys, err := rh.db.GetAll("A1m_ns")
 118
 119         if err != nil {
 120                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 121                 return policyTypeIDs
 122         }
 123         a1.Logger.Debug("keys : %+v", keys)
 124
 125         for _, key := range keys {
 126                 if strings.HasPrefix(strings.TrimLeft(key, " "), a1PolicyPrefix) {
 127                         pti := strings.Split(strings.Trim(key, " "), a1PolicyPrefix)[1]
 128                         ptii, _ := strconv.ParseInt(pti, 10, 64)
 129                         policyTypeIDs = append(policyTypeIDs, models.PolicyTypeID(ptii))
 130                 }
 131         }
 132
 133         a1.Logger.Debug("return : %+v", policyTypeIDs)
 134         return policyTypeIDs
 135 }
 136
 137 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
 138         a1.Logger.Debug("GetPolicyType1")
 139
 140         var policytypeschema *models.PolicyTypeSchema
 141         var keys [1]string
 142
 143         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 144         keys[0] = key
 145
 146         a1.Logger.Debug("key : %+v", key)
 147
 148         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 149
 150         a1.Logger.Debug("policytype map : %+v", valmap)
 151
 152         if len(valmap) == 0 {
 153                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 154                 return policytypeschema
 155         }
 156
 157         if err != nil {
 158                 a1.Logger.Error("error in retrieving policy type. err: %v", err)
 159                 return nil
 160         }
 161
 162         if valmap[key] == nil {
 163                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 164                 return policytypeschema
 165         }
 166
 167         a1.Logger.Debug("keysmap : %+v", valmap[key])
 168
 169         var item models.PolicyTypeSchema
 170         valStr := fmt.Sprint(valmap[key])
 171
 172         a1.Logger.Debug("Policy type for %+v :  %+v", key, valStr)
 173         valkey := "`" + valStr + "`"
 174         valToUnmarshall, err := strconv.Unquote(valkey)
 175         if err != nil {
 176                 a1.Logger.Error("unquote error : %+v", err)
 177                 return nil
 178         }
 179
 180         a1.Logger.Debug("Policy type for %+v :  %+v", key, string(valToUnmarshall))
 181
 182         errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
 183
 184         a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
 185         a1.Logger.Debug("Policy type Name :  %v", (item.Name))
 186
 187         return &item
 188 }
 189
 190 func (rh *Resthook) CreatePolicyType(policyTypeId models.PolicyTypeID, httprequest models.PolicyTypeSchema) error {
 191         a1.Logger.Debug("CreatePolicyType function")
 192         if policyTypeId != models.PolicyTypeID(*httprequest.PolicyTypeID) {
 193                 //error message
 194                 a1.Logger.Debug("Policytype Mismatch")
 195                 return typeMismatchError
 196         }
 197         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 198         a1.Logger.Debug("key %+v ", key)
 199         if data, err := httprequest.MarshalBinary(); err == nil {
 200                 a1.Logger.Debug("Marshaled String : %+v", string(data))
 201                 success, err1 := rh.db.SetIfNotExists(a1MediatorNs, key, string(data))
 202                 a1.Logger.Info("success:%+v", success)
 203                 if err1 != nil {
 204                         a1.Logger.Error("error :%+v", err1)
 205                         return err1
 206                 }
 207                 if !success {
 208                         a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
 209                         return typeAlreadyError
 210                 }
 211         }
 212         return nil
 213 }
 214
 215 func toStringKeys(val interface{}) (interface{}, error) {
 216         var err error
 217         switch val := val.(type) {
 218         case map[interface{}]interface{}:
 219                 m := make(map[string]interface{})
 220                 for k, v := range val {
 221                         k, ok := k.(string)
 222                         if !ok {
 223                                 return nil, errors.New("found non-string key")
 224                         }
 225                         m[k], err = toStringKeys(v)
 226                         if err != nil {
 227                                 return nil, err
 228                         }
 229                 }
 230                 return m, nil
 231         case []interface{}:
 232                 var l = make([]interface{}, len(val))
 233                 for i, v := range val {
 234                         l[i], err = toStringKeys(v)
 235                         if err != nil {
 236                                 return nil, err
 237                         }
 238                 }
 239                 return l, nil
 240         default:
 241                 return val, nil
 242         }
 243 }
 244
 245 func validate(httpBodyString string, schemaString string) bool {
 246         var m interface{}
 247         err := yaml.Unmarshal([]byte(httpBodyString), &m)
 248         if err != nil {
 249                 a1.Logger.Error("Unmarshal error : %+v", err)
 250         }
 251         m, err = toStringKeys(m)
 252         if err != nil {
 253                 a1.Logger.Error("Conversion to string error : %+v", err)
 254                 return false
 255         }
 256         compiler := jsonschema.NewCompiler()
 257         if err := compiler.AddResource("schema.json", strings.NewReader(schemaString)); err != nil {
 258                 a1.Logger.Error("string reader error : %+v", err)
 259                 return false
 260         }
 261         schema, err := compiler.Compile("schema.json")
 262         if err != nil {
 263                 a1.Logger.Error("schema json compile error : %+v", err)
 264                 return false
 265         }
 266         if err := schema.Validate(m); err != nil {
 267                 a1.Logger.Error("schema validation error : %+v", err)
 268                 return false
 269         }
 270         a1.Logger.Debug("validation successfull")
 271         return true
 272 }
 273
 274 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
 275         var keys [1]string
 276         operation := "CREATE"
 277         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 278         keys[0] = typekey
 279
 280         a1.Logger.Debug("key1 : %+v", typekey)
 281
 282         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 283         if err != nil {
 284                 a1.Logger.Error("policy type error : %+v", err)
 285         }
 286         a1.Logger.Debug("policytype map : %+v", valmap)
 287         if valmap[typekey] == nil {
 288                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 289                 return operation, policyTypeNotFoundError
 290         }
 291         // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
 292
 293         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 294         keys[0] = typekey
 295         instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
 296         if err != nil {
 297                 a1.Logger.Error("policy type error : %v", err)
 298         }
 299         a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
 300
 301         if instanceMap[instancekey] != nil {
 302                 operation = "UPDATE"
 303                 a1.Logger.Debug("UPDATE")
 304                 data, _ := json.Marshal(httpBody)
 305                 a1.Logger.Debug("Marshaled String : %+v", string(data))
 306                 a1.Logger.Debug("key   : %+v", instancekey)
 307                 success, err1 := rh.db.SetIf(a1MediatorNs, instancekey, instanceMap[instancekey], string(data))
 308                 if err1 != nil {
 309                         a1.Logger.Error("error2 :%+v", err1)
 310                         return operation, err1
 311                 }
 312                 if !success {
 313                         a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
 314                         return operation, InstanceAlreadyError
 315                 }
 316         } else {
 317                 data, _ := json.Marshal(httpBody)
 318                 a1.Logger.Debug("Marshaled String : %+v", string(data))
 319                 a1.Logger.Debug("key   : %+v", instancekey)
 320
 321                 var instance_map []interface{}
 322                 instance_map = append(instance_map, instancekey, string(data))
 323                 a1.Logger.Debug("policyinstancetype map : %+v", instance_map[1])
 324                 a1.Logger.Debug("policyinstancetype to create : %+v", instance_map)
 325
 326                 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
 327                 if err1 != nil {
 328                         a1.Logger.Error("error1 :%+v", err1)
 329                         return operation, err1
 330                 }
 331         }
 332         a1.Logger.Debug("Policy Instance created ")
 333         return operation, nil
 334 }
 335
 336 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
 337
 338         creation_timestamp := time.Now()
 339         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 340
 341         a1.Logger.Debug("key : %+v", instanceMetadataKey)
 342
 343         var metadatajson []interface{}
 344         metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"})
 345         metadata, _ := json.Marshal(metadatajson)
 346
 347         a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
 348
 349         err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
 350
 351         if err != nil {
 352                 a1.Logger.Error("error :%+v", err)
 353                 return false, err
 354         }
 355
 356         a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
 357
 358         return true, nil
 359 }
 360
 361 func (rh *Resthook) CreatePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) error {
 362         a1.Logger.Debug("CreatePolicyInstance function")
 363         //  validate the PUT against the schema
 364         var policyTypeSchema *models.PolicyTypeSchema
 365         policyTypeSchema = rh.GetPolicyType(policyTypeId)
 366         schemaStr, err := json.Marshal(policyTypeSchema.CreateSchema)
 367         if err != nil {
 368                 a1.Logger.Error("Json Marshal error : %+v", err)
 369                 return err
 370         }
 371         a1.Logger.Debug("schema to validate %+v", string(schemaStr))
 372         a1.Logger.Debug("httpbody to validate %+v", httpBody)
 373         schemaString := fmt.Sprint(string(schemaStr))
 374         httpBodyMarshal, err := json.Marshal(httpBody)
 375         httpBodyString := string((httpBodyMarshal))
 376         a1.Logger.Debug("schema to validate sprint  %+v", (schemaString))
 377         a1.Logger.Debug("httpbody to validate sprint %+v", httpBodyString)
 378         isvalid := validate(httpBodyString, schemaString)
 379         if isvalid {
 380                 var operation string
 381                 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
 382                 if err != nil {
 383                         a1.Logger.Error("error :%+v", err)
 384                         return err
 385                 }
 386                 a1.Logger.Debug("policy instance :%+v", operation)
 387                 iscreated, errmetadata := rh.storePolicyInstanceMetadata(policyTypeId, policyInstanceID)
 388                 if errmetadata != nil {
 389                         a1.Logger.Error("error :%+v", errmetadata)
 390                         return errmetadata
 391                 }
 392                 if iscreated {
 393                         a1.Logger.Debug("policy instance metadata created")
 394                 }
 395
 396                 message := rmr.Message{}
 397                 rmrMessage, err := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
 398                 if err != nil {
 399                         a1.Logger.Error("error : %v", err)
 400                         return err
 401                 }
 402                 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
 403                 if isSent {
 404                         a1.Logger.Debug("rmrSendToXapp : message sent")
 405                 } else {
 406                         a1.Logger.Debug("rmrSendToXapp : message not sent")
 407                 }
 408
 409         } else {
 410                 a1.Logger.Error("%+v", invalidJsonSchema)
 411                 return invalidJsonSchema
 412         }
 413
 414         return nil
 415 }
 416
 417 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (interface{}, error) {
 418         a1.Logger.Debug("GetPolicyInstance1")
 419
 420         var keys [1]string
 421
 422         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 423         keys[0] = typekey
 424
 425         a1.Logger.Debug("key1 : %+v", typekey)
 426
 427         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 428         if len(valmap) == 0 {
 429                 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
 430                 return "{}", policyTypeNotFoundError
 431         }
 432
 433         if err != nil {
 434                 a1.Logger.Error("error in retrieving policy type. err: %v", err)
 435                 return "{}", err
 436         }
 437
 438         if valmap[typekey] == nil {
 439                 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
 440                 return "{}", policyTypeNotFoundError
 441         }
 442
 443         a1.Logger.Debug("keysmap : %+v", valmap[typekey])
 444
 445         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 446         a1.Logger.Debug("key2 : %+v", instancekey)
 447         keys[0] = instancekey
 448         instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
 449         if err != nil {
 450                 a1.Logger.Error("policy instance error : %v", err)
 451         }
 452         a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
 453
 454         if instanceMap[instancekey] == nil {
 455                 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
 456                 return "{}", policyInstanceNotFoundError
 457         }
 458
 459         valStr := fmt.Sprint(instanceMap[instancekey])
 460         return valStr, nil
 461 }
 462
 463 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
 464         a1.Logger.Debug("GetAllPolicyInstance")
 465         var policyTypeInstances = []models.PolicyInstanceID{}
 466
 467         keys, err := rh.db.GetAll("A1m_ns")
 468
 469         if err != nil {
 470                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 471                 return policyTypeInstances, err
 472         }
 473         a1.Logger.Debug("keys : %+v", keys)
 474         typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
 475
 476         for _, key := range keys {
 477                 if strings.HasPrefix(strings.TrimLeft(key, " "), typekey) {
 478                         pti := strings.Split(strings.Trim(key, " "), typekey)[1]
 479                         a1.Logger.Debug("pti %+v", pti)
 480                         policyTypeInstances = append(policyTypeInstances, models.PolicyInstanceID(pti))
 481                 }
 482         }
 483
 484         if len(policyTypeInstances) == 0 {
 485                 a1.Logger.Debug("policy instance Not Present  ")
 486         }
 487
 488         a1.Logger.Debug("return : %+v", policyTypeInstances)
 489         return policyTypeInstances, nil
 490 }
 491
 492 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
 493         a1.Logger.Debug("DeletePolicyType")
 494
 495         policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
 496         if err != nil {
 497                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 498                 return err
 499         }
 500
 501         var keys [1]string
 502         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 503         keys[0] = key
 504         if len(policyinstances) == 0 {
 505                 err := rh.db.Remove(a1MediatorNs, keys[:])
 506                 if err != nil {
 507                         a1.Logger.Error("error in deleting policy type err: %v", err)
 508                         return err
 509                 }
 510         } else {
 511                 a1.Logger.Error("tried to delete a type that isn't empty")
 512                 return policyTypeCanNotBeDeletedError
 513         }
 514         return nil
 515 }
 516
 517 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
 518         var keys [1]string
 519
 520         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 521         keys[0] = typekey
 522
 523         a1.Logger.Debug("key1 : %+v", typekey)
 524         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 525         if err != nil {
 526                 a1.Logger.Error("error in retrieving policytype err: %v", err)
 527                 return err
 528         }
 529         if len(valmap) == 0 {
 530                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 531                 return policyTypeNotFoundError
 532         }
 533 }
 534
 535 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 536         err := rh.typeValidity(policyTypeId)
 537         if err != nil {
 538                 return err
 539         }
 540         policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
 541         if err != nil {
 542                 a1.Logger.Error("policy instance error : %v", err)
 543                 return err
 544         }
 545         if len(policyTypeInstances.(string)) == 0 {
 546                 a1.Logger.Debug("policy instance Not Present  ")
 547                 return policyInstanceNotFoundError
 548         }
 549 }
 550
 551 func (rh *Resthook) getMetaData(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (map[string]interface{}, error) {
 552         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 553         a1.Logger.Debug("instanceMetadata key : %+v", instanceMetadataKey)
 554         var keys [1]string
 555         keys[0] = instanceMetadataKey
 556         instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
 557         if err != nil {
 558                 a1.Logger.Error("policy instance error : %v", err)
 559         }
 560         a1.Logger.Debug("instanceMetadata map : %+v", instanceMetadataMap)
 561         if instanceMetadataMap[instanceMetadataKey] == nil {
 562                 a1.Logger.Error("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
 563                 return map[string]interface{}{}, policyInstanceNotFoundError
 564         }
 565         return instanceMetadataMap, nil
 566 }
 567
 568 func (rh *Resthook) GetPolicyInstanceStatus(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (*a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody, error) {
 569         err := rh.instanceValidity(policyTypeId, policyInstanceID)
 570         if err != nil && err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
 571                 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
 572                 return &policyInstanceStatus, err
 573         }
 574         policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
 575         metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
 576         a1.Logger.Debug(" metadata %v", metadata)
 577         if err != nil {
 578                 a1.Logger.Error("policy instance error : %v", err)
 579                 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
 580                 return &policyInstanceStatus, err
 581         }
 582         jsonbody, err := json.Marshal(metadata)
 583         if err != nil {
 584                 a1.Logger.Error("marshal error : %v", err)
 585                 return &policyInstanceStatus, err
 586         }
 587
 588         if err := json.Unmarshal(jsonbody, &policyInstanceStatus); err != nil {
 589                 a1.Logger.Error("unmarshal error : %v", err)
 590                 //this error maps to 503 error but can be mapped to 500: internal error
 591                 return &policyInstanceStatus, err
 592         }
 593         if policyInstanceStatus.HasBeenDeleted == false {
 594                 policyInstanceStatus.InstanceStatus = "IN EFFECT"
 595         } else {
 596                 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
 597         }
 598         return &policyInstanceStatus, nil
 599 }
 600
 601 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
 602         deleted_timestamp := time.Now()
 603
 604         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 605
 606         a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
 607
 608         var metadatajson interface{}
 609         metadatajson = map[string]string{"created_at": creation_timestamp, "has_been_deleted": "True", "deleted_at": deleted_timestamp.Format("2006-01-02 15:04:05")}
 610         a1.Logger.Debug("metadatajson to create : %+v", metadatajson)
 611         deletedmetadata, err := json.Marshal(metadatajson)
 612
 613         a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
 614
 615         err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
 616         a1.Logger.Debug("deletemetadatacreated")
 617         if err != nil {
 618                 a1.Logger.Error("error :%+v", err)
 619                 return err
 620         }
 621
 622         a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
 623
 624         return nil
 625 }
 626
 627 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 628         var keys [1]string
 629         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 630         keys[0] = instancekey
 631         err := rh.db.Remove(a1MediatorNs, keys[:])
 632         if err != nil {
 633                 a1.Logger.Error("error in deleting policy type err: %v", err)
 634                 return err
 635         }
 636         return nil
 637 }
 638
 639 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 640         var keys [1]string
 641         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 642
 643         a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
 644         keys[0] = instanceMetadataKey
 645         err := rh.db.Remove(a1MediatorNs, keys[:])
 646         if err != nil {
 647                 a1.Logger.Error("error in deleting policy metadata err: %v", err)
 648                 return err
 649         }
 650         return nil
 651 }
 652
 653 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 654         err := rh.instanceValidity(policyTypeId, policyInstanceID)
 655         if err != nil {
 656                 a1.Logger.Error("policy instance error : %v", err)
 657                 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
 658                         return err
 659                 }
 660         }
 661
 662         createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
 663         if err != nil {
 664                 a1.Logger.Error("error : %v", err)
 665                 return err
 666         }
 667         a1.Logger.Debug(" created metadata %v", createdmetadata)
 668         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 669         creation_metadata := createdmetadata[instanceMetadataKey]
 670         var metadata map[string]interface{}
 671         if err = json.Unmarshal([]byte(creation_metadata.(string)), &metadata); err != nil {
 672                 a1.Logger.Error("unmarshal error : %v", err)
 673                 return err
 674         }
 675
 676         a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
 677         creation_timestamp := metadata["created_at"]
 678
 679         rh.deleteMetadata(policyTypeId, policyInstanceID)
 680
 681         rh.deleteInstancedata(policyTypeId, policyInstanceID)
 682
 683         rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
 684
 685         message := rmr.Message{}
 686         rmrMessage, err1 := message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
 687         if err1 != nil {
 688                 a1.Logger.Error("error : %v", err1)
 689                 return err1
 690         }
 691         isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
 692         if isSent {
 693                 a1.Logger.Debug("rmrSendToXapp : message sent")
 694         } else {
 695                 //TODO:if message not sent need to return error or just log it or retry sending
 696                 a1.Logger.Error("rmrSendToXapp : message not sent")
 697         }
 698
 699         return nil
 700 }
 701
 702 func (rh *Resthook) DataDelivery(httpBody interface{}) error {
 703         a1.Logger.Debug("httpbody : %+v", httpBody)
 704         mymap := httpBody.(map[string]interface{})
 705         message := rmr.Message{}
 706         rmrMessage, err := message.A1EIMessage(mymap["job"].(string), mymap["payload"].(string))
 707         if err != nil {
 708                 a1.Logger.Error("error : %v", err)
 709                 return err
 710         }
 711         a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
 712         isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
 713         if isSent {
 714                 a1.Logger.Debug("rmrSendToXapp : message sent")
 715         } else {
 716                 a1.Logger.Error("rmrSendToXapp : message not sent")
 717         }
 718         return nil
 719 }