de.zalando.paradox.nakadi.consumer.partitioned.zk.ZKMembersOrderings Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of paradox-nakadi-consumer-partitioned-zk Show documentation

Paradox high level Nakadi consumer

There is a newer version: 0.3.7

Show newest version

package de.zalando.paradox.nakadi.consumer.partitioned.zk;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Map;

import javax.annotation.Nonnull;

import com.google.common.collect.ComparisonChain;
import com.google.common.collect.Ordering;

public final class ZKMembersOrderings {

    private ZKMembersOrderings() { }

    public static final ZKLeaderConsumerPartitionRebalanceStrategy.MembersOrdering MEMBERS_ID_ORDER =
        currentMembers -> {
        final String[] membersIdsArray = currentMembers.keySet().toArray(new String[currentMembers.size()]);
        Arrays.sort(membersIdsArray);
        return membersIdsArray;
    };

    private static long created(final Map.Entry entry) {
        return null != entry.getValue() ? entry.getValue().getCreated() : 0L;
    }

    private static String[] getSortedMembers(final Map currentMembers,
            final Comparator> comparator) {
        return currentMembers.entrySet().stream().sorted(comparator).map(Map.Entry::getKey).toArray(String[]::new);
    }

    public static final ZKLeaderConsumerPartitionRebalanceStrategy.MembersOrdering OLDEST_MEMBERS = currentMembers -> {
        final Comparator> comparator = new Ordering>() {
            @Override
            public int compare(@Nonnull final Map.Entry left,
                    @Nonnull final Map.Entry right) {
                return ComparisonChain.start().compare(created(left), created(right))
                                      .compare(left.getKey(), right.getKey()).result();
            }
        };
        return getSortedMembers(currentMembers, comparator);
    };

    public static final ZKLeaderConsumerPartitionRebalanceStrategy.MembersOrdering NEWEST_MEMBERS = currentMembers -> {

        final Comparator> comparator = new Ordering>() {
            @Override
            public int compare(@Nonnull final Map.Entry left,
                    @Nonnull final Map.Entry right) {
                return ComparisonChain.start().compare(created(right), created(left))
                                      .compare(left.getKey(), right.getKey()).result();
            }
        };
        return getSortedMembers(currentMembers, comparator);
    };
}