package com.example.sonarqube;

import org.sonar.server.platform.ClusterFeature;

public class MyClusterFeature implements ClusterFeature {
    public boolean isEnabled() {
        return true;
    }
}

package com.example.sonarqube;

import com.hazelcast.cluster.Cluster;
import com.hazelcast.cluster.MemberSelector;
import com.hazelcast.cp.IAtomicReference;
import org.jetbrains.annotations.NotNull;
import org.sonar.api.Startable;
import org.sonar.api.ce.ComputeEngineSide;
import org.sonar.api.config.Configuration;
import org.sonar.api.server.ServerSide;
import org.sonar.process.NetworkUtils;
import org.sonar.process.ProcessId;
import org.sonar.process.ProcessProperties;
import org.sonar.process.cluster.hz.DistributedAnswer;
import org.sonar.process.cluster.hz.DistributedCall;
import org.sonar.process.cluster.hz.DistributedCallback;
import org.sonar.process.cluster.hz.HazelcastMember;
import org.sonar.process.cluster.hz.HazelcastMemberBuilder;
import org.sonar.process.cluster.hz.InetAdressResolver;

import java.util.Arrays;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.locks.Lock;

@ComputeEngineSide
@ServerSide
public class MyHazelcastMember implements HazelcastMember, Startable {
    private static final String WEB_PORT = "sonar.cluster.node.web.port";

    private static final String CE_PORT = "sonar.cluster.node.ce.port";

    private final Configuration configuration;

    private final NetworkUtils networkUtils;

    private HazelcastMember hzMember = null;

    public MyHazelcastMember(Configuration configuration, NetworkUtils networkUtils) {
        this.configuration = configuration;
        this.networkUtils = networkUtils;
    }

    public <E> IAtomicReference<E> getAtomicReference(@NotNull String name) {
        return getHzMember().getAtomicReference(name);
    }

    public <K, V> Map<K, V> getReplicatedMap(@NotNull String name) {
        return getHzMember().getReplicatedMap(name);
    }

    public UUID getUuid() {
        return getHzMember().getUuid();
    }

    public Set<UUID> getMemberUuids() {
        return getHzMember().getMemberUuids();
    }

    public Lock getLock(@NotNull String name) {
        return getHzMember().getLock(name);
    }

    public long getClusterTime() {
        return getHzMember().getClusterTime();
    }

    public Cluster getCluster() {
        return getHzMember().getCluster();
    }

    public <T> DistributedAnswer<T> call(@NotNull DistributedCall<T> callable, @NotNull MemberSelector memberSelector, long timeoutMs) throws InterruptedException {
        return getHzMember().call(callable, memberSelector, timeoutMs);
    }

    public <T> void callAsync(@NotNull DistributedCall<T> callable, @NotNull MemberSelector memberSelector, @NotNull DistributedCallback<T> callback) {
        getHzMember().callAsync(callable, memberSelector, callback);
    }

    private HazelcastMember getHzMember() {
        return Objects.requireNonNull(this.hzMember, "Hazelcast member not started");
    }

    public void close() {
        if (this.hzMember != null) {
            this.hzMember.close();
            this.hzMember = null;
        }
    }

    public void start() {
        if (!isClusterEnabled())
            return;
        ProcessId processId = ProcessId.fromKey(this.configuration.get("process.key").orElseThrow(() -> new IllegalStateException("Missing process key")));
        String nodeHost = this.configuration.get(ProcessProperties.Property.CLUSTER_NODE_HOST.getKey()).orElseThrow(() -> new IllegalStateException("Missing node host"));
        this.hzMember = (new HazelcastMemberBuilder(new InetAdressResolver()))
                .setNodeName(this.configuration.get(ProcessProperties.Property.CLUSTER_NODE_NAME.getKey()).orElseThrow(() -> new IllegalStateException("Missing node name")))
                .setPort(getPort(processId, nodeHost))
                .setProcessId(processId)
                .setMembers(Arrays.asList(this.configuration.getStringArray(ProcessProperties.Property.CLUSTER_HZ_HOSTS.getKey())))
                .setNetworkInterface(nodeHost)
                .build();
    }

    private int getPort(ProcessId processId, String hostOrAddress) {
        switch (processId) {
            case WEB_SERVER:
                return fixPortIfZero(WEB_PORT, hostOrAddress);
            case COMPUTE_ENGINE:
                return fixPortIfZero(CE_PORT, hostOrAddress);
            default:
                throw new IllegalStateException(String.format("Incorrect processId [%s]", processId.getKey()));
        }
    }

    private int fixPortIfZero(String portKey, String hostOrAddress) {
        Optional<Integer> optional = this.configuration.getInt(portKey);
        return optional.orElseGet(() -> this.networkUtils.getNextAvailablePort(hostOrAddress).orElseThrow(() -> new IllegalStateException(String.format("Failed to find a free port for property '%s' for configured host: %s", portKey, hostOrAddress))));
    }

    private boolean isClusterEnabled() {
        Optional<Boolean> optional = this.configuration.getBoolean(ProcessProperties.Property.CLUSTER_ENABLED.getKey());
        return (optional.isPresent() && optional.get() == Boolean.TRUE);
    }

    public void stop() {
        close();
    }
}

package com.example.sonarqube;

import org.sonar.core.extension.CoreExtension;
import org.sonar.api.SonarQubeSide;

public class ClusterExtension implements CoreExtension {
    @Override
    public String getName() {
        return "cluster";
    }

    @Override
    public void load(Context context) {
        if (context.getRuntime().getSonarQubeSide() == SonarQubeSide.COMPUTE_ENGINE) {
            context.addExtension(MyHazelcastMember.class);
        } else if (context.getRuntime().getSonarQubeSide() == SonarQubeSide.SERVER) {
            context.addExtensions(MyClusterFeature.class, MyHazelcastMember.class);
        }
    }
}