.setGetServerRequest(LocatorAPI.GetServerRequest.newBuilder()).build() .writeDelimitedTo(outputStream);
@Override public Map<K, V> getAll(Collection<K> keys) throws IOException { Map<K, V> values = new HashMap<>(); RegionAPI.GetAllRequest.Builder getAllRequest = RegionAPI.GetAllRequest.newBuilder(); getAllRequest.setRegionName(name); for (K key : keys) { getAllRequest.addKey(valueEncoder.encodeValue(key)); } Message request = Message.newBuilder().setGetAllRequest(getAllRequest).build(); Message message = protobufChannel.sendRequest(request, MessageTypeCase.GETALLRESPONSE); final RegionAPI.GetAllResponse getAllResponse = message.getGetAllResponse(); Map<Object, String> failures = new HashMap<>(); if (getAllResponse.getFailuresCount() > 0) { for (BasicTypes.KeyedError keyedError : getAllResponse.getFailuresList()) { failures.put(valueEncoder.decodeValue(keyedError.getKey()), keyedError.getError().getMessage()); } throw new IOException("Unable to process the following keys: " + failures); } for (BasicTypes.Entry entry : getAllResponse.getEntriesList()) { values.put((K) valueEncoder.decodeValue(entry.getKey()), (V) valueEncoder.decodeValue(entry.getValue())); } return values; }
@Override public void putAll(Map<K, V> values) throws IOException { RegionAPI.PutAllRequest.Builder putAllRequest = RegionAPI.PutAllRequest.newBuilder(); putAllRequest.setRegionName(name); for (K key : values.keySet()) { putAllRequest.addEntry(valueEncoder.encodeEntry(key, values.get(key))); } final Message request = Message.newBuilder().setPutAllRequest(putAllRequest).build(); final RegionAPI.PutAllResponse putAllResponse = protobufChannel.sendRequest(request, MessageTypeCase.PUTALLRESPONSE).getPutAllResponse(); if (0 < putAllResponse.getFailedKeysCount()) { Map<Object, String> failures = new HashMap<>(); for (BasicTypes.KeyedError keyedError : putAllResponse.getFailedKeysList()) { failures.put(valueEncoder.decodeValue(keyedError.getKey()), keyedError.getError().getMessage()); } throw new IOException("Unable to put the following keys: " + failures); } }
@Override public void close() { try { final Message disconnectClientRequest = ClientProtocol.Message.newBuilder() .setDisconnectClientRequest( ConnectionAPI.DisconnectClientRequest.newBuilder().setReason("Driver closed")) .build(); final ConnectionAPI.DisconnectClientResponse disconnectClientResponse = channel.sendRequest(disconnectClientRequest, MessageTypeCase.DISCONNECTCLIENTRESPONSE) .getDisconnectClientResponse(); if (Objects.isNull(disconnectClientResponse)) { // The server did not acknowledge the disconnect request; ignore for now. } } catch (IOException ioe) { // NOP } finally { try { this.channel.close(); } catch (IOException e) { // ignore } } }
public ClientProtocol.Message process(ClientProtocol.Message request, MessageExecutionContext messageExecutionContext) { ClientProtocol.Message.MessageTypeCase requestType = request.getMessageTypeCase(); logger.debug("Processing request of type {}", requestType); ProtobufOperationContext operationContext = protobufOperationContextRegistry.getOperationContext(requestType); Result result; try { messageExecutionContext.getConnectionState().validateOperation(operationContext); result = processOperation(request, messageExecutionContext, requestType, operationContext); } catch (VirtualMachineError error) { SystemFailure.initiateFailure(error); throw error; } catch (Throwable t) { logger.warn("Failure for request " + request, t); SystemFailure.checkFailure(); result = Failure.of(t); if (t instanceof ConnectionStateException) { messageExecutionContext.setState(new TerminateConnection()); } } return ((ClientProtocol.Message.Builder) result.map(operationContext.getToResponse(), operationContext.getToErrorResponse())).build(); }
@Override public List<T> execute(final Object... bindParameters) throws IOException { List<EncodedValue> encodedParameters = Arrays.asList(bindParameters).stream() .map(valueEncoder::encodeValue).collect(Collectors.toList());; Message request = Message.newBuilder().setOqlQueryRequest( OQLQueryRequest.newBuilder().addAllBindParameter(encodedParameters).setQuery(queryString)) .build(); final OQLQueryResponse response = channel.sendRequest(request, MessageTypeCase.OQLQUERYRESPONSE).getOqlQueryResponse(); switch (response.getResultCase()) { case SINGLERESULT: return (List<T>) parseSingleResult(response); case LISTRESULT: return parseListResult(response); case TABLERESULT: return (List<T>) parseTableResult(response); default: throw new RuntimeException("Unexpected response: " + response); } }
@Override public List<T> executeOnRegion(Object arguments, String regionName, Object... keyFilters) throws IOException { List<BasicTypes.EncodedValue> encodedFilters = Arrays.asList(keyFilters).stream() .map(valueEncoder::encodeValue).collect(Collectors.toList()); ClientProtocol.Message request = ClientProtocol.Message.newBuilder() .setExecuteFunctionOnRegionRequest(FunctionAPI.ExecuteFunctionOnRegionRequest.newBuilder() .setRegion(regionName).addAllKeyFilter(encodedFilters).setFunctionID(functionId)) .build(); final FunctionAPI.ExecuteFunctionOnRegionResponse response = channel .sendRequest(request, ClientProtocol.Message.MessageTypeCase.EXECUTEFUNCTIONONREGIONRESPONSE) .getExecuteFunctionOnRegionResponse(); return response.getResultsList().stream().map(value -> (T) valueEncoder.decodeValue(value)) .collect(Collectors.toList()); }
@Override public List<T> executeOnMember(Object arguments, String... members) throws IOException { final List<String> stringMembers = Arrays.asList(members); ClientProtocol.Message request = ClientProtocol.Message.newBuilder() .setExecuteFunctionOnMemberRequest(FunctionAPI.ExecuteFunctionOnMemberRequest.newBuilder() .addAllMemberName(stringMembers).setFunctionID(functionId)) .build(); final FunctionAPI.ExecuteFunctionOnMemberResponse response = channel .sendRequest(request, ClientProtocol.Message.MessageTypeCase.EXECUTEFUNCTIONONMEMBERRESPONSE) .getExecuteFunctionOnMemberResponse(); return response.getResultsList().stream().map(value -> (T) valueEncoder.decodeValue(value)) .collect(Collectors.toList()); }
@Override public List<T> executeOnGroup(Object arguments, String... groups) throws IOException { final List<String> stringGroups = Arrays.asList(groups); ClientProtocol.Message request = ClientProtocol.Message.newBuilder() .setExecuteFunctionOnGroupRequest(FunctionAPI.ExecuteFunctionOnGroupRequest.newBuilder() .addAllGroupName(stringGroups).setFunctionID(functionId)) .build(); final FunctionAPI.ExecuteFunctionOnGroupResponse response = channel .sendRequest(request, ClientProtocol.Message.MessageTypeCase.EXECUTEFUNCTIONONGROUPRESPONSE) .getExecuteFunctionOnGroupResponse(); return response.getResultsList().stream().map(value -> (T) valueEncoder.decodeValue(value)) .collect(Collectors.toList()); } }
/** * Create a request to insert multiple entries in a region * * @param regionName - Region to which entries are being added * @param entries - key, value pairs to add to the region * @return Request object containing the putAll request for the passed parameters */ public static ClientProtocol.Message createPutAllRequest(String regionName, Set<BasicTypes.Entry> entries) { RegionAPI.PutAllRequest.Builder putAllRequestBuilder = RegionAPI.PutAllRequest.newBuilder().setRegionName(regionName); putAllRequestBuilder.addAllEntry(entries); return ClientProtocol.Message.newBuilder().setPutAllRequest(putAllRequestBuilder).build(); }
@Override public Set<K> keySet() throws IOException { final Message request = Message.newBuilder() .setKeySetRequest(RegionAPI.KeySetRequest.newBuilder().setRegionName(name)).build(); final Message message = protobufChannel.sendRequest(request, MessageTypeCase.KEYSETRESPONSE); final RegionAPI.KeySetResponse keySetResponse = message.getKeySetResponse(); Set<K> keys = new HashSet<>(keySetResponse.getKeysCount()); for (BasicTypes.EncodedValue value : keySetResponse.getKeysList()) { keys.add((K) valueEncoder.decodeValue(value)); } return keys; } }
/** * Creates a request object containing a RegionAPI.PutIfAbsentRequest * * @param region - Name of the region to put data in * @param entry - Encoded key,value pair, see createEntry in {@link ProtobufRequestUtilities} * @return Request object containing the passed params. */ public static ClientProtocol.Message createPutIfAbsentRequest(String region, BasicTypes.Entry entry) { RegionAPI.PutIfAbsentRequest putIfAbsentRequest = RegionAPI.PutIfAbsentRequest.newBuilder().setRegionName(region).setEntry(entry).build(); return ClientProtocol.Message.newBuilder().setPutIfAbsentRequest(putIfAbsentRequest).build(); }
/** * Creates a request object containing a RegionAPI.GetRequest * * @param regionName - Name of the region being fetched from * @param key - Encoded key, see createEncodedValue in {@link ProtobufRequestUtilities} * @return Request object containing the passed params. */ public static ClientProtocol.Message createGetRequest(String regionName, BasicTypes.EncodedValue key) { RegionAPI.GetRequest getRequest = RegionAPI.GetRequest.newBuilder().setRegionName(regionName).setKey(key).build(); return ClientProtocol.Message.newBuilder().setGetRequest(getRequest).build(); }
public static ClientProtocol.Message makeGetSizeRequestMessage(String requestRegion) { return ClientProtocol.Message.newBuilder().setGetSizeRequest(makeGetSizeRequest(requestRegion)) .build(); }
/** * Creates a request object containing a RegionAPI.RemoveRequest * * @param regionName - Name of the region being deleted from * @param key - Encoded key, see createEncodedValue in {@link ProtobufRequestUtilities} * @return Request object containing the passed params. */ public static ClientProtocol.Message createRemoveRequest(String regionName, BasicTypes.EncodedValue key) { RegionAPI.RemoveRequest removeRequest = RegionAPI.RemoveRequest.newBuilder().setRegionName(regionName).setKey(key).build(); return ClientProtocol.Message.newBuilder().setRemoveRequest(removeRequest).build(); }
private void sendHandshake(String username, String password, OutputStream outputStream) throws IOException { final ConnectionAPI.HandshakeRequest.Builder builder = ConnectionAPI.HandshakeRequest.newBuilder(); if (username != null) { builder.putCredentials("security-username", username); builder.putCredentials("security-password", password); } builder.setValueFormat(serializer.getID()); final Message authenticationRequest = Message.newBuilder().setHandshakeRequest(builder).build(); authenticationRequest.writeDelimitedTo(outputStream); }
@Override public void remove(K key) throws IOException { final Message request = Message.newBuilder() .setRemoveRequest( RemoveRequest.newBuilder().setRegionName(name).setKey(valueEncoder.encodeValue(key))) .build(); protobufChannel.sendRequest(request, MessageTypeCase.REMOVERESPONSE); }
public static ClientProtocol.Message createGetRequestMessage() { ClientProtocol.Message.Builder messageBuilder = ClientProtocol.Message.newBuilder(); messageBuilder.setGetRequest(getGetRequestBuilder()); return messageBuilder.build(); }
@Override public void put(K key, V value) throws IOException { final Message request = Message.newBuilder().setPutRequest( PutRequest.newBuilder().setRegionName(name).setEntry(valueEncoder.encodeEntry(key, value))) .build(); protobufChannel.sendRequest(request, MessageTypeCase.PUTRESPONSE); }
/** * This creates a protobuf message containing a ClientProtocol.Message * * @param getAllRequest - The request for the message * @return a protobuf Message containing the above parameters */ public static ClientProtocol.Message createProtobufRequestWithGetAllRequest( RegionAPI.GetAllRequest getAllRequest) { return ClientProtocol.Message.newBuilder().setGetAllRequest(getAllRequest).build(); } }