"401": {"description": "Unauthorized"},
"403": {"description": "Forbidden"},
"404": {
- "schema": {"type": "string"},
+ "schema": {"$ref": "#/definitions/error_information"},
"description": "Near-RT RIC is not found"
}
},
"summary": "Returns service information",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "getServicesUsingGET",
+ "operationId": "getServicesUsingGET_1",
"responses": {
"200": {
"schema": {
"summary": "Delete a service",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "deleteServiceUsingDELETE",
+ "operationId": "deleteServiceUsingDELETE_1",
"responses": {
"200": {
"schema": {"type": "string"},
"summary": "Unregister a service",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "deleteServiceUsingDELETE_1",
+ "operationId": "deleteServiceUsingDELETE",
"responses": {
"200": {"description": "Not used"},
"401": {"description": "Unauthorized"},
},
"401": {"description": "Unauthorized"},
"403": {"description": "Forbidden"},
- "404": {"description": "Policy is not found"}
+ "404": {
+ "schema": {"$ref": "#/definitions/error_information"},
+ "description": "Policy is not found"
+ }
},
"parameters": [{
"in": "query",
"401": {"description": "Unauthorized"},
"403": {"description": "Forbidden"},
"404": {
- "schema": {"type": "string"},
+ "schema": {"$ref": "#/definitions/error_information"},
"description": "The policy type is not found"
}
},
"summary": "Query Near-RT RIC information",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "getRicsUsingGET",
+ "operationId": "getRicsUsingGET_1",
"responses": {
"200": {
"schema": {
"deprecated": false,
"produces": ["application/json"],
"description": "The call returns all Near-RT RICs that supports a given policy type identity",
- "operationId": "getRicsUsingGET_1",
+ "operationId": "getRicsUsingGET",
"responses": {
"200": {
"schema": {"$ref": "#/definitions/ric_info_list_v2"},
"401": {"description": "Unauthorized"},
"403": {"description": "Forbidden"},
"404": {
- "schema": {"type": "string"},
+ "schema": {"$ref": "#/definitions/error_information"},
"description": "Near-RT RIC is not found"
}
},
"deprecated": false,
"produces": ["application/json"],
"description": "Either information about a registered service with given identity or all registered services are returned.",
- "operationId": "getServicesUsingGET_1",
+ "operationId": "getServicesUsingGET",
"responses": {
"200": {
"schema": {"$ref": "#/definitions/service_list_v2"},
"deprecated": false,
"produces": ["*/*"],
"description": "Registering a service is needed to:<ul><li>Get callbacks.<\/li><li>Activate supervision of the service. If a service is inactive, its policies will be deleted.<\/li><\/ul>",
- "operationId": "putServiceUsingPUT_1",
+ "operationId": "putServiceUsingPUT",
"responses": {
"200": {
"schema": {"type": "object"},
"summary": "Returns the name of a RIC managing one Mananged Element",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "getRicUsingGET",
+ "operationId": "getRicUsingGET_1",
"responses": {
"200": {
"schema": {"type": "string"},
"summary": "Heartbeat from a service",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "keepAliveServiceUsingPUT",
+ "operationId": "keepAliveServiceUsingPUT_1",
"responses": {
"200": {
"schema": {"type": "string"},
"summary": "Heartbeat indicates that the service is running",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "keepAliveServiceUsingPUT_1",
+ "operationId": "keepAliveServiceUsingPUT",
"responses": {
"200": {
"schema": {"type": "object"},
"deprecated": false,
"produces": ["application/json"],
"description": "Either a Near-RT RIC identity or a Mananged Element identity can be specified.<br>The intention with Mananged Element identity is the ID used in O1 for accessing the traffical element (such as the ID of CU).",
- "operationId": "getRicUsingGET_1",
+ "operationId": "getRicUsingGET",
"responses": {
"200": {
"schema": {"$ref": "#/definitions/ric_info_v2"},
"summary": "Register a service",
"deprecated": false,
"produces": ["*/*"],
- "operationId": "putServiceUsingPUT",
+ "operationId": "putServiceUsingPUT_1",
"responses": {
"200": {
"schema": {"type": "string"},
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
import org.onap.ccsdk.oran.a1policymanagementservice.controllers.VoidResponse;
-import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
+import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.ErrorResponse;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.ImmutablePolicy;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Lock.LockType;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
@ApiOperation(value = "Returns policy type schema definitions")
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Policy schemas", response = Object.class, responseContainer = "List"), //
- @ApiResponse(code = 404, message = "Near-RT RIC is not found", response = String.class)})
+ @ApiResponse(code = 404, message = "Near-RT RIC is not found", response = ErrorResponse.ErrorInfo.class)})
public ResponseEntity<String> getPolicySchemas( //
@ApiParam(name = "ric", required = false, value = "The name of the Near-RT RIC to get the definitions for.") //
- @RequestParam(name = "ric", required = false) String ricName) {
+ @RequestParam(name = "ric", required = false) String ricName) throws EntityNotFoundException {
if (ricName == null) {
Collection<PolicyType> types = this.policyTypes.getAll();
return new ResponseEntity<>(toPolicyTypeSchemasJson(types), HttpStatus.OK);
} else {
- try {
- Collection<PolicyType> types = rics.getRic(ricName).getSupportedPolicyTypes();
- return new ResponseEntity<>(toPolicyTypeSchemasJson(types), HttpStatus.OK);
- } catch (ServiceException e) {
- return new ResponseEntity<>(e.toString(), HttpStatus.NOT_FOUND);
- }
+ Collection<PolicyType> types = rics.getRic(ricName).getSupportedPolicyTypes();
+ return new ResponseEntity<>(toPolicyTypeSchemasJson(types), HttpStatus.OK);
}
}
@GetMapping("/policy_schema")
@ApiOperation(value = "Returns one policy type schema definition")
@ApiResponses(value = { //
- @ApiResponse(code = 200, message = "Policy schema", response = Object.class),
- @ApiResponse(code = 404, message = "The policy type is not found", response = String.class)})
+ @ApiResponse(code = 200, message = "Policy schema", response = Object.class), @ApiResponse(code = 404,
+ message = "The policy type is not found", response = ErrorResponse.ErrorInfo.class)})
public ResponseEntity<String> getPolicySchema( //
@ApiParam(name = "id", required = true,
value = "The identity of the policy type to get the definition for.") //
- @RequestParam(name = "id", required = true) String id) {
- try {
- PolicyType type = policyTypes.getType(id);
- return new ResponseEntity<>(type.schema(), HttpStatus.OK);
- } catch (ServiceException e) {
- return new ResponseEntity<>(e.toString(), HttpStatus.NOT_FOUND);
- }
+ @RequestParam(name = "id", required = true) String id) throws EntityNotFoundException {
+ PolicyType type = policyTypes.getType(id);
+ return new ResponseEntity<>(type.schema(), HttpStatus.OK);
}
@GetMapping("/policy_types")
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Policy type names", response = String.class,
responseContainer = "List"),
- @ApiResponse(code = 404, message = "Near-RT RIC is not found", response = String.class)})
+ @ApiResponse(code = 404, message = "Near-RT RIC is not found", response = ErrorResponse.ErrorInfo.class)})
public ResponseEntity<String> getPolicyTypes( //
@ApiParam(name = "ric", required = false, value = "The name of the Near-RT RIC to get types for.") //
- @RequestParam(name = "ric", required = false) String ricName) {
+ @RequestParam(name = "ric", required = false) String ricName) throws EntityNotFoundException {
if (ricName == null) {
Collection<PolicyType> types = this.policyTypes.getAll();
return new ResponseEntity<>(toPolicyTypeIdsJson(types), HttpStatus.OK);
} else {
- try {
- Collection<PolicyType> types = rics.getRic(ricName).getSupportedPolicyTypes();
- return new ResponseEntity<>(toPolicyTypeIdsJson(types), HttpStatus.OK);
- } catch (ServiceException e) {
- return new ResponseEntity<>(e.toString(), HttpStatus.NOT_FOUND);
- }
+ Collection<PolicyType> types = rics.getRic(ricName).getSupportedPolicyTypes();
+ return new ResponseEntity<>(toPolicyTypeIdsJson(types), HttpStatus.OK);
}
}
@ApiOperation(value = "Returns a policy configuration") //
@ApiResponses(value = { //
@ApiResponse(code = 200, message = "Policy found", response = Object.class), //
- @ApiResponse(code = 404, message = "Policy is not found")} //
+ @ApiResponse(code = 404, message = "Policy is not found", response = ErrorResponse.ErrorInfo.class)} //
)
public ResponseEntity<String> getPolicy( //
@ApiParam(name = "id", required = true, value = "The identity of the policy instance.") //
- @RequestParam(name = "id", required = true) String id) {
- try {
- Policy p = policies.getPolicy(id);
- return new ResponseEntity<>(p.json(), HttpStatus.OK);
- } catch (ServiceException e) {
- return new ResponseEntity<>(e.getMessage(), HttpStatus.NOT_FOUND);
- }
+ @RequestParam(name = "id", required = true) String id) throws EntityNotFoundException {
+ Policy p = policies.getPolicy(id);
+ return new ResponseEntity<>(p.json(), HttpStatus.OK);
}
@DeleteMapping("/policy")
@ApiResponse(code = 423, message = "Near-RT RIC is not operational", response = String.class)})
public Mono<ResponseEntity<Object>> deletePolicy( //
@ApiParam(name = "id", required = true, value = "The identity of the policy instance.") //
- @RequestParam(name = "id", required = true) String id) {
- try {
- Policy policy = policies.getPolicy(id);
- keepServiceAlive(policy.ownerServiceId());
- Ric ric = policy.ric();
- return ric.getLock().lock(LockType.SHARED) //
- .flatMap(notUsed -> assertRicStateIdle(ric)) //
- .flatMap(notUsed -> a1ClientFactory.createA1Client(policy.ric())) //
- .doOnNext(notUsed -> policies.remove(policy)) //
- .flatMap(client -> client.deletePolicy(policy)) //
- .doOnNext(notUsed -> ric.getLock().unlockBlocking()) //
- .doOnError(notUsed -> ric.getLock().unlockBlocking()) //
- .flatMap(notUsed -> Mono.just(new ResponseEntity<>(HttpStatus.NO_CONTENT)))
- .onErrorResume(this::handleException);
- } catch (ServiceException e) {
- return Mono.just(new ResponseEntity<>(HttpStatus.NOT_FOUND));
- }
+ @RequestParam(name = "id", required = true) String id) throws EntityNotFoundException {
+ Policy policy = policies.getPolicy(id);
+ keepServiceAlive(policy.ownerServiceId());
+ Ric ric = policy.ric();
+ return ric.getLock().lock(LockType.SHARED) //
+ .flatMap(notUsed -> assertRicStateIdle(ric)) //
+ .flatMap(notUsed -> a1ClientFactory.createA1Client(policy.ric())) //
+ .doOnNext(notUsed -> policies.remove(policy)) //
+ .flatMap(client -> client.deletePolicy(policy)) //
+ .doOnNext(notUsed -> ric.getLock().unlockBlocking()) //
+ .doOnError(notUsed -> ric.getLock().unlockBlocking()) //
+ .flatMap(notUsed -> Mono.just(new ResponseEntity<>(HttpStatus.NO_CONTENT)))
+ .onErrorResume(this::handleException);
}
@PutMapping(path = "/policy")
)
public Mono<ResponseEntity<String>> getPolicyStatus( //
@ApiParam(name = "id", required = true, value = "The identity of the policy.") @RequestParam(name = "id", //
- required = true) String id) {
- try {
- Policy policy = policies.getPolicy(id);
-
- return a1ClientFactory.createA1Client(policy.ric()) //
- .flatMap(client -> client.getPolicyStatus(policy)) //
- .flatMap(status -> Mono.just(new ResponseEntity<>(status, HttpStatus.OK)))
- .onErrorResume(this::handleException);
- } catch (ServiceException e) {
- return Mono.just(new ResponseEntity<>(e.getMessage(), HttpStatus.NOT_FOUND));
- }
+ required = true) String id)
+ throws EntityNotFoundException {
+ Policy policy = policies.getPolicy(id);
+
+ return a1ClientFactory.createA1Client(policy.ric()) //
+ .flatMap(client -> client.getPolicyStatus(policy)) //
+ .flatMap(status -> Mono.just(new ResponseEntity<>(status, HttpStatus.OK)))
+ .onErrorResume(this::handleException);
}
private void keepServiceAlive(String name) {
import java.util.ArrayList;
import java.util.List;
-import java.util.Optional;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyTypes;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
/**
* Example: http://localhost:8081/rics?managedElementId=kista_1
+ *
+ * @throws EntityNotFoundException
*/
@GetMapping("/ric")
@ApiOperation(value = "Returns the name of a RIC managing one Mananged Element")
})
public ResponseEntity<String> getRic( //
@ApiParam(name = "managedElementId", required = true, value = "The identity of the Managed Element") //
- @RequestParam(name = "managedElementId", required = true) String managedElementId) {
- Optional<Ric> ric = this.rics.lookupRicForManagedElement(managedElementId);
-
- if (ric.isPresent()) {
- return new ResponseEntity<>(ric.get().id(), HttpStatus.OK);
- } else {
- return new ResponseEntity<>("No RIC found", HttpStatus.NOT_FOUND);
- }
+ @RequestParam(name = "managedElementId", required = true) String managedElementId)
+ throws EntityNotFoundException {
+ Ric ric = this.rics.lookupRicForManagedElement(managedElementId);
+ return new ResponseEntity<>(ric.id(), HttpStatus.OK);
}
/**
import org.springframework.http.ResponseEntity;
import reactor.core.publisher.Mono;
-class ErrorResponse {
+public class ErrorResponse {
private static Gson gson = new GsonBuilder() //
.create(); //
return new ResponseEntity<>(json, headers, code);
}
- static ResponseEntity<Object> create(Exception e, HttpStatus code) {
+ public static ResponseEntity<Object> create(Exception e, HttpStatus code) {
return create(e.toString(), code);
}
import org.onap.ccsdk.oran.a1policymanagementservice.clients.A1ClientFactory;
import org.onap.ccsdk.oran.a1policymanagementservice.controllers.VoidResponse;
-import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.ImmutablePolicy;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Lock.LockType;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Policies;
@ApiResponse(code = 200, message = "Policy type", response = PolicyTypeInfo.class), //
@ApiResponse(code = 404, message = "Policy type is not found", response = ErrorResponse.ErrorInfo.class)})
public ResponseEntity<Object> getPolicyType( //
- @PathVariable("policytype_id") String policyTypeId) {
- try {
- PolicyType type = policyTypes.getType(policyTypeId);
- PolicyTypeInfo info = new PolicyTypeInfo(type.schema());
- return new ResponseEntity<>(gson.toJson(info), HttpStatus.OK);
- } catch (ServiceException e) {
- return ErrorResponse.create(e, HttpStatus.NOT_FOUND);
- }
+ @PathVariable("policytype_id") String policyTypeId) throws EntityNotFoundException {
+ PolicyType type = policyTypes.getType(policyTypeId);
+ PolicyTypeInfo info = new PolicyTypeInfo(type.schema());
+ return new ResponseEntity<>(gson.toJson(info), HttpStatus.OK);
}
@GetMapping(path = Consts.V2_API_ROOT + "/policy-types", produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<Object> getPolicyTypes( //
@ApiParam(name = Consts.RIC_ID_PARAM, required = false,
value = "The identity of the Near-RT RIC to get types for.") //
- @RequestParam(name = Consts.RIC_ID_PARAM, required = false) String ricId) {
+ @RequestParam(name = Consts.RIC_ID_PARAM, required = false) String ricId) throws EntityNotFoundException {
if (ricId == null) {
Collection<PolicyType> types = this.policyTypes.getAll();
return new ResponseEntity<>(toPolicyTypeIdsJson(types), HttpStatus.OK);
} else {
- try {
- Collection<PolicyType> types = rics.getRic(ricId).getSupportedPolicyTypes();
- return new ResponseEntity<>(toPolicyTypeIdsJson(types), HttpStatus.OK);
- } catch (ServiceException e) {
- return ErrorResponse.create(e, HttpStatus.NOT_FOUND);
- }
+ Collection<PolicyType> types = rics.getRic(ricId).getSupportedPolicyTypes();
+ return new ResponseEntity<>(toPolicyTypeIdsJson(types), HttpStatus.OK);
}
}
@ApiResponse(code = 404, message = "Policy is not found", response = ErrorResponse.ErrorInfo.class)} //
)
public ResponseEntity<Object> getPolicy( //
- @PathVariable(name = Consts.POLICY_ID_PARAM, required = true) String id) {
- try {
- Policy p = policies.getPolicy(id);
- return new ResponseEntity<>(gson.toJson(toPolicyInfo(p)), HttpStatus.OK);
- } catch (ServiceException e) {
- return ErrorResponse.create(e, HttpStatus.NOT_FOUND);
- }
+ @PathVariable(name = Consts.POLICY_ID_PARAM, required = true) String id) throws EntityNotFoundException {
+ Policy p = policies.getPolicy(id);
+ return new ResponseEntity<>(gson.toJson(toPolicyInfo(p)), HttpStatus.OK);
}
@DeleteMapping(Consts.V2_API_ROOT + "/policies/{policy_id:.+}")
@ApiResponse(code = 423, message = "Near-RT RIC is not operational",
response = ErrorResponse.ErrorInfo.class)})
public Mono<ResponseEntity<Object>> deletePolicy( //
- @PathVariable(Consts.POLICY_ID_PARAM) String policyId) {
- try {
- Policy policy = policies.getPolicy(policyId);
- keepServiceAlive(policy.ownerServiceId());
- Ric ric = policy.ric();
- return ric.getLock().lock(LockType.SHARED) //
- .flatMap(notUsed -> assertRicStateIdle(ric)) //
- .flatMap(notUsed -> a1ClientFactory.createA1Client(policy.ric())) //
- .doOnNext(notUsed -> policies.remove(policy)) //
- .flatMap(client -> client.deletePolicy(policy)) //
- .doOnNext(notUsed -> ric.getLock().unlockBlocking()) //
- .doOnError(notUsed -> ric.getLock().unlockBlocking()) //
- .flatMap(notUsed -> Mono.just(new ResponseEntity<>(HttpStatus.NO_CONTENT)))
- .onErrorResume(this::handleException);
- } catch (ServiceException e) {
- return ErrorResponse.createMono(e, HttpStatus.NOT_FOUND);
- }
+ @PathVariable(Consts.POLICY_ID_PARAM) String policyId) throws EntityNotFoundException {
+ Policy policy = policies.getPolicy(policyId);
+ keepServiceAlive(policy.ownerServiceId());
+ Ric ric = policy.ric();
+ return ric.getLock().lock(LockType.SHARED) //
+ .flatMap(notUsed -> assertRicStateIdle(ric)) //
+ .flatMap(notUsed -> a1ClientFactory.createA1Client(policy.ric())) //
+ .doOnNext(notUsed -> policies.remove(policy)) //
+ .flatMap(client -> client.deletePolicy(policy)) //
+ .doOnNext(notUsed -> ric.getLock().unlockBlocking()) //
+ .doOnError(notUsed -> ric.getLock().unlockBlocking()) //
+ .flatMap(notUsed -> Mono.just(new ResponseEntity<>(HttpStatus.NO_CONTENT)))
+ .onErrorResume(this::handleException);
}
@PutMapping(path = Consts.V2_API_ROOT + "/policies", produces = MediaType.APPLICATION_JSON_VALUE)
@ApiResponse(code = 404, message = "Near-RT RIC or policy type is not found",
response = ErrorResponse.ErrorInfo.class) //
})
- public Mono<ResponseEntity<Object>> putPolicy(@RequestBody PolicyInfo policyInfo) {
+ public Mono<ResponseEntity<Object>> putPolicy(@RequestBody PolicyInfo policyInfo) throws EntityNotFoundException {
if (!policyInfo.validate()) {
return ErrorResponse.createMono("Missing required parameter in body", HttpStatus.BAD_REQUEST);
PolicyType type = policyTypes.get(policyInfo.policyTypeId);
keepServiceAlive(policyInfo.serviceId);
if (ric == null || type == null) {
- return ErrorResponse.createMono("Near-RT RIC or policy type not found", HttpStatus.NOT_FOUND);
+ throw new EntityNotFoundException("Near-RT RIC or policy type not found");
}
Policy policy = ImmutablePolicy.builder() //
.id(policyInfo.policyId) //
@RequestParam(name = Consts.RIC_ID_PARAM, required = false) String ric, //
@ApiParam(name = Consts.SERVICE_ID_PARAM, required = false,
value = "The identity of the service to get policies for.") //
- @RequestParam(name = Consts.SERVICE_ID_PARAM, required = false) String service) //
+ @RequestParam(name = Consts.SERVICE_ID_PARAM, required = false) String service)
+ throws EntityNotFoundException //
{
if ((type != null && this.policyTypes.get(type) == null)) {
- return ErrorResponse.create("Policy type not found", HttpStatus.NOT_FOUND);
+ throw new EntityNotFoundException("Policy type not found");
}
if ((ric != null && this.rics.get(ric) == null)) {
- return ErrorResponse.create("Near-RT RIC not found", HttpStatus.NOT_FOUND);
+ throw new EntityNotFoundException("Near-RT RIC not found");
}
String filteredPolicies = policiesToJson(filter(type, ric, service));
@RequestParam(name = Consts.RIC_ID_PARAM, required = false) String ricId, //
@ApiParam(name = Consts.SERVICE_ID_PARAM, required = false,
value = "The identity of the service to get policies for.") //
- @RequestParam(name = Consts.SERVICE_ID_PARAM, required = false) String serviceId) //
+ @RequestParam(name = Consts.SERVICE_ID_PARAM, required = false) String serviceId)
+ throws EntityNotFoundException //
{
if ((policyTypeId != null && this.policyTypes.get(policyTypeId) == null)) {
- return ErrorResponse.create("Policy type not found", HttpStatus.NOT_FOUND);
+ throw new EntityNotFoundException("Policy type not found");
}
if ((ricId != null && this.rics.get(ricId) == null)) {
- return ErrorResponse.create("Near-RT RIC not found", HttpStatus.NOT_FOUND);
+ throw new EntityNotFoundException("Near-RT RIC not found");
}
String policyIdsJson = toPolicyIdsJson(filter(policyTypeId, ricId, serviceId));
@ApiResponse(code = 404, message = "Policy is not found", response = ErrorResponse.ErrorInfo.class)} //
)
public Mono<ResponseEntity<Object>> getPolicyStatus( //
- @PathVariable(Consts.POLICY_ID_PARAM) String policyId) {
- try {
- Policy policy = policies.getPolicy(policyId);
-
- return a1ClientFactory.createA1Client(policy.ric()) //
- .flatMap(client -> client.getPolicyStatus(policy).onErrorResume(e -> Mono.just("{}"))) //
- .flatMap(status -> createPolicyStatus(policy, status)) //
- .onErrorResume(this::handleException);
- } catch (ServiceException e) {
- return ErrorResponse.createMono(e, HttpStatus.NOT_FOUND);
- }
+ @PathVariable(Consts.POLICY_ID_PARAM) String policyId) throws EntityNotFoundException {
+ Policy policy = policies.getPolicy(policyId);
+
+ return a1ClientFactory.createA1Client(policy.ric()) //
+ .flatMap(client -> client.getPolicyStatus(policy).onErrorResume(e -> Mono.just("{}"))) //
+ .flatMap(status -> createPolicyStatus(policy, status)) //
+ .onErrorResume(this::handleException);
+
}
private Mono<ResponseEntity<Object>> createPolicyStatus(Policy policy, String statusFromNearRic) {
PolicyStatusInfo info = new PolicyStatusInfo(policy.lastModified(), fromJson(statusFromNearRic));
String str = gson.toJson(info);
- return Mono.just(new ResponseEntity<>((Object) str, HttpStatus.OK));
+ return Mono.just(new ResponseEntity<>(str, HttpStatus.OK));
}
private void keepServiceAlive(String name) {
import java.util.ArrayList;
import java.util.List;
-import java.util.Optional;
-import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.InvalidRequestException;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.PolicyTypes;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Ric;
import org.onap.ccsdk.oran.a1policymanagementservice.repository.Rics;
/**
* Example: http://localhost:8081/v2/rics/ric?managed_element_id=kista_1
+ *
+ * @throws EntityNotFoundException
*/
@GetMapping(path = Consts.V2_API_ROOT + "/rics/ric", produces = MediaType.APPLICATION_JSON_VALUE)
@ApiOperation(value = GET_RIC_BRIEF, notes = GET_RIC_DETAILS)
@RequestParam(name = Consts.MANAGED_ELEMENT_ID_PARAM, required = false) String managedElementId,
@ApiParam(name = Consts.RIC_ID_PARAM, required = false,
value = "The identity of a Near-RT RIC to get information for.") //
- @RequestParam(name = Consts.RIC_ID_PARAM, required = false) String ricId) {
- try {
- if (managedElementId != null && ricId != null) {
- return ErrorResponse.create("Give one query parameter", HttpStatus.BAD_REQUEST);
- } else if (managedElementId != null) {
- Optional<Ric> ric = this.rics.lookupRicForManagedElement(managedElementId);
- if (ric.isPresent()) {
- return new ResponseEntity<>(gson.toJson(toRicInfo(ric.get())), HttpStatus.OK);
- } else {
- return ErrorResponse.create("No Near-RT RIC managing the ME is found", HttpStatus.NOT_FOUND);
- }
- } else if (ricId != null) {
- RicInfo info = toRicInfo(this.rics.getRic(ricId));
- return new ResponseEntity<>(gson.toJson(info), HttpStatus.OK);
- } else {
- return ErrorResponse.create("Give one query parameter", HttpStatus.BAD_REQUEST);
- }
- } catch (ServiceException e) {
- return ErrorResponse.create(e, HttpStatus.NOT_FOUND);
+ @RequestParam(name = Consts.RIC_ID_PARAM, required = false) String ricId)
+ throws EntityNotFoundException, InvalidRequestException {
+ if (managedElementId != null && ricId != null) {
+ throw new InvalidRequestException("Give one query parameter");
+ } else if (managedElementId != null) {
+ Ric ric = this.rics.lookupRicForManagedElement(managedElementId);
+ return new ResponseEntity<>(gson.toJson(toRicInfo(ric)), HttpStatus.OK);
+ } else if (ricId != null) {
+ RicInfo info = toRicInfo(this.rics.getRic(ricId));
+ return new ResponseEntity<>(gson.toJson(info), HttpStatus.OK);
+ } else {
+ throw new InvalidRequestException("Give one query parameter");
}
}
/**
* @return a Json array of all RIC data Example: http://localhost:8081/v2/ric
+ * @throws EntityNotFoundException
*/
@GetMapping(path = Consts.V2_API_ROOT + "/rics", produces = MediaType.APPLICATION_JSON_VALUE)
@ApiOperation(value = "Query Near-RT RIC information", notes = QUERY_RIC_INFO_DETAILS)
public ResponseEntity<Object> getRics( //
@ApiParam(name = Consts.POLICY_TYPE_ID_PARAM, required = false,
value = "The identity of a policy type. If given, all Near-RT RICs supporteing the policy type are returned") //
- @RequestParam(name = Consts.POLICY_TYPE_ID_PARAM, required = false) String supportingPolicyType
-
- ) {
+ @RequestParam(name = Consts.POLICY_TYPE_ID_PARAM, required = false) String supportingPolicyType)
+ throws EntityNotFoundException {
if ((supportingPolicyType != null) && (this.types.get(supportingPolicyType) == null)) {
- return ErrorResponse.create("Policy type not found", HttpStatus.NOT_FOUND);
+ throw new EntityNotFoundException("Policy type not found");
}
List<RicInfo> result = new ArrayList<>();
--- /dev/null
+/*-
+ * ========================LICENSE_START=================================
+ * ONAP : ccsdk oran
+ * ======================================================================
+ * Copyright (C) 2019-2020 Nordix Foundation. All rights reserved.
+ * ======================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================LICENSE_END===================================
+ */
+
+package org.onap.ccsdk.oran.a1policymanagementservice.exceptions;
+
+public class EntityNotFoundException extends ServiceException {
+
+ private static final long serialVersionUID = 1L;
+
+ public EntityNotFoundException(String message) {
+ super(message);
+ }
+
+ public EntityNotFoundException(String message, Exception originalException) {
+ super(message, originalException);
+ }
+}
--- /dev/null
+/*-
+ * ========================LICENSE_START=================================
+ * ONAP : ccsdk oran
+ * ======================================================================
+ * Copyright (C) 2019-2020 Nordix Foundation. All rights reserved.
+ * ======================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================LICENSE_END===================================
+ */
+
+package org.onap.ccsdk.oran.a1policymanagementservice.exceptions;
+
+import org.onap.ccsdk.oran.a1policymanagementservice.controllers.v2.ErrorResponse;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
+
+@ControllerAdvice(annotations = RestController.class)
+public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
+
+ @ExceptionHandler(EntityNotFoundException.class)
+ public final ResponseEntity<Object> handleNotFoundException(EntityNotFoundException ex) {
+ return ErrorResponse.create(ex, HttpStatus.NOT_FOUND);
+ }
+
+ @ExceptionHandler(InvalidRequestException.class)
+ public final ResponseEntity<Object> handleInvalidRequestException(InvalidRequestException ex) {
+ return ErrorResponse.create(ex, HttpStatus.BAD_REQUEST);
+ }
+}
--- /dev/null
+/*-
+ * ========================LICENSE_START=================================
+ * ONAP : ccsdk oran
+ * ======================================================================
+ * Copyright (C) 2019-2020 Nordix Foundation. All rights reserved.
+ * ======================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ========================LICENSE_END===================================
+ */
+
+package org.onap.ccsdk.oran.a1policymanagementservice.exceptions;
+
+public class InvalidRequestException extends ServiceException {
+
+ private static final long serialVersionUID = 1L;
+
+ public InvalidRequestException(String message) {
+ super(message);
+ }
+
+ public InvalidRequestException(String message, Exception originalException) {
+ super(message, originalException);
+ }
+}
import java.util.Set;
import java.util.Vector;
-import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
public class Policies {
private Map<String, Policy> policiesId = new HashMap<>();
return policiesId.get(id);
}
- public synchronized Policy getPolicy(String id) throws ServiceException {
+ public synchronized Policy getPolicy(String id) throws EntityNotFoundException {
Policy p = policiesId.get(id);
if (p == null) {
- throw new ServiceException("Could not find policy: " + id);
+ throw new EntityNotFoundException("Could not find policy: " + id);
}
return p;
}
import java.util.Map;
import java.util.Vector;
-import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
public class PolicyTypes {
private Map<String, PolicyType> types = new HashMap<>();
- public synchronized PolicyType getType(String name) throws ServiceException {
+ public synchronized PolicyType getType(String name) throws EntityNotFoundException {
PolicyType t = types.get(name);
if (t == null) {
- throw new ServiceException("Could not find type: " + name);
+ throw new EntityNotFoundException("Could not find type: " + name);
}
return t;
}
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
-import java.util.Optional;
import java.util.Vector;
-import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.ServiceException;
+import org.onap.ccsdk.oran.a1policymanagementservice.exceptions.EntityNotFoundException;
import org.springframework.lang.Nullable;
/**
return new Vector<>(registeredRics.values());
}
- public synchronized Ric getRic(String ricId) throws ServiceException {
+ public synchronized Ric getRic(String ricId) throws EntityNotFoundException {
Ric ric = registeredRics.get(ricId);
if (ric == null) {
- throw new ServiceException("Could not find ric: " + ricId);
+ throw new EntityNotFoundException("Could not find ric: " + ricId);
}
return ric;
}
this.registeredRics.clear();
}
- public synchronized Optional<Ric> lookupRicForManagedElement(String managedElementId) {
+ public synchronized Ric lookupRicForManagedElement(String managedElementId) throws EntityNotFoundException {
for (Ric ric : this.registeredRics.values()) {
if (ric.getManagedElementIds().contains(managedElementId)) {
- return Optional.of(ric);
+ return ric;
}
}
- return Optional.empty();
+ throw new EntityNotFoundException("No Near-RT RIC managing the ME is found");
}
}
Code Review / ccsdk / oran.git / commitdiff