Java 类org.apache.hadoop.hbase.protobuf.generated.ErrorHandlingProtos.ForeignExceptionMessage 实例源码

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

@InterfaceAudience.Private
public ProcedureInfo(
    final long procId,
    final String procName,
    final String procOwner,
    final ProcedureState procState,
    final long parentId,
    final NonceKey nonceKey,
    final ForeignExceptionMessage exception,
    final long lastUpdate,
    final long startTime,
    final byte[] result) {
  this.procId = procId;
  this.procName = procName;
  this.procOwner = procOwner;
  this.procState = procState;
  this.parentId = parentId;
  this.nonceKey = nonceKey;
  this.lastUpdate = lastUpdate;
  this.startTime = startTime;

  // If the procedure is completed, we should treat exception and result differently
  this.exception = exception;
  this.result = result;
}

public static ForeignExceptionMessage toProtoForeignException(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack = toProtoStackTraceElement(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  return exception.build();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Converts a ForeignException to an array of bytes.
 * @param source the name of the external exception source
 * @param t the "local" external exception (local)
 * @return protobuf serialized version of ForeignException
 */
public static byte[] serialize(String source, Throwable t) {
  GenericExceptionMessage.Builder gemBuilder = GenericExceptionMessage.newBuilder();
  gemBuilder.setClassName(t.getClass().getName());
  if (t.getMessage() != null) {
    gemBuilder.setMessage(t.getMessage());
  }
  // set the stack trace, if there is one
  List<StackTraceElementMessage> stack =
      ForeignException.toStackTraceElementMessages(t.getStackTrace());
  if (stack != null) {
    gemBuilder.addAllTrace(stack);
  }
  GenericExceptionMessage payload = gemBuilder.build();
  ForeignExceptionMessage.Builder exception = ForeignExceptionMessage.newBuilder();
  exception.setGenericException(payload).setSource(source);
  ForeignExceptionMessage eem = exception.build();
  return eem.toByteArray();
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

public static IOException toIOException(final ForeignExceptionMessage eem) {
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement[] trace = toStackTrace(gem.getTraceList());
  RemoteException re = new RemoteException(gem.getClassName(), gem.getMessage());
  re.setStackTrace(trace);
  return re.unwrapRemoteException();
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

/**
 * Takes a series of bytes and tries to generate an ForeignException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static ForeignException deserialize(byte[] bytes) throws InvalidProtocolBufferException {
  // figure out the data we need to pass
  ForeignExceptionMessage eem = ForeignExceptionMessage.parseFrom(bytes);
  GenericExceptionMessage gem = eem.getGenericException();
  StackTraceElement [] trace = ForeignException.toStackTrace(gem.getTraceList());
  ProxyThrowable dfe = new ProxyThrowable(gem.getMessage(), trace);
  ForeignException e = new ForeignException(eem.getSource(), dfe);
  return e;
}

public ForeignExceptionMessage convert() {
  return ForeignExceptionUtil.toProtoForeignException(getSource(), getCause());
}

public static ForeignExceptionMessage toProto(String source, Throwable t) {
  return ForeignExceptionUtil.toProtoForeignException(source, t);
}

public static RemoteProcedureException fromProto(final ForeignExceptionMessage eem) {
  return new RemoteProcedureException(eem.getSource(), ForeignExceptionUtil.toIOException(eem));
}

public static void assertProcNotFailed(final ProcedureInfo result) {
  ForeignExceptionMessage exception = result.getForeignExceptionMessage();
  String msg = exception != null ? result.getExceptionFullMessage() : "no exception found";
  assertFalse(msg, result.isFailed());
}

@InterfaceAudience.Private
public ForeignExceptionMessage getForeignExceptionMessage() {
  return exception;
}

/**
 * Takes a series of bytes and tries to generate an RemoteProcedureException instance for it.
 * @param bytes
 * @return the ForeignExcpetion instance
 * @throws InvalidProtocolBufferException if there was deserialization problem this is thrown.
 */
public static RemoteProcedureException deserialize(byte[] bytes)
    throws InvalidProtocolBufferException {
  return fromProto(ForeignExceptionMessage.parseFrom(bytes));
}