Help us shape the future of Go! Take the 2026 Go Developer Survey

module

package
v1.15.2 Latest Latest
Warning

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

Go to latest
Published: May 28, 2024 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source
const (
	SystemdScopeSystem = "system"
	SystemdScopeUser   = "user"
	SystemdScopeGlobal = "global"
)

scope can be either "system", "user" or "global"

View Source
const (

	// UserActionAdd add user.
	UserActionAdd = "add"
	// UserActionDel delete user.
	UserActionDel = "del"
)

Variables

View Source
var (

	// ErrUserAddFailed is ErrUserAddFailed
	ErrUserAddFailed = errNSUser.NewType("user_add_failed")
	// ErrUserDeleteFailed is ErrUserDeleteFailed
	ErrUserDeleteFailed = errNSUser.NewType("user_delete_failed")
)

Functions

This section is empty.

Types

type ShellModule

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

ShellModule is the module used to control systemd units

func NewShellModule

func NewShellModule(config ShellModuleConfig) *ShellModule

NewShellModule builds and returns a ShellModule object base on given config.

func (*ShellModule) Execute

func (mod *ShellModule) Execute(ctx context.Context, exec ctxt.Executor) ([]byte, []byte, error)

Execute passes the command to executor and returns its results, the executor should be already initialized.

type ShellModuleConfig

type ShellModuleConfig struct {
	Command  string // the command to run
	Sudo     bool   // whether use root privilege to run the command
	Chdir    string // change working directory before running the command
	UseShell bool   // whether use shell to invoke the command
}

ShellModuleConfig is the configurations used to initialize a TiUPModuleSystemd

type SystemdModule

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

SystemdModule is the module used to control systemd units

func NewSystemdModule

func NewSystemdModule(config SystemdModuleConfig) *SystemdModule

NewSystemdModule builds and returns a SystemdModule object base on given config.

func (*SystemdModule) Execute

func (mod *SystemdModule) Execute(ctx context.Context, exec ctxt.Executor) ([]byte, []byte, error)

Execute passes the command to executor and returns its results, the executor should be already initialized.

type SystemdModuleConfig

type SystemdModuleConfig struct {
	Unit         string        // the name of systemd unit(s)
	Action       string        // the action to perform with the unit
	ReloadDaemon bool          // run daemon-reload before other actions
	CheckActive  bool          // run is-active before action
	Scope        string        // user, system or global
	Force        bool          // add the `--force` arg to systemctl command
	Signal       string        // specify the signal to send to process
	Timeout      time.Duration // timeout to execute the command
	SystemdMode  string
}

SystemdModuleConfig is the configurations used to initialize a SystemdModule

type UserModule

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

UserModule is the module used to control systemd units

func NewUserModule

func NewUserModule(config UserModuleConfig) *UserModule

NewUserModule builds and returns a UserModule object base on given config.

func (*UserModule) Execute

func (mod *UserModule) Execute(ctx context.Context, exec ctxt.Executor) ([]byte, []byte, error)

Execute passes the command to executor and returns its results, the executor should be already initialized.

type UserModuleConfig

type UserModuleConfig struct {
	Action string // add, del or modify user
	Name   string // username
	Group  string // group name
	Home   string // home directory of user
	Shell  string // login shell of the user
	Sudoer bool   // when true, the user will be added to sudoers list
}

UserModuleConfig is the configurations used to initialize a UserModule

type WaitFor

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

WaitFor is the module used to wait for some condition.

func NewWaitFor

func NewWaitFor(c WaitForConfig) *WaitFor

NewWaitFor create a WaitFor instance.

func (*WaitFor) Execute

func (w *WaitFor) Execute(ctx context.Context, e ctxt.Executor) (err error)

Execute the module return nil if successfully wait for the event.

type WaitForConfig

type WaitForConfig struct {
	Port  int           // Port number to poll.
	Sleep time.Duration // Duration to sleep between checks, default 1 second.
	// Choices:
	// started
	// stopped
	// When checking a port started will ensure the port is open, stopped will check that it is closed
	State   string
	Timeout time.Duration // Maximum duration to wait for.
}

WaitForConfig is the configurations of WaitFor module.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL