Exemple #1
0
  public static LogLevel fromLogLevel(final Level level) {

    if (Level.ALL.equals(level)) {
      return TRACE;
    }

    if (Level.TRACE.equals(level)) {
      return TRACE;
    }

    if (Level.DEBUG.equals(level)) {
      return DEBUG;
    }

    if (Level.INFO.equals(level)) {
      return INFO;
    }

    if (Level.WARN.equals(level)) {
      return WARN;
    }
    if (Level.ERROR.equals(level)) {
      return ERROR;
    }
    if (Level.FATAL.equals(level)) {
      return FATAL;
    }

    return UNKNOWN;
  }
  private void testLog4j(CustomAppender customAppender) {
    // Ensure there's no events
    List events = customAppender.getEvents();
    events.clear();

    Class clazz = getClass();
    Logger log4j = Logger.getLogger(clazz);
    log4j.debug(EXPECTED_MESSAGE);

    assertEquals(1, events.size());

    PaxLoggingEvent event = (PaxLoggingEvent) events.get(0);
    assertEquals(Level.DEBUG.getSyslogEquivalent(), event.getLevel().getSyslogEquivalent());
    assertEquals(EXPECTED_MESSAGE, event.getMessage());

    events.clear();
  }
 private boolean deleteLinkImpl(
     String dbid, long id1, long link_type, long id2, boolean noinverse, boolean expunge)
     throws Exception {
   if (Level.DEBUG.isGreaterOrEqual(debuglevel)) {
     logger.debug("deleteLink " + id1 + "." + id2 + "." + link_type);
   }
   String s = "wormhole...";
   dbid += "assocs";
   return getAssocClient()
           .TaoAssocDelete(
               dbid.getBytes(),
               link_type,
               id1,
               id2,
               AssocVisibility.HARD__DELETE,
               true,
               s.getBytes(),
               writeOptions)
       == 1;
 }
  private boolean addLinkImpl(String dbid, Link l, boolean noinverse) throws Exception {

    if (Level.DEBUG.isGreaterOrEqual(debuglevel)) {
      logger.debug("addLink " + l.id1 + "." + l.id2 + "." + l.link_type);
    }
    AssocVisibility av = AssocVisibility.values()[l.visibility];
    String s = "wormhole...";
    dbid += "assocs";
    return getAssocClient()
            .TaoAssocPut(
                dbid.getBytes(),
                l.link_type,
                l.id1,
                l.id2,
                l.time,
                av,
                true,
                Long.valueOf(l.version),
                l.data,
                s.getBytes(),
                writeOptions)
        == 1;
  }
/**
 * 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 */
  }
}