CounterConfiguration BaseCounterOperation::readConfiguration(infinispan::hotrod::transport::Transport& transport) {
uint8_t flags;
CounterType ct;
Storage st;
long concurrentLevel = 0;
long lower = 0;
long upper = 0;
long initial = 0;
flags = transport.readByte();
switch (flags & 0x03) {
case 0x00:
ct = CounterType::UNBOUNDED_STRONG;
break;
case 0x01:
ct = CounterType::WEAK;
break;
case 0x02:
ct = CounterType::BOUNDED_STRONG;
break;
default:
throw HotRodClientException(std::string("Unknown counter type: ") + std::to_string(flags));
}
st = (flags & 0x04) ? Storage::PERSISTENT : Storage::VOLATILE;
if (ct == WEAK) {
concurrentLevel = transport.readVInt();
}
if (ct == BOUNDED_STRONG) {
lower = transport.readLong();
upper = transport.readLong();
}
initial = transport.readLong();
return CounterConfiguration(initial, lower, upper, concurrentLevel, ct, st);
}
std::map<InetSocketAddress, std::set<int32_t> > Codec11::computeNewHashes(
infinispan::hotrod::transport::Transport& transport, uint32_t /*newTopologyId*/, int16_t /*numKeyOwners*/,
uint8_t hashFunctionVersion, uint32_t /*hashSpace*/, uint32_t clusterSize) const {
uint32_t numVirtualNodes = transport.readVInt();
std::map<InetSocketAddress, std::set<int32_t> > servers2Hash;
ConsistentHash* ch;
if (hashFunctionVersion != 0) {
ch = transport.getTransportFactory().getConsistentHashFactory().newConsistentHash(hashFunctionVersion);
} else {
ch = 0;
WARN("Could not obtain a consistent hash for version %d", hashFunctionVersion);
}
for (uint32_t i = 0; i < clusterSize; i++) {
std::string host = transport.readString();
int16_t port = transport.readUnsignedShort();
// TODO: Performance improvement, since hash positions are fixed, we could
//maybe only calculate for those nodes that the client is not aware of?
int32_t baseHashCode = transport.read4ByteInt();
int32_t normalizedHashCode = getNormalizedHash(baseHashCode, ch);
cacheHashCode(servers2Hash, host, port, normalizedHashCode);
if (numVirtualNodes > 1) {
calcVirtualHashCodes(baseHashCode, numVirtualNodes, servers2Hash,
host, port, ch);
}
}
return servers2Hash;
}
void BaseCounterOperation::writeConfiguration(infinispan::hotrod::transport::Transport& transport,
const CounterConfiguration& c) {
uint8_t flags = 0;
switch (c.getType()) {
case CounterType::WEAK:
flags |= 0x01;
break;
case CounterType::BOUNDED_STRONG:
flags |= 0x02;
break;
case CounterType::UNBOUNDED_STRONG:
break;
}
switch (c.getStorage()) {
case Storage::PERSISTENT:
flags |= 0x04;
break;
case Storage::VOLATILE:
break;
}
transport.writeByte(flags);
if (c.getType() == CounterType::WEAK) {
transport.writeVInt(c.getConcurrencyLevel());
}
if (c.getType() == CounterType::BOUNDED_STRONG)
{
transport.writeLong(c.getLowerBound());
transport.writeLong(c.getUpperBound());
}
transport.writeLong(c.getInitialValue());
}
bool RemoveCounterListenerOperation::executeOperation(infinispan::hotrod::transport::Transport& transport) {
TRACE("Executing RemoveCounterListenerOperation(flags=%u)", flags);
std::unique_ptr<HeaderParams> params(
RetryOnFailureOperation<bool>::writeHeader(transport, COUNTER_REMOVE_LISTENER_REQUEST));
writeName(transport, counterName);
transport.writeArray(listenerId);
transport.flush();
uint8_t status = readHeaderAndValidate(transport, *params);
return status == NO_ERROR_STATUS;
}
long GetCounterValueOperation::executeOperation(infinispan::hotrod::transport::Transport& transport) {
TRACE("Executing IsCounterDefinedOperation(flags=%u)", flags);
std::unique_ptr<HeaderParams> params(RetryOnFailureOperation<long>::writeHeader(transport, COUNTER_GET_REQUEST));
writeName(transport, counterName);
transport.flush();
uint8_t status = readHeaderAndValidate(transport, *params);
if (!isSuccess(status)) {
throw HotRodClientException(
std::string("Error in GetCountervalue operation, counter name: ") + counterName + " status: "
+ std::to_string(status));
}
auto ret = (long)transport.readLong();
TRACE("Finished IsCounterDefinedOperation");
return ret;
}
std::set<std::string> GetCounterNamesOperation::executeOperation(infinispan::hotrod::transport::Transport& transport) {
TRACE("Executing GetCounterNamesOperation(flags=%u)", flags);
std::unique_ptr<HeaderParams> params(
RetryOnFailureOperation<std::set<std::string>>::writeHeader(transport, COUNTER_GET_NAMES_REQUEST));
uint8_t status = readHeaderAndValidate(transport, *params);
std::set<std::string> ret;
if (!isSuccess(status)) {
auto num = transport.readVInt();
for (uint32_t i = 0; i < num; i++) {
auto name = transport.readString();
ret.insert(name);
}
}
TRACE("Finished GetCounterNamesOperation");
return ret;
}
hrbytes ClearOperation::executeOperation(infinispan::hotrod::transport::Transport& transport)
{
hr_scoped_ptr<HeaderParams> params(&(RetryOnFailureOperation<hrbytes>::writeHeader(transport, CLEAR_REQUEST)));
transport.flush();
RetryOnFailureOperation<hrbytes>::readHeaderAndValidate(transport, *params);
return hrbytes();
}
long CompareAndSwapCounterValueOperation::executeOperation(infinispan::hotrod::transport::Transport& transport) {
TRACE("Executing CompareAndSwapOperation(flags=%u)", flags);
std::unique_ptr<HeaderParams> params(RetryOnFailureOperation<long>::writeHeader(transport, COUNTER_CAS_REQUEST));
writeName(transport, counterName);
transport.writeLong(expect);
transport.writeLong(update);
transport.flush();
uint8_t status = readHeaderAndValidate(transport, *params);
assertBoundaries(status);
if (status != NO_ERROR_STATUS) {
throw HotRodClientException(
std::string("Error in CompareAndSwap operation, counter name: ") + counterName + " status: "
+ std::to_string(status));
}
auto ret = (long)transport.readLong();
TRACE("Finished CompareAndSwapDefinedOperation");
return ret;
}
bool IsCounterDefinedOperation::executeOperation(infinispan::hotrod::transport::Transport& transport) {
TRACE("Executing IsCounterDefinedOperation(flags=%u)", flags);
std::unique_ptr<HeaderParams> params(RetryOnFailureOperation<bool>::writeHeader(transport, COUNTER_CREATE_REQUEST));
writeName(transport, counterName);
transport.flush();
uint8_t status = readHeaderAndValidate(transport, *params);
TRACE("Finished IsCounterDefinedOperation");
return status==0x00;
}
void RemoveCounterOperation::executeOperation(infinispan::hotrod::transport::Transport& transport) {
TRACE("Executing RemoveOperation(flags=%u)", flags);
std::unique_ptr<HeaderParams> params(RetryOnFailureOperation<void>::writeHeader(transport, COUNTER_REMOVE_REQUEST));
writeName(transport, counterName);
transport.flush();
uint8_t status = readHeaderAndValidate(transport, *params);
if (!isSuccess(status) && status != KEY_DOES_NOT_EXIST_STATUS) {
throw HotRodClientException(
std::string("Error in CounterRemove operation, counter name: ") + counterName + " status: "
+ std::to_string(status));
}
TRACE("Finished RemoveOperation");
}
void BaseCounterOperation::writeName(infinispan::hotrod::transport::Transport& transport, std::string counterName) {
std::vector<char> counterNameAsVector(counterName.begin(), counterName.end());
transport.writeArray(counterNameAsVector);
}
