2 * ========================LICENSE_START=================================
5 * Copyright (C) 2019 Nordix Foundation
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ========================LICENSE_END===================================
20 package org.oransc.ric.portal.dashboard.controller;
22 import java.lang.invoke.MethodHandles;
23 import java.util.List;
24 import javax.servlet.http.HttpServletResponse;
25 import org.oransc.ric.a1controller.client.api.A1ControllerApi;
26 import org.oransc.ric.a1controller.client.model.InputNRRidPTidPIidPISchema;
27 import org.oransc.ric.a1controller.client.model.InputNRRidPTidPIidPISchemaInput;
28 import org.oransc.ric.a1controller.client.model.InputNRRidPTidPIidSchema;
29 import org.oransc.ric.a1controller.client.model.InputNRRidPTidPIidSchemaInput;
30 import org.oransc.ric.a1controller.client.model.InputNRRidPTidSchema;
31 import org.oransc.ric.a1controller.client.model.InputNRRidPTidSchemaInput;
32 import org.oransc.ric.a1controller.client.model.InputNRRidSchema;
33 import org.oransc.ric.a1controller.client.model.InputNRRidSchemaInput;
34 import org.oransc.ric.a1controller.client.model.OutputCodeSchema;
35 import org.oransc.ric.a1controller.client.model.OutputDescNamePTCodeSchema;
36 import org.oransc.ric.a1controller.client.model.OutputDescNamePTCodeSchemaOutput;
37 import org.oransc.ric.a1controller.client.model.OutputPICodeSchema;
38 import org.oransc.ric.a1controller.client.model.OutputPIidsListCodeSchema;
39 import org.oransc.ric.a1controller.client.model.OutputPTidsListCodeSchema;
40 import org.oransc.ric.portal.dashboard.DashboardApplication;
41 import org.oransc.ric.portal.dashboard.DashboardConstants;
42 import org.oransc.ric.portal.dashboard.exceptions.HttpBadRequestException;
43 import org.oransc.ric.portal.dashboard.exceptions.HttpInternalServerErrorException;
44 import org.oransc.ric.portal.dashboard.exceptions.HttpNotFoundException;
45 import org.oransc.ric.portal.dashboard.exceptions.HttpNotImplementedException;
46 import org.oransc.ric.portal.dashboard.model.PolicyInstance;
47 import org.oransc.ric.portal.dashboard.model.PolicyInstances;
48 import org.oransc.ric.portal.dashboard.model.PolicyType;
49 import org.oransc.ric.portal.dashboard.model.PolicyTypes;
50 import org.oransc.ric.portal.dashboard.model.SuccessTransport;
51 import org.slf4j.Logger;
52 import org.slf4j.LoggerFactory;
53 import org.springframework.beans.factory.annotation.Autowired;
54 import org.springframework.http.HttpStatus;
55 import org.springframework.http.MediaType;
56 import org.springframework.security.access.annotation.Secured;
57 import org.springframework.util.Assert;
58 import org.springframework.web.bind.annotation.DeleteMapping;
59 import org.springframework.web.bind.annotation.GetMapping;
60 import org.springframework.web.bind.annotation.PathVariable;
61 import org.springframework.web.bind.annotation.PutMapping;
62 import org.springframework.web.bind.annotation.RequestBody;
63 import org.springframework.web.bind.annotation.RequestMapping;
64 import org.springframework.web.bind.annotation.RestController;
65 import io.swagger.annotations.ApiOperation;
68 * Proxies calls from the front end to the A1 Controller via the A1 Mediator
71 * If a method throws RestClientResponseException, it is handled by
72 * {@link CustomResponseEntityExceptionHandler#handleProxyMethodException(Exception,
73 * org.springframework.web.context.request.WebRequest)}
74 * which returns status 502. All other exceptions are handled by Spring which
78 @RequestMapping(value = A1Controller.CONTROLLER_PATH, produces = MediaType.APPLICATION_JSON_VALUE)
79 public class A1Controller {
81 private static final String NEAR_RT_RIC_ID = "NearRtRic1";
83 private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass());
85 // Publish paths in constants so tests are easy to write
86 public static final String CONTROLLER_PATH = DashboardConstants.ENDPOINT_PREFIX + "/policy";
88 public static final String VERSION_METHOD = DashboardConstants.VERSION_METHOD;
89 public static final String POLICY_TYPES_METHOD = "policytypes";
90 public static final String POLICY_TYPE_ID_NAME = "policy_type_id";
91 public static final String POLICIES_NAME = "policies";
92 public static final String POLICY_INSTANCE_ID_NAME = "policy_instance_id";
94 // Populated by the autowired constructor
95 private final A1ControllerApi a1ControllerApi;
98 public A1Controller(final A1ControllerApi A1ControllerApi) {
99 Assert.notNull(A1ControllerApi, "API must not be null");
100 this.a1ControllerApi = A1ControllerApi;
101 if (logger.isDebugEnabled())
102 logger.debug("ctor: configured with client type {}", A1ControllerApi.getClass().getName());
105 @ApiOperation(value = "Gets the A1 client library MANIFEST.MF property Implementation-Version.",
106 response = SuccessTransport.class)
107 @GetMapping(VERSION_METHOD)
109 public SuccessTransport getA1ControllerClientVersion() {
110 return new SuccessTransport(200, DashboardApplication.getImplementationVersion(A1ControllerApi.class));
114 * The fields are defined in the A1Control Typescript interface.
116 @ApiOperation(value = "Gets the policy types from Near Realtime-RIC via the A1 Controller API")
117 @GetMapping(POLICY_TYPES_METHOD)
118 @Secured({ DashboardConstants.ROLE_ADMIN, DashboardConstants.ROLE_STANDARD })
119 public Object getAllPolicyTypes(HttpServletResponse response) {
120 logger.debug("getAllPolicyTypes");
121 InputNRRidSchemaInput nrrid = new InputNRRidSchemaInput();
122 nrrid.setNearRtRicId(NEAR_RT_RIC_ID);
123 InputNRRidSchema inputSchema = new InputNRRidSchema();
124 inputSchema.setInput(nrrid);
125 OutputPTidsListCodeSchema outputPTidsListCodeSchema =
126 a1ControllerApi.a1ControllerGetAllPolicyTypes(inputSchema);
127 checkHttpError(outputPTidsListCodeSchema.getOutput().getCode());
128 List<Integer> policyTypeIds = outputPTidsListCodeSchema.getOutput().getPolicyTypeIdList();
129 PolicyTypes policyTypes = new PolicyTypes();
130 InputNRRidPTidSchema typeSchema = new InputNRRidPTidSchema();
131 InputNRRidPTidSchemaInput typeId = new InputNRRidPTidSchemaInput();
132 typeId.setNearRtRicId(NEAR_RT_RIC_ID);
133 for (Integer policyTypeId : policyTypeIds) {
134 typeId.setPolicyTypeId(policyTypeId);
135 typeSchema.setInput(typeId);
136 OutputDescNamePTCodeSchema controllerGetPolicyType =
137 a1ControllerApi.a1ControllerGetPolicyType(typeSchema);
138 checkHttpError(controllerGetPolicyType.getOutput().getCode());
139 OutputDescNamePTCodeSchemaOutput policyTypeSchema = controllerGetPolicyType.getOutput();
140 PolicyType type = new PolicyType(policyTypeId, policyTypeSchema.getName(),
141 policyTypeSchema.getPolicyType().toString());
142 policyTypes.add(type);
147 @ApiOperation(value = "Returns the policy instances for the given policy type.")
148 @GetMapping(POLICY_TYPES_METHOD + "/{" + POLICY_TYPE_ID_NAME + "}/" + POLICIES_NAME)
149 @Secured({ DashboardConstants.ROLE_ADMIN, DashboardConstants.ROLE_STANDARD })
150 public Object getPolicyInstances(@PathVariable(POLICY_TYPE_ID_NAME) String policyTypeIdString) {
151 logger.debug("getPolicyInstances {}", policyTypeIdString);
152 InputNRRidPTidSchemaInput typeIdInput = new InputNRRidPTidSchemaInput();
153 typeIdInput.setNearRtRicId(NEAR_RT_RIC_ID);
154 Integer policyTypeId = Integer.decode(policyTypeIdString);
155 typeIdInput.setPolicyTypeId(policyTypeId);
156 InputNRRidPTidSchema inputSchema = new InputNRRidPTidSchema();
157 inputSchema.setInput(typeIdInput);
158 OutputPIidsListCodeSchema controllerGetAllInstancesForType =
159 a1ControllerApi.a1ControllerGetAllInstancesForType(inputSchema);
160 checkHttpError(controllerGetAllInstancesForType.getOutput().getCode());
161 List<String> instancesForType = controllerGetAllInstancesForType.getOutput().getPolicyInstanceIdList();
162 PolicyInstances instances = new PolicyInstances();
163 InputNRRidPTidPIidSchemaInput instanceIdInput = new InputNRRidPTidPIidSchemaInput();
164 instanceIdInput.setNearRtRicId(NEAR_RT_RIC_ID);
165 instanceIdInput.setPolicyTypeId(policyTypeId);
166 InputNRRidPTidPIidSchema instanceInputSchema = new InputNRRidPTidPIidSchema();
167 for (String instanceId : instancesForType) {
168 instanceIdInput.setPolicyInstanceId(instanceId);
169 instanceInputSchema.setInput(instanceIdInput);
170 OutputPICodeSchema policyInstance =
171 a1ControllerApi.a1ControllerGetPolicyInstance(instanceInputSchema);
172 checkHttpError(policyInstance.getOutput().getCode());
173 PolicyInstance instance =
174 new PolicyInstance(instanceId, policyInstance.getOutput().getPolicyInstance());
175 instances.add(instance);
180 @ApiOperation(value = "Returns a policy instance of a type")
181 @GetMapping(POLICY_TYPES_METHOD + "/{" + POLICY_TYPE_ID_NAME + "}/" + POLICIES_NAME + "/{"
182 + POLICY_INSTANCE_ID_NAME + "}")
183 @Secured({ DashboardConstants.ROLE_ADMIN, DashboardConstants.ROLE_STANDARD })
184 public Object getPolicyInstance(@PathVariable(POLICY_TYPE_ID_NAME) String policyTypeIdString,
185 @PathVariable(POLICY_INSTANCE_ID_NAME) String policyInstanceId) {
186 logger.debug("getPolicyInstance {}:{}", policyTypeIdString, policyInstanceId);
187 InputNRRidPTidPIidSchemaInput instanceIdInput = new InputNRRidPTidPIidSchemaInput();
188 instanceIdInput.setNearRtRicId(NEAR_RT_RIC_ID);
189 instanceIdInput.setPolicyTypeId(Integer.decode(policyTypeIdString));
190 instanceIdInput.setPolicyInstanceId(policyInstanceId);
191 InputNRRidPTidPIidSchema inputSchema = new InputNRRidPTidPIidSchema();
192 inputSchema.setInput(instanceIdInput);
193 OutputPICodeSchema policyInstance = a1ControllerApi.a1ControllerGetPolicyInstance(inputSchema);
194 checkHttpError(policyInstance.getOutput().getCode());
195 return policyInstance.getOutput().getPolicyInstance();
198 @ApiOperation(value = "Creates the policy instances for the given policy type.")
199 @PutMapping(POLICY_TYPES_METHOD + "/{" + POLICY_TYPE_ID_NAME + "}/" + POLICIES_NAME + "/{"
200 + POLICY_INSTANCE_ID_NAME + "}")
201 @Secured({ DashboardConstants.ROLE_ADMIN })
202 public void putPolicyInstance(@PathVariable(POLICY_TYPE_ID_NAME) String policyTypeIdString,
203 @PathVariable(POLICY_INSTANCE_ID_NAME) String policyInstanceId, @RequestBody String instance) {
204 logger.debug("putPolicyInstance typeId: {}, instanceId: {}, instance: {}", policyTypeIdString,
205 policyInstanceId, instance);
206 InputNRRidPTidPIidPISchemaInput createInstanceInput = new InputNRRidPTidPIidPISchemaInput();
207 createInstanceInput.setNearRtRicId(NEAR_RT_RIC_ID);
208 createInstanceInput.setPolicyTypeId(Integer.decode(policyTypeIdString));
209 createInstanceInput.setPolicyInstanceId(policyInstanceId);
210 createInstanceInput.setPolicyInstance(instance);
211 InputNRRidPTidPIidPISchema inputSchema = new InputNRRidPTidPIidPISchema();
212 inputSchema.setInput(createInstanceInput);
213 OutputCodeSchema outputCodeSchema = a1ControllerApi.a1ControllerCreatePolicyInstance(inputSchema);
214 checkHttpError(outputCodeSchema.getOutput().getCode());
217 @ApiOperation(value = "Deletes the policy instances for the given policy type.")
218 @DeleteMapping(POLICY_TYPES_METHOD + "/{" + POLICY_TYPE_ID_NAME + "}/" + POLICIES_NAME + "/{"
219 + POLICY_INSTANCE_ID_NAME + "}")
220 @Secured({ DashboardConstants.ROLE_ADMIN })
221 public void deletePolicyInstance(@PathVariable(POLICY_TYPE_ID_NAME) String policyTypeIdString,
222 @PathVariable(POLICY_INSTANCE_ID_NAME) String policyInstanceId) {
223 logger.debug("deletePolicyInstance typeId: {}, instanceId: {}", policyTypeIdString, policyInstanceId);
224 InputNRRidPTidPIidSchemaInput instanceIdInput = new InputNRRidPTidPIidSchemaInput();
225 instanceIdInput.setNearRtRicId(NEAR_RT_RIC_ID);
226 instanceIdInput.setPolicyTypeId(Integer.decode(policyTypeIdString));
227 instanceIdInput.setPolicyInstanceId(policyInstanceId);
228 InputNRRidPTidPIidSchema inputSchema = new InputNRRidPTidPIidSchema();
229 inputSchema.setInput(instanceIdInput);
230 OutputCodeSchema outputCodeSchema = a1ControllerApi.a1ControllerDeletePolicyInstance(inputSchema);
231 checkHttpError(outputCodeSchema.getOutput().getCode());
234 private void checkHttpError(String httpCode) {
235 logger.debug("Http Response Code: {}", httpCode);
236 if (httpCode.equals(String.valueOf(HttpStatus.NOT_FOUND.value()))) {
237 logger.error("Caught HttpNotFoundException");
238 throw new HttpNotFoundException("Not Found Exception");
239 } else if (httpCode.equals(String.valueOf(HttpStatus.BAD_REQUEST.value()))) {
240 logger.error("Caught HttpBadRequestException");
241 throw new HttpBadRequestException("Bad Request Exception");
242 } else if (httpCode.equals(String.valueOf(HttpStatus.INTERNAL_SERVER_ERROR.value()))) {
243 logger.error("Caught HttpInternalServerErrorException");
244 throw new HttpInternalServerErrorException("Internal Server Error Exception");
245 } else if (httpCode.equals(String.valueOf(HttpStatus.NOT_IMPLEMENTED.value()))) {
246 logger.error("Caught HttpNotImplementedException");
247 throw new HttpNotImplementedException("Not Implemented Exception");