diff --git a/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApi.java b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApi.java new file mode 100644 index 0000000000000000000000000000000000000000..b5595535132a027f88cc6c34e38b8d6f3a2350fe --- /dev/null +++ b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApi.java @@ -0,0 +1,49 @@ +package org.etsi.osl.tmf.metrics.api; + +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.responses.ApiResponse; +import io.swagger.v3.oas.annotations.responses.ApiResponses; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.validation.Valid; +import org.etsi.osl.tmf.common.model.service.ServiceStateType; +import org.etsi.osl.tmf.metrics.ServicesGroupByState; +import org.etsi.osl.tmf.metrics.TotalServices; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.format.annotation.DateTimeFormat; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RequestParam; + +import java.time.OffsetDateTime; +import java.util.Map; + +@Tag(name = "ServiceMetricsApi", description = "The Services' Metrics API") +public interface ServiceMetricsApi { + + Logger log = LoggerFactory.getLogger(ServiceMetricsApi.class); + + @Operation(summary = "Get total number of services", operationId = "getTotalServices") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "Success"), + @ApiResponse(responseCode = "400", description = "Bad Request"), + @ApiResponse(responseCode = "500", description = "Internal Server Error") + }) + @RequestMapping(value = "/metrics/totalServices", method = RequestMethod.GET, produces = "application/json;charset=utf-8") + ResponseEntity getTotalServices( + @Valid @RequestParam(value = "state", required = false) ServiceStateType state + ); + + @Operation(summary = "Get services grouped by state", operationId = "getServicesGroupedByState") + @ApiResponses(value = { + @ApiResponse(responseCode = "200", description = "Success"), + @ApiResponse(responseCode = "400", description = "Bad Request"), + @ApiResponse(responseCode = "500", description = "Internal Server Error") + }) + @RequestMapping(value = "/metrics/servicesGroupByState", method = RequestMethod.GET, produces = "application/json;charset=utf-8") + ResponseEntity getServicesGroupedByState( + @Valid @RequestParam(value = "starttime", required = true) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime starttime, + @Valid @RequestParam(value = "endtime", required = true) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime endtime + ); +} diff --git a/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApiController.java b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApiController.java new file mode 100644 index 0000000000000000000000000000000000000000..abe7575e19556a33442e830bdca100173f0d681a --- /dev/null +++ b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApiController.java @@ -0,0 +1,75 @@ +package org.etsi.osl.tmf.metrics.api; + +import org.etsi.osl.tmf.common.model.service.ServiceStateType; +import org.etsi.osl.tmf.metrics.*; +import org.etsi.osl.tmf.metrics.reposervices.ServiceMetricsRepoService; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.stereotype.Controller; + +import java.time.OffsetDateTime; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +@Controller +public class ServiceMetricsApiController implements ServiceMetricsApi { + + private static final Logger log = LoggerFactory.getLogger(ServiceMetricsApiController.class); + private final ServiceMetricsRepoService serviceMetricsRepoService; + + @Autowired + public ServiceMetricsApiController(ServiceMetricsRepoService serviceMetricsRepoService) { + this.serviceMetricsRepoService = serviceMetricsRepoService; + } + + @Override + public ResponseEntity getTotalServices(ServiceStateType state) { + try { + int totalServices = serviceMetricsRepoService.countTotalServices(state); + TotalServices response = new TotalServices(totalServices); + return new ResponseEntity<>(response, HttpStatus.OK); + } catch (Exception e) { + log.error("Couldn't retrieve total services. ", e); + return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR); + } + } + + @Override + public ResponseEntity getServicesGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) { + try { + Map servicesByState = serviceMetricsRepoService.getServicesGroupedByState(starttime, endtime); + + // Initialize with all possible states and 0. Ensures that all states are represented, even if not present in the data. + Map fullStateMap = new LinkedHashMap<>(); + for (ServiceStateType state : ServiceStateType.values()) { + fullStateMap.put(state.name(), 0); // default to 0 + } + + // Overwrite counts with actual data + servicesByState.forEach((key, value) -> { + fullStateMap.put(key.toUpperCase(), value); // normalize case just in case + }); + + // Create aggregation items + List groupByStateList = fullStateMap.entrySet().stream() + .map(entry -> new ServicesGroupByStateItem(ServiceStateType.valueOf(entry.getKey()), entry.getValue())) + .toList(); + + // Build response structure using metrics models + ServicesGroupByStateAggregations aggregations = new ServicesGroupByStateAggregations(groupByStateList); + int total = fullStateMap.values().stream().mapToInt(Integer::intValue).sum(); + Services services = new Services(total, aggregations); + ServicesGroupByState response = new ServicesGroupByState(services); + + return new ResponseEntity<>(response, HttpStatus.OK); + + } catch (Exception e) { + log.error("Couldn't retrieve services grouped by state. ", e); + return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR); + } + } +} diff --git a/src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceMetricsRepoService.java b/src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceMetricsRepoService.java new file mode 100644 index 0000000000000000000000000000000000000000..ef910dce296959d123368acaeccffb72fca095e8 --- /dev/null +++ b/src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceMetricsRepoService.java @@ -0,0 +1,45 @@ +package org.etsi.osl.tmf.metrics.reposervices; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.etsi.osl.tmf.common.model.service.ServiceStateType; +import org.etsi.osl.tmf.sim638.repo.ServiceRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.time.OffsetDateTime; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +@Service +public class ServiceMetricsRepoService { + + @Autowired + ObjectMapper objectMapper; + + @Autowired + ServiceRepository serviceRepo; + + public int countTotalServices(ServiceStateType state) { + if (state == null) { + return serviceRepo.countAll(); + } else { + return serviceRepo.countByState(state); + } + } + + public Map getServicesGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) { + if (starttime.plusDays(31).isBefore(endtime)) { + starttime = endtime.minusDays(31); + } + + List rawResults = serviceRepo.groupByStateBetweenDates(starttime, endtime); + + return rawResults.stream() + .collect(Collectors.toMap( + row -> row[0].toString(), + row -> ((Number) row[1]).intValue() + )); + } + +} diff --git a/src/main/java/org/etsi/osl/tmf/sim638/repo/ServiceRepository.java b/src/main/java/org/etsi/osl/tmf/sim638/repo/ServiceRepository.java index 8c920375ad11b35fcd9eb5ad794f3e029ad6f839..ee3d9c3b56894e9b87299d26465af958924dce54 100644 --- a/src/main/java/org/etsi/osl/tmf/sim638/repo/ServiceRepository.java +++ b/src/main/java/org/etsi/osl/tmf/sim638/repo/ServiceRepository.java @@ -19,8 +19,11 @@ */ package org.etsi.osl.tmf.sim638.repo; +import java.time.OffsetDateTime; import java.util.List; import java.util.Optional; + +import org.etsi.osl.tmf.common.model.service.ServiceStateType; import org.etsi.osl.tmf.sim638.model.Service; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; @@ -68,4 +71,15 @@ public interface ServiceRepository extends JpaRepository { + "WHERE sres.id = ?1 " ) List findServicesHavingThisSupportingResourceID(String resourceID); + // Methods for metrics + + @Query("SELECT COUNT(srv) FROM Service srv") + int countAll(); + + int countByState(ServiceStateType state); + + @Query("SELECT srv.state, COUNT(srv) FROM Service srv " + + "WHERE srv.startDate >= :starttime AND srv.endDate <= :endtime " + + "GROUP BY srv.state") + List groupByStateBetweenDates(OffsetDateTime starttime, OffsetDateTime endtime); } diff --git a/src/test/java/org/etsi/osl/services/api/metrics/ServiceMetricsApiControllerTest.java b/src/test/java/org/etsi/osl/services/api/metrics/ServiceMetricsApiControllerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..e7562ec4338ad9c501a888ba82f335553943110d --- /dev/null +++ b/src/test/java/org/etsi/osl/services/api/metrics/ServiceMetricsApiControllerTest.java @@ -0,0 +1,215 @@ +package org.etsi.osl.services.api.metrics; + +import com.jayway.jsonpath.JsonPath; +import org.apache.commons.io.IOUtils; +import org.etsi.osl.tmf.JsonUtils; +import org.etsi.osl.tmf.OpenAPISpringBoot; +import org.etsi.osl.tmf.common.model.Any; +import org.etsi.osl.tmf.common.model.service.*; +import org.etsi.osl.tmf.scm633.model.ServiceSpecification; +import org.etsi.osl.tmf.scm633.model.ServiceSpecificationCreate; +import org.etsi.osl.tmf.sim638.model.Service; +import org.etsi.osl.tmf.sim638.model.ServiceCreate; +import org.etsi.osl.tmf.sim638.service.ServiceRepoService; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.http.MediaType; +import org.springframework.security.test.context.support.WithMockUser; +import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.context.WebApplicationContext; + +import java.io.File; +import java.io.FileInputStream; +import java.io.InputStream; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@RunWith(SpringRunner.class) +@Transactional +@SpringBootTest( + webEnvironment = SpringBootTest.WebEnvironment.MOCK, + classes = OpenAPISpringBoot.class +) +//@AutoConfigureTestDatabase //this automatically uses h2 +@AutoConfigureMockMvc +@ActiveProfiles("testing") +//@TestPropertySource( +// locations = "classpath:application-testing.yml") +public class ServiceMetricsApiControllerTest { + + @Autowired + private MockMvc mvc; + + @Autowired + ServiceRepoService serviceRepoService; + + @Autowired + private WebApplicationContext context; + + @Before + public void setup() throws Exception { + mvc = MockMvcBuilders + .webAppContextSetup(context) + .apply(springSecurity()) + .build(); + } + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testCountTotalServices() throws Exception { + createService(ServiceStateType.ACTIVE); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/totalServices" ) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk() ) + .andReturn().getResponse().getContentAsString(); + + int totalServices = JsonPath.read(response, "$.totalServices"); + + + assertThat(totalServices).isEqualTo(serviceRepoService.findAll().size()); + } + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testCountTotalServicesWithState() throws Exception { + createService(ServiceStateType.ACTIVE); + createService(ServiceStateType.INACTIVE); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/totalServices" ) + .param("state", "ACTIVE") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk() ) + .andReturn().getResponse().getContentAsString(); + + int totalServices = JsonPath.read(response, "$.totalServices"); + + + List servicesList = serviceRepoService.findAll(); + int activeServices = (int) servicesList.stream().filter(service -> service.getState() == ServiceStateType.ACTIVE).count(); + + assertThat(totalServices).isEqualTo(activeServices); + assertThat(activeServices).isEqualTo(1); + } + + @WithMockUser(username = "osadmin", roles = {"ADMIN", "USER"}) + @Test + public void testGetServicesGroupedByState() throws Exception { + String startTime = OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT); + + createService(ServiceStateType.ACTIVE); + createService(ServiceStateType.ACTIVE); + createService(ServiceStateType.ACTIVE); + createService(ServiceStateType.INACTIVE); + createService(ServiceStateType.INACTIVE); + createService(ServiceStateType.TERMINATED); + + String endTime = OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/servicesGroupByState") + .param("starttime", startTime) + .param("endtime", endTime) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + + List> groupByState = JsonPath.read(response, "$.services.aggregations.groupByState"); + + // Create a map from key -> count + Map stateCounts = groupByState.stream() + .collect(Collectors.toMap( + entry -> (String) entry.get("key"), + entry -> (Integer) entry.get("count") + )); + + assertThat(stateCounts.get("ACTIVE")).isEqualTo(3); + assertThat(stateCounts.get("INACTIVE")).isEqualTo(2); + assertThat(stateCounts.get("TERMINATED")).isEqualTo(1); + assertThat(stateCounts.get("FEASIBILITYCHECKED")).isEqualTo(0); + assertThat(stateCounts.get("RESERVED")).isEqualTo(0); + assertThat(stateCounts.get("DESIGNED")).isEqualTo(0); + } + + + + @Transactional + void createService(ServiceStateType state ) throws Exception { + int servicesCount = serviceRepoService.findAll().size(); + + File sspec = new File( "src/test/resources/testServiceSpec.json" ); + InputStream in = new FileInputStream( sspec ); + String sspectext = IOUtils.toString(in, "UTF-8"); + + ServiceSpecificationCreate sspeccr1 = JsonUtils.toJsonObj( sspectext, ServiceSpecificationCreate.class); + sspeccr1.setName("Spec1"); + ServiceSpecification responsesSpec = createServiceSpec(sspeccr1); + + ServiceCreate aService = new ServiceCreate(); + aService.setName("aNew Service"); + aService.setCategory("Test Category"); + aService.setDescription("A Test Service"); + aService.setStartDate( OffsetDateTime.now(ZoneOffset.UTC ).toString() ); + aService.setEndDate( OffsetDateTime.now(ZoneOffset.UTC ).toString() ); + aService.setState(state); + + Characteristic serviceCharacteristicItem = new Characteristic(); + + serviceCharacteristicItem.setName( "ConfigStatus" ); + serviceCharacteristicItem.setValue( new Any("NONE")); + aService.addServiceCharacteristicItem(serviceCharacteristicItem); + + ServiceSpecificationRef aServiceSpecificationRef = new ServiceSpecificationRef(); + aServiceSpecificationRef.setId(responsesSpec.getId() ); + aServiceSpecificationRef.setName(responsesSpec.getName()); + + aService.setServiceSpecificationRef(aServiceSpecificationRef ); + + String response = mvc.perform(MockMvcRequestBuilders.post("/serviceInventory/v4/service") + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON) + .content( JsonUtils.toJson( aService ) )) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + + Service responseService = JsonUtils.toJsonObj(response, Service.class); + + assertThat( serviceRepoService.findAll().size() ).isEqualTo( servicesCount + 1 ); + assertThat(responseService.getCategory()).isEqualTo("Test Category"); + assertThat(responseService.getDescription()).isEqualTo("A Test Service"); + + } + + private ServiceSpecification createServiceSpec(ServiceSpecificationCreate sspeccr1) throws Exception{ + String response = mvc.perform(MockMvcRequestBuilders.post("/serviceCatalogManagement/v4/serviceSpecification") + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON) + .content( JsonUtils.toJson( sspeccr1 ) )) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + + return JsonUtils.toJsonObj(response, ServiceSpecification.class); + } +}