Java InterfaceAudience.Private方法代码示例

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@InterfaceAudience.Private
public Context(
    final Configuration conf,
    final FileSystem fs,
    final ReplicationPeerConfig peerConfig,
    final String peerId,
    final UUID clusterId,
    final ReplicationPeer replicationPeer,
    final MetricsSource metrics,
    final TableDescriptors tableDescriptors) {
  this.peerConfig = peerConfig;
  this.conf = conf;
  this.fs = fs;
  this.clusterId = clusterId;
  this.peerId = peerId;
  this.replicationPeer = replicationPeer;
  this.metrics = metrics;
  this.tableDescriptors = tableDescriptors;
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
/**
 * Helper to convert the protobuf object.
 * @return Convert the current Protocol Buffers Procedure to {@link ProcedureInfo}
 * instance.
 */
@InterfaceAudience.Private
public static ProcedureInfo convert(final ProcedureProtos.Procedure procProto) {
  NonceKey nonceKey = null;
  if (procProto.getNonce() != HConstants.NO_NONCE) {
    nonceKey = new NonceKey(procProto.getNonceGroup(), procProto.getNonce());
  }

  return new ProcedureInfo(
    procProto.getProcId(),
    procProto.getClassName(),
    procProto.getOwner(),
    procProto.getState(),
    procProto.hasParentId() ? procProto.getParentId() : -1,
    nonceKey,
    procProto.hasException() ? procProto.getException() : null,
    procProto.getLastUpdate(),
    procProto.getStartTime(),
    procProto.hasResult() ? procProto.getResult().toByteArray() : null);
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@InterfaceAudience.Private
public Context(
    final Configuration conf,
    final FileSystem fs,
    final ReplicationPeerConfig peerConfig,
    final String peerId,
    final UUID clusterId,
    final ReplicationPeer replicationPeer,
    final MetricsSource metrics) {
  this.peerConfig = peerConfig;
  this.conf = conf;
  this.fs = fs;
  this.clusterId = clusterId;
  this.peerId = peerId;
  this.replicationPeer = replicationPeer;
  this.metrics = metrics;
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@InterfaceAudience.Private
public static Connector createDefaultChannelConnector() {
  SelectChannelConnector ret = new SelectChannelConnector();
  ret.setLowResourceMaxIdleTime(10000);
  ret.setAcceptQueueSize(128);
  ret.setResolveNames(false);
  ret.setUseDirectBuffers(false);
  if(Shell.WINDOWS) {
    // result of setting the SO_REUSEADDR flag is different on Windows
    // http://msdn.microsoft.com/en-us/library/ms740621(v=vs.85).aspx
    // without this 2 NN's can start on the same machine and listen on
    // the same port with indeterminate routing of incoming requests to them
    ret.setReuseAddress(false);
  }
  ret.setHeaderBufferSize(1024*64);
  return ret;
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@InterfaceAudience.Private
public static ThreadPoolExecutor getDefaultExecutor(Configuration conf) {
  int maxThreads = conf.getInt("hbase.htable.threads.max", Integer.MAX_VALUE);
  if (maxThreads == 0) {
    maxThreads = 1; // is there a better default?
  }
  long keepAliveTime = conf.getLong("hbase.htable.threads.keepalivetime", 60);

  // Using the "direct handoff" approach, new threads will only be created
  // if it is necessary and will grow unbounded. This could be bad but in HCM
  // we only create as many Runnables as there are region servers. It means
  // it also scales when new region servers are added.
  ThreadPoolExecutor pool = new ThreadPoolExecutor(1, maxThreads, keepAliveTime, TimeUnit.SECONDS,
      new SynchronousQueue<Runnable>(), Threads.newDaemonThreadFactory("htable"));
  pool.allowCoreThreadTimeOut(true);
  return pool;
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@Override
@InterfaceAudience.Private
public void callMethod(Descriptors.MethodDescriptor method,
                       RpcController controller,
                       Message request, Message responsePrototype,
                       RpcCallback<Message> callback) {
  Message response = null;
  try {
    response = callExecService(method, request, responsePrototype);
  } catch (IOException ioe) {
    LOG.warn("Call failed on IOException", ioe);
    ResponseConverter.setControllerException(controller, ioe);
  }
  if (callback != null) {
    callback.run(response);
  }
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
/**
 * Marked as audience Private as of 1.2.0.
 * Creating a Cell with tags and a memstoreTS/mvcc is an internal implementation detail not for
 * public use.
 */
@InterfaceAudience.Private
public static Cell createCell(final byte[] row, final byte[] family, final byte[] qualifier,
    final long timestamp, final byte type, final byte[] value, byte[] tags, final long memstoreTS) {
  KeyValue keyValue = new KeyValue(row, family, qualifier, timestamp,
      KeyValue.Type.codeToType(type), value, tags);
  keyValue.setSequenceId(memstoreTS);
  return keyValue;
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
/**
 * limits the amount of logging to once per coprocessor class.
 * Used in concert with {@link #useLegacyMethod(Class, String, Class[])} when a runtime issue
 * prevents properly supporting the legacy version of a coprocessor API.
 * Since coprocessors can be in tight loops this serves to limit the amount of log spam we create.
 */
@InterfaceAudience.Private
protected void legacyWarning(final Class<? extends Coprocessor> clazz, final String message) {
  if(legacyWarning.add(clazz)) {
    LOG.error("You have a legacy coprocessor loaded and there are events we can't map to the " +
        " deprecated API. Your coprocessor will not see these events.  Please update '" + clazz +
        "'. Details of the problem: " + message);
  }
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
/**
 * Sets the given seqId to the cell.
 * Marked as audience Private as of 1.2.0.
 * Setting a Cell sequenceid is an internal implementation detail not for general public use.
 * @param cell
 * @param seqId
 * @throws IOException when the passed cell is not of type {@link SettableSequenceId}
 */
@InterfaceAudience.Private
public static void setSequenceId(Cell cell, long seqId) throws IOException {
  if (cell instanceof SettableSequenceId) {
    ((SettableSequenceId) cell).setSequenceId(seqId);
  } else {
    throw new IOException(new UnsupportedOperationException("Cell is not of type "
        + SettableSequenceId.class.getName()));
  }
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@InterfaceAudience.Private
protected ScannerCallableWithReplicas getScannerCallable(byte [] localStartKey,
    int nbRows) {
  scan.setStartRow(localStartKey);
  ScannerCallable s =
      new ScannerCallable(getConnection(), getTable(), scan, this.scanMetrics,
          this.rpcControllerFactory);
  s.setCaching(nbRows);
  ScannerCallableWithReplicas sr = new ScannerCallableWithReplicas(tableName, getConnection(),
   s, pool, primaryOperationTimeout, scan,
   retries, scannerTimeout, caching, conf, caller);
  return sr;
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@Override
@InterfaceAudience.Private
public Message callBlockingMethod(Descriptors.MethodDescriptor method,
                                  RpcController controller,
                                  Message request, Message responsePrototype)
    throws ServiceException {
  try {
    return callExecService(controller, method, request, responsePrototype);
  } catch (IOException ioe) {
    throw new ServiceException("Error calling method "+method.getFullName(), ioe);
  }
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
@InterfaceAudience.Private
protected void init(final byte [] encodedRegionName, final TableName tablename,
    long logSeqNum, final long now, List<UUID> clusterIds, long nonceGroup, long nonce) {
  this.logSeqNum = logSeqNum;
  this.writeTime = now;
  this.clusterIds = clusterIds;
  this.encodedRegionName = encodedRegionName;
  this.tablename = tablename;
  this.nonceGroup = nonceGroup;
  this.nonce = nonce;
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
/**
 * <em> INTERNAL </em> Private constructor used internally creating table descriptors for
 * catalog tables, <code>hbase:meta</code> and <code>-ROOT-</code>.
 */
@InterfaceAudience.Private
protected HTableDescriptor(final TableName name, HColumnDescriptor[] families) {
  setName(name);
  for(HColumnDescriptor descriptor : families) {
    this.families.put(descriptor.getName(), descriptor);
  }
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
/**
 * Create a new RetriesExhaustedException from the list of prior failures.
 * @param numTries
 * @param exceptions List of exceptions that failed before giving up
 */
@InterfaceAudience.Private
public RetriesExhaustedException(final int numTries,
                                 final List<ThrowableWithExtraContext> exceptions) {
  super(getMessage(numTries, exceptions),
      (exceptions != null && !exceptions.isEmpty() ?
          exceptions.get(exceptions.size() - 1).t : null));
}
 

import org.apache.hadoop.hbase.classification.InterfaceAudience; //导入方法依赖的package包/类
/**
 * Creates an object to access a HBase table.
 * Used by HBase internally.  DO NOT USE. See {@link ConnectionFactory} class comment for how to
 * get a {@link Table} instance (use {@link Table} instead of {@link HTable}).
 * @param tableName Name of the table.
 * @param connection HConnection to be used.
 * @param pool ExecutorService to be used.
 * @throws IOException if a remote or network exception occurs
 */
@InterfaceAudience.Private
public HTable(TableName tableName, final ClusterConnection connection,
    final TableConfiguration tableConfig,
    final RpcRetryingCallerFactory rpcCallerFactory,
    final RpcControllerFactory rpcControllerFactory,
    final ExecutorService pool) throws IOException {
  if (connection == null || connection.isClosed()) {
    throw new IllegalArgumentException("Connection is null or closed.");
  }
  this.tableName = tableName;
  this.cleanupConnectionOnClose = false;
  this.connection = connection;
  this.configuration = connection.getConfiguration();
  this.tableConfiguration = tableConfig;
  this.pool = pool;
  if (pool == null) {
    this.pool = getDefaultExecutor(this.configuration);
    this.cleanupPoolOnClose = true;
  } else {
    this.cleanupPoolOnClose = false;
  }

  this.rpcCallerFactory = rpcCallerFactory;
  this.rpcControllerFactory = rpcControllerFactory;

  this.finishSetup();
}