"k8s.io/utils/strings/slices"
"oransc.org/nonrtric/capifcore/internal/common29122"
+ "oransc.org/nonrtric/capifcore/internal/eventsapi"
publishapi "oransc.org/nonrtric/capifcore/internal/publishserviceapi"
"oransc.org/nonrtric/capifcore/internal/helmmanagement"
publishedServices map[string][]publishapi.ServiceAPIDescription
serviceRegister providermanagement.ServiceRegister
helmManager helmmanagement.HelmManager
+ eventChannel chan<- eventsapi.EventNotification
lock sync.Mutex
}
// Creates a service that implements both the PublishRegister and the publishserviceapi.ServerInterface interfaces.
-func NewPublishService(serviceRegister providermanagement.ServiceRegister, hm helmmanagement.HelmManager) *PublishService {
+func NewPublishService(serviceRegister providermanagement.ServiceRegister, hm helmmanagement.HelmManager, eventChannel chan<- eventsapi.EventNotification) *PublishService {
return &PublishService{
helmManager: hm,
publishedServices: make(map[string][]publishapi.ServiceAPIDescription),
serviceRegister: serviceRegister,
+ eventChannel: eventChannel,
}
}
if shouldReturn {
return returnValue
}
+ go ps.sendEvent(newServiceAPIDescription, eventsapi.CAPIFEventSERVICEAPIAVAILABLE)
_, ok := ps.publishedServices[apfId]
if ok {
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)
}
}
return ctx.NoContent(http.StatusNoContent)
// 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 {
func (ps *PublishService) PutApfIdServiceApisServiceApiId(ctx echo.Context, apfId string, serviceApiId string) error {
ps.lock.Lock()
defer ps.lock.Unlock()
-
- pos, publishedService, shouldReturn, returnValue := ps.checkIfServiceIsPublished(apfId, serviceApiId, ctx)
- if shouldReturn {
- return returnValue
+ 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))
}
-
- updatedServiceDescription, shouldReturn, returnValue := getServiceFromRequest(ctx)
- if shouldReturn {
- return returnValue
+ updatedServiceDescription, err := getServiceFromRequest(ctx)
+ if err != nil {
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
}
-
- if updatedServiceDescription.Description != nil {
- publishedService.Description = updatedServiceDescription.Description
- ps.publishedServices[apfId][pos] = publishedService
+ ps.updateDescription(pos, apfId, &updatedServiceDescription, &publishedService)
+ 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])
+ 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, nil
+}
+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)
+ }
+}
+
+func (ps *PublishService) sendEvent(service publishapi.ServiceAPIDescription, eventType eventsapi.CAPIFEvent) {
+ apiIds := []string{*service.ApiId}
+ apis := []publishapi.ServiceAPIDescription{service}
+ event := eventsapi.EventNotification{
+ EventDetail: &eventsapi.CAPIFEventDetail{
+ ApiIds: &apiIds,
+ ServiceAPIDescriptions: &apis,
+ },
+ Events: eventType,
+ }
+ ps.eventChannel <- event
+}
+
+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 updatedServiceDescription, false, nil
+ return nil
+
}
// This function wraps sending of an error in the Error format, and