Java LogWriter.info方法代码示例

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包/类
/**
 * Release the lock acquired in given mode by a previous call to
 * {@link #acquireLock} for the given object. Implementations of
 * {@link ExclusiveSharedLockObject} will typically throw an
 * {@link IllegalMonitorStateException} if no lock was acquired previously or
 * if the owner does not match.
 * 
 * @param lockObj
 *          the object that is locked
 * @param mode
 *          the <code>LockMode</code> to release the lock
 * @param lockOwner
 *          the owner of the lock; can be null
 * @param releaseAll
 *          release all the read/write locks on the object acquired by the
 *          <code>lockOwner</code>
 * @param context
 *          any context required to be passed to the
 *          {@link ExclusiveSharedLockObject#releaseLock} method that can be
 *          used by the particular locking implementation
 */
public final void releaseLock(ExclusiveSharedLockObject lockObj,
    LockMode mode, Object lockOwner, boolean releaseAll, Object context)
    throws IllegalMonitorStateException {
  if (mode != null) {
    LogWriter logger = null;
    if (ExclusiveSharedSynchronizer.TRACE_LOCK_COMPACT) {
      logger = GemFireCacheImpl.getExisting().getLogger();
      if (TXStateProxy.LOG_FINEST) {
        logger.info("LockingPolicy." + name() + ": releasing lock in mode "
            + mode + " on object: " + lockObj);
      }
    }
    lockObj.releaseLock(mode, releaseAll, lockOwner, context);
    if (logger != null) {
      logger.info("LockingPolicy." + name()
          + ": released lock in mode " + mode + " on object: "
          + (TXStateProxy.LOG_FINEST ? lockObj : ArrayUtils.objectRefString(
              lockObj) + "[lockState=0x" + Integer.toHexString(
                  lockObj.getState()) + ']'));
    }
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
public void logSizes(LogWriter lw, String msg) {
  long headAddr = topAddrUpdater.get(this);
  long addr;
  boolean concurrentModDetected;
  do {
    concurrentModDetected = false;
    addr = headAddr;
    while (addr != 0L) {
      int curSize = Chunk.getSize(addr);
      addr = Chunk.getNext(addr);
      long curHead = topAddrUpdater.get(this);
      if (curHead != headAddr) {
        headAddr = curHead;
        concurrentModDetected = true;
        // Someone added or removed from the stack.
        // So we break out of the inner loop and start
        // again at the new head.
        break;
      }
      // TODO construct a single log msg
      // that gets reset on the concurrent mad.
      lw.info(msg + curSize);
    }
  } while (concurrentModDetected);
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
protected void doCreateEntry(String name) {
  LogWriter log = getLogWriter();
  log.info(
      "<ExpectedException action=add>" +
      "dunit.RMIException"
      + "</ExpectedException>");

  Object[] args = new Object[] { name, };
  Host host = Host.getHost(0);
  VM vm = host.getVM(0);
  try {
    vm.invoke(this.getClass(), "createEntry", args);
  }
  catch (RMIException e) {
    // expected
  }

  log.info(
      "<ExpectedException action=add>" +
      "dunit.RMIException"
      + "</ExpectedException>");
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
public final static void renameFiles(List<File> files) {
  File[] targetFiles = new File[files.size()];
  for (int i = 0; i < files.size(); i++) {
    File dest = new File(files.get(i).getAbsolutePath().replaceAll("BACKUPSQLF", "BACKUPGFXD"));
    if (dest.exists()) {
      throw new GemFireIOException("Couldn't rename to destination file as it already exists " + dest);
    }
    targetFiles[i] = dest;
  }
  
  final String logMsg = "Renaming diskstore files from " + files + " to " + Arrays.toString(targetFiles);
  LogWriter logger = Misc.getCacheLogWriterNoThrow();
  if (logger != null) {
    logger.info(logMsg);
  }
  else {
    System.out.println(logMsg);
  }
  for (int i = 0; i < files.size(); i++) {
    files.get(i).renameTo(targetFiles[i]);
  }
}
 

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包/类
public static final void logInitMessage(int logLevel, String msg, Throwable t) {

      final GemFireCacheImpl cache = GemFireCacheImpl.getInstance();
      final GemFireCacheImpl.StaticSystemCallbacks sysCb;
      final LogWriter logger = cache != null ? cache.getLogger() : null;

      if (logger != null) {
        logger.info(msg);
      } else if (cache != null
          && (sysCb = GemFireCacheImpl.getInternalProductCallbacks()) != null) {
        sysCb.log(LogWriterImpl.levelToString(logLevel), msg);
      } else {
        System.out.println("NanoTimer::" + msg);
      }
    }
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
/**
 * A START task that reads the capacity for the
 * <code>RemoteBlockingQueue</code> and writes the chosen capacity
 * to the blackboard so that each VM the creates the
 * <code>RemoteBlockingQueue</code> can create it with the same
 * capacity
 */
public static void initialize() {
  if (!RBQPrms.useBlackboard()) {
    String s = "This test is not configured to use the blackboard";
    throw new HydraConfigException(s);
  }

  RBQBlackboard bb = RBQBlackboard.getBB();
  bb.initializeCapacity();

  // Show the initial values of the blackboard shared counters
  LogWriter log = Log.getLogWriter();
  log.info("Initial value of RBQBlackboard.MinOfferTime: " + 
           bb.getMinOfferTime());
  log.info("Initial value of RBQBlackboard.MaxOfferTime: " + 
           bb.getMaxOfferTime());
  log.info("Initial value of RBQBlackboard.MinPollTime: " + 
           bb.getMinPollTime());
  log.info("Initial value of RBQBlackboard.MaxPollTime: " + 
           bb.getMaxPollTime());
  log.info("Initial value of RBQBlackboard.NumOffers: " + 
           bb.getNumOffers());
  log.info("Initial value of RBQBlackboard.NumPolls: " + 
           bb.getNumPolls());
  log.info("Initial value of RBQBlackboard.MyCounter: " + 
           bb.getMyCounter());
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
private static void logInfo(String message, Throwable t) {
  LogWriter logger = Misc.getCacheLogWriterNoThrow();
  if (logger != null && logger.infoEnabled()) {
    logger.info(message, t);
  } else {
    SanityManager.DEBUG_PRINT(Level.INFO.toString().toLowerCase(), message, t);
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
@Override
public void execute() throws StandardException {
  LogWriter logger = Misc.getGemFireCache().getLoggerI18n()
      .convertToLogWriter();
  if (logger.infoEnabled()) {
    logger.info("GfxdRemoveLoaderMessage: Executing with fields as: "
        + this.toString());
  }
  CallbackProcedures.removeGfxdCacheLoaderLocally(CallbackProcedures
      .getContainerForTable(this.schema, this.table));
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
/**
 * @return
 */
private Runnable createWarningAlertRunnable(final int expectedAlerts) {
  return new SerializableRunnable("checkForWarningAlert") {
    public void run()
    {
      AdminDistributedSystem ads = (AdminDistributedSystem) singleToneAdmin.get();
      assertNotNull(ads);
      // Validate that a warning alert (via the warning log message) is generated
      TestAlertListener tal = TestAlertListener.getInstance();
      try {
        tal.waitForEventsWithSeverity(expectedAlerts, 
            com.gemstone.gemfire.internal.admin.Alert.WARNING);
      }
      catch (InterruptedException e) {
        fail("interrupted");
      }
      Alert[] al = tal.getAlerts();
      int numMatches = 0;
      LogWriter l = getLogWriter();
      for (int i=0; i<al.length; i++) {
        String msg = al[i].getMessage();
        l.info("Alert found with message: " + msg);
        if (msg != null &&
            (msg.lastIndexOf(PRHARedundancyProvider.INSUFFICIENT_STORES_MSG.toLocalizedString()) >= 0)) {
          numMatches++;
        }
      }
      assertEquals(expectedAlerts, numMatches);
      tal.resetList();
    }
  };
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
/**
 * @see PrintWriter#write(String, int, int)
 */
@Override
public void write(String s, int off, int len) {
  final LogWriter log;
  if ((log = this.logger) != null) {
    log.info(s.substring(off, off + len));
    this.skipPrintLnForLogger = true;
  }
  else {
    moveToEndOfStream();
    super.write(s, off, len);
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
public void testRootSnapshot() throws IOException, CacheException, ClassNotFoundException {
  final String name = this.getUniqueName();
  
  // create region in controller
  preSnapshotRegion = createRootRegion(name, getRegionAttributes());
  
  // create region in other VMs if distributed
  boolean isDistributed = getRegionAttributes().getScope().isDistributed();
  if (isDistributed) {
    invokeInEveryVM(new CacheSerializableRunnable("create presnapshot region") {
      public void run2() throws CacheException {
        preSnapshotRegion = createRootRegion(name, getRegionAttributes());
      }
    });
  }
  
  
  // add data to region in controller
  for (int i = 0; i < MAX_KEYS; i++) {
    if (i == MAX_KEYS-1) {
      // bug 33311 coverage
      preSnapshotRegion.create(String.valueOf(i), null);
    } else {
      preSnapshotRegion.create(String.valueOf(i), new Integer(i));
    }
  }
  
  // save snapshot
  File file = new File(name + ".snap");
  OutputStream out = new FileOutputStream(file);
  
  try {
    preSnapshotRegion.saveSnapshot(out);
    
    assertEquals(new Integer(5), preSnapshotRegion.get("5"));
    
    // destroy all data
    for (int i = 0; i < MAX_KEYS; i++) {
      preSnapshotRegion.destroy(String.valueOf(i));
    }
    
    assertTrue(preSnapshotRegion.keys().size() == 0);
    
    LogWriter log = getCache().getLogger();
    log.info("before loadSnapshot");
    //      DebuggerSupport.waitForJavaDebugger(getLogWriter());
    InputStream in = new FileInputStream(file);
    preSnapshotRegion.loadSnapshot(in);
    log.info("after loadSnapshot");
    
    // test postSnapshot behavior in controller
    log.info("before controller remoteTestPostSnapshot");
    remoteTestPostSnapshot(name, true, true);
    log.info("after controller remoteTestPostSnapshot");
    
    // test postSnapshot behavior in other VMs if distributed
    if (isDistributed) {
      log.info("before distributed remoteTestPostSnapshot");
      invokeInEveryVM(new CacheSerializableRunnable("postSnapshot") {
        public void run2() throws CacheException {
          RegionTestCase.this.remoteTestPostSnapshot(name, false, true);
        }
      });
      log.info("after distributed remoteTestPostSnapshot");
    }
  }
  finally {
    file.delete();
  }
}
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
/**
   * Insure queries on a pr is using index if not fail.
   */
  public CacheSerializableRunnable getCacheSerializableRunnableForIndexUsageCheck(final String name) {
    SerializableRunnable PrIndexCheck = new CacheSerializableRunnable("PrIndexCheck") {
      @Override
      public void run2() {
        Cache cache = getCache();
        
//        Region parRegion = cache.getRegion(name);
        QueryService qs = cache.getQueryService();
        LogWriter logger = cache.getLogger();
      
          Collection indexes = qs.getIndexes();
          Iterator it = indexes.iterator();
          while(it.hasNext()) {         
            //logger.info("Following indexes found : " + it.next());
            PartitionedIndex ind = (PartitionedIndex)it.next();
            /*List bucketIndex = ind.getBucketIndexes();
            int k = 0;
            logger.info("Total number of bucket index : "+bucketIndex.size());
            while ( k < bucketIndex.size() ){
              Index bukInd = (Index)bucketIndex.get(k);
              logger.info("Buket Index "+bukInd+"  usage : "+bukInd.getStatistics().getTotalUses());
              // if number of quries on pr change in getCacheSerializableRunnableForPRQueryAndCompareResults
              // literal 6  should change.
              //Asif :  With the optmization of Range Queries a where clause
              // containing something like ID > 4 AND ID < 9 will be evaluated 
              //using a single index lookup, so accordingly modifying the 
              //assert value from 7 to 6
              // Anil : With aquiringReadLock during Index.getSizeEstimate(), the
              // Index usage in case of "ID = 0 OR ID = 1" is increased by 3.
              int indexUsageWithSizeEstimation = 3;
              int expectedUse = 6;
              long indexUse = bukInd.getStatistics().getTotalUses();
              // Anil : With chnages to use single index for PR query evaluation, once the index
              // is identified the same index is used on other PR buckets, the sieEstimation is
              // done only once, which adds additional index use for only one bucket index.
              if (!(indexUse == expectedUse || indexUse == (expectedUse + indexUsageWithSizeEstimation))){
                fail ("Index usage is not as expected, expected it to be either " + 
                    expectedUse + " or " + (expectedUse + indexUsageWithSizeEstimation) + 
                    " it is: " + indexUse);
                //assertEquals(6 + indexUsageWithSizeEstimation, bukInd.getStatistics().getTotalUses());
              }
              k++;
            }*/
            //Shobhit: Now we dont need to check stats per bucket index,
            //stats are accumulated in single pr index stats.
            
            // Anil : With aquiringReadLock during Index.getSizeEstimate(), the
            // Index usage in case of "ID = 0 OR ID = 1" is increased by 3.
            int indexUsageWithSizeEstimation = 3;
            
            logger.info("index uses for "+ind.getNumberOfIndexedBuckets()+" index "+ind.getName()+": "+ind.getStatistics().getTotalUses());
            assertEquals(6*ind.getNumberOfIndexedBuckets(), ind.getStatistics().getTotalUses());
          }
          
      }

          
      
    };
    return (CacheSerializableRunnable) PrIndexCheck;
  }
 

import com.gemstone.gemfire.LogWriter; //导入方法依赖的package包/类
/**
   * Generates a "log file" whose entry timestamps are in a random
   * order.  Then it sorts the log file and asserts that the entries
   * are sorted order.
   */
  public void testRandomLog() throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    PrintWriter pw =
      new PrintWriter(new OutputStreamWriter(baos), true);
    LogWriter logger = new RandomLogWriter(pw);

    for (int i = 0; i < 100; i++) {
      logger.info(String.valueOf(i));
    }

    pw.flush();
    pw.close();
    
    byte[] bytes = baos.toByteArray();

//     System.out.println("RANDOM:");
//     System.out.println(new String(bytes));

    ByteArrayInputStream bais = new ByteArrayInputStream(bytes);

    StringWriter sw = new StringWriter();
    pw = new PrintWriter(sw, true);
    SortLogFile.sortLogFile(bais, pw);

    String sorted = sw.toString();
//     System.out.println("SORTED");
//     System.out.println(sorted);

    BufferedReader br = new BufferedReader(new StringReader(sorted));
    LogFileParser parser = new LogFileParser(null, br);
    String prevTimestamp = null;
    while (parser.hasMoreEntries()) {
      LogFileParser.LogEntry entry = parser.getNextEntry();
      String timestamp = entry.getTimestamp();
      if (prevTimestamp != null) {
        assertTrue("Prev: " + prevTimestamp + ", current: " + timestamp,
                   prevTimestamp.compareTo(timestamp) <= 0);
      }
      prevTimestamp = entry.getTimestamp();
    }
  }