// 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 {
- 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)
- }
+ ps.lock.Lock()
+ serviceDescriptions, ok := ps.publishedServices[apfId]
+ ps.lock.Unlock()
- 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
+ if ok {
+ err := ctx.JSON(http.StatusOK, serviceDescriptions)
+ if err != nil {
+ // Something really bad happened, tell Echo that our handler failed
+ return err
+ }
+ } else {
+ 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 = []publishapi.ServiceAPIDescription{}
+ err := ctx.JSON(http.StatusOK, serviceDescriptions)
+ if err != nil {
+ // Something really bad happened, tell Echo that our handler failed
+ 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 {
+ 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