sttnet.h

Go to the documentation of this file.

#ifndef PUBLIC_H
#define PUBLIC_H 1
#include<jsoncpp/json/json.h>
#include<string_view>
#include<string>
#include<atomic>
#include<iostream>
#include<unistd.h>
#include<sys/stat.h>
#include<fstream>
#include<fcntl.h>
#include<sstream>
#include<mutex>
#include<chrono>
#include<iomanip>
#include<random>
#include<cmath>
#include<thread>
#include<openssl/sha.h>
#include<netdb.h>
#include<arpa/inet.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<cstring>
#include<openssl/bio.h>
#include<openssl/evp.h>
#include<openssl/buffer.h>
#include<functional>
#include<list>
#include<queue>
#include<sys/epoll.h> 
#include<condition_variable>
#include <regex>
#include<unordered_map>
#include <openssl/ssl.h>
#include <openssl/err.h>
#include<openssl/crypto.h>
#include<signal.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<sys/wait.h>
#include<sys/shm.h>
#include<type_traits>
#include<charconv>
#include<any>
#include <sys/eventfd.h>
#include <sys/timerfd.h>
#include <cstddef>
#include <cstdint>
#include <new>
#include <vector>
#include <memory>
#include <limits>
#include <poll.h>
#include <exception>
#include <cstdlib>
#include <cstdio>
#include <deque>
#include <algorithm>
#include <array>
#include <unordered_set>
#include <cctype>
#include <sys/uio.h>
#include <netinet/tcp.h>
#ifdef __linux__
#include <sys/prctl.h>
#include <sys/syscall.h>
#endif
 
namespace stt
{

    inline constexpr int version_major=0;
    inline constexpr int version_minor=7;
    inline constexpr int version_patch=0;
    inline constexpr std::string_view version="0.7.0";
 
    namespace system
    {
        class WorkerPool;

template <typename T>
class MPSCQueue {
public:
    explicit MPSCQueue(std::size_t capacity_pow2)
        : capacity_(capacity_pow2),
          mask_(capacity_pow2 - 1),
          buffer_(capacity_pow2),
          head_(0),
          tail_(0)
    {
        static_assert(std::is_nothrow_move_constructible_v<T>,
                      "MPSCQueue requires a nothrow-move-constructible value type");
        // capacity must be power of two
        if (capacity_ < 2 || (capacity_ & mask_) != 0) {
            // You can replace with your own assert/log
            throw std::invalid_argument("MPSCQueue capacity must be power of two and >= 2");
        }
 
        // Initialize per-slot sequence
        for (std::size_t i = 0; i < capacity_; ++i) {
            buffer_[i].seq.store(i, std::memory_order_relaxed);
        }
    }
 
    MPSCQueue(const MPSCQueue&) = delete;
    MPSCQueue& operator=(const MPSCQueue&) = delete;
 
    ~MPSCQueue() {
        // Drain remaining items to call destructors if needed
        while (discard_one()) {}
    }

    bool push(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) {
        return emplace_impl(std::move(v));
    }
 
    bool push(const T& v) {
        // Copy before reserving a ring slot. If the copy throws, producer
        // progress and the per-slot sequence state remain untouched.
        T copy(v);
        return emplace_impl(std::move(copy));
    }

    bool pop(T& out) noexcept(std::is_nothrow_move_assignable_v<T> &&
                              std::is_nothrow_move_constructible_v<T>)
    {
        const std::size_t head = head_.load(std::memory_order_relaxed);
        Slot& slot = buffer_[head & mask_];
        const std::size_t seq = slot.seq.load(std::memory_order_acquire);
        const std::intptr_t dif = static_cast<std::intptr_t>(seq) - static_cast<std::intptr_t>(head + 1);
 
        if (dif != 0) {
            // seq != head+1 => empty
            return false;
        }
 
        // Move out
        out = std::move(*slot.ptr());
 
        // Destroy in-place
        slot.destroy();
 
        // Mark slot as free for producers:
        // seq = head + capacity
        slot.seq.store(head + capacity_, std::memory_order_release);
 
        head_.store(head + 1, std::memory_order_relaxed);
        return true;
    }

    std::size_t approx_size() const noexcept {
        const std::size_t t = tail_.load(std::memory_order_acquire);
        const std::size_t h = head_.load(std::memory_order_acquire);
        return (t >= h) ? (t - h) : 0;
    }

    bool possibly_nonempty() const noexcept {
        return tail_.load(std::memory_order_acquire) !=
               head_.load(std::memory_order_acquire);
    }
 
private:
    struct Slot {
        std::atomic<std::size_t> seq;
        typename std::aligned_storage<sizeof(T), alignof(T)>::type storage;
        bool has_value = false;
 
        T* ptr() noexcept { return reinterpret_cast<T*>(&storage); }
        const T* ptr() const noexcept { return reinterpret_cast<const T*>(&storage); }
 
        template <class U>
        void construct(U&& v) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
            ::new (static_cast<void*>(&storage)) T(std::forward<U>(v));
            has_value = true;
        }
 
        void destroy() noexcept {
            if (has_value) {
                ptr()->~T();
                has_value = false;
            }
        }
    };
 
    template <class U>
    bool emplace_impl(U&& v) noexcept(std::is_nothrow_constructible_v<T, U&&>) {
        std::size_t pos = tail_.load(std::memory_order_relaxed);
 
        for (;;) {
            Slot& slot = buffer_[pos & mask_];
            const std::size_t seq = slot.seq.load(std::memory_order_acquire);
            const std::intptr_t dif = static_cast<std::intptr_t>(seq) - static_cast<std::intptr_t>(pos);
 
            if (dif == 0) {
                // slot is free for this pos
                if (tail_.compare_exchange_weak(
                        pos, pos + 1,
                        std::memory_order_relaxed,
                        std::memory_order_relaxed))
                {
                    // We own this slot now
                    slot.construct(std::forward<U>(v));
                    // Publish to consumer: seq = pos+1 means "ready"
                    slot.seq.store(pos + 1, std::memory_order_release);
                    return true;
                }
                // CAS failed: pos updated with current tail; retry
            } else if (dif < 0) {
                // slot seq < pos => queue is full (producer wrapped)
                return false;
            } else {
                // Another producer is ahead; move pos forward
                pos = tail_.load(std::memory_order_relaxed);
            }
        }
    }
 
    bool discard_one() noexcept {
        const std::size_t head = head_.load(std::memory_order_relaxed);
        Slot& slot = buffer_[head & mask_];
        const std::size_t seq = slot.seq.load(std::memory_order_acquire);
        if (static_cast<std::intptr_t>(seq) - static_cast<std::intptr_t>(head + 1) != 0)
            return false;
        slot.destroy();
        slot.seq.store(head + capacity_, std::memory_order_release);
        head_.store(head + 1, std::memory_order_relaxed);
        return true;
    }
 
private:
    const std::size_t capacity_;
    const std::size_t mask_;
    std::vector<Slot> buffer_;
 
    // Single consumer only
    alignas(64) std::atomic<std::size_t> head_;
 
    // Multi-producer
    alignas(64) std::atomic<std::size_t> tail_;
};
 
 
    }

    namespace file
    {
    class FileTool
    {
    public:
        static bool createDir(const std::string & ddir,const mode_t &mode=0775); 
        static bool copy(const std::string &sourceFile,const std::string &objectFile);
        static bool createFile(const std::string &filePath,const mode_t &mode=0666);
        static size_t get_file_size(const std::string &fileName);
    };
    
    struct FileThreadLock
    {
        std::string loc;
        int threads;
        std::mutex lock;
        FileThreadLock(const std::string &loc,const int &threads):loc(loc),threads(threads){};
    };

    class File:private FileTool
    {
    protected:
        static std::mutex l1;
        static std::unordered_map<std::string,FileThreadLock> fl2;
    protected:
        std::mutex che;
        
    private:
        void lockfl2();
        void unlockfl2();
        bool memoryLockOwnedByCurrentThread();
        void markMemoryLockOwned();
        void releaseMemoryLocks();
    private:
        std::ifstream fin;
        std::vector<std::string> data;
        std::vector<std::string> backUp;
        char *data_binary=nullptr;
        char *backUp_binary=nullptr;
        size_t size1=0;
        size_t size2=0;
        int multiple=0;
        size_t multiple_backup=0;
        size_t malloced=0;
        std::mutex fl1;
        std::mutex memoryOwnerMutex;
        std::thread::id memoryLockOwner{};
        bool memoryLocked=false;
        
        std::ofstream fout;
        std::string fileName;
        
        std::string fileNameTemp;
        std::atomic<bool> flag{false};
        bool binary;
        mode_t mode;
        size_t size=0;
        uint64_t totalLines=0;
    private:
        void toMemory();
        bool toDisk();
    public:
        bool openFile(const std::string &fileName,const bool &create=true,const int &multiple=0,const size_t &size=0,const mode_t &mode=0666);
        bool closeFile(const bool &del=false);
        ~File(){closeFile(false);}
        bool isOpen(){return flag.load(std::memory_order_acquire);}
        bool isBinary(){return binary;}
        std::string getFileName(){return fileName;}
        uint64_t getFileLine(){return totalLines;}
        size_t getFileSize(){return size;}
        size_t getSize1(){return size1;}
    public:
        bool lockMemory();     
        bool unlockMemory(const bool &rec=false);
    public:
        int findC(const std::string &targetString,const int linePos=1);
        bool appendLineC(const std::string &data,const int &linePos=0);
        bool deleteLineC(const int &linePos=0);
        bool deleteAllC();
        bool chgLineC(const std::string &data,const int &linePos=0);
        bool readLineC(std::string &data,const int linePos);
        std::string& readC(std::string &data,const int &linePos,const int &num);
        std::string& readAllC(std::string &data);
        bool readC(char *data,const size_t &pos,const size_t &size);
        bool writeC(const char *data,const size_t &pos,const size_t &size);
        bool formatC();
    public:
        int find(const std::string &targetString,const int linePos=1);
        bool appendLine(const std::string &data,const int &linePos=0);
        bool deleteLine(const int &linePos=0);
        bool deleteAll();
        bool chgLine(const std::string &data,const int &linePos=0);
        bool readLine(std::string &data,const int linePos);
        std::string& read(std::string &data,const int &linePos,const int &num);
        std::string& readAll(std::string &data);
        bool read(char *data,const size_t &pos,const size_t &size);
        bool write(const char *data,const size_t &pos,const size_t &size);
        void format();
    };
    }
    namespace time
    {
    struct Duration
    {
        long long day;
        int hour;
        int min;
        int sec;
        int msec;
        Duration(long long a,int b,int c,int d,int e):day(a),hour(b),min(c),sec(d),msec(e){}
        Duration()=default;
        bool operator>(const Duration &b)
        {
            long long total;
            total=day*24*60*60*1000+hour*60*60*1000+min*60*1000+sec*1000+msec;
            long long totalB;
            totalB=b.day*24*60*60*1000+b.hour*60*60*1000+b.min*60*1000+b.sec*1000+b.msec;
            if(total>totalB)
                return true;
            else
                return false;
        }

        bool operator<(const Duration &b)
        {
            long long total;
            total=day*24*60*60*1000+hour*60*60*1000+min*60*1000+sec*1000+msec;
            long long totalB;
            totalB=b.day*24*60*60*1000+b.hour*60*60*1000+b.min*60*1000+b.sec*1000+b.msec;
            if(total<totalB)
                return true;
            else
                return false;
        }

        bool operator==(const Duration &b)
        {
            long long total;
            total=day*24*60*60*1000+hour*60*60*1000+min*60*1000+sec*1000+msec;
            long long totalB;
            totalB=b.day*24*60*60*1000+b.hour*60*60*1000+b.min*60*1000+b.sec*1000+b.msec;
            if(total==totalB)
                return true;
            else
                return false;
        }

        bool operator>=(const Duration &b)
        {
            long long total;
            total=day*24*60*60*1000+hour*60*60*1000+min*60*1000+sec*1000+msec;
            long long totalB;
            totalB=b.day*24*60*60*1000+b.hour*60*60*1000+b.min*60*1000+b.sec*1000+b.msec;
            if(total>=totalB)
                return true;
            else
                return false;
        }

        bool operator<=(const Duration &b)
        {
            long long total;
            total=day*24*60*60*1000+hour*60*60*1000+min*60*1000+sec*1000+msec;
            long long totalB;
            totalB=b.day*24*60*60*1000+b.hour*60*60*1000+b.min*60*1000+b.sec*1000+b.msec;
            if(total<=totalB)
                return true;
            else
                return false;
        }

        Duration operator+(const Duration &b)
        {
            long long dayy=day;
            int hourr=hour;
            int minn=min;
            int secc=sec;
            int msecc=msec;
 
            msecc+=b.msec;
            secc+=b.sec;
            minn+=b.min;
            hourr+=b.hour;
            dayy+=b.day;
 
            if(msecc/1000!=0)
            {
                secc+=msecc/1000;
                msecc=msecc%1000;
            }
 
            if(secc/60!=0)
            {
                minn+=secc/60;
                secc=secc%60;
            }
 
            if(minn/60!=0)
            {
                hourr+=minn/60;
                minn=minn%60;
            }
 
            if(hourr/24!=0)
            {
                dayy+=hourr/24;
                hourr=hourr%24;
            }
            return Duration(dayy,hourr,minn,secc,msecc);
        }

        Duration operator-(const Duration &b)
        {
            long long dayy=day;
            int hourr=hour;
            int minn=min;
            int secc=sec;
            int msecc=msec;
 
            msecc=dayy*24*60*60*1000+hourr*60*60*1000+minn*60*1000+secc*1000+msecc-b.day*24*60*60*1000-b.hour*60*60*1000-b.min*60*1000-b.sec*1000-b.msec;
            secc=0;
            minn=0;
            hourr=0;
            dayy=0;
 
            if(msecc/1000!=0)
            {
                secc+=msecc/1000;
                msecc=msecc%1000;
            }
 
            if(secc/60!=0)
            {
                minn+=secc/60;
                secc=secc%60;
            }
 
            if(minn/60!=0)
            {
                hourr+=minn/60;
                minn=minn%60;
            }
 
            if(hourr/24!=0)
            {
                dayy+=hourr/24;
                hourr=hourr%24;
            }
            return Duration(dayy,hourr,minn,secc,msecc);
        }
        
        double convertToDay()
        { 
            long long total;
            total=hour*60*60*1000+min*60*1000+sec*1000+msec; 
            double k=day+total/86400000.0000;
            return k;
        }

        double convertToHour()
        {
            long long total;
            total=min*60*1000+sec*1000+msec; 
            double k=day*24+hour+total/36000000.0000;
            return k;
        }

        double convertToMin()
        {
            long long total;
            total=sec*1000+msec; 
            double k=day*24*60+hour*60+min+total/60000.0000;
            return k;
        }

        double convertToSec()
        {
            long long total;
            total=msec; 
            double k=day*24*60*60+hour*60*60+min*60+sec+total/1000.0000;
            return k;
        }

        long long convertToMsec()
        {
            long long total;
            total=day*24*60*60*1000+hour*60*60*1000+min*60*1000+sec*1000+msec;
            return total;
        }

        Duration recoverForm(const long long &t)
        {
            msec=t;
            sec=0;
            min=0;
            hour=0;
            day=0;
 
            if(msec/1000!=0)
            {
                sec+=msec/1000;
                msec=msec%1000;
            }
 
            if(sec/60!=0)
            {
                min+=sec/60;
                sec=sec%60;
            }
 
            if(min/60!=0)
            {
                hour+=min/60;
                min=min%60;
            }
 
            if(hour/24!=0)
            {
                day+=hour/24;
                hour=hour%24;
            }
            return Duration(day,hour,min,sec,msec);
        }
    };

    std::ostream& operator<<(std::ostream &os,const Duration &a);
 
    using Milliseconds = std::chrono::duration<uint64_t,std::milli>;
    using Seconds=std::chrono::duration<uint64_t>;
    #define ISO8086A "yyyy-mm-ddThh:mi:ss"
    #define ISO8086B "yyyy-mm-ddThh:mi:ss.sss"
 

    class DateTime
    {
    private:
        static Duration& dTOD(const Milliseconds& d1,Duration &D1);
        static Milliseconds& DTOd(const Duration &D1,Milliseconds& d1);
        static std::string &toPGtimeFormat();
        static std::chrono::system_clock::time_point strToTimePoint(const std::string &timeStr,const std::string &format=ISO8086A);
        static std::string& timePointToStr(const std::chrono::system_clock::time_point &tp,std::string &timeStr,const std::string &format=ISO8086A);
    public:
        static std::string& getTime(std::string &timeStr,const std::string &format=ISO8086A);
        static bool convertFormat(std::string &timeStr,const std::string &oldFormat,const std::string &newFormat=ISO8086A);
        static Duration& calculateTime(const std::string &time1,const std::string &time2,Duration &result,const std::string &format1=ISO8086A,const std::string &format2=ISO8086A);
        static std::string& calculateTime(const std::string &time1,const Duration &time2,std::string &result,const std::string &am,const std::string &format1=ISO8086A,const std::string &format2=ISO8086A);
        static bool compareTime(const std::string &time1,const std::string &time2,const std::string &format1=ISO8086A,const std::string &format2=ISO8086A);
    private:
        Duration dt{-1,-1,-1,-1,-1};
        bool flag=false;
        std::chrono::steady_clock::time_point start;
        std::chrono::steady_clock::time_point end;
    public:
        bool startTiming();
        Duration checkTime();
        Duration endTiming();
    public:
        Duration getDt(){return dt;}
        bool isStart(){return flag;}
    };
    }
    namespace file
    {
    class LogFile:private time::DateTime,protected File
    {
    private:
        std::string timeFormat;
        std::string contentFormat;
        std::atomic<bool> consumerGuard{true};
        std::atomic<bool> logWakePending{false};
        std::atomic<uint64_t> droppedLogs{0};
        std::mutex queueMutex;
        std::condition_variable queueCV;
        system::MPSCQueue<std::string> logQueue;
        std::thread consumerThread;
    public:
        LogFile(const size_t &logQueue_cap=8192):logQueue(logQueue_cap)
        {
        consumerGuard=true;
        consumerThread = std::thread([this]()->void
        {
            std::string content;
            content.reserve(1024);
            std::string time;
            time.reserve(128);
            while (true)
            {
                while(this->logQueue.pop(content))//非空则执行
                {       
                    getTime(time,timeFormat);
                    time+=contentFormat;
                    time+=content;
                    this->appendLine(time);
                }
                this->logWakePending.store(false,std::memory_order_release);
                if(this->logQueue.possibly_nonempty())
                {
                    this->logWakePending.store(true,std::memory_order_release);
                    continue;
                }
                if (!this->consumerGuard.load(std::memory_order_acquire))
                    break;
                std::unique_lock<std::mutex> lock(this->queueMutex);
                this->queueCV.wait(lock,[this] {
                    return !this->consumerGuard.load(std::memory_order_acquire)||
                           this->logWakePending.load(std::memory_order_acquire);
                });
            }
        });
        }

        bool openFile(const std::string &fileName,const std::string &timeFormat=ISO8086A,const std::string &contentFormat="   ");
        bool isOpen(){return File::isOpen();}
        std::string getFileName(){return File::getFileName();}
        bool closeFile(const bool &del=false);
        void writeLog(const std::string &data);
        uint64_t getDroppedLogCount() const noexcept{return droppedLogs.load(std::memory_order_relaxed);}
        bool clearLog();
        bool deleteLogByTime(const std::string &date1="1",const std::string &date2="2");
        ~LogFile();
    };
    }
    namespace data
    {
        class CryptoUtil
        {
        public:
            static bool encryptSymmetric(const unsigned char *before,const size_t &length,const unsigned char *passwd,const unsigned char *iv,unsigned char *after);
            static bool decryptSymmetric(const unsigned char *before,const size_t &length,const unsigned char *passwd,const unsigned char *iv,unsigned char *after);
            static std::string& sha1(const std::string &ori_str,std::string &result);
            static std::string& sha11(const std::string &ori_str,std::string &result);
        };

        class BitUtil
        {
        public:
            static std::string& bitOutput(char input,std::string &result);
            static std::string& bitOutput(const std::string &input,std::string &result);
            static char& bitOutput_bit(char input,const int pos,char &result);
            static unsigned long& bitStrToNumber(const std::string &input,unsigned long &result);
            static unsigned long& bitToNumber(const std::string &input,unsigned long &result);
            static char& toBit(const std::string &input,char &result);
            static std::string& toBit(const std::string &input,std::string &result);
        };

        class RandomUtil
        {
        public:
            static long getRandomNumber(const long &a,const long &b);
            static std::string& getRandomStr_base64(std::string &str,const int &length);
            static std::string& generateMask_4(std::string &mask);
        };

        class NetworkOrderUtil
        {
        public:
            static unsigned long& htonl_ntohl_64(unsigned long &data);//64位无符号数转化为大/小端序（网络字节序）
        };
        
        class PrecisionUtil
        {
        public:
        
            static std::string& getPreciesFloat(const float &number,const int &bit,std::string &str);
            static float& getPreciesFloat(float &number,const int &bit);
            static std::string& getPreciesDouble(const double &number,const int &bit,std::string &str);
            static double& getPreciesDouble(double &number,const int &bit);
            static float& getValidFloat(float &number,const int &bit);
        };

        class HttpStringUtil
        {
        public:       
            static size_t get_split_str(const std::string_view& ori_str,std::string_view &str,const std::string_view &a,const std::string_view &b,const size_t &pos=0);
            static std::string_view& get_value_str(const std::string_view& ori_str,std::string_view &str,const std::string& name);
            static std::string_view& get_value_header(const std::string_view& ori_str,std::string_view &str,const std::string& name);
            static std::string_view& get_location_str(const std::string_view& ori_str,std::string_view &str);
            static std::string_view& getLocPara(const std::string_view &url,std::string_view &locPara);
            static std::string_view& getPara(const std::string_view &url,std::string_view &para);
 
       
            static size_t get_split_str(const std::string_view& ori_str,std::string &str,const std::string_view &a,const std::string_view &b,const size_t &pos=0);
            static std::string& get_value_str(const std::string& ori_str,std::string &str,const std::string& name);
            static std::string& get_value_header(const std::string& ori_str,std::string &str,const std::string& name);
            static std::string& get_location_str(const std::string& ori_str,std::string &str);
            static std::string& getLocPara(const std::string &url,std::string &locPara);
            static std::string& getPara(const std::string &url,std::string &para);
            static std::string& getIP(const std::string &url,std::string &IP);
            static int& getPort(const std::string &url,int &port);
            static std::string createHeader(const std::string& first,const std::string& second);
            template<class... Args>
            static std::string createHeader(const std::string& first,const std::string& second,Args... args)
            {
                std::string cf=first+": "+second+"\r\n"+createHeader(args...);
                return cf;
            }
        };

        class WebsocketStringUtil
        {
        public:
            static std::string& transfer_websocket_key(std::string &str);
        };

        class NumberStringConvertUtil
        {
        public:
            static int& toInt(const std::string_view&ori_str,int &result,const int &i=-1);
            static int& str16toInt(const std::string_view&ori_str,int &result,const int &i=-1);
            static long& toLong(const std::string_view&ori_str,long &result,const long &i=-1);
            static float& toFloat(const std::string&ori_str,float &result,const float &i=-1);
            static double& toDouble(const std::string&ori_str,double &result,const double &i=-1);
            static bool& toBool(const std::string_view&ori_str,bool &result);
            static std::string& strto16(const std::string &ori_str,std::string &result);// Convert bytes to a lowercase hexadecimal string
        };

        class EncodingUtil
        {
        public:
            static std::string base64_encode(const std::string &input);
            static std::string base64_decode(const std::string &input);
            static std::string& transfer_websocket_key(std::string &str);
            static std::string& generateMask_4(std::string &mask);
            static std::string& maskCalculate(std::string &data,const std::string &mask);
        };

        class JsonHelper
        {
            public:
            static int getValue(const std::string &oriStr,std::string& result,const std::string &type="value",const std::string &name="a",const int &num=0);

            static std::string toString(const Json::Value &val);
            static Json::Value toJsonArray(const std::string & str);
            template<class T1,class T2>
            static std::string createJson(T1 first,T2 second)
            {
                Json::Value root;
                //root[first]=second;
                if constexpr (std::is_integral_v<T2>) {
                    root[first] = Json::Value(static_cast<Json::Int64>(second));
                } else {
                    root[first] = second;
                }
                Json::StreamWriterBuilder builder;
                std::string jsonString=Json::writeString(builder,root);
                return jsonString;
            }

             template<class T1,class T2,class... Args>
            static std::string createJson(T1 first,T2 second,Args... args)
            {
                Json::Value root;
                //root[first]=second;
                if constexpr (std::is_integral_v<T2>) {
                    root[first] = Json::Value(static_cast<Json::Int64>(second));
                } else {
                    root[first] = second;
                }
                std::string kk=createJson(args...);
                Json::StreamWriterBuilder builder;
                std::string jsonString=Json::writeString(builder,root);
                jsonString=jsonString.erase(jsonString.length()-2);
                kk=kk.substr(1);
                return jsonString+","+kk;
 
            }

            template<class T>
            static std::string createArray(T first)
            {
                Json::Value root(Json::arrayValue);
                root.append(first);
                Json::StreamWriterBuilder builder;
                std::string jsonString=Json::writeString(builder,root);
                return jsonString;
            }

            template<class T,class... Args>
            static std::string createArray(T first,Args... args)
            {
                Json::Value root(Json::arrayValue);
                root.append(first);
                std::string kk=createArray(args...);
                Json::StreamWriterBuilder builder;
                std::string jsonString=Json::writeString(builder,root);
                jsonString=jsonString.erase(jsonString.length()-2);
                kk=kk.substr(1);
                return jsonString+","+kk;
 
            }

            static std::string jsonAdd(const std::string &a,const std::string &b);
            static std::string& jsonFormatify(const std::string &a,std::string &b);
            static std::string& jsonToUTF8(const std::string &input,std::string &output);
        };
    }

    namespace security
    {
        enum class RateLimitType 
        {
            Cooldown,      // 连续触发惩罚：达到上限后进入冷却，需要安静 secs 才恢复
            FixedWindow,   // 固定窗口计数：每 secs 一个窗口，窗口内最多 times 次
            SlidingWindow, // 滑动窗口：统计最近 secs 内的次数（队列时间戳）
            TokenBucket    // 令牌桶：允许突发 + 控制长期平均速率（常用于 API/消息）
        };

        struct RateState
        {
            // 通用
            int counter = 0;
            int violations = 0;   // 新增：触发限流的次数
            std::chrono::steady_clock::time_point lastTime{};
 
            // SlidingWindow
            std::deque<std::chrono::steady_clock::time_point> history;
 
            // TokenBucket
            double tokens = 0.0;
            std::chrono::steady_clock::time_point lastRefill{};
        };

        struct ConnectionState
        {
            int fd = -1;
            RateState requestRate;
            std::unordered_map<std::string, RateState> pathRate;
            std::chrono::steady_clock::time_point lastActivity{};
        };

        struct IPInformation
        {
            int activeConnections = 0;
            RateState connectRate;
            int badScore = 0; //IP 风险评分（用于升级惩罚）
            std::unordered_map<int, ConnectionState> conns; // fd -> state
        };

        enum DefenseDecision : int
        {
            ALLOW = 0,  // 正常通过
            DROP  = 1,  // 不回应（丢弃）
            CLOSE = 2   // 断连（可伴随封 IP）
        };
    
        class ConnectionLimiter
        {
        public:
            ConnectionLimiter(const int& maxConn = 20, const int& idleTimeout = 60) : maxConnections(maxConn),connectionTimeout(idleTimeout){}
 
            // ========== 策略设置 ==========
            void setConnectStrategy(const RateLimitType &type);
            void setRequestStrategy(const RateLimitType &type);
            void setPathStrategy(const RateLimitType &type);
 
            // ========== Path 配置 ==========
            void setPathLimit(const std::string &path, const int &times, const int &secs);
 
            // ========== 核心判断 ==========
            DefenseDecision allowConnect(const std::string &ip, const int &fd,const int &times, const int &secs);
            DefenseDecision allowRequest(const std::string &ip,const int &fd,const std::string_view &path,const int &times,const int &secs);
 
            // ========== 生命周期 ==========
            void clearIP(const std::string &ip,const int &fd);
            bool connectionDetect(const std::string &ip,const int &fd);
        void banIP(const std::string &ip,int banSeconds,const std::string &reasonCN,const std::string &reasonEN);
    void unbanIP(const std::string &ip);
    bool isBanned(const std::string &ip) const;
 
 
        private:
            // 核心判定
            bool allow(RateState &st,const RateLimitType &type,const int &times,const int &secs,const std::chrono::steady_clock::time_point &now);
 
        private:
            int maxConnections;
            int connectionTimeout;
 
            RateLimitType connectStrategy = RateLimitType::Cooldown;
            RateLimitType requestStrategy = RateLimitType::SlidingWindow;
            RateLimitType pathStrategy    = RateLimitType::SlidingWindow;
 
            std::unordered_map<std::string, IPInformation> table;
            std::unordered_map<std::string, std::pair<int,int>> pathConfig;
            // IP -> 解封时间
            std::unordered_map<std::string,std::chrono::steady_clock::time_point> blacklist;
            inline void logSecurity(const std::string &msgCN,const std::string &msgEN);
        };
 
        
        
    }

    namespace network
    {
    class TcpFDHandler
    {
    protected:
        int fd=-1;
        bool flag1=false;
        bool flag2=false;
        SSL *ssl=nullptr;
        int sec=-1;
        std::function<int(std::string)> queuedSendFunction;
        std::function<void()> queuedCloseFunction;
    public:
        bool flag3=false;
    public:
        void setFD(const int &fd,SSL *ssl,const bool &flag1=false,const bool &flag2=false,const int &sec=-1);
        void setTransportFunctions(std::function<int(std::string)> sendFunction,std::function<void()> closeFunction={})
        {
            queuedSendFunction=std::move(sendFunction);
            queuedCloseFunction=std::move(closeFunction);
        }

        int getFD(){return fd;}
        SSL *getSSL(){return ssl;}
        void close(const bool &cle=true);
        void blockSet(const int &sec = -1);
        void unblockSet();
        bool multiUseSet();
        bool isConnect(){if(fd==-1)return false;else return true;}
    public:
        int sendData(const std::string &data,const bool &block=true);
        int sendData(const char *data,const uint64_t &length,const bool &block=true);
        int recvDataByLength(std::string &data,const uint64_t &length,const int &sec=2);
        int recvDataByLength(char *data,const uint64_t &length,const int &sec=2);
        int recvData(std::string &data,const uint64_t &length);
        int recvData(char *data,const uint64_t &length);
    };

    class TcpClient:public TcpFDHandler
    {
    private:
        std::string serverIP="";
        int serverPort=-1;
        bool flag=false;
        bool TLS;
        SSL_CTX *ctx=nullptr;
        const char *ca;
        const char *cert;
        const char *key;
        const char *passwd;
    private:
        bool createFD();
        void closeAndUnCreate();
        bool initCTX(const char *ca,const char *cert="",const char *key="",const char *passwd="");
    public:
        TcpClient(const bool &TLS=false,const char *ca="",const char *cert="",const char *key="",const char *passwd="");
        bool connect(const std::string &ip,const int &port);        
        void resetCTX(const bool &TLS=false,const char *ca="",const char *cert="",const char *key="",const char *passwd="");
        bool close();
        ~TcpClient(){closeAndUnCreate();}
    public:
        std::string getServerIP(){return serverIP;}
        int getServerPort(){return serverPort;}
        bool isConnect(){return flag;}
    };  

    class HttpClient:private TcpClient
    {
    private:
        bool flag=false;
    public:
        HttpClient(const bool &TLS=false,const char *ca="",const char *cert="",const char *key="",const char *passwd=""):TcpClient(TLS,ca,cert,key,passwd){}
    public:
        bool getRequest(const std::string &url,const std::string &header="",const std::string &header1="Connection: keep-alive",const int &sec=-1);
        bool postRequest(const std::string &url,const std::string &body="",const std::string &header="",const std::string &header1="Connection: keep-alive",const int &sec=-1);
        bool getRequestFromFD(const int &fd,SSL *ssl,const std::string &url,const std::string &header="",const std::string &header1="Connection: keep-alive",const int &sec=2);
        bool postRequestFromFD(const int &fd,SSL *ssl,const std::string &url,const std::string &body="",const std::string &header="",const std::string &header1="Connection: keep-alive",const int &sec=2);
    public:
        bool isReturn(){return flag;}
        std::string header="";
        std::string body="";
    };
    
    class EpollSingle
    {
    private:
        int fd=-1;
        bool flag=true;
        std::function<bool(const int &fd)> fc=[](const int &)->bool
        {return true;};
        std::function<void(const int &fd)> fcEnd=[](const int &)->void
        {};
        std::function<bool(const int &fd)> fcTimeOut=[](const int &)->bool
        {return true;};
        std::atomic<bool> flag1{true};
        std::atomic<bool> flag2{false};
        time::Duration dt{0,20,0,0,0};
        std::atomic<bool> flag3{false};
        time::Duration t;
        std::thread listenerThread;
        int controlFD=-1;
        std::mutex callbackMutex;
        std::mutex countdownMutex;
    private:
        void epolll();
    public:
        void startListen(const int &fd,const bool &flag=true,const time::Duration &dt=time::Duration{0,0,20,0,0});
    public:
        bool isListen(){return flag2.load(std::memory_order_acquire);}
        void setFunction(std::function<bool(const int &fd)> fc){std::lock_guard<std::mutex> lock(callbackMutex);this->fc=std::move(fc);}
        void setEndFunction(std::function<void(const int &fd)> fcEnd){std::lock_guard<std::mutex> lock(callbackMutex);this->fcEnd=std::move(fcEnd);};
        void setTimeOutFunction(std::function<bool(const int &fd)> fcTimeOut){std::lock_guard<std::mutex> lock(callbackMutex);this->fcTimeOut=std::move(fcTimeOut);};
        bool endListen();
        void endListenWithSignal();
        void waitAndQuit(const time::Duration &t=time::Duration{0,0,0,10,10})
        {
            std::lock_guard<std::mutex> lock(countdownMutex);
            this->t=t;
            flag3.store(true,std::memory_order_release);
        }

        ~EpollSingle(){endListen();}
    };
    
    class WebSocketClient:private TcpClient 
    {
    private:
        bool flag4=false;
        std::function<bool(const std::string &message,WebSocketClient &k)> fc=[](const std::string &message,WebSocketClient &)->bool
        {std::cout<<"收到: "<<message<<std::endl;return true;};
        std::string url;
        EpollSingle k;
        bool flag5=false;
    private:
        bool close1();
    public:
        WebSocketClient(const bool &TLS=false,const char *ca="",const char *cert="",const char *key="",const char *passwd=""):TcpClient(TLS,ca,cert,key,passwd){}
        void setFunction(std::function<bool(const std::string &message,WebSocketClient &k)> fc){this->fc=fc;}
        bool connect(const std::string &url,const int &min=20);
        bool sendMessage(const std::string &message,const std::string &type="0001");
        void close(const std::string &closeCodeAndMessage,const bool &wait=true);
        void close(const short &code=1000,const std::string &message="bye",const bool &wait=true);       
    public:
        bool isConnect(){return flag4;}
        std::string getUrl(){return url;}
        std::string getServerIp(){return TcpClient::getServerIP();}
        std::string getServerPort(){return std::to_string(TcpClient::getServerPort());}
        int getServerPortNumber(){return TcpClient::getServerPort();}    
        ~WebSocketClient();
    };

    struct HttpRequestInformation 
    {
        int fd=-1;
        uint64_t connection_obj_fd=0;
        std::string type;
        std::string locPara;
        std::string loc;
        std::string para;
        std::string header;
        std::string body;
        std::string body_chunked;
        std::unordered_map<std::string,std::any> ctx;

        std::string_view headerValue(std::string_view name) const noexcept;

        std::string_view bodyView() const noexcept;
    };
    
    struct TcpFDInf;
    class HttpServerFDHandler:public TcpFDHandler
    {
    public:
        void setFD(const int &fd,SSL *ssl=nullptr,const bool &flag1=false,const bool &flag2=true){TcpFDHandler::setFD(fd,ssl,flag1,flag2);}
        int solveRequest(TcpFDInf &TcpInf,HttpRequestInformation &HttpInf,const unsigned long &buffer_size,const int &times=1,const unsigned long &max_header_size=64UL*1024UL);
        bool sendBack(const std::string &data,const std::string &header="",const std::string &code="200 OK",const std::string &header1="");

        bool sendText(const std::string &data,const std::string &code="200 OK",
                      const std::string &contentType="text/plain; charset=utf-8",
                      const std::string &extraHeaders="");

        bool sendJson(const Json::Value &data,const std::string &code="200 OK",
                      const std::string &extraHeaders="");

        bool redirect(const std::string &location,const std::string &code="302 Found");
        bool sendBack(const char *data,const size_t &length,const char *header="\0",const char *code="200 OK\0",const char *header1="\0",const size_t &header_length=50);
    };

    struct WebSocketFDInformation
    {
        int fd=-1;
        uint64_t connection_obj_fd=0;
        bool closeflag=false;
        std::string locPara;
        std::string header;
        time_t HBTime=0;
        time_t response=0;
        size_t recv_length=0;
        size_t have_recv_length=0;
        int message_type=0;
        std::string message="";
        bool fin=true;
        uint8_t fragmented_opcode=0;
        std::string fragmented_message;
        std::string mask;
        std::unordered_map<std::string,std::any> ctx;
        HttpRequestInformation httpinf;
    };

    struct TcpInformation
    {
        int fd=-1;
        uint64_t connection_obj_fd=0;
        std::string data;
        std::unordered_map<std::string,std::any> ctx;
    };
 
    enum class TLSState : uint8_t {
    NONE = 0,        // 非 TLS 连接（普通 TCP）
    HANDSHAKING,    // TLS 握手中（SSL_accept 还没完成）
    ESTABLISHED,    // TLS 已建立，可以 SSL_read / SSL_write
    ERROR           // TLS 出错（可选）
    };

    enum class TLSClientAuthMode : uint8_t {
        None = 0, 
        Optional, 
        Required  
    };

    struct ServerMetricsSnapshot
    {
        uint64_t accepted_connections=0;       
        uint64_t active_connections=0;         
        uint64_t closed_connections=0;         
        uint64_t rejected_connections=0;       
        uint64_t accept_errors=0;              
        uint64_t tls_handshake_failures=0;     
        uint64_t parsed_http_requests=0;       
        uint64_t queued_write_bytes=0;         
        uint64_t sent_bytes=0;                 
        uint64_t pending_write_bytes=0;        
        uint64_t peak_pending_write_bytes=0;   
        uint64_t peak_pending_worker_tasks=0;  
        uint64_t write_overflows=0;            
        uint64_t worker_queue_overflows=0;     
        uint64_t send_ready_queue_overflows=0; 
        uint64_t worker_task_rejections=0;     
        uint64_t reactor_wakeups=0;            
        uint64_t reactor_wakeups_coalesced=0;  
        uint64_t write_syscalls=0;             
        uint64_t batched_write_syscalls=0;     
        uint64_t batched_write_buffers=0;      
        uint64_t idle_timeout_checks=0;         
        uint64_t idle_timeout_closes=0;         
        uint64_t graceful_shutdown_timeouts=0;  
    };

    struct ServerSocketOptions
    {
        bool tcp_no_delay=true;          
        bool keep_alive=false;           
        bool reuse_port=true;            
        int receive_buffer_bytes=0;      
        int send_buffer_bytes=0;         
        int keep_alive_idle_seconds=0;   
        int keep_alive_interval_seconds=0; 
        int keep_alive_probe_count=0;    
        int defer_accept_seconds=0;      
        int fast_open_queue=0;           
        int listen_backlog=0;            
    };

    struct ConnectionWriteState
    {
        std::mutex mutex;                    
        std::deque<std::string> queue;        
        size_t front_offset=0;                
        size_t queued_bytes=0;                
        size_t max_queued_bytes=4UL*1024UL*1024UL; 
        int fd=-1;                            
        uint64_t connection_obj_fd=0;         
        bool notification_pending=false;      
        bool close_requested=false;           
        bool close_after_flush=false;          
        bool overflowed=false;                 
        bool closed=false;                     
    };

    struct SendReadyMessage
    {
        int fd=-1;                    
        uint64_t connection_obj_fd=0; 
    };

    struct TcpFDInf
    {
        int fd=-1;
        uint64_t connection_obj_fd=0;
        std::string ip;
        std::string port;
        int FDStatus=-1;
        std::queue<std::any> pendindQueue;
        int status=0;
        std::string_view data;
        SSL* ssl=nullptr;
        TLSState tls_state=TLSState::NONE;
        char *buffer=nullptr;
        unsigned long p_buffer_now=0;
        unsigned long buffer_capacity=0;
        size_t active_workers=0;
        bool closing=false;
        std::shared_ptr<ConnectionWriteState> write_state;
        bool write_interest=false;
        bool write_waiting_for_read=false;
    };

    struct WorkerMessage
    {
        int fd=-1;
        uint64_t connection_obj_fd=0;
        int ret=-2;
        std::shared_ptr<void> request;
    };
    
    
    class TcpServer 
    {
    protected:
        system::MPSCQueue<WorkerMessage> finishQueue;
        system::MPSCQueue<SendReadyMessage> sendReadyQueue;
        stt::system::WorkerPool *workpool=nullptr;
        unsigned long buffer_size;
        unsigned long long  maxFD;
        security::ConnectionLimiter connectionLimiter;
        //std::unordered_map<int,TcpFDInf> clientfd;
        //std::mutex lc1;
        std::unordered_map<int,TcpFDInf> clientfd;
        std::atomic<bool> flag1{false};
        //std::queue<QueueFD> *fdQueue;
        //std::mutex *lq1;
        //std::condition_variable cv1;
        //std::condition_variable *cv;
        //int consumerNum;
        //std::mutex lco1;
        bool unblock;
        SSL_CTX *ctx=nullptr;
        bool TLS=false;
        mutable std::mutex tlsContextMutex;
        //std::unordered_map<int,SSL*> tlsfd;
        //std::mutex ltl1;
        bool security_open;
        //bool flag_detect;
        //bool flag_detect_status;
        std::atomic<int> workerEventFD{-1};
        std::atomic<bool> workerWakePending{false};
        std::recursive_mutex lifecycleMutex;
        std::thread reactorThread;
        std::mutex reactorStartupMutex;
        std::condition_variable reactorStartupCV;
        bool reactorStartupComplete=false;
        bool reactorStartupSuccess=false;
        std::atomic<bool> gracefulDrainRequested{false};
        std::mutex gracefulShutdownMutex;
        std::condition_variable gracefulShutdownCV;
        std::mutex overflowFinishMutex;
        std::deque<WorkerMessage> overflowFinishQueue;
        std::mutex overflowSendReadyMutex;
        std::deque<SendReadyMessage> overflowSendReadyQueue;
        std::mutex writeRegistryMutex;
        std::unordered_map<int,std::weak_ptr<ConnectionWriteState>> writeRegistry;
        std::deque<SendReadyMessage> bufferedReadQueue;
        std::deque<SendReadyMessage> timeoutCandidates;
        int serverType; // 1 tcp 2 http 3 websocket
        int connectionSecs;
        int connectionTimes;
        int requestSecs;
        int requestTimes;
        int checkFrequency;
        uint64_t connection_obj_fd;
        size_t maxPendingWriteBytes=4UL*1024UL*1024UL;
        size_t writeBudgetPerEvent=256UL*1024UL;
        size_t maxHttpHeaderBytes=64UL*1024UL;
        size_t maxPendingWorkerTasks=65536;
        size_t workerCompletionBudgetPerWake=2048;
        size_t sendReadyBudgetPerWake=256;
        size_t gracefulShutdownTimeoutMs=5000;
        ServerSocketOptions socketOptions;
        std::atomic<uint64_t> metricAcceptedConnections{0};
        std::atomic<uint64_t> metricActiveConnections{0};
        std::atomic<uint64_t> metricClosedConnections{0};
        std::atomic<uint64_t> metricRejectedConnections{0};
        std::atomic<uint64_t> metricAcceptErrors{0};
        std::atomic<uint64_t> metricTLSHandshakeFailures{0};
        std::atomic<uint64_t> metricParsedHttpRequests{0};
        std::atomic<uint64_t> metricQueuedWriteBytes{0};
        std::atomic<uint64_t> metricSentBytes{0};
        std::atomic<uint64_t> metricPendingWriteBytes{0};
        std::atomic<uint64_t> metricPeakPendingWriteBytes{0};
        std::atomic<uint64_t> metricPeakPendingWorkerTasks{0};
        std::atomic<uint64_t> metricWriteOverflows{0};
        std::atomic<uint64_t> metricWorkerQueueOverflows{0};
        std::atomic<uint64_t> metricSendReadyQueueOverflows{0};
        std::atomic<uint64_t> metricWorkerTaskRejections{0};
        std::atomic<uint64_t> metricReactorWakeups{0};
        std::atomic<uint64_t> metricReactorWakeupsCoalesced{0};
        std::atomic<uint64_t> metricWriteSyscalls{0};
        std::atomic<uint64_t> metricBatchedWriteSyscalls{0};
        std::atomic<uint64_t> metricBatchedWriteBuffers{0};
        std::atomic<uint64_t> metricIdleTimeoutChecks{0};
        std::atomic<uint64_t> metricIdleTimeoutCloses{0};
        std::atomic<uint64_t> metricGracefulShutdownTimeouts{0};
    private:
        std::function<void(const int &fd)> closeFun=[](const int &)->void
        {
 
        };
        std::function<void(TcpFDHandler &k,TcpInformation &inf)> securitySendBackFun=[](TcpFDHandler &,TcpInformation &)->void
        {};
        std::function<bool(TcpFDHandler &k,TcpInformation &inf)> globalSolveFun=[](TcpFDHandler &,TcpInformation &)->bool
        {return true;};
        std::unordered_map<std::string,std::vector<std::function<int(TcpFDHandler &k,TcpInformation &inf)>>> solveFun;
        std::function<int(TcpFDHandler &k,TcpInformation &inf)> parseKey=[](TcpFDHandler &,TcpInformation &inf)->int
        {inf.ctx["key"]=inf.data;return 1;};
        int fd=-1;
        std::atomic<int> port{-1};
        std::atomic<bool> flag{false};
        std::atomic<bool> flag2{true};
    private:
        void epolll(const int &evsNum,const int &listenFD);
        //virtual void consumer(const int &threadID);
        virtual void handler_netevent(const int &fd);
        virtual void handler_workerevent(WorkerMessage message);
        virtual void handleHeartbeat()=0;
        virtual void onConnectionClosed(const int &fd) {(void)fd;}
    protected:
        enum class WriteFlushResult { Drained, WaitWrite, WaitRead, Reschedule, Error };
        int enqueueWrite(const std::shared_ptr<ConnectionWriteState> &state,std::string data);
        void requestQueuedClose(const std::shared_ptr<ConnectionWriteState> &state);
        void requestCloseAfterFlush(const int &fd,const uint64_t expectedConnection=0);
        void publishSendReady(const std::shared_ptr<ConnectionWriteState> &state);
        void notifyReactor() noexcept;
        bool hasPendingReactorWork();
        void clearReactorQueues();
        void drainReactorWork(const int &epollFD);
        size_t drainWorkerResults(const size_t budget);
        size_t drainSendReady(const int &epollFD,const size_t budget);
        void applyAcceptedSocketOptions(const int &acceptedFD) const noexcept;
        void reportReactorStartup(const bool success);
        void advanceGracefulDrain();
        void prepareHandler(TcpFDHandler &handler,const int &fd);
        void prepareQueuedHandler(TcpFDHandler &handler,const int &fd);
        void prepareQueuedHandler(TcpFDHandler &handler,const int &fd,const uint64_t expectedConnection);
        WriteFlushResult flushConnectionWrites(TcpFDInf &connection);
        bool updateConnectionEvents(const int &epollFD,TcpFDInf &connection,const bool &wantWrite);
        void handleSendReady(const int &epollFD,SendReadyMessage message);
        void publishWorkerResult(WorkerMessage message);
        void scheduleBufferedRead(const int &fd,const uint64_t connection);
    public:
        void putTask(const std::function<int(TcpFDHandler &k,TcpInformation &inf)> &fun,TcpFDHandler &k,TcpInformation &inf);
        TcpServer(const unsigned long long &maxFD=1000000,const int &buffer_size=256,const size_t &finishQueue_cap=65536,const bool &security_open=true,
        const int &connectionNumLimit=20,const int &connectionSecs=1,const int &connectionTimes=6,const int &requestSecs=1,const int &requestTimes=40,
        const int &checkFrequency=60,const int &connectionTimeout=60):
        finishQueue(finishQueue_cap),sendReadyQueue(finishQueue_cap),buffer_size(buffer_size>0?static_cast<unsigned long>(buffer_size)*1024UL:256UL*1024UL),
        maxFD(maxFD>0?maxFD:1'000'000ULL),connectionLimiter(connectionNumLimit,connectionTimeout),security_open(security_open),
        serverType(1),connectionSecs(connectionSecs),connectionTimes(connectionTimes),requestSecs(requestSecs),requestTimes(requestTimes),
        checkFrequency(checkFrequency),connection_obj_fd(1){}

        bool startListen(const int &port,const int &threads=8);
        bool setTLS(const char *cert,const char *key,const char *passwd,const char *ca);
        bool setTLS(const char *cert,const char *key,const char *passwd="");
        bool setTLS(const char *cert,const char *key,const char *passwd,const char *ca,
                    TLSClientAuthMode clientAuth);
        void redrawTLS();
        void setSecuritySendBackFun(std::function<void(TcpFDHandler &k,TcpInformation &inf)> fc){this->securitySendBackFun=fc;}
        void setGlobalSolveFunction(std::function<bool(TcpFDHandler &k,TcpInformation &inf)> fc){this->globalSolveFun=fc;}
        void setFunction(const std::string &key,std::function<int(TcpFDHandler &k,TcpInformation &inf)> fc)
        {
            auto [it, inserted] = solveFun.try_emplace(key);
            it->second.push_back(std::move(fc));
        }

        void setGetKeyFunction(std::function<int(TcpFDHandler &k,TcpInformation &inf)> parseKeyFun){this->parseKey=parseKeyFun;}
        bool stopListen();
        virtual bool close();
        virtual bool close(const int &fd);
        void setConnectStrategy(const stt::security::RateLimitType &type){this->connectionLimiter.setConnectStrategy(type);}
        void setRequestStrategy(const stt::security::RateLimitType &type){this->connectionLimiter.setRequestStrategy(type);}
        void setPathStrategy(const stt::security::RateLimitType &type){this->connectionLimiter.setPathStrategy(type);}
        void setPathLimit(const std::string &path, const int &times, const int &secs){this->connectionLimiter.setPathLimit(path,times,secs);}
        void setCloseFun(std::function<void(const int &fd)> closeFun){this->closeFun=closeFun;}
        void setMaxPendingWriteBytes(const size_t bytes){if(bytes>0)maxPendingWriteBytes=bytes;}
        void setWriteBudgetPerEvent(const size_t bytes){if(bytes>0)writeBudgetPerEvent=bytes;}
        void setMaxHttpHeaderBytes(const size_t bytes){if(bytes>=1024)maxHttpHeaderBytes=bytes;}
        void setMaxPendingWorkerTasks(const size_t tasks){if(tasks>0)maxPendingWorkerTasks=tasks;}
        void setReactorMessageBudgets(const size_t workerCompletions,const size_t sendReadyNotifications)
        {
            if(workerCompletions>0)workerCompletionBudgetPerWake=workerCompletions;
            if(sendReadyNotifications>0)sendReadyBudgetPerWake=sendReadyNotifications;
        }

        void setSocketOptions(const ServerSocketOptions &options)
        {
            socketOptions=options;
            if(socketOptions.receive_buffer_bytes<0)socketOptions.receive_buffer_bytes=0;
            if(socketOptions.send_buffer_bytes<0)socketOptions.send_buffer_bytes=0;
            if(socketOptions.keep_alive_idle_seconds<0)socketOptions.keep_alive_idle_seconds=0;
            if(socketOptions.keep_alive_interval_seconds<0)socketOptions.keep_alive_interval_seconds=0;
            if(socketOptions.keep_alive_probe_count<0)socketOptions.keep_alive_probe_count=0;
            if(socketOptions.defer_accept_seconds<0)socketOptions.defer_accept_seconds=0;
            if(socketOptions.fast_open_queue<0)socketOptions.fast_open_queue=0;
            if(socketOptions.listen_backlog<0)socketOptions.listen_backlog=0;
        }

        void setGracefulShutdownTimeout(const size_t milliseconds){gracefulShutdownTimeoutMs=milliseconds;}
        ServerMetricsSnapshot getMetrics() const noexcept
        {
            return {
                metricAcceptedConnections.load(std::memory_order_relaxed),
                metricActiveConnections.load(std::memory_order_relaxed),
                metricClosedConnections.load(std::memory_order_relaxed),
                metricRejectedConnections.load(std::memory_order_relaxed),
                metricAcceptErrors.load(std::memory_order_relaxed),
                metricTLSHandshakeFailures.load(std::memory_order_relaxed),
                metricParsedHttpRequests.load(std::memory_order_relaxed),
                metricQueuedWriteBytes.load(std::memory_order_relaxed),
                metricSentBytes.load(std::memory_order_relaxed),
                metricPendingWriteBytes.load(std::memory_order_relaxed),
                metricPeakPendingWriteBytes.load(std::memory_order_relaxed),
                metricPeakPendingWorkerTasks.load(std::memory_order_relaxed),
                metricWriteOverflows.load(std::memory_order_relaxed),
                metricWorkerQueueOverflows.load(std::memory_order_relaxed),
                metricSendReadyQueueOverflows.load(std::memory_order_relaxed),
                metricWorkerTaskRejections.load(std::memory_order_relaxed),
                metricReactorWakeups.load(std::memory_order_relaxed),
                metricReactorWakeupsCoalesced.load(std::memory_order_relaxed),
                metricWriteSyscalls.load(std::memory_order_relaxed),
                metricBatchedWriteSyscalls.load(std::memory_order_relaxed),
                metricBatchedWriteBuffers.load(std::memory_order_relaxed),
                metricIdleTimeoutChecks.load(std::memory_order_relaxed),
                metricIdleTimeoutCloses.load(std::memory_order_relaxed),
                metricGracefulShutdownTimeouts.load(std::memory_order_relaxed)
            };
        }
    public:
        bool isListen(){return flag.load(std::memory_order_acquire);}
        int getListenPort() const noexcept{return port.load(std::memory_order_acquire);}
        SSL* getSSL(const int &fd);
        virtual ~TcpServer(){close();redrawTLS();}
    };
 
    
    
    class HttpServer:public TcpServer
    {
    private:
        std::function<void(HttpServerFDHandler &k,HttpRequestInformation &inf)> securitySendBackFun=[](HttpServerFDHandler &,HttpRequestInformation &)->void
        {};
        std::vector<std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)>> globalSolveFun;
        //std::function<bool(HttpServerFDHandler &k,HttpRequestInformation &inf)> globalSolveFun={};
        std::unordered_map<std::string,std::vector<std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)>>> solveFun;
        std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> parseKey=[](HttpServerFDHandler &,HttpRequestInformation &inf)->int
        {inf.ctx["key"]=inf.loc;return 1;};
        //std::function<bool(const HttpRequestInformation &inf,HttpServerFDHandler &k)> fc;
        //HttpRequestInformation *HttpInf;
        std::unordered_map<int,HttpRequestInformation> httpinf;
    private:
        //void consumer(const int &threadID);
        //inline void handler(const int &fd);
        void handler_netevent(const int &fd) override;
        void handler_workerevent(WorkerMessage message) override;
        void handleHeartbeat() override {}
    public:
        using TcpServer::close;
        void putTask(const std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> &fun,HttpServerFDHandler &k,HttpRequestInformation &inf);
         
        HttpServer(const unsigned long long &maxFD=1000000,const int &buffer_size=256,const size_t &finishQueue_cap=65536,const bool &security_open=true,
        const int &connectionNumLimit=10,const int &connectionSecs=1,const int &connectionTimes=3,const int &requestSecs=1,const int &requestTimes=20,
        const int &checkFrequency=30,const int &connectionTimeout=30):TcpServer(
              maxFD,
              buffer_size,
              finishQueue_cap,
              security_open,
              connectionNumLimit,
              connectionSecs,
              connectionTimes,
              requestSecs,
              requestTimes,
              checkFrequency,
              connectionTimeout
          ){serverType=2;}

        void setSecuritySendBackFun(std::function<void(HttpServerFDHandler &k,HttpRequestInformation &inf)> fc){this->securitySendBackFun=fc;}
        void setGlobalSolveFunction(std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> fc){globalSolveFun.push_back(std::move(fc));}
        void setFunction(const std::string &key,std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> fc)
        {
            auto [it, inserted] = solveFun.try_emplace(key);
            it->second.push_back(std::move(fc));
        }

        void setGetKeyFunction(std::function<int(HttpServerFDHandler &k,HttpRequestInformation &inf)> parseKeyFun){this->parseKey=parseKeyFun;}
        bool startListen(const int &port,const int &threads=8)
        {
            return TcpServer::startListen(port,threads);
        }
        bool close() override;
        bool close(const int &fd) override;
        ~HttpServer()
        {
            close();
        }
    };

    class WebSocketServerFDHandler:public TcpFDHandler
    {
    public:
        void setFD(const int &fd,SSL *ssl=nullptr,const bool &flag1=false,const bool &flag2=true){TcpFDHandler::setFD(fd,ssl,flag1,flag2);}
        int getMessage(TcpFDInf &Tcpinf,WebSocketFDInformation &Websocketinf,const unsigned long &buffer_size,const int &ii=1);
        bool sendMessage(const std::string &msg,const std::string &type="0001");
       
    };
    
    class WebSocketServer:public TcpServer
    {
    private:
        std::unordered_map<int,WebSocketFDInformation> wbclientfd;
        std::mutex websocketRegistryMutex;
        std::unordered_map<int,uint64_t> websocketConnections;
        std::unordered_set<int> websocketClosing;
        std::function<void(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> securitySendBackFun=[](WebSocketServerFDHandler &,WebSocketFDInformation &)->void
        {};
        //std::function<bool(const std::string &msg,WebSocketServer &k,const WebSocketFDInformation &inf)> fc=[](const std::string &message,WebSocketServer &k,const WebSocketFDInformation &inf)->bool
        //{std::cout<<"收到: "<<message<<std::endl;return true;};
        std::function<bool(WebSocketFDInformation &k)> fcc=[](WebSocketFDInformation &)
        {return true;};
        std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fccc=[](WebSocketServerFDHandler &,WebSocketFDInformation &)->bool
        {
            return true;
        };
        std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> globalSolveFun=[](WebSocketServerFDHandler &,WebSocketFDInformation &)->bool
        {return true;};
        std::unordered_map<std::string,std::vector<std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)>>> solveFun;
        std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> parseKey=[](WebSocketServerFDHandler &,WebSocketFDInformation &inf)->int
        {inf.ctx["key"]=inf.message;return 1;};
        int seca=20*60;
        int secb=30;
 
    private:
        void handler_netevent(const int &fd) override;
        void handler_workerevent(WorkerMessage message) override;
        //void consumer(const int &threadID);
        //inline void handler(const int &fd);
        void closeAck(const int &fd,const std::string &closeCodeAndMessage);
        void closeAck(const int &fd,const short &code=1000,const std::string &message="bye");
        
        void handleHeartbeat() override;
        void onConnectionClosed(const int &fd) override;
        bool sendMessageForConnection(const int &fd,const uint64_t connection,const std::string &msg,const std::string &type);
        bool closeWithoutLock(const int &fd,const std::string &closeCodeAndMessage);
        bool closeWithoutLock(const int &fd,const short &code=1000,const std::string &message="bye");
    public:
         void putTask(const std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> &fun,WebSocketServerFDHandler &k,WebSocketFDInformation &inf);
        WebSocketServer(const unsigned long long &maxFD=1000000,const int &buffer_size=256,const size_t &finishQueue_cap=65536,const bool &security_open=true,
        const int &connectionNumLimit=5,const int &connectionSecs=10,const int &connectionTimes=3,const int &requestSecs=1,const int &requestTimes=10,
        const int &checkFrequency=60,const int &connectionTimeout=120):TcpServer(
              maxFD,
              buffer_size,
              finishQueue_cap,
              security_open,
              connectionNumLimit,
              connectionSecs,
              connectionTimes,
              requestSecs,
              requestTimes,
              checkFrequency,
              connectionTimeout
          ){serverType=3;}

        void setSecuritySendBackFun(std::function<void(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fc){this->securitySendBackFun=fc;}
        void setGlobalSolveFunction(std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fc){this->globalSolveFun=fc;}
        void setStartFunction(std::function<bool(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fccc){this->fccc=fccc;}
        void setJudgeFunction(std::function<bool(WebSocketFDInformation &k)> fcc){this->fcc=fcc;}
        void setFunction(const std::string &key,std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> fc)
        {
            auto [it, inserted] = solveFun.try_emplace(key);
            it->second.push_back(std::move(fc));
        }

        void setGetKeyFunction(std::function<int(WebSocketServerFDHandler &k,WebSocketFDInformation &inf)> parseKeyFun){this->parseKey=parseKeyFun;}
        //void setFunction(std::function<bool(const std::string &msg,WebSocketServer &k,const WebSocketFDInformation &inf)> fc){this->fc=fc;}
        void setTimeOutTime(const int &seca){this->seca=seca*60;}
        void setHBTimeOutTime(const int &secb){this->secb=secb;}
        bool closeFD(const int &fd,const std::string &closeCodeAndMessage);
        bool closeFD(const int &fd,const short &code=1000,const std::string &message="bye");
        bool sendMessage(const int &fd,const std::string &msg,const std::string &type="0001");
        bool close() override;
        bool close(const int &fd) override;
        bool startListen(const int &port,const int &threads=8)
        {
            //std::thread(&WebSocketServer::HB,this).detach();
 
            return TcpServer::startListen(port,threads);
        }

        void sendMessage(const std::string &msg,const std::string &type="0001");
        ~WebSocketServer(){ close(); }
    };

    class UdpFDHandler
    {
    protected:
        int fd=-1;
        bool flag1=false;
        bool flag2=false;
        int sec=-1;
    public:
        void setFD(const int &fd,const bool &flag1=false,const int &sec=-1,const bool &flag2=false);
        void blockSet(const int &sec=-1);
        void unblockSet();
        bool multiUseSet();
        int getFD(){return fd;}
        void close(const bool &cle=true);
        int sendData(const std::string &data,const std::string &ip,const int &port,const bool &block=true);
        int sendData(const char *data,const uint64_t &length,const std::string &ip,const int &port,const bool &block=true);
        int recvData(std::string &data,const uint64_t &length,std::string &ip,int &port);
        int recvData(char *data,const uint64_t &length,std::string &ip,int &port);
        
    };

    class UdpClient:public UdpFDHandler
    {
    public:
        UdpClient(const bool &flag1=false,const int &sec=-1);
        bool createFD(const bool &flag1=false,const int &sec=-1);
        ~UdpClient(){close();}
    };

    class UdpServer:public UdpFDHandler
    {
    public:
        UdpServer(const int &port,const bool &flag1=false,const int &sec=-1,const bool &flag2=true);
        bool createFD(const int &port,const bool &flag1=false,const int &sec=-1,const bool &flag2=true);
        ~UdpServer(){close();}
    };
    }
    namespace system
    {
        class ServerSetting
        {
        public:
            static file::LogFile *logfile;
            static std::string language;
        private:
            [[noreturn]] static void signalterminated() noexcept;
        public:
            static void setExceptionHandling();
            static bool blockTerminationSignals();
            static int waitForTerminationSignal();
            static void setLogFile(file::LogFile *logfile=nullptr,const std::string &language="");
            static void init(file::LogFile *logfile=nullptr,const std::string &language="");
        };
        
        class csemp
        {
        private:
            union semun  
            {
                int val;                
                struct semid_ds *buf;   
                unsigned short  *arry;  
            };
 
            int   m_semid;      
            short m_sem_flg;    
 
            csemp(const csemp &) = delete;             
            csemp &operator=(const csemp &) = delete;  
 
        public:
            csemp():m_semid(-1){}

            bool init(key_t key, unsigned short value = 1, short sem_flg = SEM_UNDO);

            bool wait(short value = -1);

            bool post(short value = 1);

            int getvalue();

            bool destroy();

            ~csemp();
        };

        #define MAX_PROCESS_NAME 100
        #define MAX_PROCESS_INF 1000
        #define SHARED_MEMORY_KEY 0x5095
        #define SHARED_MEMORY_LOCK_KEY 0x5095

        struct ProcessInf
        {
            pid_t pid;
            time_t lastTime;
            char name[MAX_PROCESS_NAME];
            char argv0[20];
            char argv1[20];
            char argv2[20];
        };

        class HBSystem
        {
        private:
        
            static ProcessInf *p;
            static csemp plock;
            static bool isJoin;
        public:
            bool join(const char *name,const char *argv0="",const char *argv1="",const char *argv2="");
            bool renew();
            static void list();
            static bool HBCheck(const int &sec);
            bool deleteFromHBS();
            ~HBSystem();
        };

        class Process
        {
        private:
            static void prepareForkedChild(const bool terminateWithParent=false) noexcept
            {
                sigset_t emptySet;
                sigemptyset(&emptySet);
                pthread_sigmask(SIG_SETMASK,&emptySet,nullptr);
                struct sigaction defaultAction{};
                sigemptyset(&defaultAction.sa_mask);
                defaultAction.sa_handler=SIG_DFL;
                for(const int childSignal:{SIGTERM,SIGINT,SIGHUP,SIGQUIT,SIGCHLD,SIGPIPE})
                    sigaction(childSignal,&defaultAction,nullptr);
#ifdef __linux__
                if(terminateWithParent)
                {
                    prctl(PR_SET_PDEATHSIG,SIGTERM);
                    if(getppid()==1)
                        _exit(128+SIGTERM);
                }
#else
                (void)terminateWithParent;
#endif
            }
        public:
        

            template<class... Args>
            static bool startProcess(const std::string &name,const int &sec=-1,Args ...args)
            {
                std::vector<const char *> paramList={args...,nullptr};
                if(sec==-1)
                {
                    pid_t pid=fork();
                    if(pid==-1)
                        return false;
                    if(pid>0)
                        return true;
                    else
                    {
                        prepareForkedChild();
                        execv(name.c_str(),const_cast<char* const*>(paramList.data()));
                        _exit(127);
                    }
                }
                pid_t pid=fork();
                if(pid==-1)
                    return false;
                if(pid>0)
                {   
                    return true;
                }
                else
                {
                    prepareForkedChild(true);
                    while(1)
                    {
                        pid=fork();
                        if(pid==0)
                        {
                            prepareForkedChild(true);
                            execv(name.c_str(),const_cast<char* const*>(paramList.data()));
                            _exit(127);
                        }
                        else if(pid>0)
                        {
                            int sts;
                            while(waitpid(pid,&sts,0)<0&&errno==EINTR) {}
                            sleep(sec);
                        }
                        else
                            continue;
                    }
                }
            }

            template<class Fn,class... Args>
            static typename std::enable_if<!std::is_convertible<Fn, std::string>::value, bool>::type
            startProcess(Fn&& fn,const int &sec=-1,Args &&...args)
            {
                if(sec==-1)
                {
                    pid_t pid=fork();
                    if(pid==-1)
                        return false;
                    if(pid>0)
                    return true;
                    else
                    {
                        prepareForkedChild();
                        auto f=std::bind(std::forward<Fn>(fn),std::forward<Args>(args)...);
                        f();
                        _exit(EXIT_SUCCESS);
                    }
                }
                pid_t pid=fork();
                if(pid==-1)
                    return false;
                if(pid>0)
                {   
                    return true;
                }
                else
                {
                    prepareForkedChild(true);
                    while(1)
                    {
                        pid=fork();
                        if(pid==0)
                        {
                            prepareForkedChild(true);
                            auto f=std::bind(std::forward<Fn>(fn),std::forward<Args>(args)...);
                            f();
                            _exit(EXIT_SUCCESS);
                        }
                        else if(pid>0)
                        {
                            int sts;
                            while(waitpid(pid,&sts,0)<0&&errno==EINTR) {}
                            sleep(sec);
                        }
                        else
                            continue;
                    }
                }
            }
        };
 
        using Task = std::function<void()>;
        class WorkerPool 
        {
        public:
            explicit WorkerPool(size_t n,size_t maxPendingTasks=65536):
            stop_(false),maxPendingTasks_(std::max<size_t>(1,maxPendingTasks))
            {
                if(n==0)
                    throw std::invalid_argument("WorkerPool requires at least one worker");
                for (size_t i = 0; i < n; ++i) {
                    threads_.emplace_back([this] {
                        this->workerLoop();
                    });
                }
            }

            ~WorkerPool() 
            {
                stop();
            }

            bool submit(Task task)
            {
                size_t pending=0;
                {
                    std::lock_guard<std::mutex> lk(mtx_);
                    if (stop_||tasks_.size()>=maxPendingTasks_)
                        return false;
                    tasks_.push(std::move(task));
                    pending=tasks_.size();
                    pendingTaskCount_.store(pending,std::memory_order_relaxed);
                }
                size_t peak=peakPendingTaskCount_.load(std::memory_order_relaxed);
                while(peak<pending&&!peakPendingTaskCount_.compare_exchange_weak(
                      peak,pending,std::memory_order_relaxed,std::memory_order_relaxed)) {}
                cv_.notify_one();
                return true;
            }

            void stop(const bool drain=true)
            {
                std::call_once(stopOnce_,[this,drain] {
                    {
                        std::lock_guard<std::mutex> lk(mtx_);
                        stop_ = true;
                        if(!drain)
                        {
                            tasks_=std::queue<Task>();
                            pendingTaskCount_.store(0,std::memory_order_relaxed);
                        }
                    }
                    cv_.notify_all();
                    for (auto &t : threads_)
                    {
                        if (t.joinable()) t.join();
                    }
                });
            }

            size_t pendingTasks() const
            {
                return pendingTaskCount_.load(std::memory_order_relaxed);
            }

            size_t maxPendingTasks() const noexcept {return maxPendingTasks_;}

            size_t peakPendingTasks() const noexcept
            {
                return peakPendingTaskCount_.load(std::memory_order_relaxed);
            }
 
        private:
            void workerLoop() 
            {
                while (true) 
                {
                    Task task;
                    {
                        std::unique_lock<std::mutex> lk(mtx_);
                        cv_.wait(lk, [this] {
                        return stop_ || !tasks_.empty();
                        });
                        if (stop_ && tasks_.empty())
                        {
                            return;
                        }
                        task = std::move(tasks_.front());
                        tasks_.pop();
                        pendingTaskCount_.store(tasks_.size(),std::memory_order_relaxed);
                    }
                    try
                    {
                        task(); // 执行任务
                    }
                    catch (...)
                    {
                        // 单个任务的异常不应终止整个服务进程或工作线程。
                    }
                }
            }
 
        private:
            std::vector<std::thread> threads_;
            std::queue<Task> tasks_;
            mutable std::mutex mtx_;
            std::condition_variable cv_;
            bool stop_;
            const size_t maxPendingTasks_;
            std::atomic<size_t> pendingTaskCount_{0};
            std::atomic<size_t> peakPendingTaskCount_{0};
            std::once_flag stopOnce_;
        };
    }
    
}
 
 
#endif