Commit 3cf29964 authored by Kostis Trantzas's avatar Kostis Trantzas
Browse files

Merge branch '70-create-metrics-endpoints-for-tmf-service-related-information' into 'develop' 

Resolve "Create metrics endpoints for TMF Service related information"

See merge request !68
parents fa3ee343 724fcef3

src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApi.java

0 → 100644
+49 −0
Original line number Diff line number Diff line 
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<TotalServices> 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<ServicesGroupByState> 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

    );

}

src/main/java/org/etsi/osl/tmf/metrics/api/ServiceMetricsApiController.java

0 → 100644
+75 −0
Original line number Diff line number Diff line 
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<TotalServices> 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<ServicesGroupByState> getServicesGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) {

        try {

            Map<String, Integer> 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<String, Integer> 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<ServicesGroupByStateItem> 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);

        }

    }

}

src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceMetricsRepoService.java

0 → 100644
+45 −0
Original line number Diff line number Diff line 
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<String, Integer> getServicesGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) {

        if (starttime.plusDays(31).isBefore(endtime)) {

            starttime = endtime.minusDays(31);

        }



        List<Object[]> rawResults = serviceRepo.groupByStateBetweenDates(starttime, endtime);



        return rawResults.stream()

                .collect(Collectors.toMap(

                        row -> row[0].toString(),

                        row -> ((Number) row[1]).intValue()

                ));

    }



}

src/main/java/org/etsi/osl/tmf/sim638/repo/ServiceRepository.java

+14 −0
Original line number Diff line number Diff line
@@ -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<Service, Long> { 
        + "WHERE sres.id = ?1 " )  

    List<Service> 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<Object[]> groupByStateBetweenDates(OffsetDateTime starttime, OffsetDateTime endtime);

}

src/test/java/org/etsi/osl/services/api/metrics/ServiceMetricsApiControllerTest.java

0 → 100644
+215 −0
Original line number Diff line number Diff line 
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<Service> 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<Map<String, Object>> groupByState = JsonPath.read(response, "$.services.aggregations.groupByState");



        // Create a map from key -> count

        Map<String, Integer> 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);

    }

}