aai-core/src/main/java/org/openecomp/aai/logging/ErrorLogHelper.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   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
  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
  21 package org.openecomp.aai.logging;
  22
  23 import com.att.eelf.configuration.EELFLogger;
  24 import com.att.eelf.configuration.EELFManager;
  25 import org.apache.commons.lang.StringUtils;
  26 import org.openecomp.aai.exceptions.AAIException;
  27 import org.openecomp.aai.logging.LoggingContext.StatusCode;
  28 import org.openecomp.aai.util.AAIConstants;
  29 import org.openecomp.aai.util.MapperUtil;
  30 import org.slf4j.MDC;
  31
  32 import javax.ws.rs.core.MediaType;
  33 import javax.xml.bind.JAXBContext;
  34 import javax.xml.bind.Marshaller;
  35 import java.io.FileInputStream;
  36 import java.io.IOException;
  37 import java.io.InputStream;
  38 import java.io.StringWriter;
  39 import java.util.*;
  40 import java.util.Map.Entry;
  41
  42 /**
  43  *
  44  * This classes loads the application error properties file
  45  * and provides a method that returns an ErrorObject
  46  *
  47  */
  48
  49 public class ErrorLogHelper {
  50
  51         private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(ErrorLogHelper.class);
  52         private static final HashMap<String, ErrorObject> ERROR_OBJECTS = new HashMap<String, ErrorObject> ();
  53
  54         static {
  55                 try {
  56                         loadProperties();
  57                 } catch (IOException e) {
  58                         throw new RuntimeException("Failed to load error.properties file", e);
  59                 } catch (ErrorObjectFormatException e) {
  60                         throw new RuntimeException("Failed to parse error.properties file", e);
  61                 }
  62         }
  63
  64         /**
  65          * Load properties.
  66          * @throws ErrorObjectFormatException
  67          * @throws Exception the exception
  68          */
  69         public static void loadProperties() throws IOException, ErrorObjectFormatException {
  70                 final String filePath = AAIConstants.AAI_HOME_ETC_APP_PROPERTIES + "error.properties";
  71                 final InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(filePath);
  72                 final Properties properties = new Properties();
  73
  74                 if (is != null) {
  75                         properties.load(is);
  76                 } else {
  77                         try (final FileInputStream fis = new FileInputStream(filePath)) {
  78                                 properties.load(fis);
  79                         }
  80                 }
  81
  82                 for (Entry<Object, Object> entry : properties.entrySet()) {
  83                         final String key = (String) entry.getKey();
  84                         final String value = (String) entry.getValue();
  85                         final String[] errorProperties = value.split(":");
  86
  87                         if (errorProperties.length != 7) throw new ErrorObjectFormatException();
  88
  89                         final ErrorObject errorObject = new ErrorObject();
  90
  91                         errorObject.setDisposition(errorProperties[0].trim());
  92                         errorObject.setCategory(errorProperties[1].trim());
  93                         errorObject.setSeverity(errorProperties[2].trim());
  94                         errorObject.setErrorCode(errorProperties[3].trim());
  95                         errorObject.setHTTPResponseCode(errorProperties[4].trim());
  96                         errorObject.setRESTErrorCode(errorProperties[5].trim());
  97                         errorObject.setErrorText(errorProperties[6].trim());
  98
  99                         ERROR_OBJECTS.put(key, errorObject);
 100                 }
 101         }
 102
 103         /**
 104          * Logs a known A&AI exception (i.e. one that can be found in error.properties)
 105          *
 106          * @param key The key for the error in the error.properties file
 107          * @throws IOException
 108          * @throws ErrorObjectNotFoundException
 109          * @throws ErrorObjectFormatException
 110          */
 111         public static ErrorObject getErrorObject(String code) throws ErrorObjectNotFoundException {
 112
 113                 if (code == null) throw new IllegalArgumentException("Key cannot be null");
 114
 115                 final ErrorObject errorObject = ERROR_OBJECTS.get(code);
 116
 117                 if (errorObject == null) {
 118                         LOGGER.warn("Unknown AAIException with code=" + code + ".  Using default AAIException");
 119                         return ERROR_OBJECTS.get(AAIException.DEFAULT_EXCEPTION_CODE);
 120                 }
 121
 122                 return errorObject;
 123         }
 124
 125         /**
 126          * Determines whether category is policy or not.  If policy (1), this is a POL error, else it's a SVC error.
 127          * The AAIRESTException may contain a different ErrorObject than that created with the REST error key.
 128          * This allows lower level exception detail to be returned to the client to help troubleshoot the problem.
 129          * If no error object is embedded in the AAIException, one will be created using the error object from the AAIException.
 130          * @param are must have a restError value whose numeric value must match what should be returned in the REST API
 131          * @param variables optional list of variables to flesh out text in error string
 132          * @return appropriately formatted JSON response per the REST API spec.
 133          * @throws ErrorObjectFormatException
 134          * @throws ErrorObjectNotFoundException
 135          * @throws IOException
 136          * @deprecated
 137          */
 138         public static String getRESTAPIErrorResponse(AAIException are, ArrayList<String> variables) {
 139                 List<MediaType> acceptHeaders = new ArrayList<MediaType>();
 140                 acceptHeaders.add(MediaType.APPLICATION_JSON_TYPE);
 141
 142                 return getRESTAPIErrorResponse(acceptHeaders, are, variables);
 143         }
 144
 145         /**
 146          * Determines whether category is policy or not.  If policy (1), this is a POL error, else it's a SVC error.
 147          * The AAIRESTException may contain a different ErrorObject than that created with the REST error key.
 148          * This allows lower level exception detail to be returned to the client to help troubleshoot the problem.
 149          * If no error object is embedded in the AAIException, one will be created using the error object from the AAIException.
 150          *
 151          * @param acceptHeadersOrig the accept headers orig
 152          * @param are must have a restError value whose numeric value must match what should be returned in the REST API
 153          * @param variables optional list of variables to flesh out text in error string
 154          * @return appropriately formatted JSON response per the REST API spec.
 155          * @throws ErrorObjectFormatException
 156          * @throws ErrorObjectNotFoundException
 157          * @throws IOException
 158          */
 159         public static String getRESTAPIErrorResponse(List<MediaType> acceptHeadersOrig, AAIException are, ArrayList<String> variables) {
 160
 161
 162                 StringBuilder text = new StringBuilder();
 163                 String response = null;
 164
 165                 List<MediaType> acceptHeaders = new ArrayList<MediaType>();
 166                 // we might have an exception but no accept header, so we'll set default to JSON
 167                 boolean foundValidAcceptHeader = false;
 168                 for (MediaType mt : acceptHeadersOrig) {
 169                         if (MediaType.APPLICATION_XML_TYPE.isCompatible(mt) ||
 170                                         MediaType.APPLICATION_JSON_TYPE.isCompatible(mt)) {
 171                                 acceptHeaders.add(mt);
 172                                 foundValidAcceptHeader = true;
 173                         }
 174                 }
 175                 if (foundValidAcceptHeader == false) {
 176                         // override the exception, client needs to set an appropriate Accept header
 177                         are = new AAIException("AAI_4014");
 178                         acceptHeaders.add(MediaType.APPLICATION_JSON_TYPE);
 179                 }
 180
 181                 final ErrorObject eo = are.getErrorObject();
 182
 183                 int restErrorCode = Integer.parseInt(eo.getRESTErrorCode());
 184
 185                 ErrorObject restErrorObject;
 186
 187                 try {
 188                         restErrorObject = ErrorLogHelper.getErrorObject("AAI_"+restErrorCode);
 189                 } catch (ErrorObjectNotFoundException e) {
 190                         LOGGER.warn("Failed to find related error object AAI_" + restErrorCode + " for error object " + eo.getErrorCode() + "; using AAI_" + restErrorCode);
 191                         restErrorObject = eo;
 192                 }
 193
 194                 text.append(restErrorObject.getErrorText());
 195
 196                 // We want to always append the (msg=%n) (ec=%n+1) to the text, but have to find value of n
 197                 // This assumes that the variables in the ArrayList, which might be more than are needed to flesh out the
 198                 // error, are ordered based on the error string.
 199                 int localDataIndex = StringUtils.countMatches(restErrorObject.getErrorText(), "%");
 200                 text.append(" (msg=%").append(localDataIndex+1).append(") (ec=%").append(localDataIndex+2).append(")");
 201
 202                 if (variables == null)
 203                 {
 204                         variables = new ArrayList<String>();
 205                 }
 206
 207                 if (variables.size() < localDataIndex) {
 208                         ErrorLogHelper.logError("AAI_4011", "data missing for rest error");
 209                         while (variables.size() < localDataIndex) {
 210                                 variables.add("null");
 211                         }
 212                 }
 213
 214                 // This will put the error code and error text into the right positions
 215                 if (are.getMessage() == null || are.getMessage().length() == 0) {
 216                         variables.add(localDataIndex++, eo.getErrorText());
 217                 }
 218                 else {
 219                         variables.add(localDataIndex++, eo.getErrorText() + ":" + are.getMessage());
 220                 }
 221                 variables.add(localDataIndex, eo.getErrorCodeString());
 222
 223                 for (MediaType mediaType : acceptHeaders) {
 224                 if (MediaType.APPLICATION_XML_TYPE.isCompatible(mediaType)) {
 225                                 JAXBContext context = null;
 226                                 try {
 227                                         if(eo.getCategory().equals("1")) {
 228
 229                                                 context = JAXBContext.newInstance(org.openecomp.aai.domain.restPolicyException.Fault.class);
 230                                                 Marshaller m = context.createMarshaller();
 231                                                 m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
 232                                                 m.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
 233
 234                                                 org.openecomp.aai.domain.restPolicyException.ObjectFactory factory = new org.openecomp.aai.domain.restPolicyException.ObjectFactory();
 235                                                 org.openecomp.aai.domain.restPolicyException.Fault fault = factory.createFault();
 236                                                 org.openecomp.aai.domain.restPolicyException.Fault.RequestError requestError = factory.createFaultRequestError();
 237                                                 org.openecomp.aai.domain.restPolicyException.Fault.RequestError.PolicyException policyException = factory.createFaultRequestErrorPolicyException();
 238                                                 org.openecomp.aai.domain.restPolicyException.Fault.RequestError.PolicyException.Variables polvariables = factory.createFaultRequestErrorPolicyExceptionVariables();
 239
 240                                                 policyException.setMessageId("POL" + eo.getRESTErrorCode());
 241                                                 policyException.setText(text.toString());
 242                                                 for (int i=0;i<variables.size();i++)
 243                                                 {
 244                                                         polvariables.getVariable().add(variables.get(i));
 245                                                 }
 246                                                 policyException.setVariables(polvariables);
 247                                                 requestError.setPolicyException(policyException);
 248                                                 fault.setRequestError(requestError);
 249
 250                                                 StringWriter sw = new StringWriter();
 251                                                 m.marshal(fault, sw);
 252
 253                                                 response = sw.toString();
 254
 255                                         } else {
 256
 257                                                 context = JAXBContext.newInstance(org.openecomp.aai.domain.restServiceException.Fault.class);
 258                                                 Marshaller m = context.createMarshaller();
 259                                                 m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
 260                                                 m.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
 261
 262                                                 org.openecomp.aai.domain.restServiceException.ObjectFactory factory = new org.openecomp.aai.domain.restServiceException.ObjectFactory();
 263                                                 org.openecomp.aai.domain.restServiceException.Fault fault = factory.createFault();
 264                                                 org.openecomp.aai.domain.restServiceException.Fault.RequestError requestError = factory.createFaultRequestError();
 265                                                 org.openecomp.aai.domain.restServiceException.Fault.RequestError.ServiceException serviceException = factory.createFaultRequestErrorServiceException();
 266                                                 org.openecomp.aai.domain.restServiceException.Fault.RequestError.ServiceException.Variables svcvariables = factory.createFaultRequestErrorServiceExceptionVariables();
 267                                                 serviceException.setMessageId("SVC" + eo.getRESTErrorCode());
 268                                                 serviceException.setText(text.toString());
 269                                                 for (int i=0;i<variables.size();i++)
 270                                                 {
 271                                                         svcvariables.getVariable().add(variables.get(i));
 272                                                 }
 273                                                 serviceException.setVariables(svcvariables);
 274                                                 requestError.setServiceException(serviceException);
 275                                                 fault.setRequestError(requestError);
 276
 277                                                 StringWriter sw = new StringWriter();
 278                                                 m.marshal(fault, sw);
 279
 280                                                 response = sw.toString();
 281
 282                                         }
 283                                 } catch (Exception ex) {
 284                                         LOGGER.error("We were unable to create a rest exception to return on an API because of a parsing error", ex);
 285                                 }
 286                         }
 287                 else  {
 288                         try {
 289                                 if(eo.getCategory().equals("1")) {
 290                                         org.openecomp.aai.domain.restPolicyException.RESTResponse restresp = new org.openecomp.aai.domain.restPolicyException.RESTResponse();
 291                                         org.openecomp.aai.domain.restPolicyException.RequestError reqerr = new org.openecomp.aai.domain.restPolicyException.RequestError();
 292                                         org.openecomp.aai.domain.restPolicyException.PolicyException polexc = new org.openecomp.aai.domain.restPolicyException.PolicyException();
 293                                         polexc.setMessageId("POL" + eo.getRESTErrorCode());
 294                                         polexc.setText(text.toString());
 295                                         polexc.setVariables(variables);
 296                                         reqerr.setPolicyException(polexc);
 297                                         restresp.setRequestError(reqerr);
 298                                         response = (MapperUtil.writeAsJSONString((Object) restresp));
 299
 300                                 } else {
 301                                         org.openecomp.aai.domain.restServiceException.RESTResponse restresp = new org.openecomp.aai.domain.restServiceException.RESTResponse();
 302                                         org.openecomp.aai.domain.restServiceException.RequestError reqerr = new org.openecomp.aai.domain.restServiceException.RequestError();
 303                                         org.openecomp.aai.domain.restServiceException.ServiceException svcexc = new org.openecomp.aai.domain.restServiceException.ServiceException();
 304                                         svcexc.setMessageId("SVC" + eo.getRESTErrorCode());
 305                                         svcexc.setText(text.toString());
 306                                         svcexc.setVariables(variables);
 307                                         reqerr.setServiceException(svcexc);
 308                                         restresp.setRequestError(reqerr);
 309                                         response = (MapperUtil.writeAsJSONString((Object) restresp));
 310                                 }
 311                         } catch (AAIException ex) {
 312                                 LOGGER.error("We were unable to create a rest exception to return on an API because of a parsing error", ex);
 313                         }
 314                 }
 315                 }
 316
 317
 318                 return response;
 319         }
 320
 321         /**
 322          * Gets the RESTAPI error response with logging.
 323          *
 324          * @param acceptHeadersOrig the accept headers orig
 325          * @param are the are
 326          * @param variables the variables
 327          * @param logline the logline
 328          * @return the RESTAPI error response with logging
 329          * @throws ErrorObjectFormatException
 330          * @throws ErrorObjectNotFoundException
 331          * @throws IOException
 332          */
 333         public static String getRESTAPIErrorResponseWithLogging(List<MediaType> acceptHeadersOrig, AAIException are, ArrayList<String> variables) {
 334                 String response = ErrorLogHelper.getRESTAPIErrorResponse(acceptHeadersOrig, are, variables);
 335
 336                 LOGGER.error(are.getMessage(), are);
 337
 338                 return response;
 339         }
 340
 341         /**
 342          * Gets the RESTAPI info response.
 343          *
 344          * @param acceptHeaders the accept headers
 345          * @param areList the are list
 346          * @return the RESTAPI info response
 347          * @throws ErrorObjectFormatException
 348          * @throws ErrorObjectNotFoundException
 349          * @throws IOException
 350          */
 351         public static Object getRESTAPIInfoResponse(List<MediaType> acceptHeaders, HashMap<AAIException,ArrayList<String>> areList) {
 352
 353                 Object respObj = null;
 354
 355                 org.openecomp.aai.domain.restResponseInfo.ObjectFactory factory = new org.openecomp.aai.domain.restResponseInfo.ObjectFactory();
 356                 org.openecomp.aai.domain.restResponseInfo.Info info = factory.createInfo();
 357                 org.openecomp.aai.domain.restResponseInfo.Info.ResponseMessages responseMessages = factory.createInfoResponseMessages();
 358                 Iterator<Entry<AAIException, ArrayList<String>>> it = areList.entrySet().iterator();
 359
 360                 while (it.hasNext()) {
 361                         Entry<AAIException,ArrayList<String>> pair = (Entry<AAIException, ArrayList<String>>)it.next();
 362                         AAIException are = pair.getKey();
 363                         ArrayList<String> variables = pair.getValue();
 364
 365                         StringBuilder text = new StringBuilder();
 366
 367                         ErrorObject eo = are.getErrorObject();
 368
 369                         int restErrorCode = Integer.parseInt(eo.getRESTErrorCode());
 370                         ErrorObject restErrorObject;
 371                         try {
 372                                 restErrorObject = ErrorLogHelper.getErrorObject("AAI_"+String.format("%04d", restErrorCode));
 373                         } catch (ErrorObjectNotFoundException e) {
 374                                 restErrorObject = eo;
 375                         }
 376                         text.append(restErrorObject.getErrorText());
 377
 378                         // We want to always append the (msg=%n) (ec=%n+1) to the text, but have to find value of n
 379                         // This assumes that the variables in the ArrayList, which might be more than are needed to flesh out the
 380                         // error, are ordered based on the error string.
 381                         int localDataIndex = StringUtils.countMatches(restErrorObject.getErrorText(), "%");
 382                         text.append(" (msg=%").append(localDataIndex+1).append(") (rc=%").append(localDataIndex+2).append(")");
 383
 384                         if (variables == null)
 385                         {
 386                                 variables = new ArrayList<String>();
 387                         }
 388
 389                         if (variables.size() < localDataIndex) {
 390                                 ErrorLogHelper.logError("AAI_4011", "data missing for rest error");
 391                                 while (variables.size() < localDataIndex) {
 392                                         variables.add("null");
 393                                 }
 394                         }
 395
 396                         // This will put the error code and error text into the right positions
 397                         if (are.getMessage() == null) {
 398                                 variables.add(localDataIndex++, eo.getErrorText());
 399                         }
 400                         else {
 401                                 variables.add(localDataIndex++, eo.getErrorText() + ":" + are.getMessage());
 402                         }
 403                         variables.add(localDataIndex, eo.getErrorCodeString());
 404
 405                         try {
 406                                 org.openecomp.aai.domain.restResponseInfo.Info.ResponseMessages.ResponseMessage responseMessage = factory.createInfoResponseMessagesResponseMessage();
 407                                 org.openecomp.aai.domain.restResponseInfo.Info.ResponseMessages.ResponseMessage.Variables infovariables = factory.createInfoResponseMessagesResponseMessageVariables();
 408
 409                                 responseMessage.setMessageId("INF" + eo.getRESTErrorCode());
 410                                 responseMessage.setText(text.toString());
 411                                 for (int i=0;i<variables.size();i++)
 412                                 {
 413                                         infovariables.getVariable().add(variables.get(i));
 414                                 }
 415
 416                                 responseMessage.setVariables(infovariables);
 417                                 responseMessages.getResponseMessage().add(responseMessage);
 418
 419                         } catch (Exception ex) {
 420                                 LOGGER.error("We were unable to create a rest exception to return on an API because of a parsing error", ex);
 421                         }
 422                 }
 423
 424                 info.setResponseMessages(responseMessages);
 425                 respObj = (Object) info;
 426
 427                 return respObj;
 428         }
 429
 430
 431                 /**
 432                  * Determines whether category is policy or not.  If policy (1), this is a POL error, else it's a SVC error.
 433                  * The AAIRESTException may contain a different ErrorObject than that created with the REST error key.
 434                  * This allows lower level exception detail to be returned to the client to help troubleshoot the problem.
 435                  * If no error object is embedded in the AAIException, one will be created using the error object from the AAIException.
 436                  * @param are must have a restError value whose numeric value must match what should be returned in the REST API
 437                  * @param variables optional list of variables to flesh out text in error string
 438                  * @return appropriately formatted JSON response per the REST API spec.
 439                  * @throws ErrorObjectFormatException
 440                  * @throws ErrorObjectNotFoundException
 441                  * @throws IOException
 442                  */
 443                 public static String getRESTAPIPolicyErrorResponseXML(AAIException are, ArrayList<String> variables) {
 444
 445                         StringBuilder text = new StringBuilder();
 446                         String response = null;
 447                         JAXBContext context = null;
 448
 449                         ErrorObject eo = are.getErrorObject();
 450
 451                         int restErrorCode = Integer.parseInt(eo.getRESTErrorCode());
 452                         ErrorObject restErrorObject;
 453                         try {
 454                                 restErrorObject = ErrorLogHelper.getErrorObject("AAI_"+restErrorCode);
 455                         } catch (ErrorObjectNotFoundException e) {
 456                                 restErrorObject = eo;
 457                         }
 458
 459                         text.append(restErrorObject.getErrorText());
 460
 461                         // We want to always append the (msg=%n) (ec=%n+1) to the text, but have to find value of n
 462                         // This assumes that the variables in the ArrayList, which might be more than are needed to flesh out the
 463                         // error, are ordered based on the error string.
 464                         int localDataIndex = StringUtils.countMatches(restErrorObject.getErrorText(), "%");
 465                         text.append(" (msg=%").append(localDataIndex+1).append(") (ec=%").append(localDataIndex+2).append(")");
 466
 467                         if (variables == null)
 468                         {
 469                                 variables = new ArrayList<String>();
 470                         }
 471
 472                         if (variables.size() < localDataIndex) {
 473                                 ErrorLogHelper.logError("AAI_4011", "data missing for rest error");
 474                                 while (variables.size() < localDataIndex) {
 475                                         variables.add("null");
 476                                 }
 477                         }
 478
 479                         // This will put the error code and error text into the right positions
 480                         if (are.getMessage() == null) {
 481                                 variables.add(localDataIndex++, eo.getErrorText());
 482                         }
 483                         else {
 484                                 variables.add(localDataIndex++, eo.getErrorText() + ":" + are.getMessage());
 485                         }
 486                         variables.add(localDataIndex, eo.getErrorCodeString());
 487
 488                         try {
 489                                 if(eo.getCategory().equals("1")) {
 490
 491                                         context = JAXBContext.newInstance(org.openecomp.aai.domain.restPolicyException.Fault.class);
 492                                         Marshaller m = context.createMarshaller();
 493                                         m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
 494                                         m.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
 495
 496                                         org.openecomp.aai.domain.restPolicyException.ObjectFactory factory = new org.openecomp.aai.domain.restPolicyException.ObjectFactory();
 497                                         org.openecomp.aai.domain.restPolicyException.Fault fault = factory.createFault();
 498                                         org.openecomp.aai.domain.restPolicyException.Fault.RequestError requestError = factory.createFaultRequestError();
 499                                         org.openecomp.aai.domain.restPolicyException.Fault.RequestError.PolicyException policyException = factory.createFaultRequestErrorPolicyException();
 500                                         org.openecomp.aai.domain.restPolicyException.Fault.RequestError.PolicyException.Variables polvariables = factory.createFaultRequestErrorPolicyExceptionVariables();
 501
 502                                         policyException.setMessageId("POL" + eo.getRESTErrorCode());
 503                                         policyException.setText(text.toString());
 504                                         for (int i=0;i<variables.size();i++)
 505                                         {
 506                                                 polvariables.getVariable().add(variables.get(i));
 507                                         }
 508                                         policyException.setVariables(polvariables);
 509                                         requestError.setPolicyException(policyException);
 510                                         fault.setRequestError(requestError);
 511
 512                                         StringWriter sw = new StringWriter();
 513                                         m.marshal(fault, sw);
 514
 515                                         response = sw.toString();
 516
 517                                 } else {
 518
 519                                         context = JAXBContext.newInstance(org.openecomp.aai.domain.restServiceException.Fault.class);
 520                                         Marshaller m = context.createMarshaller();
 521                                         m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
 522                                         m.setProperty(Marshaller.JAXB_ENCODING, "UTF-8");
 523
 524                                         org.openecomp.aai.domain.restServiceException.ObjectFactory factory = new org.openecomp.aai.domain.restServiceException.ObjectFactory();
 525                                         org.openecomp.aai.domain.restServiceException.Fault fault = factory.createFault();
 526                                         org.openecomp.aai.domain.restServiceException.Fault.RequestError requestError = factory.createFaultRequestError();
 527                                         org.openecomp.aai.domain.restServiceException.Fault.RequestError.ServiceException serviceException = factory.createFaultRequestErrorServiceException();
 528                                         org.openecomp.aai.domain.restServiceException.Fault.RequestError.ServiceException.Variables svcvariables = factory.createFaultRequestErrorServiceExceptionVariables();
 529                                         serviceException.setMessageId("POL" + eo.getRESTErrorCode());
 530                                         serviceException.setText(text.toString());
 531                                         for (int i=0;i<variables.size();i++)
 532                                         {
 533                                                 svcvariables.getVariable().add(variables.get(i));
 534                                         }
 535                                         serviceException.setVariables(svcvariables);
 536                                         requestError.setServiceException(serviceException);
 537                                         fault.setRequestError(requestError);
 538
 539                                         StringWriter sw = new StringWriter();
 540                                         m.marshal(fault, sw);
 541
 542                                         response = sw.toString();
 543
 544                                 }
 545                         } catch (Exception ex) {
 546                                 LOGGER.error("We were unable to create a rest exception to return on an API because of a parsing error", ex);
 547                         }
 548                         return response;
 549                 }
 550
 551         public static void logException(AAIException e) {
 552                 final ErrorObject errorObject = e.getErrorObject();
 553
 554                 MDC.put("severity", errorObject.getSeverity()); //TODO Use LoggingContext.severity(int severity)
 555
 556                 final String errorMessage = new StringBuilder()
 557                                                                                         .append(errorObject.getErrorText())
 558                                                                                         .append(":")
 559                                                                                         .append(errorObject.getRESTErrorCode())
 560                                                                                         .append(":")
 561                                                                                         .append(errorObject.getHTTPResponseCode())
 562                                                                                         .append(":")
 563                                                                                         .append(e.getMessage())
 564                                                                                         .toString();
 565
 566                 LoggingContext.responseCode(errorObject.getErrorCodeString());
 567                 LoggingContext.responseDescription(errorMessage);
 568                 LoggingContext.statusCode(StatusCode.ERROR);
 569
 570                 if (errorObject.getSeverity().equalsIgnoreCase("WARN"))
 571                         LOGGER.warn(errorMessage, e);
 572                 else if (errorObject.getSeverity().equalsIgnoreCase("ERROR"))
 573                         LOGGER.error(errorMessage, e);
 574                 else if (errorObject.getSeverity().equalsIgnoreCase("FATAL"))
 575                         LOGGER.error(errorMessage, e);
 576                 else if (errorObject.getSeverity().equals("INFO"))
 577                         LOGGER.info(errorMessage + ", " + e.getMessage());
 578         }
 579
 580         public static void logError(String code) {
 581                 logError(code, "");
 582         }
 583
 584         public static void logError(String code, String message) {
 585                 logException(new AAIException(code, message));
 586         }
 587 }