public void sendFragments(RpcOutcomeListener<Ack> outcomeListener, InitializeFragments fragments){ SendFragment b = new SendFragment(outcomeListener, fragments); manager.runCommand(b); }
public void cancelFragment(RpcOutcomeListener<Ack> outcomeListener, FragmentHandle handle){ final SignalFragment b = new SignalFragment(outcomeListener, handle, RpcType.REQ_CANCEL_FRAGMENTS); manager.runCommand(b); }
public void sendFragmentStatus(RpcOutcomeListener<Ack> outcomeListener, FragmentStatus status){ SendFragmentStatus b = new SendFragmentStatus(outcomeListener, status); manager.runCommand(b); }
public void sendData(RpcOutcomeListener<Ack> outcomeListener, QueryWritableBatch data) { manager.runCommand(new SendBatch(outcomeListener, data)); }
public void sendStreamComplete(RpcOutcomeListener<Ack> outcomeListener, FragmentStreamComplete streamComplete) { manager.runCommand(new SendStreamCompleteListen(outcomeListener, streamComplete)); }
public void sendRecordBatch(RpcOutcomeListener<Ack> outcomeListener, FragmentWritableBatch batch) { manager.runCommand(new SendBatchAsyncListen(outcomeListener, batch)); }
public RpcFuture<Ack> sendNodeQueryStatus(NodeQueryStatus status){ SendNodeQueryStatusFuture b = new SendNodeQueryStatusFuture(status); manager.runCommand(b); return b.getFuture(); }
public RpcFuture<Ack> requestCancelQuery(ExternalId queryId, String reason){ CancelQuery c = new CancelQuery(queryId, reason); manager.runCommand(c); return c.getFuture(); }
public RpcFuture<QueryProfile> requestQueryProfile(ExternalId queryId) { RequestProfile b = new RequestProfile(queryId); manager.runCommand(b); return b.getFuture(); } }
public RpcFuture<Ack> sendFragmentStatus(FragmentStatus status){ SendFragmentStatusFuture b = new SendFragmentStatusFuture(status); manager.runCommand(b); return b.getFuture(); }
public void sendOOBMessage(RpcOutcomeListener<Ack> outcomeListener, OutOfBandMessage message) { manager.runCommand(new SendOOBMessage(outcomeListener, message.toProtoMessage())); }
private void nextIterator() throws IOException { final ListStatusCommand command = new ListStatusCommand(path, handle, listStatusBatchSize); runner.runCommand(command); RpcFuture<DFS.ListStatusResponse> future = command.getFuture(); try { DFS.ListStatusResponse response = future.checkedGet(rpcTimeoutMs, TimeUnit.MILLISECONDS); handle = response.hasHandle() ? response.getHandle() : null; List<DFS.FileStatus> protoStatuses = getListOrEmpty(response.getStatusesList()); currentIterator = protoStatuses.stream().map(s -> { return fromProtoFileStatus(s); }).iterator(); } catch(TimeoutException e) { throw new IOException("Timeout occured during I/O request for " + uri, e); } catch(RpcException e) { RpcException.propagateIfPossible(e, IOException.class); throw e; } }
public RpcFuture<ReflectionRPC.ReflectionInfoResp> requestReflectionStatus() { ReflectionRPC.ReflectionInfoReq reflectionStatusRequest = ReflectionRPC.ReflectionInfoReq.newBuilder().build(); ReflectionTunnel.RequestReflectionInfo b = new ReflectionTunnel.RequestReflectionInfo(reflectionStatusRequest); manager.runCommand(b); return b.getFuture(); }
public RpcFuture<ReflectionRPC.DependencyInfoResp> requestDependencyInfos() { ReflectionRPC.DependencyInfoReq dependencyInfosRequest = ReflectionRPC.DependencyInfoReq.newBuilder().build(); ReflectionTunnel.RequestDependencyInfos b = new ReflectionTunnel.RequestDependencyInfos(dependencyInfosRequest); manager.runCommand(b); return b.getFuture(); } }
public void informReceiverFinished(RpcOutcomeListener<Ack> outcomeListener, FinishedReceiver finishedReceiver){ Preconditions.checkNotNull(finishedReceiver.getReceiver(), "must set receiver's handle"); checkFragmentHandle(finishedReceiver.getReceiver()); Preconditions.checkNotNull(finishedReceiver.getSender(), "must set sender's handle"); checkFragmentHandle(finishedReceiver.getSender()); final ReceiverFinished b = new ReceiverFinished(outcomeListener, finishedReceiver); manager.runCommand(b); }
public RpcFuture<ReflectionRPC.RefreshInfoResp> requestRefreshInfos() { ReflectionRPC.RefreshInfoReq refreshInfosRequest = ReflectionRPC.RefreshInfoReq.newBuilder().build(); ReflectionTunnel.RequestRefreshInfos b = new ReflectionTunnel.RequestRefreshInfos(refreshInfosRequest); manager.runCommand(b); return b.getFuture(); }
@Override public boolean delete(Path f, boolean recursive) throws IOException { Path absolutePath = toAbsolutePath(f); checkPath(absolutePath); final DeleteCommand command = new DeleteCommand(absolutePath.toUri().getPath(), recursive); runner.runCommand(command); RpcFuture<DFS.DeleteResponse> future = command.getFuture(); try { DFS.DeleteResponse response = future.checkedGet(rpcTimeoutMs, TimeUnit.MILLISECONDS); return response.getValue(); } catch(TimeoutException e) { throw new IOException("Timeout occured during I/O request for " + uri, e); } catch(RpcException e) { RpcException.propagateIfPossible(e, IOException.class); throw e; } }
private void communicateChange(SourceConfig config, RpcType rpcType) { final Set<NodeEndpoint> endpoints = new HashSet<>(); endpoints.add(context.get().getEndpoint()); List<RpcFuture<Ack>> futures = new ArrayList<>(); SourceWrapper wrapper = SourceWrapper.newBuilder().setBytes(ByteString.copyFrom(ProtobufIOUtil.toByteArray(config, SourceConfig.getSchema(), LinkedBuffer.allocate()))).build(); for(NodeEndpoint e : Iterables.concat(this.context.get().getCoordinators(), this.context.get().getExecutors())) { if(!endpoints.add(e)) { continue; } SendSource send = new SendSource(wrapper, rpcType); tunnelFactory.getCommandRunner(e.getAddress(), e.getFabricPort()).runCommand(send);; logger.trace("Sending [{}] to {}:{}", config.getName(), e.getAddress(), e.getUserPort()); futures.add(send.getFuture()); } try { Futures.successfulAsList(futures).get(CHANGE_COMMUNICATION_WAIT, TimeUnit.MILLISECONDS); } catch (InterruptedException | ExecutionException | TimeoutException e1) { logger.warn("Failure while communicating source change [{}].", config.getName(), e1); } }
@Override public FileStatus getFileStatus(Path f) throws IOException { Path absolutePath = toAbsolutePath(f); checkPath(absolutePath); final GetFileStatusCommand command = new GetFileStatusCommand(absolutePath.toUri().getPath()); runner.runCommand(command); RpcFuture<DFS.GetFileStatusResponse> future = command.getFuture(); try { DFS.GetFileStatusResponse response = future.checkedGet(rpcTimeoutMs, TimeUnit.MILLISECONDS); return fromProtoFileStatus(response.getStatus()); } catch(TimeoutException e) { throw new IOException("Timeout occured during I/O request for " + uri, e); } catch(RpcException e) { RpcException.propagateIfPossible(e, IOException.class); throw e; } }
@Test(expected=ChannelClosedException.class) public void failureOnDisconnection() throws Exception { FabricRunnerFactory factory = getFabric().registerProtocol(new Protocol(null)); FabricCommandRunner runner = factory.getCommandRunner(getFabric().getAddress(), getFabric().getPort()); SimpleMessage m = new SimpleMessage(2); runner.runCommand(m); m.getFuture().checkedGet(1000, TimeUnit.MILLISECONDS); }