Java LogWriter类代码示例

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
private void checkLoadLib(final String testName) {
  invokeInEveryVM(new SerializableRunnable("verifying for " + testName) {
    
    @Override
    public void run() {
      
      GemFireStore store = Misc.getMemStoreBootingNoThrow();
      LogWriter log = getLogWriter();
      
      if (store == null) {
        log.info("SB: server not booted");
        return;
      }
      
      if (!store.getMyVMKind().isAccessorOrStore()) {
        log.info("SB: not a server or accessor.");
        return;
      }

      TestUtil.assertTimerLibraryLoaded();
    }
  });
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
static void loadSampleData(LogWriter logw, Connection conn, int numOfRows, String tabname, int startVal) throws SQLException {
  String tablename = schemaName + "." + tabname;
  logw.info("Loading data (" 
      + numOfRows + " rows..."
      + startVal + " as start value)...");
  String[] securities = { "IBM", "INTC", "MOT", "TEK", "AMD", "CSCO", "DELL",
      "HP", "SMALL1", "SMALL2" };

  PreparedStatement psInsert = conn
  .prepareStatement("insert into " + tablename + " values (?, ?, ?, ?, ?, ?)");
  for (int i = 0; i < numOfRows; i++) {
    int baseId = i + startVal;
    String custName = "CustomerWithaLongName" + baseId;
    psInsert.setInt(1, baseId);
    psInsert.setString(2, custName);
    psInsert.setInt(3, baseId); // max volume is 500
    psInsert.setString(4, securities[baseId%10]);
    psInsert.setInt(5, 0);
    String queryString = "Emperors club for desperate men, "
      + "Washington DC, District of Columbia";
    psInsert.setString(6, queryString);
    psInsert.executeUpdate();
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
public static boolean stopNetServer() {
  if (netServer != null) {
    com.gemstone.gemfire.LogWriter logger = null;
    try {
      logger = getLogger();
      netServer.stop();
      logger.info(netServer.status() + " gemfirexd network server on host "
          + SocketCreator.getLocalHost().getHostName());
    } catch (Exception ex) {
      if (logger != null) {
        logger.error("Failed in gemfirexd network server shutdown", ex);
      }
      fail("Failed in gemfirexd network server shutdown: " + ex);
    }
    netServer = null;
    return true;
  }
  return false;
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
public static void main(String[] args) throws InterruptedException {
  DistributedSystem system =
    DistributedSystem.connect(new Properties());
  LogWriter logger = system.getLogWriter();

  for (int i = 0; i < 100; i++) {
    logger.finest("Finest message");
    Thread.sleep(500);
    logger.finer("Finer message");
    Thread.sleep(500);
    logger.fine("Fine message");
    Thread.sleep(500);
    logger.config("Config message");
    Thread.sleep(500);
    logger.info("Info message");
    Thread.sleep(500);
    logger.warning("Warning message");
    Thread.sleep(500);
    logger.severe("Severe message");
    Thread.sleep(500);
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
@Override
protected void processMessage(DistributionManager dm) {
  LogWriter logger = dm.getLoggerI18n().convertToLogWriter();
  try {
    this.executeLocally(dm, this.dumpBackingMap);
  } catch (Exception ex) {
    // Log a severe log in case of an exception
    if (logger.severeEnabled()) {
      logger.severe("GfxdDumpLocalResultMessage: SQL exception in executing "
          + "message with fields as " + this.toString(), ex);
    }
    if (this.processorId > 0 || dm == null) {
      throw new ReplyException("Unexpected SQLException on member "
          + dm.getDistributionManagerId(), ex);
    }
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
public void executeFunctionReturningArgs(FunctionContext context) {
  DistributedSystem ds = InternalDistributedSystem.getAnyInstance();
  LogWriter logger = ds.getLogWriter();
  logger.info(
      "Executing executeFunctionReturningArgs in TestFunction on Member : "
          + ds.getDistributedMember()+ "with Context : " + context);
  if (!hasResult()) {
    return;
  }
  Object[] args = (Object[])context.getArguments();
  if(args != null){
    context.getResultSender().lastResult(args[0]);
  }else{
    context.getResultSender().lastResult(Boolean.FALSE);      
  }
  

}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
/**
 * @see PrintWriter#println()
 */
@Override
public void println() {
  final LogWriter log;
  if ((log = this.logger) != null) {
    if (!this.skipPrintLnForLogger) {
      log.info(SanityManager.lineSeparator);
    }
    else {
      this.skipPrintLnForLogger = false;
    }
  }
  else {
    moveToEndOfStream();
    super.println();
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
@Override
public int getLogSeverityLevel() {
  final LogWriter log = getLogger();
  if (log != null) {
    // report everything for fine-level and higher
    if (log.fineEnabled()) {
      return ExceptionSeverity.NO_APPLICABLE_SEVERITY;
    }
    // for info-level, only report STATEMENT_SEVERITY or higher
    if (log.infoEnabled()) {
      return ExceptionSeverity.STATEMENT_SEVERITY;
    }
    // for warning-level, only report SESSION_SEVERITY or higher
    if (log.warningEnabled()) {
      return ExceptionSeverity.SESSION_SEVERITY;
    }
    // for severe-level, only report DATABASE_SEVERITY or higher
    if (log.severeEnabled()) {
      return ExceptionSeverity.DATABASE_SEVERITY;
    }
    // if none of the above then only report SYSTEM_SEVERITY errors
    return ExceptionSeverity.SYSTEM_SEVERITY;
  }
  return super.getLogSeverityLevel();
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
public String getRandomClient() {
  LogWriter logger = Log.getLogWriter();
  Map<String, String> map = (Map<String, String>) getSharedMap().get(CONNECTOR_URL_LIST);
  if (map.size() > 0) {
    Random r = new Random();
    int randomKey = r.nextInt(map.size());
    Set<String> keys = map.keySet();
    Object keysarray[] = keys.toArray();
    String clientName = (String) keysarray[randomKey];
    logger.info("URL for client " + clientName + " is " + map.get(clientName));
    String url = map.get(clientName);
    return url;
  } else
    return null;

}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
@Override
public boolean printStackTrace(Throwable error, int logSeverityLevel) {
  if (logSeverityLevel >= ExceptionSeverity.STATEMENT_SEVERITY) {
    // avoid logging stack traces for constraint violations, conflicts, syntax
    // errors etc.
    if (error instanceof StandardException) {
      StandardException se = (StandardException)error;
      if (se.getSQLState().startsWith(SQLState.INTEGRITY_VIOLATION_PREFIX)
          || se.getSQLState().startsWith(
              SQLState.GFXD_OPERATION_CONFLICT_PREFIX)) {
        return false;
      }
      // also skip stacks for all syntax errors at log-level < fine
      final LogWriter log = getLogger();
      if (log != null && !log.fineEnabled()) {
        if (se.getSQLState().startsWith(SQLState.LSE_COMPILATION_PREFIX)) {
          return false;
        }
      }
    }
  }
  return true;
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
public CacheSerializableRunnable loadRegion(
    final String name)
{
  CacheSerializableRunnable sr = new CacheSerializableRunnable("load region on " + name) {
    public void run2()
    {
      Cache cache = getCache();
      LogWriter logger = cache.getLogger();
      Region region = cache.getRegion(name);
      for (int i=0; i < 100; i++){
        region.put("" +i, new Portfolio(i));
      }        
    }
  };
  return sr;
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
private void report(ClassTraverser c) throws IllegalArgumentException,
    IllegalAccessException {

  if (!logObjectGraph) {
    return;
  }

  LogWriter logger = Misc.getCacheLogWriter();

  StringBuilder sb = c.getStack("");
  if (sb == null) {
    return;
  }
  String msg = sb.append("===== EOF ======").toString();
  logger.info(msg);
  System.out.println(msg);
  msg = null;
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
/**
 * Sends a PartitionedRegion PutAllPRMessage to the recipient
 * @param recipients the members to which the put message is sent
 * @param r  the PartitionedRegion for which the put was performed
 * @return the processor used to await acknowledgement that the update was
 *         sent, or null to indicate that no acknowledgement will be sent
 * @throws ForceReattemptException if the peer is no longer available
 */
public PartitionResponse send(final Set<DistributedMember> recipients, PartitionedRegion r)
    throws ForceReattemptException {
  //Assert.assertTrue(recipient != null, "PutAllPRMessage NULL recipient");  recipient can be null for event notifications
  //Set recipients = Collections.singleton(recipient);
  PutAllResponseFromRemote p = new PutAllResponseFromRemote(r.getSystem(), recipients,
      getTXState(), this);
  initMessage(r, recipients, false, p);
  final LogWriter logger = r.getCache().getLogger();
  if (logger.fineEnabled()) {
    logger.fine("PutAllPRMessage.send: recipients are "+recipients+", msg is "+this);
  }

  Set failures =r.getDistributionManager().putOutgoing(this);
  if (failures != null && failures.size() > 0) {
    throw new ForceReattemptException("Failed sending <" + this + ">");
  }
  return p;
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
/**
 * Sets the loglevel for the provided log writer
 * @param l  the {@link LogWriter}
 * @param logLevl the new log level as specified in {@link LogWriterImpl}
 * @return the old log level
 */
public static int setLogLevel(LogWriter l, int logLevl)
{
  int ret = -1;
  l.config("PartitionedRegionDUnitTest attempting to set log level on LogWriter instance class:" + l.getClass().getName());
  if (l instanceof PureLogWriter) {
    
      PureLogWriter pl = (PureLogWriter) l;
      ret = pl.getLevel();
      l.config("PartitiionedRegionDUnitTest forcing log level to " + LogWriterImpl.levelToString(logLevl) 
          + " from "  +  LogWriterImpl.levelToString(ret));
      pl.setLevel(logLevl);
  } else if (l instanceof AnyLogWriter) {
      AnyLogWriter al = (AnyLogWriter) l;
      ret = al.getLevel();
      l.config("PartitiionedRegionDUnitTest forcing log level to " + LogWriterImpl.levelToString(logLevl) 
          + " from "  +  LogWriterImpl.levelToString(ret));
      al.setLevel(logLevl);
  }
  return ret;
}
 

import com.gemstone.gemfire.LogWriter; //导入依赖的package包/类
@Override
public void execute(FunctionContext context) {
  try {
    String regionPath = (String) context.getArguments();
    if (regionPath == null) {
      throw new IllegalArgumentException(CliStrings.CREATE_REGION__MSG__SPECIFY_VALID_REGION_PATH);
    }
    FetchRegionAttributesFunctionResult<?, ?> result = getRegionAttributes(regionPath);
    context.getResultSender().lastResult(result);
  } catch (IllegalArgumentException e) {
    LogWriter logger = CacheFactory.getAnyInstance().getLogger();
    if (logger.fineEnabled()) {
      logger.fine(e);
    }
    context.getResultSender().lastResult(e);
  }
}