Examples with ClientMessage com.hazelcast.client.impl.protocol.ClientMessage used on opensource projects

Example 61 with ClientMessage

use of com.hazelcast.client.impl.protocol.ClientMessage in project hazelcast by hazelcast.

the class ClientMessageReadHandler method onRead.

@Override
public void onRead(ByteBuffer src) throws Exception {
    int messagesCreated = 0;
    while (src.hasRemaining()) {
        final boolean complete = message.readFrom(src);
        if (!complete) {
            messageCounter.inc(messagesCreated);
            return;
        }
        //MESSAGE IS COMPLETE HERE
        if (message.isFlagSet(BEGIN_AND_END_FLAGS)) {
            //HANDLE-MESSAGE
            handleMessage(message);
            message = ClientMessage.create();
            messagesCreated++;
            continue;
        }
        // first fragment
        if (message.isFlagSet(BEGIN_FLAG)) {
            final BufferBuilder builder = new BufferBuilder();
            builderBySessionIdMap.put(message.getCorrelationId(), builder);
            builder.append(message.buffer(), 0, message.getFrameLength());
        } else {
            final BufferBuilder builder = builderBySessionIdMap.get(message.getCorrelationId());
            if (builder.position() == 0) {
                throw new IllegalStateException();
            }
            builder.append(message.buffer(), message.getDataOffset(), message.getFrameLength() - message.getDataOffset());
            if (message.isFlagSet(END_FLAG)) {
                final int msgLength = builder.position();
                ClientMessage cm = ClientMessage.createForDecode(builder.buffer(), 0);
                cm.setFrameLength(msgLength);
                //HANDLE-MESSAGE
                handleMessage(cm);
                builderBySessionIdMap.remove(message.getCorrelationId());
            }
        }
        message = ClientMessage.create();
        messagesCreated++;
    }
}

Example 62 with ClientMessage

use of com.hazelcast.client.impl.protocol.ClientMessage in project hazelcast by hazelcast.

the class AbstractClientCacheProxy method putToAllPartitionsAndWaitForCompletion.

private void putToAllPartitionsAndWaitForCompletion(List<Map.Entry<Data, Data>>[] entriesPerPartition, ExpiryPolicy expiryPolicy, long start) throws ExecutionException, InterruptedException {
    Data expiryPolicyData = toData(expiryPolicy);
    List<FutureEntriesTuple> futureEntriesTuples = new ArrayList<FutureEntriesTuple>(entriesPerPartition.length);
    for (int partitionId = 0; partitionId < entriesPerPartition.length; partitionId++) {
        List<Map.Entry<Data, Data>> entries = entriesPerPartition[partitionId];
        if (entries != null) {
            int completionId = nextCompletionId();
            // TODO If there is a single entry, we could make use of a put operation since that is a bit cheaper
            ClientMessage request = CachePutAllCodec.encodeRequest(nameWithPrefix, entries, expiryPolicyData, completionId);
            Future f = invoke(request, partitionId, completionId);
            futureEntriesTuples.add(new FutureEntriesTuple(f, entries));
        }
    }
    waitResponseFromAllPartitionsForPutAll(futureEntriesTuples, start);
}

Example 63 with ClientMessage

use of com.hazelcast.client.impl.protocol.ClientMessage in project hazelcast by hazelcast.

the class AbstractClientCacheProxy method getAll.

@Override
public Map<K, V> getAll(Set<? extends K> keys, ExpiryPolicy expiryPolicy) {
    final long start = System.nanoTime();
    ensureOpen();
    validateNotNull(keys);
    if (keys.isEmpty()) {
        return emptyMap();
    }
    final Set<Data> keySet = new HashSet<Data>(keys.size());
    for (K key : keys) {
        final Data k = toData(key);
        keySet.add(k);
    }
    Map<K, V> result = createHashMap(keys.size());
    populateResultFromNearCache(keySet, result);
    if (keySet.isEmpty()) {
        return result;
    }
    List<Map.Entry<Data, Data>> entries;
    Map<Data, Long> reservations = createHashMap(keySet.size());
    try {
        for (Data key : keySet) {
            long reservationId = tryReserveForUpdate(key);
            if (reservationId != NOT_RESERVED) {
                reservations.put(key, reservationId);
            }
        }
        Data expiryPolicyData = toData(expiryPolicy);
        ClientMessage request = CacheGetAllCodec.encodeRequest(nameWithPrefix, keySet, expiryPolicyData);
        ClientMessage responseMessage = invoke(request);
        entries = CacheGetAllCodec.decodeResponse(responseMessage).response;
        for (Map.Entry<Data, Data> dataEntry : entries) {
            Data keyData = dataEntry.getKey();
            Data valueData = dataEntry.getValue();
            K key = toObject(keyData);
            V value = toObject(valueData);
            result.put(key, value);
            Long reservationId = reservations.get(keyData);
            if (reservationId != null) {
                storeInNearCache(keyData, valueData, value, reservationId, false);
                reservations.remove(keyData);
            }
        }
    } finally {
        releaseRemainingReservedKeys(reservations);
    }
    if (statisticsEnabled) {
        statistics.increaseCacheHits(entries.size());
        statistics.addGetTimeNanos(System.nanoTime() - start);
    }
    return result;
}

Example 64 with ClientMessage

use of com.hazelcast.client.impl.protocol.ClientMessage in project hazelcast by hazelcast.

the class AbstractClientCacheProxy method getInternal.

protected Object getInternal(final K key, ExpiryPolicy expiryPolicy, boolean async) {
    final long start = System.nanoTime();
    ensureOpen();
    validateNotNull(key);
    final Data keyData = toData(key);
    Object cached = getCachedValue(keyData, !async);
    if (cached != NOT_CACHED) {
        return asCompletedFutureOrValue(cached, async);
    }
    final long reservationId = tryReserveForUpdate(keyData);
    final Data expiryPolicyData = toData(expiryPolicy);
    ClientMessage request = CacheGetCodec.encodeRequest(nameWithPrefix, keyData, expiryPolicyData);
    ClientInvocationFuture future;
    try {
        final int partitionId = clientContext.getPartitionService().getPartitionId(keyData);
        final HazelcastClientInstanceImpl client = (HazelcastClientInstanceImpl) clientContext.getHazelcastInstance();
        final ClientInvocation clientInvocation = new ClientInvocation(client, request, partitionId);
        future = clientInvocation.invoke();
    } catch (Throwable t) {
        invalidateNearCache(keyData);
        throw rethrow(t);
    }
    SerializationService serializationService = clientContext.getSerializationService();
    ClientDelegatingFuture<V> delegatingFuture = new ClientDelegatingFuture<V>(future, serializationService, cacheGetResponseDecoder);
    if (async) {
        if (nearCache != null) {
            delegatingFuture.andThenInternal(new ExecutionCallback<Data>() {

                public void onResponse(Data valueData) {
                    storeInNearCache(keyData, valueData, null, reservationId, false);
                    if (statisticsEnabled) {
                        handleStatisticsOnGet(start, valueData);
                    }
                }

                public void onFailure(Throwable t) {
                    invalidateNearCache(keyData);
                }
            }, false);
        }
        return delegatingFuture;
    } else {
        try {
            V value = toObject(delegatingFuture.get());
            if (nearCache != null) {
                storeInNearCache(keyData, (Data) delegatingFuture.getResponse(), value, reservationId, false);
            }
            if (statisticsEnabled) {
                handleStatisticsOnGet(start, value);
            }
            return value;
        } catch (Throwable e) {
            invalidateNearCache(keyData);
            throw rethrowAllowedTypeFirst(e, CacheException.class);
        }
    }
}

Example 65 with ClientMessage

use of com.hazelcast.client.impl.protocol.ClientMessage in project hazelcast by hazelcast.

the class ClientCacheHelper method createCacheConfig.

/**
     * Sends the cache configuration to server.
     *
     * @param client             the client instance which will send the operation to server
     * @param configs            {@link ConcurrentMap} based store that holds cache configurations
     * @param cacheName          full cache name with prefixes
     * @param newCacheConfig     the cache configuration to be sent to server
     * @param createAlsoOnOthers flag which represents whether cache config
     *                           will be sent to other nodes by the target node
     * @param syncCreate         flag which represents response will be waited from the server
     * @param <K>                type of the key of the cache
     * @param <V>                type of the value of the cache
     * @return the created cache configuration
     */
static <K, V> CacheConfig<K, V> createCacheConfig(HazelcastClientInstanceImpl client, ConcurrentMap<String, CacheConfig> configs, String cacheName, CacheConfig<K, V> newCacheConfig, boolean createAlsoOnOthers, boolean syncCreate) {
    try {
        CacheConfig<K, V> currentCacheConfig = configs.get(cacheName);
        int partitionId = client.getClientPartitionService().getPartitionId(newCacheConfig.getNameWithPrefix());
        Object resolvedConfig = resolveCacheConfig(client, newCacheConfig, partitionId);
        Data configData = client.getSerializationService().toData(resolvedConfig);
        ClientMessage request = CacheCreateConfigCodec.encodeRequest(configData, createAlsoOnOthers);
        ClientInvocation clientInvocation = new ClientInvocation(client, request, partitionId);
        Future<ClientMessage> future = clientInvocation.invoke();
        if (syncCreate) {
            final ClientMessage response = future.get();
            final Data data = CacheCreateConfigCodec.decodeResponse(response).response;
            return resolveCacheConfig(client, clientInvocation, data);
        } else {
            return currentCacheConfig;
        }
    } catch (Exception e) {
        throw rethrow(e);
    }
}