protected <T> InternalCompletableFuture<T> replaceAsyncInternal(
K key,
V oldValue,
V newValue,
ExpiryPolicy expiryPolicy,
boolean hasOldValue,
boolean isGet,
boolean withCompletionEvent) {
ensureOpen();
if (hasOldValue) {
validateNotNull(key, oldValue, newValue);
validateConfiguredTypes(true, key, oldValue, newValue);
} else {
validateNotNull(key, newValue);
validateConfiguredTypes(true, key, newValue);
}
final Data keyData = serializationService.toData(key);
final Data oldValueData = oldValue != null ? serializationService.toData(oldValue) : null;
final Data newValueData = serializationService.toData(newValue);
final Operation operation;
if (isGet) {
operation =
new CacheGetAndReplaceOperation(
getDistributedObjectName(), keyData, newValueData, expiryPolicy);
} else {
operation =
new CacheReplaceOperation(
getDistributedObjectName(), keyData, oldValueData, newValueData, expiryPolicy);
}
return invoke(operation, keyData, withCompletionEvent);
}
private Result processQueryEventFilter(
EventFilter filter,
EntryEventType eventType,
final Data dataKey,
Data dataOldValue,
Data dataValue) {
final NodeEngine nodeEngine = mapServiceContext.getNodeEngine();
final SerializationService serializationService = nodeEngine.getSerializationService();
Object testValue;
if (eventType == EntryEventType.REMOVED || eventType == EntryEventType.EVICTED) {
testValue = serializationService.toObject(dataOldValue);
} else {
testValue = serializationService.toObject(dataValue);
}
Object key = serializationService.toObject(dataKey);
QueryEventFilter queryEventFilter = (QueryEventFilter) filter;
QueryEntry entry = new QueryEntry(serializationService, dataKey, key, testValue);
if (queryEventFilter.eval(entry)) {
if (queryEventFilter.isIncludeValue()) {
return Result.VALUE_INCLUDED;
} else {
return Result.NO_VALUE_INCLUDED;
}
}
return Result.NONE;
}
@Override
public void innerBeforeRun() {
super.innerBeforeRun();
final SerializationService serializationService = getNodeEngine().getSerializationService();
final ManagedContext managedContext = serializationService.getManagedContext();
managedContext.initialize(entryProcessor);
}
private Object authenticate(
ClientConnection connection,
Credentials credentials,
ClientPrincipal principal,
boolean firstConnection)
throws IOException {
final SerializationService ss = getSerializationService();
AuthenticationRequest auth = new AuthenticationRequest(credentials, principal);
connection.init();
auth.setOwnerConnection(firstConnection);
// contains remoteAddress and principal
SerializableCollection collectionWrapper;
try {
collectionWrapper = (SerializableCollection) sendAndReceive(auth, connection);
} catch (Exception e) {
throw new RetryableIOException(e);
}
final Iterator<Data> iter = collectionWrapper.iterator();
if (iter.hasNext()) {
final Data addressData = iter.next();
final Address address = ss.toObject(addressData);
connection.setRemoteEndpoint(address);
if (iter.hasNext()) {
final Data principalData = iter.next();
return ss.toObject(principalData);
}
}
throw new AuthenticationException();
}
public <T> T sendAndReceiveFixedConnection(Connection conn, Object obj) throws IOException {
final SerializationService serializationService = getSerializationService();
final Data request = serializationService.toData(obj);
conn.write(request);
final Data response = conn.read();
final Object result = serializationService.toObject(response);
return ErrorHandler.returnResultOrThrowException(result);
}
public void sendResponse(ClientEndpoint endpoint, Object response) {
if (response instanceof Throwable) {
response =
ClientExceptionConverters.get(endpoint.getClientType()).convert((Throwable) response);
}
final Data resultData = response != null ? serializationService.toData(response) : NULL;
Connection conn = endpoint.getConnection();
conn.write(new DataAdapter(resultData, serializationService.getSerializationContext()));
}
protected InternalCompletableFuture<Boolean> putIfAbsentAsyncInternal(
K key, V value, ExpiryPolicy expiryPolicy, boolean withCompletionEvent) {
ensureOpen();
validateNotNull(key, value);
validateConfiguredTypes(true, key, value);
final Data keyData = serializationService.toData(key);
final Data valueData = serializationService.toData(value);
final Operation op =
new CachePutIfAbsentOperation(getDistributedObjectName(), keyData, valueData, expiryPolicy);
return invoke(op, keyData, withCompletionEvent);
}
@Test
public void testAddAll() throws IOException {
List<Data> list = new ArrayList<Data>();
list.add(ss.toData("item1"));
list.add(ss.toData("item2"));
list.add(ss.toData("item3"));
list.add(ss.toData("item4"));
final SimpleClient client = getClient();
client.send(new AddAllRequest(queueName, list));
Object result = client.receive();
assertTrue((Boolean) result);
int size = getQueue().size();
assertEquals(size, list.size());
}
private void listenMembershipEvents() throws IOException {
final SerializationService serializationService = clusterService.getSerializationService();
while (!Thread.currentThread().isInterrupted()) {
final Data clientResponseData = conn.read();
final ClientResponse clientResponse = serializationService.toObject(clientResponseData);
final Object eventObject = serializationService.toObject(clientResponse.getResponse());
final ClientMembershipEvent event = (ClientMembershipEvent) eventObject;
final MemberImpl member = (MemberImpl) event.getMember();
boolean membersUpdated = false;
if (event.getEventType() == MembershipEvent.MEMBER_ADDED) {
members.add(member);
membersUpdated = true;
} else if (event.getEventType() == ClientMembershipEvent.MEMBER_REMOVED) {
members.remove(member);
membersUpdated = true;
// getConnectionManager().removeConnectionPool(member.getAddress());
// //TODO
} else if (event.getEventType() == ClientMembershipEvent.MEMBER_ATTRIBUTE_CHANGED) {
MemberAttributeChange memberAttributeChange = event.getMemberAttributeChange();
Map<Address, MemberImpl> memberMap = clusterService.getMembersRef();
if (memberMap != null) {
for (MemberImpl target : memberMap.values()) {
if (target.getUuid().equals(memberAttributeChange.getUuid())) {
final MemberAttributeOperationType operationType =
memberAttributeChange.getOperationType();
final String key = memberAttributeChange.getKey();
final Object value = memberAttributeChange.getValue();
target.updateAttribute(operationType, key, value);
MemberAttributeEvent memberAttributeEvent =
new MemberAttributeEvent(client.getCluster(), target, operationType, key, value);
clusterService.fireMemberAttributeEvent(memberAttributeEvent);
break;
}
}
}
}
if (membersUpdated) {
((ClientPartitionServiceImpl) client.getClientPartitionService()).refreshPartitions();
updateMembersRef();
LOGGER.info(clusterService.membersString());
clusterService.fireMembershipEvent(
new MembershipEvent(
client.getCluster(),
member,
event.getEventType(),
Collections.unmodifiableSet(new LinkedHashSet<Member>(members))));
}
}
}
@Override
public Object sendAndReceive(ClientRequest request, ClientConnection connection)
throws Exception {
final SerializationService ss = client.getSerializationService();
connection.write(ss.toData(request));
final Data data = connection.read();
ClientResponse clientResponse = ss.toObject(data);
Object response = ss.toObject(clientResponse.getResponse());
if (response instanceof Throwable) {
Throwable t = (Throwable) response;
ExceptionUtil.fixRemoteStackTrace(t, Thread.currentThread().getStackTrace());
throw new Exception(t);
}
return response;
}
@Override
public void handle(Data dataItem, String uuid, int eventType) {
SerializationService serializationService = getContext().getSerializationService();
ClientClusterService clusterService = getContext().getClusterService();
E item = includeValue ? (E) serializationService.toObject(dataItem) : null;
Member member = clusterService.getMember(uuid);
ItemEvent<E> itemEvent =
new ItemEvent<E>(name, ItemEventType.getByType(eventType), item, member);
if (eventType == ItemEventType.ADDED.getType()) {
listener.itemAdded(itemEvent);
} else {
listener.itemRemoved(itemEvent);
}
}
@Override
public Data getKeyData() {
if (keyData == null && serializationService != null) {
keyData = serializationService.toData(keyObject);
}
return keyData;
}
public CacheRecord newRecordWithExpiry(Data key, Object value, long expiryTime) {
final CacheRecord record;
switch (inMemoryFormat) {
case BINARY:
Data dataValue = serializationService.toData(value);
record = new CacheDataRecord(key, dataValue, expiryTime);
break;
case OBJECT:
Object objectValue = serializationService.toObject(value);
record = new CacheObjectRecord(key, objectValue, expiryTime);
break;
default:
throw new IllegalArgumentException("Invalid storage format: " + inMemoryFormat);
}
return record;
}
@Override
public Data getValueData() {
if (valueData == null && serializationService != null) {
valueData = serializationService.toData(valueObject);
}
return valueData;
}
private void _sendAndHandle(
ConnectionFactory connectionFactory, Object obj, ResponseHandler handler) throws IOException {
ResponseStream stream = null;
while (stream == null) {
if (!active) {
throw new HazelcastInstanceNotActiveException();
}
Connection conn = null;
try {
conn = connectionFactory.create();
final SerializationService serializationService = getSerializationService();
final Data request = serializationService.toData(obj);
conn.write(request);
stream = new ResponseStreamImpl(serializationService, conn);
} catch (Exception e) {
if (e instanceof IOException) {
if (logger.isFinestEnabled()) {
logger.finest("Error on connection... conn: " + conn + ", error: " + e);
}
}
if (conn != null) {
IOUtil.closeResource(conn);
}
if (ErrorHandler.isRetryable(e)) {
if (redoOperation || obj instanceof RetryableRequest) {
if (logger.isFinestEnabled()) {
logger.finest("Retrying " + obj + ", last-conn: " + conn + ", last-error: " + e);
}
beforeRetry();
continue;
}
}
if (e instanceof IOException && !active) {
continue;
}
throw ExceptionUtil.rethrow(e, IOException.class);
}
}
try {
handler.handle(stream);
} catch (Exception e) {
throw ExceptionUtil.rethrow(e, IOException.class);
} finally {
stream.end();
}
}
@Override
public Object getKey() {
// TODO: What is serialization service is null??
if (keyObject == null && serializationService != null) {
keyObject = serializationService.toObject(keyData);
}
return keyObject;
}
@Override
public void init(NodeEngine nodeEngine, Properties properties) {
ClassDefinitionBuilder builder =
new ClassDefinitionBuilder(ClientPortableHook.ID, ClientPortableHook.PRINCIPAL);
builder.addUTFField("uuid").addUTFField("ownerUuid");
serializationService.getSerializationContext().registerClassDefinition(builder.build());
node.getConnectionManager().addConnectionListener(this);
}
@Override
public Object getValue() {
// TODO: What is serialization service is null??
if (valueObject == null && serializationService != null) {
valueObject = serializationService.toObject(valueData);
}
return valueObject;
}
@Test
public void testRemove() throws IOException {
final IQueue q = getQueue();
q.offer("item1");
q.offer("item2");
q.offer("item3");
final SimpleClient client = getClient();
client.send(new RemoveRequest(queueName, ss.toData("item2")));
Boolean result = (Boolean) client.receive();
assertTrue(result);
assertEquals(2, q.size());
client.send(new RemoveRequest(queueName, ss.toData("item2")));
result = (Boolean) client.receive();
assertFalse(result);
assertEquals(2, q.size());
}
private <T> T _sendAndReceive(ConnectionFactory connectionFactory, Object obj)
throws IOException {
while (active) {
Connection conn = null;
boolean release = true;
try {
conn = connectionFactory.create();
final SerializationService serializationService = getSerializationService();
final Data request = serializationService.toData(obj);
conn.write(request);
final Data response = conn.read();
final Object result = serializationService.toObject(response);
return ErrorHandler.returnResultOrThrowException(result);
} catch (Exception e) {
if (e instanceof IOException) {
if (logger.isFinestEnabled()) {
logger.finest("Error on connection... conn: " + conn + ", error: " + e);
}
IOUtil.closeResource(conn);
release = false;
}
if (ErrorHandler.isRetryable(e)) {
if (redoOperation || obj instanceof RetryableRequest) {
if (logger.isFinestEnabled()) {
logger.finest("Retrying " + obj + ", last-conn: " + conn + ", last-error: " + e);
}
beforeRetry();
continue;
}
}
if (e instanceof IOException && !active) {
continue;
}
throw ExceptionUtil.rethrow(e, IOException.class);
} finally {
if (release && conn != null) {
conn.release();
}
}
}
throw new HazelcastInstanceNotActiveException();
}
@Test
public void testAddListener() throws IOException {
final SimpleClient client = getClient();
client.send(new AddListenerRequest(queueName, true));
client.receive();
getQueue().offer("item");
PortableItemEvent result = (PortableItemEvent) client.receive();
assertEquals("item", ss.toObject(result.getItem()));
assertEquals(ItemEventType.ADDED, result.getEventType());
}
private Object authenticate(
Connection connection,
Credentials credentials,
ClientPrincipal principal,
boolean reAuth,
boolean firstConnection)
throws IOException {
AuthenticationRequest auth = new AuthenticationRequest(credentials, principal);
auth.setReAuth(reAuth);
auth.setFirstConnection(firstConnection);
final SerializationService serializationService = getSerializationService();
connection.write(serializationService.toData(auth));
final Data addressData = connection.read();
Address address =
ErrorHandler.returnResultOrThrowException(serializationService.toObject(addressData));
connection.setRemoteEndpoint(address);
final Data data = connection.read();
return ErrorHandler.returnResultOrThrowException(serializationService.toObject(data));
}
private void loadInitialMemberList() throws IOException {
final SerializationService serializationService = getSerializationService();
final Data request = serializationService.toData(new AddMembershipListenerRequest());
conn.write(request);
final Data response = conn.read();
SerializableCollection coll =
ErrorHandler.returnResultOrThrowException(serializationService.toObject(response));
Map<String, MemberImpl> prevMembers = Collections.emptyMap();
if (!members.isEmpty()) {
prevMembers = new HashMap<String, MemberImpl>(members.size());
for (MemberImpl member : members) {
prevMembers.put(member.getUuid(), member);
}
members.clear();
}
for (Data d : coll.getCollection()) {
members.add((MemberImpl) serializationService.toObject(d));
}
updateMembersRef();
logger.info(membersString());
final List<MembershipEvent> events = new LinkedList<MembershipEvent>();
final Set<Member> eventMembers =
Collections.unmodifiableSet(new LinkedHashSet<Member>(members));
for (MemberImpl member : members) {
final MemberImpl former = prevMembers.remove(member.getUuid());
if (former == null) {
events.add(
new MembershipEvent(
client.getCluster(), member, MembershipEvent.MEMBER_ADDED, eventMembers));
}
}
for (MemberImpl member : prevMembers.values()) {
events.add(
new MembershipEvent(
client.getCluster(), member, MembershipEvent.MEMBER_REMOVED, eventMembers));
}
for (MembershipEvent event : events) {
fireMembershipEvent(event);
}
}
private void loadInitialMemberList() throws Exception {
final SerializationService serializationService = clusterService.getSerializationService();
final AddMembershipListenerRequest request = new AddMembershipListenerRequest();
final SerializableCollection coll =
(SerializableCollection) connectionManager.sendAndReceive(request, conn);
Map<String, MemberImpl> prevMembers = Collections.emptyMap();
if (!members.isEmpty()) {
prevMembers = new HashMap<String, MemberImpl>(members.size());
for (MemberImpl member : members) {
prevMembers.put(member.getUuid(), member);
}
members.clear();
}
for (Data data : coll) {
members.add((MemberImpl) serializationService.toObject(data));
}
updateMembersRef();
LOGGER.info(clusterService.membersString());
final List<MembershipEvent> events = new LinkedList<MembershipEvent>();
final Set<Member> eventMembers =
Collections.unmodifiableSet(new LinkedHashSet<Member>(members));
for (MemberImpl member : members) {
final MemberImpl former = prevMembers.remove(member.getUuid());
if (former == null) {
events.add(
new MembershipEvent(
client.getCluster(), member, MembershipEvent.MEMBER_ADDED, eventMembers));
}
}
for (MemberImpl member : prevMembers.values()) {
events.add(
new MembershipEvent(
client.getCluster(), member, MembershipEvent.MEMBER_REMOVED, eventMembers));
}
for (MembershipEvent event : events) {
clusterService.fireMembershipEvent(event);
}
latch.countDown();
}
@Test
public void testOffer() throws IOException, InterruptedException {
final IQueue q = getQueue();
final SimpleClient client = getClient();
client.send(new OfferRequest(queueName, ss.toData("item1")));
Object result = client.receive();
assertTrue((Boolean) result);
Object item = q.peek();
assertEquals(item, "item1");
q.offer("item2");
q.offer("item3");
q.offer("item4");
q.offer("item5");
q.offer("item6");
final CountDownLatch latch = new CountDownLatch(1);
new Thread() {
public void run() {
try {
latch.await(30, TimeUnit.SECONDS);
} catch (InterruptedException e) {
e.printStackTrace();
}
q.poll();
}
}.start();
client.send(new OfferRequest(queueName, 500, ss.toData("item7")));
result = client.receive();
assertFalse((Boolean) result);
client.send(new OfferRequest(queueName, 10 * 1000, ss.toData("item7")));
Thread.sleep(1000);
latch.countDown();
result = client.receive();
assertTrue((Boolean) result);
}
private void listenMembershipEvents() throws IOException {
final SerializationService serializationService = getSerializationService();
while (!Thread.currentThread().isInterrupted()) {
final Data eventData = conn.read();
final ClientMembershipEvent event =
(ClientMembershipEvent) serializationService.toObject(eventData);
final MemberImpl member = (MemberImpl) event.getMember();
if (event.getEventType() == MembershipEvent.MEMBER_ADDED) {
members.add(member);
} else {
members.remove(member);
getConnectionManager().removeConnectionPool(member.getAddress());
}
updateMembersRef();
logger.info(membersString());
fireMembershipEvent(
new MembershipEvent(
client.getCluster(),
member,
event.getEventType(),
Collections.unmodifiableSet(new LinkedHashSet<Member>(members))));
}
}
protected void putAndGetFromCacheRecordStore(
ICacheRecordStore cacheRecordStore, InMemoryFormat inMemoryFormat) {
SerializationService serializationService = new DefaultSerializationServiceBuilder().build();
for (int i = 0; i < CACHE_RECORD_COUNT; i++) {
cacheRecordStore.put(serializationService.toData(i), "value-" + i, null, null, -1);
}
if (inMemoryFormat == InMemoryFormat.BINARY || inMemoryFormat == InMemoryFormat.NATIVE) {
for (int i = 0; i < CACHE_RECORD_COUNT; i++) {
assertTrue(
Data.class.isAssignableFrom(
cacheRecordStore.get(serializationService.toData(i), null).getClass()));
}
} else if (inMemoryFormat == InMemoryFormat.OBJECT) {
for (int i = 0; i < CACHE_RECORD_COUNT; i++) {
assertTrue(
String.class.isAssignableFrom(
cacheRecordStore.get(serializationService.toData(i), null).getClass()));
}
} else {
throw new IllegalArgumentException("Unsupported in-memory format: " + inMemoryFormat);
}
}
@Test
public void testContains() throws IOException {
IQueue q = getQueue();
q.offer("item1");
q.offer("item2");
q.offer("item3");
q.offer("item4");
q.offer("item5");
List<Data> list = new ArrayList<Data>();
list.add(ss.toData("item1"));
list.add(ss.toData("item2"));
final SimpleClient client = getClient();
client.send(new ContainsRequest(queueName, list));
Boolean result = (Boolean) client.receive();
assertTrue(result);
list.add(ss.toData("item0"));
client.send(new ContainsRequest(queueName, list));
result = (Boolean) client.receive();
assertFalse(result);
}
@Test
public void testDrain() throws IOException {
IQueue q = getQueue();
q.offer("item1");
q.offer("item2");
q.offer("item3");
q.offer("item4");
q.offer("item5");
final SimpleClient client = getClient();
client.send(new DrainRequest(queueName, 1));
PortableCollection result = (PortableCollection) client.receive();
Collection<Data> coll = result.getCollection();
assertEquals(1, coll.size());
assertEquals("item1", ss.toObject(coll.iterator().next()));
assertEquals(4, q.size());
}
@Override
public AttributeType getAttributeType(String attributeName) {
if (KEY_ATTRIBUTE_NAME.equals(attributeName)) {
return ReflectionHelper.getAttributeType(getKey().getClass());
} else if (THIS_ATTRIBUTE_NAME.equals(attributeName)) {
return ReflectionHelper.getAttributeType(getValue().getClass());
}
boolean isKey = isKey(attributeName);
attributeName = getAttributeName(isKey, attributeName);
Data data = getOptionalTargetData(isKey);
if (data != null && data.isPortable()) {
PortableContext portableContext = serializationService.getPortableContext();
return PortableExtractor.getAttributeType(portableContext, data, attributeName);
}
return ReflectionHelper.getAttributeType(isKey ? getKey() : getValue(), attributeName);
}