blackteay/gf
1
0
Fork 0
mirror of https://github.com/gogf/gf.git synced 2025-04-05 11:18:50 +08:00
Code Issues Projects Releases Wiki Activity

add tracing feature for package gproc (#1923)

Browse Source
This commit is contained in:
John Guo 2022-06-21 21:46:12 +08:00 committed by GitHub
parent f0568b4e22
commit 2bcee014f7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
22 changed files with 355 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
cmd/gf/internal/cmd/cmd_build.go
View File

@ -206,11 +206,14 @@ func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, e
}
packCmd := fmt.Sprintf(`gf pack %s %s`, in.PackSrc, in.PackDst)
mlog.Print(packCmd)
gproc.MustShellRun(packCmd)
gproc.MustShellRun(ctx, packCmd)
}
// Injected information by building flags.
ldFlags := fmt.Sprintf(`-X 'github.com/gogf/gf/v2/os/gbuild.builtInVarStr=%v'`, c.getBuildInVarStr(in))
ldFlags := fmt.Sprintf(
`-X 'github.com/gogf/gf/v2/os/gbuild.builtInVarStr=%v'`,
c.getBuildInVarStr(ctx, in),
)
// start building
mlog.Print("start building...")
@ -261,7 +264,7 @@ func (c cBuild) Index(ctx context.Context, in cBuildInput) (out *cBuildOutput, e
// It's not necessary printing the complete command string.
cmdShow, _ := gregex.ReplaceString(`\s+(-ldflags ".+?")\s+`, " ", cmd)
mlog.Print(cmdShow)
if result, err := gproc.ShellExec(cmd); err != nil {
if result, err := gproc.ShellExec(ctx, cmd); err != nil {
mlog.Printf(
"failed to build, os:%s, arch:%s, error:\n%s\n\n%s\n",
system, arch, gstr.Trim(result),
@ -287,12 +290,12 @@ buildDone:
// getBuildInVarMapJson retrieves and returns the custom build-in variables in configuration
// file as json.
func (c cBuild) getBuildInVarStr(in cBuildInput) string {
func (c cBuild) getBuildInVarStr(ctx context.Context, in cBuildInput) string {
buildInVarMap := in.VarMap
if buildInVarMap == nil {
buildInVarMap = make(g.Map)
}
buildInVarMap["builtGit"] = c.getGitCommit()
buildInVarMap["builtGit"] = c.getGitCommit(ctx)
buildInVarMap["builtTime"] = gtime.Now().String()
b, err := json.Marshal(buildInVarMap)
if err != nil {
@ -302,13 +305,13 @@ func (c cBuild) getBuildInVarStr(in cBuildInput) string {
}
// getGitCommit retrieves and returns the latest git commit hash string if present.
func (c cBuild) getGitCommit() string {
func (c cBuild) getGitCommit(ctx context.Context) string {
if gproc.SearchBinary("git") == "" {
return ""
}
var (
cmd = `git log -1 --format="%cd %H" --date=format:"%Y-%m-%d %H:%M:%S"`
s, _ = gproc.ShellExec(cmd)
s, _ = gproc.ShellExec(ctx, cmd)
)
mlog.Debug(cmd)
if s != "" {

14
cmd/gf/internal/cmd/cmd_docker.go
View File

@ -88,14 +88,14 @@ func (c cDocker) Index(ctx context.Context, in cDockerInput) (out *cDockerOutput
// Binary build.
in.Build += " --exit"
if in.Main != "" {
if err = gproc.ShellRun(fmt.Sprintf(`gf build %s %s`, in.Main, in.Build)); err != nil {
if err = gproc.ShellRun(ctx, fmt.Sprintf(`gf build %s %s`, in.Main, in.Build)); err != nil {
return
}
}
// Shell executing.
if in.Shell != "" && gfile.Exists(in.Shell) {
if err = c.exeDockerShell(in.Shell); err != nil {
if err = c.exeDockerShell(ctx, in.Shell); err != nil {
return
}
}
@ -116,7 +116,7 @@ func (c cDocker) Index(ctx context.Context, in cDockerInput) (out *cDockerOutput
}
for i, dockerTag := range dockerTags {
if i > 0 {
err = gproc.ShellRun(fmt.Sprintf(`docker tag %s %s`, dockerTagBase, dockerTag))
err = gproc.ShellRun(ctx, fmt.Sprintf(`docker tag %s %s`, dockerTagBase, dockerTag))
if err != nil {
return
}
@ -130,7 +130,7 @@ func (c cDocker) Index(ctx context.Context, in cDockerInput) (out *cDockerOutput
if in.Extra != "" {
dockerBuildOptions = fmt.Sprintf(`%s %s`, dockerBuildOptions, in.Extra)
}
err = gproc.ShellRun(fmt.Sprintf(`docker build -f %s . %s`, in.File, dockerBuildOptions))
err = gproc.ShellRun(ctx, fmt.Sprintf(`docker build -f %s . %s`, in.File, dockerBuildOptions))
if err != nil {
return
}
@ -144,7 +144,7 @@ func (c cDocker) Index(ctx context.Context, in cDockerInput) (out *cDockerOutput
if dockerTag == "" {
continue
}
err = gproc.ShellRun(fmt.Sprintf(`docker push %s`, dockerTag))
err = gproc.ShellRun(ctx, fmt.Sprintf(`docker push %s`, dockerTag))
if err != nil {
return
}
@ -152,10 +152,10 @@ func (c cDocker) Index(ctx context.Context, in cDockerInput) (out *cDockerOutput
return
}
func (c cDocker) exeDockerShell(shellFilePath string) error {
func (c cDocker) exeDockerShell(ctx context.Context, shellFilePath string) error {
if gfile.ExtName(shellFilePath) == "sh" && runtime.GOOS == "windows" {
mlog.Debugf(`ignore shell file "%s", as it cannot be run on windows system`, shellFilePath)
return nil
}
return gproc.ShellRun(gfile.GetContents(shellFilePath))
return gproc.ShellRun(ctx, gfile.GetContents(shellFilePath))
}

2
cmd/gf/internal/cmd/cmd_env.go
View File

@ -26,7 +26,7 @@ type cEnvInput struct {
type cEnvOutput struct{}
func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err error) {
result, err := gproc.ShellExec("go env")
result, err := gproc.ShellExec(ctx, "go env")
if err != nil {
mlog.Fatal(err)
}

2
cmd/gf/internal/cmd/cmd_gen_pb.go
View File

@ -57,7 +57,7 @@ func (c cGenPb) Pb(ctx context.Context, in cGenPbInput) (out *cGenPbOutput, err
parsingCommand += " -I" + goPathSrc
}
mlog.Print(parsingCommand)
if output, err := gproc.ShellExec(parsingCommand); err != nil {
if output, err := gproc.ShellExec(ctx, parsingCommand); err != nil {
mlog.Print(output)
mlog.Fatal(err)
}

2
cmd/gf/internal/cmd/cmd_gen_service.go
View File

@ -80,7 +80,7 @@ func (c cGenService) Service(ctx context.Context, in cGenServiceInput) (out *cGe
`%s gen service -packages=%s`,
gfile.SelfName(), gfile.Basename(watchFileDir),
)
err = gproc.ShellRun(command)
err = gproc.ShellRun(ctx, command)
return
}

2
cmd/gf/internal/cmd/cmd_init.go
View File

@ -98,7 +98,7 @@ func (c cInit) Index(ctx context.Context, in cInitInput) (out *cInitOutput, err
if in.Name != "." {
updateCommand = fmt.Sprintf(`cd %s && %s`, in.Name, updateCommand)
}
if err = gproc.ShellRun(updateCommand); err != nil {
if err = gproc.ShellRun(ctx, updateCommand); err != nil {
mlog.Fatal(err)
}
}

10
cmd/gf/internal/cmd/cmd_run.go
View File

@ -99,17 +99,17 @@ func (c cRun) Index(ctx context.Context, in cRunInput) (out *cRunOutput, err err
gtimer.SetTimeout(ctx, 1500*gtime.MS, func(ctx context.Context) {
defer dirty.Set(false)
mlog.Printf(`go file changes: %s`, event.String())
app.Run()
app.Run(ctx)
})
})
if err != nil {
mlog.Fatal(err)
}
go app.Run()
go app.Run(ctx)
select {}
}
func (app *cRunApp) Run() {
func (app *cRunApp) Run(ctx context.Context) {
// Rebuild and run the codes.
renamePath := ""
mlog.Printf("build: %s", app.File)
@ -132,7 +132,7 @@ func (app *cRunApp) Run() {
app.File,
)
mlog.Print(buildCommand)
result, err := gproc.ShellExec(buildCommand)
result, err := gproc.ShellExec(ctx, buildCommand)
if err != nil {
mlog.Printf("build error: \n%s%s", result, err.Error())
return
@ -154,7 +154,7 @@ func (app *cRunApp) Run() {
} else {
process = gproc.NewProcessCmd(outputPath, gstr.SplitAndTrim(" ", app.Args))
}
if pid, err := process.Start(); err != nil {
if pid, err := process.Start(ctx); err != nil {
mlog.Printf("build running error: %s", err.Error())
} else {
mlog.Printf("build running pid: %d", pid)

5
cmd/gf/internal/utility/utils/utils.go
View File

@ -1,6 +1,7 @@
package utils
import (
"context"
"fmt"
"github.com/gogf/gf/cmd/gf/v2/internal/consts"
@ -31,7 +32,7 @@ func GoFmt(path string) {
mlog.Fatal(`command "gofmt" not found`)
}
var command = fmt.Sprintf(`%s -w %s`, gofmtPath, path)
result, err := gproc.ShellExec(command)
result, err := gproc.ShellExec(context.Background(), command)
if err != nil {
mlog.Fatalf(`error executing command "%s": %s`, command, result)
}
@ -43,7 +44,7 @@ func GoImports(path string) {
mlog.Fatal(`command "goimports" not found`)
}
var command = fmt.Sprintf(`%s -w %s`, goimportsPath, path)
result, err := gproc.ShellExec(command)
result, err := gproc.ShellExec(context.Background(), command)
if err != nil {
mlog.Fatalf(`error executing command "%s": %s`, command, result)
}

4
example/go.mod
View File

@ -7,8 +7,8 @@ require (
github.com/gogf/gf/contrib/registry/etcd/v2 v2.1.0-rc3.0.20220523034830-510fa3faf03f
github.com/gogf/gf/contrib/registry/polaris/v2 v2.0.0-rc2
github.com/gogf/gf/contrib/trace/jaeger/v2 v2.0.0-rc2
github.com/gogf/gf/v2 v2.1.0-rc3.0.20220523034830-510fa3faf03f
github.com/gogf/katyusha v0.4.0
github.com/gogf/gf/v2 v2.1.0-rc4.0.20220620123459-52056644d499
github.com/gogf/katyusha v0.4.1-0.20220620125113-f55d6f739773
github.com/gogo/protobuf v1.3.2
github.com/golang/protobuf v1.5.2
github.com/polarismesh/polaris-go v1.2.0-beta.0.0.20220517041223-596a6a63b00f

2
example/go.sum
View File

@ -113,6 +113,8 @@ github.com/go-task/slim-sprig v0.0.0-20210107165309-348f09dbbbc0/go.mod h1:fyg78
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/gogf/katyusha v0.4.0 h1:mQVfXHhzC+UQf11Q8HAk9IOhQZ1VMXqGUqezyywZUOs=
github.com/gogf/katyusha v0.4.0/go.mod h1:nqsIWBsImnq9+OLlfB6iNef6ZLRyR2L1Bnk9h2aZvKs=
github.com/gogf/katyusha v0.4.1-0.20220620125113-f55d6f739773 h1:YQBLawktoymYtPGs9idE9JS5Wqd3SjIzUEZOPKCdSw0=
github.com/gogf/katyusha v0.4.1-0.20220620125113-f55d6f739773/go.mod h1:Z0GCeHXz1UI0HtA0K45c6TzEGM4DL/PLatS747/WarI=
github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=

25
example/trace/processes/gcmd/main.go Normal file
View File

@ -0,0 +1,25 @@
package main
import (
"context"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gcmd"
"github.com/gogf/gf/v2/os/gctx"
"github.com/gogf/gf/v2/os/gproc"
)
var (
Main = &gcmd.Command{
Name: "main",
Brief: "main process",
Func: func(ctx context.Context, parser *gcmd.Parser) (err error) {
g.Log().Debug(ctx, `this is main process`)
return gproc.ShellRun(ctx, `go run sub/sub.go`)
},
}
)
func main() {
Main.Run(gctx.New())
}

24
example/trace/processes/gcmd/sub/sub.go Normal file
View File

@ -0,0 +1,24 @@
package main
import (
"context"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gcmd"
"github.com/gogf/gf/v2/os/gctx"
)
var (
Sub = &gcmd.Command{
Name: "sub",
Brief: "sub process",
Func: func(ctx context.Context, parser *gcmd.Parser) (err error) {
g.Log().Debug(ctx, `this is sub process`)
return nil
},
}
)
func main() {
Sub.Run(gctx.New())
}

15
example/trace/processes/gproc/main.go Normal file
View File

@ -0,0 +1,15 @@
package main
import (
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gctx"
"github.com/gogf/gf/v2/os/gproc"
)
func main() {
ctx := gctx.New()
g.Log().Debug(ctx, `this is main process`)
if err := gproc.ShellRun(ctx, `go run sub/sub.go`); err != nil {
panic(err)
}
}

11
example/trace/processes/gproc/sub/sub.go Normal file
View File

@ -0,0 +1,11 @@
package main
import (
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gctx"
)
func main() {
ctx := gctx.New()
g.Log().Debug(ctx, `this is sub process`)
}

4
net/ghttp/ghttp_server_admin_process.go
View File

@ -144,7 +144,7 @@ func forkReloadProcess(ctx context.Context, newExeFilePath ...string) error {
}
buffer, _ := gjson.Encode(sfm)
p.Env = append(p.Env, adminActionReloadEnvKey+"="+string(buffer))
if _, err := p.Start(); err != nil {
if _, err := p.Start(ctx); err != nil {
glog.Errorf(
ctx,
"%d: fork process failed, error:%s, %s",
@ -169,7 +169,7 @@ func forkRestartProcess(ctx context.Context, newExeFilePath ...string) error {
env := os.Environ()
env = append(env, adminActionRestartEnvKey+"=1")
p := gproc.NewProcess(path, os.Args, env)
if _, err := p.Start(); err != nil {
if _, err := p.Start(ctx); err != nil {
glog.Errorf(
ctx,
`%d: fork process failed, error:%s, are you running using "go run"?`,

34
os/genv/genv.go
View File

@ -8,6 +8,7 @@
package genv
import (
"fmt"
"os"
"strings"
@ -25,13 +26,7 @@ func All() []string {
// Map returns a copy of strings representing the environment as a map.
func Map() map[string]string {
m := make(map[string]string)
i := 0
for _, s := range os.Environ() {
i = strings.IndexByte(s, '=')
m[s[0:i]] = s[i+1:]
}
return m
return MapFromEnv(os.Environ())
}
// Get creates and returns a Var with the value of the environment variable
@ -117,3 +112,28 @@ func Build(m map[string]string) []string {
}
return array
}
// MapFromEnv converts environment variables from slice to map.
func MapFromEnv(envs []string) map[string]string {
m := make(map[string]string)
i := 0
for _, s := range envs {
i = strings.IndexByte(s, '=')
m[s[0:i]] = s[i+1:]
}
return m
}
// MapToEnv converts environment variables from map to slice.
func MapToEnv(m map[string]string) []string {
envs := make([]string, 0)
for k, v := range m {
envs = append(envs, fmt.Sprintf(`%s=%s`, k, v))
}
return envs
}
// Filter filters repeated items from given environment variables.
func Filter(envs []string) []string {
return MapToEnv(MapFromEnv(envs))
}

21
os/genv/genv_z_unit_test.go
View File

@ -121,3 +121,24 @@ func Test_GetWithCmd(t *testing.T) {
t.Assert(genv.GetWithCmd("test"), 1)
})
}
func Test_MapFromEnv(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
m := genv.MapFromEnv([]string{"a=1", "b=2"})
t.Assert(m, g.Map{"a": 1, "b": 2})
})
}
func Test_MapToEnv(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
s := genv.MapToEnv(g.MapStrStr{"a": "1"})
t.Assert(s, []string{"a=1"})
})
}
func Test_Filter(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
s := genv.Filter([]string{"a=1", "a=3"})
t.Assert(s, []string{"a=3"})
})
}

119
os/gproc/gproc.go
View File

@ -8,8 +8,6 @@
package gproc
import (
"bytes"
"io"
"os"
"runtime"
"time"
@ -21,7 +19,8 @@ import (
)
const (
envKeyPPid = "GPROC_PPID"
envKeyPPid = "GPROC_PPID"
tracingInstrumentName = "github.com/gogf/gf/v2/os/gproc.Process"
)
var (
@ -80,120 +79,6 @@ func Uptime() time.Duration {
return time.Now().Sub(processStartTime)
}
// Shell executes command `cmd` synchronously with given input pipe `in` and output pipe `out`.
// The command `cmd` reads the input parameters from input pipe `in`, and writes its output automatically
// to output pipe `out`.
func Shell(cmd string, out io.Writer, in io.Reader) error {
p := NewProcess(
getShell(),
append([]string{getShellOption()}, parseCommand(cmd)...),
)
p.Stdin = in
p.Stdout = out
return p.Run()
}
// ShellRun executes given command `cmd` synchronously and outputs the command result to the stdout.
func ShellRun(cmd string) error {
p := NewProcess(
getShell(),
append([]string{getShellOption()}, parseCommand(cmd)...),
)
return p.Run()
}
// ShellExec executes given command `cmd` synchronously and returns the command result.
func ShellExec(cmd string, environment ...[]string) (result string, err error) {
var (
buf = bytes.NewBuffer(nil)
p = NewProcess(
getShell(),
append([]string{getShellOption()}, parseCommand(cmd)...),
environment...,
)
)
p.Stdout = buf
p.Stderr = buf
err = p.Run()
result = buf.String()
return
}
// parseCommand parses command `cmd` into slice arguments.
//
// Note that it just parses the `cmd` for "cmd.exe" binary in windows, but it is not necessary
// parsing the `cmd` for other systems using "bash"/"sh" binary.
func parseCommand(cmd string) (args []string) {
if runtime.GOOS != "windows" {
return []string{cmd}
}
// Just for "cmd.exe" in windows.
var argStr string
var firstChar, prevChar, lastChar1, lastChar2 byte
array := gstr.SplitAndTrim(cmd, " ")
for _, v := range array {
if len(argStr) > 0 {
argStr += " "
}
firstChar = v[0]
lastChar1 = v[len(v)-1]
lastChar2 = 0
if len(v) > 1 {
lastChar2 = v[len(v)-2]
}
if prevChar == 0 && (firstChar == '"' || firstChar == '\'') {
// It should remove the first quote char.
argStr += v[1:]
prevChar = firstChar
} else if prevChar != 0 && lastChar2 != '\\' && lastChar1 == prevChar {
// It should remove the last quote char.
argStr += v[:len(v)-1]
args = append(args, argStr)
argStr = ""
prevChar = 0
} else if len(argStr) > 0 {
argStr += v
} else {
args = append(args, v)
}
}
return
}
// getShell returns the shell command depending on current working operating system.
// It returns "cmd.exe" for windows, and "bash" or "sh" for others.
func getShell() string {
switch runtime.GOOS {
case "windows":
return SearchBinary("cmd.exe")
default:
// Check the default binary storage path.
if gfile.Exists("/bin/bash") {
return "/bin/bash"
}
if gfile.Exists("/bin/sh") {
return "/bin/sh"
}
// Else search the env PATH.
path := SearchBinary("bash")
if path == "" {
path = SearchBinary("sh")
}
return path
}
}
// getShellOption returns the shell option depending on current working operating system.
// It returns "/c" for windows, and "-c" for others.
func getShellOption() string {
switch runtime.GOOS {
case "windows":
return "/c"
default:
return "-c"
}
}
// SearchBinary searches the binary `file` in current working folder and PATH environment.
func SearchBinary(file string) string {
// Check if it is absolute path of exists at current working directory.

13
os/gproc/gproc_must.go
View File

@ -7,26 +7,27 @@
package gproc
import (
"context"
"io"
)
// MustShell performs as Shell, but it panics if any error occurs.
func MustShell(cmd string, out io.Writer, in io.Reader) {
if err := Shell(cmd, out, in); err != nil {
func MustShell(ctx context.Context, cmd string, out io.Writer, in io.Reader) {
if err := Shell(ctx, cmd, out, in); err != nil {
panic(err)
}
}
// MustShellRun performs as ShellRun, but it panics if any error occurs.
func MustShellRun(cmd string) {
if err := ShellRun(cmd); err != nil {
func MustShellRun(ctx context.Context, cmd string) {
if err := ShellRun(ctx, cmd); err != nil {
panic(err)
}
}
// MustShellExec performs as ShellExec, but it panics if any error occurs.
func MustShellExec(cmd string, environment ...[]string) string {
result, err := ShellExec(cmd, environment...)
func MustShellExec(ctx context.Context, cmd string, environment ...[]string) string {
result, err := ShellExec(ctx, cmd, environment...)
if err != nil {
panic(err)
}

39
os/gproc/gproc_process.go
View File

@ -14,9 +14,16 @@ import (
"runtime"
"strings"
"github.com/gogf/gf/v2"
"github.com/gogf/gf/v2/errors/gcode"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/internal/intlog"
"github.com/gogf/gf/v2/net/gtrace"
"github.com/gogf/gf/v2/os/genv"
"github.com/gogf/gf/v2/text/gstr"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/propagation"
"go.opentelemetry.io/otel/trace"
)
// Process is the struct for a single process.
@ -64,11 +71,37 @@ func NewProcessCmd(cmd string, environment ...[]string) *Process {
// Start starts executing the process in non-blocking way.
// It returns the pid if success, or else it returns an error.
func (p *Process) Start() (int, error) {
func (p *Process) Start(ctx context.Context) (int, error) {
if p.Process != nil {
return p.Pid(), nil
}
// OpenTelemetry for command.
var (
span trace.Span
tr = otel.GetTracerProvider().Tracer(
tracingInstrumentName,
trace.WithInstrumentationVersion(gf.VERSION),
)
)
ctx, span = tr.Start(
otel.GetTextMapPropagator().Extract(
ctx,
propagation.MapCarrier(genv.Map()),
),
gstr.Join(os.Args, " "),
trace.WithSpanKind(trace.SpanKindInternal),
)
defer span.End()
span.SetAttributes(gtrace.CommonLabels()...)
// OpenTelemetry propagation.
tracingEnv := tracingEnvFromCtx(ctx)
if len(tracingEnv) > 0 {
p.Env = append(p.Env, tracingEnv...)
}
p.Env = append(p.Env, fmt.Sprintf("%s=%d", envKeyPPid, p.PPid))
p.Env = genv.Filter(p.Env)
if err := p.Cmd.Start(); err == nil {
if p.Manager != nil {
p.Manager.processes.Set(p.Process.Pid, p)
@ -80,8 +113,8 @@ func (p *Process) Start() (int, error) {
}
// Run executes the process in blocking way.
func (p *Process) Run() error {
if _, err := p.Start(); err == nil {
func (p *Process) Run(ctx context.Context) error {
if _, err := p.Start(ctx); err == nil {
return p.Wait()
} else {
return err

149
os/gproc/gproc_shell.go Normal file
View File

@ -0,0 +1,149 @@
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gproc
import (
"bytes"
"context"
"fmt"
"io"
"runtime"
"github.com/gogf/gf/v2/os/gfile"
"github.com/gogf/gf/v2/text/gstr"
"go.opentelemetry.io/otel"
"go.opentelemetry.io/otel/propagation"
)
// Shell executes command `cmd` synchronously with given input pipe `in` and output pipe `out`.
// The command `cmd` reads the input parameters from input pipe `in`, and writes its output automatically
// to output pipe `out`.
func Shell(ctx context.Context, cmd string, out io.Writer, in io.Reader) error {
p := NewProcess(
getShell(),
append([]string{getShellOption()}, parseCommand(cmd)...),
)
p.Stdin = in
p.Stdout = out
return p.Run(ctx)
}
// ShellRun executes given command `cmd` synchronously and outputs the command result to the stdout.
func ShellRun(ctx context.Context, cmd string) error {
p := NewProcess(
getShell(),
append([]string{getShellOption()}, parseCommand(cmd)...),
)
return p.Run(ctx)
}
// ShellExec executes given command `cmd` synchronously and returns the command result.
func ShellExec(ctx context.Context, cmd string, environment ...[]string) (result string, err error) {
var (
buf = bytes.NewBuffer(nil)
p = NewProcess(
getShell(),
append([]string{getShellOption()}, parseCommand(cmd)...),
environment...,
)
)
p.Stdout = buf
p.Stderr = buf
err = p.Run(ctx)
result = buf.String()
return
}
// parseCommand parses command `cmd` into slice arguments.
//
// Note that it just parses the `cmd` for "cmd.exe" binary in windows, but it is not necessary
// parsing the `cmd` for other systems using "bash"/"sh" binary.
func parseCommand(cmd string) (args []string) {
if runtime.GOOS != "windows" {
return []string{cmd}
}
// Just for "cmd.exe" in windows.
var argStr string
var firstChar, prevChar, lastChar1, lastChar2 byte
array := gstr.SplitAndTrim(cmd, " ")
for _, v := range array {
if len(argStr) > 0 {
argStr += " "
}
firstChar = v[0]
lastChar1 = v[len(v)-1]
lastChar2 = 0
if len(v) > 1 {
lastChar2 = v[len(v)-2]
}
if prevChar == 0 && (firstChar == '"' || firstChar == '\'') {
// It should remove the first quote char.
argStr += v[1:]
prevChar = firstChar
} else if prevChar != 0 && lastChar2 != '\\' && lastChar1 == prevChar {
// It should remove the last quote char.
argStr += v[:len(v)-1]
args = append(args, argStr)
argStr = ""
prevChar = 0
} else if len(argStr) > 0 {
argStr += v
} else {
args = append(args, v)
}
}
return
}
// getShell returns the shell command depending on current working operating system.
// It returns "cmd.exe" for windows, and "bash" or "sh" for others.
func getShell() string {
switch runtime.GOOS {
case "windows":
return SearchBinary("cmd.exe")
default:
// Check the default binary storage path.
if gfile.Exists("/bin/bash") {
return "/bin/bash"
}
if gfile.Exists("/bin/sh") {
return "/bin/sh"
}
// Else search the env PATH.
path := SearchBinary("bash")
if path == "" {
path = SearchBinary("sh")
}
return path
}
}
// getShellOption returns the shell option depending on current working operating system.
// It returns "/c" for windows, and "-c" for others.
func getShellOption() string {
switch runtime.GOOS {
case "windows":
return "/c"
default:
return "-c"
}
}
// tracingEnvFromCtx converts OpenTelemetry propagation data as environment variables.
func tracingEnvFromCtx(ctx context.Context) []string {
var (
a = make([]string, 0)
m = make(map[string]string)
)
otel.GetTextMapPropagator().Inject(ctx, propagation.MapCarrier(m))
for k, v := range m {
a = append(a, fmt.Sprintf(`%s=%s`, k, v))
}
return a
}

5
os/gproc/gproc_z_unit_test.go
View File

@ -11,19 +11,20 @@ package gproc_test
import (
"testing"
"github.com/gogf/gf/v2/os/gctx"
"github.com/gogf/gf/v2/os/gproc"
"github.com/gogf/gf/v2/test/gtest"
)
func Test_ShellExec(t *testing.T) {
gtest.C(t, func(t *gtest.T) {
s, err := gproc.ShellExec(`echo 123`)
s, err := gproc.ShellExec(gctx.New(), `echo 123`)
t.AssertNil(err)
t.Assert(s, "123\n")
})
// error
gtest.C(t, func(t *gtest.T) {
_, err := gproc.ShellExec(`NoneExistCommandCall`)
_, err := gproc.ShellExec(gctx.New(), `NoneExistCommandCall`)
t.AssertNE(err, nil)
})
}