Comment construisez-vous un tube de lecture-écriture avec lua?

J'aimerais faire l'équivalent de:

foo=$(echo "$foo"|someprogram)

dans lua -- c'est à dire, j'ai une variable qui contient un tas de texte, et je voudrais le faire passer à travers un filtre (implémenté en python, comme il arrive).

Un indice?

Ajouté: tiens vraiment à le faire sans l'aide d'un fichier temporaire

source d'informationauteur Anthony Towns

lua pipe

4

Il n'y a rien dans le Lua de la bibliothèque standard pour permettre cela.

Voici une exploration en profondeur de la difficulté de faire une communication bidirectionnelle correctementet une proposition de solution:
si possible, de rediriger une extrémité du flux (entrée ou sortie) vers un fichier. I. e.:
```
fp = io.popen("foo >/tmp/unique", "w")
fp:write(anything)
fp:close()
fp = io.open("/tmp/unique")
x = read("*a")
fp:close()
```
Vous pouvez être intéressé par cette extension qui ajoute des fonctions à la os et io espaces de noms pour faire une communication bidirectionnelle avec un sous-processus possible.

Aha, un probablement la meilleure solution:

require('posix')
require('os')
require('io')

function splat_popen(data,cmd)
   rd,wr = posix.pipe()
   io.flush()
   child = posix.fork()
   if child == 0 then
      rd:close()
      wr:write(data)
      io.flush()
      os.exit(1)
   end
   wr:close()

   rd2,wr2 = posix.pipe()
   io.flush()
   child2 = posix.fork()
   if child2 == 0 then
      rd2:close()
      posix.dup(rd,io.stdin)
      posix.dup(wr2,io.stdout)
      posix.exec(cmd)
      os.exit(2)
   end
   wr2:close()
   rd:close()

   y = rd2:read("*a")
   rd2:close()

   posix.wait(child2)
   posix.wait(child)

   return y
end

munged=splat_popen("hello, world","/usr/games/rot13")
print("munged: "..munged.." !")

Tant que votre Lua prend en charge io.popence problème est facile. La solution est exactement comme vous l'avez indiqué, sauf qu'au lieu de $(...) vous avez besoin d'une fonction comme celle-ci:

function os.capture(cmd, raw)
  local f = assert(io.popen(cmd, 'r'))
  local s = assert(f:read('*a'))
  f:close()
  if raw then return s end
  s = string.gsub(s, '^%s+', '')
  s = string.gsub(s, '%s+$', '')
  s = string.gsub(s, '[\n\r]+', ' ')
  return s
end

Vous pouvez ensuite appeler

local foo = ...
local cmd = ("echo $foo | someprogram"):gsub('$foo', foo)
foo = os.capture(cmd)

Je fais les choses comme cela tout le temps. Voici une relative fonction utile pour la formation de commandes:

local quote_me = '[^%w%+%-%=%@%_%/]' -- complement (needn't quote)
local strfind = string.find

function os.quote(s)
  if strfind(s, quote_me) or s == '' then
    return "'" .. string.gsub(s, "'", [['"'"']]) .. "'"
  else
    return s
  end
end

Je suis tombé sur ce post en essayant de faire la même chose et n'a jamais trouvé une bonne solution, voir le code ci-dessous pour savoir comment j'ai résolu mes problèmes. Cette application permet aux utilisateurs d'accéder à stdin, stdout, stderr et obtenir le code d'état de retour. Un simple wrapper est appelé pour un simple tuyau d'appels.

require("posix")
--
-- Simple popen3() implementation
--
function popen3(path, ...)
local r1, w1 = posix.pipe()
local r2, w2 = posix.pipe()
local r3, w3 = posix.pipe()
assert((w1 ~= nil or r2 ~= nil or r3 ~= nil), "pipe() failed")
local pid, err = posix.fork()
assert(pid ~= nil, "fork() failed")
if pid == 0 then
posix.close(w1)
posix.close(r2)
posix.dup2(r1, posix.fileno(io.stdin))
posix.dup2(w2, posix.fileno(io.stdout))
posix.dup2(w3, posix.fileno(io.stderr))
posix.close(r1)
posix.close(w2)
posix.close(w3)
local ret, err = posix.execp(path, unpack({...}))
assert(ret ~= nil, "execp() failed")
posix._exit(1)
return
end
posix.close(r1)
posix.close(w2)
posix.close(w3)
return pid, w1, r2, r3
end
--
-- Pipe input into cmd + optional arguments and wait for completion
-- and then return status code, stdout and stderr from cmd.
--
function pipe_simple(input, cmd, ...)
--
-- Launch child process
--
local pid, w, r, e = popen3(cmd, unpack({...}))
assert(pid ~= nil, "filter() unable to popen3()")
--
-- Write to popen3's stdin, important to close it as some (most?) proccess
-- block until the stdin pipe is closed
--
posix.write(w, input)
posix.close(w)
local bufsize = 4096
--
-- Read popen3's stdout via Posix file handle
--
local stdout = {}
local i = 1
while true do
buf = posix.read(r, bufsize)
if buf == nil or #buf == 0 then break end
stdout[i] = buf
i = i + 1
end
--
-- Read popen3's stderr via Posix file handle
--
local stderr = {}
local i = 1
while true do
buf = posix.read(e, bufsize)
if buf == nil or #buf == 0 then break end
stderr[i] = buf
i = i + 1
end
--
-- Clean-up child (no zombies) and get return status
--
local wait_pid, wait_cause, wait_status = posix.wait(pid)
return wait_status, table.concat(stdout), table.concat(stderr)
end
--
-- Example usage
--
local my_in = io.stdin:read("*all")
--local my_cmd = "wc"
--local my_args = {"-l"}
local my_cmd = "spamc"
local my_args = {} -- no arguments
local my_status, my_out, my_err = pipe_simple(my_in, my_cmd, unpack(my_args))
-- Obviously not interleaved as they would have been if printed in realtime
io.stdout:write(my_out)
io.stderr:write(my_err)
os.exit(my_status)

Voici comment j'ai résolu le problème, il faut de lua posix.

          p = require 'posix'
local r,w = p.pipe()
local r1,w1 = p.pipe()
local cpid = p.fork()
if cpid == 0 then -- child reads from pipe                                     
w:close()
r1:close()
p.dup(r, io.stdin)
p.dup(w1 ,io.stdout)
p.exec('./myProgram')
r:close()
w1:close()
p._exit(0)
else -- parent writes to pipe                                                  
IN = r1
OUT = w
end

Pendant myProgram de l'exécution, vous l lire et à écrire à partir de la normale io et après cette partie de code, vous avez juste à écrire/lire sur IN et OUT à communiquer avec le programme enfant.

C'est facile, pas d'extensions nécessaires (testé avec lua 5.3).

#!/usr/bin/lua
-- use always locals
local stdin = io.stdin:lines()
local stdout = io.write
for line in stdin do
stdout (line)
end

enregistrer sous inout.lua et ne chmod +x /tmp/inout.lua

20:30 $ foo=$(echo "bla"|  /tmp/inout.lua)
20:30 $ echo $foo
bla

-1

Un pas très gentil solution qui évite un fichier temporaire...

require("io")
require("posix")
x="hello\nworld"
posix.setenv("LUA_X",x)
i=popen('echo "$LUA_X" | myfilter')
x=i.read("*a")

Vous devez vous connecter pour publier un commentaire.