示例#1
0
 /**
  * Removes all the successful minor results. Also checks if the result is roughly consistent and
  * complete. (e.g. does not have unknown operation status, etc.)
  *
  * <p>The argument "e" is for easier use of the cleanup in the exceptions handlers. The original
  * exception is passed to the IAE that this method produces for easier debugging.
  */
 public void cleanupResult(Throwable e) {
   if (status == OperationResultStatus.UNKNOWN) {
     LOGGER.error(
         "Attempt to cleanup result of operation " + operation + " that is still UNKNOWN:\n{}",
         this.debugDump());
     throw new IllegalStateException(
         "Attempt to cleanup result of operation " + operation + " that is still UNKNOWN");
   }
   if (subresults == null) {
     return;
   }
   Iterator<OperationResult> iterator = subresults.iterator();
   while (iterator.hasNext()) {
     OperationResult subresult = iterator.next();
     if (subresult.getStatus() == OperationResultStatus.UNKNOWN) {
       String message =
           "Subresult "
               + subresult.getOperation()
               + " of operation "
               + operation
               + " is still UNKNOWN during cleanup";
       LOGGER.error("{}:\n{}", message, this.debugDump(), e);
       if (e == null) {
         throw new IllegalStateException(message);
       } else {
         throw new IllegalStateException(message + "; during handling of exception " + e, e);
       }
     }
     if (subresult.canCleanup()) {
       iterator.remove();
     }
   }
 }
示例#2
0
 /** Set all error status in this result and all subresults as handled. */
 public void setErrorsHandled() {
   if (isError()) {
     setStatus(OperationResultStatus.HANDLED_ERROR);
   }
   for (OperationResult subresult : getSubresults()) {
     subresult.setErrorsHandled();
   }
 }
示例#3
0
 /**
  * Returns true if result status is UNKNOWN or any of the subresult status is unknown (recursive).
  *
  * <p>May come handy in tests to check if all the operations fill out the status as they should.
  */
 public boolean hasUnknownStatus() {
   if (status == OperationResultStatus.UNKNOWN) {
     return true;
   }
   for (OperationResult subresult : getSubresults()) {
     if (subresult.hasUnknownStatus()) {
       return true;
     }
   }
   return false;
 }
示例#4
0
 public OperationResult findSubresult(String operation) {
   if (subresults == null) {
     return null;
   }
   for (OperationResult subResult : getSubresults()) {
     if (operation.equals(subResult.getOperation())) {
       return subResult;
     }
   }
   return null;
 }
示例#5
0
 public List<OperationResult> findSubresults(String operation) {
   List<OperationResult> found = new ArrayList<>();
   if (subresults == null) {
     return found;
   }
   for (OperationResult subResult : getSubresults()) {
     if (operation.equals(subResult.getOperation())) {
       found.add(subResult);
     }
   }
   return found;
 }
示例#6
0
  public void summarize() {
    Iterator<OperationResult> iterator = getSubresults().iterator();
    while (iterator.hasNext()) {
      OperationResult subresult = iterator.next();
      if (subresult.getCount() > 1) {
        // Already summarized
        continue;
      }
      if (subresult.isError() && summarizeErrors) {
        // go on
      } else if (subresult.isPartialError() && summarizePartialErrors) {
        // go on
      } else if (subresult.isSuccess() && summarizeSuccesses) {
        // go on
      } else {
        continue;
      }
      OperationResult similar = findSimilarSubresult(subresult);
      if (similar == null) {
        // Nothing to summarize to
        continue;
      }
      merge(similar, subresult);
      iterator.remove();
    }

    // subresult stripping if necessary
    // we strip subresults that have same operation name and status, if there are more of them than
    // threshold
    Map<OperationStatusKey, Integer> counter = new HashMap<OperationStatusKey, Integer>();
    iterator = getSubresults().iterator();
    while (iterator.hasNext()) {
      OperationResult sr = iterator.next();
      OperationStatusKey key = new OperationStatusKey(sr.getOperation(), sr.getStatus());
      if (counter.containsKey(key)) {
        int count = counter.get(key);
        if (count > SUBRESULT_STRIP_THRESHOLD) {
          iterator.remove();
        } else {
          counter.put(key, ++count);
        }
      } else {
        counter.put(key, 1);
      }
    }
  }
示例#7
0
  public static OperationResult createOperationResult(OperationResultType result) {
    if (result == null) {
      return null;
    }

    Map<String, Serializable> params = ParamsTypeUtil.fromParamsType(result.getParams());
    //		if (result.getParams() != null) {
    //			params = new HashMap<String, Serializable>();
    //			for (EntryType entry : result.getParams().getEntry()) {
    //				params.put(entry.getKey(), (Serializable) entry.getEntryValue());
    //			}
    //		}

    Map<String, Serializable> context = ParamsTypeUtil.fromParamsType(result.getContext());
    //		if (result.getContext() != null) {
    //			context = new HashMap<String, Serializable>();
    //			for (EntryType entry : result.getContext().getEntry()) {
    //				context.put(entry.getKey(), (Serializable) entry.getEntryValue());
    //			}
    //		}

    Map<String, Serializable> returns = ParamsTypeUtil.fromParamsType(result.getReturns());
    //		if (result.getReturns() != null) {
    //			returns = new HashMap<String, Serializable>();
    //			for (EntryType entry : result.getReturns().getEntry()) {
    //				returns.put(entry.getKey(), (Serializable) entry.getEntryValue());
    //			}
    //		}

    List<OperationResult> subresults = null;
    if (!result.getPartialResults().isEmpty()) {
      subresults = new ArrayList<OperationResult>();
      for (OperationResultType subResult : result.getPartialResults()) {
        subresults.add(createOperationResult(subResult));
      }
    }

    LocalizedMessageType message = result.getLocalizedMessage();
    String localizedMessage = message == null ? null : message.getKey();
    List<Serializable> localizedArguments =
        message == null
            ? null
            : (List<Serializable>) (List) message.getArgument(); // FIXME: brutal hack

    OperationResult opResult =
        new OperationResult(
            result.getOperation(),
            params,
            context,
            returns,
            OperationResultStatus.parseStatusType(result.getStatus()),
            result.getToken(),
            result.getMessageCode(),
            result.getMessage(),
            localizedMessage,
            localizedArguments,
            null,
            subresults);
    if (result.getCount() != null) {
      opResult.setCount(result.getCount());
    }
    return opResult;
  }
示例#8
0
 public void muteLastSubresultError() {
   OperationResult lastSubresult = getLastSubresult();
   if (lastSubresult != null) {
     lastSubresult.muteError();
   }
 }
示例#9
0
  /**
   * Used when the result contains several composite sub-result that are of equivalent meaning. If
   * all of them fail the result will be fatal error as well. If only some of them fail the result
   * will be partial error. Handled error is considered a success.
   */
  public void computeStatusComposite() {
    if (getSubresults().isEmpty()) {
      if (status == OperationResultStatus.UNKNOWN) {
        status = OperationResultStatus.NOT_APPLICABLE;
      }
      return;
    }

    boolean allFatalError = true;
    boolean allNotApplicable = true;
    boolean hasInProgress = false;
    boolean hasHandledError = false;
    boolean hasError = false;
    boolean hasWarning = false;
    for (OperationResult sub : getSubresults()) {
      if (sub.getStatus() != OperationResultStatus.NOT_APPLICABLE) {
        allNotApplicable = false;
      }
      if (sub.getStatus() != OperationResultStatus.FATAL_ERROR) {
        allFatalError = false;
      }
      if (sub.getStatus() == OperationResultStatus.FATAL_ERROR) {
        hasError = true;
        if (message == null) {
          message = sub.getMessage();
        } else {
          message = message + ", " + sub.getMessage();
        }
      }
      if (sub.getStatus() == OperationResultStatus.PARTIAL_ERROR) {
        hasError = true;
        if (message == null) {
          message = sub.getMessage();
        } else {
          message = message + ", " + sub.getMessage();
        }
      }
      if (sub.getStatus() == OperationResultStatus.HANDLED_ERROR) {
        hasHandledError = true;
        if (message == null) {
          message = sub.getMessage();
        } else {
          message = message + ", " + sub.getMessage();
        }
      }
      if (sub.getStatus() == OperationResultStatus.IN_PROGRESS) {
        hasInProgress = true;
        if (message == null) {
          message = sub.getMessage();
        } else {
          message = message + ", " + sub.getMessage();
        }
      }
      if (sub.getStatus() == OperationResultStatus.WARNING) {
        hasWarning = true;
        if (message == null) {
          message = sub.getMessage();
        } else {
          message = message + ", " + sub.getMessage();
        }
      }
    }

    if (allNotApplicable) {
      status = OperationResultStatus.NOT_APPLICABLE;
    } else if (allFatalError) {
      status = OperationResultStatus.FATAL_ERROR;
    } else if (hasInProgress) {
      status = OperationResultStatus.IN_PROGRESS;
    } else if (hasError) {
      status = OperationResultStatus.PARTIAL_ERROR;
    } else if (hasWarning) {
      status = OperationResultStatus.WARNING;
    } else if (hasHandledError) {
      status = OperationResultStatus.HANDLED_ERROR;
    } else {
      status = OperationResultStatus.SUCCESS;
    }
  }
示例#10
0
  /** Computes operation result status based on subtask status. */
  public void computeStatus() {
    if (getSubresults().isEmpty()) {
      if (status == OperationResultStatus.UNKNOWN) {
        status = OperationResultStatus.SUCCESS;
      }
      return;
    }
    if (status == OperationResultStatus.FATAL_ERROR) {
      return;
    }
    OperationResultStatus newStatus = OperationResultStatus.UNKNOWN;
    boolean allSuccess = true;
    boolean allNotApplicable = true;
    String newMessage = null;
    for (OperationResult sub : getSubresults()) {
      if (sub.getStatus() != OperationResultStatus.NOT_APPLICABLE) {
        allNotApplicable = false;
      }
      if (sub.getStatus() == OperationResultStatus.FATAL_ERROR) {
        status = OperationResultStatus.FATAL_ERROR;
        if (message == null) {
          message = sub.getMessage();
        } else {
          message = message + ": " + sub.getMessage();
        }
        return;
      }
      if (sub.getStatus() == OperationResultStatus.IN_PROGRESS) {
        status = OperationResultStatus.IN_PROGRESS;
        if (message == null) {
          message = sub.getMessage();
        } else {
          message = message + ": " + sub.getMessage();
        }
        return;
      }
      if (sub.getStatus() == OperationResultStatus.PARTIAL_ERROR) {
        newStatus = OperationResultStatus.PARTIAL_ERROR;
        newMessage = sub.getMessage();
      }
      if (newStatus != OperationResultStatus.PARTIAL_ERROR) {
        if (sub.getStatus() == OperationResultStatus.HANDLED_ERROR) {
          newStatus = OperationResultStatus.HANDLED_ERROR;
          newMessage = sub.getMessage();
        }
      }
      if (sub.getStatus() != OperationResultStatus.SUCCESS
          && sub.getStatus() != OperationResultStatus.NOT_APPLICABLE) {
        allSuccess = false;
      }
      if (newStatus != OperationResultStatus.HANDLED_ERROR) {
        if (sub.getStatus() == OperationResultStatus.WARNING) {
          newStatus = OperationResultStatus.WARNING;
          newMessage = sub.getMessage();
        }
      }
    }

    if (allNotApplicable && !getSubresults().isEmpty()) {
      status = OperationResultStatus.NOT_APPLICABLE;
    }
    if (allSuccess && !getSubresults().isEmpty()) {
      status = OperationResultStatus.SUCCESS;
    } else {
      status = newStatus;
      if (message == null) {
        message = newMessage;
      } else {
        message = message + ": " + newMessage;
      }
    }
  }
示例#11
0
 /** @return last subresult status, or null if there are no subresults. */
 public OperationResultStatus getLastSubresultStatus() {
   OperationResult last = getLastSubresult();
   return last != null ? last.getStatus() : null;
 }
示例#12
0
 public OperationResult createMinorSubresult(String operation) {
   OperationResult subresult = createSubresult(operation);
   subresult.minor = true;
   return subresult;
 }
示例#13
0
  public OperationResult clone() {
    OperationResult clone = new OperationResult(operation);

    clone.status = status;
    clone.params = CloneUtil.clone(params);
    clone.context = CloneUtil.clone(context);
    clone.returns = CloneUtil.clone(returns);
    clone.token = token;
    clone.messageCode = messageCode;
    clone.message = message;
    clone.localizationMessage = localizationMessage;
    clone.localizationArguments = CloneUtil.clone(localizationArguments);
    clone.cause = CloneUtil.clone(cause);
    clone.count = count;
    if (subresults != null) {
      clone.subresults = new ArrayList<>(subresults.size());
      for (OperationResult subresult : subresults) {
        if (subresult != null) {
          clone.subresults.add(subresult.clone());
        }
      }
    }
    clone.details = CloneUtil.clone(details);
    clone.summarizeErrors = summarizeErrors;
    clone.summarizePartialErrors = summarizePartialErrors;
    clone.summarizeSuccesses = summarizeSuccesses;
    clone.minor = minor;

    return clone;
  }
示例#14
0
  private void dumpIndent(StringBuilder sb, int indent, boolean printStackTrace) {
    for (int i = 0; i < indent; i++) {
      sb.append(INDENT_STRING);
    }
    sb.append("*op* ");
    sb.append(operation);
    sb.append(", st: ");
    sb.append(status);
    if (minor) {
      sb.append(", MINOR");
    }
    sb.append(", msg: ");
    sb.append(message);
    if (count > 1) {
      sb.append(" x");
      sb.append(count);
    }
    sb.append("\n");

    for (Map.Entry<String, Serializable> entry : getParams().entrySet()) {
      for (int i = 0; i < indent + 2; i++) {
        sb.append(INDENT_STRING);
      }
      sb.append("[p]");
      sb.append(entry.getKey());
      sb.append("=");
      sb.append(dumpEntry(indent + 2, entry.getValue()));
      sb.append("\n");
    }

    for (Map.Entry<String, Serializable> entry : getContext().entrySet()) {
      for (int i = 0; i < indent + 2; i++) {
        sb.append(INDENT_STRING);
      }
      sb.append("[c]");
      sb.append(entry.getKey());
      sb.append("=");
      sb.append(dumpEntry(indent + 2, entry.getValue()));
      sb.append("\n");
    }

    for (Map.Entry<String, Serializable> entry : getReturns().entrySet()) {
      for (int i = 0; i < indent + 2; i++) {
        sb.append(INDENT_STRING);
      }
      sb.append("[r]");
      sb.append(entry.getKey());
      sb.append("=");
      sb.append(dumpEntry(indent + 2, entry.getValue()));
      sb.append("\n");
    }

    for (String line : details) {
      for (int i = 0; i < indent + 2; i++) {
        sb.append(INDENT_STRING);
      }
      sb.append("[d]");
      sb.append(line);
      sb.append("\n");
    }

    if (cause != null) {
      for (int i = 0; i < indent + 2; i++) {
        sb.append(INDENT_STRING);
      }
      sb.append("[cause]");
      sb.append(cause.getClass().getSimpleName());
      sb.append(":");
      sb.append(cause.getMessage());
      sb.append("\n");
      if (printStackTrace) {
        dumpStackTrace(sb, cause.getStackTrace(), indent + 4);
        dumpInnerCauses(sb, cause.getCause(), indent + 3);
      }
    }

    for (OperationResult sub : getSubresults()) {
      sub.dumpIndent(sb, indent + 1, printStackTrace);
    }
  }
示例#15
0
 private void merge(OperationResult target, OperationResult source) {
   mergeMap(target.getParams(), source.getParams());
   mergeMap(target.getContext(), source.getContext());
   mergeMap(target.getReturns(), source.getReturns());
   target.incrementCount();
 }
示例#16
0
  private OperationResultType createOperationResultType(OperationResult opResult) {
    OperationResultType result = new OperationResultType();
    result.setToken(opResult.getToken());
    result.setStatus(OperationResultStatus.createStatusType(opResult.getStatus()));
    if (opResult.getCount() != 1) {
      result.setCount(opResult.getCount());
    }
    result.setOperation(opResult.getOperation());
    result.setMessage(opResult.getMessage());
    result.setMessageCode(opResult.getMessageCode());

    if (opResult.getCause() != null || !opResult.details.isEmpty()) {
      StringBuilder detailsb = new StringBuilder();

      // Record text messages in details (if present)
      if (!opResult.details.isEmpty()) {
        for (String line : opResult.details) {
          detailsb.append(line);
          detailsb.append("\n");
        }
      }

      // Record stack trace in details if a cause is present
      if (opResult.getCause() != null) {
        Throwable ex = opResult.getCause();
        detailsb.append(ex.getClass().getName());
        detailsb.append(": ");
        detailsb.append(ex.getMessage());
        detailsb.append("\n");
        StackTraceElement[] stackTrace = ex.getStackTrace();
        for (int i = 0; i < stackTrace.length; i++) {
          detailsb.append(stackTrace[i].toString());
          detailsb.append("\n");
        }
      }

      result.setDetails(detailsb.toString());
    }

    if (StringUtils.isNotEmpty(opResult.getLocalizationMessage())) {
      LocalizedMessageType message = new LocalizedMessageType();
      message.setKey(opResult.getLocalizationMessage());
      if (opResult.getLocalizationArguments() != null) {
        message.getArgument().addAll(opResult.getLocalizationArguments());
      }
      result.setLocalizedMessage(message);
    }

    //		Set<Entry<String, Serializable>> params = opResult.getParams();
    //		if (!params.isEmpty()) {
    ParamsType paramsType = ParamsTypeUtil.toParamsType(opResult.getParams());
    result.setParams(paramsType);

    //			for (Entry<String, Serializable> entry : params) {
    //				paramsType.getEntry().add(createEntryElement(entry.getKey(),entry.getValue()));
    //			}
    //		}

    //		Set<Entry<String, Serializable>> context = opResult.getContext().entrySet();
    //		if (!context.isEmpty()) {
    paramsType = ParamsTypeUtil.toParamsType(opResult.getContext());
    result.setContext(paramsType);

    //			for (Entry<String, Serializable> entry : context) {
    //				paramsType.getEntry().add(createEntryElement(entry.getKey(),entry.getValue()));
    //			}
    //		}

    //		Set<Entry<String, Serializable>> returns = opResult.getReturns().entrySet();
    //		if (!returns.isEmpty()) {
    paramsType = ParamsTypeUtil.toParamsType(opResult.getReturns());
    result.setReturns(paramsType);

    //			for (Entry<String, Serializable> entry : returns) {
    //				paramsType.getEntry().add(createEntryElement(entry.getKey(),entry.getValue()));
    //			}
    //		}

    for (OperationResult subResult : opResult.getSubresults()) {
      result.getPartialResults().add(opResult.createOperationResultType(subResult));
    }

    return result;
  }