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) GetAllPolicyType() []models.PolicyTypeID {
  99
 100         var policyTypeIDs []models.PolicyTypeID
 101
 102         keys, err := rh.db.GetAll("A1m_ns")
 103
 104         if err != nil {
 105                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 106                 return policyTypeIDs
 107         }
 108         a1.Logger.Debug("keys : %+v", keys)
 109
 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))
 115                 }
 116         }
 117
 118         a1.Logger.Debug("return : %+v", policyTypeIDs)
 119         return policyTypeIDs
 120 }
 121
 122 func (rh *Resthook) GetPolicyType(policyTypeId models.PolicyTypeID) *models.PolicyTypeSchema {
 123         a1.Logger.Debug("GetPolicyType1")
 124
 125         var policytypeschema *models.PolicyTypeSchema
 126         var keys [1]string
 127
 128         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 129         keys[0] = key
 130
 131         a1.Logger.Debug("key : %+v", key)
 132
 133         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 134
 135         a1.Logger.Debug("policytype map : %+v", valmap)
 136
 137         if len(valmap) == 0 {
 138                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 139                 return policytypeschema
 140         }
 141
 142         if err != nil {
 143                 a1.Logger.Error("error in retrieving policy type. err: %v", err)
 144                 return nil
 145         }
 146
 147         if valmap[key] == nil {
 148                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 149                 return policytypeschema
 150         }
 151
 152         a1.Logger.Debug("keysmap : %+v", valmap[key])
 153
 154         var item models.PolicyTypeSchema
 155         valStr := fmt.Sprint(valmap[key])
 156
 157         a1.Logger.Debug("Policy type for %+v :  %+v", key, valStr)
 158         valkey := "`" + valStr + "`"
 159         valToUnmarshall, err := strconv.Unquote(valkey)
 160         if err != nil {
 161                 a1.Logger.Error("unquote error : %+v", err)
 162                 return nil
 163         }
 164
 165         a1.Logger.Debug("Policy type for %+v :  %+v", key, string(valToUnmarshall))
 166
 167         errunm := json.Unmarshal([]byte(valToUnmarshall), &item)
 168
 169         a1.Logger.Debug(" Unmarshalled json : %+v", (errunm))
 170         a1.Logger.Debug("Policy type Name :  %v", (item.Name))
 171
 172         return &item
 173 }
 174
 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) {
 178                 //error message
 179                 a1.Logger.Debug("Policytype Mismatch")
 180                 return typeMismatchError
 181         }
 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)
 188                 if err1 != nil {
 189                         a1.Logger.Error("error :%+v", err1)
 190                         return err1
 191                 }
 192                 if !success {
 193                         a1.Logger.Debug("Policy type %+v already exist", policyTypeId)
 194                         return typeAlreadyError
 195                 }
 196         }
 197         return nil
 198 }
 199
 200 func toStringKeys(val interface{}) (interface{}, error) {
 201         var err error
 202         switch val := val.(type) {
 203         case map[interface{}]interface{}:
 204                 m := make(map[string]interface{})
 205                 for k, v := range val {
 206                         k, ok := k.(string)
 207                         if !ok {
 208                                 return nil, errors.New("found non-string key")
 209                         }
 210                         m[k], err = toStringKeys(v)
 211                         if err != nil {
 212                                 return nil, err
 213                         }
 214                 }
 215                 return m, nil
 216         case []interface{}:
 217                 var l = make([]interface{}, len(val))
 218                 for i, v := range val {
 219                         l[i], err = toStringKeys(v)
 220                         if err != nil {
 221                                 return nil, err
 222                         }
 223                 }
 224                 return l, nil
 225         default:
 226                 return val, nil
 227         }
 228 }
 229
 230 func validate(httpBodyString string, schemaString string) bool {
 231         var m interface{}
 232         err := yaml.Unmarshal([]byte(httpBodyString), &m)
 233         if err != nil {
 234                 a1.Logger.Error("Unmarshal error : %+v", err)
 235         }
 236         m, err = toStringKeys(m)
 237         if err != nil {
 238                 a1.Logger.Error("Conversion to string error : %+v", err)
 239                 return false
 240         }
 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)
 244                 return false
 245         }
 246         schema, err := compiler.Compile("schema.json")
 247         if err != nil {
 248                 a1.Logger.Error("schema json compile error : %+v", err)
 249                 return false
 250         }
 251         if err := schema.Validate(m); err != nil {
 252                 a1.Logger.Error("schema validation error : %+v", err)
 253                 return false
 254         }
 255         a1.Logger.Debug("validation successfull")
 256         return true
 257 }
 258
 259 func (rh *Resthook) storePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, httpBody interface{}) (string, error) {
 260         var keys [1]string
 261         operation := "CREATE"
 262         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 263         keys[0] = typekey
 264
 265         a1.Logger.Debug("key1 : %+v", typekey)
 266
 267         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 268         if err != nil {
 269                 a1.Logger.Error("policy type error : %+v", err)
 270         }
 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
 275         }
 276         // TODO : rmr creation_timestamp := time.Now() // will be needed for rmr to notify the creation of instance
 277
 278         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 279         keys[0] = typekey
 280         instanceMap, err := rh.db.Get(a1MediatorNs, keys[:])
 281         if err != nil {
 282                 a1.Logger.Error("policy type error : %v", err)
 283         }
 284         a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
 285
 286         if instanceMap[instancekey] != nil {
 287                 operation = "UPDATE"
 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))
 293                 if err1 != nil {
 294                         a1.Logger.Error("error2 :%+v", err1)
 295                         return operation, err1
 296                 }
 297                 if !success {
 298                         a1.Logger.Debug("Policy instance %+v already exist", policyInstanceID)
 299                         return operation, InstanceAlreadyError
 300                 }
 301         } else {
 302                 data, _ := json.Marshal(httpBody)
 303                 a1.Logger.Debug("Marshaled String : %+v", string(data))
 304                 a1.Logger.Debug("key   : %+v", instancekey)
 305
 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)
 310
 311                 err1 := rh.db.Set(a1MediatorNs, instancekey, string(data))
 312                 if err1 != nil {
 313                         a1.Logger.Error("error1 :%+v", err1)
 314                         return operation, err1
 315                 }
 316         }
 317         a1.Logger.Debug("Policy Instance created ")
 318         return operation, nil
 319 }
 320
 321 func (rh *Resthook) storePolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (bool, error) {
 322
 323         creation_timestamp := time.Now()
 324         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 325
 326         a1.Logger.Debug("key : %+v", instanceMetadataKey)
 327
 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)
 331
 332         a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(metadata))
 333
 334         err := rh.db.Set(a1MediatorNs, instanceMetadataKey, string(metadata))
 335
 336         if err != nil {
 337                 a1.Logger.Error("error :%+v", err)
 338                 return false, err
 339         }
 340
 341         a1.Logger.Debug("Policy Instance Meta Data created at :%+v", creation_timestamp)
 342
 343         return true, nil
 344 }
 345
 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)
 352         if err != nil {
 353                 a1.Logger.Error("Json Marshal error : %+v", err)
 354                 return err
 355         }
 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)
 364         if isvalid {
 365                 var operation string
 366                 operation, err = rh.storePolicyInstance(policyTypeId, policyInstanceID, httpBody)
 367                 if err != nil {
 368                         a1.Logger.Error("error :%+v", err)
 369                         return err
 370                 }
 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)
 375                         return errmetadata
 376                 }
 377                 if iscreated {
 378                         a1.Logger.Debug("policy instance metadata created")
 379                 }
 380
 381                 message := rmr.Message{}
 382                 rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), httpBodyString, operation)
 383                 if err != nil {
 384                         a1.Logger.Error("error : %v", err)
 385                         return err
 386                 }
 387                 isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
 388                 if isSent {
 389                         a1.Logger.Debug("rmrSendToXapp : message sent")
 390                 } else {
 391                         a1.Logger.Debug("rmrSendToXapp : message not sent")
 392                 }
 393
 394         } else {
 395                 a1.Logger.Error("%+v", invalidJsonSchema)
 396                 return invalidJsonSchema
 397         }
 398
 399         return nil
 400 }
 401
 402 func (rh *Resthook) GetPolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) (interface{}, error) {
 403         a1.Logger.Debug("GetPolicyInstance1")
 404
 405         var keys [1]string
 406
 407         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 408         keys[0] = typekey
 409
 410         a1.Logger.Debug("key1 : %+v", typekey)
 411
 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
 416         }
 417
 418         if err != nil {
 419                 a1.Logger.Error("error in retrieving policy type. err: %v", err)
 420                 return "{}", err
 421         }
 422
 423         if valmap[typekey] == nil {
 424                 a1.Logger.Debug("policy type Not Present for policyid : %v", policyTypeId)
 425                 return "{}", policyTypeNotFoundError
 426         }
 427
 428         a1.Logger.Debug("keysmap : %+v", valmap[typekey])
 429
 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[:])
 434         if err != nil {
 435                 a1.Logger.Error("policy instance error : %v", err)
 436         }
 437         a1.Logger.Debug("policyinstancetype map : %+v", instanceMap)
 438
 439         if instanceMap[instancekey] == nil {
 440                 a1.Logger.Debug("policy instance Not Present for policyinstaneid : %v", policyInstanceID)
 441                 return "{}", policyInstanceNotFoundError
 442         }
 443
 444         valStr := fmt.Sprint(instanceMap[instancekey])
 445         return valStr, nil
 446 }
 447
 448 func (rh *Resthook) GetAllPolicyInstance(policyTypeId models.PolicyTypeID) ([]models.PolicyInstanceID, error) {
 449         a1.Logger.Debug("GetAllPolicyInstance")
 450         var policyTypeInstances = []models.PolicyInstanceID{}
 451
 452         keys, err := rh.db.GetAll("A1m_ns")
 453
 454         if err != nil {
 455                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 456                 return policyTypeInstances, err
 457         }
 458         a1.Logger.Debug("keys : %+v", keys)
 459         typekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "."
 460
 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))
 466                 }
 467         }
 468
 469         if len(policyTypeInstances) == 0 {
 470                 a1.Logger.Debug("policy instance Not Present  ")
 471         }
 472
 473         a1.Logger.Debug("return : %+v", policyTypeInstances)
 474         return policyTypeInstances, nil
 475 }
 476
 477 func (rh *Resthook) DeletePolicyType(policyTypeId models.PolicyTypeID) error {
 478         a1.Logger.Debug("DeletePolicyType")
 479
 480         policyinstances, err := rh.GetAllPolicyInstance(policyTypeId)
 481         if err != nil {
 482                 a1.Logger.Error("error in retrieving policy. err: %v", err)
 483                 return err
 484         }
 485
 486         var keys [1]string
 487         key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 488         keys[0] = key
 489         if len(policyinstances) == 0 {
 490                 err := rh.db.Remove(a1MediatorNs, keys[:])
 491                 if err != nil {
 492                         a1.Logger.Error("error in deleting policy type err: %v", err)
 493                         return err
 494                 }
 495         } else {
 496                 a1.Logger.Error("tried to delete a type that isn't empty")
 497                 return policyTypeCanNotBeDeletedError
 498         }
 499         return nil
 500 }
 501
 502 func (rh *Resthook) typeValidity(policyTypeId models.PolicyTypeID) error {
 503         var keys [1]string
 504
 505         typekey := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10)
 506         keys[0] = typekey
 507
 508         a1.Logger.Debug("key1 : %+v", typekey)
 509         valmap, err := rh.db.Get(a1MediatorNs, keys[:])
 510         if err != nil {
 511                 a1.Logger.Error("error in retrieving policytype err: %v", err)
 512                 return err
 513         }
 514         if len(valmap) == 0 {
 515                 a1.Logger.Error("policy type Not Present for policyid : %v", policyTypeId)
 516                 return policyTypeNotFoundError
 517         }
 518 }
 519
 520 func (rh *Resthook) instanceValidity(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 521         err := rh.typeValidity(policyTypeId)
 522         if err != nil {
 523                 return err
 524         }
 525         policyTypeInstances, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID)
 526         if err != nil {
 527                 a1.Logger.Error("policy instance error : %v", err)
 528                 return err
 529         }
 530         if len(policyTypeInstances.(string)) == 0 {
 531                 a1.Logger.Debug("policy instance Not Present  ")
 532                 return policyInstanceNotFoundError
 533         }
 534 }
 535
 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)
 539         var keys [1]string
 540         keys[0] = instanceMetadataKey
 541         instanceMetadataMap, err := rh.db.Get(a1MediatorNs, keys[:])
 542         if err != nil {
 543                 a1.Logger.Error("policy instance error : %v", err)
 544         }
 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
 549         }
 550         return instanceMetadataMap, nil
 551 }
 552
 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
 558         }
 559         policyInstanceStatus := a1_mediator.A1ControllerGetPolicyInstanceStatusOKBody{}
 560         metadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
 561         a1.Logger.Debug(" metadata %v", metadata)
 562         if err != nil {
 563                 a1.Logger.Error("policy instance error : %v", err)
 564                 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
 565                 return &policyInstanceStatus, err
 566         }
 567         jsonbody, err := json.Marshal(metadata)
 568         if err != nil {
 569                 a1.Logger.Error("marshal error : %v", err)
 570                 return &policyInstanceStatus, err
 571         }
 572
 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
 577         }
 578         if policyInstanceStatus.HasBeenDeleted == false {
 579                 policyInstanceStatus.InstanceStatus = "IN EFFECT"
 580         } else {
 581                 policyInstanceStatus.InstanceStatus = "NOT IN EFFECT"
 582         }
 583         return &policyInstanceStatus, nil
 584 }
 585
 586 func (rh *Resthook) storeDeletedPolicyInstanceMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID, creation_timestamp string) error {
 587         deleted_timestamp := time.Now()
 588
 589         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 590
 591         a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
 592
 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)
 597
 598         a1.Logger.Debug("policyinstanceMetaData to create : %+v", string(deletedmetadata))
 599
 600         err = rh.db.Set(a1MediatorNs, instanceMetadataKey, string(deletedmetadata))
 601         a1.Logger.Debug("deletemetadatacreated")
 602         if err != nil {
 603                 a1.Logger.Error("error :%+v", err)
 604                 return err
 605         }
 606
 607         a1.Logger.Error("Policy Instance Meta Data deleted at :%+v", creation_timestamp)
 608
 609         return nil
 610 }
 611
 612 func (rh *Resthook) deleteInstancedata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 613         var keys [1]string
 614         instancekey := a1InstancePrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 615         keys[0] = instancekey
 616         err := rh.db.Remove(a1MediatorNs, keys[:])
 617         if err != nil {
 618                 a1.Logger.Error("error in deleting policy type err: %v", err)
 619                 return err
 620         }
 621         return nil
 622 }
 623
 624 func (rh *Resthook) deleteMetadata(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 625         var keys [1]string
 626         instanceMetadataKey := a1InstanceMetadataPrefix + strconv.FormatInt((int64(policyTypeId)), 10) + "." + string(policyInstanceID)
 627
 628         a1.Logger.Debug("instanceMetadata Key : %+v", instanceMetadataKey)
 629         keys[0] = instanceMetadataKey
 630         err := rh.db.Remove(a1MediatorNs, keys[:])
 631         if err != nil {
 632                 a1.Logger.Error("error in deleting policy metadata err: %v", err)
 633                 return err
 634         }
 635         return nil
 636 }
 637
 638 func (rh *Resthook) DeletePolicyInstance(policyTypeId models.PolicyTypeID, policyInstanceID models.PolicyInstanceID) error {
 639         err := rh.instanceValidity(policyTypeId, policyInstanceID)
 640         if err != nil {
 641                 a1.Logger.Error("policy instance error : %v", err)
 642                 if err == policyInstanceNotFoundError || err == policyTypeNotFoundError {
 643                         return err
 644                 }
 645         }
 646
 647         createdmetadata, err := rh.getMetaData(policyTypeId, policyInstanceID)
 648         if err != nil {
 649                 a1.Logger.Error("error : %v", err)
 650                 return err
 651         }
 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)
 658                 return err
 659         }
 660
 661         a1.Logger.Debug(" created metadata created_at %v", metadata["created_at"])
 662         creation_timestamp := metadata["created_at"]
 663
 664         rh.deleteMetadata(policyTypeId, policyInstanceID)
 665
 666         rh.deleteInstancedata(policyTypeId, policyInstanceID)
 667
 668         rh.storeDeletedPolicyInstanceMetadata(policyTypeId, policyInstanceID, creation_timestamp.(string))
 669
 670         message := rmr.Message{}
 671         rmrMessage, err = message.PolicyMessage(strconv.FormatInt((int64(policyTypeId)), 10), string(policyInstanceID), "", "DELETE")
 672         if err != nil {
 673                 a1.Logger.Error("error : %v", err)
 674                 return err
 675         }
 676         isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1PolicyRequest)
 677         if isSent {
 678                 a1.Logger.Debug("rmrSendToXapp : message sent")
 679         } else {
 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")
 682         }
 683
 684         return nil
 685 }
 686
 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))
 692         if err != nil {
 693                 a1.Logger.Error("error : %v", err)
 694                 return err
 695         }
 696         a1.Logger.Debug("rmrSendToXapp :rmrMessage %+v", rmrMessage)
 697         isSent := rh.iRmrSenderInst.RmrSendToXapp(rmrMessage, a1EIDataDelivery)
 698         if isSent {
 699                 a1.Logger.Debug("rmrSendToXapp : message sent")
 700         } else {
 701                 a1.Logger.Error("rmrSendToXapp : message not sent")
 702         }
 703         return nil
 704 }