Java Stanza类代码示例

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
public static CacheDirectiveInfo readCacheDirectiveInfo(Stanza st)
    throws InvalidXmlException {
  CacheDirectiveInfo.Builder builder =
      new CacheDirectiveInfo.Builder();
  builder.setId(Long.parseLong(st.getValue("ID")));
  String path = st.getValueOrNull("PATH");
  if (path != null) {
    builder.setPath(new Path(path));
  }
  String replicationString = st.getValueOrNull("REPLICATION");
  if (replicationString != null) {
    builder.setReplication(Short.parseShort(replicationString));
  }
  String pool = st.getValueOrNull("POOL");
  if (pool != null) {
    builder.setPool(pool);
  }
  String expiryTime = st.getValueOrNull("EXPIRATION");
  if (expiryTime != null) {
    builder.setExpiration(CacheDirectiveInfo.Expiration.newAbsolute(
        Long.parseLong(expiryTime)));
  }
  return builder.build();
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
public static CachePoolInfo readCachePoolInfo(Stanza st)
    throws InvalidXmlException {
  String poolName = st.getValue("POOLNAME");
  CachePoolInfo info = new CachePoolInfo(poolName);
  if (st.hasChildren("OWNERNAME")) {
    info.setOwnerName(st.getValue("OWNERNAME"));
  }
  if (st.hasChildren("GROUPNAME")) {
    info.setGroupName(st.getValue("GROUPNAME"));
  }
  if (st.hasChildren("MODE")) {
    info.setMode(FSEditLogOp.fsPermissionFromXml(st));
  }
  if (st.hasChildren("LIMIT")) {
    info.setLimit(Long.parseLong(st.getValue("LIMIT")));
  }
  if (st.hasChildren("MAXRELATIVEEXPIRY")) {
    info.setMaxRelativeExpiryMs(
        Long.parseLong(st.getValue("MAXRELATIVEEXPIRY")));
  }
  return info;
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
@Override 
void fromXml(Stanza st) throws InvalidXmlException {
  this.length = Integer.parseInt(st.getValue("LENGTH"));
  this.inodeId = Long.parseLong(st.getValue("INODEID"));
  this.path = st.getValue("PATH");
  this.replication = Short.valueOf(st.getValue("REPLICATION"));
  this.mtime = Long.parseLong(st.getValue("MTIME"));
  this.atime = Long.parseLong(st.getValue("ATIME"));
  this.blockSize = Long.parseLong(st.getValue("BLOCKSIZE"));

  this.clientName = st.getValue("CLIENT_NAME");
  this.clientMachine = st.getValue("CLIENT_MACHINE");
  this.overwrite = Boolean.parseBoolean(st.getValueOrNull("OVERWRITE"));
  if (st.hasChildren("BLOCK")) {
    List<Stanza> blocks = st.getChildren("BLOCK");
    this.blocks = new Block[blocks.size()];
    for (int i = 0; i < blocks.size(); i++) {
      this.blocks[i] = FSEditLogOp.blockFromXml(blocks.get(i));
    }
  } else {
    this.blocks = new Block[0];
  }
  this.permissions = permissionStatusFromXml(st);
  aclEntries = readAclEntriesFromXml(st);
  readRpcIdsFromXml(st);
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
public static DelegationTokenIdentifier delegationTokenFromXml(Stanza st)
    throws InvalidXmlException {
  String kind = st.getValue("KIND");
  if (!kind.equals(DelegationTokenIdentifier.
      HDFS_DELEGATION_KIND.toString())) {
    throw new InvalidXmlException("can't understand " +
      "DelegationTokenIdentifier KIND " + kind);
  }
  int seqNum = Integer.parseInt(st.getValue("SEQUENCE_NUMBER"));
  String owner = st.getValue("OWNER");
  String renewer = st.getValue("RENEWER");
  String realuser = st.getValue("REALUSER");
  long issueDate = Long.parseLong(st.getValue("ISSUE_DATE"));
  long maxDate = Long.parseLong(st.getValue("MAX_DATE"));
  int masterKeyId = Integer.parseInt(st.getValue("MASTER_KEY_ID"));
  DelegationTokenIdentifier token =
      new DelegationTokenIdentifier(new Text(owner),
          new Text(renewer), new Text(realuser));
  token.setSequenceNumber(seqNum);
  token.setIssueDate(issueDate);
  token.setMaxDate(maxDate);
  token.setMasterKeyId(masterKeyId);
  return token;
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
private static List<AclEntry> readAclEntriesFromXml(Stanza st) {
  List<AclEntry> aclEntries = Lists.newArrayList();
  if (!st.hasChildren("ENTRY"))
    return null;

  List<Stanza> stanzas = st.getChildren("ENTRY");
  for (Stanza s : stanzas) {
    AclEntry e = new AclEntry.Builder()
      .setScope(AclEntryScope.valueOf(s.getValue("SCOPE")))
      .setType(AclEntryType.valueOf(s.getValue("TYPE")))
      .setName(s.getValueOrNull("NAME"))
      .setPermission(fsActionFromXml(s)).build();
    aclEntries.add(e);
  }
  return aclEntries;
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
private static List<XAttr> readXAttrsFromXml(Stanza st)
    throws InvalidXmlException {
  if (!st.hasChildren("XATTR")) {
    return null;
  }

  List<Stanza> stanzas = st.getChildren("XATTR");
  List<XAttr> xattrs = Lists.newArrayListWithCapacity(stanzas.size());
  for (Stanza a: stanzas) {
    XAttr.Builder builder = new XAttr.Builder();
    builder.setNameSpace(XAttr.NameSpace.valueOf(a.getValue("NAMESPACE"))).
        setName(a.getValue("NAME"));
    String v = a.getValueOrNull("VALUE");
    if (v != null) {
      try {
        builder.setValue(XAttrCodec.decodeValue(v));
      } catch (IOException e) {
        throw new InvalidXmlException(e.toString());
      }
    }
    xattrs.add(builder.build());
  }
  return xattrs;
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
void readRpcIdsFromXml(Stanza st) {
  this.rpcClientId = st.hasChildren("RPC_CLIENTID") ? 
      ClientId.toBytes(st.getValue("RPC_CLIENTID"))
      : RpcConstants.DUMMY_CLIENT_ID;
  this.rpcCallId = st.hasChildren("RPC_CALLID") ? 
      Integer.parseInt(st.getValue("RPC_CALLID"))
      : RpcConstants.INVALID_CALL_ID;
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
public static Block blockFromXml(Stanza st)
    throws InvalidXmlException {
  long blockId = Long.parseLong(st.getValue("BLOCK_ID"));
  long numBytes = Long.parseLong(st.getValue("NUM_BYTES"));
  long generationStamp = Long.parseLong(st.getValue("GENSTAMP"));
  return new Block(blockId, numBytes, generationStamp);
}
 

import org.apache.hadoop.hdfs.util.XMLUtils.Stanza; //导入依赖的package包/类
public static PermissionStatus permissionStatusFromXml(Stanza st)
    throws InvalidXmlException {
  Stanza status = st.getChildren("PERMISSION_STATUS").get(0);
  String username = status.getValue("USERNAME");
  String groupname = status.getValue("GROUPNAME");
  FsPermission mode = fsPermissionFromXml(status);
  return new PermissionStatus(username, groupname, mode);
}