private int predictSerializedSize() { int size = 0; size += 4; // int: Number of parameters. size += 1; // byte: Type of the 1st parameter. size += 3; // vint: region name length (3 bytes => max length = 32768). size += region.name().length; // The region name. size += 1; // byte: Type of the 2nd parameter. size += 3; // vint: row key length (3 bytes => max length = 32768). size += key.length; // The row key. return size; }
private int predictSerializedSize() { int size = 0; size += 4; // int: Number of parameters. size += 1; // byte: Type of the 1st parameter. size += 3; // vint: region name length (3 bytes => max length = 32768). size += region.name().length; // The region name. size += 1; // byte: Type of the 2nd parameter. size += 3; // vint: row key length (3 bytes => max length = 32768). size += key.length; // The row key. size += 1; // byte: Type of the 3rd parameter. size += 1; // vint: Family length (guaranteed on 1 byte). size += family.length; // The family. size += 1; // byte: Type of the 4th parameter. size += 3; // vint: Qualifier length. size += qualifier.length; // The qualifier. size += 1; // byte: Type of the 5th parameter. size += 8; // long: Amount. size += 1; // byte: Type of the 6th parameter. size += 1; // bool: Whether or not to write to the WAL. return size; }
private int predictSerializedSize() { int size = 0; size += 4; // int: Number of parameters. size += 1; // byte: Type of the 1st parameter. size += 3; // vint: region name length (3 bytes => max length = 32768). size += region.name().length; // The region name. size += 1; // byte: Type of the 2nd parameter. size += 3; // vint: row key length (3 bytes => max length = 32768). size += key.length; // The row key. size += 1; // byte: Type of the 3rd parameter. size += 1; // vint: Family length (guaranteed on 1 byte). size += family.length; // The family. size += 1; // byte: Type of the 4th parameter. size += 3; // vint: Qualifier length. for(byte[] qualifier : qualifiers) { size += qualifier.length; // The qualifier. } size += 1; // byte: Type of the 5th parameter. size += 8 * amounts.length; // long: Amount. size += 1; // byte: Type of the 6th parameter. size += 1; // bool: Whether or not to write to the WAL. return size; }
/** * Adds an RPC to this batch. * <p> * @param rpc The RPC to add in this batch. * @throws IllegalArgumentException if the edit specifies an explicit row lock. * Edits with locks cannot be batched * @throws IllegalArgumentException if the region was missing from the RPC */ public void add(final BatchableRpc rpc) { if (rpc.lockid != RowLock.NO_LOCK) { throw new AssertionError("Should never happen! We don't do multi-put" + " with RowLocks but we've been given an edit that has one!" + " edit=" + rpc + ", this=" + this); } if (rpc.region == null || rpc.region.name() == null) { throw new IllegalArgumentException("RPC " + rpc + " is missing the region or region name"); } batch.add(rpc); }
/** * Predicts a lower bound on the serialized size of this RPC. * This is to avoid using a dynamic buffer, to avoid re-sizing the buffer. * Since we use a static buffer, if the prediction is wrong and turns out * to be less than what we need, there will be an exception which will * prevent the RPC from being serialized. That'd be a severe bug. */ private int predictSerializedSize() { int size = 0; size += 4; // int: Number of parameters. size += 1; // byte: Type of the 1st parameter. size += 3; // vint: region name length (3 bytes => max length = 32768). size += region.name().length; // The region name. size += predictPutSize(); return size; }
/** * Predicts a lower bound on the serialized size of this RPC. * This is to avoid using a dynamic buffer, to avoid re-sizing the buffer. * Since we use a static buffer, if the prediction is wrong and turns out * to be less than what we need, there will be an exception which will * prevent the RPC from being serialized. That'd be a severe bug. */ private int predictSerializedSize() { int size = 0; size += 4; // int: Number of parameters. size += 1; // byte: Type of the 1st parameter. size += 3; // vint: region name length (3 bytes => max length = 32768). size += region.name().length; // The region name. size += predictAppendSize(); size += 4; // int: Number of attributes size += 4; // int: length of the attribute name size += 4; // char[]: attribute name size += 1; // vint: attribute length size += 1; // vint: attribute value return size; }
/** * Package private ctor as we want read-only information for the caller to play * with. We'll make copies of all of the arrays so that the user can't modify * anything used by AsyncHBase internally. * @param region_info The region info to pull the table, name and stop key from * @param start_key The start key of the region * @param host The region server hosting the region. May be null if the region * isn't hosted anywhere. * @param port The port for the region server. May be zero if the region isn't * hosted anywhere. */ RegionLocation(RegionInfo region_info, byte[] start_key, String host, int port) { table = Arrays.copyOf(region_info.table(), region_info.table().length); region_name = Arrays.copyOf(region_info.name(), region_info.name().length); // may be an empty array but shouldn't be null stop_key = Arrays.copyOf(region_info.stopKey(), region_info.stopKey().length); this.start_key = Arrays.copyOf(start_key, start_key.length); this.host = host; this.port = port; }
ChannelBuffer serialize(final byte server_version) { // num param + type 1 + region length + region + type 2 + long final ChannelBuffer buf = newBuffer(server_version, + 4 + 1 + 3 + region.name().length + 1 + 8); buf.writeInt(2); // Number of parameters. writeHBaseByteArray(buf, region.name()); writeHBaseLong(buf, lock.id()); return buf; }
public RowLock call(final Object response) { if (response instanceof Long) { return new RowLock(request.getRegion().name(), (Long) response); } else { throw new InvalidResponseException(Long.class, response); } } public String toString() {
/** Serializes this request. */ ChannelBuffer serialize(final byte server_version) { if (server_version >= RegionClient.SERVER_VERSION_095_OR_ABOVE) { throw new UnsupportedOperationException("Row locks are not supported with" + " this version of HBase (" + server_version + ")."); } final ChannelBuffer buf = newBuffer(server_version, predictSerializedSize()); buf.writeInt(2); // Number of parameters. writeHBaseByteArray(buf, region.name()); writeHBaseByteArray(buf, key); return buf; }
private int predictSerializedSize() { int size = 0; size += 4; // int: Number of parameters. size += 1; // byte: Type of the 1st parameter. size += 3; // vint: region name length (3 bytes => max length = 32768). size += region.name().length; // The region name. size += 1; // byte: Type of the 2nd parameter. size += 3; // vint: row key length (3 bytes => max length = 32768). size += key.length; // The row key. size += 1; // byte: Type of the 3rd parameter. size += 3; // vint: family length (3 bytes => max length = 32768). size += put.family().length; // The family name. size += 1; // byte: Type of the 4th parameter. size += 3; // vint: qualifier length (3 bytes => max length = 32768). size += put.qualifier().length; // The qualifier key. size += 1; // byte: Type of the 5th parameter. size += 4; // vint: data length. size += expected.length; // The data. // 6th parameter : put request size += put.predictPutSize(); return size; }
/** Serializes this request for HBase 0.94 and before. */ private ChannelBuffer serializeOld(final byte server_version) { final ChannelBuffer buf = newBuffer(server_version, predictSerializedSize()); buf.writeInt(2); // Number of parameters. // 1st param: byte array containing region name writeHBaseByteArray(buf, region.name()); // 2nd param: Put object serializeInto(buf); return buf; }
/** Serializes this request for HBase 0.94 and before. */ private ChannelBuffer serializeOld(final byte server_version) { final ChannelBuffer buf = newBuffer(server_version, predictSerializedSize()); buf.writeInt(2); // Number of parameters. // 1st param: byte array containing region name writeHBaseByteArray(buf, region.name()); // 2nd param: Append object serializeInto(buf); return buf; }
@Override /** * Compares two RPCs. */ public int compare(final BatchableRpc a, final BatchableRpc b) { int d; if ((d = Bytes.memcmp(a.getRegion().name(), b.getRegion().name())) != 0) { return d; } else if ((d = a.code() - b.code()) != 0) { // Sort by code before key. // Note that DeleteRequest.code() < PutRequest.code() and this matters // as the RegionServer processes deletes before puts, and we want to // send RPCs in the same order as they will be processed. return d; } else if ((d = Bytes.memcmp(a.key, b.key)) != 0) { return d; } return Bytes.memcmp(a.family(), b.family()); }
/** * Package-private access point for {@link Scanner}s to close themselves. * @param scanner The scanner to close. * @return A deferred object that indicates the completion of the request. * The {@link Object} has not special meaning and can be {@code null}. */ Deferred<Object> closeScanner(final Scanner scanner) { final RegionInfo region = scanner.currentRegion(); final RegionClient client = clientFor(region); if (client == null) { // Oops, we no longer know anything about this client or region. Our // cache was probably invalidated while the client was scanning. So // we can't close this scanner properly. LOG.warn("Cannot close " + scanner + " properly, no connection open for " + Bytes.pretty(region == null ? null : region.name())); return Deferred.fromResult(null); } final HBaseRpc close_request = scanner.getCloseRequest(); final Deferred<Object> d = close_request.getDeferred(); client.sendRpc(close_request); return d; }
/** * Fail all RPCs in a collection or attempt to reschedule them if possible. * @param rpcs A possibly empty but non-{@code null} collection of RPCs. * @param exception The exception with which to fail RPCs that can't be * retried. */ private void failOrRetryRpcs(final Collection<HBaseRpc> rpcs, final ConnectionResetException exception) { for (final HBaseRpc rpc : rpcs) { final RegionInfo region = rpc.getRegion(); if (region == null // Can't retry, dunno where this RPC should go. || rpc.failfast()) { rpc.callback(exception); } else { final NotServingRegionException nsre = new NotServingRegionException("Connection reset: " + exception.getMessage(), rpc); // Re-schedule the RPC by (ab)using the NSRE handling mechanism. hbase_client.handleNSRE(rpc, region.name(), nsre); } } }
/** Serializes this request for HBase 0.94 and before. */ private ChannelBuffer serializeOld(final byte server_version) { final ChannelBuffer buf = newBuffer(server_version, predictSerializedSize()); buf.writeInt(6); // Number of parameters. writeHBaseByteArray(buf, region.name()); writeHBaseByteArray(buf, key); writeHBaseByteArray(buf, family); writeHBaseByteArray(buf, qualifier); writeHBaseLong(buf, amount); writeHBaseBool(buf, durable); return buf; }
/** Serializes this request for HBase 0.94 and before. */ private ChannelBuffer serializeOld(final byte server_version) { final ChannelBuffer buf = newBuffer(server_version, predictSerializedSize()); buf.writeInt(6); // Number of parameters. // 1st param: byte array: region name. writeHBaseByteArray(buf, region.name()); // 2nd param: byte array: row key. writeHBaseByteArray(buf, put.key()); // 3rd param: byte array: column family. writeHBaseByteArray(buf, put.family()); // 4th param: byte array: qualifier. writeHBaseByteArray(buf, put.qualifier()); // 5th param: byte array: expected value. writeHBaseByteArray(buf, expected); // 6th param: New value. put.serializeInto(buf); return buf; }