pkg/restful/restful.go

   1 /*
   2 ==================================================================================
   3
   4         Copyright (c) 2021 Samsung
   5
   6          Licensed under the Apache License, Version 2.0 (the "License");
   7          you may not use this file except in compliance with the License.
   8          You may obtain a copy of the License at
   9
  10              http://www.apache.org/licenses/LICENSE-2.0
  11
  12          Unless required by applicable law or agreed to in writing, software
  13          distributed under the License is distributed on an "AS IS" BASIS,
  14          WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15          See the License for the specific language governing permissions and
  16          limitations under the License.
  17
  18          This source code is part of the near-RT RIC (RAN Intelligent Controller)
  19          platform project (RICP).
  20
  21 ==================================================================================
  22 */
  23 package restful
  24
  25 import (
  26         "log"
  27         "os"
  28
  29         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1"
  30         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models"
  31         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/restapi"
  32         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/restapi/operations"
  33         "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/restapi/operations/a1_e_i_data_delivery"
  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/resthooks"
  36         "github.com/go-openapi/loads"
  37         "github.com/go-openapi/runtime/middleware"
  38 )
  39
  40 func NewRestful() *Restful {
  41         r := &Restful{
  42                 rh: resthooks.NewResthook(),
  43         }
  44         r.api = r.setupHandler()
  45         return r
  46 }
  47
  48 func (r *Restful) setupHandler() *operations.A1API {
  49         swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwaggerJSON)
  50         if err != nil {
  51                 os.Exit(1)
  52         }
  53
  54         api := operations.NewA1API(swaggerSpec)
  55
  56         api.A1MediatorA1ControllerGetHealthcheckHandler = a1_mediator.A1ControllerGetHealthcheckHandlerFunc(func(param a1_mediator.A1ControllerGetHealthcheckParams) middleware.Responder {
  57                 a1.Logger.Debug("handler for get Health Check of A1")
  58                 resp := r.rh.GetA1Health()
  59                 if resp == false {
  60                         return a1_mediator.NewA1ControllerGetHealthcheckInternalServerError()
  61                 }
  62                 return a1_mediator.NewA1ControllerGetHealthcheckOK()
  63         })
  64
  65         api.A1MediatorA1ControllerGetAllPolicyTypesHandler = a1_mediator.A1ControllerGetAllPolicyTypesHandlerFunc(func(param a1_mediator.A1ControllerGetAllPolicyTypesParams) middleware.Responder {
  66                 a1.Logger.Debug("handler for get all policy type")
  67                 return a1_mediator.NewA1ControllerGetAllPolicyTypesOK().WithPayload(r.rh.GetAllPolicyType())
  68         })
  69
  70         api.A1MediatorA1ControllerCreatePolicyTypeHandler = a1_mediator.A1ControllerCreatePolicyTypeHandlerFunc(func(params a1_mediator.A1ControllerCreatePolicyTypeParams) middleware.Responder {
  71                 a1.Logger.Debug("handler for Create policy type ")
  72                 if err = r.rh.CreatePolicyType(models.PolicyTypeID(params.PolicyTypeID), *params.Body); err == nil {
  73                         //Increase prometheus counter
  74                         return a1_mediator.NewA1ControllerCreatePolicyTypeCreated()
  75                 }
  76                 if r.rh.IsTypeAlready(err) || r.rh.IsTypeMismatch(err) {
  77                         return a1_mediator.NewA1ControllerCreatePolicyTypeBadRequest()
  78                 }
  79                 return a1_mediator.NewA1ControllerCreatePolicyTypeServiceUnavailable()
  80
  81         })
  82
  83         api.A1MediatorA1ControllerGetPolicyTypeHandler = a1_mediator.A1ControllerGetPolicyTypeHandlerFunc(func(params a1_mediator.A1ControllerGetPolicyTypeParams) middleware.Responder {
  84                 a1.Logger.Debug("handler for get policy type from policytypeID")
  85                 var policyTypeSchema *models.PolicyTypeSchema
  86                 policyTypeSchema, err = r.rh.GetPolicyType(models.PolicyTypeID(params.PolicyTypeID))
  87                 if err != nil {
  88                         return a1_mediator.NewA1ControllerGetPolicyTypeNotFound()
  89                 }
  90                 return a1_mediator.NewA1ControllerGetPolicyTypeOK().WithPayload(policyTypeSchema)
  91         })
  92
  93         api.A1MediatorA1ControllerCreateOrReplacePolicyInstanceHandler = a1_mediator.A1ControllerCreateOrReplacePolicyInstanceHandlerFunc(func(params a1_mediator.A1ControllerCreateOrReplacePolicyInstanceParams) middleware.Responder {
  94                 a1.Logger.Debug("handler for create policy type instance ")
  95                 var notificationDestination string
  96                 if params.NotificationDestination != nil {
  97                         notificationDestination = *params.NotificationDestination
  98                 }
  99                 if err = r.rh.CreatePolicyInstance(models.PolicyTypeID(params.PolicyTypeID), models.PolicyInstanceID(params.PolicyInstanceID), params.Body, notificationDestination); err == nil {
 100
 101                         return a1_mediator.NewA1ControllerCreateOrReplacePolicyInstanceAccepted()
 102                 }
 103                 if r.rh.IsValidJson(err) {
 104                         return a1_mediator.NewA1ControllerCreateOrReplacePolicyInstanceBadRequest()
 105                 }
 106                 return a1_mediator.NewA1ControllerCreateOrReplacePolicyInstanceServiceUnavailable()
 107
 108         })
 109
 110         api.A1MediatorA1ControllerGetPolicyInstanceHandler = a1_mediator.A1ControllerGetPolicyInstanceHandlerFunc(func(params a1_mediator.A1ControllerGetPolicyInstanceParams) middleware.Responder {
 111                 a1.Logger.Debug("handler for get policy instance from policytypeID")
 112                 if resp, err := r.rh.GetPolicyInstance(models.PolicyTypeID(params.PolicyTypeID), models.PolicyInstanceID(params.PolicyInstanceID)); err == nil {
 113                         return a1_mediator.NewA1ControllerGetPolicyInstanceOK().WithPayload(resp)
 114                 }
 115                 if r.rh.IsPolicyInstanceNotFound(err) {
 116                         return a1_mediator.NewA1ControllerGetPolicyInstanceNotFound()
 117                 }
 118                 return a1_mediator.NewA1ControllerGetPolicyInstanceServiceUnavailable()
 119         })
 120
 121         api.A1MediatorA1ControllerGetAllInstancesForTypeHandler = a1_mediator.A1ControllerGetAllInstancesForTypeHandlerFunc(func(params a1_mediator.A1ControllerGetAllInstancesForTypeParams) middleware.Responder {
 122                 a1.Logger.Debug("handler for get all policy instance")
 123                 if resp, err := r.rh.GetAllPolicyInstance(models.PolicyTypeID(params.PolicyTypeID)); err == nil {
 124                         if resp != nil {
 125                                 return a1_mediator.NewA1ControllerGetAllInstancesForTypeOK().WithPayload(resp)
 126                         }
 127                 }
 128                 if r.rh.IsPolicyInstanceNotFound(err) {
 129                         return a1_mediator.NewA1ControllerGetPolicyInstanceNotFound()
 130                 }
 131                 return a1_mediator.NewA1ControllerGetAllInstancesForTypeServiceUnavailable()
 132
 133         })
 134
 135         api.A1MediatorA1ControllerDeletePolicyTypeHandler = a1_mediator.A1ControllerDeletePolicyTypeHandlerFunc(func(params a1_mediator.A1ControllerDeletePolicyTypeParams) middleware.Responder {
 136                 a1.Logger.Debug("handler for delete policy type")
 137                 if err := r.rh.DeletePolicyType(models.PolicyTypeID(params.PolicyTypeID)); err != nil {
 138                         if r.rh.CanPolicyTypeBeDeleted(err) {
 139                                 return a1_mediator.NewA1ControllerDeletePolicyTypeBadRequest()
 140                         }
 141                         return a1_mediator.NewA1ControllerDeletePolicyTypeServiceUnavailable()
 142                 }
 143
 144                 return a1_mediator.NewA1ControllerDeletePolicyTypeNoContent()
 145
 146         })
 147
 148         api.A1MediatorA1ControllerGetPolicyInstanceStatusHandler = a1_mediator.A1ControllerGetPolicyInstanceStatusHandlerFunc(func(params a1_mediator.A1ControllerGetPolicyInstanceStatusParams) middleware.Responder {
 149                 a1.Logger.Debug("handler for get policy instance status")
 150                 if resp, err := r.rh.GetPolicyInstanceStatus(models.PolicyTypeID(params.PolicyTypeID), models.PolicyInstanceID(params.PolicyInstanceID)); err == nil {
 151                         return a1_mediator.NewA1ControllerGetPolicyInstanceStatusOK().WithPayload(resp)
 152                 } else if r.rh.IsPolicyInstanceNotFound(err) {
 153                         return a1_mediator.NewA1ControllerGetPolicyInstanceStatusNotFound()
 154                 }
 155                 return a1_mediator.NewA1ControllerGetPolicyInstanceStatusServiceUnavailable()
 156         })
 157
 158         api.A1MediatorA1ControllerDeletePolicyInstanceHandler = a1_mediator.A1ControllerDeletePolicyInstanceHandlerFunc(func(params a1_mediator.A1ControllerDeletePolicyInstanceParams) middleware.Responder {
 159                 a1.Logger.Debug("handler for delete policy instance")
 160                 if err := r.rh.DeletePolicyInstance(models.PolicyTypeID(params.PolicyTypeID), models.PolicyInstanceID(params.PolicyInstanceID)); err != nil {
 161                         if r.rh.CanPolicyInstanceBeDeleted(err) {
 162                                 return a1_mediator.NewA1ControllerDeletePolicyInstanceNotFound()
 163                         }
 164                         return a1_mediator.NewA1ControllerDeletePolicyInstanceServiceUnavailable()
 165                 }
 166
 167                 return a1_mediator.NewA1ControllerDeletePolicyInstanceAccepted()
 168
 169         })
 170
 171         api.A1eiDataDeliveryA1ControllerDataDeliveryHandler = a1_e_i_data_delivery.A1ControllerDataDeliveryHandlerFunc(func(params a1_e_i_data_delivery.A1ControllerDataDeliveryParams) middleware.Responder {
 172                 a1.Logger.Debug("handler for EI data delivery")
 173                 if err = r.rh.DataDelivery(params.Body); err != nil {
 174                         return a1_e_i_data_delivery.NewA1ControllerDataDeliveryNotFound()
 175                 }
 176                 return a1_e_i_data_delivery.NewA1ControllerDataDeliveryOK()
 177         })
 178
 179         return api
 180
 181 }
 182
 183 func (r *Restful) Run() {
 184
 185         server := restapi.NewServer(r.api)
 186         defer server.Shutdown()
 187         server.Port = 10000
 188         server.Host = "0.0.0.0"
 189         if err := server.Serve(); err != nil {
 190                 log.Fatal(err.Error())
 191         }
 192 }