import io.grpc.Grpc;
import io.grpc.InsecureServerCredentials;
import io.grpc.Server;
import io.grpc.stub.StreamObserver;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import java.lang.management.ManagementFactory;

import com.sun.management.OperatingSystemMXBean;

import TinyServer.ServerStatusGrpc;
import TinyServer.StatusOptions;
import TinyServer.StatusRequest;
import TinyServer.StatusResponse;
/**
 * 查看服务器远程状态包括CPU占用率、可用内存、os分支、系统时间
 *
 * @author lzwgiter
 * @email float311@163.com
 * @since 2023/7/3
 */
public class TinyStatusServer {
    private static final Logger logger = Logger.getLogger(TinyStatusServer.class.getName());

    private final String port;

    private final Server server;

    public TinyStatusServer(String port) {
        this.port = port;
        this.server = Grpc.newServerBuilderForPort(Integer.parseInt(port), InsecureServerCredentials.create())
                .addService(new StatusServiceImpl())
                .build();
    }

    public void startServer() {
        try {
            server.start();
            logger.info("状态服务启动成功！监听端口：" + port);
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                System.err.println("*** JVM已停止");
                try {
                    TinyStatusServer.this.stopServer();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.err.println("*** 服务关闭");
            }));
            server.awaitTermination();
        } catch (IOException e) {
            throw new RuntimeException("端口已被占用！");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public void stopServer() throws InterruptedException {
        if (server != null) {
            server.shutdown().awaitTermination(5, TimeUnit.SECONDS);
        }
    }

    private static class StatusServiceImpl extends ServerStatusGrpc.ServerStatusImplBase {
        private StatusResponse getResult(StatusRequest request) {
            OperatingSystemMXBean operatingSystemMXBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
            String result;
            switch (request.getRequestOpt()) {
                case StatusOptions.CPU_USAGE_VALUE:
                    result = String.valueOf(operatingSystemMXBean.getSystemLoadAverage());
                    break;
                case StatusOptions.MEM_USAGE_VALUE:
                    result = (operatingSystemMXBean.getTotalPhysicalMemorySize()
                            - operatingSystemMXBean.getFreePhysicalMemorySize()) / (1024 * 1024) + "MB";
                    break;
                case StatusOptions.KERNEL_VALUE:
                    result = operatingSystemMXBean.getArch();
                    break;
                case StatusOptions.TIME_VALUE:
                    SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    ;
                    result = format.format(new Date());
                    break;
                default:
                    result = "未知的操作数！";
            }
            return StatusResponse.newBuilder()
                    .setStatusReport(result)
                    .build();
        }

        @Override
        public void queryIndex(StatusRequest request, StreamObserver<StatusResponse> responseObserver) {
            responseObserver.onNext(getResult(request));
            responseObserver.onCompleted();
        }
    }

    public static void main(String[] args) {
        TinyStatusServer statusServer = new TinyStatusServer(args[0]);
        statusServer.startServer();
    }
}

import TinyServer.ServerStatusGrpc;
import TinyServer.ServerStatusGrpc.ServerStatusBlockingStub;
import TinyServer.StatusRequest;
import TinyServer.StatusResponse;
import io.grpc.Grpc;
import io.grpc.InsecureChannelCredentials;
import io.grpc.ManagedChannel;

import java.util.logging.Logger;

/**
 * TinyStatus 客户端
 *
 * @author lzwgiter
 * @email float311@163.com
 * @since 2023/7/4
 */
public class TinyStatusClient {

    private static final Logger logger = Logger.getLogger(TinyStatusServer.class.getName());

    private final ServerStatusBlockingStub blockingStub;

    public TinyStatusClient(ManagedChannel channel) {
        this.blockingStub = ServerStatusGrpc.newBlockingStub(channel);
    }

    public static void main(String[] args) {
        String target = args[0];
        String requestOpt = args[1];
        ManagedChannel channel = Grpc.newChannelBuilder(target, InsecureChannelCredentials.create()).build();
        TinyStatusClient client = new TinyStatusClient(channel);
        StatusRequest request = StatusRequest.newBuilder()
                .setRequestOpt(Integer.parseInt(requestOpt))
                .build();
        StatusResponse response = client.blockingStub.queryIndex(request);
        logger.info(response.toString());
    }
}