class RaftRpcClient {

    protected volatile RpcClient rpcClient;
    private RpcOptions rpcOptions;

    public synchronized boolean init(final RpcOptions rpcOptions) {
        this.rpcOptions = rpcOptions;
        final RaftRpcFactory factory = RpcFactoryHelper.rpcFactory();
        this.rpcClient =
                factory.createRpcClient(factory.defaultJRaftClientConfigHelper(this.rpcOptions));
        return this.rpcClient.init(null);
    }

    /**
     * 请求快照
     */
    public CompletableFuture<RaftRpcProcessor.GetMemberResponse>
    getGrpcAddress(final String address) {<FILL_FUNCTION_BODY>}

    private <V> void internalCallAsyncWithRpc(final Endpoint endpoint,
                                              final RaftRpcProcessor.BaseRequest request,
                                              final FutureClosureAdapter<V> closure) {
        final InvokeContext invokeCtx = new InvokeContext();
        final InvokeCallback invokeCallback = new InvokeCallback() {

            @Override
            public void complete(final Object result, final Throwable err) {
                if (err == null) {
                    final RaftRpcProcessor.BaseResponse response =
                            (RaftRpcProcessor.BaseResponse) result;
                    closure.setResponse((V) response);
                } else {
                    closure.failure(err);
                    closure.run(new Status(-1, err.getMessage()));
                }
            }
        };

        try {
            this.rpcClient.invokeAsync(endpoint, request, invokeCtx, invokeCallback,
                                       this.rpcOptions.getRpcDefaultTimeout());
        } catch (final Throwable t) {
            log.error("failed to call rpc to {}. {}", endpoint, t.getMessage());
            closure.failure(t);
            closure.run(new Status(-1, t.getMessage()));
        }
    }
}

        RaftRpcProcessor.GetMemberRequest request = new RaftRpcProcessor.GetMemberRequest();
        FutureClosureAdapter<RaftRpcProcessor.GetMemberResponse> response =
                new FutureClosureAdapter<>();
        internalCallAsyncWithRpc(JRaftUtils.getEndPoint(address), request, response);
        return response.future;
    
<no_super_class>