Java Code Examples for com.twitter.util.Future#value()

@Override
public Future<ServerInfo> handshakeWithClientInfo(ClientInfo clientInfo) {
    ServerInfo serverInfo = new ServerInfo();
    closeLock.readLock().lock();
    try {
        serverInfo.setServerStatus(serverStatus);
    } finally {
        closeLock.readLock().unlock();
    }

    if (clientInfo.isSetGetOwnerships() && !clientInfo.isGetOwnerships()) {
        return Future.value(serverInfo);
    }

    Optional<String> regex = Optional.absent();
    if (clientInfo.isSetStreamNameRegex()) {
        regex = Optional.of(clientInfo.getStreamNameRegex());
    }

    Map<String, String> ownershipMap = streamManager.getStreamOwnershipMap(regex);
    serverInfo.setOwnerships(ownershipMap);
    return Future.value(serverInfo);
}
 

/**
 * Get client id and its ephemeral owner.
 *
 * @param zkClient
 *          zookeeper client
 * @param lockPath
 *          lock path
 * @param nodeName
 *          node name
 * @return client id and its ephemeral owner.
 */
static Future<Pair<String, Long>> asyncParseClientID(ZooKeeper zkClient, String lockPath, String nodeName) {
    String[] parts = nodeName.split("_");
    // member_<clientid>_s<owner_session>_
    if (4 == parts.length && parts[2].startsWith("s")) {
        long sessionOwner = Long.parseLong(parts[2].substring(1));
        String clientId;
        try {
            clientId = URLDecoder.decode(parts[1], UTF_8.name());
            return Future.value(Pair.of(clientId, sessionOwner));
        } catch (UnsupportedEncodingException e) {
            // if failed to parse client id, we have to get client id by zookeeper#getData.
        }
    }
    final Promise<Pair<String, Long>> promise = new Promise<Pair<String, Long>>();
    zkClient.getData(lockPath + "/" + nodeName, false, new AsyncCallback.DataCallback() {
        @Override
        public void processResult(int rc, String path, Object ctx, byte[] data, Stat stat) {
            if (KeeperException.Code.OK.intValue() != rc) {
                promise.setException(KeeperException.create(KeeperException.Code.get(rc)));
            } else {
                promise.setValue(Pair.of(deserializeClientId(data), stat.getEphemeralOwner()));
            }
        }
    }, null);
    return promise;
}
 

/**
 * Get the last committed position stored for this subscription
 */
@Override
public Future<DLSN> getLastCommitPosition() {
    if (null != lastCommittedPosition.get()) {
        return Future.value(lastCommittedPosition.get());
    } else {
        return getLastCommitPositionFromZK();
    }
}
 

@Override
public Future<String> placeStream(String stream) {
    String streamOwner = getStreamOwner(stream);
    if (null != streamOwner) {
        return Future.value(streamOwner);
    }
    Future<StreamLoad> streamLoadFuture = loadAppraiser.getStreamLoad(stream);
    return streamLoadFuture.map(new Function<StreamLoad, String>() {
        @Override
        public String apply(StreamLoad streamLoad) {
            return placeStreamSynchronized(streamLoad);
        }
    });
}
 

@Override
public Future<Boolean> issueSpeculativeRequest() {
    return Future.value(!complete.get() && null != sendNextWrite());
}
 

@Benchmark
public Future<String> value() {
  return Future.value(string);
}
 

@Override
public Future<WriteResponse> heartbeat(String stream, WriteContext ctx) {
    return Future.value(new WriteResponse());
}
 

@Override
public Future<ServerInfo> handshake() {
    return Future.value(serverInfo);
}
 

@Override
public Future<WriteResponse> writeWithContext(String stream,
                                              ByteBuffer data,
                                              WriteContext ctx) {
    return Future.value(new WriteResponse());
}
 

public Future<String> hello(String name) {
    return Future.value("hello, " + name);
}
 

@Override
public Future<WriteResponse> writeWithContext(String stream,
                                              ByteBuffer data,
                                              WriteContext ctx) {
    return Future.value(new WriteResponse());
}
 

@Override
public Future<Void> refreshCache() {
    return Future.value(null);
}
 

@Override
public Future<StreamLoad> getStreamLoad(String stream) {
    return Future.value(new StreamLoad(stream, 1));
}
 

@Override
public Future<Optional<URI>> getLogLocation(String logName) {
    return Future.value(nsOptional);
}
 

private static Future<LogSegmentCandidate> checkLogSegment(
        final String streamName,
        final LogSegmentMetadata metadata,
        final ExecutorService executorService,
        final BookKeeperClient bkc,
        final String digestpw) {
    if (metadata.isInProgress()) {
        return Future.value(null);
    }

    final LedgerHandleCache handleCache = LedgerHandleCache.newBuilder()
            .bkc(bkc)
            .conf(new DistributedLogConfiguration().setBKDigestPW(digestpw))
            .build();
    return ReadUtils.asyncReadLastRecord(
            streamName,
            metadata,
            true,
            false,
            true,
            4,
            16,
            new AtomicInteger(0),
            executorService,
            handleCache
    ).map(new Function<LogRecordWithDLSN, LogSegmentCandidate>() {
        @Override
        public LogSegmentCandidate apply(LogRecordWithDLSN record) {
            if (null != record &&
                (record.getDlsn().compareTo(metadata.getLastDLSN()) > 0 ||
                 record.getTransactionId() > metadata.getLastTxId() ||
                 !metadata.isRecordPositionWithinSegmentScope(record))) {
                return new LogSegmentCandidate(metadata, record);
            } else {
                return null;
            }
        }
    }).ensure(new AbstractFunction0<BoxedUnit>() {
        @Override
        public BoxedUnit apply() {
            handleCache.clear();
            return BoxedUnit.UNIT;
        }
    });
}
 

@Override
public Future<ServerInfo> handshake() {
    return Future.value(new ServerInfo());
}
 

public static Future<Response> buildFailedFutureResponse(String errorStackInfo) {
  return Future.value(new Response(false).setError(errorStackInfo));
}
 

public static Future<Response> buildFailedFutureResponse(Exception e) {
  return Future.value(new Response(false).setError(Throwables.getStackTraceAsString(e)));
}
 

@Override
public Future<ServerInfo> handshakeWithClientInfo(ClientInfo clientInfo) {
    return Future.value(serverInfo);
}
 

private Future<Integer> loop(int i) {
  if (i > 0)
    return Future.value(i - 1).flatMap(this::loop);
  else
    return Future.value(0);
}