files

package
v2.0.9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 11, 2025 License: MIT Imports: 36 Imported by: 0

Documentation

Overview

Package files 提供文件操作相关的功能

Package files 提供文件操作相关功能

* 使用示例: 

// 创建控制器
controller, err := NewController(
    WithMaxWorkers(10),
    WithMinWorkers(2),
    WithQueueSize(1000),
)
if err != nil {
    log.Fatal(err)
}

// 执行任务
err = controller.ExecuteTaskWithPriority(
    context.Background(),
    func(ctx context.Context, task *TaskInfo) error {
        // 任务处理逻辑
        return nil
    },
    1, // taskID
    PriorityHigh,
    map[string]interface{}{
        "source": "api",
    },
)

// 获取指标
metrics, err := controller.GetMetrics()

// 停止控制器
err = controller.Stop()

Package files 提供文件和资源管理相关功能

* 使用示例: 

// 创建资源守卫
guard := NewResourceGuard(memManager,
	WithMemoryThreshold(0.85),
	WithCriticalThreshold(0.95),
	WithAsyncCleanup(true),
)
defer guard.Stop()

// 获取资源(非阻塞)
err := guard.AcquireResources(ctx)

// 清理资源(支持异步)
err = guard.CleanupResources(files, true)

// 获取统计信息
stats := guard.GetStats()

Package files 提供内存管理相关功能

* 使用示例: 

// 创建内存管理器
mm, err := NewMemoryManager(
	WithWarningThreshold(0.75),
	WithCriticalThreshold(0.85),
	WithMonitorInterval(10 * time.Second),
	WithAutoTuneGC(true),
)
if err != nil {
	log.Fatal(err)
}
defer mm.Stop()

// 获取内存指标
metrics := mm.GetMetrics()
fmt.Printf("内存使用率: %.2f%%\n", metrics.UsedPercent)

// 手动触发GC
mm.TriggerGC()

* 使用示例: 

// 创建带默认配置的读写锁
mutex, err := NewSafeRWMutex()

// 创建带自定义配置的读写锁
mutex, err := NewSafeRWMutex(
	WithTimeout(3 * time.Second),
	WithRetries(5),
	WithBackoff(500 * time.Millisecond),
)

// 使用锁
ctx := context.Background()
if err := mutex.TryLockTimeout(ctx); err != nil {
	// 处理错误
}
defer mutex.Unlock()

* 使用示例: 

// 创建重试操作实例
retry, err := NewRetryableOperation(
	WithMaxRetries(5),
	WithInitialBackoff(time.Second),
	WithMaxBackoff(30 * time.Second),
	WithMaxElapsed(time.Minute),
	WithOnRetry(func(attempt int, err error) {
		log.Printf("第%d次重试失败: %v", attempt+1, err)
	}),
)

// 执行操作
ctx := context.Background()
err = retry.Execute(ctx, func() error {
	// 要重试的操作
	return nil
})

Package files 提供文件相关的操作功能,包括密钥分片生成和恢复等功能

Index

Constants

View Source 
const (
	CtrlMinWorkers         = 1                // 最小工作协程数
	CtrlMaxWorkers         = 10000            // 最大工作协程数
	CtrlDefaultMinWorkers  = 1                // 默认最小工作协程数
	CtrlDefaultMaxWorkers  = 4                // 默认最大工作协程数
	CtrlDefaultQueueSize   = 1000             // 默认任务队列大小
	CtrlDefaultRetryTimes  = 3                // 默认重试次数
	CtrlDefaultTaskTimeout = 10 * time.Minute // 默认任务超时时间
	CtrlShutdownTimeout    = time.Minute      // 默认关闭超时时间
	CtrlMetricsInterval    = time.Second      // 默认指标收集间隔
	CtrlCleanupInterval    = 5 * time.Minute  // 默认清理间隔
)

控制器常量定义

View Source 
const (
	CtrlErrInvalidConfig = iota + 1000 // 无效配置错误码
	CtrlErrTaskNotFound                // 任务未找到错误码
	CtrlErrTaskTimeout                 // 任务超时错误码
	CtrlErrTaskCanceled                // 任务取消错误码
	CtrlErrSystemBusy                  // 系统繁忙错误码
)

控制器错误码定义

View Source 
const (
	GuardMemoryThreshold   = 0.9                    // 默认内存警告阈值(90%)
	GuardCriticalThreshold = 0.95                   // 默认内存临界阈值(95%)
	GuardGCInterval        = 30 * time.Second       // 默认GC间隔
	GuardMaxRetries        = 3                      // 默认最大重试次数
	GuardRetryBackoff      = 500 * time.Millisecond // 默认重试等待时间
	GuardMaxBackoff        = 10 * time.Second       // 最大重试等待时间
	GuardMonitorInterval   = 1 * time.Minute        // 默认监控间隔
	GuardCleanupInterval   = 5 * time.Minute        // 默认清理间隔
)

系统常量定义

View Source 
const (
	DefaultWarningThreshold  = 0.8              // 默认内存使用预警阈值（80%）
	DefaultCriticalThreshold = 0.9              // 默认内存使用危险阈值（90%）
	DefaultMinGCInterval     = time.Second      // 默认最小GC间隔
	DefaultMaxGCTimeout      = 30 * time.Second // 默认GC超时时间
	DefaultMonitorInterval   = 5 * time.Second  // 默认监控间隔
)

系统默认配置常量

View Source 
const (
	DefaultTimeout = 5 * time.Second  // 默认超时时间
	DefaultRetries = 3                // 默认重试次数
	DefaultBackoff = time.Second      // 默认重试间隔
	MaxTimeout     = time.Minute      // 最大超时时间
	MaxRetries     = 10               // 最大重试次数
	MaxBackoff     = 10 * time.Second // 最大重试间隔
)

默认配置常量

View Source 
const (
	DefaultMaxRetries     = 3                // 默认最大重试次数
	DefaultInitialBackoff = time.Second      // 默认初始重试等待时间
	DefaultMaxBackoff     = 30 * time.Second // 默认最大重试等待时间
	DefaultMaxElapsed     = time.Minute      // 默认最大总耗时
)

默认配置常量

Variables

This section is empty.

Functions

func BoolToByte 

func BoolToByte(b bool) byte

BoolToByte 将bool转换为byte 参数:

  • b: bool 需要转换的布尔值

返回值:

  • byte: 转换后的字节值，true为1，false为0

func CalculateFileHash 

func CalculateFileHash(file afero.File) ([]byte, error)

CalculateFileHash 计算文件的SHA-256 hash

参数:

  • file afero.File: 要计算哈希的文件

返回值:

  • []byte: 计算得到的SHA-256哈希值
  • error: 处理过程中发生的任何错误

func CalculateHash 

func CalculateHash(data []byte) []byte

CalculateHash 计算[]byte的SHA-256 hash值

参数:

  • data []byte: 要计算哈希的数据

返回值:

  • []byte: 计算得到的SHA-256哈希值

func CheckAndMkdir 

func CheckAndMkdir(dirPath string) error

CheckAndMkdir 检查文件夹是否存在，不存在则新建

参数:

  • dirPath string: 要检查或创建的目录路径

返回值:

  • error: 处理过程中发生的任何错误

func CompareHashes 

func CompareHashes(hash1, hash2 []byte) bool

CompareHashes 比较两个哈希值是否相等

参数:

  • hash1 []byte: 第一个哈希值
  • hash2 []byte: 第二个哈希值

返回值:

  • bool: 如果两个哈希值相等，返回 true；否则返回 false

func ConvertSliceTableToSortedSlice 

func ConvertSliceTableToSortedSlice(sliceTable map[int64]*pb.HashTable) []*pb.HashTable

ConvertSliceTableToSortedSlice 将 map[int64]*pb.HashTable 转换为有序的 []*pb.HashTable

func CopyFile 

func CopyFile(opt *fscfg.Options, afe afero.Afero, srcSubDir, srcFileName, destSubDir, destFileName string) error

CopyFile 将文件从源路径复制到目标路径 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • srcSubDir: string 类型，源文件子目录路径
  • srcFileName: string 类型，源文件名
  • destSubDir: string 类型，目标文件子目录路径
  • destFileName: string 类型，目标文件名

返回值:

  • error: 如果复制过程中发生错误，返回相应的错误信息

func CreateFile 

func CreateFile(opt *fscfg.Options, afe afero.Afero, subDir, fileName string) error

CreateFile 在指定子目录创建一个新文件 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • subDir: string 类型，子目录路径
  • fileName: string 类型，文件名

返回值:

  • error: 如果创建过程中发生错误，返回相应的错误信息

func DecodeFromBytes 

func DecodeFromBytes(data []byte, result interface{}) error

DecodeFromBytes 使用 gob 解码将 []byte 转换为指定的数据结构

参数:

  • data []byte: 要解码的字节切片
  • result interface{}: 解码后的结果将存储在这个接口中

返回值:

  • error: 处理过程中发生的任何错误

func Delete 

func Delete(opt *fscfg.Options, afe afero.Afero, subDir, fileName string) error

Delete 删除指定的文件 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • subDir: string 类型，子目录路径
  • fileName: string 类型，文件名

返回值:

  • error: 如果删除过程中发生错误，返回相应的错误信息

func DeleteAll 

func DeleteAll(opt *fscfg.Options, afe afero.Afero, subDir string) error

DeleteAll 删除所有文件 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • subDir: string 类型，子目录路径

返回值:

  • error: 如果删除过程中发生错误，返回相应的错误信息

func DeserializeSliceTable 

func DeserializeSliceTable(data []byte) (map[int64]*pb.HashTable, error)

DeserializeSliceTable 将字节切片反序列化为 SliceTable 参数:

  • data: []byte 需要反序列化的字节切片

返回值:

  • map[int64]*HashTable: 反序列化后的 SliceTable
  • error: 如果在反序列化过程中发生错误，返回相应的错误信息

func EncodeToBytes 

func EncodeToBytes(data interface{}) ([]byte, error)

EncodeToBytes 使用 gob 编码将任意数据转换为 []byte

参数:

  • data interface{}: 要编码的数据

返回值:

  • []byte: 编码后的字节切片
  • error: 处理过程中发生的任何错误

func Exists 

func Exists(opt *fscfg.Options, afe afero.Afero, subDir, fileName string) (bool, error)

Exists 检查指定的文件是否存在 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • subDir: string 类型，子目录路径
  • fileName: string 类型，文件名

返回值:

  • bool: 文件是否存在
  • error: 如果检查过程中发生错误，返回相应的错误信息

func ExtractPublicKey 

func ExtractPublicKey(privateKey *ecdsa.PrivateKey) []byte

ExtractPublicKey 从ECDSA私钥中提取公钥

参数:

  • privateKey *ecdsa.PrivateKey: 输入的ECDSA私钥

返回值:

  • []byte: 提取的公钥的字节表示

func FromBytes 

func FromBytes[T any](data []byte) (T, error)

FromBytes 泛型函数，用于将 []byte 转换回指定类型

参数:

  • data []byte: 要转换的字节切片

返回值:

  • T: 转换后的数据，类型为 T
  • error: 处理过程中发生的任何错误

func GenerateFileID 

func GenerateFileID(privateKey *ecdsa.PrivateKey, checksum []byte) (string, error)

GenerateFileID 生成文件的唯一标识 参数：

  • privateKey: *ecdsa.PrivateKey ECDSA 私钥，用于生成文件ID
  • checksum: []byte 文件的校验和

返回值：

  • string: 生成的文件ID
  • error: 如果发生错误，返回错误信息

func GenerateKeyShares 

func GenerateKeyShares(ownerPriv *ecdsa.PrivateKey, fileIdentifier string) ([][]byte, error)

GenerateKeyShares 生成密钥分片

参数:

  • ownerPriv *ecdsa.PrivateKey: 文件所有者的私钥,用于生成初始秘密
  • fileIdentifier string: 文件的唯一标识符,用于生成特定于文件的密钥分片

返回值:

  • [][]byte: 生成的密钥分片列表,每个元素为一个密钥分片
  • error: 生成过程中的错误信息,如果成功则为nil

func GenerateSecretFromPrivateKeyAndChecksum 

func GenerateSecretFromPrivateKeyAndChecksum(ownerPriv *ecdsa.PrivateKey, checksum []byte) ([]byte, error)

GenerateSecretFromPrivateKeyAndChecksum 使用私钥和文件校验和生成秘密

参数:

  • ownerPriv *ecdsa.PrivateKey: 文件所有者的私钥,用于生成秘密
  • checksum []byte: 文件的校验和,用于生成特定于文件的秘密

返回值:

  • []byte: 生成的秘密字节数组
  • error: 生成过程中的错误信息,如果成功则为nil

func GenerateSegmentID 

func GenerateSegmentID(fileID string, index int64) (string, error)

GenerateSegmentID 生成用于文件片段的SegmentID

参数:

  • fileID string: 文件的唯一标识符
  • index int64: 文件片段的索引

返回值:

  • string: 生成的SegmentID
  • error: 处理过程中发生的任何错误

func GenerateTaskID 

func GenerateTaskID(ownerPriv *ecdsa.PrivateKey) (string, error)

GenerateTaskID 生成任务ID 使用时间戳、私钥和随机数生成一个唯一的taskID

参数:

  • ownerPriv *ecdsa.PrivateKey: 所有者的私钥

返回值:

  • string: 生成的taskID
  • error: 处理过程中发生的任何错误

func GetAferoFileCRC32 

func GetAferoFileCRC32(file afero.File) (uint32, error)

GetAferoFileCRC32 计算文件的CRC32校验和 (afero.File版本) 参数:

  • file: 需要计算校验和的afero.File文件接口

返回值:

  • uint32: 文件的CRC32校验和
  • error: 计算过程中的错误信息

func GetAferoFileMIME 

func GetAferoFileMIME(file afero.File) (string, error)

GetAferoFileMIME 获取文件的MIME类型 (afero.File版本) 参数:

  • file: 需要获取MIME类型的afero.File文件接口

返回值:

  • string: 文件的MIME类型
  • error: 获取过程中的错误信息

func GetAferoFileModTime 

func GetAferoFileModTime(file afero.File) (time.Time, error)

GetAferoFileModTime 获取文件最后修改时间 (afero.File版本) 参数:

  • file: 需要获取修改时间的afero.File文件接口

返回值:

  • time.Time: 文件的最后修改时间
  • error: 获取过程中的错误信息

func GetAferoFileMode 

func GetAferoFileMode(file afero.File) (os.FileMode, error)

GetAferoFileMode 获取文件模式和权限 (afero.File版本) 参数:

  • file: 需要获取模式和权限的afero.File文件接口

返回值:

  • os.FileMode: 文件的模式和权限
  • error: 获取过程中的错误信息

func GetAferoFileName 

func GetAferoFileName(file afero.File) (string, error)

GetAferoFileName 获取文件名 (afero.File版本) 参数:

  • file: 需要获取文件名的afero.File文件接口

返回值:

  • string: 文件名
  • error: 获取过程中的错误信息

func GetAferoFileSHA256 

func GetAferoFileSHA256(file afero.File) ([]byte, error)

GetAferoFileSHA256 计算文件的SHA256哈希值 (afero.File版本) 参数:

  • file: 需要计算哈希值的afero.File文件接口

返回值:

  • []byte: 文件的SHA256哈希值
  • error: 计算过程中的错误信息

func GetAferoFileSize 

func GetAferoFileSize(file afero.File) (int64, error)

GetAferoFileSize 获取文件大小 (afero.File版本) 参数:

  • file: 需要获取大小的afero.File文件接口

返回值:

  • int64: 文件大小(字节)
  • error: 获取过程中的错误信息

func GetAferoFileSys 

func GetAferoFileSys(file afero.File) (interface{}, error)

GetAferoFileSys 获取底层系统特定的文件信息 (afero.File版本) 参数:

  • file: 需要获取系统信息的afero.File文件接口

返回值:

  • interface{}: 系统特定的文件信息
  • error: 获取过程中的错误信息

func GetBytesCRC32 

func GetBytesCRC32(data []byte) uint32

GetBytesCRC32 计算字节切片的CRC32校验和 参数:

  • data: 需要计算校验和的字节切片

返回值:

  • uint32: 字节切片的CRC32校验和

func GetBytesSHA256 

func GetBytesSHA256(data []byte) []byte

GetBytesSHA256 计算字节切片的SHA256哈希值 参数:

  • data: 需要计算哈希值的字节切片

返回值:

  • []byte: 字节切片的SHA256哈希值

func GetFileCRC32 

func GetFileCRC32(file *os.File) (uint32, error)

GetFileCRC32 计算文件的CRC32校验和 (*os.File版本) 参数:

  • file: 需要计算校验和的文件指针

返回值:

  • uint32: 文件的CRC32校验和
  • error: 计算过程中的错误信息

func GetFileMIME 

func GetFileMIME(file *os.File) (string, error)

GetFileMIME 获取文件的MIME类型 (*os.File版本) 参数:

  • file: 需要获取MIME类型的文件指针

返回值:

  • string: 文件的MIME类型
  • error: 获取过程中的错误信息

func GetFileModTime 

func GetFileModTime(file *os.File) (time.Time, error)

GetFileModTime 获取文件最后修改时间 (*os.File版本) 参数:

  • file: 需要获取修改时间的文件指针

返回值:

  • time.Time: 文件的最后修改时间
  • error: 获取过程中的错误信息

func GetFileMode 

func GetFileMode(file *os.File) (os.FileMode, error)

GetFileMode 获取文件模式和权限 (*os.File版本) 参数:

  • file: 需要获取模式和权限的文件指针

返回值:

  • os.FileMode: 文件的模式和权限
  • error: 获取过程中的错误信息

func GetFileName 

func GetFileName(file *os.File) (string, error)

GetFileName 获取文件名 (*os.File版本) 参数:

  • file: 需要获取文件名的文件指针

返回值:

  • string: 文件名
  • error: 获取过程中的错误信息

func GetFileSHA256 

func GetFileSHA256(file *os.File) ([]byte, error)

GetFileSHA256 计算文件的SHA256哈希值 (*os.File版本) 参数:

  • file: 需要计算哈希值的文件指针

返回值:

  • []byte: 文件的SHA256哈希值
  • error: 计算过程中的错误信息

func GetFileSize 

func GetFileSize(file *os.File) (int64, error)

GetFileSize 获取文件大小 (*os.File版本) 参数:

  • file: 需要获取大小的文件指针

返回值:

  • int64: 文件大小(字节)
  • error: 获取过程中的错误信息

func GetFileSys 

func GetFileSys(file *os.File) (interface{}, error)

GetFileSys 获取底层系统特定的文件信息 (*os.File版本) 参数:

  • file: 需要获取系统信息的文件指针

返回值:

  • interface{}: 系统特定的文件信息
  • error: 获取过程中的错误信息

func HashPublicKey 

func HashPublicKey(pubKeyBytes []byte) []byte

HashPublicKey 将公钥字节进行SHA-256和RIPEMD-160双重哈希

参数:

  • pubKeyBytes []byte: 公钥的字节表示

返回值:

  • []byte: 公钥的双重哈希值

func IsAferoFileDir 

func IsAferoFileDir(file afero.File) (bool, error)

IsAferoFileDir 判断是否为目录 (afero.File版本) 参数:

  • file: 需要判断的afero.File文件接口

返回值:

  • bool: 是否为目录
  • error: 判断过程中的错误信息

func IsFileDir 

func IsFileDir(file *os.File) (bool, error)

IsFileDir 判断是否为目录 (*os.File版本) 参数:

  • file: 需要判断的文件指针

返回值:

  • bool: 是否为目录
  • error: 判断过程中的错误信息

func IsRetryable 

func IsRetryable(err error) bool

IsRetryable 判断错误是否可重试 参数：

  • err: 要判断的错误

返回值：

  • bool: 是否可以重试该错误

func JoinStrings 

func JoinStrings(strs ...string) string

JoinStrings 函数将任意数量的字符串参数组合成一个单一的字符串

参数:

  • strs ...string: 要组合的字符串列表

返回值:

  • string: 组合后的字符串

func MarshalPrivateKey 

func MarshalPrivateKey(privateKey *ecdsa.PrivateKey) ([]byte, error)

MarshalPrivateKey 将ECDSA私钥序列化为字节表示

参数:

  • privateKey *ecdsa.PrivateKey: 输入的ECDSA私钥

返回值:

  • []byte: 私钥的字节序列
  • error: 失败时的错误信息

func MarshalPublicKey 

func MarshalPublicKey(publicKey ecdsa.PublicKey) []byte

MarshalPublicKey 将ECDSA公钥序列化为字节表示

参数:

  • publicKey ecdsa.PublicKey: 输入的ECDSA公钥

返回值:

  • []byte: 公钥的字节序列

func MergeFieldsForSigning 

func MergeFieldsForSigning(fields ...interface{}) ([]byte, error)

MergeFieldsForSigning 接受任意数量和类型的字段，将它们序列化并合并为一个 []byte

参数:

  • fields ...interface{}: 任意数量和类型的字段

返回值:

  • []byte: 合并后的字节切片
  • error: 处理过程中发生的任何错误

func PrivateKeyBytesToPublicKeyHash 

func PrivateKeyBytesToPublicKeyHash(privateKeyBytes []byte) ([]byte, error)

PrivateKeyBytesToPublicKeyHash 通过私钥字节生成公钥哈希

参数:

  • privateKeyBytes []byte: 输入的私钥字节

返回值:

  • []byte: 生成的公钥哈希
  • error: 如果在处理过程中发生错误，返回相应的错误信息

func PrivateKeyToPublicKeyHash 

func PrivateKeyToPublicKeyHash(privateKey *ecdsa.PrivateKey) ([]byte, bool)

PrivateKeyToPublicKeyHash 通过私钥生成公钥哈希

参数:

  • privateKey *ecdsa.PrivateKey: 输入的ECDSA私钥

返回值:

  • []byte: 生成的公钥哈希
  • bool: 操作是否成功

func Read 

func Read(opt *fscfg.Options, afe afero.Afero, subDir, fileName string) ([]byte, error)

Read 从指定的文件读取数据 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • subDir: string 类型，子目录路径
  • fileName: string 类型，文件名

返回值:

  • []byte: 读取的文件内容
  • error: 如果读取过程中发生错误，返回相应的错误信息

func RecoverSecretFromShares 

func RecoverSecretFromShares(shareOne, shareTwo []byte) ([]byte, error)

RecoverSecretFromShares 从密钥分片中恢复原始密钥

参数:

  • shareOne []byte: 第一个密钥分片,用于恢复原始密钥
  • shareTwo []byte: 第二个密钥分片,用于恢复原始密钥

返回值:

  • []byte: 恢复的原始密钥数据
  • error: 恢复过程中的错误信息,如果成功则为nil

func RenameFile 

func RenameFile(opt *fscfg.Options, afe afero.Afero, oldSubDir, oldFileName, newSubDir, newFileName string) error

RenameFile 重命名或移动文件 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • oldSubDir: string 类型，原文件子目录路径
  • oldFileName: string 类型，原文件名
  • newSubDir: string 类型，新文件子目录路径
  • newFileName: string 类型，新文件名

返回值:

  • error: 如果重命名过程中发生错误，返回相应的错误信息

func SeparateHashFromData 

func SeparateHashFromData(combinedData []byte) ([]byte, []byte, error)

SeparateHashFromData 从数据中分离出SHA-256哈希值和原始数据

参数:

  • combinedData []byte: 包含哈希值和原始数据的字节切片

返回值:

  • []byte: 分离出的哈希值
  • []byte: 分离出的原始数据
  • error: 处理过程中发生的任何错误

func SerializeSliceTable 

func SerializeSliceTable(sliceTable map[int64]*pb.HashTable) ([]byte, error)

SerializeSliceTable 将 SliceTable 序列化为字节切片 参数:

  • sliceTable: map[int64]*HashTable 需要序列化的 SliceTable

返回值:

  • []byte: 序列化后的字节切片
  • error: 如果在序列化过程中发生错误，返回相应的错误信息

func SplitString 

func SplitString(combined string) ([]string, error)

SplitString 函数将一个组合过的字符串分割成原始的字符串数组

参数:

  • combined string: 要分割的组合字符串

返回值:

  • []string: 分割后的字符串数组
  • error: 处理过程中发生的任何错误

func ToBytes 

func ToBytes[T any](data T) ([]byte, error)

ToBytes 泛型函数，用于将不同类型的数据转换为 []byte

参数:

  • data T: 要转换的数据，类型为 T

返回值:

  • []byte: 转换后的字节切片
  • error: 处理过程中发生的任何错误

func UnmarshalPrivateKey 

func UnmarshalPrivateKey(privKeyBytes []byte) (*ecdsa.PrivateKey, error)

UnmarshalPrivateKey 将字节序列反序列化为ECDSA私钥

参数:

  • privKeyBytes []byte: 私钥的字节表示

返回值:

  • *ecdsa.PrivateKey: 反序列化后的ECDSA私钥
  • error: 失败时的错误信息

func UnmarshalPublicKey 

func UnmarshalPublicKey(pubKeyBytes []byte) (ecdsa.PublicKey, error)

UnmarshalPublicKey 将字节序列反序列化为ECDSA公钥

参数:

  • pubKeyBytes []byte: 公钥的字节表示

返回值:

  • ecdsa.PublicKey: 反序列化后的ECDSA公钥
  • error: 失败时的错误信息

func WalkFiles 

func WalkFiles(opt *fscfg.Options, afe afero.Afero, subDir string, callback func(filePath string, info os.FileInfo) error) error

WalkFiles 遍历指定目录下的文件并执行回调函数 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • subDir: string 类型，要遍历的子目录路径
  • callback: func(filePath string, info os.FileInfo) error 类型，对每个文件执行的回调函数

返回值:

  • error: 如果遍历过程中发生错误，返回相应的错误信息

func WithAsyncCleanup 

func WithAsyncCleanup(async bool) func(*GuardOption)

WithAsyncCleanup 设置是否异步清理 参数: - async: 是否启用异步清理 返回值: - func(*GuardOption): 返回一个修改配置的函数

func WithAutoTuneGC 

func WithAutoTuneGC(enable bool) func(*MemoryConfig)

WithAutoTuneGC 设置是否自动调整GC 参数：

  • enable: 是否启用

返回值：

  • func(*MemoryConfig): 配置函数

func WithBackoff 

func WithBackoff(backoff time.Duration) func(*MutexConfig)

WithBackoff 设置重试间隔配置选项 参数：

  • backoff: 重试间隔

返回值：

  • func(*MutexConfig): 配置函数

func WithCleanupInterval 

func WithCleanupInterval(interval time.Duration) func(*GuardOption)

WithCleanupInterval 设置清理间隔时间 参数: - interval: 新的清理间隔时间 返回值: - func(*GuardOption): 返回一个修改配置的函数

func WithCriticalThreshold 

func WithCriticalThreshold(threshold float64) func(*MemoryConfig)

WithCriticalThreshold 设置危险阈值 参数：

  • threshold: 危险阈值(0.0-1.0)

返回值：

  • func(*MemoryConfig): 配置函数

func WithGuardCleanupInterval 

func WithGuardCleanupInterval(interval time.Duration) func(*GuardOption)

WithGuardCleanupInterval 设置资源守卫的清��间隔时间 参数: - interval: 新的清理间隔时间 返回值: - func(*GuardOption): 返回一个修改配置的函数

func WithGuardCriticalThreshold 

func WithGuardCriticalThreshold(threshold float64) func(*GuardOption)

WithGuardCriticalThreshold 设置资源守卫的内存临界阈值 参数: - threshold: 新的内存临界阈值(0.0-1.0) 返回值: - func(*GuardOption): 返回一个修改配置的函数

func WithGuardMonitorInterval 

func WithGuardMonitorInterval(interval time.Duration) func(*GuardOption)

WithGuardMonitorInterval 设置资源守卫的监控间隔时间 参数: - interval: 新的监控间隔时间 返回值: - func(*GuardOption): 返回一个修改配置的函数

func WithInitialBackoff 

func WithInitialBackoff(backoff time.Duration) func(*RetryConfig)

WithInitialBackoff 设置初始重试等待时间 参数：

  • backoff: 初始重试等待时间

返回值：

  • func(*RetryConfig): 配置函数

func WithMaxBackoff 

func WithMaxBackoff(maxBackoff time.Duration) func(*RetryConfig)

WithMaxBackoff 设置最大重试等待时间 参数：

  • maxBackoff: 最大重试等待时间

返回值：

  • func(*RetryConfig): 配置函数

func WithMaxElapsed 

func WithMaxElapsed(maxElapsed time.Duration) func(*RetryConfig)

WithMaxElapsed 设置最大总耗时 参数：

  • maxElapsed: 最大总耗时

返回值：

  • func(*RetryConfig): 配置函数

func WithMaxRetries 

func WithMaxRetries(maxRetries int) func(*RetryConfig)

WithMaxRetries 设置最大重试次数 参数：

  • maxRetries: 最大重试次数

返回值：

  • func(*RetryConfig): 配置函数

func WithMaxWorkers 

func WithMaxWorkers(max int) func(*ControllerOption)

WithMaxWorkers 设置最大工作协程数 参数:

  • max: 最大工作协程数

返回值:

  • func(*ControllerOption): 配置函数

func WithMemoryThreshold 

func WithMemoryThreshold(threshold float64) func(*GuardOption)

WithMemoryThreshold 设置内���警告阈值 参数: - threshold: 新的内存警告阈值 返回值: - func(*GuardOption): 返回一个修改配置的函数

func WithMinWorkers 

func WithMinWorkers(min int) func(*ControllerOption)

WithMinWorkers 设置最小工作协程数 参数:

  • min: 最小工作协程数

返回值:

  • func(*ControllerOption): 配置函数

func WithMonitorInterval 

func WithMonitorInterval(interval time.Duration) func(*MemoryConfig)

WithMonitorInterval 设置监控间隔 参数：

  • interval: 监控间隔时间

返回值：

  • func(*MemoryConfig): 配置函数

func WithOnRetry 

func WithOnRetry(onRetry func(attempt int, err error)) func(*RetryConfig)

WithOnRetry 设置重试回调函数 参数：

  • onRetry: 重试回调函数

返回值：

  • func(*RetryConfig): 配置函数

func WithQueueSize 

func WithQueueSize(size int) func(*ControllerOption)

WithQueueSize 设置队列大小 参数:

  • size: 队列大小

返回值:

  • func(*ControllerOption): 配置函数

func WithRetries 

func WithRetries(retries int) func(*MutexConfig)

WithRetries 设置重试次数配置选项 参数：

  • retries: 重试次数

返回值：

  • func(*MutexConfig): 配置函数

func WithTimeout 

func WithTimeout(timeout time.Duration) func(*MutexConfig)

WithTimeout 设置超时时间配置选项 参数：

  • timeout: 超时时间

返回值：

  • func(*MutexConfig): 配置函数

func WithWarningThreshold 

func WithWarningThreshold(threshold float64) func(*MemoryConfig)

WithWarningThreshold 设置警告阈值 参数：

  • threshold: 警告阈值(0.0-1.0)

返回值：

  • func(*MemoryConfig): 配置函数

func Write 

func Write(opt *fscfg.Options, afe afero.Afero, subDir, fileName string, data *[]byte) error

Write 写入数据到指定的文件 参数:

  • opt: *fscfg.Options 类型，包含文件系统配置选项
  • afe: afero.Afero 类型，文件系统接口
  • subDir: string 类型，子目录路径
  • fileName: string 类型，文件名
  • data: *[]byte 类型，要写入的数据的指针

返回值:

  • error: 如果写入过程中发生错误，返回相应的错误信息

Types

type ConcurrencyController 

type ConcurrencyController struct {
	// contains filtered or unexported fields
}

ConcurrencyController 并发控制器结构体

func NewController 

func NewController(opts ...func(*ControllerOption)) (*ConcurrencyController, error)

NewController 创建新的并发控制器 参数:

  • opts: 配置选项函数列表

返回值:

  • *ConcurrencyController: 新创建的控制器实例
  • error: 创建过程中的错误

func (*ConcurrencyController) ExecuteTaskWithPriority 

func (cc *ConcurrencyController) ExecuteTaskWithPriority(
	ctx context.Context,
	handler TaskHandler,
	taskID int64,
	priority TaskPriority,
	metadata map[string]interface{},
) error

ExecuteTaskWithPriority 执行带优先级的任务 参数:

  • ctx: 上下文
  • handler: 任务处理函数
  • taskID: 任务ID
  • priority: 任务优先级
  • metadata: 任务元数据

返回值:

  • error: 执行错误

func (*ConcurrencyController) GetMetrics 

func (cc *ConcurrencyController) GetMetrics() (*ExtendedMetrics, error)

GetMetrics 获取指标 返回值:

  • *ExtendedMetrics: 指标统计信息
  • error: 获取错误

func (*ConcurrencyController) Stop 

func (cc *ConcurrencyController) Stop() error

Stop 停止控制器 返回值:

  • error: 停止错误

type ControllerError 

type ControllerError struct {
	Code    int    // 错误码
	Message string // 错误信息
	Err     error  // 原始错误
}

ControllerError 定义错误类型

func NewError 

func NewError(code int, message string, err error) *ControllerError

NewError 创建新的控制器错误 参数:

  • code: 错误码
  • message: 错误信息
  • err: 原始错误

返回值:

  • *ControllerError: 新创建的错误实例

func (*ControllerError) Error 

func (e *ControllerError) Error() string

Error 实现error接口 返回值:

  • string: 格式化的错误信息

type ControllerOption 

type ControllerOption struct {
	MaxWorkers      int           // 最大工作协程数
	MinWorkers      int           // 最小工作协程数
	QueueSize       int           // 队列大小
	RetryTimes      int           // 重试次数
	TaskTimeout     time.Duration // 任务超时时间
	ShutdownTimeout time.Duration // 关闭超时时间
	MetricsInterval time.Duration // 指标收集间隔
	CleanupInterval time.Duration // 清理间隔
}

ControllerOption 定义控制器配置选项

func DefaultOption 

func DefaultOption() *ControllerOption

DefaultOption 返回默认配置选项 返回值:

  • *ControllerOption: 默认配置选项实例

type ExtendedMetrics 

type ExtendedMetrics struct {
	WorkerMetrics                 // 基础指标
	QueueLatency    time.Duration // 队列延迟
	PriorityMetrics map[TaskPriority]struct {
		Count      int64         // 任务数量
		AvgLatency time.Duration // 平均延迟
	}
	ErrorCounts   map[string]int64     // 错误计数
	TasksByStatus map[TaskStatus]int64 // 各状态任务数量
}

ExtendedMetrics 扩展的指标统计

type GuardOption 

type GuardOption struct {
	MemoryThreshold   float64       // 内存使用警告阈值,当内存使用率超过此值时发出警告
	CriticalThreshold float64       // 内存使用临界阈值,当内存使用率超过此值触发强制GC
	GCInterval        time.Duration // GC间隔时间,定期触发GC的时间间隔
	MaxRetries        int           // 最大重试次数,资源释放失败时的最大重试次数
	RetryBackoff      time.Duration // 重试等待时间,重试之间的等待时间
	MaxBackoff        time.Duration // 最大重试等待时间,重试等待时间的上限
	MonitorInterval   time.Duration // 监控间隔时间,资源监控的时间间隔
	CleanupInterval   time.Duration // 清理间隔时间,定期清理的时间间隔
	AsyncCleanup      bool          // 是否异步清理,true表示异步清理,false表示同步清理
}

GuardOption 定义资源守卫配置选项

func DefaultGuardOption 

func DefaultGuardOption() *GuardOption

DefaultGuardOption 返回默认配置选项 返回值: - *GuardOption: 包含默认配置值的GuardOption对象

type MemoryConfig 

type MemoryConfig struct {
	WarningThreshold  float64       // 内存使用预警阈值（默认80%）
	CriticalThreshold float64       // 内存使用危险阈值（默认90%）
	MinGCInterval     time.Duration // 最小GC间隔（默认1秒）
	MaxGCTimeout      time.Duration // 最大GC超时时间（默认30秒）
	AutoTuneGC        bool          // 是否自动调整GC（默认true）
	MonitorInterval   time.Duration // 监控间隔（默认5秒）
}

MemoryConfig 内存管理器配置

func DefaultMemoryConfig 

func DefaultMemoryConfig() *MemoryConfig

DefaultMemoryConfig 返回默认配置 返回值：

  • *MemoryConfig: 默认配置对象

type MemoryLevel 

type MemoryLevel int

MemoryLevel 内存使用级别 

const (
	MemoryLevelNormal   MemoryLevel = iota // 正常
	MemoryLevelWarning                     // 警告
	MemoryLevelCritical                    // 危险
)

内存使用级别常量定义

type MemoryManager 

type MemoryManager struct {
	// contains filtered or unexported fields
}

MemoryManager 内存管理器

func NewMemoryManager 

func NewMemoryManager(opts ...func(*MemoryConfig)) (*MemoryManager, error)

NewMemoryManager 创建新的内存管理器 参数：

  • opts: 配置选项函数列表

返回值：

  • *MemoryManager: 内存管理器实例
  • error: 创建过程中的错误

func (*MemoryManager) GetMemoryStats 

func (mm *MemoryManager) GetMemoryStats() (*MemoryMetrics, error)

GetMemoryStats 获取内存统计信息 返回值：

  • *MemoryMetrics: 内存统计信息
  • error: 获取过程中的错误

func (*MemoryManager) GetMetrics 

func (mm *MemoryManager) GetMetrics() *MemoryMetrics

GetMetrics 获取内存指标 返回值：

  • *MemoryMetrics: 当前内存指标快照

func (*MemoryManager) Stop 

func (mm *MemoryManager) Stop()

Stop 停止内存管理器

func (*MemoryManager) TriggerGC 

func (mm *MemoryManager) TriggerGC()

TriggerGC 触发垃圾回收

type MemoryManagerInterface 

type MemoryManagerInterface interface {
	GetMemoryStats() (*MemoryMetrics, error) // 获取内存统计
	TriggerGC()                              // 触发GC
}

MemoryManagerInterface 定义内存管理器接口

type MemoryMetrics 

type MemoryMetrics struct {
	UsedPercent    float64       // 内存使用百分比
	UsedBytes      uint64        // 已用内存字节数
	TotalBytes     uint64        // 总内存字节数
	Level          MemoryLevel   // 内存使用级别
	GCCount        int64         // GC次数
	TotalGCTime    time.Duration // 总GC时间
	AverageGCPause time.Duration // 平均GC暂停时间
	MaxGCPause     time.Duration // 最大GC暂停时间
	LastGCTime     time.Time     // 上次GC时间
	LastGCDuration time.Duration // 上次GC持续时间
}

MemoryMetrics 内存指标统计

type MutexConfig 

type MutexConfig struct {
	Timeout time.Duration // 锁超时时间
	Retries int           // 重试次数
	Backoff time.Duration // 重试间隔
}

MutexConfig 互斥锁配置

func DefaultMutexConfig 

func DefaultMutexConfig() *MutexConfig

DefaultMutexConfig 返回默认配置 返回值：

  • *MutexConfig: 默认配置对象

type NewAferoFsInput 

type NewAferoFsInput struct {
	fx.In
}

NewAferoFsInput 是用于传递给 NewAferoFs 函数的输入结构体。

type NewAferoFsOutput 

type NewAferoFsOutput struct {
	fx.Out

	Fs afero.Afero
}

NewAferoFsOutput 是 NewAferoFs 函数的输出结构体。

func NewAferoFs 

func NewAferoFs(lc fx.Lifecycle, input NewAferoFsInput) (out NewAferoFsOutput, err error)

NewAferoFs 创建并返回一个新的 afero.Afero 实例 参数:

  • lc: fx.Lifecycle 对象，用于管理生命周期
  • input: NewAferoFsInput 结构体，包含输入参数

返回值:

  • out: NewAferoFsOutput 结构体，包含输出结果
  • err: 错误信息，如果没有错误则为 nil

type ResourceGuard 

type ResourceGuard struct {
	// contains filtered or unexported fields
}

ResourceGuard 资源守卫实现

func NewResourceGuard 

func NewResourceGuard(memManager MemoryManagerInterface, opts ...func(*GuardOption)) *ResourceGuard

NewResourceGuard 创建新的资源守卫 参数: - memManager: 内存管理器实例 - opts: 可选的配置选项函数列表 返回值: - *ResourceGuard: 新创建的资源守卫实例

func (*ResourceGuard) AcquireResources 

func (g *ResourceGuard) AcquireResources(ctx context.Context) error

AcquireResources 获取资源(非阻塞) 参数: - ctx: 上下文对象,用于传递取消信号 返回值: - error: 获取资源过程中的错误,如果成功则返回nil

func (*ResourceGuard) CleanupResources 

func (g *ResourceGuard) CleanupResources(files []*os.File, removeFile bool) error

CleanupResources 清理资源列表 参数: - files: 需要清理的文件列表 - removeFile: 是否同时删除文件 返回值: - error: 清理过程中的错误,如果成功则返回nil

func (*ResourceGuard) GetStats 

func (g *ResourceGuard) GetStats() *ResourceStats

GetStats 获取资源统计信息 返回值: - *ResourceStats: 当前的资源统计信息

func (*ResourceGuard) ReleaseResources 

func (g *ResourceGuard) ReleaseResources() error

ReleaseResources 释放资源 返回值: - error: 释放资源过程中的错误,如果成功则返回nil

func (*ResourceGuard) Stop 

func (g *ResourceGuard) Stop()

Stop 停止资源守卫

type ResourceStats 

type ResourceStats struct {
	TotalResources    int64         // 总资源数,记录所有已申请的资源数量
	ActiveResources   int64         // 活跃资源数,当前正在使用的资源数量
	ReleasedResources int64         // 已释放资源数,已成功释放的资源数量
	LastReleaseTime   time.Time     // 上次资源释放时间,最近一次资源释放的时间点
	TotalReleaseTime  time.Duration // 总释放时间,所有资源释放操作耗费的总时间
	FailedReleases    int64         // 释放失败次数,资源释放失败的总次数
	LastError         error         // 最后一次错误,最近一次操作发生的错误
	MemoryUsage       float64       // 当前内存使用率,系统当前内存使用百分比
}

ResourceStats 资源统计信息

type RetryConfig 

type RetryConfig struct {
	MaxRetries     int                          // 最大重试次数
	InitialBackoff time.Duration                // 初始重试等待时间
	MaxBackoff     time.Duration                // 最大重试等待时间
	MaxElapsed     time.Duration                // 最大总耗时
	OnRetry        func(attempt int, err error) // 重试回调函数
}

RetryConfig 重试配置

func DefaultRetryConfig 

func DefaultRetryConfig() *RetryConfig

DefaultRetryConfig 返回默认重试配置 返回值：

  • *RetryConfig: 默认配置对象

type RetryableOperation 

type RetryableOperation struct {
	// contains filtered or unexported fields
}

RetryableOperation 可重试操作结构体

func NewRetryableOperation 

func NewRetryableOperation(opts ...func(*RetryConfig)) (*RetryableOperation, error)

NewRetryableOperation 创建新的可重试操作实例 参数：

  • opts: 配置选项函数列表

返回值：

  • *RetryableOperation: 可重试操作实例
  • error: 创建过程中的错误

func (*RetryableOperation) Execute 

func (ro *RetryableOperation) Execute(ctx context.Context, op func() error) error

Execute 执行可重试操作 参数：

  • ctx: 上下文，用于取消操作
  • op: 要执行的操作函数

返回值：

  • error: 执行过程中的错误

func (*RetryableOperation) ExecuteWithFallback 

func (ro *RetryableOperation) ExecuteWithFallback(
	ctx context.Context,
	op func() error,
	fallback func() error,
) error

ExecuteWithFallback 执行可重试操作，带有降级处理 参数：

  • ctx: 上下文，用于取消操作
  • op: 主要操作函数
  • fallback: 降级操作函数

返回值：

  • error: 执行过程中的错误

type SafeRWMutex 

type SafeRWMutex struct {
	sync.RWMutex // 内嵌标准读写锁
	// contains filtered or unexported fields
}

SafeRWMutex 安全的读写锁结构体

func NewSafeRWMutex 

func NewSafeRWMutex(opts ...func(*MutexConfig)) (*SafeRWMutex, error)

NewSafeRWMutex 创建新的安全读写锁 参数：

  • opts: 配置选项函数列表

返回值：

  • *SafeRWMutex: 安全读写锁实例
  • error: 创建过程中的错误

func (*SafeRWMutex) LockWithDeadline 

func (m *SafeRWMutex) LockWithDeadline(deadline time.Time) error

LockWithDeadline 在指定截止时间前获取写锁 参数：

  • deadline: 截止时间

返回值：

  • error: 获取锁过程中的错误

func (*SafeRWMutex) LockWithRetry 

func (m *SafeRWMutex) LockWithRetry(ctx context.Context) error

LockWithRetry 带重试机制的写锁获取 参数：

  • ctx: 上下文，用于取消操作

返回值：

  • error: 获取锁过程中的错误

func (*SafeRWMutex) RLockWithDeadline 

func (m *SafeRWMutex) RLockWithDeadline(deadline time.Time) error

RLockWithDeadline 在指定截止时间前获取读锁 参数：

  • deadline: 截止时间

返回值：

  • error: 获取锁过程中的错误

func (*SafeRWMutex) RLockWithRetry 

func (m *SafeRWMutex) RLockWithRetry(ctx context.Context) error

RLockWithRetry 带重试机制的读锁获取 参数：

  • ctx: 上下文，用于取消操作

返回值：

  • error: 获取锁过程中的错误

func (*SafeRWMutex) TryLockTimeout 

func (m *SafeRWMutex) TryLockTimeout(ctx context.Context) error

TryLockTimeout 尝试在指定时间内获取写锁 参数：

  • ctx: 上下文，用于取消操作

返回值：

  • error: 获取锁过程中的错误

func (*SafeRWMutex) TryRLockTimeout 

func (m *SafeRWMutex) TryRLockTimeout(ctx context.Context) error

TryRLockTimeout 尝试在指定时间内获取读锁 参数：

  • ctx: 上下文，用于取消操作

返回值：

  • error: 获取锁过程中的错误

type SegmentDistribution 

type SegmentDistribution struct {
	// contains filtered or unexported fields
}

SegmentDistribution 分片分配管理器 用于管理文件分片在不同节点间的分配关系

func NewSegmentDistribution 

func NewSegmentDistribution() *SegmentDistribution

NewSegmentDistribution 创建新的分片分配管理器 返回值:

  • *SegmentDistribution: 初始化后的分片分配管理器实例

func (*SegmentDistribution) AddDistribution 

func (sd *SegmentDistribution) AddDistribution(distribution map[peer.ID][]string)

AddDistribution 添加分片分配映射 参数:

  • distribution: map[peer.ID][]string 节点ID到分片ID列表的映射

func (*SegmentDistribution) Clear 

func (sd *SegmentDistribution) Clear()

Clear 清空分片分配列表 移除所有已添加的分配信息

func (*SegmentDistribution) GetLength 

func (sd *SegmentDistribution) GetLength() int

GetLength 获取当前列表长度 返回值:

  • int: 当前列表中的元素数量

func (*SegmentDistribution) GetNextDistribution 

func (sd *SegmentDistribution) GetNextDistribution() (map[peer.ID][]string, bool)

GetNextDistribution 获取并移除下一个待处理的分配 返回值:

  • map[peer.ID][]string: 下一个待处理的节点分片映射
  • bool: 是否成功获取到分配信息

type TaskHandler 

type TaskHandler func(context.Context, *TaskInfo) error

TaskHandler 定义任务处理函数的类型

type TaskInfo 

type TaskInfo struct {
	TaskID       int64                  // 任务ID
	Status       TaskStatus             // 任务状态
	Priority     TaskPriority           // 任务优先级
	CreateTime   time.Time              // 创建时间
	StartTime    time.Time              // 开始时间
	EndTime      time.Time              // 结束时间
	RetryCount   int32                  // 重试次数
	ErrorMessage string                 // 错误信息
	Metadata     map[string]interface{} // 元数据
	// contains filtered or unexported fields
}

TaskInfo 存储任务的详细信息

type TaskPriority 

type TaskPriority int

TaskPriority 定义任务优先级类型 

const (
	PriorityLow      TaskPriority = iota // 低优先级
	PriorityNormal                       // 普通优先级
	PriorityHigh                         // 高优先级
	PriorityCritical                     // 关键优先级
)

任务优先级常量定义

type TaskStatus 

type TaskStatus int32

TaskStatus 定义任务状态类型 

const (
	TaskStatusPending  TaskStatus = iota // 等待中
	TaskStatusRunning                    // 运行中
	TaskStatusComplete                   // 已完成
	TaskStatusFailed                     // 已失败
)

任务状态常量定义

type WorkerMetrics 

type WorkerMetrics struct {
	TotalTasks     int64         // 总任务数
	CompletedTasks int64         // 已完成任务数
	FailedTasks    int64         // 失败任务数
	ProcessingTime time.Duration // 处理时间
	MaxProcessTime time.Duration // 最大处理时间
	MinProcessTime time.Duration // 最小处理时间
	AvgProcessTime time.Duration // 平均处理时间
	RetryCount     int64         // 重试次数
	QueueLength    int32         // 队列长度
}

WorkerMetrics 基础指标统计

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.