wsl更新后支持wslg, 可以在windows上直接显示wsl中运行的程序界面



地址： https://github.com/microsoft/wslg


# 步骤
## 切换为 wsl2
```shell
wsl --shutdown
wsl --set-version _distro_name_ 2
```

## 更新 wsl
```shell
wsl --update
```

## 设置wslg正常显示中文
进入wsl
### 生成locale配置文件
```bash
sudo locale-gen
locale
```
### 共享windos字体
```bash
sudo apt install fontconfig
sudo vim /etc/fonts/local.conf
```
### 在 local.conf中添加如下内容
```bash
<?xml version="1.0"?>
<!DOCTYPE fontconfig SYSTEM "fonts.dtd">
<fontconfig>
    <dir>/mnt/c/Windows/Fonts</dir>
</fontconfig>

```

# 完成


![image.png](http://text.beiklive.top/static/img/6166e1e9a01fa16a2412404044456829.image.webp)

安装和使用WSLG

实现该功能需要依赖  https://github.com/ineo6/hosts 项目

![image.png](http://text.beiklive.top/static/img/aea1bb1a3089c31ffaa48e464386b4ca.image.webp)



## 代码
```python
#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests

# 定义源URL和目标文件
source_url = "https://gitlab.com/ineo6/hosts/-/raw/master/hosts"
target_file = "/etc/hosts"

# 定义标记
start_marker = "# >>>>start\n"
end_marker = "\n# <<<<end"

def fetch_latest_content(url):
    # 发送GET请求获取最新内容
    response = requests.get(url)
    if response.status_code == 200:
        return response.text.splitlines()
    else:
        print(f"无法从 {url} 获取内容。")
        return None

def update_host_file_with_new_content(source_content, file_path):
    # 构建新的内容
    new_content = start_marker + '\n' + '\n'.join(source_content) + end_marker + '\n'

    # 替换目标文件中的内容
    try:
        with open(file_path, 'r+') as f:
            file_data = f.read()
            start_pos = file_data.find(start_marker)
            end_pos = file_data.find(end_marker, start_pos + len(start_marker))

            if start_pos != -1 and end_pos != -1:
                f.seek(0)
                f.truncate()
                f.write(file_data[:start_pos])
                f.write(new_content)
                f.write(file_data[end_pos + len(end_marker):])
                print("目标文件已更新。")
            else:
                print("未找到标记，无法替换内容。")

    except FileNotFoundError:
        print(f"文件 {file_path} 未找到。")
    except IOError:
        print(f"无法写入到文件 {file_path}。")

def main():
    # 获取最新内容
    latest_content = fetch_latest_content(source_url)
    if latest_content:
        # 更新目标文件中的内容
        update_host_file_with_new_content(latest_content, target_file)
    else:
        print("未能获取最新内容。")

if __name__ == "__main__":
    main()
```

上面的脚本会获取到 https://gitlab.com/ineo6/hosts/-/raw/master/hosts 的内容，然后插入到/etc/hosts 文件的 start_marker 和 end_marker 之间

***请手动在 /etc/hosts 中添加 start_marker 和 end_marker***


## 定时运行
在 crontab 中添加定时任务

1. 打开 crontab 文件
```bash
sudo vim  /etc/crontab
```
2. 添加定时任务

这是我的脚本路径，请自行替换为自己的路径
```bash
30 * * * * root /usr/bin/python3 /home/beiklive/Host/updateHost.py >> /home/beiklive/Host/log.log 2>&1
```

4. 刷新crontab
```bash
sudo systemctl restart cron
```

自动更新获取github的hosts

![image.png](http://text.beiklive.top/static/img/601a713b3d43bbdd106d1a6022fb3ed5.image.webp)



## 背景描述

由于公司的网络使用的是白名单，对很多网站以及我自己的服务器访问有限制，虽然可以通过手机打开热点，给公司电脑链接来访问一些网站，但是切换来切换去，总归是不方便的。

而且手机现在又 USB提供网络的功能，可以在电脑上作为一个网口使用，因此可以使用修改路由表的方法来使一些网站的流量跳到手机网口上

## 操作方法

### 查看手机网口的网关 

![image.png](http://text.beiklive.top/static/img/e01e62a241f0ac99108791bf9850351a.image.webp)


![image.png](http://text.beiklive.top/static/img/acf1db275af0bc3b33b4c746d4be5e47.image.webp)

### 在CMD 使用 route命令
```powershell
route add {要跳转的地址} mask 255.255.255.255 {上面的DNS服务器地址}
```

配置指定IP 走指定网关

# 小抄备忘录




## name
要想按如下方式命名组件
```js
<script name="Person" lang="ts" setup>
<script>
```
需要执行以下命令安装
```bash
npm i vite-plugin-vue-setup-extend -D
```
然后修改 `vite.config.ts`
```ts
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import VueSetup from 'vite-plugin-vue-setup-extend'   // 加这行

// https://vitejs.dev/config/
export default defineConfig({
  plugins: [vue(), VueSetup()],  // 这里也要加
})

```

## 响应式对象 ref reactive
使变量变成响应式

ref 可以定义：基本类型、对象类型响应式数据
reactive 只能定义：对象类型的响应式数据

```ts
<script name="Person" lang="ts" setup>
        import { ref } from 'vue';
        // 定义基本变量响应式数据
        let name = ref('张三');
        
        import { reactive } from 'vue';
        // 定义对象类型响应式数据
        let person = reactive({
            name: '张三',
            age: 25,
            occupation: '学生'
        });
        // 定义方法
        function changeName() {
            console.log('changeName');
            name.value = '小乔'
        }
</script>
```

vue3 小抄

![image.png](http://text.beiklive.top/static/img/abc2bd8dafc0e0b7f3d92da3ed0f2b5f.image.webp)




模仿 `fmtlib` 的格式化方式，使用 `{}` 作为占位符
待改进：
* 占位符的更多功能尚未扩展
* `{{}}` 这种括号包括号会出错
* 性能待提升

代码如下

```CPP
// Copyright (c) RealCoolEngineer. 2024. All rights reserved.
// Author: beiklive
// Date: 2024-01-31
#ifndef INC_LOG_HH_
#define INC_LOG_HH_

#include <iostream>
#include <sstream>
#include <iomanip>
#include <mutex>
#include <fstream>
#include <sys/stat.h>
#include <cstdlib>
#include <memory>
#ifdef _WIN32
#include <direct.h>
#else
#include <unistd.h>  // For Unix/Linux
#endif



namespace beiklive
{
    namespace LOG
    {
        class FileLogger;

        enum class LOGLEVEL
        {
            ERROR,
            WARNING,
            INFO,
            DEBUG
        };

        enum class OUTPUT
        {
            NONE,
            CONSOLE,
            FILE,
            ALL
        };

        enum class ColorCode
        {
            RESET = 0,
            DEBUG = 34,   // Blue
            INFO = 32,    // Green
            WARNING = 33, // Yellow
            ERROR = 31    // Red
        };


        class FileLogger {
        public:
            FileLogger() : logFile(nullptr) {}

            ~FileLogger() {
                if (logFile && logFile->is_open()) {

                    // 刷新并关闭文件
                    flush();
                    logFile->close();
                }
            }

            void initializeLogFile(const std::string& filePath) {
                logFile.reset(new std::ofstream(filePath, std::ios::app));

                if (!logFile->is_open()) {
                    std::cerr << "Error opening log file: " << filePath << std::endl;
                }
                else {
                    currentFilePath = filePath;
                    // 设置缓冲区大小
                    logFile->rdbuf()->pubsetbuf(0, 1024);

                }
            }

            void logMessage(const std::string& message) {
                if (logFile && logFile->is_open()) {
                    (*logFile) << message  << std::endl;
                }
            }

            void switchLogFile(const std::string& newFilePath) {
                if (logFile && logFile->is_open()) {
                    // 刷新并关闭当前文件
                    flush();
                    logFile->close();

                    // 初始化新文件
                    initializeLogFile(newFilePath);
                }
            }

        private:
            std::unique_ptr<std::ofstream> logFile;
            std::string currentFilePath;

            void flush() {
                if (logFile && logFile->is_open()) {
                    logFile->flush();
                }
            }
        };


        namespace
        {
            LOGLEVEL        loglevel_ = LOGLEVEL::INFO;
            OUTPUT          output_ = OUTPUT::CONSOLE;

            std::string     logFilePath_ = "./log";
            std::string     CurLogFile_;
            std::string     CurCycleLogDirName_;
            long long       MaxSingleLogFileSize_ = 1024 * 1024 * 10; // 10MB
            FileLogger      filelogger;

            std::mutex      logMutex;
        }

        //*FILE ***************************************************************
        std::string generateLogFileName() {
            auto now = std::chrono::system_clock::now();
            auto millisec = std::chrono::duration_cast<std::chrono::milliseconds>(
                now.time_since_epoch()
            ).count() % 1000;

            // 获取当前日期和时间
            auto timeNow = std::chrono::system_clock::to_time_t(now);
            std::tm tmNow = *std::localtime(&timeNow);

            // 格式化日期和时间
            std::stringstream ss;
            ss << std::put_time(&tmNow, "%Y%m%d_%H_%M_%S_") << std::setw(3) << std::setfill('0') << millisec;

            return ss.str();
        }


        bool createDirectory(const std::string& directoryPath) {
            // 检查目录是否已存在
            if (access(directoryPath.c_str(), 0) == 0) {
                std::cout << "Directory already exists: " << directoryPath << std::endl;
                return true;
            }

        #ifdef _WIN32
            int result = _mkdir(directoryPath.c_str());
        #else
            mode_t mode = 0755;  // 权限设置为rwxr-xr-x
            int result = mkdir(directoryPath.c_str(), mode);
        #endif

            if (result == 0) {
                std::cout << "Directory created successfully: " << directoryPath << std::endl;
                return true;
            } else {
                std::perror(std::string("Error creating directory: " + directoryPath).c_str());
                return false;
            }
        }


        bool isFileSizeOverSize(const std::string& filename) {

            std::lock_guard<std::mutex> lock(logMutex);
            std::ifstream file(filename, std::ios::binary | std::ios::ate);
            if (!file.is_open()) {
                std::cerr << "Error opening file: " << filename << std::endl;
                return false;  // Unable to open the file
            }
            std::streamsize fileSize = file.tellg();  // Get the file size
            file.close();  // Close the file
            return fileSize > MaxSingleLogFileSize_;
        }

        void endsWithSlash(std::string& str) {
            if (!str.empty()) {
                char lastChar = str.back();
                if (lastChar == '/') {
                    return;
                }
                else {
                    str += '/';
                }
            }
        }

        void LogFileRotation(const std::string& msg)
        {
            // 目录初始化
            if (CurCycleLogDirName_.empty())
            {
                createDirectory(logFilePath_);
                CurCycleLogDirName_ = generateLogFileName();
                endsWithSlash(logFilePath_);
                createDirectory(logFilePath_ + CurCycleLogDirName_);
            }

            if (CurLogFile_.empty())
            {
                CurLogFile_ = generateLogFileName() + ".log";
                std::cout << "New logfile : " << CurLogFile_ << std::endl;
                filelogger.initializeLogFile(logFilePath_ + CurCycleLogDirName_ + "/" + CurLogFile_);
            }

            if (isFileSizeOverSize(logFilePath_ + CurCycleLogDirName_ + "/" + CurLogFile_))
            {
                CurLogFile_ = generateLogFileName() + ".log";
                std::cout << "Switch to new logfile : " << CurLogFile_ << std::endl;
                filelogger.switchLogFile(logFilePath_ + CurCycleLogDirName_ + "/" + CurLogFile_);
            }

            filelogger.logMessage(msg);
        }

        void LogFileSizeSet(const long& maxSize = 1024 * 1024 * 10)
        {
            MaxSingleLogFileSize_ = maxSize;
        }

        void LogFilePathSet(const std::string& dirPath)
        {
            if(createDirectory(dirPath))
            {
                logFilePath_ = dirPath;
            }
            std::cout << "Use log path : " << logFilePath_ << std::endl;
        }
        //***************************************************************


        void LoggerOutputSet(const OUTPUT set)
        {
            std::lock_guard<std::mutex> lock(logMutex);
            output_ = set;
        }

        void LoggerLevelSet(const LOGLEVEL set)
        {
            std::lock_guard<std::mutex> lock(logMutex);
            loglevel_ = set;
        }

        void LoggerStop()
        {
            std::lock_guard<std::mutex> lock(logMutex);
            output_ = OUTPUT::NONE;
        }

        bool isEnableOutput()
        {
            return !(output_ == OUTPUT::NONE);
        }

        bool isConsoleOutput() {
            return (output_ == OUTPUT::CONSOLE || output_ == OUTPUT::ALL);
        }

        bool isFileOutput()
        {
            return (output_ == OUTPUT::FILE || output_ == OUTPUT::ALL);
        }

#define COLOR(level, message) \
        (std::string("\033[") + std::to_string(static_cast<int>(level)) + "m" + message + "\033[0m")

#define GET_FUNCTION_NAME() (std::string(__PRETTY_FUNCTION__) + ":" + std::to_string(__LINE__))

        std::string getCurrentTimestamp()
        {
            auto now = std::chrono::system_clock::now();
            auto currentTime = std::chrono::system_clock::to_time_t(now);
            auto millisec = std::chrono::duration_cast<std::chrono::milliseconds>(
                now.time_since_epoch()
            ).count() % 1000;

            std::tm tmNow = *std::localtime(&currentTime);

            std::stringstream timestamp;
            timestamp << std::put_time(&tmNow, "%Y-%m-%d %H:%M:%S.") << std::setw(3) << std::setfill('0') << millisec;;

            return timestamp.str();
        }


        std::string format(const std::string& pattern)
        {
            return pattern;
        }

        template <typename T, typename... Args>
        std::string format(const std::string& pattern, T first, Args &&...args)
        {
            std::stringstream ss;
            size_t pos = pattern.find("{");
            size_t pos2 = pattern.find("}", pos);

            if (pos != std::string::npos && pos2 != std::string::npos)
            {
                ss << pattern.substr(0, pos) << first << pattern.substr(pos2 + 1);
            }
            else
            {
                ss << pattern;
            }

            return format(ss.str(), args...);
        }

        template <typename T, typename K, typename... Args>
        void MACRO_LOG_OUTPUT(const LOGLEVEL level, T first, K pattern, Args &&...args)
        {
            if (isEnableOutput())
            {
                if (loglevel_ >= level)
                {
                    std::stringstream ss;
                    ss << "[";
                    ss << first;
                    ss << "] ";
                    ss << pattern;
                    LOG_OUTPUT(level, ss.str(), args...);
                }
            }
        }

        template <typename... Args>
        void LOG_OUTPUT(const LOGLEVEL level, const std::string& pattern, Args &&...args)
        {
            std::string&& s = format(pattern, args...);


            std::stringstream ss;
            ss << "[" << getCurrentTimestamp() << "]";
            ss << " ";
            if (isConsoleOutput()) {
                std::stringstream sss;
                sss << ss.str();
                switch (level)
                {
                case LOGLEVEL::INFO:
                    sss << "[" << COLOR(ColorCode::INFO, "I") << "]";
                    break;
                case LOGLEVEL::WARNING:
                    sss << "[" << COLOR(ColorCode::WARNING, "W") << "]";
                    break;
                case LOGLEVEL::ERROR:
                    sss << "[" << COLOR(ColorCode::ERROR, "E") << "]";
                    break;
                case LOGLEVEL::DEBUG:
                    sss << "[" << COLOR(ColorCode::DEBUG, "D") << "]";
                    break;
                }
                sss << " ";
                sss << s;
                std::cout << sss.str() << std::endl;
            }
            if (isFileOutput())
            {
                std::stringstream sss;
                sss << ss.str();
                switch (level)
                {
                case LOGLEVEL::INFO:
                    sss << "[I]";
                    break;
                case LOGLEVEL::WARNING:
                    sss << "[W]";
                    break;
                case LOGLEVEL::ERROR:
                    sss << "[E]";
                    break;
                case LOGLEVEL::DEBUG:
                    sss << "[D]";
                    break;
                }
                sss << " ";
                sss << s;
                LogFileRotation(sss.str());
            }
        }

        template <typename T, typename... Args>
        void info(T pattern, Args &&...args)
        {
            if (loglevel_ >= LOGLEVEL::INFO && isEnableOutput())
                LOG_OUTPUT(LOGLEVEL::INFO, pattern, args...);
        }
        template <typename T, typename... Args>
        void warning(T pattern, Args &&...args)
        {
            if (loglevel_ >= LOGLEVEL::WARNING && isEnableOutput())
                LOG_OUTPUT(LOGLEVEL::WARNING, pattern, args...);
        }
        template <typename T, typename... Args>
        void error(T pattern, Args &&...args)
        {
            if (loglevel_ >= LOGLEVEL::ERROR && isEnableOutput())
                LOG_OUTPUT(LOGLEVEL::ERROR, pattern, args...);
        }
        template <typename T, typename... Args>
        void debug(T pattern, Args &&...args)
        {
            if (loglevel_ >= LOGLEVEL::DEBUG && isEnableOutput())
                LOG_OUTPUT(LOGLEVEL::DEBUG, pattern, args...);
        }

    } // namespace log
#define LOG_INFO(...) LOGGER_INFO(__VA_ARGS__)
#define LOG_WARNING(...) LOGGER_WARNING(__VA_ARGS__)
#define LOG_ERROR(...) LOGGER_ERROR(__VA_ARGS__)
#define LOG_DEBUG(...) LOGGER_DEBUG(__VA_ARGS__)

#define LOGGER_INFO(...) MACRO_LOG_OUTPUT(beiklive::LOG::LOGLEVEL::INFO, GET_FUNCTION_NAME(), __VA_ARGS__)
#define LOGGER_WARNING(...) MACRO_LOG_OUTPUT(beiklive::LOG::LOGLEVEL::WARNING, GET_FUNCTION_NAME(), __VA_ARGS__)
#define LOGGER_ERROR(...) MACRO_LOG_OUTPUT(beiklive::LOG::LOGLEVEL::ERROR, GET_FUNCTION_NAME(), __VA_ARGS__)
#define LOGGER_DEBUG(...) MACRO_LOG_OUTPUT(beiklive::LOG::LOGLEVEL::DEBUG, GET_FUNCTION_NAME(), __VA_ARGS__)

} // namespace beiklive


#endif  // INC_LOG_HH_


```

main.cpp
```cpp
#include <iostream>
#include "log.hh"
int main()
{
    beiklive::LOG::LoggerOutputSet(beiklive::LOG::OUTPUT::ALL);
    beiklive::LOG::LogFileSizeSet(1024*1024*10); // 10MB
    beiklive::LOG::LogFilePathSet("/home/beiklive/WorkSpace/MyCode/clearn");
    
    int i = 0;
    beiklive::LOG::info("this is info {}", i);
    beiklive::LOG::warning("this is warning {}", i);
    beiklive::LOG::error("this is error {}", i);
    beiklive::LOG::debug("this is debug {}", i);

    i++;
    beiklive::LOG::LoggerLevelSet(beiklive::LOG::LOGLEVEL::DEBUG);

    beiklive::LOG::info("this is info {}", i);
    beiklive::LOG::warning("this is warning {}", i);
    beiklive::LOG::error("this is error {}", i);
    beiklive::LOG::debug("this is debug {}", i);

    i++;

    
    beiklive::LOG::info("this is info {}", i);
    beiklive::LOG::warning("this is warning {}", i);


    beiklive::LOG::error("this is error {}", i);
    beiklive::LOG::debug("this is debug {}", i);


    return 0;
}
```