path: root/_.lua

#!/usr/bin/env luajit

--[[

TODO - I should name this project PolygLua.  Gluing things onto Lua, making it a polyglot language.
	    PolygLuaT  PoLuaGlot  PoLuaGLuaT

TODO - Add some sort of alias mechanism for the #! thing.  _.bash'echo "This is bash."':Do()
	The user can define their own aliases in a table, with defaults for bash, sh, luajit, and maybe some others.
	Then extend it to changing language on the fly     _.bash'echo "This is bash."':luajit("print('This is Lua.')"):Do()

]]

-- Most of this _ stuff was copied from apt-panopticon.
local _ = {}
_.version = '0.0 crap'


-- TODO - add the rest of the logging and debug level stuff from apt-panopticon.
-- This sets the global values, here and in the caller.
D = function(s)	print('DEBUG    ' .. s); io.flush() end
I = function(s)	print('INFO     ' .. s); io.flush() end
T = function(s)	print('TIMEOUT  ' .. s); io.flush() end
W = function(s)	print('WARNING  ' .. s); io.flush() end
E = function(s)	print('ERROR    ' .. s); io.flush() end
C = function(s)	print('CRITICAL ' .. s); io.flush() end


local optionsCommon =
{
    help =	{help = 'Print the help text',
	func = function(self, a, args, i)
	    print(Help)
	    os.exit(0)
	end
    },
    ['--version'] =	{help = 'Print the version details.',
	func = function(self, a, args, i)
	    print('This is version ' ..Version .. ' of ' .. args[0])
	    os.exit(0)
	end
    },
}
optionsCommon['--help'] = optionsCommon['help']

_.parse = function(args, options, confFile)
    local o = nil

    local doIt = function(name, val, a, args, i)
	    local o = options[name]
	    if nil == o then o = optionsCommon[name] end
	    if nil ~= o then
		if nil ~= val then o.value = val; D(name .. ' = ' .. tostring(val)) end
		if nil ~= o.func then o:func(a, args, i) end
	    end
	return o
    end

    if nil ~= confFile then
	for i,v in ipairs{'/etc/', '~/.', './.'} do
	    local p = v .. confFile .. '.conf.lua'
	    local h, e = io.open(p, "r")
	    if nil ~= h then
		D('Found configuration file '.. p)
		h:close()
		local ar = dofile(p)
		for k, w in pairs(ar) do
		    if nil == doIt(k, w, k .. '=' .. tostring(w), args, i) then W('config variable not found ' .. k .. ' = ' .. tostring(w)) end
		end
	    end
	end
    end

    if 0 ~= #args then
	for i,a in ipairs(args) do
	    D('Argument ' .. i .. ' = ' .. a)
	    local s, e = a:find("=")
	    if nil == s then
		e = 0
	        o = doIt(a:sub(1, e - 1), nil, a, args, i)
	    else
		o = doIt(a:sub(1, e - 1), a:sub(e + 1, -1), a, args, i)
	    end
	end
    end

    if nil == o then
	local h = ''
	for k, v in pairs(options) do
	    if 'table' == type(v) then h = h .. k .. ' | ' end
	end
	for k, v in pairs(optionsCommon) do
	    if 'table' == type(v) then h = h .. k .. ' | ' end
	end
	print('Usage: ' .. args[0] .. ' {' .. string.sub(h, 1, -2) .. '}')
	os.exit(0)
    end
end

_.runnable = function(c)
    return ( 0 == __('which ' .. c):Do().status )
end

_.running = function(c)
	return ( 1 ~= tonumber(__("pgrep -u $USER -cf " .. c):Do().lines[1]) )
end

_.exists = function(f)
    local h, e = io.open(f, "r")
    if nil == h then return false else h:close(); return true end
end


_.killEmAll = function(all)
    for i,l in ipairs(all) do
	local c = 0
	while 0 ~= tonumber(__("pgrep -u $USER -xc " .. l):Do().lines[1]) do
	    local s = 'TERM'
	    if c > 1 then s = 'KILL'; __("sleep " .. c):Do() end
	    __("pkill -" .. s .. " -u $USER -x " .. l):log():Do()
	    c = c + 1
	end
    end
end


_.readCmd = function(cmd)
    local result = {}
    local output = io.popen(cmd)
    if nil ~= output then
	for l in output:lines() do
	    table.insert(result, l)
	end
    end
    -- While this does return the same things as os.execute(), it's just as useless.
    output:close()
    return result
end


__ = function(c)
    local exe = {status = 0, lines = {}, logging = false, showing = false, cmd = '', command = c, isScript = false, script = ''}
    local n = 0

    exe.cmd = '{ '
    if 'table' == type(c) then
	for i, l in ipairs(c) do
	    n = n + 1
	    exe.cmd = exe.cmd .. l .. ' ; '
	end
    elseif 'string' == type(c) then
	exe.isScript = ('#!' == c:sub(1,2)) and (n == 0)
	for l in string.gmatch(c, "\n*([^\n]+)\n*") do
	    if '' ~= l then
		if exe.isScript then
		    if '' == exe.script then
			exe.scriptFile = os.tmpname()
			D('Creating temporary script file at ' .. exe.scriptFile)
			exe.cmd = exe.cmd .. l:sub(3) .. ' ' .. exe.scriptFile .. ' ; '
		    end
		    exe.script = exe.script .. l .. '\n'
		else
		    n = n + 1
		    exe.cmd = exe.cmd .. l .. ' ; '
		end
	    end
	end
    end
    if exe.isScript then
	local a, e = io.open(exe.scriptFile, "w")
	if nil == a then E("Could not open " .. exe.scriptFile) else
	    a:write(exe.script)
	    a:close()
	end
	exe.cmd = exe.cmd .. 'rm ' .. exe.scriptFile .. ' ; '
    end
    exe.cmd = exe.cmd .. ' } '
    if 1 == n then exe.cmd = c end


    function exe:Nice(c)
	if nil == c then
	    self.cmd = 'ionice -c3 nice -n 19 ' .. self.cmd
	else
	    self.cmd = self.cmd .. ' ionice -c3 nice -n 19 ' .. c .. ' '
	end
	return self
    end

    function exe:timeout(c)
	-- timeout returns a status of - command status if --preserve-status; "128+9" (actually 137) if --kill-after ends up being done; 124 if it had to TERM; command status if all went well.
	-- --kill-after means "send KILL after TERM fails.
	if nil == c then
	    self.cmd = 'timeout --kill-after=10.0 --foreground 42.0s ' .. self.cmd
	else
	    self.cmd = 'timeout --kill-after=10.0 --foreground ' .. c .. ' ' .. self.cmd
	end
	return self
    end

    function exe:log()								self.logging = true				return self	end
    function exe:show()								self.showing = true				return self	end
    -- Should be called "then" but that's a reserved word.
    function exe:Then(c)	if nil == c then c = '' else c = ' ' .. c end	self.cmd = self.cmd .. '; ' .. c .. ' '		return self	end
    function exe:And(c)		if nil == c then c = '' else c = ' ' .. c end	self.cmd = self.cmd .. ' && ' .. c .. ' '	return self	end
    function exe:Or(c)		if nil == c then c = '' else c = ' ' .. c end	self.cmd = self.cmd .. ' || ' .. c .. ' '	return self	end
    function exe:noErr()							self.cmd = self.cmd .. ' 2>/dev/null '		return self	end
    function exe:noOut()							self.cmd = self.cmd .. ' 1>/dev/null '		return self	end
    function exe:wait(w)							self.cmd = self.cmd .. ' && touch ' .. w .. ' '	return self	end

    function exe:Do()
    --[[    "The condition expression of a control structure can return any
	    value. Both false and nil are considered false. All values different
	    from nil and false are considered true (in particular, the number 0
	    and the empty string are also true)."
	    says the docs, I beg to differ.]]
	if true == self.logging then D(" executing - " .. self.cmd) end
	--[[ Damn os.execute()
	    Lua 5.1 says it returns "a status code, which is system-dependent"
	    Lua 5.2 says it returns true/nil, "exit"/"signal", the status code.
	    I'm getting 7168 or 0.  No idea what the fuck that is.
	local ok, rslt, status = os.execute(s)
	]]
	self.lines = _.readCmd(self.cmd .. '; echo "$?"', 'r')
	-- The last line will be the command's returned status, fish that out and collect everything else in lines.
	self.status = tonumber(self.lines[#self.lines])
	self.lines[#self.lines] = nil
	if true == self.showing then for i, l in ipairs(self.lines) do I(l) end end

	if     (nil == self.status)				then	D("STATUS |" .. "NIL" ..	       '| ' .. self.command)
	elseif (137 == self.status) or (124 == self.status)	then	T("timeout killed " ..	self.status .. ' '  .. self.command)
	elseif (0   ~= self.status)				then	D("STATUS |" ..		self.status .. '| ' .. self.command)
	end

	return self
    end

    function exe:fork(after, host)
-- The host part is from apt-panopticon, likely needed there, but makes no sense here.
--	if nil ~= host then self.cmd = self.cmd .. ';  r=$?; if [ $r -ge 124 ]; then echo "$r ' .. host .. ' failed forked command ' .. string.gsub(self.cmd, '"', "'") .. '"; fi' end
	if nil == after then after = '' end
	if ''  ~= after then after = ' ; ' .. after end
	self.cmd = '{ ' .. self.cmd .. after .. ' ; } & '
	if true == self.logging then D(" forking - " .. self.cmd) end
	os.execute(self.cmd)
	return self
    end

    function exe:forkOnce()
	if _.running(self.command) then
	    D('Already running ' .. self.command)
	else
	    self:fork()
	end
    end

    return exe
end


return _