@Override
public synchronized T fetchEntity()
throws EntityNotFoundException, EntityVersionMismatchException {
EntityClientEndpoint endpoint = null;
try {
ClientInstanceID clientInstanceID =
new ClientInstanceID(this.nextClientInstanceID.getAndIncrement());
EntityDescriptor entityDescriptor =
new EntityDescriptor(getEntityID(), clientInstanceID, this.version);
endpoint =
this.entityManager.fetchEntity(
entityDescriptor, entityClientService.getMessageCodec(), null);
} catch (EntityException e) {
// In this case, we want to close the endpoint but still throw back the exception.
// Note that we must externally only present the specific exception types we were expecting.
// Thus, we need to check
// that this is one of those supported types, asserting that there was an unexpected wire
// inconsistency, otherwise.
if (e instanceof EntityNotFoundException) {
throw (EntityNotFoundException) e;
} else if (e instanceof EntityVersionMismatchException) {
throw (EntityVersionMismatchException) e;
} else {
throw Assert.failure("Unsupported exception type returned to fetch", e);
}
} catch (final Throwable t) {
Util.printLogAndRethrowError(t, logger);
}
// Note that a failure to resolve the endpoint would have thrown so this can't be null.
if (endpoint == null) {
Assert.assertNotNull(endpoint);
}
return (T) entityClientService.create(endpoint);
}
@Override
public C reconfigure(C configuration) throws EntityException {
EntityID entityID = getEntityID();
try {
return entityClientService.deserializeConfiguration(
this.entityManager
.reconfigureEntity(
entityID, this.version, entityClientService.serializeConfiguration(configuration))
.get());
} catch (EntityException e) {
throw ExceptionUtils.addLocalStackTraceToEntityException(e);
} catch (InterruptedException e) {
// We don't expect an interruption here.
throw new RuntimeException(e);
}
}
@Override
public void create(C configuration)
throws EntityNotProvidedException, EntityAlreadyExistsException,
EntityVersionMismatchException {
EntityID entityID = getEntityID();
try {
this.entityManager
.createEntity(
entityID, this.version, entityClientService.serializeConfiguration(configuration))
.get();
} catch (EntityException e) {
// Note that we must externally only present the specific exception types we were expecting.
// Thus, we need to check
// that this is one of those supported types, asserting that there was an unexpected wire
// inconsistency, otherwise.
e = ExceptionUtils.addLocalStackTraceToEntityException(e);
if (e instanceof EntityNotProvidedException) {
throw (EntityNotProvidedException) e;
} else if (e instanceof EntityAlreadyExistsException) {
throw (EntityAlreadyExistsException) e;
} else if (e instanceof EntityVersionMismatchException) {
throw (EntityVersionMismatchException) e;
} else {
// WARNING: Assert.failure returns an exception, instead of throwing one.
throw Assert.failure("Unsupported exception type returned to create", e);
}
} catch (InterruptedException e) {
// We don't expect an interruption here.
throw new RuntimeException(e);
}
}
