示例#1
0
  public static void setLogLevel(Logger log) {
    int level = 7; // E_DEFAULT
    switch (log.getEffectiveLevel().toInt()) {
      case Level.ALL_INT:
        level = 7; // E_FORCE
        break;
      case Level.TRACE_INT:
        level = 6; // E_TRACE
        break;
      case Level.DEBUG_INT:
        level = 5; // E_DEBUG
        break;
      case Level.INFO_INT:
        level = 4; // E_INFO
        break;
      case Level.WARN_INT:
        level = 3; // E_WARN
        break;
      case Level.ERROR_INT:
        level = 2; // E_ERROR
        break;
      case Level.FATAL_INT:
        level = 1; // E_FATAL
        break;
      case Level.OFF_INT:
        level = 0; // E_OFF
        break;
    }

    setLogLevel(level);
  }
示例#2
0
  public String debug() {
    if (logger.getEffectiveLevel().equals(Level.ALL)) {
      return "";
    }
    // otherwise we want output

    StringBuilder sb = new StringBuilder();
    sb.append("remove ");
    sb.append(m_from.printContour(m_removed));
    sb.append("\n");

    sb.append(" from ");
    sb.append(m_from.debugAsSentence());
    sb.append("\n");

    sb.append(" to ");
    sb.append(m_to.debugAsSentence());
    sb.append("\n");

    sb.append(" zonesMoved: ");
    Set<Map.Entry<AbstractBasicRegion, AbstractBasicRegion>> entries = m_zones_moved.entrySet();
    for (Map.Entry<AbstractBasicRegion, AbstractBasicRegion> z_map : entries) {
      sb.append("<");
      sb.append(z_map.getKey().debug());
      sb.append("->");
      sb.append(z_map.getValue().debug());
      sb.append(">");
    }
    return sb.toString();
  }
示例#3
0
 /** 获取Logger的日志级别. */
 @ManagedOperation(description = "Get logging level of the logger")
 @ManagedOperationParameters({
   @ManagedOperationParameter(name = "loggerName", description = "Logger name")
 })
 public String getLoggerLevel(String loggerName) {
   Logger logger = Logger.getLogger(loggerName);
   return logger.getEffectiveLevel().toString();
 }
示例#4
0
 private void displayLoggerLevel(Logger logger, PrintStream out, PrintStream err) {
   if (logger == null) {
     out.println("Logger not found");
     return;
   }
   Level level = logger.getEffectiveLevel();
   out.println(levelToString(level));
 }
示例#5
0
 /**
  * Write our internal representation to output stream <code>os</code>, in the appropriate way as
  * determined by our <code>type</code>.
  *
  * @param os os
  * @throws TransformerConfigurationException TransformerConfigurationException
  * @throws FileNotFoundException FileNotFoundException
  * @throws TransformerException TransformerException
  * @throws IOException IOException
  * @throws Exception Exception
  */
 public void writeTo(OutputStream os)
     throws TransformerConfigurationException, FileNotFoundException, TransformerException,
         IOException, Exception {
   if (type.isXMLType()) {
     if (writer == null) writer = new MaryNormalisedWriter();
     if (logger.getEffectiveLevel().equals(Level.DEBUG)) {
       ByteArrayOutputStream debugOut = new ByteArrayOutputStream();
       writer.output(xmlDocument, debugOut);
       logger.debug(debugOut.toString());
     }
     writer.output(xmlDocument, new BufferedOutputStream(os));
   } else if (type.isTextType()) { // caution: XML types are text types!
     writeTo(new OutputStreamWriter(os, "UTF-8"));
   } else { // audio
     logger.debug("Writing audio output, frame length " + audio.getFrameLength());
     AudioSystem.write(audio, audioFileFormat.getType(), os);
     os.flush();
     os.close();
   }
 }
示例#6
0
 /** Returns the level for this logger. */
 public Level getLevel() {
   return toJavaLevel(logger.getEffectiveLevel());
 }
示例#7
0
/**
 * Atomic write of a single block for a file version.
 *
 * @author <a href="mailto:[email protected]">Bryan Thompson</a>
 */
public class AtomicBlockWriteProc implements ISimpleIndexProcedure<Object>, Externalizable {

  private static final long serialVersionUID = 4982851251684333327L;

  protected static transient Logger log = Logger.getLogger(AtomicBlockWriteProc.class);

  /** True iff the {@link #log} level is INFO or less. */
  public static final transient boolean INFO =
      log.getEffectiveLevel().toInt() <= Level.INFO.toInt();

  /** True iff the {@link #log} level is DEBUG or less. */
  public static final transient boolean DEBUG =
      log.getEffectiveLevel().toInt() <= Level.DEBUG.toInt();

  private String id;
  private int version;
  private long block;
  private int off;
  private int len;
  private byte[] b;

  @Override
  public final boolean isReadOnly() {

    return false;
  }

  /**
   * @param id The file identifier.
   * @param version The file version.
   * @param block The block identifier.
   * @param b The buffer containing the data to be written.
   * @param off The offset in the buffer of the first byte to be written.
   * @param len The #of bytes to be written.
   */
  public AtomicBlockWriteProc(
      BigdataFileSystem repo, String id, int version, long block, byte[] b, int off, int len) {

    assert id != null && id.length() > 0;
    assert version >= 0;
    assert block >= 0 && block <= BigdataFileSystem.MAX_BLOCK;
    assert b != null;
    assert off >= 0 : "off=" + off;
    assert len >= 0 && off + len <= b.length;
    assert len <= repo.getBlockSize() : "len=" + len + " exceeds blockSize=" + repo.getBlockSize();

    this.id = id;
    this.version = version;
    this.block = block;
    this.off = off;
    this.len = len;
    this.b = b;
  }

  /**
   * This procedure runs on the unisolated index. The raw data is written directly onto the {@link
   * Journal} and the index is added/updated using the given file, version and block and the address
   * of the block's data on the {@link Journal}.
   *
   * @return A {@link Boolean} whose value is <code>true</code> iff the block was overwritten.
   */
  @Override
  public Object apply(final IIndex ndx) {

    // tunnel through to the backing journal.
    final AbstractJournal journal = (AbstractJournal) ((AbstractBTree) ndx).getStore();

    // obtain the thread-local key builder for that journal.
    final IKeyBuilder keyBuilder = ndx.getIndexMetadata().getKeyBuilder();

    /*
     * Write the block on the journal, obtaining the address at which it
     * was written - use 0L as the address for an empty block.
     */
    final long addr = len == 0 ? 0L : journal.write(ByteBuffer.wrap(b, off, len));

    // form the key for the index entry for this block.
    final byte[] key =
        keyBuilder
            .reset()
            .appendText(id, true /* unicode */, false /* successor */)
            .append(version)
            .append(block)
            .getKey();

    // record the address of the block in the index.
    final boolean overwrite;
    {
      final DataOutputBuffer out = new DataOutputBuffer(Bytes.SIZEOF_LONG);

      // encode the value for the entry.
      out.reset().putLong(addr);

      final byte[] val = out.toByteArray();

      // insert the entry into the index.
      overwrite = ndx.insert(key, val) != null;
    }

    log.info(
        "Wrote "
            + len
            + " bytes : id="
            + id
            + ", version="
            + version
            + ", block#="
            + block
            + " @ addr"
            + journal.toString(addr)
            + ", overwrite="
            + overwrite);

    return Boolean.valueOf(overwrite);
  }

  @Override
  public void readExternal(final ObjectInput in) throws IOException, ClassNotFoundException {

    id = in.readUTF();

    version = in.readInt();

    block = in.readLong();

    off = 0; // Note: offset always zero when de-serialized.

    len = in.readInt();

    b = new byte[len];

    in.readFully(b);
  }

  @Override
  public void writeExternal(final ObjectOutput out) throws IOException {

    out.writeUTF(id);

    out.writeInt(version);

    out.writeLong(block);

    /*
     * Note: offset not written when serialized and always zero when
     * de-serialized.
     */

    out.writeInt(len); /* length */

    out.write(b, off, len); /* data */
  }
}
示例#8
0
 private void printLoggerInfo(Logger logger, PrintStream out) {
   out.println(levelToString(logger.getEffectiveLevel()) + "\t\t" + logger.getName());
 }