posix.lua

local posix = {}

local signal = require("posix.signal")
local wait = require("posix.sys.wait")
local unistd = require("posix.unistd")
local stat = require("posix.sys.stat")
local procdata = require("procdata")
local safer = require("safer")
local util = require("sga.util")
local filemonitor = require("sga.filemonitor")

local function done_file(self, jid)
   return self.config.runtime_data_dir.."/"..jid..".done"
end

local function start_file(self, jid)
   return self.config.runtime_data_dir.."/"..jid..".start"
end

---
-- Execute a new command.
-- @param job The job object: job.data is a writable table for driver data.
-- @param cmd_string The command string
-- @return True if succeded or nil and an error message
function posix.execute_command(self, job, cmd_string)
   self.active_commands = self.active_commands + 1

   filemonitor.init(job)

   for _, sandbox_path in ipairs(job.sandboxes) do
      local ok, err = lfs.mkdir(sandbox_path)
      if not ok then
         local attr = lfs.attributes(sandbox_path)
         if not (attr and attr.mode == "directory") then
            return nil, "Failed creating job's sandbox "..sandbox_path
         end
      end
   end

   local pid, errmsg = unistd.fork()
   if pid == nil then
      return nil, "Failed forking subprocess"
   end
  
   if pid == 0 then
      -- FIXME In the forked process, just dump errors to stdout
      -- until we have a better procedure.
      local function dump(err)
         io.stderr:write(err.."\n")
      end
      
      for i = 3, 65535 do
         unistd.close(i)
      end
      
      local ok, err = pcall(function()
         signal.signal(signal.SIGHUP, signal.SIG_IGN)
         pid = unistd.getpid()
         local pinfo = procdata.get_process_info(pid)
         assert(pinfo)
         local ok, err = util.write_file(start_file(self, job.jid), pinfo.starttime)
         if not ok then
            dump(err)
            os.exit(0) -- don't run a command we can't monitor
         end

         local start_time = os.time()
         os.execute(cmd_string)
         local walltime_s = os.difftime(os.time(), start_time)