• Home
• com.netflix.dyno
• dyno-jedis
• 1.6.8
• source code
• DynoDualWriterPipeline.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.netflix.dyno.jedis.DynoDualWriterPipeline Maven / Gradle / Ivy

/*******************************************************************************
 * Copyright 2018 Netflix
 *
 * 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.netflix.dyno.jedis;

import com.netflix.dyno.connectionpool.ConnectionPoolMonitor;
import com.netflix.dyno.connectionpool.impl.ConnectionPoolImpl;
import org.slf4j.LoggerFactory;
import redis.clients.jedis.*;
import redis.clients.jedis.params.GeoRadiusParam;
import redis.clients.jedis.params.ZAddParams;
import redis.clients.jedis.params.ZIncrByParams;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * Dual writer for pipeline commands. This dual writer will apply mutation to both
 * the primary and shadow Dyno clusters but the response returned is only for the
 * primary dynomite cluster. Non-mutation operations are targeted only to primary
 * dynomite clusters.
 */
public class DynoDualWriterPipeline extends DynoJedisPipeline {
    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(DynoDualWriterPipeline.class);
    private static ExecutorService executor = Executors.newSingleThreadExecutor();
    private final ConnectionPoolImpl connPool;
    private final DynoJedisPipeline shadowPipeline;
    private final DynoDualWriterClient.Dial dial;

    DynoDualWriterPipeline(String appName,
                           ConnectionPoolImpl pool,
                           DynoJedisPipelineMonitor operationMonitor,
                           ConnectionPoolMonitor connPoolMonitor,
                           ConnectionPoolImpl shadowConnectionPool,
                           DynoDualWriterClient.Dial dial) {
        super(pool, operationMonitor, connPoolMonitor);
        this.connPool = pool;
        this.dial = dial;

        // use a new pipeline monitor for shadow cluster
        int flushTimerFrequency = shadowConnectionPool.getConfiguration().getTimingCountersResetFrequencySeconds();
        DynoJedisPipelineMonitor shadowOperationMonitor = new DynoJedisPipelineMonitor(appName, flushTimerFrequency);
        this.shadowPipeline = new DynoJedisPipeline(shadowConnectionPool, shadowOperationMonitor,
                shadowConnectionPool.getMonitor());
    }

    private ConnectionPoolImpl getConnPool() {
        return this.connPool;
    }

    /*
     * For async scheduling of Jedis commands on shadow clusters.
     */
    private  Future> writeAsync(final String key, Callable> func) {
        if (canSendShadowRequest(key)) {
            return executor.submit(func);
        }
        return null;
    }

    /*
     *  For async scheduling of Jedis binary commands on shadow clusters.
     */
    private  Future> writeAsync(final byte[] key, Callable> func) {
        if (canSendShadowRequest(key)) {
            return executor.submit(func);
        }
        return null;
    }

    /*
     * Asynchronous processing of non Jedis commands. No dial check as these operations are preceded
     * by Jedis pipeline commands that perform dial check on shadow cluster.
     */
    private  Future scheduleAsync(Callable func) {
        return executor.submit(func);
    }

    /**
     * Returns true if the connection pool
     * 
Is NOT idle
     * 
Has active pools (the shadow cluster may disappear at any time and we don't want to bloat logs)
     * 
The key is in range in the dial
     * 

     * The idle check is necessary since there may be active host pools however the shadow client may not be able to
     * connect to them, for example, if security groups are not configured properly.
     */
    private boolean canSendShadowRequest(String key) {
        return this.getConnPool().getConfiguration().isDualWriteEnabled() &&
                !this.getConnPool().isIdle() &&
                this.getConnPool().getActivePools().size() > 0 &&
                dial.isInRange(key);
    }

    private boolean canSendShadowRequest(byte[] key) {
        return this.getConnPool().getConfiguration().isDualWriteEnabled() &&
                !this.getConnPool().isIdle() &&
                this.getConnPool().getActivePools().size() > 0 &&
                dial.isInRange(key);
    }

    /**
     * Sync operation will wait for primary cluster and the result is returned. But,
     * on a shadow cluster the operation is asynchronous and the result is not
     * returned to client.
     */
    @Override
    public void sync() {
        scheduleAsync(() -> {
            shadowPipeline.sync();
            return null;
        });
        super.sync();
    }

    @Override
    public List