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); }