/** * Create a protocol buffer MutateRequest for a conditioned delete * * @param regionName * @param row * @param family * @param qualifier * @param comparator * @param compareType * @param delete * @return a mutate request * @throws IOException */ public static MutateRequest buildMutateRequest( final byte[] regionName, final byte[] row, final byte[] family, final byte [] qualifier, final ByteArrayComparable comparator, final CompareType compareType, final Delete delete) throws IOException { MutateRequest.Builder builder = MutateRequest.newBuilder(); RegionSpecifier region = buildRegionSpecifier( RegionSpecifierType.REGION_NAME, regionName); builder.setRegion(region); Condition condition = buildCondition( row, family, qualifier, comparator, compareType); builder.setMutation(ProtobufUtil.toMutation(MutationType.DELETE, delete, MutationProto.newBuilder())); builder.setCondition(condition); return builder.build(); }
/** * Starts the nonce operation for a mutation, if needed. * @param mutation Mutation. * @param nonceGroup Nonce group from the request. * @returns Nonce used (can be NO_NONCE). */ private long startNonceOperation(final MutationProto mutation, long nonceGroup) throws IOException, OperationConflictException { if (regionServer.nonceManager == null || !mutation.hasNonce()) return HConstants.NO_NONCE; boolean canProceed = false; try { canProceed = regionServer.nonceManager.startOperation( nonceGroup, mutation.getNonce(), regionServer); } catch (InterruptedException ex) { throw new InterruptedIOException("Nonce start operation interrupted"); } if (!canProceed) { // TODO: instead, we could convert append/increment to get w/mvcc String message = "The operation with nonce {" + nonceGroup + ", " + mutation.getNonce() + "} on row [" + Bytes.toString(mutation.getRow().toByteArray()) + "] may have already completed"; throw new OperationConflictException(message); } return mutation.getNonce(); }
private void skipCellsForMutation(Action action, CellScanner cellScanner) { try { if (action.hasMutation()) { MutationProto m = action.getMutation(); if (m.hasAssociatedCellCount()) { for (int i = 0; i < m.getAssociatedCellCount(); i++) { cellScanner.advance(); } } } } catch (IOException e) { // No need to handle these Individual Muatation level issue. Any way this entire RegionAction // marked as failed as we could not see the Region here. At client side the top level // RegionAction exception will be considered first. LOG.error("Error while skipping Cells in CellScanner for invalid Region Mutations", e); } }
/** * Create a protocol buffer MultiRequest for row mutations. * Does not propagate Action absolute position. Does not set atomic action on the created * RegionAtomic. Caller should do that if wanted. * @param regionName * @param rowMutations * @return a data-laden RegionMutation.Builder * @throws IOException */ public static RegionAction.Builder buildRegionAction(final byte [] regionName, final RowMutations rowMutations) throws IOException { RegionAction.Builder builder = getRegionActionBuilderWithRegion(RegionAction.newBuilder(), regionName); ClientProtos.Action.Builder actionBuilder = ClientProtos.Action.newBuilder(); MutationProto.Builder mutationBuilder = MutationProto.newBuilder(); for (Mutation mutation: rowMutations.getMutations()) { MutationType mutateType = null; if (mutation instanceof Put) { mutateType = MutationType.PUT; } else if (mutation instanceof Delete) { mutateType = MutationType.DELETE; } else { throw new DoNotRetryIOException("RowMutations supports only put and delete, not " + mutation.getClass().getName()); } mutationBuilder.clear(); MutationProto mp = ProtobufUtil.toMutation(mutateType, mutation, mutationBuilder); actionBuilder.clear(); actionBuilder.setMutation(mp); builder.addAction(actionBuilder.build()); } return builder; }
/** * Create a protocol buffer MultiRequest for row mutations that does not hold data. Data/Cells * are carried outside of protobuf. Return references to the Cells in <code>cells</code> param. * Does not propagate Action absolute position. Does not set atomic action on the created * RegionAtomic. Caller should do that if wanted. * @param regionName * @param rowMutations * @param cells Return in here a list of Cells as CellIterable. * @return a region mutation minus data * @throws IOException */ public static RegionAction.Builder buildNoDataRegionAction(final byte[] regionName, final RowMutations rowMutations, final List<CellScannable> cells, final RegionAction.Builder regionActionBuilder, final ClientProtos.Action.Builder actionBuilder, final MutationProto.Builder mutationBuilder) throws IOException { for (Mutation mutation: rowMutations.getMutations()) { MutationType type = null; if (mutation instanceof Put) { type = MutationType.PUT; } else if (mutation instanceof Delete) { type = MutationType.DELETE; } else { throw new DoNotRetryIOException("RowMutations supports only put and delete, not " + mutation.getClass().getName()); } mutationBuilder.clear(); MutationProto mp = ProtobufUtil.toMutationNoData(type, mutation, mutationBuilder); cells.add(mutation); actionBuilder.clear(); regionActionBuilder.addAction(actionBuilder.setMutation(mp).build()); } return regionActionBuilder; }
/** * Convert a protobuf Durability into a client Durability */ public static Durability toDurability( final ClientProtos.MutationProto.Durability proto) { switch(proto) { case USE_DEFAULT: return Durability.USE_DEFAULT; case SKIP_WAL: return Durability.SKIP_WAL; case ASYNC_WAL: return Durability.ASYNC_WAL; case SYNC_WAL: return Durability.SYNC_WAL; case FSYNC_WAL: return Durability.FSYNC_WAL; default: return Durability.USE_DEFAULT; } }
/** * Convert a client Durability into a protbuf Durability */ public static ClientProtos.MutationProto.Durability toDurability( final Durability d) { switch(d) { case USE_DEFAULT: return ClientProtos.MutationProto.Durability.USE_DEFAULT; case SKIP_WAL: return ClientProtos.MutationProto.Durability.SKIP_WAL; case ASYNC_WAL: return ClientProtos.MutationProto.Durability.ASYNC_WAL; case SYNC_WAL: return ClientProtos.MutationProto.Durability.SYNC_WAL; case FSYNC_WAL: return ClientProtos.MutationProto.Durability.FSYNC_WAL; default: return ClientProtos.MutationProto.Durability.USE_DEFAULT; } }
/** * Code shared by {@link #toMutation(MutationType, Mutation)} and * {@link #toMutationNoData(MutationType, Mutation)} * @param type * @param mutation * @return A partly-filled out protobuf'd Mutation. */ private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type, final Mutation mutation, MutationProto.Builder builder) { builder.setRow(ByteStringer.wrap(mutation.getRow())); builder.setMutateType(type); builder.setDurability(toDurability(mutation.getDurability())); builder.setTimestamp(mutation.getTimeStamp()); Map<String, byte[]> attributes = mutation.getAttributesMap(); if (!attributes.isEmpty()) { NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder(); for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) { attributeBuilder.setName(attribute.getKey()); attributeBuilder.setValue(ByteStringer.wrap(attribute.getValue())); builder.addAttribute(attributeBuilder.build()); } } return builder; }
/** * Starts the nonce operation for a mutation, if needed. * * @param mutation Mutation. * @param nonceGroup Nonce group from the request. * @returns Nonce used (can be NO_NONCE). */ private long startNonceOperation(final MutationProto mutation, long nonceGroup) throws IOException, OperationConflictException { if (regionServer.nonceManager == null || !mutation.hasNonce()) return HConstants.NO_NONCE; boolean canProceed = false; try { canProceed = regionServer.nonceManager.startOperation( nonceGroup, mutation.getNonce(), regionServer); } catch (InterruptedException ex) { throw new InterruptedIOException("Nonce start operation interrupted"); } if (!canProceed) { // TODO: instead, we could convert append/increment to get w/mvcc String message = "The operation with nonce {" + nonceGroup + ", " + mutation.getNonce() + "} on row [" + Bytes.toString(mutation.getRow().toByteArray()) + "] may have already completed"; throw new OperationConflictException(message); } return mutation.getNonce(); }
/** * Starts the nonce operation for a mutation, if needed. * @param mutation Mutation. * @param nonceGroup Nonce group from the request. * @returns Nonce used (can be NO_NONCE). */ private long startNonceOperation(final MutationProto mutation, long nonceGroup) throws IOException, OperationConflictException { if (nonceManager == null || !mutation.hasNonce()) return HConstants.NO_NONCE; boolean canProceed = false; try { canProceed = nonceManager.startOperation(nonceGroup, mutation.getNonce(), this); } catch (InterruptedException ex) { throw new InterruptedIOException("Nonce start operation interrupted"); } if (!canProceed) { // TODO: instead, we could convert append/increment to get w/mvcc String message = "The operation with nonce {" + nonceGroup + ", " + mutation.getNonce() + "} on row [" + Bytes.toString(mutation.getRow().toByteArray()) + "] may have already completed"; throw new OperationConflictException(message); } return mutation.getNonce(); }
/** * Code shared by {@link #toMutation(MutationType, Mutation)} and * {@link #toMutationNoData(MutationType, Mutation)} * @param type * @param mutation * @return A partly-filled out protobuf'd Mutation. */ private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type, final Mutation mutation, MutationProto.Builder builder) { builder.setRow(HBaseZeroCopyByteString.wrap(mutation.getRow())); builder.setMutateType(type); builder.setDurability(toDurability(mutation.getDurability())); builder.setTimestamp(mutation.getTimeStamp()); Map<String, byte[]> attributes = mutation.getAttributesMap(); if (!attributes.isEmpty()) { NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder(); for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) { attributeBuilder.setName(attribute.getKey()); attributeBuilder.setValue(HBaseZeroCopyByteString.wrap(attribute.getValue())); builder.addAttribute(attributeBuilder.build()); } } return builder; }
/** * Create a protocol buffer MutateRequest for a client increment * * @param regionName * @param row * @param family * @param qualifier * @param amount * @param durability * @return a mutate request */ public static MutateRequest buildMutateRequest( final byte[] regionName, final byte[] row, final byte[] family, final byte [] qualifier, final long amount, final Durability durability) { MutateRequest.Builder builder = MutateRequest.newBuilder(); RegionSpecifier region = buildRegionSpecifier( RegionSpecifierType.REGION_NAME, regionName); builder.setRegion(region); MutationProto.Builder mutateBuilder = MutationProto.newBuilder(); mutateBuilder.setRow(ZeroCopyLiteralByteString.wrap(row)); mutateBuilder.setMutateType(MutationType.INCREMENT); mutateBuilder.setDurability(ProtobufUtil.toDurability(durability)); ColumnValue.Builder columnBuilder = ColumnValue.newBuilder(); columnBuilder.setFamily(ZeroCopyLiteralByteString.wrap(family)); QualifierValue.Builder valueBuilder = QualifierValue.newBuilder(); valueBuilder.setValue(ZeroCopyLiteralByteString.wrap(Bytes.toBytes(amount))); valueBuilder.setQualifier(ZeroCopyLiteralByteString.wrap(qualifier)); columnBuilder.addQualifierValue(valueBuilder.build()); mutateBuilder.addColumnValue(columnBuilder.build()); builder.setMutation(mutateBuilder.build()); return builder.build(); }
public static MutationProto toMutation(final MutationType type, final Mutation mutation, MutationProto.Builder builder) throws IOException { builder = getMutationBuilderAndSetCommonFields(type, mutation, builder); ColumnValue.Builder columnBuilder = ColumnValue.newBuilder(); QualifierValue.Builder valueBuilder = QualifierValue.newBuilder(); for (Map.Entry<byte[],List<Cell>> family: mutation.getFamilyCellMap().entrySet()) { columnBuilder.clear(); columnBuilder.setFamily(ZeroCopyLiteralByteString.wrap(family.getKey())); for (Cell cell: family.getValue()) { KeyValue kv = KeyValueUtil.ensureKeyValue(cell); valueBuilder.setQualifier(ZeroCopyLiteralByteString.wrap( kv.getQualifierArray(), kv.getQualifierOffset(), kv.getQualifierLength())); valueBuilder.setValue(ZeroCopyLiteralByteString.wrap( kv.getValueArray(), kv.getValueOffset(), kv.getValueLength())); valueBuilder.setTimestamp(kv.getTimestamp()); if (type == MutationType.DELETE) { KeyValue.Type keyValueType = KeyValue.Type.codeToType(kv.getType()); valueBuilder.setDeleteType(toDeleteType(keyValueType)); } columnBuilder.addQualifierValue(valueBuilder.build()); } builder.addColumnValue(columnBuilder.build()); } return builder.build(); }
/** * Code shared by {@link #toMutation(MutationType, Mutation)} and * {@link #toMutationNoData(MutationType, Mutation)} * @param type * @param mutation * @return A partly-filled out protobuf'd Mutation. */ private static MutationProto.Builder getMutationBuilderAndSetCommonFields(final MutationType type, final Mutation mutation, MutationProto.Builder builder) { builder.setRow(ZeroCopyLiteralByteString.wrap(mutation.getRow())); builder.setMutateType(type); builder.setDurability(toDurability(mutation.getDurability())); builder.setTimestamp(mutation.getTimeStamp()); Map<String, byte[]> attributes = mutation.getAttributesMap(); if (!attributes.isEmpty()) { NameBytesPair.Builder attributeBuilder = NameBytesPair.newBuilder(); for (Map.Entry<String, byte[]> attribute: attributes.entrySet()) { attributeBuilder.setName(attribute.getKey()); attributeBuilder.setValue(ZeroCopyLiteralByteString.wrap(attribute.getValue())); builder.addAttribute(attributeBuilder.build()); } } return builder; }