capifcore/internal/invokermanagement/invokermanagement.go

   1 // -
   2 //   ========================LICENSE_START=================================
   3 //   O-RAN-SC
   4 //   %%
   5 //   Copyright (C) 2022: Nordix Foundation
   6 //   %%
   7 //   Licensed under the Apache License, Version 2.0 (the "License");
   8 //   you may not use this file except in compliance with the License.
   9 //   You may obtain a copy of the License at
  10 //
  11 //        http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 //   Unless required by applicable law or agreed to in writing, software
  14 //   distributed under the License is distributed on an "AS IS" BASIS,
  15 //   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 //   See the License for the specific language governing permissions and
  17 //   limitations under the License.
  18 //   ========================LICENSE_END===================================
  19 //
  20
  21 package invokermanagement
  22
  23 import (
  24         "errors"
  25         "fmt"
  26         "net/http"
  27         "path"
  28         "sync"
  29
  30         "oransc.org/nonrtric/capifcore/internal/eventsapi"
  31         publishapi "oransc.org/nonrtric/capifcore/internal/publishserviceapi"
  32
  33         "oransc.org/nonrtric/capifcore/internal/common29122"
  34         invokerapi "oransc.org/nonrtric/capifcore/internal/invokermanagementapi"
  35
  36         "oransc.org/nonrtric/capifcore/internal/publishservice"
  37
  38         "github.com/labstack/echo/v4"
  39 )
  40
  41 //go:generate mockery --name InvokerRegister
  42 type InvokerRegister interface {
  43         // Checks if the invoker is registered.
  44         // Returns true of the provided invoker is registered, false otherwise.
  45         IsInvokerRegistered(invokerId string) bool
  46         // Verifies that the provided secret is the invoker's registered secret.
  47         // Returns true if the provided secret is the registered invoker's secret, false otherwise.
  48         VerifyInvokerSecret(invokerId, secret string) bool
  49         // Gets the provided invoker's registered APIs.
  50         // Returns a list of all the invoker's registered APIs.
  51         GetInvokerApiList(invokerId string) *invokerapi.APIList
  52 }
  53
  54 type InvokerManager struct {
  55         onboardedInvokers map[string]invokerapi.APIInvokerEnrolmentDetails
  56         publishRegister   publishservice.PublishRegister
  57         nextId            int64
  58         eventChannel      chan<- eventsapi.EventNotification
  59         lock              sync.Mutex
  60 }
  61
  62 // Creates a manager that implements both the InvokerRegister and the invokermanagementapi.ServerInterface interfaces.
  63 func NewInvokerManager(publishRegister publishservice.PublishRegister, eventChannel chan<- eventsapi.EventNotification) *InvokerManager {
  64         return &InvokerManager{
  65                 onboardedInvokers: make(map[string]invokerapi.APIInvokerEnrolmentDetails),
  66                 publishRegister:   publishRegister,
  67                 nextId:            1000,
  68                 eventChannel:      eventChannel,
  69         }
  70 }
  71
  72 func (im *InvokerManager) IsInvokerRegistered(invokerId string) bool {
  73         im.lock.Lock()
  74         defer im.lock.Unlock()
  75
  76         _, registered := im.onboardedInvokers[invokerId]
  77         return registered
  78 }
  79
  80 func (im *InvokerManager) VerifyInvokerSecret(invokerId, secret string) bool {
  81         im.lock.Lock()
  82         defer im.lock.Unlock()
  83
  84         verified := false
  85         if invoker, registered := im.onboardedInvokers[invokerId]; registered {
  86                 verified = *invoker.OnboardingInformation.OnboardingSecret == secret
  87         }
  88         return verified
  89 }
  90
  91 func (im *InvokerManager) GetInvokerApiList(invokerId string) *invokerapi.APIList {
  92         var apiList invokerapi.APIList = im.publishRegister.GetAllPublishedServices()
  93         im.lock.Lock()
  94         defer im.lock.Unlock()
  95         invoker, ok := im.onboardedInvokers[invokerId]
  96         if ok {
  97                 invoker.ApiList = &apiList
  98                 return &apiList
  99         }
 100         return nil
 101 }
 102
 103 // Creates a new individual API Invoker profile.
 104 func (im *InvokerManager) PostOnboardedInvokers(ctx echo.Context) error {
 105         var newInvoker invokerapi.APIInvokerEnrolmentDetails
 106         errMsg := "Unable to onboard invoker due to %s"
 107         if err := ctx.Bind(&newInvoker); err != nil {
 108                 return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, "invalid format for invoker"))
 109         }
 110
 111         if im.isInvokerOnboarded(newInvoker) {
 112                 return sendCoreError(ctx, http.StatusForbidden, fmt.Sprintf(errMsg, "invoker already onboarded"))
 113         }
 114
 115         if err := im.validateInvoker(newInvoker, ctx); err != nil {
 116                 return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
 117         }
 118
 119         im.prepareNewInvoker(&newInvoker)
 120
 121         go im.sendEvent(*newInvoker.ApiInvokerId, eventsapi.CAPIFEventAPIINVOKERONBOARDED)
 122
 123         uri := ctx.Request().Host + ctx.Request().URL.String()
 124         ctx.Response().Header().Set(echo.HeaderLocation, ctx.Scheme()+`://`+path.Join(uri, *newInvoker.ApiInvokerId))
 125         err := ctx.JSON(http.StatusCreated, newInvoker)
 126         if err != nil {
 127                 // Something really bad happened, tell Echo that our handler failed
 128                 return err
 129         }
 130
 131         return nil
 132 }
 133
 134 func (im *InvokerManager) isInvokerOnboarded(newInvoker invokerapi.APIInvokerEnrolmentDetails) bool {
 135         for _, invoker := range im.onboardedInvokers {
 136                 if newInvoker.OnboardingInformation.ApiInvokerPublicKey == invoker.OnboardingInformation.ApiInvokerPublicKey {
 137                         return true
 138                 }
 139         }
 140         return false
 141 }
 142
 143 func (im *InvokerManager) prepareNewInvoker(newInvoker *invokerapi.APIInvokerEnrolmentDetails) {
 144         var apiList invokerapi.APIList = im.publishRegister.GetAllPublishedServices()
 145         newInvoker.ApiList = &apiList
 146
 147         im.lock.Lock()
 148         defer im.lock.Unlock()
 149
 150         newInvoker.PrepareNewInvoker()
 151
 152         im.onboardedInvokers[*newInvoker.ApiInvokerId] = *newInvoker
 153 }
 154
 155 // Deletes an individual API Invoker.
 156 func (im *InvokerManager) DeleteOnboardedInvokersOnboardingId(ctx echo.Context, onboardingId string) error {
 157         if _, ok := im.onboardedInvokers[onboardingId]; ok {
 158                 im.deleteInvoker(onboardingId)
 159         }
 160
 161         go im.sendEvent(onboardingId, eventsapi.CAPIFEventAPIINVOKEROFFBOARDED)
 162
 163         return ctx.NoContent(http.StatusNoContent)
 164 }
 165
 166 func (im *InvokerManager) deleteInvoker(onboardingId string) {
 167         im.lock.Lock()
 168         defer im.lock.Unlock()
 169         delete(im.onboardedInvokers, onboardingId)
 170 }
 171
 172 // Updates an individual API invoker details.
 173 func (im *InvokerManager) PutOnboardedInvokersOnboardingId(ctx echo.Context, onboardingId string) error {
 174         var invoker invokerapi.APIInvokerEnrolmentDetails
 175         errMsg := "Unable to update invoker due to %s"
 176         if err := ctx.Bind(&invoker); err != nil {
 177                 return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, "invalid format for invoker"))
 178         }
 179
 180         if onboardingId != *invoker.ApiInvokerId {
 181                 return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, "ApiInvokerId not matching"))
 182         }
 183
 184         if err := im.validateInvoker(invoker, ctx); err != nil {
 185                 return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
 186         }
 187
 188         if _, ok := im.onboardedInvokers[onboardingId]; ok {
 189                 im.updateInvoker(invoker)
 190         } else {
 191                 return sendCoreError(ctx, http.StatusNotFound, "The invoker to update has not been onboarded")
 192         }
 193
 194         err := ctx.JSON(http.StatusOK, invoker)
 195         if err != nil {
 196                 // Something really bad happened, tell Echo that our handler failed
 197                 return err
 198         }
 199
 200         return nil
 201 }
 202
 203 func (im *InvokerManager) updateInvoker(invoker invokerapi.APIInvokerEnrolmentDetails) {
 204         im.lock.Lock()
 205         defer im.lock.Unlock()
 206         im.onboardedInvokers[*invoker.ApiInvokerId] = invoker
 207 }
 208
 209 func (im *InvokerManager) ModifyIndApiInvokeEnrolment(ctx echo.Context, onboardingId string) error {
 210         return ctx.NoContent(http.StatusNotImplemented)
 211 }
 212
 213 func (im *InvokerManager) validateInvoker(invoker invokerapi.APIInvokerEnrolmentDetails, ctx echo.Context) error {
 214         if err := invoker.Validate(); err != nil {
 215                 return err
 216         }
 217         if !im.areAPIsPublished(invoker.ApiList) {
 218                 return errors.New("some APIs needed by invoker are not registered")
 219         }
 220
 221         return nil
 222 }
 223
 224 func (im *InvokerManager) areAPIsPublished(apis *invokerapi.APIList) bool {
 225         if apis == nil {
 226                 return true
 227         }
 228         return im.publishRegister.AreAPIsPublished((*[]publishapi.ServiceAPIDescription)(apis))
 229 }
 230
 231 func (im *InvokerManager) sendEvent(invokerId string, eventType eventsapi.CAPIFEvent) {
 232         invokerIds := []string{invokerId}
 233         event := eventsapi.EventNotification{
 234                 EventDetail: &eventsapi.CAPIFEventDetail{
 235                         ApiInvokerIds: &invokerIds,
 236                 },
 237                 Events: eventType,
 238         }
 239         im.eventChannel <- event
 240 }
 241
 242 // This function wraps sending of an error in the Error format, and
 243 // handling the failure to marshal that.
 244 func sendCoreError(ctx echo.Context, code int, message string) error {
 245         pd := common29122.ProblemDetails{
 246                 Cause:  &message,
 247                 Status: &code,
 248         }
 249         err := ctx.JSON(code, pd)
 250         return err
 251 }