/** creates the given exception, but without propagating it, for use when caller will be wrapping */ public static Throwable create(Iterable<? extends Throwable> exceptions) { return create(null, exceptions); } /** creates the given exception, but without propagating it, for use when caller will be wrapping */
public static RuntimeException propagate(Iterable<? extends Throwable> exceptions) { throw propagate(create(exceptions)); } public static RuntimeException propagate(String prefix, Iterable<? extends Throwable> exceptions) {
public static RuntimeException propagate(String prefix, Iterable<? extends Throwable> exceptions) { throw propagate(create(prefix, exceptions)); }
private EntitySpec<?> resolve( Collection<EntitySpecResolver> resolvers, String localType, BrooklynClassLoadingContext loader, Set<String> encounteredTypes) { Collection<String> resolversWhoDontSupport = new ArrayList<String>(); Collection<Exception> otherProblemsFromResolvers = new ArrayList<Exception>(); for (EntitySpecResolver resolver : resolvers) { if (resolver.accepts(localType, loader)) { try { EntitySpec<?> spec = resolver.resolve(localType, loader, encounteredTypes); if (spec != null) { return spec; } else { resolversWhoDontSupport.add(resolver.getName() + " (returned null)"); } } catch (Exception e) { otherProblemsFromResolvers.add(new PropagatedRuntimeException("Transformer for "+resolver.getName()+" gave an error creating this plan: ", Exceptions.collapseText(e), e)); } } } if (!otherProblemsFromResolvers.isEmpty()) { // at least one thought he could do it log.debug("Type " + localType + " could not be resolved; failure will be propagated (other transformers tried = "+resolversWhoDontSupport+"): "+otherProblemsFromResolvers); throw otherProblemsFromResolvers.size()==1 ? Exceptions.create(null, otherProblemsFromResolvers) : Exceptions.create("ServiceSpecResolvers all failed", otherProblemsFromResolvers); } return null; }
result = otherProblemsFromTransformers.size()==1 ? Exceptions.create(null, otherProblemsFromTransformers) : Exceptions.create("All plan transformers failed", otherProblemsFromTransformers); } else { result = new UnsupportedTypePlanException("Invalid plan; format could not be recognized, trying with: "+transformersWhoDontSupport);
@Test public void test12CollapseCompound() throws Exception { RuntimeException e = Exceptions.create("test1", MutableSet.of(new IllegalStateException("test2"), new IllegalStateException("test3"))); assert12StandardChecks(e, false); }
@Test public void test12CollapsePropagatedExecutionCompoundBoring() throws Exception { RuntimeException e = new PropagatedRuntimeException("test1", new ExecutionException(Exceptions.create(MutableSet.of(new IllegalStateException("test2"), new IllegalStateException("test3"))))); assert12StandardChecks(e, true); }
throw new RuntimeException("No drivers could be found for "+driverInterface.getName()+"; " + "currently only SshMachineLocation is supported for autodetection (location "+location+")"); else throw Exceptions.create("No drivers could be loaded for "+driverInterface.getName()+" in "+location, exceptions);
private void validateAllTypes(Set<RegisteredType> installedTypes) { Stopwatch sw = Stopwatch.createStarted(); LOG.debug("Getting catalog to validate all types"); final BrooklynCatalog catalog = this.managementContext.getCatalog(); LOG.debug("Got catalog in {} now validate", sw.toString()); sw.reset(); sw.start(); Map<RegisteredType, Collection<Throwable>> validationErrors = catalog.validateTypes( installedTypes ); LOG.debug("Validation done in {}", sw.toString()); if (!validationErrors.isEmpty()) { Map<VersionedName, Map<RegisteredType,Collection<Throwable>>> errorsByBundle = MutableMap.of(); for (RegisteredType t: validationErrors.keySet()) { VersionedName vn = VersionedName.fromString(t.getContainingBundle()); Map<RegisteredType, Collection<Throwable>> errorsInBundle = errorsByBundle.get(vn); if (errorsInBundle==null) { errorsInBundle = MutableMap.of(); errorsByBundle.put(vn, errorsInBundle); } errorsInBundle.put(t, validationErrors.get(t)); } for (VersionedName vn: errorsByBundle.keySet()) { Map<RegisteredType, Collection<Throwable>> errorsInBundle = errorsByBundle.get(vn); ManagedBundle b = managementContext.getOsgiManager().get().getManagedBundle(vn); exceptionHandler.onCreateFailed(BrooklynObjectType.MANAGED_BUNDLE, b!=null ? b.getId() : /* just in case it was uninstalled concurrently somehow */ vn.toString(), vn.getSymbolicName(), Exceptions.create("Failed to install "+vn+", types "+errorsInBundle.keySet()+" gave errors", Iterables.concat(errorsInBundle.values()))); } } }
@Test public void test12CollapsePropagatedCompoundConcMod() throws Exception { RuntimeException e = new PropagatedRuntimeException("test1", new ExecutionException(Exceptions.create(MutableSet.of(new ConcurrentModificationException("test2"), new ConcurrentModificationException("test3"))))); assert12StandardChecks(e, true); assertContains(e, "ConcurrentModification"); }
return; // no errors } else { RuntimeException compoundException = Exceptions.create("Failure rebinding", allExceptions); LOG.debug(compoundException.getMessage()+" (rethrowing)"); throw compoundException;
Throwable t = Exceptions.create(appExceptions); throw new FatalRuntimeException("Error starting applications: "+Exceptions.collapseText(t), t);
Iterables.getOnlyElement(errors.values())); } else { throw Exceptions.create("Error starting referenced libraries in Brooklyn bundles "+errors.keySet(), errors.values());
+ (extraMessages.isEmpty() ? "" : " ("+Strings.join(extraMessages, " ")+")"), error); } else { return Maybe.absent(Exceptions.create("Unable to resolve class "+type+": "+bundleProblems + (extraMessages.isEmpty() ? "" : " ("+Strings.join(extraMessages, " ")+")"), bundleProblems.values()));
@Override public Maybe<Class<?>> tryLoadClass(String className) { List<Throwable> errors = MutableList.of(); for (BrooklynClassLoadingContext target: primaries) { Maybe<Class<?>> clazz = target.tryLoadClass(className); if (clazz.isPresent()) return clazz; errors.add( Maybe.getException(clazz) ); } boolean noPrimaryErrors = errors.isEmpty(); for (BrooklynClassLoadingContext target: secondaries) { Maybe<Class<?>> clazz = target.tryLoadClass(className); if (clazz.isPresent()) return clazz; if (noPrimaryErrors) errors.add( Maybe.getException(clazz) ); } return Maybe.absent(Exceptions.create("Unable to load "+className+" from "+primaries, errors)); }
cleanupFailedNodes(errors.keySet()); return ReferenceWithError.newInstanceMaskingError(result, Exceptions.create(errors.values()));
exceptionsInOrder.add(e); throw Exceptions.create("Unable to instantiate "+(symbolicName==null ? "item" : symbolicName), exceptionsInOrder);
throw propagate(Exceptions.create("failed to execute command", exceptions), "");
@Override public <SpecT extends AbstractBrooklynObjectSpec<?,?>> SpecT createSpec(RegisteredType type, @Nullable RegisteredTypeLoadingContext constraint, @Nullable Class<SpecT> specSuperType) { Preconditions.checkNotNull(type, "type"); if (type.getKind()==RegisteredTypeKind.SPEC) { return createSpec(type, type.getPlan(), type.getSymbolicName(), type.getVersion(), type.getSuperTypes(), constraint, specSuperType); } else if (type.getKind()==RegisteredTypeKind.UNRESOLVED) { if (constraint != null && constraint.getAlreadyEncounteredTypes().contains(type.getSymbolicName())) { throw new UnsupportedTypePlanException("Cannot create spec from type "+type+" (kind "+type.getKind()+"), recursive reference following "+constraint.getAlreadyEncounteredTypes()); } else { // try just-in-time validation Collection<Throwable> validationErrors = mgmt.getCatalog().validateType(type, constraint); if (!validationErrors.isEmpty()) { throw new ReferencedUnresolvedTypeException(type, true, Exceptions.create(validationErrors)); } type = mgmt.getTypeRegistry().get(type.getSymbolicName(), type.getVersion()); if (type==null || type.getKind()==RegisteredTypeKind.UNRESOLVED) { throw new ReferencedUnresolvedTypeException(type); } return createSpec(type, constraint, specSuperType); } } else { throw new UnsupportedTypePlanException("Cannot create spec from type "+type+" (kind "+type.getKind()+")"); } }