"k8s.io/utils/strings/slices"
"oransc.org/nonrtric/capifcore/internal/common29122"
- "oransc.org/nonrtric/capifcore/internal/publishserviceapi"
+ "oransc.org/nonrtric/capifcore/internal/eventsapi"
+ publishapi "oransc.org/nonrtric/capifcore/internal/publishserviceapi"
"oransc.org/nonrtric/capifcore/internal/helmmanagement"
"oransc.org/nonrtric/capifcore/internal/providermanagement"
//go:generate mockery --name PublishRegister
type PublishRegister interface {
- AreAPIsPublished(serviceDescriptions *[]publishserviceapi.ServiceAPIDescription) bool
+ // 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
+ // Gets all published APIs.
+ // Returns a list of all APIs that has been published.
+ GetAllPublishedServices() []publishapi.ServiceAPIDescription
}
type PublishService struct {
- publishedServices map[string][]*publishserviceapi.ServiceAPIDescription
+ publishedServices map[string][]publishapi.ServiceAPIDescription
serviceRegister providermanagement.ServiceRegister
helmManager helmmanagement.HelmManager
+ eventChannel chan<- eventsapi.EventNotification
lock sync.Mutex
}
-func NewPublishService(serviceRegister providermanagement.ServiceRegister, hm helmmanagement.HelmManager) *PublishService {
+// Creates a service that implements both the PublishRegister and the publishserviceapi.ServerInterface interfaces.
+func NewPublishService(serviceRegister providermanagement.ServiceRegister, hm helmmanagement.HelmManager, eventChannel chan<- eventsapi.EventNotification) *PublishService {
return &PublishService{
helmManager: hm,
- publishedServices: make(map[string][]*publishserviceapi.ServiceAPIDescription),
+ publishedServices: make(map[string][]publishapi.ServiceAPIDescription),
serviceRegister: serviceRegister,
+ eventChannel: eventChannel,
}
}
-func (ps *PublishService) AreAPIsPublished(serviceDescriptions *[]publishserviceapi.ServiceAPIDescription) bool {
+func (ps *PublishService) AreAPIsPublished(serviceDescriptions *[]publishapi.ServiceAPIDescription) bool {
if serviceDescriptions != nil {
registeredApis := ps.getAllAefIds()
allIds := []string{}
for _, descriptions := range ps.publishedServices {
for _, description := range descriptions {
- allIds = append(allIds, getIdsFromDescription(*description)...)
+ allIds = append(allIds, getIdsFromDescription(description)...)
}
}
return allIds
}
-func getIdsFromDescription(description publishserviceapi.ServiceAPIDescription) []string {
+func getIdsFromDescription(description publishapi.ServiceAPIDescription) []string {
allIds := []string{}
if description.AefProfiles != nil {
for _, aefProfile := range *description.AefProfiles {
return allIds
}
-func checkNewDescriptions(newDescriptions []publishserviceapi.ServiceAPIDescription, registeredAefIds []string) bool {
+func checkNewDescriptions(newDescriptions []publishapi.ServiceAPIDescription, registeredAefIds []string) bool {
registered := true
for _, newApi := range newDescriptions {
if !checkProfiles(newApi.AefProfiles, registeredAefIds) {
return registered
}
-func checkProfiles(newProfiles *[]publishserviceapi.AefProfile, registeredAefIds []string) bool {
+func checkProfiles(newProfiles *[]publishapi.AefProfile, registeredAefIds []string) bool {
allRegistered := true
if newProfiles != nil {
for _, profile := range *newProfiles {
return slices.Contains(ps.getAllAefIds(), aefId)
}
+func (ps *PublishService) GetAllPublishedServices() []publishapi.ServiceAPIDescription {
+ publishedDescriptions := []publishapi.ServiceAPIDescription{}
+ for _, descriptions := range ps.publishedServices {
+ publishedDescriptions = append(publishedDescriptions, descriptions...)
+ }
+ return publishedDescriptions
+}
+
+// Retrieve all published APIs.
func (ps *PublishService) GetApfIdServiceApis(ctx echo.Context, apfId string) error {
serviceDescriptions, ok := ps.publishedServices[apfId]
if ok {
return nil
}
+// Publish a new API.
func (ps *PublishService) PostApfIdServiceApis(ctx echo.Context, apfId string) error {
- var newServiceAPIDescription publishserviceapi.ServiceAPIDescription
+ var newServiceAPIDescription publishapi.ServiceAPIDescription
err := ctx.Bind(&newServiceAPIDescription)
if err != nil {
return sendCoreError(ctx, http.StatusBadRequest, "Invalid format for service "+apfId)
if shouldReturn {
return returnValue
}
+ go ps.sendEvent(newServiceAPIDescription, eventsapi.CAPIFEventSERVICEAPIAVAILABLE)
_, ok := ps.publishedServices[apfId]
if ok {
- ps.publishedServices[apfId] = append(ps.publishedServices[apfId], &newServiceAPIDescription)
+ ps.publishedServices[apfId] = append(ps.publishedServices[apfId], newServiceAPIDescription)
} else {
- ps.publishedServices[apfId] = append([]*publishserviceapi.ServiceAPIDescription{}, &newServiceAPIDescription)
+ ps.publishedServices[apfId] = append([]publishapi.ServiceAPIDescription{}, newServiceAPIDescription)
}
uri := ctx.Request().Host + ctx.Request().URL.String()
return nil
}
-func (ps *PublishService) installHelmChart(newServiceAPIDescription publishserviceapi.ServiceAPIDescription, ctx echo.Context) (bool, error) {
+func (ps *PublishService) installHelmChart(newServiceAPIDescription publishapi.ServiceAPIDescription, ctx echo.Context) (bool, error) {
info := strings.Split(*newServiceAPIDescription.Description, ",")
if len(info) == 5 {
err := ps.helmManager.InstallHelmChart(info[1], info[2], info[3], info[4])
return false, nil
}
+// Unpublish a published service API.
func (ps *PublishService) DeleteApfIdServiceApisServiceApiId(ctx echo.Context, apfId string, serviceApiId string) error {
serviceDescriptions, ok := ps.publishedServices[string(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 {
return ctx.NoContent(http.StatusNotFound)
}
-func getServiceDescription(serviceApiId string, descriptions []*publishserviceapi.ServiceAPIDescription) (int, *publishserviceapi.ServiceAPIDescription) {
+func getServiceDescription(serviceApiId string, descriptions []publishapi.ServiceAPIDescription) (int, *publishapi.ServiceAPIDescription) {
for pos, description := range descriptions {
if serviceApiId == *description.ApiId {
- return pos, description
+ return pos, &description
}
}
return -1, nil
}
-func removeServiceDescription(i int, a []*publishserviceapi.ServiceAPIDescription) []*publishserviceapi.ServiceAPIDescription {
- a[i] = a[len(a)-1] // Copy last element to index i.
- a[len(a)-1] = nil // Erase last element (write zero value).
- a = a[:len(a)-1] // Truncate slice.
+func removeServiceDescription(i int, a []publishapi.ServiceAPIDescription) []publishapi.ServiceAPIDescription {
+ a[i] = a[len(a)-1] // Copy last element to index i.
+ a[len(a)-1] = publishapi.ServiceAPIDescription{} // Erase last element (write zero value).
+ a = a[:len(a)-1] // Truncate slice.
return a
}
+// Modify an existing published service API.
func (ps *PublishService) ModifyIndAPFPubAPI(ctx echo.Context, apfId string, serviceApiId string) error {
return ctx.NoContent(http.StatusNotImplemented)
}
+// Update a published service API.
func (ps *PublishService) PutApfIdServiceApisServiceApiId(ctx echo.Context, apfId string, serviceApiId string) error {
- return ctx.NoContent(http.StatusNotImplemented)
+ 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))
+ }
+ updatedServiceDescription, err := getServiceFromRequest(ctx)
+ if err != nil {
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
+ }
+ ps.updateDescription(pos, apfId, &updatedServiceDescription, &publishedService)
+ err = ps.checkProfilesRegistered(apfId, *updatedServiceDescription.AefProfiles)
+ if err != nil {
+ return sendCoreError(ctx, http.StatusBadRequest, fmt.Sprintf(errMsg, err))
+ }
+ 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, error) {
+ publishedServices, ok := ps.publishedServices[apfId]
+ if !ok {
+ 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, nil
+ }
+ }
+ }
+ 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)
+ if err != nil {
+ 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 nil
+
}
// This function wraps sending of an error in the Error format, and