com.alogic.kube.KubeController Maven / Gradle / Ivy

Go to download
package com.alogic.kube;

import com.alogic.kube.builder.ControllerBuilder;
import com.alogic.kube.builder.ControllerManagerBuilder;
import com.alogic.kube.controller.ControllerManager;
import com.alogic.kube.informer.SharedInformerFactory;
import com.alogic.kube.scanner.FromInner;
import com.alogic.event.Event;
import com.alogic.event.EventServer;
import com.alogic.load.Scanner;
import io.kubernetes.client.extended.controller.Controller;
import io.kubernetes.client.extended.controller.LeaderElectingController;
import io.kubernetes.client.extended.leaderelection.LeaderElectionConfig;
import io.kubernetes.client.extended.leaderelection.LeaderElector;
import io.kubernetes.client.extended.leaderelection.resourcelock.EndpointsLock;
import io.kubernetes.client.openapi.ApiClient;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.w3c.dom.Element;
import com.anysoft.util.*;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * k8s通用控制器
 *
 * @since 1.6.16.14
 */
public class KubeController extends EventServer.Abstract implements Scanner.Listener {

    /**
     * a logger of slf4j
     */
    protected static final Logger LOG =
            LoggerFactory.getLogger(KubeController.class);

    /**
     * 配置文件
     */
    private String config = "/apps/alogic/.kube/config";

    private String lockNamespace = "nest-system";
    private String lockName = "nest-controller-lock";

    /**
     * k8s api client
     */
    private ApiClient apiClient = null;

    /**
     * handlers
     */
    private List handlers = new ArrayList();

    private Scanner scanner = null;

    /**
     * 执行线程池
     */
    protected ScheduledThreadPoolExecutor exec = new  ScheduledThreadPoolExecutor(10);

    /**
     * 线程具柄
     */
    protected ScheduledFuture future = null;

    @Override
    public void configure(Element e, Properties p) {
        Properties props = new XmlElementProperties(e,p);
        configure(props);

        Factory> f = new Factory>();
        try {
            scanner = f.newInstance(e,p,"scanner", FromInner.class.getName());
        }catch (Exception ex){
            LOG.error("Can not create handler scanner,using default:{}", FromInner.class.getName());
            scanner = new FromInner();
            scanner.configure(e,p);
        }

        if (scanner != null){
            scanner.scan(this);
        }
    }

    @Override
    public void configure(Properties p) {
        super.configure(p);
        config = PropertiesConstants.getString(p,"config",config,true);
        lockName = PropertiesConstants.getString(p,"lock.name",lockName,true);
        lockNamespace = PropertiesConstants.getString(p,"lock.namespace",lockNamespace,true);
    }

    protected void onApiClientCustomize(ApiClient apiClient){
        apiClient.setReadTimeout(0);
    }

    @Override
    public void start() {
        LOG.info("Start kube controller...");
        try {
            apiClient = KubeApiClients.getClientFromConfig(config,true);
            if (apiClient != null) {
                onApiClientCustomize(apiClient);
                KubeApiClients.registryClient(KubeApiClients.DEFAULT,apiClient);
            }

            SharedInformerFactory informerFactory = new SharedInformerFactory(apiClient);
            ControllerManagerBuilder builder = ControllerBuilder.controllerManagerBuilder(informerFactory);
            for (KubeHandler handler:handlers){
                Controller controller = handler.build(informerFactory,apiClient);
                if (controller != null){
                    builder.addController(controller);
                }
            }
            ControllerManager controllerManager = builder.build();
            EndpointsLock lock = new EndpointsLock(
                    lockNamespace,lockName,UUID.randomUUID().toString(),apiClient);
            LeaderElectionConfig leaderElectionConfig = new LeaderElectionConfig(
                    lock,
                    Duration.ofMillis(10000),
                    Duration.ofMillis(8000),
                    Duration.ofMillis(5000));
            LeaderElectingController leaderElectingController =
                    new LeaderElectingController(new LeaderElector(leaderElectionConfig), controllerManager);

            future = exec.scheduleWithFixedDelay(()->{
                leaderElectingController.run();
            },1000,60*1000, TimeUnit.MILLISECONDS);
            LOG.info("Successfully started kube controller.");
        } catch (Exception e) {
            LOG.error("Failed to start kube controller.");
            LOG.error(ExceptionUtils.getStackTrace(e));
            return;
        }
    }

    @Override
    public void stop() {
        LOG.info("Stop kube controller...");
        if (future != null){
            future.cancel(false);
        }
    }

    @Override
    public void join(long timeout) {
        if (future != null){
            try {
                future.wait(timeout);
            } catch (InterruptedException e) {

            }
        }
    }

    @Override
    public void handle(Event _data, long timestamp) {
        // nothing to do
    }

    @Override
    public Object begin(String scannerId) {
        return this;
    }

    @Override
    public void found(Object cookie, KubeHandler data) {
        if (data.isOk()){
            handlers.add(data);
        }
    }

    @Override
    public void end(Object cookie, String scannerId) {
        // nothing to do
    }
}