2010-10-25 17:38:57 +00:00
|
|
|
--============================================================================
|
2010-10-19 10:20:27 +00:00
|
|
|
-- lsyncd.lua Live (Mirror) Syncing Demon
|
|
|
|
--
|
|
|
|
-- License: GPLv2 (see COPYING) or any later version
|
|
|
|
--
|
|
|
|
-- Authors: Axel Kittenberger <axkibe@gmail.com>
|
|
|
|
--
|
|
|
|
-- This is the "runner" part of lsyncd. It containts all its high-level logic.
|
|
|
|
-- It works closely together with the lsyncd core in lsyncd.c. This means it
|
|
|
|
-- cannot be runned directly from the standard lua interpreter.
|
2010-10-25 17:38:57 +00:00
|
|
|
--============================================================================
|
2010-10-16 18:21:01 +00:00
|
|
|
|
2010-10-18 17:09:59 +00:00
|
|
|
----
|
2010-10-19 10:20:27 +00:00
|
|
|
-- A security measurement.
|
2010-10-18 17:09:59 +00:00
|
|
|
-- Core will exit if version ids mismatch.
|
2010-10-25 14:55:40 +00:00
|
|
|
--
|
2010-10-26 11:26:57 +00:00
|
|
|
if lsyncd_version then
|
2010-10-22 08:37:15 +00:00
|
|
|
-- checks if the runner is being loaded twice
|
2010-10-27 19:34:56 +00:00
|
|
|
io.stderr:write(
|
|
|
|
"You cannot use the lsyncd runner as configuration file!\n")
|
2010-11-02 21:04:01 +00:00
|
|
|
os.exit(-1) -- ERRNO
|
2010-10-19 21:56:00 +00:00
|
|
|
end
|
2010-10-27 11:31:18 +00:00
|
|
|
lsyncd_version = "2.0beta1"
|
2010-10-18 17:09:59 +00:00
|
|
|
|
2010-10-21 12:37:27 +00:00
|
|
|
----
|
|
|
|
-- Shortcuts (which user is supposed to be able to use them as well)
|
2010-10-22 12:58:57 +00:00
|
|
|
--
|
2010-10-22 10:35:26 +00:00
|
|
|
log = lsyncd.log
|
|
|
|
exec = lsyncd.exec
|
2010-10-27 19:34:56 +00:00
|
|
|
terminate = lsyncd.terminate
|
2010-10-20 18:33:17 +00:00
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
--============================================================================
|
|
|
|
-- Coding checks, ensure termination on some easy to do coding errors.
|
|
|
|
--============================================================================
|
2010-10-25 14:55:40 +00:00
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
-----
|
2010-11-02 13:18:34 +00:00
|
|
|
-- The array objects are tables that error if accessed with a non-number.
|
2010-10-25 14:55:40 +00:00
|
|
|
--
|
2010-11-02 13:18:34 +00:00
|
|
|
local Array = (function()
|
|
|
|
-- Metatable
|
|
|
|
local mt = {}
|
|
|
|
|
|
|
|
-- on accessing a nil index.
|
|
|
|
mt.__index = function(t, k)
|
2010-10-25 17:38:57 +00:00
|
|
|
if type(k) ~= "number" then
|
2010-11-02 13:18:34 +00:00
|
|
|
error("Key '"..k.."' invalid for Array", 2)
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
return rawget(t, k)
|
2010-11-02 13:18:34 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
-- on assigning a new index.
|
|
|
|
mt.__newindex = function(t, k, v)
|
2010-10-25 17:38:57 +00:00
|
|
|
if type(k) ~= "number" then
|
2010-11-02 13:18:34 +00:00
|
|
|
error("Key '"..k.."' invalid for Array", 2)
|
2010-10-25 17:38:57 +00:00
|
|
|
end
|
|
|
|
rawset(t, k, v)
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
2010-11-02 13:18:34 +00:00
|
|
|
|
|
|
|
-- creates a new object
|
2010-11-02 17:07:42 +00:00
|
|
|
local function new()
|
2010-11-02 13:18:34 +00:00
|
|
|
local o = {}
|
|
|
|
setmetatable(o, mt)
|
|
|
|
return o
|
|
|
|
end
|
|
|
|
|
|
|
|
-- objects public interface
|
|
|
|
return {new = new}
|
|
|
|
end)()
|
|
|
|
|
2010-10-25 14:55:40 +00:00
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
-----
|
2010-11-02 13:18:34 +00:00
|
|
|
-- The count array objects are tables that error if accessed with a non-number.
|
|
|
|
-- Additionally they maintain their length as "size" attribute.
|
2010-10-25 17:38:57 +00:00
|
|
|
-- Lua's # operator does not work on tables which key values are not
|
|
|
|
-- strictly linear.
|
|
|
|
--
|
2010-11-02 13:18:34 +00:00
|
|
|
local CountArray = (function()
|
|
|
|
-- Metatable
|
|
|
|
local mt = {}
|
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
2010-11-02 13:18:34 +00:00
|
|
|
-- key to native table
|
|
|
|
local k_nt = {}
|
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
2010-11-02 13:18:34 +00:00
|
|
|
-- on accessing a nil index.
|
|
|
|
mt.__index = function(t, k)
|
2010-10-25 17:38:57 +00:00
|
|
|
if type(k) ~= "number" then
|
2010-11-02 13:18:34 +00:00
|
|
|
error("Key '"..k.."' invalid for CountArray", 2)
|
2010-10-25 17:38:57 +00:00
|
|
|
end
|
2010-11-02 13:18:34 +00:00
|
|
|
return t[k_nt][k]
|
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
2010-11-02 13:18:34 +00:00
|
|
|
-- on assigning a new index.
|
|
|
|
mt.__newindex = function(t, k, v)
|
2010-10-25 17:38:57 +00:00
|
|
|
if type(k) ~= "number" then
|
2010-11-02 13:18:34 +00:00
|
|
|
error("Key '"..k.."' invalid for CountArray", 2)
|
2010-10-25 17:38:57 +00:00
|
|
|
end
|
2010-11-02 13:18:34 +00:00
|
|
|
-- value before
|
|
|
|
local vb = t[k_nt][k]
|
2010-10-25 17:38:57 +00:00
|
|
|
if v and not vb then
|
2010-11-03 11:37:25 +00:00
|
|
|
t._size = t._size + 1
|
2010-10-25 17:38:57 +00:00
|
|
|
elseif not v and vb then
|
2010-11-03 11:37:25 +00:00
|
|
|
t._size = t._size - 1
|
2010-10-25 17:38:57 +00:00
|
|
|
end
|
2010-11-02 13:18:34 +00:00
|
|
|
t[k_nt][k] = v
|
|
|
|
end
|
|
|
|
|
|
|
|
-- TODO
|
2010-11-02 17:07:42 +00:00
|
|
|
local function iwalk(self)
|
2010-11-02 13:18:34 +00:00
|
|
|
return ipairs(self[k_nt])
|
|
|
|
end
|
2010-11-03 11:37:25 +00:00
|
|
|
|
|
|
|
------
|
|
|
|
-- returns the count
|
|
|
|
local function size(self)
|
|
|
|
return self._size
|
|
|
|
end
|
|
|
|
|
|
|
|
----
|
2010-11-02 13:18:34 +00:00
|
|
|
-- creates a new count array
|
2010-11-02 17:07:42 +00:00
|
|
|
local function new()
|
2010-11-02 13:18:34 +00:00
|
|
|
-- k_nt is native table, private for this object.
|
2010-11-03 11:37:25 +00:00
|
|
|
local o = {_size = 0, iwalk = iwalk, size = size, [k_nt] = {} }
|
2010-11-02 13:18:34 +00:00
|
|
|
setmetatable(o, mt)
|
|
|
|
return o
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
2010-11-02 13:18:34 +00:00
|
|
|
|
|
|
|
-- objects public interface
|
|
|
|
return {new = new}
|
|
|
|
end)()
|
2010-10-25 14:55:40 +00:00
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- Metatable to limit keys to those only presented in their prototype
|
|
|
|
--
|
|
|
|
local meta_check_prototype = {
|
|
|
|
__index = function(t, k)
|
|
|
|
if not t.prototype[k] then
|
2010-10-27 19:34:56 +00:00
|
|
|
error("tables prototype doesn't have key '"..k.."'.", 2)
|
2010-10-25 17:38:57 +00:00
|
|
|
end
|
|
|
|
return rawget(t, k)
|
|
|
|
end,
|
|
|
|
__newindex = function(t, k, v)
|
|
|
|
if not t.prototype[k] then
|
2010-10-27 19:34:56 +00:00
|
|
|
error("tables prototype doesn't have key '"..k.."'.", 2)
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
|
|
|
rawset(t, k, v)
|
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Sets the prototype of a table limiting its keys to a defined list.
|
|
|
|
--
|
|
|
|
local function set_prototype(t, prototype)
|
|
|
|
t.prototype = prototype
|
|
|
|
for k, _ in pairs(t) do
|
|
|
|
if not t.prototype[k] and k ~= "prototype" then
|
2010-10-27 19:34:56 +00:00
|
|
|
error("Cannot set prototype, conflicting key: '"..k.."'.", 2)
|
2010-10-25 17:38:57 +00:00
|
|
|
end
|
|
|
|
end
|
2010-10-31 22:25:34 +00:00
|
|
|
setmetatable(t, meta_check_prototype)
|
2010-10-25 17:38:57 +00:00
|
|
|
end
|
|
|
|
|
2010-10-31 22:25:34 +00:00
|
|
|
----
|
2010-11-01 16:38:39 +00:00
|
|
|
-- Locks globals,
|
|
|
|
-- no more globals can be created
|
|
|
|
--
|
2010-11-01 17:54:09 +00:00
|
|
|
local function globals_lock()
|
2010-11-01 16:38:39 +00:00
|
|
|
local t = _G
|
2010-10-31 22:25:34 +00:00
|
|
|
local mt = getmetatable(t) or {}
|
2010-11-01 19:57:53 +00:00
|
|
|
mt.__index = function(t, k)
|
|
|
|
if (k~="_" and string.sub(k, 1, 2) ~= "__") then
|
|
|
|
error("Access of non-existing global.", 2)
|
|
|
|
else
|
|
|
|
rawget(t, k)
|
|
|
|
end
|
|
|
|
end
|
2010-11-01 16:38:39 +00:00
|
|
|
mt.__newindex = function(t, k, v)
|
|
|
|
if (k~="_" and string.sub(k, 1, 2) ~= "__") then
|
|
|
|
error("Lsyncd does not allow GLOBALS to be created on the fly." ..
|
|
|
|
"Declare '" ..k.."' local or declare global on load.", 2)
|
|
|
|
else
|
|
|
|
rawset(t, k, v)
|
|
|
|
end
|
|
|
|
end
|
2010-10-31 22:25:34 +00:00
|
|
|
setmetatable(t, mt)
|
|
|
|
end
|
|
|
|
|
2010-11-02 14:11:26 +00:00
|
|
|
-----
|
|
|
|
-- Holds information about a delayed event for one origin/target.
|
|
|
|
--
|
|
|
|
local Delay = (function()
|
|
|
|
-----
|
|
|
|
-- Creates a new delay.
|
|
|
|
--
|
|
|
|
-- @param TODO
|
2010-11-02 17:07:42 +00:00
|
|
|
local function new(ename, pathname, alarm)
|
2010-11-02 14:11:26 +00:00
|
|
|
local o = {
|
|
|
|
ename = ename,
|
|
|
|
alarm = alarm,
|
|
|
|
pathname = pathname,
|
|
|
|
}
|
|
|
|
return o
|
|
|
|
end
|
2010-10-31 22:25:34 +00:00
|
|
|
|
2010-11-02 14:11:26 +00:00
|
|
|
return {new = new}
|
|
|
|
end)()
|
|
|
|
|
|
|
|
-----
|
2010-11-03 11:37:25 +00:00
|
|
|
-- Holds information about one observed directory inclusively subdirs.
|
2010-11-02 14:11:26 +00:00
|
|
|
--
|
|
|
|
local Origin = (function()
|
|
|
|
----
|
|
|
|
-- TODO
|
|
|
|
--
|
2010-11-02 17:07:42 +00:00
|
|
|
local function new(source, targetident, config)
|
2010-11-02 14:11:26 +00:00
|
|
|
local o = {
|
|
|
|
config = config,
|
|
|
|
delays = CountArray.new(),
|
|
|
|
delayname = {},
|
|
|
|
source = source,
|
|
|
|
targetident = targetident,
|
|
|
|
processes = CountArray.new(),
|
|
|
|
}
|
|
|
|
return o
|
|
|
|
end
|
|
|
|
|
|
|
|
-- public interface
|
|
|
|
return {new = new}
|
|
|
|
end)()
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Puts an action on the delay stack.
|
|
|
|
--
|
2010-11-03 11:37:25 +00:00
|
|
|
function Origin:delay(origin, ename, time, pathname, pathname2)
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Debug", "delay ", ename, " ", pathname)
|
2010-11-02 14:11:26 +00:00
|
|
|
local o = origin
|
|
|
|
local delays = o.delays
|
|
|
|
local delayname = o.delayname
|
|
|
|
|
|
|
|
if ename == "Move" and not o.config.move then
|
|
|
|
-- if there is no move action defined, split a move as delete/create
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Debug", "splitting Move into Delete & Create")
|
2010-11-02 14:11:26 +00:00
|
|
|
delay(o, "Delete", time, pathname, nil)
|
|
|
|
delay(o, "Create", time, pathname2, nil)
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
-- creates the new action
|
|
|
|
local alarm
|
|
|
|
-- TODO scope
|
|
|
|
if time and o.config.delay then
|
|
|
|
alarm = lsyncd.addto_clock(time, o.config.delay)
|
|
|
|
else
|
|
|
|
alarm = lsyncd.now()
|
|
|
|
end
|
|
|
|
local newd = Delay.new(ename, pathname, alarm)
|
|
|
|
|
|
|
|
local oldd = delayname[pathname]
|
|
|
|
if oldd then
|
|
|
|
-- if there is already a delay on this pathname.
|
|
|
|
-- decide what should happen with multiple delays.
|
|
|
|
if newd.ename == "MoveFrom" or newd.ename == "MoveTo" or
|
|
|
|
oldd.ename == "MoveFrom" or oldd.ename == "MoveTo" then
|
|
|
|
-- do not collapse moves
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "Not collapsing events with moves on ", pathname)
|
2010-11-02 14:11:26 +00:00
|
|
|
-- TODO stackinfo
|
|
|
|
return
|
|
|
|
else
|
|
|
|
local col = o.config.collapse_table[oldd.ename][newd.ename]
|
|
|
|
if col == -1 then
|
|
|
|
-- events cancel each other
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "Nullfication: ", newd.ename, " after ",
|
2010-11-02 17:07:42 +00:00
|
|
|
oldd.ename, " on ", pathname)
|
2010-11-02 14:13:45 +00:00
|
|
|
oldd.ename = "None"
|
2010-11-02 14:11:26 +00:00
|
|
|
return
|
|
|
|
elseif col == 0 then
|
|
|
|
-- events tack
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "Stacking ", newd.ename, " after ",
|
2010-11-02 17:07:42 +00:00
|
|
|
oldd.ename, " on ", pathname)
|
2010-11-02 14:11:26 +00:00
|
|
|
-- TODO Stack pointer
|
|
|
|
else
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "Collapsing ", newd.ename, " upon ",
|
2010-11-02 17:07:42 +00:00
|
|
|
oldd.ename, " to ", col, " on ", pathname)
|
2010-11-02 14:11:26 +00:00
|
|
|
oldd.ename = col
|
|
|
|
return
|
|
|
|
end
|
|
|
|
end
|
|
|
|
table.insert(delays, newd)
|
|
|
|
else
|
|
|
|
delayname[pathname] = newd
|
|
|
|
table.insert(delays, newd)
|
|
|
|
end
|
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
|
2010-11-02 14:11:26 +00:00
|
|
|
-----
|
|
|
|
-- Origins - a singleton
|
|
|
|
--
|
|
|
|
-- It maintains all configured directories to be synced.
|
|
|
|
--
|
|
|
|
local Origins = (function()
|
|
|
|
-- the list of all origins
|
|
|
|
local list = Array.new()
|
|
|
|
|
2010-11-02 20:18:05 +00:00
|
|
|
-----
|
2010-11-03 11:37:25 +00:00
|
|
|
-- inheritly copies all non integer keys from
|
2010-11-02 20:18:05 +00:00
|
|
|
-- @cd copy destination
|
2010-11-03 11:37:25 +00:00
|
|
|
-- to
|
2010-11-02 20:18:05 +00:00
|
|
|
-- @cs copy source
|
2010-11-03 11:37:25 +00:00
|
|
|
-- all integer keys are treated as new copy sources
|
|
|
|
--
|
2010-11-02 20:18:05 +00:00
|
|
|
local function inherit(cd, cs)
|
2010-11-03 11:37:25 +00:00
|
|
|
-- first recurses into all integer keyed tables
|
|
|
|
for i, v in ipairs(cs) do
|
|
|
|
if type(v) == "table" then
|
|
|
|
inherit(cd, v)
|
|
|
|
end
|
2010-11-02 20:18:05 +00:00
|
|
|
end
|
2010-11-03 11:37:25 +00:00
|
|
|
-- does nothing further if source == destination (first step)
|
|
|
|
if (cd == cs) then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
-- then copies from the source all non integer keyed values
|
2010-11-02 20:18:05 +00:00
|
|
|
for k, v in pairs(cs) do
|
2010-11-03 11:37:25 +00:00
|
|
|
if type(k) ~= "number" and not cd[k] then
|
2010-11-02 20:18:05 +00:00
|
|
|
cd[k] = v
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
-----
|
2010-11-03 11:37:25 +00:00
|
|
|
-- Adds a new directory to observe.
|
|
|
|
--
|
|
|
|
local function add(config)
|
|
|
|
inherit(config, config)
|
2010-11-02 20:18:05 +00:00
|
|
|
|
|
|
|
-- raises an error if 'name' isnt in opts
|
|
|
|
local function require_opt(name)
|
|
|
|
if not config[name] then
|
|
|
|
local info = debug.getinfo(3, "Sl")
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", info.short_src, ":", info.currentline,
|
2010-11-02 20:18:05 +00:00
|
|
|
": ", name, " missing from sync.")
|
|
|
|
terminate(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
end
|
|
|
|
require_opt("source")
|
|
|
|
require_opt("target")
|
|
|
|
|
2010-11-02 14:11:26 +00:00
|
|
|
-- absolute path of source
|
2010-11-02 20:18:05 +00:00
|
|
|
local real_src = lsyncd.real_dir(config.source)
|
2010-11-02 14:11:26 +00:00
|
|
|
if not real_src then
|
2010-11-02 20:18:05 +00:00
|
|
|
log(Error, "Cannot access source directory: ", config.source)
|
2010-11-02 14:11:26 +00:00
|
|
|
terminate(-1) -- ERRNO
|
|
|
|
end
|
2010-11-02 20:18:05 +00:00
|
|
|
config.source = real_src
|
|
|
|
|
|
|
|
if not config.action and not config.attrib and
|
|
|
|
not config.create and not config.modify and
|
|
|
|
not config.delete and not config.move
|
|
|
|
then
|
|
|
|
local info = debug.getinfo(2, "Sl")
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", info.short_src, ":", info.currentline,
|
2010-11-02 20:18:05 +00:00
|
|
|
": no actions specified, use e.g. 'config=default.rsync'.")
|
|
|
|
terminate(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
|
|
|
|
-- loads a default value for an option if not existent
|
|
|
|
local function optional(name)
|
|
|
|
if config[name] then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
config[name] = settings[name] or default[name]
|
|
|
|
end
|
2010-11-02 14:11:26 +00:00
|
|
|
|
2010-11-02 21:04:01 +00:00
|
|
|
optional("action")
|
2010-11-02 20:18:05 +00:00
|
|
|
optional("max_processes")
|
2010-11-02 21:04:01 +00:00
|
|
|
optional("collapse_table")
|
2010-11-02 20:18:05 +00:00
|
|
|
local o = Origin.new(config.source, config.target, config)
|
2010-11-02 14:11:26 +00:00
|
|
|
table.insert(list, o)
|
|
|
|
end
|
|
|
|
|
|
|
|
-- allows to walk through all origins
|
2010-11-02 17:07:42 +00:00
|
|
|
local function iwalk()
|
2010-11-02 14:11:26 +00:00
|
|
|
return ipairs(list)
|
|
|
|
end
|
|
|
|
|
|
|
|
-- returns the number of origins
|
|
|
|
local size = function()
|
|
|
|
return #list
|
|
|
|
end
|
|
|
|
|
|
|
|
-- public interface
|
|
|
|
return {add = add, iwalk = iwalk, size = size}
|
|
|
|
end)()
|
2010-10-25 17:38:57 +00:00
|
|
|
|
2010-10-17 15:24:55 +00:00
|
|
|
-----
|
2010-11-03 11:37:25 +00:00
|
|
|
-- Interface to inotify, watches recursively subdirs and
|
|
|
|
-- sends events.
|
2010-10-28 17:56:33 +00:00
|
|
|
--
|
2010-11-03 11:37:25 +00:00
|
|
|
-- All inotify specific implementation should be enclosed here.
|
|
|
|
-- So lsyncd can work with other notifications mechanisms just
|
|
|
|
-- by changing this.
|
2010-10-21 12:37:27 +00:00
|
|
|
--
|
2010-11-03 11:37:25 +00:00
|
|
|
local Inotifies = (function()
|
|
|
|
-----
|
|
|
|
-- A list indexed by inotifies watch descriptor.
|
|
|
|
-- Contains a list of all origins observing this directory
|
|
|
|
-- (directly or by recurse)
|
|
|
|
local wdlist = CountArray.new()
|
2010-10-17 15:24:55 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
|
|
|
-- Adds watches for a directory including all subdirectories.
|
|
|
|
--
|
|
|
|
-- @param path relative path of this dir to origin
|
|
|
|
-- @param origin link to the observer to be notified.
|
|
|
|
-- Note: Inotifies should handle this opaquely
|
|
|
|
-- @param recurse true if recursing into subdirs
|
|
|
|
--
|
|
|
|
local function add(path, origin, recurse)
|
|
|
|
-- register watch and receive watch descriptor
|
|
|
|
local wd = lsyncd.add_watch(path);
|
|
|
|
if wd < 0 then
|
|
|
|
-- failed adding the watch
|
|
|
|
log("Error", "Failure adding watch ", path, " -> ignored ")
|
|
|
|
return
|
|
|
|
end
|
2010-10-22 08:34:41 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
local ilist = wdlist[wd]
|
|
|
|
if not ilist then
|
|
|
|
ilist = Array.new()
|
|
|
|
wdlist[wd] = ilist
|
|
|
|
end
|
|
|
|
local inotify = { path = path, origin = origin, recurse = recurse}
|
|
|
|
table.insert(ilist, inotify)
|
|
|
|
|
|
|
|
-- registers and adds watches for all subdirectories
|
|
|
|
if recurse then
|
|
|
|
local subdirs = lsyncd.sub_dirs(path)
|
|
|
|
for _, dirname in ipairs(subdirs) do
|
|
|
|
add(path..dirname.."/", origin, true)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2010-10-25 14:55:40 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
|
|
|
-- Called when an event has occured.
|
|
|
|
--
|
|
|
|
-- @param ename "Attrib", "Mofify", "Create", "Delete", "Move")
|
|
|
|
-- @param wd watch descriptor (matches lsyncd.add_watch())
|
|
|
|
-- @param isdir true if filename is a directory
|
|
|
|
-- @param time time of event
|
|
|
|
-- @param filename string filename without path
|
|
|
|
-- @param filename2
|
|
|
|
--
|
|
|
|
function event(ename, wd, isdir, time, filename, filename2)
|
|
|
|
local ftype;
|
|
|
|
if isdir then
|
|
|
|
ftype = "directory"
|
|
|
|
else
|
|
|
|
ftype = "file"
|
|
|
|
end
|
|
|
|
if filename2 then
|
|
|
|
log("Debug", "got event ", ename, " of ", ftype, " ", filename,
|
|
|
|
" to ", filename2)
|
|
|
|
else
|
|
|
|
log("Debug", "got event ", ename, " of ", ftype, " ", filename)
|
|
|
|
end
|
2010-10-22 08:34:41 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
local ilist = wdlist[wd]
|
|
|
|
-- looks up the watch descriptor id
|
|
|
|
if not ilist then
|
|
|
|
-- this is normal in case of deleted subdirs
|
|
|
|
log("Normal", "event belongs to unknown/deleted watch descriptor.")
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
-- works through all observers interested in this directory
|
|
|
|
for _, inotify in ipairs(ilist) do
|
|
|
|
local pathname = inotify.path .. filename
|
|
|
|
local pathname2
|
|
|
|
if filename2 then
|
|
|
|
pathname2 = inotify.path..filename2
|
|
|
|
end
|
|
|
|
Origin.delay(inotify.origin, ename, time, pathname, pathname2)
|
|
|
|
-- add subdirs for new directories
|
|
|
|
if inotify.recurse and isdir then
|
|
|
|
if ename == "Create" then
|
|
|
|
add(pathname.."/", inotify.origin, true)
|
|
|
|
-- TODO remove /
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2010-10-17 15:24:55 +00:00
|
|
|
end
|
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
|
|
|
-- Writes a status report about inotifies to a filedescriptor
|
|
|
|
--
|
|
|
|
local function status_report(fd)
|
|
|
|
local w = lsyncd.writefd
|
|
|
|
w(fd, "Watching ", wdlist:size(), " directories\n")
|
|
|
|
for wd, v in wdlist:iwalk() do
|
|
|
|
w(fd, " ", wd, ": ")
|
|
|
|
for _, v in ipairs(v) do
|
|
|
|
print(v.origin)
|
|
|
|
print(v.path)
|
|
|
|
print(v.origin.source)
|
|
|
|
w(fd, "(", v.origin.source, "/", (v.path) or ")")
|
|
|
|
end
|
|
|
|
w(fd, "\n")
|
|
|
|
end
|
2010-10-17 15:24:55 +00:00
|
|
|
end
|
2010-10-22 12:58:57 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
|
|
|
-- Returns the number of directories watched in total.
|
|
|
|
local function size()
|
|
|
|
return wdlist:size()
|
2010-10-22 12:58:57 +00:00
|
|
|
end
|
2010-10-16 18:21:01 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-- public interface
|
|
|
|
return { add = add, size = size, status_report = status_report }
|
|
|
|
end)()
|
|
|
|
|
|
|
|
--============================================================================
|
|
|
|
-- lsyncd runner plugs. These functions will be called from core.
|
|
|
|
--============================================================================
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Called from core whenever a lua failed.
|
|
|
|
--
|
|
|
|
function lsyncd_call_error(message)
|
|
|
|
log("Error", "IN LUA: ", message)
|
|
|
|
-- prints backtrace
|
|
|
|
local level = 2
|
|
|
|
while true do
|
|
|
|
local info = debug.getinfo(level, "Sl")
|
|
|
|
if not info then
|
|
|
|
terminate(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
log("Error", "Backtrace ", level - 1, " :",
|
|
|
|
info.short_src, ":", info.currentline)
|
|
|
|
level = level + 1
|
2010-10-16 18:21:01 +00:00
|
|
|
end
|
|
|
|
end
|
2010-10-16 10:26:48 +00:00
|
|
|
|
2010-10-23 17:01:56 +00:00
|
|
|
-----
|
|
|
|
-- Called from code whenever a child process finished and
|
|
|
|
-- zombie process was collected by core.
|
|
|
|
--
|
2010-10-24 13:52:28 +00:00
|
|
|
function lsyncd_collect_process(pid, exitcode)
|
2010-11-01 17:54:09 +00:00
|
|
|
local delay = nil
|
|
|
|
local origin = nil
|
2010-11-02 14:11:26 +00:00
|
|
|
for _, o in Origins.iwalk() do
|
2010-11-01 17:54:09 +00:00
|
|
|
delay = o.processes[pid]
|
|
|
|
if delay then
|
|
|
|
origin = o
|
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if not delay then
|
2010-10-23 17:01:56 +00:00
|
|
|
return
|
|
|
|
end
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Debug", "collected ", pid, ": ",
|
2010-11-02 17:07:42 +00:00
|
|
|
delay.ename, " of ", origin.source, delay.pathname,
|
|
|
|
" = ", exitcode)
|
2010-10-31 22:25:34 +00:00
|
|
|
origin.processes[pid] = nil
|
2010-10-23 17:01:56 +00:00
|
|
|
end
|
2010-10-23 12:36:55 +00:00
|
|
|
|
2010-11-01 14:16:35 +00:00
|
|
|
------
|
2010-11-01 16:38:39 +00:00
|
|
|
-- Hidden key for lsyncd.lua internal variables not ment for
|
|
|
|
-- the user to see
|
2010-11-01 14:16:35 +00:00
|
|
|
--
|
2010-11-01 16:38:39 +00:00
|
|
|
local hk = {}
|
2010-11-01 14:16:35 +00:00
|
|
|
|
2010-11-01 16:38:39 +00:00
|
|
|
------
|
|
|
|
--- TODO
|
2010-11-01 17:54:09 +00:00
|
|
|
local inlet = {
|
2010-11-01 16:38:39 +00:00
|
|
|
[hk] = {
|
2010-11-01 19:57:53 +00:00
|
|
|
origin = true,
|
|
|
|
delay = true,
|
2010-11-01 16:38:39 +00:00
|
|
|
},
|
|
|
|
|
2010-11-01 19:57:53 +00:00
|
|
|
config = function(self)
|
|
|
|
return self[hk].origin.config
|
|
|
|
end,
|
|
|
|
|
2010-11-01 16:38:39 +00:00
|
|
|
nextevent = function(self)
|
|
|
|
local h = self[hk]
|
2010-11-01 14:16:35 +00:00
|
|
|
return {
|
2010-11-01 19:57:53 +00:00
|
|
|
spath = h.origin.source .. h.delay.pathname,
|
|
|
|
tpath = h.origin.targetident .. h.delay.pathname,
|
|
|
|
ename = h.delay.ename
|
2010-11-01 14:16:35 +00:00
|
|
|
}
|
|
|
|
end,
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-10-23 12:36:55 +00:00
|
|
|
-----
|
|
|
|
-- TODO
|
|
|
|
--
|
|
|
|
--
|
2010-10-31 22:25:34 +00:00
|
|
|
local function invoke_action(origin, delay)
|
|
|
|
local o = origin
|
2010-11-01 19:57:53 +00:00
|
|
|
local config = o.config
|
|
|
|
if delay.ename == "None" then
|
2010-10-26 11:26:57 +00:00
|
|
|
-- a removed action
|
|
|
|
return
|
2010-10-23 12:36:55 +00:00
|
|
|
end
|
|
|
|
|
2010-11-01 19:57:53 +00:00
|
|
|
inlet[hk].origin = origin
|
|
|
|
inlet[hk].delay = delay
|
|
|
|
local pid = config.action(inlet)
|
|
|
|
if pid and pid > 0 then
|
|
|
|
o.processes[pid] = delay
|
2010-10-23 12:36:55 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
2010-10-28 17:56:33 +00:00
|
|
|
----
|
|
|
|
-- Called from core to get a status report written into a file descriptor
|
|
|
|
--
|
|
|
|
function lsyncd_status_report(fd)
|
|
|
|
local w = lsyncd.writefd
|
2010-11-02 17:07:42 +00:00
|
|
|
w(fd, "Lsyncd status report at ", os.date(), "\n\n")
|
2010-11-03 11:37:25 +00:00
|
|
|
Inotifies.status_report(fd)
|
2010-10-28 17:56:33 +00:00
|
|
|
end
|
|
|
|
|
2010-10-22 23:14:11 +00:00
|
|
|
----
|
2010-10-23 12:36:55 +00:00
|
|
|
-- Called from core everytime at the latest of an
|
|
|
|
-- expired alarm (or more often)
|
|
|
|
--
|
2010-10-24 16:41:58 +00:00
|
|
|
-- @param now the time now
|
2010-10-23 12:36:55 +00:00
|
|
|
--
|
|
|
|
function lsyncd_alarm(now)
|
2010-10-24 13:52:28 +00:00
|
|
|
-- goes through all targets and spawns more actions
|
|
|
|
-- if possible
|
2010-11-02 14:11:26 +00:00
|
|
|
for _, o in Origins.iwalk() do
|
2010-11-03 11:37:25 +00:00
|
|
|
if o.processes:size() < o.config.max_processes then
|
2010-10-24 13:52:28 +00:00
|
|
|
local delays = o.delays
|
2010-10-26 11:26:57 +00:00
|
|
|
local d = delays[1]
|
|
|
|
if d and lsyncd.before_eq(d.alarm, now) then
|
2010-10-31 22:25:34 +00:00
|
|
|
invoke_action(o, d)
|
2010-10-24 13:52:28 +00:00
|
|
|
table.remove(delays, 1)
|
2010-10-31 22:25:34 +00:00
|
|
|
o.delayname[d.pathname] = nil -- TODO grab from stack
|
2010-10-24 13:52:28 +00:00
|
|
|
end
|
2010-10-23 12:36:55 +00:00
|
|
|
end
|
|
|
|
end
|
2010-10-22 23:14:11 +00:00
|
|
|
end
|
|
|
|
|
2010-10-27 09:06:13 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- Called by core before anything is "-help" or "--help" is in
|
|
|
|
-- the arguments.
|
|
|
|
--
|
|
|
|
function lsyncd_help()
|
2010-10-27 19:34:56 +00:00
|
|
|
io.stdout:write(
|
2010-10-27 09:06:13 +00:00
|
|
|
[[TODO this is a multiline
|
|
|
|
help
|
|
|
|
]])
|
|
|
|
os.exit(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
|
|
|
|
|
2010-10-17 15:24:55 +00:00
|
|
|
----
|
|
|
|
-- Called from core on init or restart after user configuration.
|
|
|
|
--
|
2010-10-25 21:41:45 +00:00
|
|
|
function lsyncd_initialize(args)
|
2010-10-27 19:34:56 +00:00
|
|
|
-- creates settings if user didnt
|
|
|
|
settings = settings or {}
|
|
|
|
|
2010-10-25 14:55:40 +00:00
|
|
|
-- From this point on, no globals may be created anymore
|
2010-11-01 17:54:09 +00:00
|
|
|
globals_lock()
|
2010-10-25 14:55:40 +00:00
|
|
|
|
2010-10-27 19:34:56 +00:00
|
|
|
-- parses all arguments
|
2010-10-27 09:06:13 +00:00
|
|
|
for i = 1, #args do
|
|
|
|
local a = args[i]
|
|
|
|
if a:sub(1, 1) ~= "-" then
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", "Unknown option ", a,
|
2010-10-27 19:34:56 +00:00
|
|
|
". Options must start with '-' or '--'.")
|
2010-10-27 09:06:13 +00:00
|
|
|
os.exit(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
if a:sub(1, 2) == "--" then
|
|
|
|
a = a:sub(3)
|
|
|
|
else
|
|
|
|
a = a:sub(2)
|
|
|
|
end
|
2010-11-01 16:38:39 +00:00
|
|
|
--TODO
|
2010-10-27 19:34:56 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
-- all valid settings, first value is 1 if it needs a parameter
|
|
|
|
local configure_settings = {
|
2010-10-28 17:56:33 +00:00
|
|
|
statusfile = {1, nil},
|
2010-10-27 19:34:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
-- check all entries in the settings table
|
|
|
|
for c, p in pairs(settings) do
|
|
|
|
local cs = configure_settings[c]
|
|
|
|
if not cs then
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", "unknown setting '", c, "'")
|
2010-10-27 19:34:56 +00:00
|
|
|
terminate(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
if cs[1] == 1 and not p then
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", "setting '", c, "' needs a parameter")
|
2010-10-27 19:34:56 +00:00
|
|
|
end
|
|
|
|
-- calls the check function if its not nil
|
|
|
|
if cs[2] then
|
|
|
|
cs[2](p)
|
|
|
|
end
|
|
|
|
lsyncd.configure(c, p)
|
2010-10-27 09:06:13 +00:00
|
|
|
end
|
2010-10-25 21:41:45 +00:00
|
|
|
|
2010-10-21 12:37:27 +00:00
|
|
|
-- makes sure the user gave lsyncd anything to do
|
2010-11-02 14:11:26 +00:00
|
|
|
if Origins.size() == 0 then
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", "Nothing to watch!")
|
|
|
|
log("Error", "Use sync(SOURCE, TARGET, BEHAVIOR) in your config file.");
|
2010-10-27 19:34:56 +00:00
|
|
|
terminate(-1) -- ERRNO
|
2010-10-21 12:37:27 +00:00
|
|
|
end
|
|
|
|
|
2010-10-22 12:58:57 +00:00
|
|
|
-- set to true if at least one origin has a startup function
|
|
|
|
local have_startup = false
|
2010-10-21 12:37:27 +00:00
|
|
|
-- runs through the origins table filled by user calling directory()
|
2010-11-02 14:11:26 +00:00
|
|
|
for _, o in Origins.iwalk() do
|
2010-11-02 20:18:05 +00:00
|
|
|
if o.config.startup then
|
2010-10-22 12:58:57 +00:00
|
|
|
have_startup = true
|
|
|
|
end
|
2010-11-01 18:08:03 +00:00
|
|
|
-- adds the dir watch inclusively all subdirs
|
2010-11-03 11:37:25 +00:00
|
|
|
Inotifies.add(o.source, "", true)
|
2010-10-17 15:24:55 +00:00
|
|
|
end
|
2010-11-01 18:08:03 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-- from now on use logging as configured instead of stdout/err.
|
2010-11-01 18:08:03 +00:00
|
|
|
lsyncd.configure("running");
|
2010-10-22 10:35:26 +00:00
|
|
|
|
2010-10-22 12:58:57 +00:00
|
|
|
if have_startup then
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "--- startup ---")
|
2010-10-22 12:58:57 +00:00
|
|
|
local pids = { }
|
2010-11-02 14:11:26 +00:00
|
|
|
for _, o in Origins.iwalk() do
|
2010-10-22 12:58:57 +00:00
|
|
|
local pid
|
2010-11-01 19:57:53 +00:00
|
|
|
if o.config.startup then
|
|
|
|
local pid = o.config.startup(o.source, o.targetident)
|
2010-10-22 12:58:57 +00:00
|
|
|
table.insert(pids, pid)
|
|
|
|
end
|
2010-10-22 10:35:26 +00:00
|
|
|
end
|
2010-10-22 12:58:57 +00:00
|
|
|
lsyncd.wait_pids(pids, "startup_collector")
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "- Entering normal operation with ",
|
2010-11-03 11:37:25 +00:00
|
|
|
Inotifies.size(), " monitored directories -")
|
2010-10-22 12:58:57 +00:00
|
|
|
else
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "- Warmstart into normal operation with ",
|
2010-11-03 11:37:25 +00:00
|
|
|
Inotifies.size(), " monitored directories -")
|
2010-10-22 10:35:26 +00:00
|
|
|
end
|
2010-10-17 15:24:55 +00:00
|
|
|
end
|
|
|
|
|
2010-10-19 10:12:11 +00:00
|
|
|
----
|
2010-10-21 12:37:27 +00:00
|
|
|
-- Called by core to query soonest alarm.
|
2010-10-19 10:12:11 +00:00
|
|
|
--
|
|
|
|
-- @return two variables.
|
2010-10-24 16:41:58 +00:00
|
|
|
-- boolean false ... no alarm, core can in untimed sleep
|
|
|
|
-- true ... alarm time specified.
|
2010-10-19 10:12:11 +00:00
|
|
|
-- times ... the alarm time (only read if number is 1)
|
|
|
|
function lsyncd_get_alarm()
|
2010-10-24 16:41:58 +00:00
|
|
|
local have_alarm = false
|
|
|
|
local alarm = 0
|
2010-11-02 14:11:26 +00:00
|
|
|
for _, o in Origins.iwalk() do
|
2010-10-26 11:26:57 +00:00
|
|
|
if o.delays[1] and
|
2010-11-03 11:37:25 +00:00
|
|
|
o.processes:size() < o.config.max_processes then
|
2010-10-24 16:41:58 +00:00
|
|
|
if have_alarm then
|
|
|
|
alarm = lsyncd.earlier(alarm, o.delays[1].alarm)
|
|
|
|
else
|
|
|
|
alarm = o.delays[1].alarm
|
|
|
|
have_alarm = true
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
return have_alarm, alarm
|
2010-10-19 10:12:11 +00:00
|
|
|
end
|
2010-10-17 15:24:55 +00:00
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
lsyncd_inotify_event = Inotifies.event
|
2010-10-21 12:37:27 +00:00
|
|
|
|
|
|
|
-----
|
2010-10-24 13:52:28 +00:00
|
|
|
-- Collector for every child process that finished in startup phase
|
2010-10-21 12:37:27 +00:00
|
|
|
--
|
|
|
|
-- Parameters are pid and exitcode of child process
|
|
|
|
--
|
|
|
|
-- Can return either a new pid if one other child process
|
|
|
|
-- has been spawned as replacement (e.g. retry) or 0 if
|
|
|
|
-- finished/ok.
|
|
|
|
--
|
2010-10-22 10:40:59 +00:00
|
|
|
function startup_collector(pid, exitcode)
|
2010-10-21 12:37:27 +00:00
|
|
|
if exitcode ~= 0 then
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", "Startup process", pid, " failed")
|
2010-10-27 19:34:56 +00:00
|
|
|
terminate(-1) -- ERRNO
|
2010-10-20 13:01:26 +00:00
|
|
|
end
|
2010-10-21 12:37:27 +00:00
|
|
|
return 0
|
2010-10-20 10:25:34 +00:00
|
|
|
end
|
|
|
|
|
2010-10-21 12:37:27 +00:00
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
--============================================================================
|
2010-10-17 15:24:55 +00:00
|
|
|
-- lsyncd user interface
|
2010-10-25 17:38:57 +00:00
|
|
|
--============================================================================
|
2010-10-17 15:24:55 +00:00
|
|
|
|
2010-11-02 14:11:26 +00:00
|
|
|
sync = Origins.add
|
2010-10-17 15:24:55 +00:00
|
|
|
|
2010-10-19 16:40:49 +00:00
|
|
|
----
|
|
|
|
-- Called by core when an overflow happened.
|
2010-10-27 11:31:18 +00:00
|
|
|
--
|
2010-10-19 16:40:49 +00:00
|
|
|
function default_overflow()
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Error", "--- OVERFLOW on inotify event queue ---")
|
2010-10-27 19:34:56 +00:00
|
|
|
terminate(-1) -- TODO reset instead.
|
2010-10-19 16:40:49 +00:00
|
|
|
end
|
|
|
|
overflow = default_overflow
|
|
|
|
|
2010-10-27 11:31:18 +00:00
|
|
|
-----
|
|
|
|
-- Spawns a child process using bash.
|
|
|
|
--
|
|
|
|
function shell(command, ...)
|
|
|
|
return exec("/bin/sh", "-c", command, "/bin/sh", ...)
|
|
|
|
end
|
|
|
|
|
2010-10-26 11:26:57 +00:00
|
|
|
--============================================================================
|
|
|
|
-- lsyncd default settings
|
|
|
|
--============================================================================
|
|
|
|
|
2010-10-27 19:34:56 +00:00
|
|
|
-----
|
|
|
|
-- lsyncd classic - sync with rsync
|
|
|
|
--
|
|
|
|
local default_rsync = {
|
|
|
|
----
|
|
|
|
-- Called for every sync/target pair on startup
|
|
|
|
startup = function(source, target)
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "startup recursive rsync: ", source, " -> ", target)
|
2010-10-27 19:34:56 +00:00
|
|
|
return exec("/usr/bin/rsync", "-ltrs",
|
|
|
|
source, target)
|
|
|
|
end,
|
|
|
|
|
|
|
|
default = function(source, target, path)
|
|
|
|
return exec("/usr/bin/rsync", "--delete", "-ltds",
|
2010-11-02 17:07:42 +00:00
|
|
|
source.."/"..path, target.."/"..path)
|
2010-10-27 19:34:56 +00:00
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
-----
|
2010-11-02 20:18:05 +00:00
|
|
|
-- The default table for the user to access
|
|
|
|
-- TODO make readonly
|
|
|
|
--
|
|
|
|
default = {
|
|
|
|
-----
|
|
|
|
-- Default action
|
|
|
|
-- TODO desc
|
|
|
|
--
|
|
|
|
action = function(inlet)
|
|
|
|
local event = inlet:nextevent()
|
|
|
|
local func = inlet:config()[string.lower(event.ename)]
|
|
|
|
if func then
|
|
|
|
return func(event)
|
|
|
|
else
|
|
|
|
return -1
|
|
|
|
end
|
|
|
|
end,
|
|
|
|
|
2010-10-26 11:26:57 +00:00
|
|
|
-----
|
|
|
|
-- TODO
|
|
|
|
--
|
|
|
|
max_processes = 1,
|
2010-10-27 19:34:56 +00:00
|
|
|
|
2010-10-26 11:26:57 +00:00
|
|
|
------
|
|
|
|
-- TODO
|
|
|
|
--
|
|
|
|
collapse_table = {
|
2010-11-01 19:57:53 +00:00
|
|
|
Attrib = { Attrib = "Attrib", Modify = "Modify", Create = "Create", Delete = "Delete" },
|
|
|
|
Modify = { Attrib = "Modify", Modify = "Modify", Create = "Create", Delete = "Delete" },
|
|
|
|
Create = { Attrib = "Create", Modify = "Create", Create = "Create", Delete = -1 },
|
|
|
|
Delete = { Attrib = "Delete", Modify = "Delete", Create = "Modify", Delete = "Delete" },
|
2010-10-27 19:34:56 +00:00
|
|
|
},
|
|
|
|
|
|
|
|
rsync = default_rsync
|
2010-10-26 11:26:57 +00:00
|
|
|
}
|
|
|
|
|
2010-10-25 14:55:40 +00:00
|
|
|
|