Java TableName.isSystemTable方法代码示例

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
@Override
public DeleteTracker postInstantiateDeleteTracker(
    ObserverContext<RegionCoprocessorEnvironment> ctx, DeleteTracker delTracker)
    throws IOException {
  // Nothing to do if we are not filtering by visibility
  if (!authorizationEnabled) {
    return delTracker;
  }
  Region region = ctx.getEnvironment().getRegion();
  TableName table = region.getRegionInfo().getTable();
  if (table.isSystemTable()) {
    return delTracker;
  }
  // We are creating a new type of delete tracker here which is able to track
  // the timestamps and also the
  // visibility tags per cell. The covering cells are determined not only
  // based on the delete type and ts
  // but also on the visibility expression matching.
  return new VisibilityScanDeleteTracker();
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
@Override
@edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "GC_UNRELATED_TYPES",
    justification = "I do not understand why the complaints, it looks good to me -- FIX")
protected void chore() {
  // Prefetch online tables/namespaces
  for (TableName table : QuotaCache.this.rsServices.getOnlineTables()) {
    if (table.isSystemTable()) continue;
    if (!QuotaCache.this.tableQuotaCache.contains(table)) {
      QuotaCache.this.tableQuotaCache.putIfAbsent(table, new QuotaState());
    }
    String ns = table.getNamespaceAsString();
    if (!QuotaCache.this.namespaceQuotaCache.contains(ns)) {
      QuotaCache.this.namespaceQuotaCache.putIfAbsent(ns, new QuotaState());
    }
  }

  fetchNamespaceQuotaState();
  fetchTableQuotaState();
  fetchUserQuotaState();
  lastUpdate = EnvironmentEdgeManager.currentTime();
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
private boolean prepareCreate(final MasterProcedureEnv env) throws IOException {
  final TableName tableName = getTableName();
  if (MetaTableAccessor.tableExists(env.getMasterServices().getConnection(), tableName)) {
    setFailure("master-create-table", new TableExistsException(getTableName()));
    return false;
  }
  // During master initialization, the ZK state could be inconsistent from failed DDL
  // in the past. If we fail here, it would prevent master to start.  We should force
  // setting the system table state regardless the table state.
  boolean skipTableStateCheck =
      !(env.getMasterServices().isInitialized()) && tableName.isSystemTable();
  if (!skipTableStateCheck) {
    TableStateManager tsm = env.getMasterServices().getAssignmentManager().getTableStateManager();
    if (tsm.isTableState(tableName, true, ZooKeeperProtos.Table.State.ENABLING,
        ZooKeeperProtos.Table.State.ENABLED)) {
      LOG.warn("The table " + tableName + " does not exist in meta but has a znode. " +
             "run hbck to fix inconsistencies.");
      setFailure("master-create-table", new TableExistsException(getTableName()));
      return false;
    }
  }
  return true;
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
/**
 * Initialize namespace state cache by scanning meta table.
 */
private void initialize() throws IOException {
  List<NamespaceDescriptor> namespaces = this.master.listNamespaceDescriptors();
  for (NamespaceDescriptor namespace : namespaces) {
    addNamespace(namespace.getName());
    List<TableName> tables = this.master.listTableNamesByNamespace(namespace.getName());
    for (TableName table : tables) {
      if (table.isSystemTable()) {
        continue;
      }
      int regionCount = 0;
      Map<HRegionInfo, ServerName> regions =
          MetaScanner.allTableRegions(this.master.getConnection(), table);
      for (HRegionInfo info : regions.keySet()) {
        if (!info.isSplit()) {
          regionCount++;
        }
      }
      addTable(table, regionCount);
    }
  }
  LOG.info("Finished updating state of " + nsStateCache.size() + " namespaces. ");
  initialized = true;
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
@Override
public KeyValueScanner preStoreScannerOpen(
    final ObserverContext<RegionCoprocessorEnvironment> c, Store store, final Scan scan,
    final NavigableSet<byte[]> targetCols, KeyValueScanner s) throws IOException {
  TableName tn = store.getTableName();
  if (!tn.isSystemTable()) {
    Long newTtl = ttls.get(store.getTableName());
    Integer newVersions = versions.get(store.getTableName());
    ScanInfo oldSI = store.getScanInfo();
    HColumnDescriptor family = store.getFamily();
    ScanInfo scanInfo = new ScanInfo(TEST_UTIL.getConfiguration(),
        family.getName(), family.getMinVersions(),
        newVersions == null ? family.getMaxVersions() : newVersions,
        newTtl == null ? oldSI.getTtl() : newTtl, family.getKeepDeletedCells(),
        oldSI.getTimeToPurgeDeletes(), oldSI.getComparator());
    return new StoreScanner(store, scanInfo, scan, targetCols,
        ((HStore) store).getHRegion().getReadpoint(IsolationLevel.READ_COMMITTED));
  } else {
    return s;
  }
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
/**
 * Check to make sure that the description of the snapshot requested is valid
 * @param snapshot description of the snapshot
 * @throws IllegalArgumentException if the name of the snapshot or the name of the table to
 *           snapshot are not valid names.
 */
public static void assertSnapshotRequestIsValid(HBaseProtos.SnapshotDescription snapshot)
    throws IllegalArgumentException {
  // make sure the snapshot name is valid
  TableName.isLegalTableQualifierName(Bytes.toBytes(snapshot.getName()), true);
  if(snapshot.hasTable()) {
    // make sure the table name is valid, this will implicitly check validity
    TableName tableName = TableName.valueOf(snapshot.getTable());

    if (tableName.isSystemTable()) {
      throw new IllegalArgumentException("System table snapshots are not allowed");
    }
  }
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
@Override
public RegionScanner preScannerOpen(ObserverContext<RegionCoprocessorEnvironment> e, Scan scan,
    RegionScanner s) throws IOException {
  if (!initialized) {
    throw new VisibilityControllerNotReadyException("VisibilityController not yet initialized!");
  }
  // Nothing to do if authorization is not enabled
  if (!authorizationEnabled) {
    return s;
  }
  Region region = e.getEnvironment().getRegion();
  Authorizations authorizations = null;
  try {
    authorizations = scan.getAuthorizations();
  } catch (DeserializationException de) {
    throw new IOException(de);
  }
  if (authorizations == null) {
    // No Authorizations present for this scan/Get!
    // In case of system tables other than "labels" just scan with out visibility check and
    // filtering. Checking visibility labels for META and NAMESPACE table is not needed.
    TableName table = region.getRegionInfo().getTable();
    if (table.isSystemTable() && !table.equals(LABELS_TABLE_NAME)) {
      return s;
    }
  }

  Filter visibilityLabelFilter = VisibilityUtils.createVisibilityLabelFilter(region,
      authorizations);
  if (visibilityLabelFilter != null) {
    Filter filter = scan.getFilter();
    if (filter != null) {
      scan.setFilter(new FilterList(filter, visibilityLabelFilter));
    } else {
      scan.setFilter(visibilityLabelFilter);
    }
  }
  return s;
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
@Override
public void preGetOp(ObserverContext<RegionCoprocessorEnvironment> e, Get get,
    List<Cell> results) throws IOException {
  if (!initialized) {
    throw new VisibilityControllerNotReadyException("VisibilityController not yet initialized");
  }
  // Nothing useful to do if authorization is not enabled
  if (!authorizationEnabled) {
    return;
  }
  Region region = e.getEnvironment().getRegion();
  Authorizations authorizations = null;
  try {
    authorizations = get.getAuthorizations();
  } catch (DeserializationException de) {
    throw new IOException(de);
  }
  if (authorizations == null) {
    // No Authorizations present for this scan/Get!
    // In case of system tables other than "labels" just scan with out visibility check and
    // filtering. Checking visibility labels for META and NAMESPACE table is not needed.
    TableName table = region.getRegionInfo().getTable();
    if (table.isSystemTable() && !table.equals(LABELS_TABLE_NAME)) {
      return;
    }
  }
  Filter visibilityLabelFilter = VisibilityUtils.createVisibilityLabelFilter(e.getEnvironment()
      .getRegion(), authorizations);
  if (visibilityLabelFilter != null) {
    Filter filter = get.getFilter();
    if (filter != null) {
      get.setFilter(new FilterList(filter, visibilityLabelFilter));
    } else {
      get.setFilter(visibilityLabelFilter);
    }
  }
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
AccessControlFilter(TableAuthManager mgr, User ugi, TableName tableName,
    Strategy strategy, Map<ByteRange, Integer> cfVsMaxVersions) {
  authManager = mgr;
  table = tableName;
  user = ugi;
  isSystemTable = tableName.isSystemTable();
  this.strategy = strategy;
  this.cfVsMaxVersions = cfVsMaxVersions;
  this.prevFam = new SimpleMutableByteRange();
  this.prevQual = new SimpleMutableByteRange();
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
/**
 * Returns the limiter associated to the specified user/table.
 * @param ugi the user to limit
 * @param table the table to limit
 * @return the limiter associated to the specified user/table
 */
public QuotaLimiter getUserLimiter(final UserGroupInformation ugi, final TableName table) {
  if (table.isSystemTable()) {
    return NoopQuotaLimiter.get();
  }
  return getUserQuotaState(ugi).getTableLimiter(table);
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
/**
 * Returns the quota for an operation.
 * @param ugi the user that is executing the operation
 * @param table the table where the operation will be executed
 * @return the OperationQuota
 */
public OperationQuota getQuota(final UserGroupInformation ugi, final TableName table) {
  if (isQuotaEnabled() && !table.isSystemTable()) {
    UserQuotaState userQuotaState = quotaCache.getUserQuotaState(ugi);
    QuotaLimiter userLimiter = userQuotaState.getTableLimiter(table);
    boolean useNoop = userLimiter.isBypass();
    if (userQuotaState.hasBypassGlobals()) {
      if (LOG.isTraceEnabled()) {
        LOG.trace("get quota for ugi=" + ugi + " table=" + table + " userLimiter=" + userLimiter);
      }
      if (!useNoop) {
        return new DefaultOperationQuota(userLimiter);
      }
    } else {
      QuotaLimiter nsLimiter = quotaCache.getNamespaceLimiter(table.getNamespaceAsString());
      QuotaLimiter tableLimiter = quotaCache.getTableLimiter(table);
      useNoop &= tableLimiter.isBypass() && nsLimiter.isBypass();
      if (LOG.isTraceEnabled()) {
        LOG.trace("get quota for ugi=" + ugi + " table=" + table + " userLimiter=" + userLimiter
            + " tableLimiter=" + tableLimiter + " nsLimiter=" + nsLimiter);
      }
      if (!useNoop) {
        return new DefaultOperationQuota(userLimiter, tableLimiter, nsLimiter);
      }
    }
  }
  return NoopOperationQuota.get();
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
public int getPriority(RPCProtos.RequestHeader header, Message param, User user) {
  // Yes this is copy pasted from the base class but it keeps from having to look in the
  // annotatedQos table twice something that could get costly since this is called for
  // every single RPC request.
  int priorityByAnnotation = getAnnotatedPriority(header);
  if (priorityByAnnotation >= 0) {
    return priorityByAnnotation;
  }

  // If meta is moving then all the other of reports of state transitions will be
  // un able to edit meta. Those blocked reports should not keep the report that opens meta from
  // running. Hence all reports of meta transitioning should always be in a different thread.
  // This keeps from deadlocking the cluster.
  if (param instanceof RegionServerStatusProtos.ReportRegionStateTransitionRequest) {
    // Regions are moving. Lets see which ones.
    RegionServerStatusProtos.ReportRegionStateTransitionRequest
        tRequest = (RegionServerStatusProtos.ReportRegionStateTransitionRequest) param;
    for (RegionServerStatusProtos.RegionStateTransition rst : tRequest.getTransitionList()) {
      if (rst.getRegionInfoList() != null) {
        for (HBaseProtos.RegionInfo info : rst.getRegionInfoList()) {
          TableName tn = ProtobufUtil.toTableName(info.getTableName());
          if (tn.isSystemTable()) {
            return HConstants.SYSTEMTABLE_QOS;
          }
        }
      }
    }
    return HConstants.NORMAL_QOS;
  }

  // Handle the rest of the different reasons to change priority.
  return getBasePriority(header, param);
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
private int getTablePriority(TableName tableName) {
  if (tableName.equals(TableName.META_TABLE_NAME)) {
    return metaTablePriority;
  } else if (tableName.isSystemTable()) {
    return sysTablePriority;
  }
  return userTablePriority;
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
private void checkTableTypeAndThrowException(TableName name) throws IOException {
  if (name.isSystemTable()) {
    LOG.debug("Namespace auditor checks not performed for table " + name.getNameAsString());
  } else {
    throw new HBaseIOException(name
        + " is being created even before namespace auditor has been initialized.");
  }
}
 

import org.apache.hadoop.hbase.TableName; //导入方法依赖的package包/类
@Override
public void setPriority(TableName tn) {
  super.setPriority(tn);
  // ignore counts for system tables - it could change and we really only want to check on what
  // the client should change
  if (!tn.isSystemTable()) {
    TABLE_PRIORITY.incrementAndGet();
  }

}