Java tutorial
/* * Copyright (c) 2016 Couchbase, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.couchbase.client.core; import com.couchbase.client.core.config.BucketConfig; import com.couchbase.client.core.config.ClusterConfig; import com.couchbase.client.core.config.ConfigurationProvider; import com.couchbase.client.core.env.CoreEnvironment; import com.couchbase.client.core.logging.CouchbaseLogger; import com.couchbase.client.core.logging.CouchbaseLoggerFactory; import com.couchbase.client.core.message.CouchbaseMessage; import com.couchbase.client.core.message.CouchbaseRequest; import com.couchbase.client.core.message.CouchbaseResponse; import com.couchbase.client.core.message.ResponseStatus; import com.couchbase.client.core.message.internal.SignalConfigReload; import com.couchbase.client.core.message.kv.BinaryResponse; import com.couchbase.client.core.time.Delay; import com.lmax.disruptor.EventHandler; import com.lmax.disruptor.EventTranslatorTwoArg; import io.netty.util.CharsetUtil; import rx.Scheduler; import rx.functions.Action0; import rx.subjects.Subject; import java.util.concurrent.TimeUnit; public class ResponseHandler implements EventHandler<ResponseEvent> { private static final CouchbaseLogger LOGGER = CouchbaseLoggerFactory.getInstance(ResponseHandler.class); private final ClusterFacade cluster; private final ConfigurationProvider configurationProvider; private final CoreEnvironment environment; private final boolean traceLoggingEnabled; private final int nmvbRetryDelay; /** * Creates a new {@link ResponseHandler}. * * @param environment the global environment. * @param cluster the cluster reference. * @param provider th configuration provider. */ public ResponseHandler(CoreEnvironment environment, ClusterFacade cluster, ConfigurationProvider provider) { this.cluster = cluster; this.configurationProvider = provider; this.environment = environment; this.nmvbRetryDelay = Integer.parseInt(System.getProperty("com.couchbase.nmvbRetryDelay", "100")); traceLoggingEnabled = LOGGER.isTraceEnabled(); } /** * Translates {@link CouchbaseRequest}s into {@link RequestEvent}s. */ public static final EventTranslatorTwoArg<ResponseEvent, CouchbaseMessage, Subject<CouchbaseResponse, CouchbaseResponse>> RESPONSE_TRANSLATOR = new EventTranslatorTwoArg<ResponseEvent, CouchbaseMessage, Subject<CouchbaseResponse, CouchbaseResponse>>() { @Override public void translateTo(ResponseEvent event, long sequence, CouchbaseMessage message, Subject<CouchbaseResponse, CouchbaseResponse> observable) { event.setMessage(message); event.setObservable(observable); } }; /** * Handles {@link ResponseEvent}s that come into the response RingBuffer. * * Hey I just mapped you, * And this is crazy, * But here's my data * so subscribe me maybe. * * It's hard to block right, * at you baby, * But here's my data , * so subscribe me maybe. */ @Override public void onEvent(final ResponseEvent event, long sequence, boolean endOfBatch) throws Exception { try { CouchbaseMessage message = event.getMessage(); if (message instanceof SignalConfigReload) { configurationProvider.signalOutdated(); } else if (message instanceof CouchbaseResponse) { final CouchbaseResponse response = (CouchbaseResponse) message; ResponseStatus status = response.status(); if (status == ResponseStatus.RETRY) { retry(event, true); } else { final Scheduler.Worker worker = environment.scheduler().createWorker(); final Subject<CouchbaseResponse, CouchbaseResponse> obs = event.getObservable(); worker.schedule(new Action0() { @Override public void call() { try { obs.onNext(response); obs.onCompleted(); } catch (Exception ex) { obs.onError(ex); } finally { worker.unsubscribe(); } } }); } } else if (message instanceof CouchbaseRequest) { retry(event, false); } else { throw new IllegalStateException("Got message type I do not understand: " + message); } } finally { event.setMessage(null); event.setObservable(null); } } private void retry(final ResponseEvent event, final boolean isNotMyVbucket) { final CouchbaseMessage message = event.getMessage(); if (message instanceof CouchbaseRequest) { scheduleForRetry((CouchbaseRequest) message, isNotMyVbucket); } else { CouchbaseRequest request = ((CouchbaseResponse) message).request(); if (request != null) { scheduleForRetry(request, isNotMyVbucket); } else { event.getObservable().onError( new CouchbaseException("Operation failed because it does not " + "support cloning.")); } if (message instanceof BinaryResponse) { BinaryResponse response = (BinaryResponse) message; if (response.content() != null && response.content().readableBytes() > 0) { try { String config = response.content().toString(CharsetUtil.UTF_8).trim(); if (config.startsWith("{")) { configurationProvider.proposeBucketConfig(response.bucket(), config); } } finally { response.content().release(); } } } } } /** * Helper method which schedules the given {@link CouchbaseRequest} with a delay for further retry. * * @param request the request to retry. */ private void scheduleForRetry(final CouchbaseRequest request, final boolean isNotMyVbucket) { CoreEnvironment env = environment; Delay delay = env.retryDelay(); long delayTime; TimeUnit delayUnit; if (isNotMyVbucket) { boolean hasFastForward = bucketHasFastForwardMap(request.bucket(), configurationProvider.config()); delayTime = request.incrementRetryCount() == 0 && hasFastForward ? 0 : nmvbRetryDelay; delayUnit = TimeUnit.MILLISECONDS; } else { delayTime = delay.calculate(request.incrementRetryCount()); delayUnit = delay.unit(); } if (traceLoggingEnabled) { LOGGER.trace("Retrying {} with a delay of {} {}", request, delayTime, delayUnit); } final Scheduler.Worker worker = env.scheduler().createWorker(); worker.schedule(new Action0() { @Override public void call() { try { cluster.send(request); } finally { worker.unsubscribe(); } } }, delayTime, delayUnit); } /** * Helper method to check if the current given bucket contains a fast forward map. * * @param bucketName the name of the bucket. * @param clusterConfig the current cluster configuration. * @return true if it has a ffwd-map, false otherwise. */ private static boolean bucketHasFastForwardMap(String bucketName, ClusterConfig clusterConfig) { if (bucketName == null) { return false; } BucketConfig bucketConfig = clusterConfig.bucketConfig(bucketName); return bucketConfig != null && bucketConfig.hasFastForwardMap(); } }