JLoadBalancer.java

Go to the documentation of this file.

package com.griddynamics.jagger.user.test.configurations.loadbalancer;

import com.griddynamics.jagger.invoker.CircularExclusiveAccessLoadBalancer;
import com.griddynamics.jagger.invoker.ExclusiveAccessLoadBalancer;
import com.griddynamics.jagger.invoker.NonCircularExclusiveAccessLoadBalancer;
import com.griddynamics.jagger.invoker.OneByOneLoadBalancer;
import com.griddynamics.jagger.invoker.OneByOnePairSupplierFactory;
import com.griddynamics.jagger.invoker.PairSupplierFactory;
import com.griddynamics.jagger.invoker.PairSupplierFactoryLoadBalancer;
import com.griddynamics.jagger.invoker.QueryPoolLoadBalancer;
import com.griddynamics.jagger.invoker.RandomLoadBalancer;
import com.griddynamics.jagger.invoker.RoundRobinLoadBalancer;
import com.griddynamics.jagger.invoker.RoundRobinPairSupplierFactory;
import com.griddynamics.jagger.invoker.SimpleCircularLoadBalancer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.Serializable;
import java.util.Objects;
import java.util.Random;

public class JLoadBalancer implements Serializable {

    private final static Logger log = LoggerFactory.getLogger(JLoadBalancer.class);

    public static Builder builder(DefaultLoadBalancer loadBalancer) {
        return new Builder(loadBalancer);
    }

    public enum DefaultLoadBalancer {
        ROUND_ROBIN, ONE_BY_ONE
    }

    public static class Builder {
        private final DefaultLoadBalancer loadBalancer;
        private Long seed;
        private boolean exclusiveAccess;
        private boolean oneIterationOnly;

        public Builder(DefaultLoadBalancer loadBalancer) {
            this.loadBalancer = loadBalancer;
        }

        public Builder withRandomSeed(long seed) {
            this.seed = seed;
            return this;
        }

        public Builder withExclusiveAccess() {
            this.exclusiveAccess = true;
            return this;
        }

        public Builder withUniqueAccess() {
            this.oneIterationOnly = true;
            this.exclusiveAccess = true;

            return this;
        }

        public QueryPoolLoadBalancer build() {

            PairSupplierFactory pairSupplierFactory = null;
            switch (loadBalancer) {
                case ONE_BY_ONE:
                    pairSupplierFactory = new OneByOnePairSupplierFactory();
                    break;
                case ROUND_ROBIN:
                default:
                    pairSupplierFactory = new RoundRobinPairSupplierFactory();
                    break;
            }

            PairSupplierFactoryLoadBalancer loadBalancer = null;
            if (exclusiveAccess) {
                if (oneIterationOnly) {
                    loadBalancer = new NonCircularExclusiveAccessLoadBalancer(pairSupplierFactory);
                } else {
                    loadBalancer = new CircularExclusiveAccessLoadBalancer(pairSupplierFactory);
                }
                ((ExclusiveAccessLoadBalancer)loadBalancer).setRandomnessSeed(seed);
            } else {
                if (Objects.nonNull(seed)) {
                    loadBalancer = new RandomLoadBalancer(seed, pairSupplierFactory);
                } else {
                    loadBalancer = new SimpleCircularLoadBalancer(pairSupplierFactory);
                }
            }

            log.info("Built a {} load balancer", loadBalancer);
            return loadBalancer;
        }
    }
}