@Override
public byte[] serializeWalletExtension() {
lock.lock();
try {
ClientState.StoredClientPaymentChannels.Builder builder =
ClientState.StoredClientPaymentChannels.newBuilder();
for (StoredClientChannel channel : mapChannels.values()) {
// First a few asserts to make sure things won't break
checkState(
channel.valueToMe.signum() >= 0
&& channel.valueToMe.compareTo(NetworkParameters.MAX_MONEY) < 0);
checkState(
channel.refundFees.signum() >= 0
&& channel.refundFees.compareTo(NetworkParameters.MAX_MONEY) < 0);
checkNotNull(channel.myKey.getPrivKeyBytes());
checkState(channel.refund.getConfidence().getSource() == TransactionConfidence.Source.SELF);
final ClientState.StoredClientPaymentChannel.Builder value =
ClientState.StoredClientPaymentChannel.newBuilder()
.setId(ByteString.copyFrom(channel.id.getBytes()))
.setContractTransaction(ByteString.copyFrom(channel.contract.bitcoinSerialize()))
.setRefundTransaction(ByteString.copyFrom(channel.refund.bitcoinSerialize()))
.setMyKey(ByteString.copyFrom(channel.myKey.getPrivKeyBytes()))
.setValueToMe(channel.valueToMe.longValue())
.setRefundFees(channel.refundFees.longValue());
if (channel.close != null)
value.setCloseTransactionHash(ByteString.copyFrom(channel.close.getHash().getBytes()));
builder.addChannels(value);
}
return builder.build().toByteArray();
} finally {
lock.unlock();
}
}
private static void writeBeliefSet(
MarshallerWriteContext context,
BeliefSet beliefSet,
org.drools.core.marshalling.impl.ProtobufMessages.EqualityKey.Builder _key)
throws IOException {
ProtobufMessages.BeliefSet.Builder _beliefSet = ProtobufMessages.BeliefSet.newBuilder();
_beliefSet.setHandleId(beliefSet.getFactHandle().getId());
ObjectMarshallingStrategyStore objectMarshallingStrategyStore =
context.objectMarshallingStrategyStore;
// for ( LinkedListEntry node = (LinkedListEntry) beliefSet.getFirst(); node != null; node =
// (LinkedListEntry) node.getNext() ) {
FastIterator it = beliefSet.iterator();
for (LinkedListEntry node = (LinkedListEntry) beliefSet.getFirst();
node != null;
node = (LinkedListEntry) it.next(node)) {
LogicalDependency belief = (LogicalDependency) node.getObject();
ProtobufMessages.LogicalDependency.Builder _logicalDependency =
ProtobufMessages.LogicalDependency.newBuilder();
// _belief.setActivation( value )
LogicalDependency dependency = (LogicalDependency) node.getObject();
org.drools.core.spi.Activation activation = dependency.getJustifier();
ProtobufMessages.Activation _activation =
ProtobufMessages.Activation.newBuilder()
.setPackageName(activation.getRule().getPackage())
.setRuleName(activation.getRule().getName())
.setTuple(PersisterHelper.createTuple(activation.getTuple()))
.build();
_logicalDependency.setActivation(_activation);
if (belief.getObject() != null) {
ObjectMarshallingStrategy strategy =
objectMarshallingStrategyStore.getStrategyObject(belief.getObject());
Integer index = context.getStrategyIndex(strategy);
_logicalDependency.setObjectStrategyIndex(index.intValue());
_logicalDependency.setObject(
ByteString.copyFrom(
strategy.marshal(
context.strategyContext.get(strategy), context, belief.getObject())));
}
if (belief.getValue() != null) {
ObjectMarshallingStrategy strategy =
objectMarshallingStrategyStore.getStrategyObject(belief.getValue());
Integer index = context.getStrategyIndex(strategy);
_logicalDependency.setValueStrategyIndex(index.intValue());
_logicalDependency.setValue(
ByteString.copyFrom(
strategy.marshal(
context.strategyContext.get(strategy), context, belief.getValue())));
}
_beliefSet.addLogicalDependency(_logicalDependency.build());
}
_key.setBeliefSet(_beliefSet);
}
public byte[] serialize() {
return IdentityKeyPairStructure.newBuilder()
.setPublicKey(ByteString.copyFrom(publicKey.serialize()))
.setPrivateKey(ByteString.copyFrom(privateKey.serialize()))
.build()
.toByteArray();
}
@Override
public byte[] createProtobufOutput() {
Scanner.Builder builder = Scanner.newBuilder();
if (!Bytes.equals(startRow, HConstants.EMPTY_START_ROW)) {
builder.setStartRow(ByteString.copyFrom(startRow));
}
if (!Bytes.equals(endRow, HConstants.EMPTY_START_ROW)) {
builder.setEndRow(ByteString.copyFrom(endRow));
}
for (byte[] column : columns) {
builder.addColumns(ByteString.copyFrom(column));
}
builder.setBatch(batch);
if (startTime != 0) {
builder.setStartTime(startTime);
}
if (endTime != 0) {
builder.setEndTime(endTime);
}
builder.setBatch(getBatch());
builder.setMaxVersions(maxVersions);
if (filter != null) {
builder.setFilter(filter);
}
return builder.build().toByteArray();
}
private ProtocolSignature getRealSignature() throws Exception {
return ProtocolSignature.newBuilder()
.setSignerId(ByteString.copyFrom(Certificates.getRealSignerInfo().getSignerId()))
.setSignatureAlgorithm(SignatureAlgorithm.SHA1_RSA)
.setSignatureBytes(ByteString.copyFrom(Certificates.REAL_SIGNATURE))
.build();
}
/**
* Test Increment Mutate conversions.
*
* @throws IOException
*/
@Test
public void testIncrement() throws IOException {
Mutate.Builder mutateBuilder = Mutate.newBuilder();
mutateBuilder.setRow(ByteString.copyFromUtf8("row"));
mutateBuilder.setMutateType(MutateType.INCREMENT);
ColumnValue.Builder valueBuilder = ColumnValue.newBuilder();
valueBuilder.setFamily(ByteString.copyFromUtf8("f1"));
QualifierValue.Builder qualifierBuilder = QualifierValue.newBuilder();
qualifierBuilder.setQualifier(ByteString.copyFromUtf8("c1"));
qualifierBuilder.setValue(ByteString.copyFrom(Bytes.toBytes(11L)));
valueBuilder.addQualifierValue(qualifierBuilder.build());
qualifierBuilder.setQualifier(ByteString.copyFromUtf8("c2"));
qualifierBuilder.setValue(ByteString.copyFrom(Bytes.toBytes(22L)));
valueBuilder.addQualifierValue(qualifierBuilder.build());
mutateBuilder.addColumnValue(valueBuilder.build());
Mutate proto = mutateBuilder.build();
// default fields
assertEquals(true, proto.getWriteToWAL());
// set the default value for equal comparison
mutateBuilder = Mutate.newBuilder(proto);
mutateBuilder.setWriteToWAL(true);
Increment increment = ProtobufUtil.toIncrement(proto);
assertEquals(mutateBuilder.build(), ProtobufUtil.toMutate(increment));
}
/**
* Sign the provided payment request.
*
* @param paymentRequest Payment request to sign, in its builder form.
* @param certificateChain Certificate chain to send with the payment request, ordered from client
* certificate to root certificate. The root certificate itself may be omitted.
* @param privateKey The key to sign with. Must match the public key from the first certificate of
* the certificate chain.
*/
public static void signPaymentRequest(
Protos.PaymentRequest.Builder paymentRequest,
X509Certificate[] certificateChain,
PrivateKey privateKey) {
try {
final Protos.X509Certificates.Builder certificates = Protos.X509Certificates.newBuilder();
for (final Certificate certificate : certificateChain)
certificates.addCertificate(ByteString.copyFrom(certificate.getEncoded()));
paymentRequest.setPkiType("x509+sha256");
paymentRequest.setPkiData(certificates.build().toByteString());
paymentRequest.setSignature(ByteString.EMPTY);
final Protos.PaymentRequest paymentRequestToSign = paymentRequest.build();
final String algorithm;
if ("RSA".equalsIgnoreCase(privateKey.getAlgorithm())) algorithm = "SHA256withRSA";
else throw new IllegalStateException(privateKey.getAlgorithm());
final Signature signature = Signature.getInstance(algorithm);
signature.initSign(privateKey);
signature.update(paymentRequestToSign.toByteArray());
paymentRequest.setSignature(ByteString.copyFrom(signature.sign()));
} catch (final GeneralSecurityException x) {
// Should never happen so don't make users have to think about it.
throw new RuntimeException(x);
}
}
/**
* Constructs a builder for a StoreBucketPropsOperation.
*
* @param namespace The namespace in Riak.
*/
public Builder(Namespace namespace) {
if (namespace == null) {
throw new IllegalArgumentException("Namespace cannot be null");
}
reqBuilder.setBucket(ByteString.copyFrom(namespace.getBucketName().unsafeGetValue()));
reqBuilder.setType(ByteString.copyFrom(namespace.getBucketType().unsafeGetValue()));
this.namespace = namespace;
}
public static HdfsProtos.BlockTokenIdentifierProto toProto(Token<?> blockToken) {
return HdfsProtos.BlockTokenIdentifierProto.newBuilder()
.setIdentifier(ByteString.copyFrom(blockToken.getIdentifier()))
.setPassword(ByteString.copyFrom(blockToken.getPassword()))
.setKind(blockToken.getKind().toString())
.setService(blockToken.getService().toString())
.build();
}
private JournalEntry newCompletePartitionEntry(long fileId, PartitionInfo info) {
CompletePartitionEntry completePartition =
CompletePartitionEntry.newBuilder()
.setStoreId(fileId)
.setBlockId(info.blockId)
.setKeyStartBytes(ByteString.copyFrom(info.keyStart))
.setKeyLimitBytes(ByteString.copyFrom(info.keyLimit))
.build();
return JournalEntry.newBuilder().setCompletePartition(completePartition).build();
}
@Override
protected RiakMessage createChannelMessage() {
RiakPB.RpbGetBucketReq.Builder builder = RiakPB.RpbGetBucketReq.newBuilder();
if (bucketType != null) {
builder.setType(ByteString.copyFrom(bucketType.unsafeGetValue()));
}
builder.setBucket(ByteString.copyFrom(bucketName.unsafeGetValue()));
RiakPB.RpbGetBucketReq req = builder.build();
return new RiakMessage(RiakMessageCodes.MSG_GetBucketReq, req.toByteArray());
}
@Override
public Builder adapt(Scan scan, ReadHooks readHooks) {
throwIfUnsupportedScan(scan);
// For gets, startRow == stopRow. There's no need to create a new ByteString for stopRow
RowFilter filter = buildFilter(scan, readHooks);
return ReadRowsRequest.newBuilder()
.setFilter(filter)
.setRowRange(
RowRange.newBuilder()
.setStartKey(ByteString.copyFrom(scan.getStartRow()))
.setEndKey(ByteString.copyFrom(scan.getStopRow())));
}
@Override
public void run(ClientResponseImpl parameter) {
if (debug.get())
LOG.debug(
String.format(
"Got ClientResponse callback for txn #%d! Sending back to %s",
parameter.getTransactionId(), HStoreThreadManager.formatSiteName(this.destSiteId)));
FastSerializer fs = new FastSerializer();
try {
parameter.writeExternal(fs);
} catch (IOException ex) {
throw new RuntimeException(ex);
}
ByteString bs = ByteString.copyFrom(fs.getBuffer());
TransactionRedirectResponse response =
TransactionRedirectResponse.newBuilder()
.setSenderSite(this.sourceSiteId)
.setOutput(bs)
.build();
this.orig_callback.run(response);
if (debug.get())
LOG.debug(
String.format(
"Sent back ClientResponse for txn #%d to %s [bytes=%d]",
parameter.getTransactionId(), HStoreThreadManager.formatSiteName(this.destSiteId)));
// IMPORTANT: Since we're the only one that knows that we're finished (and actually even
// cares), we need to be polite and clean-up after ourselves...
try {
this.finish();
hstore_site.getObjectPools().CALLBACKS_TXN_REDIRECT_RESPONSE.returnObject(this);
} catch (Exception ex) {
throw new RuntimeException("Funky failure", ex);
}
}
/*
* (non-Javadoc)
*
* @see com.basho.riak.client.raw.RawClient#setClientId()
*/
public void setClientId(byte[] clientId) throws IOException {
if (clientId == null || clientId.length != 4) {
throw new IllegalArgumentException(
"clientId must be 4 bytes. generateAndSetClientId() can do this for you");
}
client.setClientID(ByteString.copyFrom(clientId));
}
private static List<ReadRowsResponse> createResponses() {
List<ReadRowsResponse> responses = new ArrayList<>(1);
for (int i = 0; i < 1; i++) {
String rowKey = String.format("rowKey-%s", i);
byte[] value = RandomStringUtils.randomAlphanumeric(10000).getBytes();
Preconditions.checkArgument(
!Strings.isNullOrEmpty("Family1"), "Family name may not be null or empty");
Family.Builder familyBuilder = Family.newBuilder().setName("Family1");
Column.Builder columnBuilder = Column.newBuilder();
columnBuilder.setQualifier(ByteString.copyFromUtf8("Qaulifier"));
if (value != null) {
Cell.Builder cellBuilder = Cell.newBuilder();
cellBuilder.setTimestampMicros(0L);
cellBuilder.setValue(ByteString.copyFrom(value));
columnBuilder.addCells(cellBuilder);
}
familyBuilder.addColumns(columnBuilder);
Chunk contentChunk = Chunk.newBuilder().setRowContents(familyBuilder).build();
Chunk rowCompleteChunk = Chunk.newBuilder().setCommitRow(true).build();
ReadRowsResponse response =
ReadRowsResponse.newBuilder()
.addChunks(contentChunk)
.addChunks(rowCompleteChunk)
.setRowKey(ByteString.copyFromUtf8(rowKey))
.build();
responses.add(response);
}
return responses;
}
/**
* Perform a GET operation on the Riak database
*
* @param msg The received message containing all parameters
* @return The generated reply message of the operation on the database
* @throws IllegalArgumentException if no key is specified
*/
private byte[] processGet(Request.RequestMessage msg) throws IllegalArgumentException {
if (!msg.getKey().isEmpty()) {
byte[] reply;
System.out.println("Executing a GET command to the Riak cluster for key: " + msg.getKey());
byte[] value = riakConnection.get(msg.getKey());
String string = new String(value);
System.out.println(string);
// If the object was not found, return a "NOTFOUND" response. Else, return an "OK" + value
// response
if (value == null) {
reply = Request.RequestMessage.newBuilder().setCommand("NOTFOUND").build().toByteArray();
} else {
ByteString valueBuf = ByteString.copyFrom(value);
reply =
Request.RequestMessage.newBuilder()
.setCommand("OK")
.setDatasource("Riak")
.setValue(valueBuf)
.build()
.toByteArray();
}
return reply;
} else {
throw new IllegalArgumentException();
}
}
@Override
public void catchUp(List<BID> inventory, int limit, boolean headers, final TrunkListener listener)
throws BCSAPIException {
log.trace("catchUp");
ConnectorMessage m;
try (ConnectorSession session = connection.createSession()) {
ConnectorProducer transactionRequestProducer =
session.createProducer(session.createQueue("catchUpRequest"));
m = session.createMessage();
BCSAPIMessage.CatchUpRequest.Builder builder = BCSAPIMessage.CatchUpRequest.newBuilder();
builder.setLimit(limit);
builder.setHeaders(true);
for (BID hash : inventory) {
builder.addInventory(ByteString.copyFrom(hash.unsafeGetArray()));
}
m.setPayload(builder.build().toByteArray());
byte[] response = synchronousRequest(session, transactionRequestProducer, m);
if (response != null) {
BCSAPIMessage.TrunkUpdate blockMessage = BCSAPIMessage.TrunkUpdate.parseFrom(response);
List<APIBlock> blockList = new ArrayList<>();
for (BCSAPIMessage.BLK b : blockMessage.getAddedList()) {
blockList.add(APIBlock.fromProtobuf(b));
}
listener.trunkUpdate(blockList);
}
} catch (ConnectorException | HyperLedgerException | InvalidProtocolBufferException e) {
throw new BCSAPIException(e);
}
}
public void testPushingLotsOfData() throws IOException {
RiakClient riak = new RiakClient("127.0.0.1", RiakConnection.DEFAULT_RIAK_PB_PORT);
long before = System.currentTimeMillis();
byte[] val = new byte[419];
ByteString value = ByteString.copyFrom(val);
for (int i = 0; i < 100; i++) {
long before2 = System.currentTimeMillis();
String cpr = "" + (1000000000 + i);
ByteString cpr_key = ByteString.copyFromUtf8(cpr);
for (int rid = 0; rid < 1000; rid++) {
ByteString rid_key = ByteString.copyFromUtf8("" + (200000 + i));
RiakObject ro = new RiakObject(cpr_key, rid_key, value);
riak.store(ro);
}
long after2 = System.currentTimeMillis();
System.out.println("" + i + " x 1000 INSERTS: " + (after2 - before2) + "ms");
}
long after = System.currentTimeMillis();
System.out.println("TOTAL TIME: " + (1.0 * (after - before) / 1000.0) + "s");
}
@Override
public List<ByteString> getNextRows(int fetchRowNum) throws IOException {
List<ByteString> rows = new ArrayList<ByteString>();
int startRow = currentRow;
int endRow = startRow + fetchRowNum;
if (physicalExec == null) {
return rows;
}
while (currentRow < endRow) {
Tuple currentTuple = physicalExec.next();
if (currentTuple == null) {
physicalExec.close();
physicalExec = null;
break;
}
currentRow++;
rows.add(ByteString.copyFrom(encoder.toBytes(currentTuple)));
if (currentRow >= maxRow) {
physicalExec.close();
physicalExec = null;
break;
}
}
return rows;
}
private AppInfo.Builder buildAppInfo(Tuple tuple) {
AppInfo.Builder aiBuilder = AppInfo.newBuilder();
aiBuilder.setPkgName(tuple.pkgName);
aiBuilder.setAppName(tuple.appName);
if (tuple.icon != null) aiBuilder.setIcon(ByteString.copyFrom(tuple.icon));
return aiBuilder;
}
@Override
public APIBlockIdList getBlockIds(BID blockId, int count) throws BCSAPIException {
try (ConnectorSession session = connection.createSession()) {
log.trace("get " + count + " block ids from " + blockId);
ConnectorProducer blockIdsRequestProducer =
session.createProducer(session.createQueue("blockIdsRequest"));
ConnectorMessage m = session.createMessage();
BCSAPIMessage.BLKIDSREQ.Builder builder = BCSAPIMessage.BLKIDSREQ.newBuilder();
if (blockId != null) {
builder.setBlockHash(ByteString.copyFrom(blockId.unsafeGetArray()));
}
if (count <= 0) count = 20;
builder.setCount(count);
m.setPayload(builder.build().toByteArray());
byte[] response = synchronousRequest(session, blockIdsRequestProducer, m);
if (response != null) {
BCSAPIMessage.BLKIDS message = BCSAPIMessage.BLKIDS.parseFrom(response);
List<ByteString> blockIdsList = message.getBlockIdsList();
List<BID> blockIds =
blockIdsList.stream().map(bs -> new BID(bs.toByteArray())).collect(Collectors.toList());
return new APIBlockIdList(
blockIds,
message.getHeight(),
message.hasPreviousBlockId()
? new BID(message.getPreviousBlockId().toByteArray())
: null);
}
} catch (ConnectorException | InvalidProtocolBufferException e) {
throw new BCSAPIException(e);
}
return null;
}
@Override
public List<APITransaction> getInputTransactions(TID txId) throws BCSAPIException {
log.trace("get input transactions " + txId);
ConnectorMessage m;
try (ConnectorSession session = connection.createSession()) {
ConnectorProducer transactionRequestProducer =
session.createProducer(session.createQueue("inputTransactionsRequest"));
m = session.createMessage();
BCSAPIMessage.Hash.Builder builder = BCSAPIMessage.Hash.newBuilder();
builder.addHash(ByteString.copyFrom(txId.unsafeGetArray()));
m.setPayload(builder.build().toByteArray());
byte[] response = synchronousRequest(session, transactionRequestProducer, m);
if (response != null) {
List<BCSAPIMessage.OPTIONAL_TX> txsList =
BCSAPIMessage.TXS.parseFrom(response).getTxsList();
List<APITransaction> txs = new ArrayList<>(txsList.size());
for (BCSAPIMessage.OPTIONAL_TX tx : txsList) {
if (tx.getIsNull()) {
txs.add(null);
} else {
txs.add(APITransaction.fromProtobuf(tx.getTransaction()));
}
}
return txs;
}
} catch (ConnectorException | HyperLedgerException | InvalidProtocolBufferException e) {
throw new BCSAPIException(e);
}
return null;
}
/** 添加消息，为了保证添加顺序，这里不得不加锁 */
@Override
public void addMessage(
final MessageStore store, final long msgId, final PutCommand putCmd, JournalLocation location)
throws IOException {
if (location == null) {
// 非重放，添加put日志
final AppendMessageCommand appendCmd =
AppendMessageCommand.newBuilder()
.setMessageId(msgId)
.setPutCommand(ByteString.copyFrom(putCmd.encode().array()))
.build();
final TxCommand txCommand =
TxCommand.newBuilder()
.setCmdType(TxCommandType.APPEND_MSG)
.setCmdContent(appendCmd.toByteString())
.build();
final Tx tx = this.getInflyTx(putCmd.getTransactionId());
if (tx != null) {
location = this.journalStore.write(txCommand, null, tx.location, false);
} else {
location = this.journalStore.write(txCommand, null, null, false);
}
}
final Tx tx = this.getTx(putCmd.getTransactionId(), location);
tx.add(store, msgId, putCmd);
}
private void serializeFileDiffList(INodeFile file, OutputStream out) throws IOException {
FileWithSnapshotFeature sf = file.getFileWithSnapshotFeature();
if (sf != null) {
List<FileDiff> diffList = sf.getDiffs().asList();
SnapshotDiffSection.DiffEntry entry =
SnapshotDiffSection.DiffEntry.newBuilder()
.setInodeId(file.getId())
.setType(Type.FILEDIFF)
.setNumOfDiff(diffList.size())
.build();
entry.writeDelimitedTo(out);
for (int i = diffList.size() - 1; i >= 0; i--) {
FileDiff diff = diffList.get(i);
SnapshotDiffSection.FileDiff.Builder fb =
SnapshotDiffSection.FileDiff.newBuilder()
.setSnapshotId(diff.getSnapshotId())
.setFileSize(diff.getFileSize());
INodeFileAttributes copy = diff.snapshotINode;
if (copy != null) {
fb.setName(ByteString.copyFrom(copy.getLocalNameBytes()))
.setSnapshotCopy(buildINodeFile(copy, parent.getSaverContext()));
}
fb.build().writeDelimitedTo(out);
}
}
}
/**
* Convert a ClutserStatus to a protobuf ClusterStatus
*
* @return the protobuf ClusterStatus
*/
public ClusterStatusProtos.ClusterStatus convert() {
ClusterStatusProtos.ClusterStatus.Builder builder =
ClusterStatusProtos.ClusterStatus.newBuilder();
builder.setHbaseVersion(HBaseVersionFileContent.newBuilder().setVersion(getHBaseVersion()));
for (Map.Entry<ServerName, ServerLoad> entry : liveServers.entrySet()) {
LiveServerInfo.Builder lsi =
LiveServerInfo.newBuilder().setServer(ProtobufUtil.toServerName(entry.getKey()));
lsi.setServerLoad(entry.getValue().obtainServerLoadPB());
builder.addLiveServers(lsi.build());
}
for (ServerName deadServer : getDeadServerNames()) {
builder.addDeadServers(ProtobufUtil.toServerName(deadServer));
}
for (Map.Entry<String, RegionState> rit : getRegionsInTransition().entrySet()) {
ClusterStatusProtos.RegionState rs = rit.getValue().convert();
RegionSpecifier.Builder spec =
RegionSpecifier.newBuilder().setType(RegionSpecifierType.REGION_NAME);
spec.setValue(ByteString.copyFrom(Bytes.toBytes(rit.getKey())));
RegionInTransition pbRIT =
RegionInTransition.newBuilder().setSpec(spec.build()).setRegionState(rs).build();
builder.addRegionsInTransition(pbRIT);
}
builder.setClusterId(new ClusterId(getClusterId()).convert());
for (String coprocessor : getMasterCoprocessors()) {
builder.addMasterCoprocessors(HBaseProtos.Coprocessor.newBuilder().setName(coprocessor));
}
builder.setMaster(ProtobufUtil.toServerName(getMaster()));
for (ServerName backup : getBackupMasters()) {
builder.addBackupMasters(ProtobufUtil.toServerName(backup));
}
builder.setBalancerOn(balancerOn);
return builder.build();
}
private void imageRun() {
while (running) {
try {
if (imageMsgReady) {
imageMsgReady = !(sendImage());
Thread.sleep(IMAGE_DELAY);
} else {
byte[] serialImage = new byte[(channels * sizeX * sizeY)];
Random generator = new Random();
int index = 0;
for (int i = 0; i < channels; i++) {
for (int j = 0; j < sizeY; j++) {
for (int k = 0; k < sizeX; k++) {
serialImage[index++] =
(byte) generator.nextInt(128); // Generate random number 0-127 MAX_SIZE for byte
}
}
}
imageMsgReady =
setImage(
System.currentTimeMillis(),
channels,
sizeX,
sizeY,
com.google.protobuf.ByteString.copyFrom(serialImage)); // setup status message
}
} catch (InterruptedException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
} // end while loop
} // End tracksRun method
public void testReadHugeBlob() throws Exception {
// Allocate and initialize a 1MB blob.
byte[] blob = new byte[1 << 20];
for (int i = 0; i < blob.length; i++) {
blob[i] = (byte) i;
}
// Make a message containing it.
TestAllTypes.Builder builder = TestAllTypes.newBuilder();
TestUtil.setAllFields(builder);
builder.setOptionalBytes(ByteString.copyFrom(blob));
TestAllTypes message = builder.build();
// Serialize and parse it. Make sure to parse from an InputStream, not
// directly from a ByteString, so that CodedInputStream uses buffered
// reading.
TestAllTypes message2 = TestAllTypes.parseFrom(message.toByteString().newInput());
assertEquals(message.getOptionalBytes(), message2.getOptionalBytes());
// Make sure all the other fields were parsed correctly.
TestAllTypes message3 =
TestAllTypes.newBuilder(message2)
.setOptionalBytes(TestUtil.getAllSet().getOptionalBytes())
.build();
TestUtil.assertAllFieldsSet(message3);
}
private static void setProtoKuraMetricValue(
final KuraPayloadProto.KuraPayload.KuraMetric.Builder metric, final Object o)
throws Exception {
if (o instanceof String) {
metric.setType(KuraPayloadProto.KuraPayload.KuraMetric.ValueType.STRING);
metric.setStringValue((String) o);
} else if (o instanceof Double) {
metric.setType(KuraPayloadProto.KuraPayload.KuraMetric.ValueType.DOUBLE);
metric.setDoubleValue((Double) o);
} else if (o instanceof Integer) {
metric.setType(KuraPayloadProto.KuraPayload.KuraMetric.ValueType.INT32);
metric.setIntValue((Integer) o);
} else if (o instanceof Float) {
metric.setType(KuraPayloadProto.KuraPayload.KuraMetric.ValueType.FLOAT);
metric.setFloatValue((Float) o);
} else if (o instanceof Long) {
metric.setType(KuraPayloadProto.KuraPayload.KuraMetric.ValueType.INT64);
metric.setLongValue((Long) o);
} else if (o instanceof Boolean) {
metric.setType(KuraPayloadProto.KuraPayload.KuraMetric.ValueType.BOOL);
metric.setBoolValue((Boolean) o);
} else if (o instanceof byte[]) {
metric.setType(KuraPayloadProto.KuraPayload.KuraMetric.ValueType.BYTES);
metric.setBytesValue(ByteString.copyFrom((byte[]) o));
} else if (o == null) {
throw new Exception("null value");
} else {
throw new Exception(o.getClass().getName());
}
}
public void testRpc(int packetSize) throws Exception {
TestRpcRequest.Builder builder = TestRpcRequest.newBuilder();
byte[] bytes = new byte[packetSize];
builder.setData(ByteString.copyFrom(bytes));
stub.testRpc(null, builder.build());
}
@Test
public void testSimplePayment() throws Exception {
// Create a PaymentRequest and make sure the correct values are parsed by the PaymentSession.
MockPaymentSession paymentSession = new MockPaymentSession(newSimplePaymentRequest());
assertEquals(paymentRequestMemo, paymentSession.getMemo());
assertEquals(nanoCoins, paymentSession.getValue());
assertEquals(simplePaymentUrl, paymentSession.getPaymentUrl());
assertTrue(new Date(time * 1000L).equals(paymentSession.getDate()));
assertTrue(paymentSession.getSendRequest().tx.equals(tx));
assertFalse(paymentSession.isExpired());
// Send the payment and verify that the correct information is sent.
// Add a dummy input to tx so it is considered valid.
tx.addInput(new TransactionInput(params, tx, outputToMe.getScriptBytes()));
ArrayList<Transaction> txns = new ArrayList<Transaction>();
txns.add(tx);
Address refundAddr = new Address(params, serverKey.getPubKeyHash());
paymentSession.sendPayment(txns, refundAddr, paymentMemo);
assertEquals(1, paymentSession.getPaymentLog().size());
assertEquals(simplePaymentUrl, paymentSession.getPaymentLog().get(0).getUrl().toString());
Protos.Payment payment = paymentSession.getPaymentLog().get(0).getPayment();
assertEquals(paymentMemo, payment.getMemo());
assertEquals(merchantData, payment.getMerchantData());
assertEquals(1, payment.getRefundToCount());
assertEquals(nanoCoins.longValue(), payment.getRefundTo(0).getAmount());
TransactionOutput refundOutput = new TransactionOutput(params, null, nanoCoins, refundAddr);
ByteString refundScript = ByteString.copyFrom(refundOutput.getScriptBytes());
assertTrue(refundScript.equals(payment.getRefundTo(0).getScript()));
}
