ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/service/ImportService.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   4  * ================================================================================
   5  * Copyright (C) 2017-2018 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
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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=========================================================
  19  */
  20 package org.onap.policy.pap.xacml.rest.service;
  21
  22 import java.io.BufferedWriter;
  23 import java.io.File;
  24 import java.io.FileOutputStream;
  25 import java.io.IOException;
  26 import java.io.InputStream;
  27 import java.io.OutputStreamWriter;
  28 import java.io.Writer;
  29 import java.util.HashMap;
  30 import java.util.Map;
  31 import java.util.UUID;
  32
  33 import javax.servlet.http.HttpServletRequest;
  34 import javax.servlet.http.HttpServletResponse;
  35
  36 import org.onap.policy.common.logging.eelf.PolicyLogger;
  37 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  38 import org.onap.policy.common.logging.flexlogger.Logger;
  39 import org.onap.policy.pap.xacml.rest.components.CreateBRMSRuleTemplate;
  40 import org.onap.policy.pap.xacml.rest.components.CreateNewMicroServiceModel;
  41 import org.onap.policy.pap.xacml.rest.components.CreateNewOptimizationModel;
  42
  43 public class ImportService {
  44         private static final Logger logger = FlexLogger.getLogger(ImportService.class);
  45         private static String errorMessage = "Error in reading in file from API call";
  46         private static String errorMsg  = "error";
  47         private static String operation = "operation";
  48         private static String importHeader = "import";
  49         private static String service = "service";
  50         private static String extractDir = "ExtractDir";
  51         private static String successMessage = "success";
  52         private static String invalidServiceName = "Invalid ServiceName";
  53         private static final String REGEX = "[0-9a-zA-Z._ ]*";
  54         private static final String MISSING = "missing";
  55
  56         public void doImportMicroServicePut(HttpServletRequest request, HttpServletResponse response) {
  57                 String importServiceCreation = request.getParameter("importService");
  58                 String fileName = request.getParameter("fileName");
  59                 String version = request.getParameter("version");
  60                 String serviceName = request.getParameter("serviceName");
  61
  62                 if(serviceName == null || serviceName.isEmpty() || !serviceName.matches(REGEX)){
  63                         response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
  64                         response.addHeader(errorMsg, MISSING);
  65                         response.addHeader(operation, importHeader);
  66                         response.addHeader(service, invalidServiceName);
  67                         return;
  68                 }
  69
  70                 String description = request.getParameter("description");
  71                 Map<String, String> successMap = new HashMap<>();
  72                 if(("BRMSPARAM").equals(importServiceCreation)){
  73                         StringBuilder builder = new StringBuilder();
  74                         int ch;
  75                         try {
  76                                 while((ch = request.getInputStream().read()) != -1){
  77                                     builder.append((char)ch);
  78                                 }
  79                         } catch (IOException e) {
  80                                 logger.error(e);
  81                                 PolicyLogger.error(errorMessage);
  82                                 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
  83                                 response.addHeader(errorMsg, MISSING);
  84                                 response.addHeader(operation, importHeader);
  85                                 response.addHeader(service, serviceName);
  86                         }
  87                         CreateBRMSRuleTemplate brmsRuleTemplate = new CreateBRMSRuleTemplate();
  88                         successMap = brmsRuleTemplate.addRule(builder.toString(), serviceName, description, "API");
  89                 }
  90                 else if(("MICROSERVICE").equals(importServiceCreation)){
  91                         CreateNewMicroServiceModel newMS = null;
  92                         String randomID = UUID.randomUUID().toString();
  93                         String type = ".xmi";
  94                         if ( fileName != null) {
  95                                 File extracDir = new File(extractDir);
  96                                 if (!extracDir.exists()){
  97                                         extracDir.mkdirs();
  98                                 }
  99                                 if (fileName.contains(".xmi") || fileName.contains(".yml")){
 100                                         if(fileName.contains(".yml")){
 101                                                 type = ".yml";
 102                                         }
 103                                         // get the request content into a String
 104                                         String xmi = null;
 105                                         java.util.Scanner scanner;
 106                                         try {
 107                                                 scanner = new java.util.Scanner(request.getInputStream());
 108                                                 scanner.useDelimiter("\\A");
 109                                                 xmi =  scanner.hasNext() ? scanner.next() : "";
 110                                                 scanner.close();
 111                                         } catch (IOException e1) {
 112                                                 logger.error(e1);
 113                                                 PolicyLogger.error(errorMessage);
 114                                                 return;
 115                                         }
 116                                         PolicyLogger.info("Request from API to import new Service");
 117                                         try (Writer writer = new BufferedWriter(new OutputStreamWriter(
 118                                                         new FileOutputStream(extractDir + File.separator + randomID+type), "utf-8"))) {
 119                                                 writer.write(xmi);
 120                                         } catch (IOException e) {
 121                                                 logger.error(e);
 122                                                 PolicyLogger.error(errorMessage);
 123                                                 return;
 124                                         }
 125                                 }else{
 126                                         InputStream inputStream = null;
 127                                         try(FileOutputStream outputStream = new FileOutputStream(extractDir + File.separator + randomID+".zip")) {
 128                                                 inputStream = request.getInputStream();
 129                                                 byte[] buffer = new byte[4096];
 130                                                 int bytesRead = -1 ;
 131                                                 while ((bytesRead = inputStream.read(buffer)) != -1) {
 132                                                         outputStream.write(buffer, 0, bytesRead) ;
 133                                                 }
 134                                         } catch (IOException e) {
 135                                                 PolicyLogger.error("Error in reading in Zip File from API call"+e);
 136                                                 return;
 137                                         }finally{
 138                                                 try {
 139                                                         if(inputStream != null){
 140                                                                 inputStream.close();
 141                                                         }
 142                                                 } catch (IOException e) {
 143                                                         PolicyLogger.error("Exception Occured while closing the input/output stream"+e);
 144                                                 }
 145                                         }
 146                                 }
 147
 148                                 newMS =  new CreateNewMicroServiceModel(fileName, serviceName, "API", version, randomID);
 149
 150                                 successMap = newMS.addValuesToNewModel(type);
 151
 152                                 if (successMap.containsKey(successMessage)) {
 153                                         successMap.clear();
 154                                         successMap = newMS.saveImportService();
 155                                 }
 156                         }
 157                 } else if(("OPTIMIZATION").equals(importServiceCreation)){
 158                         CreateNewOptimizationModel newOOF = null;
 159                         String randomID = UUID.randomUUID().toString();
 160                         if ( fileName != null) {
 161                                 File extracDir = new File(extractDir);
 162                                 if (!extracDir.exists()){
 163                                         extracDir.mkdirs();
 164                                 }
 165
 166                                 String type = ".yml";
 167
 168                                 // get the request content into a String
 169                                 String yml = null;
 170                                 try (java.util.Scanner scanner = new java.util.Scanner(request.getInputStream());){
 171                                         scanner.useDelimiter("\\A");
 172                                         yml =  scanner.hasNext() ? scanner.next() : "";
 173                                 } catch (IOException e1) {
 174                                         logger.error(e1);
 175                                         PolicyLogger.error(errorMessage);
 176                                         return;
 177                                 }
 178                                 PolicyLogger.info("Request from API to import new Optimization Service Model");
 179                                 try (Writer writer = new BufferedWriter(new OutputStreamWriter(
 180                                                 new FileOutputStream(extractDir + File.separator + randomID+type), "utf-8"))) {
 181                                         writer.write(yml);
 182                                 } catch (IOException e) {
 183                                         logger.error(e);
 184                                         PolicyLogger.error(errorMessage);
 185                                         return;
 186                                 }
 187
 188                                 newOOF =  new CreateNewOptimizationModel(fileName, serviceName, "API Import Service", version, randomID);
 189                                 successMap = newOOF.addValuesToNewModel();
 190                                 if (successMap.containsKey(successMessage)) {
 191                                         successMap.clear();
 192                                         successMap = newOOF.saveImportService();
 193                                 }
 194                         }
 195                 }
 196
 197                 // return a response to the PAP
 198                 if (successMap.containsKey(successMessage)) {
 199                         response.setStatus(HttpServletResponse.SC_OK);
 200                         response.addHeader("successMapKey", successMessage);
 201                         response.addHeader(operation, importHeader);
 202                         response.addHeader(service, serviceName);
 203                 } else if (successMap.containsKey("DBError")) {
 204                         if (successMap.get("DBError").contains("EXISTS")){
 205                                 response.setStatus(HttpServletResponse.SC_CONFLICT);
 206                                 response.addHeader(service, serviceName);
 207                                 response.addHeader(errorMsg, "modelExistsDB");
 208                         }else{
 209                                 response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 210                                 response.addHeader(errorMsg, "importDB");
 211                         }
 212                         response.addHeader(operation, importHeader);
 213                         response.addHeader(service, serviceName);
 214                 }else if (successMap.get(errorMsg).contains("MISSING")){
 215                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 216                         response.addHeader(errorMsg, MISSING);
 217                         response.addHeader(operation, importHeader);
 218                         response.addHeader(service, serviceName);
 219                 }else if (successMap.get(errorMsg).contains("VALIDATION")){
 220                         response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 221                         response.addHeader(errorMsg, "validation");
 222                         response.addHeader(operation, importHeader);
 223                         response.addHeader(service, serviceName);
 224                 }
 225         }
 226
 227 }