@PostMapping("/single") public Completable createWithSingle(@RequestBody Single<Person> single) { return single.map(persons::add).toCompletable(); }
@PostMapping("/single") public Single<Person> transformSingle(@RequestBody Single<Person> personFuture) { return personFuture.map(person -> new Person(person.getName().toUpperCase())); }
@Override public void start() throws Exception { // Create two requests WebClient client = WebClient.create(vertx); Single<JsonObject> request = client.get(8080, "localhost", "/") .as(BodyCodec.jsonObject()) .rxSend() .map(resp -> resp.body()); // Combine the responses with the zip into a single response request .zipWith(request, (b1, b2) -> new JsonObject().put("req1", b1).put("req2", b2)) .subscribe(json -> { System.out.println("Got combined result " + json); }, err -> { err.printStackTrace(); }); } }
private <T> Single<ChunkDetails<T>> getChunkDetails(String key, Scheduler scheduler) { final List<String> firstKeys = new ArrayList<>(2); firstKeys.add(key); final String firstKey = key + "_00"; firstKeys.add(firstKey); return evcacheMemcachedClient.asyncGetBulk(firstKeys, chunkingTranscoder, null, "GetChunkMetadataOperation") .getSome(readTimeout.get(), TimeUnit.MILLISECONDS, false, false, scheduler) .map(metadataMap -> { if (metadataMap.containsKey(key)) { return new ChunkDetails(null, null, false, metadataMap.get(key)); } else if (metadataMap.containsKey(firstKey)) { final ChunkInfo ci = getChunkInfo(firstKey, (String) decodingTranscoder.decode(metadataMap.get( firstKey))); if (ci == null) return null; final List<String> keys = new ArrayList<>(); for (int i = 1; i < ci.getChunks(); i++) { final String prefix = (i < 10) ? "0" : ""; keys.add(ci.getKey() + "_" + prefix + i); } return new ChunkDetails(keys, ci, true, null); } else { return null; } }); }
.map(dataMap -> { for (Entry<ChunkInfo, Pair<List<String>, byte[]>> entry : responseMap.entrySet()) { final ChunkInfo ci = entry.getKey();
.map(dataMap -> { if (dataMap.size() != ci.getChunks() - 1) { EVCacheMetricsFactory.increment(appName + "-INCORRECT_NUM_CHUNKS");
}).map(data -> { if (data != null) { stats.cacheHit(Call.GET);
}).map(data -> { if (data != null) { stats.cacheHit(Call.GET_AND_TOUCH);
return _client.asyncGetAndTouch(key, timeToLive, tc) .get(readTimeout.get(), TimeUnit.MILLISECONDS, _throwException, hasZF, scheduler) .map(value -> (value == null) ? null : value.getValue());
@SuppressWarnings("unchecked") @Override public Single<TAccessToken> getStoredAccessToken() { return Single .just(mSharedPreferences.getString(ACCESS_TOKEN_PREFERENCES_KEY, null)) .map(json -> (TAccessToken) new Gson().fromJson(json, mTokenClass)); }
@GetMapping(value = "/v1/catalog/service/{appName}", produces = MediaType.APPLICATION_JSON_VALUE) public Single<ResponseEntity<List<Service>>> getService(@PathVariable("appName") String appName, @QueryParam(QUERY_PARAM_WAIT) String wait, @QueryParam(QUERY_PARAM_INDEX) Long index) { Assert.isTrue(appName != null, "service name can not be null"); return registrationService.getService(appName, getWaitMillis(wait), index) .map(item -> { List<Service> services = item.getItem().stream().map(instanceInfoMapper::map).collect(toList()); return createResponseEntity(services, item.getChangeIndex()); }); }
/** * Returns a valid authorization header string using a preconfigured TraktTvRefreshAccessTokenGrant. */ public Single<String> getValidAccessToken() { TraktTvRefreshAccessTokenGrant grant = new TraktTvRefreshAccessTokenGrant(); grant.clientId = TraktTvAPIConfiguration.CLIENT_ID; grant.clientSecret = TraktTvAPIConfiguration.CLIENT_SECRET; grant.redirectUri = TraktTvAPIConfiguration.REDIRECT_URI; return super.getValidAccessToken(grant).map(token -> token.tokenType + " " + token.accessToken); }
/** * Determine the sizes of all given files * @param files the files * @param vertx the Vert.x instance * @return an observable that emits pairs of file names and sizes */ private Observable<Pair<String, Long>> getFileSizes(List<String> files, Vertx vertx) { FileSystem fs = vertx.fileSystem(); return Observable.from(files) .flatMapSingle(path -> fs.rxProps(path).map(props -> Pair.of(path, props.size()))); }
@GetMapping(value = "/v1/catalog/services", produces = MediaType.APPLICATION_JSON_VALUE) public Single<ResponseEntity<Map<String, String[]>>> getServiceNames(@QueryParam(QUERY_PARAM_WAIT) String wait, @QueryParam(QUERY_PARAM_INDEX) Long index) { return registrationService.getServiceNames(getWaitMillis(wait), index) .map(item -> createResponseEntity(item.getItem(), item.getChangeIndex())); }
protected Single<Void> createHttpServer(Router router, String host, int port) { return vertx.createHttpServer() .requestHandler(router::accept) .rxListen(port, host) .map(r -> null); }
private Single<Void> publish(Record record) { return discovery.rxPublish(record) .doOnSuccess(rec -> { registeredRecords.add(record); logger.info("Service <" + rec.getName() + "> published"); }) .map(r -> null); }
@Override public void dispatch(AsyncContext asyncContext, ResourceMethodDispatcher dispatcher, Object resource, ContainerRequest request) throws ProcessingException { final ContainerRequestContext requestContext = containerRequestContext.get(); Completable intercept = Observable.from(requestInterceptors) .concatMap(interceptor -> interceptor.intercept(requestContext)) .lastOrDefault(null) .toCompletable(); Single<?> dispatch = Single.defer(() -> (Single<?>) dispatcher.dispatch(resource, request).getEntity()); intercept.andThen(dispatch) .map(response -> response == null ? Response.noContent().build() : response) .subscribe(asyncContext::resume, asyncContext::resume); }
@Override public Single<Boolean> putMapping(String type, JsonObject mapping) { String uri = "/" + index + "/_mapping/" + type; return client.performRequest(HttpMethod.PUT, uri, mapping.toBuffer()) .map(res -> res.getBoolean("acknowledged", true)); }
@Override public Observable<CartEvent> streamByUser(String userId) { JsonArray params = new JsonArray().add(userId).add(userId); return client.rxGetConnection() .flatMapObservable(conn -> conn.rxQueryWithParams(STREAM_STATEMENT, params) .map(ResultSet::getRows) .flatMapObservable(Observable::from) .map(this::wrapCartEvent) .doOnTerminate(conn::close) ); }
private Single<JobExecutionState> setJobFinished(JobExecutionState state) { return session.execute(updateJobToFinished.bind(state.timeSlice, state.currentDetails.getJobId()), queryScheduler) .toSingle() .map(resultSet -> state) .doOnError(t -> logger.warnf(t, "There was an error while updated the finished jobs index for %s", state.currentDetails)); }