public static ModifyServiceResponseType modifyService(final ModifyServiceType request)
     throws Exception {
   final ModifyServiceResponseType reply = request.getReply();
   try {
     if (NamedTransition.INSTANCE.apply(request)) {
       reply.markWinning();
     } else {
       Component.State nextState = Component.State.valueOf(request.getState().toUpperCase());
       ServiceConfiguration config = findService(request.getName());
       Topology.transition(nextState).apply(config).get();
       reply.markWinning();
     }
   } catch (Exception ex) {
     Exceptions.maybeInterrupted(ex);
     throw new EucalyptusCloudException(
         "Failed to execute request transition: "
             + request.getState()
             + "\nDue to:\n"
             + Throwables.getRootCause(ex).getMessage()
             + "\nPossible arguments are: \n"
             + "TRANSITIONS\n\t"
             + Joiner.on("\n\t").join(Topology.Transitions.values())
             + "STATES\n\t"
             + Joiner.on("\n\t").join(Component.State.values()),
         ex);
   }
   return reply;
 }
Пример #2
0
  @Override
  public void uncaughtException(Thread t, Throwable e) {
    /* In case of fatal errors we shut down. The wrapper script
     * will restart the domain. Notice that there is no guarantee
     * that the fatal error will not reoccur during shutdown and
     * in that case the shutdown may fail. We may want to consider
     * refining the shutdown logic such that in recovers if the
     * fatal error reoccurs.
     */
    if (e instanceof VirtualMachineError) {
      _oomSafetyBuffer = null;
      kill();
      _log.error(
          AlarmMarkerFactory.getMarker(
              PredefinedAlarm.FATAL_JVM_ERROR, getCellDomainName(), getCellName()),
          "Restarting due to fatal JVM error",
          e);
      return;
    }

    Throwable root = Throwables.getRootCause(e);
    if (root instanceof FileNotFoundException) {
      if (root.getMessage().contains("Too many open files")) {
        _log.error(
            AlarmMarkerFactory.getMarker(
                PredefinedAlarm.OUT_OF_FILE_DESCRIPTORS, getCellDomainName(), getCellName()),
            "Uncaught exception in thread " + t.getName(),
            e);
        return;
      }
    }

    _log.error("Uncaught exception in thread " + t.getName(), e);
  }
  @Override
  public SOid fromString(final String from) throws Exception {
    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug(String.format("fromString(from=%s)", from));
    }
    final SOid oid;
    final Stopwatch stopwatch = Stopwatch.createStarted();
    try {
      final String split[] = from.split(":");
      Assert.isTrue(
          split.length == 3,
          String.format("OID[%s] is invalid, it should be in format A:B:C", from));

      final String oidPrefix = split[TYPE_PREFIX_INDEX];
      final Class<?> oidClass = Class.forName(split[CLASS_NAME_INDEX]);
      final String oidId = split[ID_INDEX];

      oid = this.getOidObject(oidPrefix, oidClass, oidId);
    } catch (Exception exp) {
      LOGGER.error(
          String.format("fromString(from=%s) failed...", from), Throwables.getRootCause(exp));
      throw exp;
    }

    stopwatch.stop();

    if (LOGGER.isTraceEnabled()) {
      final long elapsed = stopwatch.elapsed(TimeUnit.MILLISECONDS);
      LOGGER.trace(
          String.format("fromString(from=%s) to SOid(oid=%s) took %d ms", from, oid, elapsed));
    }

    return oid;
  }
  // since surefire and eclipse don't otherwise guarantee the order, we are
  // starting this one alphabetically before create2nodes..
  @Test(enabled = true, dependsOnMethods = "testImagesCache")
  public void testAScriptExecutionAfterBootWithBasicTemplate() throws Exception {
    String tag = this.tag + "run";
    try {
      client.destroyNodesMatching(NodePredicates.withTag(tag));
    } catch (Exception e) {

    }

    TemplateOptions options = client.templateOptions().blockOnPort(22, 120);
    try {
      Set<? extends NodeMetadata> nodes = client.runNodesWithTag(tag, 1, options);
      Credentials good = nodes.iterator().next().getCredentials();
      assert good.account != null;
      assert good.key != null;

      Image image = Iterables.get(nodes, 0).getImage();
      try {
        Map<? extends NodeMetadata, ExecResponse> responses =
            runScriptWithCreds(tag, image.getOsFamily(), new Credentials(good.account, "romeo"));
        assert false : "shouldn't pass with a bad password\n" + responses;
      } catch (RunScriptOnNodesException e) {
        assert Throwables.getRootCause(e).getMessage().contains("Auth fail") : e;
      }

      runScriptWithCreds(tag, image.getOsFamily(), good);

      checkNodes(nodes, tag);

    } finally {
      client.destroyNodesMatching(NodePredicates.withTag(tag));
    }
  }
  @JavascriptEnabled
  @Test
  @Ignore(value = {CHROME, HTMLUNIT, IE, PHANTOMJS, SAFARI})
  public void shouldCatchErrorsWithMessageAndStacktraceWhenExecutingInitialScript() {
    driver.get(pages.ajaxyPage);
    String js =
        "function functionB() { throw Error('errormessage'); };"
            + "function functionA() { functionB(); };"
            + "functionA();";
    try {
      executor.executeAsyncScript(js);
      fail("Expected an exception");
    } catch (WebDriverException e) {
      assertThat(e.getMessage(), containsString("errormessage"));

      Throwable rootCause = Throwables.getRootCause(e);
      assertThat(rootCause.getMessage(), containsString("errormessage"));

      StackTraceElement[] st = rootCause.getStackTrace();
      boolean seen = false;
      for (StackTraceElement s : st) {
        if (s.getMethodName().equals("functionB")) {
          seen = true;
        }
      }
      assertTrue("Stacktrace has not js method info", seen);
    }
  }
Пример #6
0
 /** Test of chain method, of class ExceptionChain. */
 @Test
 public void testChain() {
   System.out.println("chain");
   Throwable t = new RuntimeException("", new SocketTimeoutException("Boo timeout"));
   Throwable newRootCause = new TimeoutException("Booo");
   Throwable result = ExceptionChain.chain(t, newRootCause);
   result.printStackTrace();
   Assert.assertEquals(newRootCause, Throwables.getRootCause(result));
   Assert.assertEquals(3, Throwables.getCausalChain(result).size());
 }
 private String getExceptionMessage(Throwable throwable, Integer statusCode) {
   if (throwable != null) {
     return Throwables.getRootCause(throwable).getMessage();
   }
   logger.info("statusCode : " + statusCode);
   if (statusCode != null) {
     HttpStatus httpStatus = HttpStatus.valueOf(statusCode);
     return httpStatus.getReasonPhrase();
   } else {
     return "";
   }
 }
Пример #8
0
 // Test that an exception thrown while handling a successful async connection get reported
 // as a failure on the client future.
 @Test
 public void testClientCreateFailure()
     throws InterruptedException, ExecutionException, TTransportException {
   try {
     createClient(MalformedService.class, syncServer).get();
     fail("Should not be able to successfully create a client for MalformedService.class");
   } catch (ExecutionException e) {
     Throwable rootCause = Throwables.getRootCause(e);
     assertTrue(rootCause instanceof IllegalArgumentException);
     assertTrue(rootCause.getMessage().startsWith("Type can not be coerced to a Thrift type"));
   }
 }
Пример #9
0
 public PaymentTransaction getPaymentTransactionWithRowLock(long paymentTransactionId) {
   PaymentTransaction paymentTransaction = null;
   EntityManager forActiveEntities = getEntityManagerForActiveEntities();
   Query createQuery =
       forActiveEntities.createQuery("select pt from PaymentTransaction pt where pt.id=:id");
   createQuery.setParameter("id", paymentTransactionId);
   createQuery.setLockMode(LockModeType.PESSIMISTIC_WRITE);
   try {
     paymentTransaction = (PaymentTransaction) createQuery.getSingleResult();
   } catch (NoResultException nre) {
     log.error(
         "Exception while executing PaymentDao.getPaymentTransactionWithRowLock():No payment transaction found for id ={}",
         paymentTransactionId,
         Throwables.getRootCause(nre));
   } catch (NonUniqueResultException nue) {
     log.error(
         "Exception while executing PaymentDao.getPaymentTransactionWithRowLock():Multiple payment transactions found for id ={}",
         paymentTransactionId,
         Throwables.getRootCause(nue));
   }
   return paymentTransaction;
 }
  @Override
  public VistaVeteranClinicalReminder extractData(String record) {
    // IEN^PRINT NAME^DUE DATE/TIME^LAST OCCURRENCE DATE/TIME
    // 500047^Hepatitis C risk Factor Screening^DUE NOW^^2^1^1^^^^0

    if (StringUtils.isBlank(record)) {
      return null;
    }

    VistaVeteranClinicalReminder vistaVeteranClinicalReminder = new VistaVeteranClinicalReminder();

    String[] fields = StringUtils.splitPreserveAllTokens(record, '^');

    // 0. IEN
    vistaVeteranClinicalReminder.setClinicalReminderIen(fields[0]);

    // 1. Name
    vistaVeteranClinicalReminder.setName(fields[1]);

    // 2. Due Date
    if (StringUtils.isNotBlank(fields[2])) {
      if (!"DUE NOW".equalsIgnoreCase(fields[2])) {
        Date dueDate = VistaUtils.convertVistaDate(fields[2]);

        if (dueDate != null) {
          vistaVeteranClinicalReminder.setDueDateString(
              clinicalReminderDueDateFormat.format(dueDate));
        }
      } else {
        vistaVeteranClinicalReminder.setDueDateString(fields[2]);
      }
    }
    // So, if piece 6 (5th index) is set to 1... then the reminder is “Due”. We can see this
    // reflected in the document Liz sent....
    // 918^Evaluation of + PTSD Screen^DUE NOW^^2^1^1^^^^1     <—Says “Due Now”, and piece 6 is set
    // to “1” for “Due”
    // <—snip—>
    // 265^Screen for PTSD^3151124.083813^3141124.083813^2^1^1^^^^1  <—Says due “3141124.083813”,
    // and piece 6 is set to “1” for “Due”
    int dueNowStatus = 0; // not due
    try {
      dueNowStatus = Integer.parseInt(fields[5]);
    } catch (NumberFormatException nfe) {
      logger.error(Throwables.getRootCause(nfe).getMessage());
    }
    vistaVeteranClinicalReminder.setDueNow(dueNowStatus == 1);

    return vistaVeteranClinicalReminder;
  }
Пример #11
0
 @Override
 public AdvancedAction apply(@Nonnull final Exception input) {
   Throwable rootCause = com.google.common.base.Throwables.getRootCause(input);
   if (rootCause instanceof RuntimeException) {
     return AdvancedAction.ABORT;
   }
   if (rootCause instanceof SQLTransientException
       || rootCause instanceof SQLRecoverableException
       || rootCause instanceof IOException
       || rootCause instanceof TimeoutException) {
     LOG.debug("Exception encountered, retrying...", input);
     return AdvancedAction.RETRY;
   }
   return AdvancedAction.ABORT;
 }
 protected Map<? extends NodeMetadata, ExecResponse> runScriptWithCreds(
     final String tag, OsFamily osFamily, Credentials creds) throws RunScriptOnNodesException {
   try {
     return client.runScriptOnNodesMatching(
         NodePredicates.runningWithTag(tag),
         buildScript(osFamily).getBytes(),
         RunScriptOptions.Builder.overrideCredentialsWith(creds));
   } catch (SshException e) {
     if (Throwables.getRootCause(e).getMessage().contains("Auth fail")) {
       // System.err.printf("bad credentials: %s:%s for %s%n",
       // creds.account, creds.key, client
       // .listNodesDetailsMatching(tag));
     }
     throw e;
   }
 }
Пример #13
0
 private Delete parse(final String statement) {
   Delete delete;
   try {
     Statement stmt;
     stmt = CCJSqlParserUtil.parse(statement);
     checkArgument(stmt instanceof Delete, "Expected DELETE statement: %s", statement);
     delete = (Delete) stmt;
   } catch (JSQLParserException e) {
     Throwables.propagateIfInstanceOf(Throwables.getRootCause(e), IllegalArgumentException.class);
     throw new IllegalArgumentException("Unable to parse query: " + e.getMessage(), e);
   }
   checkArgument(null == delete.getLimit(), "LIMIT is not supported for DELETE statements");
   checkArgument(
       null == delete.getOrderByElements(), "ORDER BY is not supported for DELETE statements");
   return delete;
 }
Пример #14
0
  /**
   * Creates a new remote context.
   *
   * @param provider
   * @param account nullable, if credentials are present in the overrides
   * @param key nullable, if credentials are present in the overrides
   * @param modules Configuration you'd like to pass to the context. Ex. ImmutableSet.<Module>of(new
   *     ExecutorServiceModule(myexecutor))
   * @param overrides properties to override defaults with.
   * @return initialized context ready for use
   */
  @SuppressWarnings("unchecked")
  public T createContext(
      String provider,
      @Nullable String account,
      @Nullable String key,
      Iterable<? extends Module> modules,
      Properties overrides) {
    checkNotNull(provider, "provider");
    checkNotNull(modules, "modules");
    checkNotNull(overrides, "overrides");
    String propertiesBuilderKey = String.format("%s.propertiesbuilder", provider);
    String propertiesBuilderClassName =
        checkNotNull(
            properties.getProperty(propertiesBuilderKey), provider + " service not supported");

    String contextBuilderKey = String.format("%s.contextbuilder", provider);
    String contextBuilderClassName =
        checkNotNull(properties.getProperty(contextBuilderKey), contextBuilderKey);

    String endpointKey = String.format("%s.endpoint", provider);
    String endpoint = properties.getProperty(endpointKey);
    try {
      Class<PropertiesBuilder> propertiesBuilderClass =
          (Class<PropertiesBuilder>) Class.forName(propertiesBuilderClassName);
      Class<B> contextBuilderClass = (Class<B>) Class.forName(contextBuilderClassName);
      PropertiesBuilder builder =
          propertiesBuilderClass.getConstructor(Properties.class).newInstance(overrides);
      if (key != null) builder.withCredentials(account, key);
      if (endpoint != null) builder.withEndpoint(URI.create(endpoint));
      B contextBuilder =
          (B)
              contextBuilderClass
                  .getConstructor(String.class, Properties.class)
                  .newInstance(provider, builder.build())
                  .withModules(Iterables.toArray(modules, Module.class));
      return build(contextBuilder);
    } catch (ProvisionException e) {
      Throwable throwable = Utils.firstRootCauseOrOriginalException(e);
      Throwables.propagate(throwable);
      assert false : "exception should have propogated " + e;
      return null;
    } catch (Exception e) {
      Throwables.propagate(Throwables.getRootCause(e));
      assert false : "exception should have propogated " + e;
      return null;
    }
  }
  @Override
  public void uncaughtException(Thread thread, Throwable exception) {
    try {
      Log.wtf("CORE_CONTROLLER::", Throwables.getRootCause(exception));
      Log.i("CORE_CONTROLLER::", "Exception Details:", exception);
      try {
        Toast.makeText(
                context,
                "An almost fatal exception occurred." + exception.getLocalizedMessage(),
                Toast.LENGTH_LONG)
            .show();
      } catch (Exception ex) {
        Log.i(ExtensibleOpMode.TAG, ex.getLocalizedMessage());
      }

      AlarmManager mgr = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
      mgr.set(AlarmManager.RTC, System.currentTimeMillis() + delay, pendingIntent);
      System.exit(2);
    } catch (Exception e) {
      Log.wtf("CORE_CONTROLLER::", e);
    }
  }
Пример #16
0
 // Handle a SelectionKey which was selected
 // Runs unlocked as the caller is single-threaded (or if not, should enforce that handleKey is
 // only called
 // atomically for a given ConnectionHandler)
 public static void handleKey(SelectionKey key) {
   ConnectionHandler handler = ((ConnectionHandler) key.attachment());
   try {
     if (handler == null) return;
     if (!key.isValid()) {
       handler.closeConnection(); // Key has been cancelled, make sure the socket gets closed
       return;
     }
     if (key.isReadable()) {
       // Do a socket read and invoke the parser's receiveBytes message
       int read = handler.channel.read(handler.readBuff);
       if (read == 0) return; // Was probably waiting on a write
       else if (read == -1) { // Socket was closed
         key.cancel();
         handler.closeConnection();
         return;
       }
       // "flip" the buffer - setting the limit to the current position and setting position to 0
       handler.readBuff.flip();
       // Use parser.receiveBytes's return value as a check that it stopped reading at the right
       // location
       int bytesConsumed = checkNotNull(handler.parser).receiveBytes(handler.readBuff);
       checkState(handler.readBuff.position() == bytesConsumed);
       // Now drop the bytes which were read by compacting readBuff (resetting limit and keeping
       // relative
       // position)
       handler.readBuff.compact();
     }
     if (key.isWritable()) handler.tryWriteBytes();
   } catch (Exception e) {
     // This can happen eg if the channel closes while the thread is about to get killed
     // (ClosedByInterruptException), or if handler.parser.receiveBytes throws something
     log.error("Error handling SelectionKey: {}", Throwables.getRootCause(e).getMessage());
     handler.closeConnection();
   }
 }
Пример #17
0
 @Override
 public boolean validate(final DatagramChannel object, final Exception e) throws Exception {
   return e == null || !(Throwables.getRootCause(e) instanceof IOException);
 }
 private static void checkInterrupted(Exception e) {
   Throwable cause = Throwables.getRootCause(e);
   if (cause instanceof InterruptedException || cause instanceof InterruptedIOException) {
     throw new AnalysisException("Analysis cancelled", e);
   }
 }
Пример #19
0
  public synchronized boolean ensureCerts(InstanceDescriptor id) throws Exception {
    boolean sslEnabled = false;
    for (Map.Entry<String, InstanceDescriptor.InstanceDescriptorPort> entry : id.ports.entrySet()) {
      if (entry.getValue().sslEnabled) {
        sslEnabled = true;
        break;
      }
    }
    boolean generated = false;
    if (sslEnabled) {
      SelfSigningCertGenerator generator = new SelfSigningCertGenerator();
      String password = passwordStore.password(id.instanceKey);
      File certFile = instancePath.certs("sslKeystore");

      boolean generateSSL = false;
      try {
        if (!certFile.exists() || !generator.validate(id.instanceKey, password, certFile)) {
          generateSSL = true;
        }
      } catch (IOException x) {
        if (Throwables.getRootCause(x) instanceof UnrecoverableKeyException) {
          LOG.warn(
              "Looks like password changed so existing certs will be replaced with regenerate certs.");
          generateSSL = true;
        } else {
          throw x;
        }
      }

      if (generateSSL) {
        FileUtils.deleteQuietly(certFile);
        generator.create(id.instanceKey, password, certFile);
        generated = true;
      }
    }

    File oauthKeystoreFile = instancePath.certs("oauthKeystore");
    File oauthPublicKeyFile = instancePath.certs("oauthPublicKey");
    String password = passwordStore.password(id.instanceKey);
    RSAKeyPairGenerator generator = new RSAKeyPairGenerator();

    boolean generateOauth = false;
    try {
      if (id.publicKey == null
          || !id.publicKey.equals(
              generator.getPublicKey(
                  id.instanceKey, password, oauthKeystoreFile, oauthPublicKeyFile))) {
        generateOauth = true;
      }
    } catch (IOException x) {
      if (Throwables.getRootCause(x) instanceof UnrecoverableKeyException) {
        LOG.warn(
            "Looks like password changed so existing oauth certs will be replaced with regenerate certs.");
        generateOauth = true;
      } else {
        throw x;
      }
    }
    if (generateOauth) {
      FileUtils.deleteQuietly(oauthKeystoreFile);
      FileUtils.deleteQuietly(oauthPublicKeyFile);
      generator.create(id.instanceKey, password, oauthKeystoreFile, oauthPublicKeyFile);
      upenaClient.updateKeyPair(
          id.instanceKey,
          generator.getPublicKey(id.instanceKey, password, oauthKeystoreFile, oauthPublicKeyFile));
    }
    return generated;
  }
Пример #20
0
 /**
  * Prints the message of the root cause of the {@link Throwable} as a build failure.
  *
  * @see #printBuildFailure(String)
  */
 public void printBuildFailureWithoutStacktrace(Throwable t) {
   LOG.warn(t, "Build error caused by exception");
   printBuildFailureInternal(Throwables.getRootCause(t).getMessage());
 }
Пример #21
0
  public Layer<T> transform(final Layer<T> source) throws IOException, XMLStreamException {
    this.source = source;
    this.target = configuration.start(source);

    try {
      source.stream(
          new Text.Consumer() {
            @Override
            public void consume(Reader sourceReader) throws IOException {
              XMLStreamReader xmlStream = null;
              try {
                xmlStream = xmlInputFactory.createXMLStreamReader(sourceReader);

                final Stack<XMLEntity> entities = new Stack<XMLEntity>();
                start();
                while (xmlStream.hasNext()) {
                  final int event = xmlStream.next();
                  mapOffsetDelta(0, xmlStream.getLocation().getCharacterOffset() - sourceOffset);

                  switch (event) {
                    case XMLStreamConstants.START_ELEMENT:
                      endText();
                      nextSibling();
                      start(entities.push(XMLEntity.newElement(xmlStream)));
                      break;
                    case XMLStreamConstants.END_ELEMENT:
                      endText();
                      end(entities.pop());
                      break;
                    case XMLStreamConstants.COMMENT:
                      endText();
                      nextSibling();
                      emptyEntity(XMLEntity.newComment(xmlStream));
                      break;
                    case XMLStreamConstants.PROCESSING_INSTRUCTION:
                      endText();
                      nextSibling();
                      emptyEntity(XMLEntity.newPI(xmlStream));
                      break;
                    case XMLStreamConstants.CHARACTERS:
                    case XMLStreamConstants.ENTITY_REFERENCE:
                    case XMLStreamConstants.CDATA:
                      newText(xmlStream.getText());
                      break;
                  }
                }
                end();
              } catch (XMLStreamException e) {
                throw Throwables.propagate(e);
              } finally {
                XML.closeQuietly(xmlStream);
              }
            }
          });
      Reader textReader = null;
      try {
        configuration.end(target, textReader = read());
        return target;
      } finally {
        Closeables.close(textReader, false);
      }
    } catch (Throwable t) {
      Throwables.propagateIfInstanceOf(t, IOException.class);
      Throwables.propagateIfInstanceOf(Throwables.getRootCause(t), XMLStreamException.class);
      throw Throwables.propagate(t);
    }
  }
 /** Handle exceptions thrown by handlers. */
 @org.springframework.web.bind.annotation.ExceptionHandler(value = Exception.class)
 public ModelAndView exception(Exception exception, WebRequest request) {
   ModelAndView modelAndView = new ModelAndView("error/general");
   modelAndView.addObject("errorMessage", Throwables.getRootCause(exception));
   return modelAndView;
 }
Пример #23
0
 public void testGetRootCause_DoubleWrapped() {
   SomeCheckedException cause = new SomeCheckedException();
   SomeChainingException exception =
       new SomeChainingException(new SomeChainingException(cause));
   assertSame(cause, Throwables.getRootCause(exception));
 }
Пример #24
0
 @ExceptionHandler(Throwable.class)
 @Order(Ordered.LOWEST_PRECEDENCE)
 public ModelAndView defaultHandler(HttpServletRequest req, Throwable e) throws Exception {
   log.error("Exception at request " + req.getRequestURL(), e);
   return processException(Throwables.getRootCause(e).getMessage());
 }
Пример #25
0
 public void testGetRootCause_NoCause() {
   SomeCheckedException exception = new SomeCheckedException();
   assertSame(exception, Throwables.getRootCause(exception));
 }