],
"tags": ["NearRT-RIC Repository"]
}},
+ "/actuator/shutdown": {"post": {
+ "summary": "Actuator web endpoint 'shutdown'",
+ "operationId": "shutdown",
+ "responses": {"200": {
+ "description": "OK",
+ "content": {"*/*": {
+ "schema": {
+ "type": "object",
+ "example": null
+ },
+ "example": null
+ }}
+ }},
+ "tags": ["Actuator"]
+ }},
"/a1-policy/v2/policy-types": {"get": {
"summary": "Query policy type identities",
"operationId": "getPolicyTypes",
},
"info": {
"license": {
- "name": "Copyright (C) 2020-2022 Nordix Foundation. Licensed under the Apache License.",
+ "name": "Copyright (C) 2020-2023 Nordix Foundation. Licensed under the Apache License.",
"url": "http://www.apache.org/licenses/LICENSE-2.0"
},
- "description": "<h2>General<\/h2><p>The O-RAN Non-RT RIC Policy Management Service provides a REST API for management of A1 policies. <br/>The main tasks of the service are:<\/p><ul><li>A1 Policy creation, modification and deletion.<\/li><li>Monitoring and maintaining consistency of the SMO view of A1 policies and the Near-RT RICs<\/li><li>Maintaining a view of supported Near-RT RIC policy types<\/li><li>Supervision of using services (R-APPs). When a service is unavailable, its policies are removed.<\/li><\/ul><h2>APIs provided by the service<\/h2><h3>A1 Policy Management<\/h3><p>This is an API for management of A1 Policies.<\/p><ul><li>A1 Policy retrieval, creation, modification and deletion.<\/li><li>Retrieval of supported A1 Policy types for a Near-RT RIC<\/li><li>Retrieval of status for existing A1 policies<\/li><\/ul><h3>Management of configuration<\/h3><p>API for updating and retrieval of the component configuration. Note that there other ways to maintain the configuration.<\/p><h3>Callbacks<\/h3><p>These are endpoints that are invoked by this service. The callbacks are registered in this service at service registration.<\/p><h3>NearRT-RIC Repository<\/h3><p>This is an API that provides support for looking up a NearRT-RIC. Each A1 policy is targeted for one Near-RT RIC.<\/p><h3>Health Check<\/h3><p>API used for supervision of the PMS component.<\/p><h3>Service Registry and Supervision<\/h3><p>API used for registering services that uses PMS. Each A1 policy is optionally owned by a service. PMS can supervise each registered service by a heart-beat supervision and will automatically remove policies for unavailable services. Note that a service does not need to be registered in order to create A1 Policies. This is a feature that is optional to use.<\/p>",
+ "description": "<h2>General<\/h2><p>The O-RAN Non-RT RIC Policy Management Service provides a REST API for management of A1 policies. <br/>The main tasks of the service are:<\/p><ul><li>A1 Policy creation, modification and deletion.<\/li><li>Monitoring and maintaining consistency of the SMO view of A1 policies and the Near-RT RICs<\/li><li>Maintaining a view of supported Near-RT RIC policy types<\/li><li>Supervision of using services (R-APPs). When a service is unavailable, its policies are removed.<\/li><\/ul><h2>APIs provided by the service<\/h2><h3>A1 Policy Management<\/h3><p>This is an API for management of A1 Policies.<\/p><ul><li>A1 Policy retrieval, creation, modification and deletion.<\/li><li>Retrieval of supported A1 Policy types for a Near-RT RIC<\/li><li>Retrieval of status for existing A1 policies<\/li><\/ul><h3>Management of configuration<\/h3><p>API for updating and retrieval of the component configuration. Note that there other ways to maintain the configuration.<\/p><h3>Callbacks<\/h3><p>These are endpoints that are invoked by this service. The callbacks are registered in this service at service registration.<\/p><h3>NearRT-RIC Repository<\/h3><p>This is an API that provides support for looking up a NearRT-RIC. Each A1 policy is targeted for one Near-RT RIC.<\/p><h3>Health Check<\/h3><p>API used for supervision of the PMS component.<\/p><h3>Service Registry and Supervision<\/h3><p>API used for registering services that uses PMS. Each A1 policy is optionally owned by a service. PMS can supervise each registered service by a heart-beat supervision and will automatically remove policies for unavailable services. Note that a service does not need to be registered in order to create A1 Policies. This is a feature that is optional to use.<\/p><h3>Spring Boot Actuator<\/h3><p>Provides generic functions used to monitor and manage the Spring web application.<\/p>",
"title": "A1 Policy Management Service",
"version": "1.1.0"
},
Each A1 policy is optionally owned by a service. PMS can supervise each registered
service by a heart-beat supervision and will automatically remove policies for
unavailable services. Note that a service does not need to be registered in order
- to create A1 Policies. This is a feature that is optional to use.</p>
+ to create A1 Policies. This is a feature that is optional to use.</p><h3>Spring
+ Boot Actuator</h3><p>Provides generic functions used to monitor and manage the
+ Spring web application.</p>
license:
- name: Copyright (C) 2020-2022 Nordix Foundation. Licensed under the Apache License.
+ name: Copyright (C) 2020-2023 Nordix Foundation. Licensed under the Apache License.
url: http://www.apache.org/licenses/LICENSE-2.0
version: 1.1.0
servers:
application/json:
schema:
$ref: '#/components/schemas/error_information'
+ /actuator/shutdown:
+ post:
+ tags:
+ - Actuator
+ summary: Actuator web endpoint 'shutdown'
+ operationId: shutdown
+ responses:
+ 200:
+ description: OK
+ content:
+ '*/*':
+ schema:
+ type: object
/a1-policy/v2/policy-types:
get:
tags:
web:
exposure:
# Enabling of springboot actuator features. See springboot documentation.
- include: "loggers,logfile,health,info,metrics,threaddump,heapdump"
+ include: "loggers,logfile,health,info,metrics,threaddump,heapdump,shutdown"
+ endpoint:
+ shutdown:
+ enabled: true
+lifecycle:
+ timeout-per-shutdown-phase: "20s"
springdoc:
show-actuator: true
logging:
# See springboot documentation.
port : 8433
http-port: 8081
+ shutdown: "graceful"
ssl:
key-store-type: JKS
key-store-password: policy_agent
package org.onap.ccsdk.oran.a1policymanagementservice;
+import java.lang.invoke.MethodHandles;
+
import org.onap.ccsdk.oran.a1policymanagementservice.dmaap.DmaapMessageConsumer;
import org.onap.ccsdk.oran.a1policymanagementservice.tasks.RefreshConfigTask;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
+import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
@Autowired
private DmaapMessageConsumer dmaapMessageConsumer;
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
+
public static void main(String[] args) {
- SpringApplication.run(Application.class);
+ ConfigurableApplicationContext context = SpringApplication.run(Application.class);
+
+ Runtime.getRuntime().addShutdownHook(new Thread() {
+ @Override
+ public void run() {
+ logger.warn("Shutting down, received signal SIGTERM");
+ SpringApplication.exit(context);
+ }
+ });
}
/**
version = SwaggerConfig.VERSION, //
description = SwaggerConfig.DESCRIPTION, //
license = @License(
- name = "Copyright (C) 2020-2022 Nordix Foundation. Licensed under the Apache License.", //
+ name = "Copyright (C) 2020-2023 Nordix Foundation. Licensed under the Apache License.", //
url = "http://www.apache.org/licenses/LICENSE-2.0")) //
)
public class SwaggerConfig {
+ H3 + StatusController.API_NAME + H3_END + //
"<p>API used for supervision of the PMS component.</p>" + //
H3 + ServiceController.API_NAME + H3_END + //
- "<p>" + "API used for registering services that uses PMS."
+ "<p>" //
+ + "API used for registering services that uses PMS."
+ " Each A1 policy is optionally owned by a service. PMS can supervise each registered service by a heart-beat supervision and will automatically remove policies for unavailable services."
+ " Note that a service does not need to be registered in order to create A1 Policies. This is a feature that is optional to use."
- + "</p>";
+ + "</p>" + //
+ H3 + "Spring Boot Actuator" + H3_END + //
+ "<p>" //
+ + "Provides generic functions used to monitor and manage the Spring web application." + //
+ "</p>";
public static final String VERSION = "1.1.0";
}
package org.onap.ccsdk.oran.a1policymanagementservice.aspect;
+import java.lang.invoke.MethodHandles;
+
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
@Component
public class LogAspect {
- private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Around("execution(* org.onap.ccsdk.oran.a1policymanagementservice..*(..)))")
public void executimeTime(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
package org.onap.ccsdk.oran.a1policymanagementservice.clients;
+import java.lang.invoke.MethodHandles;
import java.lang.reflect.Constructor;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1Client.A1ProtocolType;
*/
public class A1ClientFactory {
- private static final Logger logger = LoggerFactory.getLogger(A1ClientFactory.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
private final ApplicationConfig appConfig;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
+import java.lang.invoke.MethodHandles;
import java.util.Optional;
import javax.validation.constraints.NotNull;
@Component
public class ConfigurationFile {
- private static final Logger logger = LoggerFactory.getLogger(ConfigurationFile.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
final ApplicationConfig appConfig;
final Gson gson = new Gson();
package org.onap.ccsdk.oran.a1policymanagementservice.datastore;
+import java.lang.invoke.MethodHandles;
import java.net.URI;
import java.util.concurrent.CompletableFuture;
import software.amazon.awssdk.services.s3.model.S3Object;
class S3ObjectStore implements DataStore {
- private static final Logger logger = LoggerFactory.getLogger(S3ObjectStore.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
private final ApplicationConfig applicationConfig;
private static S3AsyncClient s3AsynchClient;
import com.google.gson.JsonElement;
import com.google.gson.JsonParser;
+import java.lang.invoke.MethodHandles;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
protected static final Duration TIME_BETWEEN_DMAAP_RETRIES = Duration.ofSeconds(10);
- private static final Logger logger = LoggerFactory.getLogger(DmaapMessageConsumer.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
private final ApplicationConfig applicationConfig;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
+import java.lang.invoke.MethodHandles;
+
import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClient;
import org.onap.ccsdk.oran.a1policymanagementservice.dmaap.DmaapRequestMessage.Operation;
import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
* response though DMAAP
*/
public class DmaapMessageHandler {
- private static final Logger logger = LoggerFactory.getLogger(DmaapMessageHandler.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
private static Gson gson = new GsonBuilder().create();
private final AsyncRestClient dmaapClient;
private final AsyncRestClient pmsClient;
package org.onap.ccsdk.oran.a1policymanagementservice.exceptions;
+import java.lang.invoke.MethodHandles;
+
import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.ErrorResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ControllerAdvice(annotations = RestController.class)
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
- private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@ExceptionHandler(ServiceException.class)
public final ResponseEntity<Object> handleServiceException(ServiceException ex) {
package org.onap.ccsdk.oran.a1policymanagementservice.repository;
+import java.lang.invoke.MethodHandles;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
* resource (for shared usage).
*/
public class Lock {
- private static final Logger logger = LoggerFactory.getLogger(Lock.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
boolean isExclusive = false;
private int lockCounter = 0;
package org.onap.ccsdk.oran.a1policymanagementservice.repository;
+import java.lang.invoke.MethodHandles;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
* Holds information about a Near-RT RIC.
*/
public class Ric {
- private static final Logger logger = LoggerFactory.getLogger(Ric.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Setter
private RicConfig ricConfig;
import com.google.gson.Gson;
+import java.lang.invoke.MethodHandles;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;
import reactor.core.publisher.Mono;
public class Services {
- private static final Logger logger = LoggerFactory.getLogger(Services.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
private static Gson gson = Service.createGson();
private final DataStore dataStore;
import com.google.gson.JsonObject;
+import java.lang.invoke.MethodHandles;
import java.time.Duration;
import java.util.Optional;
import java.util.Properties;
@SuppressWarnings("squid:S2629") // Invoke method(s) only conditionally
public class RefreshConfigTask {
- private static final Logger logger = LoggerFactory.getLogger(RefreshConfigTask.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Value("#{systemEnvironment}")
public Properties systemEnvironment;
package org.onap.ccsdk.oran.a1policymanagementservice.tasks;
+import java.lang.invoke.MethodHandles;
import java.util.Collection;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1Client;
@EnableScheduling
@SuppressWarnings("squid:S2629") // Invoke method(s) only conditionally
public class RicSupervision {
- private static final Logger logger = LoggerFactory.getLogger(RicSupervision.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
private static final int CONCURRENCY = 50; // Number of RIC checked in paralell
private final Rics rics;
import static org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric.RicState;
+import java.lang.invoke.MethodHandles;
import java.util.Set;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1Client;
@SuppressWarnings("squid:S2629") // Invoke method(s) only conditionally
public class RicSynchronizationTask {
- private static final Logger logger = LoggerFactory.getLogger(RicSynchronizationTask.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
static final int CONCURRENCY_RIC = 1; // How many paralell requests that is sent to one NearRT RIC
private final A1ClientFactory a1ClientFactory;
package org.onap.ccsdk.oran.a1policymanagementservice.tasks;
+import java.lang.invoke.MethodHandles;
import java.time.Duration;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
@EnableScheduling
@SuppressWarnings("squid:S2629") // Invoke method(s) only conditionally
public class ServiceSupervision {
- private static final Logger logger = LoggerFactory.getLogger(ServiceSupervision.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
static final int CONCURRENCY_RIC = 1; // How may paralell requests that is sent
private final Services services;
private final Policies policies;
import java.io.File;
import java.io.IOException;
+import java.lang.invoke.MethodHandles;
import java.net.URL;
import java.nio.file.Files;
import java.time.Instant;
// but a mock
// of the server.
class MockPolicyManagementService {
- private static final Logger logger = LoggerFactory.getLogger(MockPolicyManagementService.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Autowired
Rics rics;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
+import java.lang.invoke.MethodHandles;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import org.json.JSONObject;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClient;
import org.onap.ccsdk.oran.a1policymanagementservice.clients.AsyncRestClientFactory;
import org.springframework.http.ResponseEntity;
import org.springframework.test.context.TestPropertySource;
import org.springframework.util.FileSystemUtils;
+import org.springframework.web.reactive.function.client.WebClientRequestException;
import org.springframework.web.reactive.function.client.WebClientResponseException;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import reactor.util.annotation.Nullable;
+@TestMethodOrder(MethodOrderer.MethodName.class)
@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@TestPropertySource(properties = { //
"server.ssl.key-store=./config/keystore.jks", //
"app.s3.bucket=" // If this is set, S3 will be used to store data.
})
class ApplicationTest {
- private static final Logger logger = LoggerFactory.getLogger(ApplicationTest.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
@Autowired
ApplicationContext context;
}
}
+ @Test
+ @SuppressWarnings("squid:S2925") // "Thread.sleep" should not be used in tests.
+ void testZZActuator() throws Exception {
+ // The test must be run last, hence the "ZZ" in the name. All succeeding tests
+ // will fail.
+ AsyncRestClient client = restClient(baseUrl(), false);
+
+ client.post("/actuator/loggers/org.onap.ccsdk.oran.a1policymanagementservice",
+ "{\"configuredLevel\":\"trace\"}").block();
+
+ String resp = client.get("/actuator/loggers/org.onap.ccsdk.oran.a1policymanagementservice").block();
+ assertThat(resp).contains("TRACE");
+
+ client.post("/actuator/loggers/org.springframework.boot.actuate", "{\"configuredLevel\":\"trace\"}").block();
+
+ // This will stop the web server and all coming tests will fail.
+ client.post("/actuator/shutdown", "").block();
+
+ Thread.sleep(1000);
+
+ StepVerifier.create(restClient().get("/rics")) // Any call
+ .expectSubscription() //
+ .expectErrorMatches(t -> t instanceof WebClientRequestException) //
+ .verify();
+
+ }
+
@Test
void generateApiDoc() throws IOException {
String url = "https://localhost:" + this.port + "/v3/api-docs";
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
+import java.lang.invoke.MethodHandles;
import java.time.Instant;
import java.util.concurrent.atomic.AtomicInteger;
* thread. For test of robustness using concurrent clients.
*/
class ConcurrencyTestRunnable implements Runnable {
- private static final Logger logger = LoggerFactory.getLogger(ConcurrencyTestRunnable.class);
+ private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
private final AsyncRestClient webClient;
static AtomicInteger nextCount = new AtomicInteger(0);
private final int count;
],
"tags": ["NearRT-RIC Repository"]
}},
+ "/actuator/shutdown": {"post": {
+ "summary": "Actuator web endpoint 'shutdown'",
+ "operationId": "shutdown",
+ "responses": {"200": {
+ "description": "OK",
+ "content": {"*/*": {
+ "schema": {
+ "type": "object",
+ "example": null
+ },
+ "example": null
+ }}
+ }},
+ "tags": ["Actuator"]
+ }},
"/a1-policy/v2/policy-types": {"get": {
"summary": "Query policy type identities",
"operationId": "getPolicyTypes",
},
"info": {
"license": {
- "name": "Copyright (C) 2020-2022 Nordix Foundation. Licensed under the Apache License.",
+ "name": "Copyright (C) 2020-2023 Nordix Foundation. Licensed under the Apache License.",
"url": "http://www.apache.org/licenses/LICENSE-2.0"
},
- "description": "<h2>General<\/h2><p>The O-RAN Non-RT RIC Policy Management Service provides a REST API for management of A1 policies. <br/>The main tasks of the service are:<\/p><ul><li>A1 Policy creation, modification and deletion.<\/li><li>Monitoring and maintaining consistency of the SMO view of A1 policies and the Near-RT RICs<\/li><li>Maintaining a view of supported Near-RT RIC policy types<\/li><li>Supervision of using services (R-APPs). When a service is unavailable, its policies are removed.<\/li><\/ul><h2>APIs provided by the service<\/h2><h3>A1 Policy Management<\/h3><p>This is an API for management of A1 Policies.<\/p><ul><li>A1 Policy retrieval, creation, modification and deletion.<\/li><li>Retrieval of supported A1 Policy types for a Near-RT RIC<\/li><li>Retrieval of status for existing A1 policies<\/li><\/ul><h3>Management of configuration<\/h3><p>API for updating and retrieval of the component configuration. Note that there other ways to maintain the configuration.<\/p><h3>Callbacks<\/h3><p>These are endpoints that are invoked by this service. The callbacks are registered in this service at service registration.<\/p><h3>NearRT-RIC Repository<\/h3><p>This is an API that provides support for looking up a NearRT-RIC. Each A1 policy is targeted for one Near-RT RIC.<\/p><h3>Health Check<\/h3><p>API used for supervision of the PMS component.<\/p><h3>Service Registry and Supervision<\/h3><p>API used for registering services that uses PMS. Each A1 policy is optionally owned by a service. PMS can supervise each registered service by a heart-beat supervision and will automatically remove policies for unavailable services. Note that a service does not need to be registered in order to create A1 Policies. This is a feature that is optional to use.<\/p>",
+ "description": "<h2>General<\/h2><p>The O-RAN Non-RT RIC Policy Management Service provides a REST API for management of A1 policies. <br/>The main tasks of the service are:<\/p><ul><li>A1 Policy creation, modification and deletion.<\/li><li>Monitoring and maintaining consistency of the SMO view of A1 policies and the Near-RT RICs<\/li><li>Maintaining a view of supported Near-RT RIC policy types<\/li><li>Supervision of using services (R-APPs). When a service is unavailable, its policies are removed.<\/li><\/ul><h2>APIs provided by the service<\/h2><h3>A1 Policy Management<\/h3><p>This is an API for management of A1 Policies.<\/p><ul><li>A1 Policy retrieval, creation, modification and deletion.<\/li><li>Retrieval of supported A1 Policy types for a Near-RT RIC<\/li><li>Retrieval of status for existing A1 policies<\/li><\/ul><h3>Management of configuration<\/h3><p>API for updating and retrieval of the component configuration. Note that there other ways to maintain the configuration.<\/p><h3>Callbacks<\/h3><p>These are endpoints that are invoked by this service. The callbacks are registered in this service at service registration.<\/p><h3>NearRT-RIC Repository<\/h3><p>This is an API that provides support for looking up a NearRT-RIC. Each A1 policy is targeted for one Near-RT RIC.<\/p><h3>Health Check<\/h3><p>API used for supervision of the PMS component.<\/p><h3>Service Registry and Supervision<\/h3><p>API used for registering services that uses PMS. Each A1 policy is optionally owned by a service. PMS can supervise each registered service by a heart-beat supervision and will automatically remove policies for unavailable services. Note that a service does not need to be registered in order to create A1 Policies. This is a feature that is optional to use.<\/p><h3>Spring Boot Actuator<\/h3><p>Provides generic functions used to monitor and manage the Spring web application.<\/p>",
"title": "A1 Policy Management Service",
"version": "1.1.0"
},
Each A1 policy is optionally owned by a service. PMS can supervise each registered
service by a heart-beat supervision and will automatically remove policies for
unavailable services. Note that a service does not need to be registered in order
- to create A1 Policies. This is a feature that is optional to use.</p>
+ to create A1 Policies. This is a feature that is optional to use.</p><h3>Spring
+ Boot Actuator</h3><p>Provides generic functions used to monitor and manage the
+ Spring web application.</p>
license:
- name: Copyright (C) 2020-2022 Nordix Foundation. Licensed under the Apache License.
+ name: Copyright (C) 2020-2023 Nordix Foundation. Licensed under the Apache License.
url: http://www.apache.org/licenses/LICENSE-2.0
version: 1.1.0
servers:
application/json:
schema:
$ref: '#/components/schemas/error_information'
+ /actuator/shutdown:
+ post:
+ tags:
+ - Actuator
+ summary: Actuator web endpoint 'shutdown'
+ operationId: shutdown
+ responses:
+ 200:
+ description: OK
+ content:
+ '*/*':
+ schema:
+ type: object
/a1-policy/v2/policy-types:
get:
tags:
Code Review / ccsdk / oran.git / commitdiff