1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00

examples: Process examples (#8598)

This commit is contained in:
kristof de spiegeleer 2021-02-07 05:19:05 +01:00 committed by GitHub
parent 68b4051a6e
commit 2d875260e8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 209 additions and 2 deletions

1
examples/process/.ignore Normal file
View File

@ -0,0 +1 @@
command

View File

@ -0,0 +1,34 @@
module main
import os
// basic example which shows how to use the Command function
fn exec(path string) string {
mut out := ''
mut line := ''
mut cmd := os.Command{
path: path
}
cmd.start() or { panic(err) }
for {
line = cmd.read_line()
println(line)
out += line
if cmd.eof {
return out
}
}
return out
}
fn main() {
mut out := ''
exec("bash -c 'find /tmp/'")
out = exec('echo to stdout')
out = exec('echo to stderr 1>&2')
println("'$out'")
// THIS DOES NOT WORK, is error, it goes to stderror of the command I run
assert out == 'to stderr'
}

21
examples/process/execve.v Normal file
View File

@ -0,0 +1,21 @@
module main
import os
fn exec(args []string) {
mut out := ''
mut line := ''
mut line_err := ''
os.execve('/bin/bash', args, []) or {
// eprintln(err)
panic(err)
}
}
fn main() {
// exec(["-c","find /"]) //works
exec(['-c', 'find /tmp/']) // here it works as well
// exec(["-c","find","/tmp/"]) // does not work I guess is normal
}

View File

@ -0,0 +1,59 @@
module main
import os
// a test where we execute a bash script but work around where we put script in bash inside bash
fn exec(path string, redirect bool) {
mut line := ''
mut line_err := ''
mut cmd := os.new_process('/bin/bash')
if redirect {
cmd.set_args(['-c', '/bin/bash /tmp/test.sh 2>&1'])
} else {
cmd.set_args([path])
}
cmd.set_redirect_stdio()
cmd.run()
if cmd.is_alive() {
for {
line = cmd.stdout_read()
println('STDOUT: $line')
if !redirect {
line_err = cmd.stderr_read()
println('STDERR: $line_err')
}
if !cmd.is_alive() {
break
}
}
}
if cmd.code > 0 {
println('ERROR:')
println(cmd)
// println(cmd.stderr_read())
}
}
fn main() {
script := '
echo line 1
#will use some stderr now
echo redirect 1 to 2 1>&2
echo line 3
'
os.write_file('/tmp/test.sh', script) or { panic(err) }
// os.chmod("/tmp/test.sh",0o700) //make executable
// this will work because stderr/stdout are smaller than 4096 chars, once larger there can be deadlocks
// in other words this can never work reliably without being able to check if there is data on stderr or stdout
exec('/tmp/test.sh', false)
// this will always work
exec('/tmp/test.sh', true)
}

View File

@ -0,0 +1,83 @@
module main
import os
// this is a example script to show you stdin can be used and keep a process open
fn exec(cmd string) (string, int) {
mut cmd2 := cmd
mut out := ''
mut line := ''
mut rc := 0
mut p := os.new_process('/bin/bash')
// there are methods missing to know if stderr/stdout has data as such its better to redirect bot on same FD
// not so nice trick to run bash in bash and redirect stderr, maybe someone has a better solution
p.set_args(['-c', 'bash 2>&1'])
p.set_redirect_stdio()
p.run()
if !cmd2.ends_with('\n') {
cmd2 += '\n'
}
p.stdin_write(cmd2)
p.stdin_write('\necho **OK**\n')
for {
if !p.is_alive() {
break
}
line = p.stdout_read()
println(line)
// line_err = p.stderr_read() //IF WE CALL STDERR_READ will block
// we need a mechanism which allows us to check if stderr/stdout has data or it should never block
// is not a good way, need to use a string buffer, is slow like this
out += line
if out.ends_with('**OK**\n') {
out = out[0..(out.len - 7)]
break
}
}
// println("read from stdout, should not block")
// is not really needed but good test to see behaviour
// out += p.stdout_read()
// println("read done")
// println(cmd.stderr_read())
if p.code > 0 {
rc = 1
println('ERROR:')
println(cmd2)
print(out)
}
// documentation says we need to call p.wait(), but this does not seem to work, will be process stop or become zombie?
// p.wait()
return out, rc
}
fn main() {
mut out := ''
mut rc := 0
// the following does not work, not sure why not
// out,rc = exec("find /tmp/ && echo '******'")
out, rc = exec("find /tmp/ ; echo '******'")
println(out)
assert out.ends_with('******\n')
out, rc = exec('echo to stdout')
assert out.contains('to stdout')
out, rc = exec('echo to stderr 1>&2')
assert out.contains('to stderr')
out, rc = exec('ls /sssss')
assert rc > 0 // THIS STILL GIVES AN ERROR !
println('test ok stderr & stdout is indeed redirected')
}

View File

@ -1,6 +1,8 @@
module os module os
// file descriptor based operations: // file descriptor based operations:
// close filedescriptor
pub fn fd_close(fd int) int { pub fn fd_close(fd int) int {
return C.close(fd) return C.close(fd)
} }
@ -18,6 +20,7 @@ pub fn fd_write(fd int, s string) {
} }
} }
// read from filedescriptor, block until data
pub fn fd_slurp(fd int) []string { pub fn fd_slurp(fd int) []string {
mut res := []string{} mut res := []string{}
for { for {
@ -30,6 +33,8 @@ pub fn fd_slurp(fd int) []string {
return res return res
} }
// read from filedescriptor, don't block
// return [bytestring,nrbytes]
pub fn fd_read(fd int, maxbytes int) (string, int) { pub fn fd_read(fd int, maxbytes int) (string, int) {
mut buf := malloc(maxbytes) mut buf := malloc(maxbytes)
nbytes := C.read(fd, buf, maxbytes) nbytes := C.read(fd, buf, maxbytes)

View File

@ -26,9 +26,9 @@ pub mut:
err string // if the process fails, contains the reason why err string // if the process fails, contains the reason why
args []string // the arguments that the command takes args []string // the arguments that the command takes
env_is_custom bool // true, when the environment was customized with .set_environment env_is_custom bool // true, when the environment was customized with .set_environment
env []string // the environment with which the process was started env []string // the environment with which the process was started (list of 'var=val')
use_stdio_ctl bool // when true, then you can use p.stdin_write(), p.stdout_slurp() and p.stderr_slurp() use_stdio_ctl bool // when true, then you can use p.stdin_write(), p.stdout_slurp() and p.stderr_slurp()
stdio_fd [3]int stdio_fd [3]int // the file descriptors
} }
// new_process - create a new process descriptor // new_process - create a new process descriptor
@ -162,16 +162,20 @@ pub fn (mut p Process) stdin_write(s string) {
fd_write(p.stdio_fd[0], s) fd_write(p.stdio_fd[0], s)
} }
// will read from stdout pipe, will only return when EOF (end of file) or data
// means this will block unless there is data
pub fn (mut p Process) stdout_slurp() string { pub fn (mut p Process) stdout_slurp() string {
p._check_redirection_call('stdout_slurp') p._check_redirection_call('stdout_slurp')
return fd_slurp(p.stdio_fd[1]).join('') return fd_slurp(p.stdio_fd[1]).join('')
} }
// read from stderr pipe, wait for data or EOF
pub fn (mut p Process) stderr_slurp() string { pub fn (mut p Process) stderr_slurp() string {
p._check_redirection_call('stderr_slurp') p._check_redirection_call('stderr_slurp')
return fd_slurp(p.stdio_fd[2]).join('') return fd_slurp(p.stdio_fd[2]).join('')
} }
// read from stdout, return if data or not
pub fn (mut p Process) stdout_read() string { pub fn (mut p Process) stdout_read() string {
p._check_redirection_call('stdout_read') p._check_redirection_call('stdout_read')
s, _ := fd_read(p.stdio_fd[1], 4096) s, _ := fd_read(p.stdio_fd[1], 4096)