@Override public Result<RegionAPI.KeySetResponse> process(ProtobufSerializationService serializationService, RegionAPI.KeySetRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, EncodingException, DecodingException { String regionName = request.getRegionName(); Set<Object> keySet = messageExecutionContext.getSecureCache().keySet(regionName); RegionAPI.KeySetResponse.Builder builder = RegionAPI.KeySetResponse.newBuilder(); keySet.stream().map(serializationService::encode).forEach(builder::addKeys); return Success.of(builder.build()); } }
@Override public Result<RegionAPI.GetRegionNamesResponse> process( ProtobufSerializationService serializationService, RegionAPI.GetRegionNamesRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException { Collection<String> regions = messageExecutionContext.getSecureCache().getRegionNames(); RegionAPI.GetRegionNamesResponse.Builder builder = RegionAPI.GetRegionNamesResponse.newBuilder(); regions.forEach(builder::addRegions); return Success.of(builder.build()); } }
@Override public Result<ConnectionAPI.DisconnectClientResponse> process( ProtobufSerializationService serializationService, ConnectionAPI.DisconnectClientRequest request, MessageExecutionContext messageExecutionContext) { logger.info("Client disconnecting due to {}", request.getReason()); messageExecutionContext.setState(new TerminateConnection()); return Success.of(ConnectionAPI.DisconnectClientResponse.newBuilder().build()); } }
@Override public Result<ExecuteFunctionOnMemberResponse> process( ProtobufSerializationService serializationService, ExecuteFunctionOnMemberRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, DecodingException, EncodingException { final String functionID = request.getFunctionID(); List<String> memberNameList = request.getMemberNameList(); Object arguments = getFunctionArguments(request, serializationService); List<Object> results = messageExecutionContext.getSecureCache().getFunctionService() .executeFunctionOnMember(functionID, arguments, memberNameList); final ExecuteFunctionOnMemberResponse.Builder responseMessage = ExecuteFunctionOnMemberResponse.newBuilder(); results.stream().map(serializationService::encode).forEach(responseMessage::addResults); return Success.of(responseMessage.build()); }
@Override public Result<FunctionAPI.ExecuteFunctionOnGroupResponse> process( ProtobufSerializationService serializationService, FunctionAPI.ExecuteFunctionOnGroupRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, DecodingException, EncodingException { final String functionID = request.getFunctionID(); List<String> memberNameList = request.getGroupNameList(); Object arguments = getFunctionArguments(request, serializationService); List<Object> results = messageExecutionContext.getSecureCache().getFunctionService() .executeFunctionOnGroups(functionID, arguments, memberNameList); final FunctionAPI.ExecuteFunctionOnGroupResponse.Builder responseMessage = FunctionAPI.ExecuteFunctionOnGroupResponse.newBuilder(); results.stream().map(serializationService::encode).forEach(responseMessage::addResults); return Success.of(responseMessage.build()); }
@Override public Result<RegionAPI.ClearResponse> process(ProtobufSerializationService serializationService, RegionAPI.ClearRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, DecodingException { String regionName = request.getRegionName(); messageExecutionContext.getSecureCache().clear(regionName); return Success.of(RegionAPI.ClearResponse.newBuilder().build()); } }
@Override public Result<RegionAPI.PutAllResponse> process(ProtobufSerializationService serializationService, RegionAPI.PutAllRequest putAllRequest, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, DecodingException { String regionName = putAllRequest.getRegionName(); RegionAPI.PutAllResponse.Builder builder = RegionAPI.PutAllResponse.newBuilder(); SecureCache cache = messageExecutionContext.getSecureCache(); Map<Object, Object> entries = new HashMap<>(putAllRequest.getEntryList().size()); putAllRequest.getEntryList() .forEach(entry -> entries.put(serializationService.decode(entry.getKey()), serializationService.decode(entry.getValue()))); cache.putAll(regionName, entries, (key, exception) -> addError(builder, serializationService.encode(key), exception)); return Success.of(builder.build()); }
@Override public Result<OQLQueryResponse> process(final ProtobufSerializationService serializationService, final OQLQueryRequest request, final MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, ConnectionStateException, EncodingException, DecodingException { String queryString = request.getQuery(); List<EncodedValue> encodedParameters = request.getBindParameterList(); Object[] bindParameters = decodeBindParameters(serializationService, encodedParameters); try { Object results = messageExecutionContext.getSecureCache().query(queryString, bindParameters); return Success.of(encodeResults(serializationService, results)); } catch (QueryException e) { logger.info("Query failed: " + queryString, e); return Failure.of(e); } }
@Override public Result<RegionAPI.GetSizeResponse> process( ProtobufSerializationService serializationService, RegionAPI.GetSizeRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException { String regionName = request.getRegionName(); int size = messageExecutionContext.getSecureCache().getSize(regionName); return Success.of(RegionAPI.GetSizeResponse.newBuilder().setSize(size).build()); } }
BasicTypes.Server server = serverBuilder.build(); builder.setServer(server); return Success.of(builder.build());
@Override public Result<ConnectionAPI.HandshakeResponse> process( ProtobufSerializationService serializationService, ConnectionAPI.HandshakeRequest request, MessageExecutionContext messageExecutionContext) throws ConnectionStateException { boolean authenticated = false; if (request.getCredentialsCount() > 0 || messageExecutionContext.getConnectionState() instanceof RequireAuthentication) { Properties properties = new Properties(); properties.putAll(request.getCredentialsMap()); try { messageExecutionContext.authenticate(properties); messageExecutionContext.setState(new AcceptMessages()); authenticated = true; } catch (AuthenticationFailedException e) { messageExecutionContext.getStatistics().incAuthenticationFailures(); logger.debug("Authentication failed", e); messageExecutionContext.setState(new TerminateConnection()); } } String valueFormat = request.getValueFormat(); if (valueFormat != null && !valueFormat.isEmpty()) { ValueSerializer newSerializer = loadSerializer(valueFormat); messageExecutionContext.setValueSerializer(newSerializer); } return Success .of(ConnectionAPI.HandshakeResponse.newBuilder().setAuthenticated(authenticated).build()); }
@Override public Result<RegionAPI.RemoveResponse> process(ProtobufSerializationService serializationService, RegionAPI.RemoveRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, DecodingException { String regionName = request.getRegionName(); Object decodedKey = serializationService.decode(request.getKey()); if (decodedKey == null) { return Failure.of(BasicTypes.ErrorCode.INVALID_REQUEST, "NULL is not a valid key for removal."); } messageExecutionContext.getSecureCache().remove(regionName, decodedKey); return Success.of(RegionAPI.RemoveResponse.newBuilder().build()); } }
@Override public Result<RegionAPI.GetAllResponse> process(ProtobufSerializationService serializationService, RegionAPI.GetAllRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, DecodingException, ConnectionStateException { String regionName = request.getRegionName(); RegionAPI.GetAllResponse.Builder responseBuilder = RegionAPI.GetAllResponse.newBuilder(); SecureCache cache = messageExecutionContext.getSecureCache(); Collection<Object> keys = serializationService.decodeList(request.getKeyList()); cache.getAll(regionName, keys, (key, value) -> addEntry(serializationService, responseBuilder, key, value), (key, exception) -> addException(serializationService, responseBuilder, key, exception)); return Success.of(responseBuilder.build()); }
@Override public Result<RegionAPI.PutResponse> process(ProtobufSerializationService serializationService, RegionAPI.PutRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, DecodingException { String regionName = request.getRegionName(); BasicTypes.Entry entry = request.getEntry(); Object decodedValue = serializationService.decode(entry.getValue()); Object decodedKey = serializationService.decode(entry.getKey()); SecureCache cache = messageExecutionContext.getSecureCache(); cache.put(regionName, decodedKey, decodedValue); return Success.of(RegionAPI.PutResponse.newBuilder().build()); } }
@Override public Result<RegionAPI.GetResponse> process(ProtobufSerializationService serializationService, RegionAPI.GetRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, EncodingException, DecodingException { String regionName = request.getRegionName(); Object decodedKey = serializationService.decode(request.getKey()); if (decodedKey == null) { return Failure.of(BasicTypes.ErrorCode.INVALID_REQUEST, "Performing a get on a NULL key."); } SecureCache secureCache = messageExecutionContext.getSecureCache(); Object resultValue = secureCache.get(regionName, decodedKey); BasicTypes.EncodedValue encodedValue = serializationService.encode(resultValue); return Success.of(RegionAPI.GetResponse.newBuilder().setResult(encodedValue).build()); } }
@Override public Result<RegionAPI.PutIfAbsentResponse> process( ProtobufSerializationService serializationService, RegionAPI.PutIfAbsentRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, ConnectionStateException, EncodingException, DecodingException { final String regionName = request.getRegionName(); final BasicTypes.Entry entry = request.getEntry(); Object decodedValue = serializationService.decode(entry.getValue()); Object decodedKey = serializationService.decode(entry.getKey()); final Object oldValue = messageExecutionContext.getSecureCache().putIfAbsent(regionName, decodedKey, decodedValue); return Success.of(RegionAPI.PutIfAbsentResponse.newBuilder() .setOldValue(serializationService.encode(oldValue)).build()); } }
@Override public Result<ExecuteFunctionOnRegionResponse> process( ProtobufSerializationService serializationService, ExecuteFunctionOnRegionRequest request, MessageExecutionContext messageExecutionContext) throws InvalidExecutionContextException, ConnectionStateException, EncodingException, DecodingException { final String functionID = request.getFunctionID(); final String regionName = request.getRegion(); Object arguments = getFunctionArguments(request, serializationService); Set<?> filter = parseFilter(serializationService, request); SecureFunctionService functionService = messageExecutionContext.getSecureCache().getFunctionService(); List<Object> results = functionService.executeFunctionOnRegion(functionID, regionName, arguments, filter); final ExecuteFunctionOnRegionResponse.Builder responseMessage = ExecuteFunctionOnRegionResponse.newBuilder(); for (Object result : results) { responseMessage.addResults(serializationService.encode(result)); } return Success.of(responseMessage.build()); }