public static boolean isRetryableException(Throwable th) {
   if (th == null) {
     Log.debug(Log.FRAMEWORK, "isRetryableException Unknown exception !");
     return false;
   } else if (th instanceof JMSException) {
     Log.debug(Log.FRAMEWORK, "isRetryableException JMSException detected.");
     return true;
   } else if (th instanceof NameNotFoundException) {
     Log.debug(Log.FRAMEWORK, "isRetryableException:  NameNotFoundException catched");
     return true;
   } else if (th instanceof NestingException) {
     NestingException nex = (NestingException) th;
     Class nextedExceptionClass = nex.getNestedExceptionClass();
     if (NameNotFoundException.class
         .getSimpleName()
         .equals(nextedExceptionClass.getSimpleName())) {
       Log.debug(
           Log.FRAMEWORK,
           "isRetryableException: GT nestedException: NameNotFoundException catched");
       return true;
     } else if (JMSException.class.getSimpleName().equals(nextedExceptionClass.getSimpleName())) {
       Log.debug(Log.FRAMEWORK, "isRetryableException: GT nestedException: JMSException catched");
       return true;
     } else {
       return false;
     }
   } else {
     Throwable ex = th.getCause();
     return isRetryableException(ex);
   }
 }
  /**
   * Send the JMS message (under new transaction) with Retry mechanism enable when encounter JMS
   * related error
   *
   * @param destName
   * @param msgObj
   * @param msgProps
   * @param jmsSendProps
   * @param isLocal
   * @throws Throwable
   */
  public static void sendMessage(
      String destName,
      Serializable msgObj,
      Hashtable msgProps,
      Hashtable<String, String> jmsSendProps,
      boolean isLocal)
      throws Throwable {
    boolean isRetryEnabled = _retryCount <= 0 ? false : true;
    int retryCount = _retryCount;
    Throwable th1 = null;

    do {
      try {
        sendJMS(isLocal, jmsSendProps, destName, msgObj, msgProps);
        retryCount = -10;
      } catch (Throwable th) {
        if (isRetryableException(th) && isRetryEnabled) {
          Log.warn(
              Log.FRAMEWORK,
              "sendMessageWithRetry: JMS exception found. Reconnect after "
                  + _sleepFor / 1000
                  + " num retry left: "
                  + retryCount,
              th);

          try {
            Thread.sleep(_sleepFor);
          } catch (Exception ex) {

          }
          Log.debug(Log.FRAMEWORK, "sendMessageWithRetry: JMS exception catched: wake up !");
          th1 = new JMSFailureException(th);

        } else {
          Log.warn(
              Log.FRAMEWORK,
              "sendMessageWithRetry: Non Retryable exception found. No retry will be performed.",
              th);
          throw th;
        }
      }
    } while (retryCount-- > 0);

    if (isRetryEnabled && retryCount == -1 && th1 != null) {
      Log.debug(
          Log.FRAMEWORK,
          "sendMessageWithRetry: JMS retry exhausted. exception is: " + th1.getMessage(),
          th1);
      throw th1;
    }
  }
  /**
   * Send the JMS message (under new transaction) with Retry mechanism enable when encounter JMS
   * related error. If the retry count has exceeded, that JMS will be stored into DB for later
   * retry.
   *
   * @param configName The JMS properties config name
   * @param destName
   * @param msgObj
   * @param msgProps
   * @throws Throwable
   */
  public static void sendMessageWithPersist(
      String configName, String destName, Serializable msgObj, Hashtable msgProps)
      throws Throwable {
    boolean isRetryEnabled = _retryCount <= 0 ? false : true;
    int retryCount = _retryCount;
    Throwable th1 = null;

    do {
      try {
        getJMSMgr().sendMessage(configName, destName, msgObj, msgProps);
        retryCount = -10;
      } catch (Throwable th) {
        if (isRetryableException(th) && isRetryEnabled) {
          Log.warn(
              Log.FRAMEWORK,
              "Send: JMS exception found. Reconnect after "
                  + _sleepFor / 1000
                  + " num retry left: "
                  + retryCount,
              th);

          try {
            Thread.sleep(_sleepFor);
          } catch (Exception ex) {

          }
          Log.debug(Log.FRAMEWORK, "Send: JMS exception catched: wake up !");
          th1 = th;

        } else {
          Log.warn(
              Log.FRAMEWORK,
              "Send: Non Retryable exception found. No retry will be performed.",
              th);
          throw th;
        }
      }
    } while (retryCount-- > 0);

    if (isRetryEnabled && retryCount == -1 && th1 != null) {
      Log.debug(Log.FRAMEWORK, "Send: JMS retry exhausted. exception is: " + th1.getMessage(), th1);
      dumpFailedJMS(
          JMS_DEST_TYPE_QUEUE, getJmsSetupPropsKey(configName), destName, msgObj, msgProps);
    }
  }
  /**
   * Broadcast the JMS msg under a new transaction. It will perform retry if encoutner retryable
   * exception. If exceed the max retry, exception will be propageted up.
   *
   * @param notification
   * @throws Exception
   */
  public static void broadcastInNewTrans(INotification notification) throws Exception {
    boolean isRetryEnabled = _retryCount <= 0 ? false : true;
    int retryCount = _retryCount;
    Exception ex1 = null;

    do {
      try {
        getLocalNotifierMgr().broadCastNotification(notification);
        retryCount = -10;
      } catch (Exception ex) {

        if (isRetryEnabled && isRetryableException(ex)) {
          ex1 = new JMSFailureException(ex);
          Log.warn(
              Log.FRAMEWORK,
              "Broadcast: JMS exception found. Reconnect after "
                  + _sleepFor / 1000
                  + " num retry left: "
                  + retryCount,
              ex);
          try {
            Thread.sleep(_sleepFor);
          } catch (Exception e) {

          }
          Log.debug(Log.FRAMEWORK, "Broadcast: JMS exception catched: wake up !");
        } else {
          Log.warn(
              Log.FRAMEWORK,
              "Broadcast: Non Retryable exception found. No retry will be performed.",
              ex);
          throw ex;
        }
      }
    } while (retryCount-- > 0);

    if (isRetryEnabled && retryCount == -1 && ex1 != null) {
      Log.debug(Log.FRAMEWORK, "Broadcast: JMS retry send exhausted. Throw up ex.", ex1);

      throw ex1;
    }
  }
  /**
   * Add an EntityMetaInfo into the factory. This does not add it to the database. If there is
   * existing EntityMetaInfo cached with the same ObjectName/EntityName, it will be replaced by this
   * metaInfo.
   *
   * @param metaInfo The EntityMetaInfo to add to the factory.
   */
  public void addEntityMetaInfo(EntityMetaInfo metaInfo) {
    _entityMap.put(metaInfo.getObjectName(), metaInfo);

    Log.debug(
        Log.DB,
        "[MetaInfoFactory.addEntityMetaInfo] "
            + "Add mapping for EntityName "
            + metaInfo.getEntityName()
            + " to ObjectName "
            + metaInfo.getObjectName());
    _entityNameMap.put(metaInfo.getEntityName(), metaInfo.getObjectName());
  }
 private static void sendJMS(
     boolean isLocal,
     Hashtable jmsSendProps,
     String destName,
     Serializable msgObj,
     Hashtable<String, String> msgProps)
     throws Exception {
   Log.debug(Log.FRAMEWORK, "sendJMS: isRemote:" + isLocal);
   if (!isLocal) {
     getRemoteJMSMgr().sendMessage(jmsSendProps, destName, msgObj, msgProps);
   } else {
     getJMSMgr().sendMessage(jmsSendProps, destName, msgObj, msgProps);
   }
 }
  private static void dumpFailedJMS(
      String destType,
      Hashtable<String, String> configProps,
      String destName,
      Serializable msgObj,
      Hashtable msgProps)
      throws Exception {
    JMSFailedMsg failedMsg = new JMSFailedMsg(destType, configProps, destName, msgObj, msgProps);

    // use DB
    try {
      Log.debug(Log.FRAMEWORK, "Persist failed jms to DB. Failed JMS: " + failedMsg);
      JMSFailedMsgHelper helper = JMSFailedMsgHelper.getInstance();
      helper.persistFailedJMSMsg(failedMsg);
    } catch (Exception ex) {
      Log.error("", Log.FRAMEWORK, "Failed to persist the failed jms to DB.", ex);
      throw ex;
    }
  }
  private static Hashtable<String, String> getJmsSetupPropsKey(String configName)
      throws ApplicationException {
    Configuration config = ConfigurationManager.getInstance().getConfig(configName);
    Properties prop = config.getProperties();
    Log.debug(Log.FRAMEWORK, "getJmsSetupPropsKey: " + prop);

    if (prop != null && prop.size() == 0) {
      throw new ApplicationException(
          "No properties file can be found given configName: " + configName);
    }

    Hashtable<String, String> configProps = new Hashtable<String, String>();
    Enumeration keys = prop.propertyNames();
    while (keys.hasMoreElements()) {
      String key = (String) keys.nextElement();
      configProps.put(key, (String) prop.get(key));
    }

    return configProps;
  }
Ejemplo n.º 9
0
 public static void debug(String msg, Throwable ex) {
   Log.debug(CATEGORY, msg, ex);
 }
Ejemplo n.º 10
0
 public static void debug(Object msg) {
   Log.debug(CATEGORY, msg);
 }
  /**
   * Broadcast the notification under a new transaction. Whenever encouter JMS retryable error, it
   * will perform retry until max retry has reached. If it happen, the JMS msg will be stored in the
   * DB.
   *
   * @param notification
   * @throws Exception
   */
  public static void broadcastWithPersist(INotification notification) throws Exception {
    boolean isRetryEnabled = _retryCount <= 0 ? false : true;
    int retryCount = _retryCount;
    Exception ex1 = null;

    do {
      try {
        getLocalNotifierMgr().broadCastNotification(notification);
        retryCount = -10;
      } catch (Exception ex) {

        if (isRetryEnabled && isRetryableException(ex)) {
          ex1 = ex;
          Log.warn(
              Log.FRAMEWORK,
              "Broadcast: JMS exception found. Reconnect after "
                  + _sleepFor / 1000
                  + " num retry left: "
                  + retryCount,
              ex);
          try {
            Thread.sleep(_sleepFor);
          } catch (Exception e) {

          }
          Log.debug(Log.FRAMEWORK, "Broadcast: JMS exception catched: wake up !");
        } else {
          Log.warn(
              Log.FRAMEWORK,
              "Broadcast: Non Retryable exception found. No retry will be performed.",
              ex);
          throw ex;
        }
      }
    } while (retryCount-- > 0);

    if (isRetryEnabled && retryCount == -1 && ex1 != null) {
      Log.debug(
          Log.FRAMEWORK,
          "Broadcast: JMS retry send exhausted. Dumping the out JMS message for later retry.",
          ex1);

      Hashtable<String, String> msgProps = new Hashtable<String, String>();
      msgProps.put("id", notification.getNotificationID());
      msgProps.put(SystemUtil.HOSTID_PROP_KEY, SystemUtil.getHostId());
      String[] properties = notification.getPropertyKeys();
      for (int i = 0; i < properties.length; i++) {
        Log.debug(
            Log.FRAMEWORK,
            "Broadcast: Adding msg props : key: "
                + properties[i]
                + " value: "
                + notification.getProperty(properties[i]));
        msgProps.put(properties[i], notification.getProperty(properties[i]));
      }

      // debug
      Hashtable<String, String> jmsConfigProps = Notifier.getInstance().getJmsSetupPropsKey();
      Log.debug(Log.FRAMEWORK, "JMSConfigProps is: " + jmsConfigProps);
      String destName = jmsConfigProps.get(JMSSender.JMS_DEST_NAME);

      dumpFailedJMS(
          JMS_DEST_TYPE_TOPIC,
          Notifier.getInstance().getJmsSetupPropsKey(),
          destName,
          notification,
          msgProps);
    }
  }