//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 ps.isServicePublished(newServiceAPIDescription) {
+ return sendCoreError(ctx, http.StatusForbidden, fmt.Sprintf(errorMsg, "service already published"))
}
+ 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) bool {
+ for _, services := range ps.publishedServices {
+ for _, service := range services {
+ if service.IsPublished(newService) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
func (ps *PublishService) installHelmChart(newServiceAPIDescription publishapi.ServiceAPIDescription, ctx echo.Context) (bool, error) {
info := strings.Split(*newServiceAPIDescription.Description, ",")
if len(info) == 5 {
if err != nil {
return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
- ps.updateDescription(pos, apfId, &updatedServiceDescription, &publishedService)
- pos, publishedService.AefProfiles, err = ps.updateProfiles(pos, apfId, updatedServiceDescription.AefProfiles, publishedService.AefProfiles)
+ err = ps.checkProfilesRegistered(apfId, *updatedServiceDescription.AefProfiles)
if err != nil {
return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
+ ps.updateDescription(pos, apfId, &updatedServiceDescription, &publishedService)
+ publishedService.AefProfiles = updatedServiceDescription.AefProfiles
ps.publishedServices[apfId][pos] = publishedService
err = ctx.JSON(http.StatusOK, publishedService)
if err != nil {
ps.eventChannel <- event
}
-func (ps *PublishService) updateProfiles(pos int, apfId string, updatedServiceDescription *[]publishapi.AefProfile, publishedService *[]publishapi.AefProfile) (int, *[]publishapi.AefProfile, error) {
+func (ps *PublishService) checkProfilesRegistered(apfId string, updatedProfiles []publishapi.AefProfile) error {
registeredFuncs := ps.serviceRegister.GetAefsForPublisher(apfId)
- addedProfiles := []publishapi.AefProfile{}
- changedProfiles := []publishapi.AefProfile{}
- for _, profile := range *updatedServiceDescription {
+ for _, profile := range updatedProfiles {
if !slices.Contains(registeredFuncs, profile.AefId) {
- return 0, nil, fmt.Errorf("function %s not registered", profile.AefId)
- }
- for _, publishedProfile := range *publishedService {
- if publishedProfile.AefId != profile.AefId {
- registeredProfiles := *publishedService
- newProfiles := append(registeredProfiles, profile)
- publishedService = &newProfiles
- addedProfiles = append(addedProfiles, profile)
- } else {
- pos, registeredProfile, err := getProfile(profile.AefId, publishedService)
- if err != nil {
- return pos, updatedServiceDescription, fmt.Errorf("unable to update service due to: %s", err.Error())
- }
- if profile.DomainName != nil {
- registeredProfile.DomainName = profile.DomainName
- (*publishedService)[pos] = registeredProfile
- }
- changedProfiles = append(changedProfiles, profile)
- }
+ return fmt.Errorf("function %s not registered", profile.AefId)
}
}
- modifiedProfiles := append(changedProfiles, addedProfiles...)
- return 0, &modifiedProfiles, 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
- }
- }
- 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