2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
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.onap.policy.pdp.rest.api.controller;
22 import io.swagger.annotations.Api;
23 import io.swagger.annotations.ApiImplicitParam;
24 import io.swagger.annotations.ApiImplicitParams;
25 import io.swagger.annotations.ApiOperation;
27 import java.lang.reflect.InvocationTargetException;
28 import java.util.Collection;
29 import java.util.concurrent.atomic.AtomicLong;
31 import javax.servlet.http.HttpServletRequest;
33 import org.onap.policy.api.ConfigRequestParameters;
34 import org.onap.policy.api.DecisionRequestParameters;
35 import org.onap.policy.api.DecisionResponse;
36 import org.onap.policy.api.DeletePolicyParameters;
37 import org.onap.policy.api.DictionaryParameters;
38 import org.onap.policy.api.DictionaryResponse;
39 import org.onap.policy.api.EventRequestParameters;
40 import org.onap.policy.api.MetricsResponse;
41 import org.onap.policy.api.PolicyParameters;
42 import org.onap.policy.api.PolicyResponse;
43 import org.onap.policy.api.PushPolicyParameters;
44 import org.onap.policy.common.logging.flexlogger.FlexLogger;
45 import org.onap.policy.common.logging.flexlogger.Logger;
46 import org.onap.policy.pdp.rest.XACMLPdpServlet;
47 import org.onap.policy.pdp.rest.api.models.ConfigFirewallPolicyAPIRequest;
48 import org.onap.policy.pdp.rest.api.models.ConfigNameRequest;
49 import org.onap.policy.pdp.rest.api.models.ConfigPolicyAPIRequest;
50 import org.onap.policy.pdp.rest.api.models.PolicyConfig;
51 import org.onap.policy.pdp.rest.api.services.CreateUpdateConfigPolicyService;
52 import org.onap.policy.pdp.rest.api.services.CreateUpdateDictionaryService;
53 import org.onap.policy.pdp.rest.api.services.CreateUpdateFirewallPolicyService;
54 import org.onap.policy.pdp.rest.api.services.CreateUpdatePolicyService;
55 import org.onap.policy.pdp.rest.api.services.DeletePolicyService;
56 import org.onap.policy.pdp.rest.api.services.GetConfigService;
57 import org.onap.policy.pdp.rest.api.services.GetDecisionService;
58 import org.onap.policy.pdp.rest.api.services.GetDictionaryService;
59 import org.onap.policy.pdp.rest.api.services.GetMetricsService;
60 import org.onap.policy.pdp.rest.api.services.ListConfigService;
61 import org.onap.policy.pdp.rest.api.services.NotificationService;
62 import org.onap.policy.pdp.rest.api.services.NotificationService.NotificationServiceType;
63 import org.onap.policy.pdp.rest.api.services.PolicyEngineImportService;
64 import org.onap.policy.pdp.rest.api.services.PushPolicyService;
65 import org.onap.policy.pdp.rest.api.services.SendEventService;
66 import org.onap.policy.pdp.rest.config.PDPApiAuth;
67 import org.springframework.http.HttpStatus;
68 import org.springframework.http.ResponseEntity;
69 import org.springframework.http.converter.HttpMessageNotReadableException;
70 import org.springframework.web.bind.annotation.ExceptionHandler;
71 import org.springframework.web.bind.annotation.RequestBody;
72 import org.springframework.web.bind.annotation.RequestHeader;
73 import org.springframework.web.bind.annotation.RequestMapping;
74 import org.springframework.web.bind.annotation.RequestMethod;
75 import org.springframework.web.bind.annotation.RequestParam;
76 import org.springframework.web.bind.annotation.ResponseBody;
77 import org.springframework.web.bind.annotation.RestController;
78 import org.springframework.web.multipart.MultipartFile;
80 import springfox.documentation.annotations.ApiIgnore;
83 @Api(value = "Policy Engine Services")
85 public class PolicyEngineServices {
86 private static Logger logger = FlexLogger.getLogger(PolicyEngineServices.class.getName());
87 private static final String NOTIFICATIONPERM = "notification";
89 private final AtomicLong configCounter = new AtomicLong();
90 private final AtomicLong configNameCounter = new AtomicLong();
91 private final AtomicLong eventCounter = new AtomicLong();
92 private final AtomicLong decisionCounter = new AtomicLong();
93 private final AtomicLong pushCounter = new AtomicLong();
94 private final AtomicLong deleteCounter = new AtomicLong();
95 private final AtomicLong createPolicyCounter = new AtomicLong();
96 private final AtomicLong updatePolicyCounter = new AtomicLong();
97 private final AtomicLong createDictionaryCounter = new AtomicLong();
98 private final AtomicLong updateDictionaryCounter = new AtomicLong();
99 private final AtomicLong getDictionaryCounter = new AtomicLong();
100 private final AtomicLong policyEngineImportCounter = new AtomicLong();
101 private final AtomicLong deprecatedCounter = new AtomicLong();
102 private final AtomicLong metricCounter = new AtomicLong();
103 private final AtomicLong notificationCounter = new AtomicLong();
106 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
107 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
108 @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP)")
109 @RequestMapping(value = "/getConfig", method = RequestMethod.POST)
111 public ResponseEntity<Collection<PolicyConfig>> getConfig(
112 @RequestBody ConfigRequestParameters configRequestParameters,
113 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
114 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
115 Collection<PolicyConfig> policyConfig = null;
116 HttpStatus status = HttpStatus.UNAUTHORIZED;
117 // Check Permissions.
118 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "getConfig")) {
119 GetConfigService getConfigService = new GetConfigService(
120 configRequestParameters, requestID);
121 policyConfig = getConfigService.getResult();
122 status = getConfigService.getResponseCode();
124 configCounter.incrementAndGet();
125 return new ResponseEntity<>(policyConfig, status);
129 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
130 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
131 @ApiOperation(value = "Gets the configuration from the PolicyDecisionPoint(PDP) using PolicyName")
132 @RequestMapping(value = "/getConfigByPolicyName", method = RequestMethod.POST)
135 public ResponseEntity<Collection<PolicyConfig>> getConfigByPolicyName(
136 @RequestBody ConfigNameRequest configNameRequest,
137 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
138 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
139 Collection<PolicyConfig> policyConfig = null;
140 HttpStatus status = HttpStatus.UNAUTHORIZED;
141 // Check Permissions.
142 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,"getConfigByPolicyName")) {
143 ConfigRequestParameters configRequestParameters = new ConfigRequestParameters();
144 configRequestParameters.setPolicyName(configNameRequest
146 GetConfigService getConfigService = new GetConfigService(
147 configRequestParameters, requestID);
148 policyConfig = getConfigService.getResult();
149 status = getConfigService.getResponseCode();
151 configNameCounter.incrementAndGet();
152 return new ResponseEntity<>(policyConfig, status);
156 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
157 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
158 @ApiOperation(value = "Gets the list of configuration policies from the PDP")
159 @RequestMapping(value = "/listConfig", method = RequestMethod.POST)
161 public ResponseEntity<Collection<String>> listConfig(
162 @RequestBody ConfigRequestParameters configRequestParameters,
163 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
164 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
165 Collection<String> results = null;
166 HttpStatus status = HttpStatus.UNAUTHORIZED;
167 // Check Permissions.
169 .checkPermissions(clientEncoding, requestID, "listConfig")) {
170 ListConfigService listConfigService = new ListConfigService(
171 configRequestParameters, requestID);
172 results = listConfigService.getResult();
173 status = listConfigService.getResponseCode();
175 configCounter.incrementAndGet();
176 return new ResponseEntity<>(results, status);
180 @ApiImplicitParam(name ="Authorization", required = true, paramType = "Header"),
181 @ApiImplicitParam(name ="Environment", required = true, paramType = "Header")
183 @ApiOperation(value= "Gets the policy metrics from the PolicyAccessPoint(PAP)")
184 @RequestMapping(value="/getMetrics", method=RequestMethod.GET)
186 public ResponseEntity<MetricsResponse> getMetrics(
187 @RequestHeader(value="ClientAuth", required=true)String clientEncoding,
188 @RequestHeader(value="X-ECOMP-RequestID", required=false)String requestID) {
189 MetricsResponse response = null;
190 HttpStatus status = HttpStatus.UNAUTHORIZED;
191 // Check Permissions.
192 if(PDPApiAuth.checkPermissions(clientEncoding, requestID, "getMetrics")){
193 GetMetricsService getMetricsService = new GetMetricsService(requestID);
194 response = getMetricsService.getResult();
195 status = getMetricsService.getResponseCode();
197 metricCounter.incrementAndGet();
198 return new ResponseEntity<>(response, status);
202 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
203 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
204 @ApiOperation(value = "Registers DMaaP Topic to recieve notification from Policy Engine")
205 @RequestMapping(value = "/getNotification", method = RequestMethod.POST)
207 public ResponseEntity<String> getNotification(
208 @RequestBody String notificationTopic,
209 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
210 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
211 String policyResponse = "Error Unauthorized to use Notification Service.";
212 HttpStatus status = HttpStatus.UNAUTHORIZED;
213 // Check Permissions.
214 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
215 NotificationService notificationService = new NotificationService(notificationTopic, requestID, NotificationServiceType.ADD);
216 policyResponse = notificationService.getResult();
217 status = notificationService.getResponseCode();
219 notificationCounter.incrementAndGet();
220 return new ResponseEntity<>(policyResponse, status);
224 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
225 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
226 @ApiOperation(value = "De-Registers DMaaP Topic to stop recieving notifications from Policy Engine")
227 @RequestMapping(value = "/stopNotification", method = RequestMethod.POST)
229 public ResponseEntity<String> stopNotification(
230 @RequestBody String notificationTopic,
231 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
232 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
233 String policyResponse = "Error Unauthorized to use Notification Service.";
234 HttpStatus status = HttpStatus.UNAUTHORIZED;
235 // Check Permissions.
236 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
237 NotificationService notificationService = new NotificationService(notificationTopic, requestID, NotificationServiceType.REMOVE);
238 policyResponse = notificationService.getResult();
239 status = notificationService.getResponseCode();
241 notificationCounter.incrementAndGet();
242 return new ResponseEntity<>(policyResponse, status);
246 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
247 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
248 @ApiOperation(value = "Sends Heartbeat to DMaaP Topic Registry to continue recieving notifications from Policy Engine")
249 @RequestMapping(value = "/sendHeartbeat", method = RequestMethod.POST)
251 public ResponseEntity<String> sendHeartbeat(
252 @RequestBody String notificationTopic,
253 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
254 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
255 String policyResponse = "Error Unauthorized to use Heartbeat Service.";
256 HttpStatus status = HttpStatus.UNAUTHORIZED;
257 // Check Permissions.
258 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, NOTIFICATIONPERM)) {
259 NotificationService notificationService = new NotificationService(notificationTopic, requestID, NotificationServiceType.HB);
260 policyResponse = notificationService.getResult();
261 status = notificationService.getResponseCode();
263 return new ResponseEntity<>(policyResponse, status);
267 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
268 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
269 @ApiOperation(value = "Sends the Events specified to the Policy Engine")
270 @RequestMapping(value = "/sendEvent", method = RequestMethod.POST)
272 public ResponseEntity<Collection<PolicyResponse>> sendEvent(
273 @RequestBody EventRequestParameters eventRequestParameters,
274 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
275 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
276 Collection<PolicyResponse> policyResponse = null;
277 HttpStatus status = HttpStatus.UNAUTHORIZED;
278 // Check Permissions.
279 if (PDPApiAuth.checkPermissions(clientEncoding, requestID, "sendEvent")) {
280 SendEventService sendEventService = new SendEventService(
281 eventRequestParameters, requestID);
282 policyResponse = sendEventService.getResult();
283 status = sendEventService.getResponseCode();
285 eventCounter.incrementAndGet();
286 return new ResponseEntity<>(policyResponse,
291 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
292 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
293 @ApiOperation(value = "Gets the Decision using specified decision parameters")
294 @RequestMapping(value = "/getDecision", method = RequestMethod.POST)
296 public ResponseEntity<DecisionResponse> getDecision(
297 @RequestBody DecisionRequestParameters decisionRequestParameters,
298 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
299 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
300 DecisionResponse decisionResponse = null;
301 HttpStatus status = HttpStatus.UNAUTHORIZED;
302 // Check Permissions.
303 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
305 GetDecisionService getDecisionService = new GetDecisionService(
306 decisionRequestParameters, requestID);
307 decisionResponse = getDecisionService.getResult();
308 status = getDecisionService.getResponseCode();
310 decisionCounter.incrementAndGet();
311 return new ResponseEntity<>(decisionResponse, status);
315 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
316 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
317 @ApiOperation(value = "Pushes the specified policy to the PDP Group.")
318 @RequestMapping(value = "/pushPolicy", method = RequestMethod.PUT)
320 public ResponseEntity<String> pushPolicy(
321 @RequestBody PushPolicyParameters pushPolicyParameters,
322 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
323 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
324 String response = null;
325 HttpStatus status = HttpStatus.UNAUTHORIZED;
326 // Check Permissions.
328 .checkPermissions(clientEncoding, requestID, "pushPolicy")) {
329 PushPolicyService pushPolicyService = new PushPolicyService(
330 pushPolicyParameters, requestID);
331 response = pushPolicyService.getResult();
332 status = pushPolicyService.getResponseCode();
334 pushCounter.incrementAndGet();
335 return new ResponseEntity<>(response, status);
339 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
340 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
341 @ApiOperation(value = "Deletes the specified policy from the PDP Group or PAP.")
342 @RequestMapping(value = "/deletePolicy", method = RequestMethod.DELETE)
344 public ResponseEntity<String> deletePolicy(
345 @RequestBody DeletePolicyParameters deletePolicyParameters,
346 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
347 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
348 String response = null;
349 HttpStatus status = HttpStatus.UNAUTHORIZED;
350 // Check Permissions.
351 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
353 DeletePolicyService deletePolicyService = new DeletePolicyService(
354 deletePolicyParameters, requestID);
355 response = deletePolicyService.getResult();
356 status = deletePolicyService.getResponseCode();
358 deleteCounter.incrementAndGet();
359 return new ResponseEntity<>(response, status);
363 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
364 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
365 @ApiOperation(value = "Creates a Policy based on given Policy Parameters.")
366 @RequestMapping(value = "/createPolicy", method = RequestMethod.PUT)
368 public ResponseEntity<String> createPolicy(
369 @RequestBody PolicyParameters policyParameters,
370 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
371 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
372 String response = null;
373 HttpStatus status = HttpStatus.UNAUTHORIZED;
374 // Check Permissions.
375 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
377 CreateUpdatePolicyService createPolicyService;
379 createPolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor().newInstance(
380 policyParameters, requestID, false);
381 response = createPolicyService.getResult();
382 status = createPolicyService.getResponseCode();
383 } catch (InstantiationException | IllegalAccessException
384 | IllegalArgumentException | InvocationTargetException e) {
385 logger.error(e.getMessage(), e);
386 response = "Problem with CreateUpdate Policy Service. ";
387 status = HttpStatus.INTERNAL_SERVER_ERROR;
390 createPolicyCounter.incrementAndGet();
391 return new ResponseEntity<>(response, status);
395 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
396 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
397 @ApiOperation(value = "Updates a Policy based on given Policy Parameters.")
398 @RequestMapping(value = "/updatePolicy", method = RequestMethod.PUT)
400 public ResponseEntity<String> updatePolicy(
401 @RequestBody PolicyParameters policyParameters,
402 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
403 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
404 String response = null;
405 HttpStatus status = HttpStatus.UNAUTHORIZED;
406 // Check Permissions.
407 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
409 CreateUpdatePolicyService updatePolicyService;
411 updatePolicyService = (CreateUpdatePolicyService) XACMLPdpServlet.getCreateUpdatePolicyConstructor().newInstance(
412 policyParameters, requestID, true);
413 response = updatePolicyService.getResult();
414 status = updatePolicyService.getResponseCode();
415 } catch (InstantiationException | IllegalAccessException
416 | IllegalArgumentException | InvocationTargetException e) {
417 logger.error(e.getMessage(), e);
418 response = "Problem with CreateUpdate Policy Service. ";
419 status = HttpStatus.INTERNAL_SERVER_ERROR;
422 updatePolicyCounter.incrementAndGet();
423 return new ResponseEntity<>(response, status);
427 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
428 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
429 @ApiOperation(value = "Creates a Dictionary Item for a specific dictionary based on given Parameters.")
430 @RequestMapping(value = "/createDictionaryItem", method = RequestMethod.PUT)
432 public ResponseEntity<String> createDictionaryItem(
433 @RequestBody DictionaryParameters dictionaryParameters,
434 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
435 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
436 String response = null;
437 HttpStatus status = HttpStatus.UNAUTHORIZED;
438 // Check Permissions.
439 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
440 "createDictionary")) {
441 CreateUpdateDictionaryService createDictionaryService = new CreateUpdateDictionaryService(
442 dictionaryParameters, requestID, false);
443 response = createDictionaryService.getResult();
444 status = createDictionaryService.getResponseCode();
446 createDictionaryCounter.incrementAndGet();
447 return new ResponseEntity<>(response, status);
451 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
452 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
453 @ApiOperation(value = "Updates a Dictionary Item for a specific dictionary based on given Parameters.")
454 @RequestMapping(value = "/updateDictionaryItem", method = RequestMethod.PUT)
456 public ResponseEntity<String> updateDictionaryItem(
457 @RequestBody DictionaryParameters dictionaryParameters,
458 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
459 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
460 String response = null;
461 HttpStatus status = HttpStatus.UNAUTHORIZED;
462 // Check Permissions.
463 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
464 "updateDictionary")) {
465 CreateUpdateDictionaryService updateDictionaryService = new CreateUpdateDictionaryService(
466 dictionaryParameters, requestID, true);
467 response = updateDictionaryService.getResult();
468 status = updateDictionaryService.getResponseCode();
470 updateDictionaryCounter.incrementAndGet();
471 return new ResponseEntity<>(response, status);
475 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
476 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
477 @ApiOperation(value = "Gets the dictionary items from the PAP")
478 @RequestMapping(value = "/getDictionaryItems", method = RequestMethod.POST)
480 public ResponseEntity<DictionaryResponse> getDictionaryItems(
481 @RequestBody DictionaryParameters dictionaryParameters,
482 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
483 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
484 DictionaryResponse dictionaryResponse = null;
485 HttpStatus status = HttpStatus.UNAUTHORIZED;
486 // Check Permissions.
487 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
489 GetDictionaryService getDictionaryService = new GetDictionaryService(
490 dictionaryParameters, requestID);
491 dictionaryResponse = getDictionaryService.getResult();
492 status = getDictionaryService.getResponseCode();
494 getDictionaryCounter.incrementAndGet();
495 return new ResponseEntity<>(dictionaryResponse,
500 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
501 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
502 @ApiOperation(value = "Imports Policy based on the parameters which represent the service used to create a policy Service.")
503 @RequestMapping(value = "/policyEngineImport", method = RequestMethod.POST)
505 public ResponseEntity<String> policyEngineImport(
506 @RequestParam("importParametersJson") String importParametersJson,
507 @RequestParam("file") MultipartFile file,
508 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
509 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
510 String response = null;
511 HttpStatus status = HttpStatus.UNAUTHORIZED;
512 // Check Permissions.
513 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
514 "policyEngineImport")) {
515 PolicyEngineImportService policyEngineImportService = new PolicyEngineImportService(
516 importParametersJson, file, requestID);
517 response = policyEngineImportService.getResult();
518 status = policyEngineImportService.getResponseCode();
520 policyEngineImportCounter.incrementAndGet();
521 return new ResponseEntity<>(response, status);
525 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
526 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
527 @ApiOperation(value = "Creates a Config Policy based on given Policy Parameters.")
528 @RequestMapping(value = "/createConfig", method = RequestMethod.PUT)
531 public ResponseEntity<String> createConfig(
532 @RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
533 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
534 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
535 String response = null;
536 HttpStatus status = HttpStatus.UNAUTHORIZED;
537 // Check Permissions.
538 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
540 CreateUpdateConfigPolicyService createPolicyService = new CreateUpdateConfigPolicyService(
541 configPolicyAPIRequest, requestID, false);
542 response = createPolicyService.getResult();
543 status = createPolicyService.getResponseCode();
545 deprecatedCounter.incrementAndGet();
546 return new ResponseEntity<>(response, status);
550 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
551 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
552 @ApiOperation(value = "Updates a Config Policy based on given Policy Parameters.")
553 @RequestMapping(value = "/updateConfig", method = RequestMethod.PUT)
556 public ResponseEntity<String> updateConfig(
557 @RequestBody ConfigPolicyAPIRequest configPolicyAPIRequest,
558 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
559 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
560 String response = null;
561 HttpStatus status = HttpStatus.UNAUTHORIZED;
562 // Check Permissions.
563 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
565 CreateUpdateConfigPolicyService updatePolicyService = new CreateUpdateConfigPolicyService(
566 configPolicyAPIRequest, requestID, true);
567 response = updatePolicyService.getResult();
568 status = updatePolicyService.getResponseCode();
570 deprecatedCounter.incrementAndGet();
571 return new ResponseEntity<>(response, status);
575 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
576 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
577 @ApiOperation(value = "Creates a Config Firewall Policy")
578 @RequestMapping(value = "/createFirewallConfig", method = RequestMethod.PUT)
581 public ResponseEntity<String> createFirewallConfig(
582 @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
583 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
584 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
585 String response = null;
586 HttpStatus status = HttpStatus.UNAUTHORIZED;
587 // Check Permissions.
588 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
590 CreateUpdateFirewallPolicyService createFirewallPolicyService = new CreateUpdateFirewallPolicyService(
591 configFirewallPolicyAPIRequest, requestID, false);
592 response = createFirewallPolicyService.getResult();
593 status = createFirewallPolicyService.getResponseCode();
595 deprecatedCounter.incrementAndGet();
596 return new ResponseEntity<>(response, status);
600 @ApiImplicitParam(name = "Authorization", required = true, paramType = "Header"),
601 @ApiImplicitParam(name = "Environment", required = true, paramType = "Header") })
602 @ApiOperation(value = "Updates a Config Firewall Policy")
603 @RequestMapping(value = "/updateFirewallConfig", method = RequestMethod.PUT)
606 public ResponseEntity<String> updateFirewallConfig(
607 @RequestBody ConfigFirewallPolicyAPIRequest configFirewallPolicyAPIRequest,
608 @RequestHeader(value = "ClientAuth", required = true) String clientEncoding,
609 @RequestHeader(value = "X-ECOMP-RequestID", required = false) String requestID) {
610 String response = null;
611 HttpStatus status = HttpStatus.UNAUTHORIZED;
612 // Check Permissions.
613 if (PDPApiAuth.checkPermissions(clientEncoding, requestID,
615 CreateUpdateFirewallPolicyService updateFirewallPolicyService = new CreateUpdateFirewallPolicyService(
616 configFirewallPolicyAPIRequest, requestID, true);
617 response = updateFirewallPolicyService.getResult();
618 status = updateFirewallPolicyService.getResponseCode();
620 deprecatedCounter.incrementAndGet();
621 return new ResponseEntity<>(response, status);
624 @ApiOperation(value = "Gets the API Services usage Information")
626 @RequestMapping(value = "/count", method = RequestMethod.GET)
627 public String getCount() {
628 return "Total Config Calls : " + configCounter + "\n"
629 + "Total Config calls made using Policy File Name: "
630 + configNameCounter + "\n" + "Total Event Calls : "
631 + eventCounter + "\nTotal Decision Calls: " + decisionCounter
632 + "\nTotal Push policy Calls: " + pushCounter
633 + "\nTotal Delete Policy Calls: " + deleteCounter
634 + "\nTotal Create Policy Calls: " + createPolicyCounter
635 + "\nTotal Update Policy Calls: " + updatePolicyCounter
636 + "\nTotal Create Dictionary Calls: " + createDictionaryCounter
637 + "\nTotal Update Dictionary Calls: " + updateDictionaryCounter
638 + "\nTotal Get Dictionary Calls: " + getDictionaryCounter
639 + "\nTotal PolicyEngine Import Calls: "
640 + policyEngineImportCounter
641 + "\nTotal Deprecated Policy Calls: " + deprecatedCounter
642 + "\nTotal Metrics Calls:" + metricCounter
643 + "\nTotal Notification Calls:" + notificationCounter;
646 @ExceptionHandler({ HttpMessageNotReadableException.class })
647 public ResponseEntity<String> messageNotReadableExceptionHandler(
648 HttpServletRequest req, HttpMessageNotReadableException exception) {
649 logger.error("Request not readable: {}", exception);
650 StringBuilder message = new StringBuilder();
651 message.append(exception.getMessage());
652 if (exception.getCause() != null) {
653 message.append(" Reason Caused: "
654 + exception.getCause().getMessage());
656 return new ResponseEntity<>(message.toString(), HttpStatus.BAD_REQUEST);