// ========================LICENSE_START=================================
// O-RAN-SC
// %%
-// Copyright (C) 2022: Nordix Foundation
+// Copyright (C) 2022-2023: Nordix Foundation
+// Copyright (C) 2024: OpenInfra Foundation Europe
// %%
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
"strings"
"sync"
- "github.com/labstack/echo/v4"
+ echo "github.com/labstack/echo/v4"
"k8s.io/utils/strings/slices"
"oransc.org/nonrtric/capifcore/internal/common29122"
// Gets all published APIs.
// Returns a list of all APIs that has been published.
GetAllPublishedServices() []publishapi.ServiceAPIDescription
+ GetAllowedPublishedServices(invokerApiList []publishapi.ServiceAPIDescription) []publishapi.ServiceAPIDescription
}
type PublishService struct {
return publishedDescriptions
}
+func (ps *PublishService) GetAllowedPublishedServices(apiListRequestedServices []publishapi.ServiceAPIDescription) []publishapi.ServiceAPIDescription {
+ apiListAllPublished := ps.GetAllPublishedServices()
+ allowedPublishedServices := join(apiListAllPublished, apiListRequestedServices)
+ return allowedPublishedServices
+}
+
+func join(a, b []publishapi.ServiceAPIDescription) []publishapi.ServiceAPIDescription {
+ var result []publishapi.ServiceAPIDescription
+
+ if (a == nil) || (b == nil) || (len(a) == 0) || (len(b) == 0) {
+ return result
+ }
+
+ for _, itemA := range a {
+ for _, itemB := range b {
+ if itemA.ApiName == itemB.ApiName {
+ result = append(result, itemA)
+ break
+ }
+ }
+ }
+ return result
+}
+
// Retrieve all published APIs.
func (ps *PublishService) GetApfIdServiceApis(ctx echo.Context, apfId string) error {
- serviceDescriptions, ok := ps.publishedServices[apfId]
- if ok {
- err := ctx.JSON(http.StatusOK, serviceDescriptions)
- if err != nil {
- // Something really bad happened, tell Echo that our handler failed
- return err
- }
- } else {
- return sendCoreError(ctx, http.StatusNotFound, fmt.Sprintf("Provider %s not registered", apfId))
+ if !ps.serviceRegister.IsPublishingFunctionRegistered(apfId) {
+ errorMsg := fmt.Sprintf("Unable to get the service due to %s api is only available for publishers", apfId)
+ return sendCoreError(ctx, http.StatusNotFound, errorMsg)
}
+ serviceDescriptions := ps.publishedServices[apfId]
+ err := ctx.JSON(http.StatusOK, serviceDescriptions)
+ if err != nil {
+ // Something really bad happened, tell Echo that our handler failed
+ return err
+ }
return nil
}
return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errorMsg, "invalid format for service "+apfId))
}
- if ps.isServicePublished(newServiceAPIDescription) {
- return sendCoreError(ctx, http.StatusForbidden, fmt.Sprintf(errorMsg, "service already published"))
+ if !ps.serviceRegister.IsPublishingFunctionRegistered(apfId) {
+ return sendCoreError(ctx, http.StatusForbidden, fmt.Sprintf(errorMsg, "api is only available for publishers "+apfId))
+ }
+
+ if err := ps.isServicePublished(newServiceAPIDescription); err != nil {
+ return sendCoreError(ctx, http.StatusForbidden, fmt.Sprintf(errorMsg, err))
}
if err := newServiceAPIDescription.Validate(); err != nil {
return nil
}
-func (ps *PublishService) isServicePublished(newService publishapi.ServiceAPIDescription) bool {
+func (ps *PublishService) isServicePublished(newService publishapi.ServiceAPIDescription) error {
for _, services := range ps.publishedServices {
for _, service := range services {
- if service.IsPublished(newService) {
- return true
+ if err := service.ValidateAlreadyPublished(newService); err != nil {
+ return err
}
}
}
- return false
+ return nil
}
func (ps *PublishService) installHelmChart(newServiceAPIDescription publishapi.ServiceAPIDescription, ctx echo.Context) (bool, error) {
info := strings.Split(*newServiceAPIDescription.Description, ",")
- if len(info) == 5 {
+ if (len(info) == 5) && (ps.helmManager != nil) {
err := ps.helmManager.InstallHelmChart(info[1], info[2], info[3], info[4])
if err != nil {
return true, sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf("Unable to install Helm chart %s due to: %s", info[3], err.Error()))
pos, description := getServiceDescription(serviceApiId, serviceDescriptions)
if description != nil {
info := strings.Split(*description.Description, ",")
- if len(info) == 5 {
+ if (len(info) == 5) && (ps.helmManager != nil) {
ps.helmManager.UninstallHelmChart(info[1], info[3])
log.Debug("Deleted service: ", serviceApiId)
}
func getServiceDescription(serviceApiId string, descriptions []publishapi.ServiceAPIDescription) (int, *publishapi.ServiceAPIDescription) {
for pos, description := range descriptions {
- if serviceApiId == *description.ApiId {
+ // Check for nil as we had a failure here when running unit tests in parallel against a single Capifcore instance
+ if (description.ApiId != nil) && (serviceApiId == *description.ApiId) {
return pos, &description
}
}
ps.lock.Lock()
defer ps.lock.Unlock()
errMsg := "Unable to update service due to %s."
- pos, publishedService, err := ps.checkIfServiceIsPublished(apfId, serviceApiId, ctx)
+
+ pos, publishedService, err := ps.checkIfServiceIsPublished(apfId, serviceApiId)
if err != nil {
return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
+
updatedServiceDescription, err := getServiceFromRequest(ctx)
if err != nil {
return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
+
+ // Additional validation for PUT
+ if (updatedServiceDescription.ApiId == nil) || (*updatedServiceDescription.ApiId != serviceApiId) {
+ errDetail := "ServiceAPIDescription ApiId doesn't match path parameter"
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, errDetail))
+ }
+
err = ps.checkProfilesRegistered(apfId, *updatedServiceDescription.AefProfiles)
if err != nil {
return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
- ps.updateDescription(pos, apfId, &updatedServiceDescription, &publishedService)
+
+ ps.updateDescription(&updatedServiceDescription, &publishedService)
+
publishedService.AefProfiles = updatedServiceDescription.AefProfiles
ps.publishedServices[apfId][pos] = publishedService
+
err = ctx.JSON(http.StatusOK, publishedService)
if err != nil {
// Something really bad happened, tell Echo that our handler failed
}
return nil
}
-func (ps *PublishService) checkIfServiceIsPublished(apfId string, serviceApiId string, ctx echo.Context) (int, publishapi.ServiceAPIDescription, error) {
+
+func (ps *PublishService) checkIfServiceIsPublished(apfId string, serviceApiId string) (int, publishapi.ServiceAPIDescription, error) {
publishedServices, ok := ps.publishedServices[apfId]
if !ok {
return 0, publishapi.ServiceAPIDescription{}, fmt.Errorf("service must be published before updating it")
}
return 0, publishapi.ServiceAPIDescription{}, fmt.Errorf("service must be published before updating it")
}
+
func getServiceFromRequest(ctx echo.Context) (publishapi.ServiceAPIDescription, error) {
var updatedServiceDescription publishapi.ServiceAPIDescription
err := ctx.Bind(&updatedServiceDescription)
}
return updatedServiceDescription, nil
}
-func (ps *PublishService) updateDescription(pos int, apfId string, updatedServiceDescription, publishedService *publishapi.ServiceAPIDescription) {
+
+func (ps *PublishService) updateDescription(updatedServiceDescription, publishedService *publishapi.ServiceAPIDescription) {
if updatedServiceDescription.Description != nil {
publishedService.Description = updatedServiceDescription.Description
go ps.sendEvent(*publishedService, eventsapi.CAPIFEventSERVICEAPIUPDATE)
Code Review / nonrtric / plt / sme.git / blobdiff