服务器监控应用（2）：使用 Golang 开发客户端

func getCPUModelName() (string, error) {
    cpuInfo, err := cpu.Info()
    if err != nil {
        return "", err
    }

    var cpuModel string

    for _, info := range cpuInfo {
        cpuModel = info.ModelName
        break
    }
    return cpuModel, nil
}

func getLoad() (string, string, string, error) {
    loadAvg, err := load.Avg()
    if err != nil {
        return "", "", "", err
    }

    load1 := fmt.Sprintf("%.2f", loadAvg.Load1)
    load5 := fmt.Sprintf("%.2f", loadAvg.Load5)
    load15 := fmt.Sprintf("%.2f", loadAvg.Load15)

    return load1, load5, load15, nil
}

func getMemoryInfo() (uint64, uint64, error) {
    memory, err := mem.VirtualMemory()
    if err != nil {
        return 0, 0, err
    }

    memoryTotal := memory.Total
    memoryUsed := memory.Used

    return memoryTotal, memoryUsed, nil
}

func getDiskUsage() (uint64, uint64, error) {
    partitions, err := disk.Partitions(false)
    if err != nil {
        return 0, 0, err
    }

    var total, used uint64

    switch runtime.GOOS {
    case "darwin":
        for _, partition := range partitions {
            if partition.Mountpoint == "/" {
                usageStat, err := disk.Usage(partition.Mountpoint)
                if err != nil {
                    continue
                }
                total += usageStat.Total
                used += usageStat.Used
            }
        }
    default:
        for _, partition := range partitions {
            usageStat, err := disk.Usage(partition.Mountpoint)
            if err != nil {
                continue
            }
            total += usageStat.Total
            used += usageStat.Used
        }

    }

    DiskTotal := total
    DiskUsed := used

    return DiskTotal, DiskUsed, nil
}

import base64
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad

class AESCipher:
    def __init__(self, _key):
        self.key = _key

    def encrypt(self, _plaintext):
        _cipher = AES.new(self.key.encode(), AES.MODE_CBC)
        _plaintext = pad(_plaintext.encode(), AES.block_size)
        _encrypted_text = _cipher.iv + _cipher.encrypt(_plaintext)
        return base64.b64encode(_encrypted_text).decode()[:128]

    def decrypt(self, ciphertext):
        ciphertext = base64.b64decode(ciphertext)
        iv = ciphertext[:AES.block_size]
        _cipher = AES.new(self.key.encode(), AES.MODE_CBC, iv)
        _decrypted_text = unpad(_cipher.decrypt(ciphertext[AES.block_size:]), AES.block_size)
        return _decrypted_text.decode()

package tool

import (
    "bytes"
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "io"
)

type AESCipher struct {
    key []byte
}

func NewAESCipher(key string) *AESCipher {
    byteKey := []byte(key)
    return &AESCipher{byteKey}
}

func (c *AESCipher) Encrypt(plaintext string) (string, error) {
    block, err := aes.NewCipher(c.key)
    if err != nil {
        return "", err
    }

    plaintextBytes := []byte(plaintext)
    plaintextBytes = pkcs7Pad(plaintextBytes, aes.BlockSize)

    ciphertext := make([]byte, aes.BlockSize+len(plaintextBytes))
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return "", err
    }

    mode := cipher.NewCBCEncrypter(block, iv)
    mode.CryptBlocks(ciphertext[aes.BlockSize:], plaintextBytes)

    encoded := base64.StdEncoding.EncodeToString(ciphertext)
    if len(encoded) > 128 {
        return "", err
    }

    return encoded, nil
}

func (c *AESCipher) Decrypt(ciphertext string) (string, error) {
    ciphertextBytes, err := base64.StdEncoding.DecodeString(ciphertext)
    if err != nil {
        return "", err
    }

    block, err := aes.NewCipher(c.key)
    if err != nil {
        return "", err
    }

    if len(ciphertextBytes) < aes.BlockSize {
        panic("ciphertext too short")
    }
    iv := ciphertextBytes[:aes.BlockSize]
    ciphertextBytes = ciphertextBytes[aes.BlockSize:]

    mode := cipher.NewCBCDecrypter(block, iv)
    mode.CryptBlocks(ciphertextBytes, ciphertextBytes)

    return string(pkcs7Unpad(ciphertextBytes)), nil
}

func pkcs7Pad(src []byte, blockSize int) []byte {
    padding := blockSize - len(src)%blockSize
    padText := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(src, padText...)
}

func pkcs7Unpad(src []byte) []byte {
    length := len(src)
    unpadding := int(src[length-1])
    return src[:(length - unpadding)]
}