near-rt-ric-simulator/nearric-simulator/nearric-service/src/main/java/org/onap/nearric/simulator/service/A1PApiServiceImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019 Nordix Foundation.
   4  * ================================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *      http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  * SPDX-License-Identifier: Apache-2.0
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.onap.nearric.simulator.service;
  22
  23 import java.io.File;
  24 import java.io.FileInputStream;
  25 import java.io.FileOutputStream;
  26 import java.io.IOException;
  27 import java.io.ObjectInputStream;
  28 import java.io.ObjectOutputStream;
  29 import java.lang.reflect.InvocationTargetException;
  30 import java.util.HashMap;
  31 import java.util.Iterator;
  32 import java.util.List;
  33 import java.util.Set;
  34
  35 import javax.servlet.http.HttpServletRequest;
  36
  37 import org.apache.commons.beanutils.BeanUtils;
  38 import org.onap.nearric.simulator.model.PolicyType;
  39 import org.onap.nearric.simulator.model.PolicyInstance;
  40 import org.oransc.ric.a1med.api.model.PolicyTypeSchema;
  41 import org.oransc.ric.a1med.api.model.InlineResponse200;
  42
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45 import org.springframework.beans.factory.annotation.Autowired;
  46 import org.springframework.http.HttpStatus;
  47 import org.springframework.http.ResponseEntity;
  48 import org.springframework.stereotype.Service;
  49
  50 import com.fasterxml.jackson.core.JsonParseException;
  51 import com.fasterxml.jackson.core.JsonParser;
  52 import com.fasterxml.jackson.databind.JsonNode;
  53 import com.fasterxml.jackson.databind.ObjectMapper;
  54 import com.github.fge.jackson.JsonLoader;
  55 import com.github.fge.jsonschema.core.exceptions.ProcessingException;
  56 import com.github.fge.jsonschema.core.report.ProcessingMessage;
  57 import com.github.fge.jsonschema.core.report.ProcessingReport;
  58 import com.github.fge.jsonschema.main.JsonSchema;
  59 import com.github.fge.jsonschema.main.JsonSchemaFactory;
  60
  61 import com.fasterxml.jackson.databind.ObjectMapper;
  62
  63 /**
  64  * This class provides the service implementation of all the A1 operation
  65  *
  66  * @author lathishbabu.ganesan@est.tech
  67  *
  68  */
  69
  70 @Service
  71 public class A1PApiServiceImpl { // implements A1PApiService {
  72
  73         private static final Logger log = LoggerFactory.getLogger(A1PApiServiceImpl.class);
  74
  75         private HashMap<String, PolicyType> policyTypes = new HashMap<String, PolicyType>();
  76
  77         private ObjectMapper objectMapper = null;
  78
  79         private HttpServletRequest request = null;
  80
  81         public boolean validateSchema(String jsonData, String jsonSchema) {
  82                 ProcessingReport report = null;
  83                 boolean result = false;
  84                 try {
  85                         System.out.println("Applying schema: @<@<" + jsonSchema + ">@>@ to data: #<#<" + jsonData + ">#>#");
  86                         JsonNode schemaNode = JsonLoader.fromString(jsonSchema);
  87                         JsonNode data = JsonLoader.fromString(jsonData);
  88                         JsonSchemaFactory factory = JsonSchemaFactory.byDefault();
  89                         JsonSchema schema = factory.getJsonSchema(schemaNode);
  90                         report = schema.validate(data);
  91                 } catch (JsonParseException jpex) {
  92                         System.out.println("Error. Something went wrong trying to parse json data: #<#<" + jsonData
  93                                         + ">#># or json schema: @<@<" + jsonSchema + ">@>@. Are the double quotes included? "
  94                                         + jpex.getMessage());
  95                         // jpex.printStackTrace();
  96                 } catch (ProcessingException pex) {
  97                         System.out.println("Error. Something went wrong trying to process json data: #<#<" + jsonData
  98                                         + ">#># with json schema: @<@<" + jsonSchema + ">@>@ " + pex.getMessage());
  99                         // pex.printStackTrace();
 100                 } catch (IOException e) {
 101                         System.out.println("Error. Something went wrong trying to read json data: #<#<" + jsonData
 102                                         + ">#># or json schema: @<@<" + jsonSchema + ">@>@");
 103                         // e.printStackTrace();
 104                 }
 105                 if (report != null) {
 106                         Iterator<ProcessingMessage> iter = report.iterator();
 107                         while (iter.hasNext()) {
 108                                 ProcessingMessage pm = iter.next();
 109                                 System.out.println("Processing Message: " + pm.getMessage());
 110                         }
 111                         result = report.isSuccess();
 112                 }
 113                 System.out.println(" Result=" + result);
 114                 return result;
 115         }
 116
 117         public A1PApiServiceImpl() {
 118         }
 119
 120         public void set(ObjectMapper objectMapper, HttpServletRequest request) {
 121                 this.objectMapper = objectMapper;
 122                 this.request = request;
 123         }
 124
 125
 126         public ResponseEntity<Void> createReplaceType(Integer policyTypeId, PolicyTypeSchema body) {
 127
 128                         System.out.println("createReplaceType - policyTypeId: " + policyTypeId);
 129                         System.out.println("createReplaceType - body: " + body);
 130
 131                         String accept = request.getHeader("Accept");
 132
 133                         if (body != null && body.getName() != null) {
 134                                 if (body.getPolicyTypeId().intValue() != policyTypeId.intValue()) {
 135                                         System.out.println("createReplaceType - policytype mismatch between request and body");
 136                                         return new ResponseEntity<Void>(HttpStatus.BAD_REQUEST);
 137                                 }
 138
 139                                 if (policyTypes.containsKey(policyTypeId.toString())) {
 140                                         System.out.println("createReplaceType - policytype already exists");
 141                                         return new ResponseEntity<Void>(HttpStatus.BAD_REQUEST);
 142                                 }
 143
 144                                 PolicyType policyType = new PolicyType(policyTypeId, body);
 145                                 policyTypes.put(policyTypeId.toString(), policyType);
 146                         }
 147                         System.out.println("createReplaceType - created ok");
 148                         return new ResponseEntity<Void>(HttpStatus.CREATED);
 149
 150         }
 151
 152         public ResponseEntity<Void> deleteType(Integer policyTypeId) {
 153
 154                         System.out.println("deleteType - policyTypeId: " + policyTypeId);
 155
 156                         String accept = request.getHeader("Accept");
 157
 158                         PolicyType policyType = policyTypes.get(policyTypeId.toString());
 159
 160                         if (policyType == null) {
 161                                 System.out.println("deleteType - policytype does not exists");
 162                                 return new ResponseEntity<Void>(HttpStatus.NOT_FOUND);
 163                         }
 164
 165                         if (policyType.getNumberInstances() > 0) {
 166                                 System.out.println("deleteType - cannot delete, instances exists");
 167                                 return new ResponseEntity<Void>(HttpStatus.BAD_REQUEST);
 168                         }
 169                         policyTypes.remove(policyTypeId.toString());
 170
 171                         System.out.println("deleteType - deleted ok");
 172                         return new ResponseEntity<Void>(HttpStatus.NO_CONTENT);
 173         }
 174
 175         public ResponseEntity<Void> deleteInstance(Integer policyTypeId, String policyInstanceId) {
 176
 177                         System.out.println("deleteInstance - policyTypeId: " + policyTypeId);
 178                         System.out.println("deleteInstance - policyInstanceId: " + policyInstanceId);
 179
 180                         PolicyType policyType = policyTypes.get(policyTypeId.toString());
 181
 182                         if (policyType == null) {
 183                                 System.out.println("deleteType - policytype does not exists");
 184                                 return new ResponseEntity<Void>(HttpStatus.NOT_FOUND);
 185                         }
 186                         PolicyInstance policyInstance = policyType.getInstance(policyInstanceId);
 187                         if (policyInstance == null) {
 188                                 System.out.println("deleteType - instance does not exists");
 189                                 return new ResponseEntity<Void>(HttpStatus.NOT_FOUND);
 190                         }
 191                         policyType.delete(policyInstanceId);
 192
 193                         System.out.println("deleteInstance - deleted ok");
 194                         return new ResponseEntity<Void>(HttpStatus.NO_CONTENT);
 195
 196         }
 197
 198         public ResponseEntity<PolicyTypeSchema> getPolicyTypeSchema(Integer policyTypeId) {
 199                 System.out.println("getPolicyTypeSchema - policyTypeId: " + policyTypeId);
 200                 String accept = request.getHeader("Accept");
 201                 if (accept != null && accept.contains("application/json")) {
 202                         String res = null;
 203                         try {
 204                                 PolicyType policyType = policyTypes.get(policyTypeId.toString());
 205
 206                                 if (policyType == null) {
 207                                         System.out.println("getPolicyTypeSchema - policytype does not exists");
 208                                         return new ResponseEntity<PolicyTypeSchema>(HttpStatus.NOT_FOUND);
 209                                 }
 210
 211                                 String json = "{}";
 212                                 PolicyTypeSchema schema = policyType.getSchema();
 213                                 String createSchema = "{}";
 214                                 try {
 215                                         // Convert Map to JSON
 216                                         json = objectMapper.writeValueAsString(schema);
 217                                         // Print JSON output
 218                                         System.out.println("getPolicyTypeSchema - schema: " + json);
 219
 220                                         createSchema = objectMapper.writeValueAsString(schema.getCreateSchema());
 221                                         System.out.println("getPolicyTypeSchema - createSchema: " + createSchema);
 222                                 } catch (Exception e) {
 223                                         e.printStackTrace();
 224                                         System.out.println("getPolicyTypeSchema - schema corrupt");
 225                                         return new ResponseEntity<PolicyTypeSchema>(HttpStatus.INTERNAL_SERVER_ERROR);
 226                                 }
 227                                 res = "{\n  \"name\" : \"" + schema.getName() + "\",\n  \"description\" : \"" + schema.getDescription()
 228                                                 + "\",\n  \"create_schema\" : " + createSchema + ",\n  \"policy_type_id\" : "
 229                                                 + schema.getPolicyTypeId().intValue() + "\n}";
 230                                 System.out.println("getPolicyTypeSchema - json schema: " + res);
 231                                 objectMapper.configure(JsonParser.Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
 232                                 return new ResponseEntity<PolicyTypeSchema>(objectMapper.readValue(res, PolicyTypeSchema.class),
 233                                                 HttpStatus.ACCEPTED);
 234                         } catch (Exception e) {
 235                                 e.printStackTrace();
 236                                 System.out
 237                                                 .println("getPolicyTypeSchema - Couldn't serialize response for content type application/json");
 238                                 return new ResponseEntity<PolicyTypeSchema>(HttpStatus.INTERNAL_SERVER_ERROR);
 239                         }
 240                 }
 241                 System.out.println("getPolicyTypeSchema - not implemented");
 242                 return new ResponseEntity<PolicyTypeSchema>(HttpStatus.NOT_IMPLEMENTED);
 243         }
 244
 245         public ResponseEntity<List<Integer>> getAllTypes() {
 246                 System.out.println("getAllTypes");
 247                 String accept = request.getHeader("Accept");
 248                 if (accept != null && accept.contains("application/json")) {
 249                         try {
 250                                 Set<String> types = policyTypes.keySet();
 251                                 String res = "";
 252                                 for (Iterator<String> iterator = types.iterator(); iterator.hasNext();) {
 253                                         String tid = (String) iterator.next();
 254                                         if (res.length() > 0) {
 255                                                 res = res + ",";
 256                                         }
 257                                         res = res + tid;
 258                                 }
 259                                 return new ResponseEntity<List<Integer>>(objectMapper.readValue("[" + res + "]", List.class),
 260                                                 HttpStatus.ACCEPTED);
 261                         } catch (IOException e) {
 262                                 e.printStackTrace();
 263                                 System.out.println("getAllTypes - Couldn't serialize response for content type application/json");
 264                                 return new ResponseEntity<List<Integer>>(HttpStatus.INTERNAL_SERVER_ERROR);
 265                         }
 266                 }
 267                 System.out.println("getAllTypes - not implemented");
 268                 return new ResponseEntity<List<Integer>>(HttpStatus.NOT_IMPLEMENTED);
 269         }
 270
 271         public ResponseEntity<Void> createReplaceInstance(Integer policyTypeId, String policyInstanceId, Object body) {
 272                         System.out.println("createReplaceInstance -  policyTypeId:" + policyTypeId);
 273                         System.out.println("createReplaceInstance -  policyInstanceId:" + policyInstanceId);
 274                         System.out.println("createReplaceInstance -  body:" + body);
 275                         System.out.println("createReplaceInstance -  bodyclass:" + body.getClass().toString());
 276
 277                         String accept = request.getHeader("Accept");
 278
 279                         PolicyType policyType = policyTypes.get(policyTypeId.toString());
 280
 281                         if (policyType == null) {
 282                                 System.out.println("createReplaceInstance - policytype does not exists");
 283                                 return new ResponseEntity<Void>(HttpStatus.NOT_FOUND);
 284                         }
 285
 286                         // Create json string from schema
 287                         String createSchema = null;
 288                         try {
 289                                 PolicyTypeSchema schema = policyType.getSchema();
 290                                 // Convert Map to JSON
 291                                 String json = objectMapper.writeValueAsString(schema);
 292                                 // Print JSON output
 293                                 System.out.println("createReplaceInstance - schema - json: " + json);
 294                                 createSchema = objectMapper.writeValueAsString(schema.getCreateSchema());
 295                                 System.out.println("createReplaceInstance - createSchema - string: " + createSchema);
 296                         } catch (Exception e) {
 297                                 e.printStackTrace();
 298                                 System.out.println("createReplaceInstance - schema corrupt");
 299                                 return new ResponseEntity<Void>(HttpStatus.INTERNAL_SERVER_ERROR);
 300                         }
 301
 302                         // Create json string from instance
 303                         String jsonInstance = null;
 304                         try {
 305                                 System.out.println("createReplaceInstance - raw: " + body);
 306                                 // Convert Map to JSON
 307                                 jsonInstance = objectMapper.writeValueAsString(body);
 308                                 // Print JSON output
 309                                 System.out.println("createReplaceInstance - instance: " + jsonInstance);
 310
 311                         } catch (Exception e) {
 312                                 e.printStackTrace();
 313                                 System.out.println("createReplaceInstance - instancce corrupt");
 314                                 return new ResponseEntity<Void>(HttpStatus.INTERNAL_SERVER_ERROR);
 315                         }
 316
 317                         if (!validateSchema(jsonInstance, createSchema)) {
 318                                 System.out.println("createReplaceInstance - schema validation failed");
 319                                 return new ResponseEntity<Void>(HttpStatus.BAD_REQUEST);
 320                         }
 321                         PolicyInstance policyInstance = new PolicyInstance(policyInstanceId, body);
 322                         policyType.createReplaceInstance(policyInstanceId, policyInstance);
 323
 324                         System.out.println("createReplaceInstance - created/replaced ok");
 325                         return new ResponseEntity<Void>(HttpStatus.CREATED);
 326
 327         }
 328
 329         public ResponseEntity<List<String>> getAllInstanceForType(Integer policyTypeId) {
 330                 System.out.println("getAllInstanceForType -  policyTypeId:" + policyTypeId);
 331
 332                 String accept = request.getHeader("Accept");
 333                 if (accept != null && accept.contains("application/json")) {
 334                         try {
 335                                 PolicyType policyType = policyTypes.get(policyTypeId.toString());
 336                                 if (policyType == null) {
 337                                         System.out.println("getAllInstanceForType - policytype does not exists");
 338                                         return new ResponseEntity<List<String>>(HttpStatus.NOT_FOUND);
 339                                 }
 340                                 Set<String> instances = policyType.getInstances();
 341                                 String res = "";
 342                                 for (Iterator iterator = instances.iterator(); iterator.hasNext();) {
 343                                         String iid = (String) iterator.next();
 344                                         iid = "\"" + iid + "\"";
 345                                         if (res.length() > 0) {
 346                                                 res = res + ",";
 347                                         }
 348                                         res = res + iid;
 349                                 }
 350                                 System.out.println("getAllInstanceForType - " + res);
 351                                 return new ResponseEntity<List<String>>(objectMapper.readValue("[" + res + "]", List.class),
 352                                                 HttpStatus.ACCEPTED);
 353                         } catch (IOException e) {
 354                                 e.printStackTrace();
 355                                 System.out.println(
 356                                                 "getAllInstanceForType - Couldn't serialize response for content type application/json");
 357                                 return new ResponseEntity<List<String>>(HttpStatus.INTERNAL_SERVER_ERROR);
 358                         }
 359                 }
 360                 System.out.println("getAllInstanceForType - not implemented");
 361                 return new ResponseEntity<List<String>>(HttpStatus.NOT_IMPLEMENTED);
 362
 363         }
 364
 365         public ResponseEntity<Object> getPolicyInstance(Integer policyTypeId, String policyInstanceId) {
 366                 System.out.println("getPolicyInstance -  policyTypeId:" + policyTypeId);
 367                 System.out.println("getPolicyInstance -  policyInstanceId:" + policyInstanceId);
 368
 369                 String accept = request.getHeader("Accept");
 370                 if (accept != null && accept.contains("application/json")) {
 371                         try {
 372                                 PolicyType policyType = policyTypes.get(policyTypeId.toString());
 373                                 if (policyType == null) {
 374                                         System.out.println("getPolicyInstance - policytype does not exists");
 375                                         return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
 376                                 }
 377                                 PolicyInstance policyInstance = policyType.getInstance(policyInstanceId);
 378                                 if (policyInstance == null) {
 379                                         System.out.println("getPolicyInstance - policyinstance does not exists");
 380                                         return new ResponseEntity<Object>(HttpStatus.NOT_FOUND);
 381                                 }
 382
 383                                 String json = "{}";
 384                                 try {
 385                                         System.out.println("getPolicyInstance - rawschema: " + policyInstance.getJson());
 386                                         // Convert Map to JSON
 387                                         json = objectMapper.writeValueAsString(policyInstance.getJson());
 388                                         // Print JSON output
 389                                         System.out.println("getPolicyInstance - schema: " + json);
 390
 391                                 } catch (Exception e) {
 392                                         e.printStackTrace();
 393                                         System.out.println("getPolicyInstance - schema corrupt");
 394                                         return new ResponseEntity<Object>(HttpStatus.INTERNAL_SERVER_ERROR);
 395                                 }
 396
 397                                 return new ResponseEntity<Object>(objectMapper.readValue(json, Object.class), HttpStatus.ACCEPTED);
 398                         } catch (IOException e) {
 399                                 e.printStackTrace();
 400                                 System.out.println("getPolicyInstance - policyinstance corrupt");
 401                                 return new ResponseEntity<Object>(HttpStatus.INTERNAL_SERVER_ERROR);
 402                         }
 403                 }
 404
 405                 return new ResponseEntity<Object>(HttpStatus.NOT_IMPLEMENTED);
 406         }
 407
 408         public ResponseEntity<List<InlineResponse200>> getStatus(Integer policyTypeId, String policyInstanceId) {
 409                 System.out.println("getStatus -  policyTypeId:" + policyTypeId);
 410                 System.out.println("getStatus -  policyInstanceId:" + policyInstanceId);
 411
 412                 String accept = request.getHeader("Accept");
 413                 if (accept != null && accept.contains("application/json")) {
 414                         try {
 415                                 PolicyType policyType = policyTypes.get(policyTypeId.toString());
 416                                 if (policyType == null) {
 417                                         System.out.println("getStatus - policytype does not exists");
 418                                         return new ResponseEntity<List<InlineResponse200>>(HttpStatus.NOT_FOUND);
 419                                 }
 420                                 PolicyInstance policyInstance = policyType.getInstance(policyInstanceId);
 421                                 if (policyInstance == null) {
 422                                         System.out.println("getStatus - policyinstance does not exists");
 423                                         return new ResponseEntity<List<InlineResponse200>>(HttpStatus.NOT_FOUND);
 424                                 }
 425
 426
 427                                 return new ResponseEntity<List<InlineResponse200>>(
 428                                                 objectMapper.readValue("[ {\n  \"handler_id\" : \"X-APP-1\",\n  \"status\" : \"enforced\"\n} ]",
 429                                                                 List.class),
 430                                                 HttpStatus.ACCEPTED);
 431                         } catch (IOException e) {
 432                                 e.printStackTrace();
 433                                 System.out.println("getStatus - Couldn't serialize response for content type application/json");
 434                                 return new ResponseEntity<List<InlineResponse200>>(HttpStatus.INTERNAL_SERVER_ERROR);
 435                         }
 436                 }
 437
 438                 return new ResponseEntity<List<InlineResponse200>>(HttpStatus.NOT_IMPLEMENTED);
 439         }
 440
 441 }