process

package module
v0.0.0-...-96ed590 Latest Latest
Warning

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

 Go to latest Published: Dec 25, 2024 License: MIT Imports: 18 Imported by: 0

README

Process 进程管理库

Go Reference Go Report Card MIT License

Process 是一个用 Go 语言编写的轻量级进程管理库，提供了完整的进程生命周期管理功能，支持自动重启、日志管理、信号控制等特性。同时提供了 Web API 扩展，可以轻松集成到 HTTP 或 Gin 等 Web 框架中。

特性

  • 完整的进程生命周期管理
  • 支持自动重启策略
  • 标准输出和错误输出日志管理
  • 灵活的进程启动配置
  • 多平台支持 (Linux、Darwin、Windows)
  • Web API 扩展支持
  • 优雅的进程重启机制
  • 进程状态监控
  • 支持用户权限控制
  • 支持环境变量配置

安装

go get github.com/darkit/process

基础使用

创建进程管理器
import "github.com/darkit/process"

// 创建进程管理器
manager := process.NewManager()
创建和管理进程
// 方式1：使用选项创建进程
proc, err := manager.NewProcess(
    process.WithName("myapp"),
    process.WithCommand("./myapp"),
    process.WithArgs("--config", "config.yaml"),
    process.WithDirectory("/app"),
    process.WithAutoStart(true),
    process.WithAutoReStart(process.AutoReStartTrue),
    process.WithStdoutLog("logs/stdout.log", "50MB", 10),
    process.WithStderrLog("logs/stderr.log", "50MB", 10),
)

// 方式2：直接使用命令创建进程
proc, err := manager.NewProcessCmd("python app.py", nil)

// 启动进程
proc.Start(true)  // true 表示阻塞等待进程启动

// 停止进程
proc.Stop(true)   // true 表示阻塞等待进程停止

// 获取进程信息
info := proc.GetProcessInfo()
进程配置选项
  • WithName(name string) - 设置进程名称
  • WithCommand(cmd string) - 设置启动命令
  • WithArgs(args ...string) - 设置启动参数
  • WithDirectory(dir string) - 设置工作目录
  • WithAutoStart(auto bool) - 设置是否自动启动
  • WithAutoReStart(restart AutoReStart) - 设置自动重启策略
  • WithUser(user string) - 设置运行用户
  • WithEnvironment(env map[string]string) - 设置环境变量
  • WithStdoutLog(file string, maxBytes string, backups int) - 设置标准输出日志
  • WithStderrLog(file string, maxBytes string, backups int) - 设置错误输出日志
  • WithStartRetries(retries int) - 设置启动重试次数
  • WithStartSecs(secs int) - 设置启动超时时间
  • WithStopWaitSecs(secs int) - 设置停止等待时间
  • WithPriority(priority int) - 设置启动优先级

Web API 扩展使用

Process 库提供了 Web API 扩展功能，支持通过 HTTP 接口管理进程。支持原生 HTTP 和 Gin 框架。

HTTP Server 示例
import (
    "github.com/darkit/process"
    "github.com/darkit/process/handlers"
)

func main() {
    // 创建进程管理器
    manager := process.NewManager()

    // 创建 HTTP 处理器
    handler := handlers.NewProcessHandler(manager, func(h http.HandlerFunc) http.HandlerFunc {
        return h
    })

    // 获取处理器接口
    httpHandlers := handler.GetHandlers()

    // 设置路由
    mux := http.NewServeMux()
    mux.HandleFunc("/processes", httpHandlers.ListProcesses())
    mux.HandleFunc("/process/create", httpHandlers.CreateProcess())
    mux.HandleFunc("/process/delete", httpHandlers.DeleteProcess())
    mux.HandleFunc("/process/start", httpHandlers.StartProcess())
    mux.HandleFunc("/process/stop", httpHandlers.StopProcess())
    mux.HandleFunc("/process/restart", httpHandlers.RestartProcess())
    mux.HandleFunc("/process/stdout", httpHandlers.GetStdoutLog())
    mux.HandleFunc("/process/stderr", httpHandlers.GetStderrLog())

    // 启动服务器
    http.ListenAndServe(":8080", mux)
}
Gin 框架集成示例
import (
    "github.com/gin-gonic/gin"
    "github.com/darkit/process"
    "github.com/darkit/process/handlers"
)

func main() {
    // 创建进程管理器
    manager := process.NewManager()

    // 创建 Gin 处理器
    handler := handlers.NewProcessHandler(manager, func(h http.HandlerFunc) gin.HandlerFunc {
        return func(c *gin.Context) {
            h(c.Writer, c.Request)
        }
    })

    // 获取处理器接口
    ginHandlers := handler.GetHandlers()

    // 创建 Gin 路由
    r := gin.Default()
    
    // 设置路由
    r.GET("/processes", ginHandlers.ListProcesses())
    r.POST("/process/create", ginHandlers.CreateProcess())
    r.DELETE("/process/delete", ginHandlers.DeleteProcess())
    r.POST("/process/start", ginHandlers.StartProcess())
    r.POST("/process/stop", ginHandlers.StopProcess())
    r.POST("/process/restart", ginHandlers.RestartProcess())
    r.GET("/process/stdout", ginHandlers.GetStdoutLog())
    r.GET("/process/stderr", ginHandlers.GetStderrLog())

    // 启动服务器
    r.Run(":8080")
}
Web API 接口说明
接口 方法 描述
/processes GET 获取所有进程列表
/process/create POST 创建新进程
/process/delete DELETE 删除指定进程
/process/start POST 启动指定进程
/process/stop POST 停止指定进程
/process/restart POST 重启指定进程
/process/stdout GET 获取标准输出日志
/process/stderr GET 获取错误输出日志
创建进程 POST 请求示例
{
    "name": "myapp",
    "command": "./myapp",
    "args": "--config config.yaml",
    "directory": "/app",
    "user": "appuser",
    "environment": "KEY1=value1\nKEY2=value2",
    "autoStart": true,
    "autoRestart": 1,
    "stdoutLogfile": "logs/stdout.log",
    "stderrLogfile": "logs/stderr.log"
}

许可证

本项目采用 MIT 许可证。详见 LICENSE 文件。

Documentation

Index

Constants

View Source 
const (
	Stopped  State = iota // Stopped 已停止
	Starting       = 10   // Starting 启动中
	Running        = 20   // Running 运行中
	Backoff        = 30   // Backoff 已挂起
	Stopping       = 40   // Stopping 停止中
	Exited         = 100  // Exited 已退出
	Fatal          = 200  // Fatal 启动失败
	Unknown        = 1000 // Unknown 未知状态
)

Variables

This section is empty.

Functions

func Reap 

func Reap()

Reap Normal entry point for the reaper code. Start reaping children in the 

background inside a goroutine.

func ReapZombie 

func ReapZombie()

ReapZombie 回收僵尸进程

func Start 

func Start(config Config)

Start Entry point for invoking the reaper code with a specific configuration. 

The config allows you to bypass the pid 1 checks, so handle with care.
The child processes are reaped in the background inside a goroutine.

Types

type AutoReStart 

type AutoReStart uint8

AutoReStart 定义自动重启类型 

const (
	AutoReStartUnexpected AutoReStart = iota
	AutoReStartTrue       AutoReStart = iota // 1
	AutoReStartFalse      AutoReStart = iota // 0
)

type Config 

type Config struct {
	Pid              int
	Options          int
	DisablePid1Check bool
}

type Info 

type Info struct {
	Name          string `json:"name"`
	Description   string `json:"description"`
	Start         int    `json:"start"`
	Stop          int    `json:"stop"`
	Now           int    `json:"now"`
	State         int    `json:"state"`
	StateName     string `json:"statename"`
	SpawnErr      string `json:"spawnerr"`
	ExitStatus    int    `json:"exitstatus"`
	Logfile       string `json:"logfile"`
	StdoutLogfile string `json:"stdout_logfile"`
	StderrLogfile string `json:"stderr_logfile"`
	Pid           int    `json:"pid"`
}

Info 进程的运行状态

type Logger 

type Logger interface {
	Infof(format string, args ...any)
	Debugf(format string, args ...any)
	Warnf(format string, args ...any)
	Errorf(format string, args ...any)
}

Logger 日志记录器接口

type Manager 

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

func NewManager 

func NewManager(logger ...Logger) *Manager

NewManager 创建进程管理器 logger: 日志记录器

func (*Manager) Add 

func (m *Manager) Add(name string, proc *Process)

Add 添加进程到Manager

func (*Manager) Clear 

func (m *Manager) Clear()

Clear 清除进程

func (*Manager) Find 

func (m *Manager) Find(name string) *Process

Find 根据进程名查询进程

func (*Manager) ForEachProcess 

func (m *Manager) ForEachProcess(procFunc func(p *Process))

ForEachProcess 迭代进程列表

func (*Manager) GetAllProcessInfo 

func (m *Manager) GetAllProcessInfo() ([]*Info, error)

GetAllProcessInfo 获取所有进程列表

func (*Manager) GetProcessInfo 

func (m *Manager) GetProcessInfo(name string) (*Info, error)

GetProcessInfo 获取所有进程信息

func (*Manager) GracefulReload 

func (m *Manager) GracefulReload(name string, wait bool) (bool, error)

GracefulReload 停止指定进程

func (*Manager) NewProcess 

func (m *Manager) NewProcess(opts ...WithOption) (*Process, error)

NewProcess 创建新的进程实例 opts: 配置对象

func (*Manager) NewProcessByOptions 

func (m *Manager) NewProcessByOptions(opts Options) (*Process, error)

NewProcessByOptions 创建进程 opts: 配置对象

func (*Manager) NewProcessByProcess 

func (m *Manager) NewProcessByProcess(proc *Process) (*Process, error)

NewProcessByProcess 创建进程 proc: Process对象

func (*Manager) NewProcessCmd 

func (m *Manager) NewProcessCmd(cmd string, environment map[string]string) (*Process, error)

NewProcessCmd 创建进程 cmd: 可执行文件路径及参数 environment: 环境变量

func (*Manager) Remove 

func (m *Manager) Remove(name string) *Process

Remove 从Manager移除进程

func (*Manager) StartProcess 

func (m *Manager) StartProcess(name string, wait bool) (bool, error)

StartProcess 启动指定进程

func (*Manager) StopAllProcesses 

func (m *Manager) StopAllProcesses()

StopAllProcesses 关闭所有进程

func (*Manager) StopProcess 

func (m *Manager) StopProcess(name string, wait bool) (bool, error)

StopProcess 停止指定进程

type Options 

type Options struct {
	Name         string      // 进程名称
	Command      string      // 启动命令
	Args         []string    // 启动参数
	Directory    string      // 进程运行目录
	AutoStart    bool        // 启动的时候自动该进程启动
	StartSecs    int         // 启动10秒后没有异常退出，就表示进程正常启动了，默认为1秒
	AutoReStart  AutoReStart // 程序退出后自动重启,可选值：[unexpected,true,false]，默认为unexpected，表示进程意外杀死后才重启
	ExitCodes    []int       // 进程退出的code值
	StartRetries int         // 启动失败自动重试次数，默认是3
	RestartPause int         // 进程重启间隔秒数，默认是0，表示不间隔
	User         string      // 用哪个用户启动进程，默认是父进程的所属用户
	Priority     int         // 进程启动优先级，默认999，值小的优先启动

	StdoutLogfile         string // 日志文件，不存在时 supervisord 会自动创建日志文件）
	StdoutLogFileMaxBytes int    // stdout 日志文件大小，默认50MB
	StdoutLogFileBackups  int    // stdout 日志文件备份数，默认是10
	RedirectStderr        bool   // 把stderr重定向到stdout，默认false
	StderrLogfile         string // 日志文件，进程启动后的标准错误写入该文件
	StderrLogFileMaxBytes int    // stderr 日志文件大小，默认50MB
	StderrLogFileBackups  int    // stderr 日志文件备份数，默认是10

	StopAsGroup              bool             // 默认为false,进程被杀死时，是否向这个进程组发送stop信号，包括子进程
	KillAsGroup              bool             // 默认为false，向进程组发送kill信号，包括子进程
	StopSignal               []string         // 结束进程发送的信号
	StopWaitSecs             int              // 发送结束进程的信号后等待的秒数
	KillWaitSecs             int              // 强杀进程等待秒数
	Environment              *utils.StrStrMap // 环境变量
	RestartWhenBinaryChanged bool             // 当进程的二进制文件有修改，是否需要重启,默认false
	ExtraFiles               []*os.File       // 继承主进程已经打开的文件列表
	Extend                   *utils.AnyAnyMap // 扩展参数
}

Options 进程配置选项

func NewOptions 

func NewOptions(opts ...WithOption) Options

NewOptions 创建进程启动配置

func (*Options) CreateCommand 

func (that *Options) CreateCommand() (*exec.Cmd, error)

CreateCommand 根据就配置生成cmd对象

type Process 

type Process struct {
	Manager *Manager // 进程管理对象
	// contains filtered or unexported fields
}

func NewProcess 

func NewProcess(opts ...WithOption) *Process

NewProcess 创建进程对象

func NewProcessByOptions 

func NewProcessByOptions(options Options) *Process

NewProcessByOptions 通过详细配置，创建进程对象

func NewProcessCmd 

func NewProcessCmd(cmd string, environment map[string]string) *Process

NewProcessCmd 按命令启动

func (*Process) Clone 

func (that *Process) Clone() (*Process, error)

Clone 进程

func (*Process) GetDescription 

func (that *Process) GetDescription() string

GetDescription 获取进程描述

func (*Process) GetExitStatus 

func (that *Process) GetExitStatus() int

GetExitStatus 获取进程退出状态

func (*Process) GetName 

func (that *Process) GetName() string

GetName 获取进程名

func (*Process) GetProcessInfo 

func (that *Process) GetProcessInfo() *Info

GetProcessInfo 获取进程的详情

func (*Process) GetStartTime 

func (that *Process) GetStartTime() time.Time

GetStartTime 获取进程启动时间

func (*Process) GetState 

func (that *Process) GetState() State

GetState 获取进程状态

func (*Process) GetStatus 

func (that *Process) GetStatus() string

GetStatus 获取进程当前状态

func (*Process) GetStderrLogfile 

func (that *Process) GetStderrLogfile() string

GetStderrLogfile 获取标准错误将要写入的日志文件

func (*Process) GetStdoutLogfile 

func (that *Process) GetStdoutLogfile() string

GetStdoutLogfile 获取标准输出将要写入的日志文件

func (*Process) GetStopTime 

func (that *Process) GetStopTime() time.Time

GetStopTime 获取进程结束时间

func (*Process) IsAutoStart 

func (that *Process) IsAutoStart() bool

IsAutoStart 在进程管理器启动的时候也自动启动

func (*Process) Pid 

func (that *Process) Pid() int

Pid 获取进程pid，返回0表示进程未启动

func (*Process) Signal 

func (that *Process) Signal(sig os.Signal, sigChildren bool) error

Signal 向进程发送信号 sig: 要发送的信号 sigChildren: 如果为true，则信号会发送到该进程的子进程

func (*Process) Start 

func (that *Process) Start(wait bool)

Start 启动进程，wait表示阻塞等待进程启动成功

func (*Process) Stop 

func (that *Process) Stop(wait bool)

Stop 主动停止进程

type State 

type State int

func (State) String 

func (p State) String() string

String 把进程状态转换成可识别的字符串

type WithOption 

type WithOption func(*Options)

WithOption 定义选项函数类型

func WithArgs 

func WithArgs(opt ...string) WithOption

WithArgs 启动参数

func WithAutoReStart 

func WithAutoReStart(opt AutoReStart) WithOption

WithAutoReStart 程序退出后自动重启,可选值：[unexpected,true,false]，默认为unexpected，表示进程意外杀死后才重启

func WithAutoStart 

func WithAutoStart(opt bool) WithOption

WithAutoStart 启动的时候自动该进程启动

func WithCommand 

func WithCommand(opt string) WithOption

WithCommand 启动命令

func WithDirectory 

func WithDirectory(opt string) WithOption

WithDirectory 进程运行目录

func WithEnvironment 

func WithEnvironment(opt map[string]string) WithOption

func WithExitCodes 

func WithExitCodes(opt ...int) WithOption

WithExitCodes 进程退出的code值列表，该列表中的值表示已知

func WithExtraFiles 

func WithExtraFiles(opt []*os.File) WithOption

WithExtraFiles 设置打开的文件句柄列表

func WithKillAsGroup 

func WithKillAsGroup(opt bool) WithOption

WithKillAsGroup 默认为false，向进程组发送kill信号，包括子进程

func WithKillWaitSecs 

func WithKillWaitSecs(opt int) WithOption

WithKillWaitSecs 强杀进程等待秒数

func WithName 

func WithName(opt string) WithOption

WithName 设置进程名称

func WithPriority 

func WithPriority(opt int) WithOption

WithPriority 进程启动优先级，默认999，值小的优先启动

func WithRedirectStderr 

func WithRedirectStderr(opt bool) WithOption

WithRedirectStderr 错误输出是否与标准输入一起

func WithRestartPause 

func WithRestartPause(opt int) WithOption

WithRestartPause 进程重启间隔秒数，默认是0，表示不间隔

func WithRestartWhenBinaryChanged 

func WithRestartWhenBinaryChanged(opt bool) WithOption

WithRestartWhenBinaryChanged 当进程的二进制文件有修改，是否需要重启

func WithSetEnvironment 

func WithSetEnvironment(key, val string) WithOption

WithSetEnvironment 环境变量

func WithSetExtend 

func WithSetExtend(key, val interface{}) WithOption

WithSetExtend 扩展参数

func WithStartRetries 

func WithStartRetries(opt int) WithOption

WithStartRetries 启动失败自动重试次数，默认是3

func WithStartSecs 

func WithStartSecs(opt int) WithOption

WithStartSecs 指定启动多少秒后没有异常退出，则表示启动成功 // 未设置该值，则表示cmd.Start方法调用为出错，则表示启动成功， // 设置了该值，则表示程序启动后需稳定运行指定的秒数后才算启动成功

func WithStderrLog 

func WithStderrLog(file string, maxBytes string, backups ...int) WithOption

WithStderrLog 设置stderrlog的存放配置

func WithStdoutLog 

func WithStdoutLog(file string, maxBytes string, backups ...int) WithOption

WithStdoutLog 设置stdoutlog的存放配置

func WithStopAsGroup 

func WithStopAsGroup(opt bool) WithOption

WithStopAsGroup 默认为false,进程被杀死时，是否向这个进程组发送stop信号，包括子进程

func WithStopSignal 

func WithStopSignal(opt ...string) WithOption

WithStopSignal 结束进程发送的信号列表

func WithStopWaitSecs 

func WithStopWaitSecs(opt int) WithOption

WithStopWaitSecs 发送结束进程的信号后等待的秒数

func WithUser 

func WithUser(opt string) WithOption

WithUser 用哪个用户启动进程，默认是父进程的所属用户

Source Files

View all Source files

Directories

Path Synopsis
cmd
basic
complex
processd

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.