//go:generate mockery --name PublishRegister
type PublishRegister interface {
- // Checks if the provided APIs are published.
- // Returns true if all provided APIs have been published, false otherwise.
- AreAPIsPublished(serviceDescriptions *[]publishapi.ServiceAPIDescription) bool
// Checks if the provided API is published.
// Returns true if the provided API has been published, false otherwise.
IsAPIPublished(aefId, path string) bool
}
}
-func (ps *PublishService) AreAPIsPublished(serviceDescriptions *[]publishapi.ServiceAPIDescription) bool {
-
- if serviceDescriptions != nil {
- registeredApis := ps.getAllAefIds()
- return checkNewDescriptions(*serviceDescriptions, registeredApis)
- }
- return true
-}
-
func (ps *PublishService) getAllAefIds() []string {
ps.lock.Lock()
defer ps.lock.Unlock()
allIds := []string{}
for _, descriptions := range ps.publishedServices {
for _, description := range descriptions {
- allIds = append(allIds, getIdsFromDescription(description)...)
- }
- }
- return allIds
-}
-
-func getIdsFromDescription(description publishapi.ServiceAPIDescription) []string {
- allIds := []string{}
- if description.AefProfiles != nil {
- for _, aefProfile := range *description.AefProfiles {
- allIds = append(allIds, aefProfile.AefId)
+ allIds = append(allIds, description.GetAefIds()...)
}
}
return allIds
}
-func checkNewDescriptions(newDescriptions []publishapi.ServiceAPIDescription, registeredAefIds []string) bool {
- registered := true
- for _, newApi := range newDescriptions {
- if !checkProfiles(newApi.AefProfiles, registeredAefIds) {
- registered = false
- break
- }
- }
- return registered
-}
-
-func checkProfiles(newProfiles *[]publishapi.AefProfile, registeredAefIds []string) bool {
- allRegistered := true
- if newProfiles != nil {
- for _, profile := range *newProfiles {
- if !slices.Contains(registeredAefIds, profile.AefId) {
- allRegistered = false
- break
- }
- }
- }
- return allRegistered
-}
-
func (ps *PublishService) IsAPIPublished(aefId, path string) bool {
return slices.Contains(ps.getAllAefIds(), aefId)
}
// Publish a new API.
func (ps *PublishService) PostApfIdServiceApis(ctx echo.Context, apfId string) error {
var newServiceAPIDescription publishapi.ServiceAPIDescription
+ errorMsg := "Unable to publish the service due to %s "
err := ctx.Bind(&newServiceAPIDescription)
if err != nil {
- return sendCoreError(ctx, http.StatusBadRequest, "Invalid format for service "+apfId)
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errorMsg, "invalid format for service "+apfId))
+ }
+
+ if err := ps.isServicePublished(newServiceAPIDescription); err != nil {
+ return sendCoreError(ctx, http.StatusForbidden, fmt.Sprintf(errorMsg, err))
}
+ if err := newServiceAPIDescription.Validate(); err != nil {
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errorMsg, err))
+ }
ps.lock.Lock()
defer ps.lock.Unlock()
registeredFuncs := ps.serviceRegister.GetAefsForPublisher(apfId)
for _, profile := range *newServiceAPIDescription.AefProfiles {
if !slices.Contains(registeredFuncs, profile.AefId) {
- return sendCoreError(ctx, http.StatusNotFound, fmt.Sprintf("Function %s not registered", profile.AefId))
+ return sendCoreError(ctx, http.StatusNotFound, fmt.Sprintf(errorMsg, fmt.Sprintf("function %s not registered", profile.AefId)))
}
}
- newId := "api_id_" + newServiceAPIDescription.ApiName
- newServiceAPIDescription.ApiId = &newId
+ newServiceAPIDescription.PrepareNewService()
shouldReturn, returnValue := ps.installHelmChart(newServiceAPIDescription, ctx)
if shouldReturn {
return nil
}
+func (ps *PublishService) isServicePublished(newService publishapi.ServiceAPIDescription) error {
+ for _, services := range ps.publishedServices {
+ for _, service := range services {
+ if err := service.ValidateAlreadyPublished(newService); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
func (ps *PublishService) installHelmChart(newServiceAPIDescription publishapi.ServiceAPIDescription, ctx echo.Context) (bool, error) {
info := strings.Split(*newServiceAPIDescription.Description, ",")
if len(info) == 5 {
log.Debug("Deleted service: ", serviceApiId)
}
ps.lock.Lock()
- defer ps.lock.Unlock()
ps.publishedServices[string(apfId)] = removeServiceDescription(pos, serviceDescriptions)
+ ps.lock.Unlock()
go ps.sendEvent(*description, eventsapi.CAPIFEventSERVICEAPIUNAVAILABLE)
}
}
// Retrieve a published service API.
func (ps *PublishService) GetApfIdServiceApisServiceApiId(ctx echo.Context, apfId string, serviceApiId string) error {
ps.lock.Lock()
- defer ps.lock.Unlock()
-
serviceDescriptions, ok := ps.publishedServices[apfId]
+ ps.lock.Unlock()
+
if ok {
_, serviceDescription := getServiceDescription(serviceApiId, serviceDescriptions)
if serviceDescription == nil {
// Update a published service API.
func (ps *PublishService) PutApfIdServiceApisServiceApiId(ctx echo.Context, apfId string, serviceApiId string) error {
- pos, publishedService, shouldReturn, returnValue := ps.checkIfServiceIsPublished(apfId, serviceApiId, ctx)
- if shouldReturn {
- return returnValue
- }
-
- updatedServiceDescription, shouldReturn, returnValue := getServiceFromRequest(ctx)
- if shouldReturn {
- return returnValue
+ ps.lock.Lock()
+ defer ps.lock.Unlock()
+ errMsg := "Unable to update service due to %s."
+ pos, publishedService, err := ps.checkIfServiceIsPublished(apfId, serviceApiId, ctx)
+ if err != nil {
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
-
- if updatedServiceDescription.Description != nil {
- ps.lock.Lock()
- defer ps.lock.Unlock()
-
- publishedService.Description = updatedServiceDescription.Description
- ps.publishedServices[apfId][pos] = publishedService
- go ps.sendEvent(publishedService, eventsapi.CAPIFEventSERVICEAPIUPDATE)
+ updatedServiceDescription, err := getServiceFromRequest(ctx)
+ if err != nil {
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
-
- pos, shouldReturn, returnValue = ps.updateProfiles(pos, apfId, updatedServiceDescription, publishedService, ctx)
- if shouldReturn {
- return returnValue
+ err = ps.checkProfilesRegistered(apfId, *updatedServiceDescription.AefProfiles)
+ if err != nil {
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
-
- err := ctx.JSON(http.StatusOK, ps.publishedServices[apfId][pos])
+ ps.updateDescription(pos, apfId, &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 err
}
return nil
}
-
-func (ps *PublishService) checkIfServiceIsPublished(apfId string, serviceApiId string, ctx echo.Context) (int, publishapi.ServiceAPIDescription, bool, error) {
+func (ps *PublishService) checkIfServiceIsPublished(apfId string, serviceApiId string, ctx echo.Context) (int, publishapi.ServiceAPIDescription, error) {
publishedServices, ok := ps.publishedServices[apfId]
if !ok {
- return 0, publishapi.ServiceAPIDescription{}, true, sendCoreError(ctx, http.StatusBadRequest, "Service must be published before updating it")
+ return 0, publishapi.ServiceAPIDescription{}, fmt.Errorf("service must be published before updating it")
} else {
for pos, description := range publishedServices {
if *description.ApiId == serviceApiId {
- return pos, description, false, nil
-
+ return pos, description, nil
}
-
}
-
}
- return 0, publishapi.ServiceAPIDescription{}, true, sendCoreError(ctx, http.StatusBadRequest, "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, bool, error) {
+func getServiceFromRequest(ctx echo.Context) (publishapi.ServiceAPIDescription, error) {
var updatedServiceDescription publishapi.ServiceAPIDescription
err := ctx.Bind(&updatedServiceDescription)
if err != nil {
- return publishapi.ServiceAPIDescription{}, true, sendCoreError(ctx, http.StatusBadRequest, "Invalid format for service")
+ return publishapi.ServiceAPIDescription{}, fmt.Errorf("invalid format for service")
}
- return updatedServiceDescription, false, nil
+ return updatedServiceDescription, nil
}
-
-func (ps *PublishService) updateProfiles(pos int, apfId string, updatedServiceDescription publishapi.ServiceAPIDescription, publishedService publishapi.ServiceAPIDescription, ctx echo.Context) (int, bool, error) {
- registeredFuncs := ps.serviceRegister.GetAefsForPublisher(apfId)
- for _, profile := range *updatedServiceDescription.AefProfiles {
- if !slices.Contains(registeredFuncs, profile.AefId) {
- return 0, false, sendCoreError(ctx, http.StatusNotFound, fmt.Sprintf("Function %s not registered", profile.AefId))
- }
- if ps.checkIfProfileIsNew(profile.AefId, *publishedService.AefProfiles) {
-
- publishedService.AefProfiles = ps.addProfile(profile, publishedService)
- ps.publishedServices[apfId][pos] = publishedService
-
- } else {
- pos, shouldReturn, returnValue := ps.updateProfile(profile, publishedService, ctx)
- if shouldReturn {
- return pos, true, returnValue
- }
- }
-
+func (ps *PublishService) updateDescription(pos int, apfId string, updatedServiceDescription, publishedService *publishapi.ServiceAPIDescription) {
+ if updatedServiceDescription.Description != nil {
+ publishedService.Description = updatedServiceDescription.Description
+ go ps.sendEvent(*publishedService, eventsapi.CAPIFEventSERVICEAPIUPDATE)
}
- return 0, false, nil
}
func (ps *PublishService) sendEvent(service publishapi.ServiceAPIDescription, eventType eventsapi.CAPIFEvent) {
ps.eventChannel <- event
}
-func (ps *PublishService) checkIfProfileIsNew(aefId string, publishedPofiles []publishapi.AefProfile) bool {
- for _, profile := range publishedPofiles {
- if profile.AefId == aefId {
- return false
- }
- }
- return true
-}
-func (ps *PublishService) addProfile(profile publishapi.AefProfile, publishedService publishapi.ServiceAPIDescription) *[]publishapi.AefProfile {
- registeredProfiles := *publishedService.AefProfiles
- newProfiles := append(registeredProfiles, profile)
- publishedService.AefProfiles = &newProfiles
- return &newProfiles
-
-}
-
-func (*PublishService) updateProfile(profile publishapi.AefProfile, publishedService publishapi.ServiceAPIDescription, ctx echo.Context) (int, bool, error) {
- pos, registeredProfile, err := getProfile(profile.AefId, publishedService.AefProfiles)
- if err != nil {
- return pos, true, sendCoreError(ctx, http.StatusBadRequest, "Unable to update service due to: "+err.Error())
- }
- if profile.DomainName != nil {
- registeredProfile.DomainName = profile.DomainName
- (*publishedService.AefProfiles)[pos] = registeredProfile
- }
- return -1, false, nil
-}
-
-func getProfile(profileId string, apiProfiles *[]publishapi.AefProfile) (int, publishapi.AefProfile, error) {
- for pos, profile := range *apiProfiles {
- if profile.AefId == profileId {
- return pos, profile, nil
+func (ps *PublishService) checkProfilesRegistered(apfId string, updatedProfiles []publishapi.AefProfile) error {
+ registeredFuncs := ps.serviceRegister.GetAefsForPublisher(apfId)
+ for _, profile := range updatedProfiles {
+ if !slices.Contains(registeredFuncs, profile.AefId) {
+ return fmt.Errorf("function %s not registered", profile.AefId)
}
}
- return 0, publishapi.AefProfile{}, fmt.Errorf("profile with ID %s is not registered for the service", profileId)
+ return nil
}
// This function wraps sending of an error in the Error format, and
Code Review / nonrtric / plt / sme.git / blobdiff