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-20 18:33:17 +00:00
|
|
|
print("You cannot use the lsyncd runner as configuration file!")
|
2010-10-19 21:56:00 +00:00
|
|
|
os.exit(-1)
|
|
|
|
end
|
2010-10-18 17:09:59 +00:00
|
|
|
lsyncd_version = "2.0b1"
|
|
|
|
|
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-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
|
|
|
-----
|
|
|
|
-- Metatable to limit keys to numerics.
|
2010-10-25 14:55:40 +00:00
|
|
|
--
|
2010-10-25 17:38:57 +00:00
|
|
|
local meta_check_array = {
|
|
|
|
__index = function(t, k)
|
|
|
|
if type(k) ~= "number" then
|
|
|
|
error("This table is an array and must have numeric keys", 2)
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
return rawget(t, k)
|
|
|
|
end,
|
|
|
|
__newindex = function(t, k, v)
|
|
|
|
if type(k) ~= "number" then
|
|
|
|
error("This table is an array and must have numeric keys", 2)
|
|
|
|
end
|
|
|
|
rawset(t, k, v)
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
}
|
2010-10-25 14:55:40 +00:00
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
-----
|
|
|
|
-- Metatable to limit keys to numerics and count the number of entries.
|
|
|
|
-- Lua's # operator does not work on tables which key values are not
|
|
|
|
-- strictly linear.
|
|
|
|
--
|
|
|
|
local meta_check_count_array = {
|
|
|
|
__index = function(t, k)
|
|
|
|
if k == size then
|
|
|
|
return rawget(t, "size")
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
if type(k) ~= "number" then
|
|
|
|
error("This table is an array and must have numeric keys", 2)
|
|
|
|
end
|
|
|
|
return rawget(t, "_t")[k]
|
|
|
|
end,
|
|
|
|
|
|
|
|
__newindex = function(t, k, v)
|
|
|
|
if type(k) ~= "number" then
|
|
|
|
error("This table is an array and must have numeric keys", 2)
|
|
|
|
end
|
|
|
|
local _t = rawget(t, "_t")
|
|
|
|
local vb = _t[k]
|
|
|
|
if v and not vb then
|
|
|
|
rawset(t, "size", rawget(t, "size") + 1)
|
|
|
|
elseif not v and vb then
|
|
|
|
rawset(t, "size", rawget(t, "size") - 1)
|
|
|
|
end
|
|
|
|
_t[k] = v
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
}
|
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
|
|
|
|
error("This table does not have key '"..k.."' in its prototype.", 2)
|
|
|
|
end
|
|
|
|
return rawget(t, k)
|
|
|
|
end,
|
|
|
|
__newindex = function(t, k, v)
|
|
|
|
if not t.prototype[k] then
|
|
|
|
error("This table does not have key '"..k.."' in its prototype.", 2)
|
2010-10-25 14:55:40 +00:00
|
|
|
end
|
|
|
|
rawset(t, k, v)
|
|
|
|
end
|
2010-10-25 17:38:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Limits the keys of table to numbers.
|
|
|
|
--
|
|
|
|
local function set_array(t)
|
|
|
|
for k, _ in pairs(t) do
|
|
|
|
if type(k) ~= "number" then
|
|
|
|
error("This table cannot be set as array, it has non-numberic key '"..k.."'", 2)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
setmetatable(t, meta_check_array)
|
|
|
|
end
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Creates a table with keys limited to numbers.
|
|
|
|
--
|
|
|
|
local function new_array()
|
|
|
|
local t = {}
|
|
|
|
setmetatable(t, meta_ckeck_array)
|
|
|
|
return t
|
|
|
|
end
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Creates a table with keys limited to numbers and
|
|
|
|
-- which counts the number of entries
|
|
|
|
--
|
|
|
|
local function new_count_array()
|
|
|
|
local t = { size = 0, _t = {} }
|
|
|
|
setmetatable(t, meta_check_count_array)
|
|
|
|
return t
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- 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
|
|
|
|
error("Cannot set prototype of table, conflicting key: '"..k.."'.", 2)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
setmetatable(t, proto_check_table)
|
|
|
|
end
|
|
|
|
|
|
|
|
----
|
|
|
|
-- Locks a table
|
|
|
|
local function GLOBAL_lock(t)
|
|
|
|
local mt = getmetatable(t) or {}
|
|
|
|
mt.__newindex = lock_new_index
|
2010-10-25 14:55:40 +00:00
|
|
|
setmetatable(t, mt)
|
|
|
|
end
|
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
----
|
|
|
|
-- Unlocks a table
|
|
|
|
---
|
|
|
|
local function GLOBAL_unlock(t)
|
|
|
|
local mt = getmetatable(t) or {}
|
|
|
|
mt.__newindex = unlock_new_index
|
|
|
|
setmetatable(t, mt)
|
|
|
|
end
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- ?
|
|
|
|
local function lock_new_index(t, k, v)
|
|
|
|
if (k~="_" and string.sub(k,1,2) ~= "__") then
|
|
|
|
GLOBAL_unlock(_G)
|
|
|
|
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
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- ?
|
|
|
|
local function unlock_new_index(t, k, v)
|
|
|
|
rawset(t, k, v)
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
|
|
--============================================================================
|
|
|
|
-- Lsyncd globals
|
|
|
|
--============================================================================
|
|
|
|
|
|
|
|
|
2010-10-17 15:24:55 +00:00
|
|
|
----
|
2010-10-22 12:58:57 +00:00
|
|
|
-- Table of all root directories to sync,
|
|
|
|
-- filled during initialization.
|
|
|
|
--
|
|
|
|
-- [#] {
|
|
|
|
-- actions = actions,
|
|
|
|
-- source = source_dir,
|
2010-10-24 13:52:28 +00:00
|
|
|
-- targetident = the identifier of target (like string "host:dir")
|
|
|
|
-- for lsyncd this passed competly opaquely to the
|
|
|
|
-- action handlers
|
2010-10-21 12:37:27 +00:00
|
|
|
--
|
2010-10-24 13:52:28 +00:00
|
|
|
-- .processes = [pid] .. a sublist of processes[] for this target
|
|
|
|
-- .delays = [#) { .. the delays stack
|
|
|
|
-- .atype .. enum, kind of action
|
2010-10-24 16:41:58 +00:00
|
|
|
-- .alarm .. when it should fire
|
2010-10-24 13:52:28 +00:00
|
|
|
-- .wd .. watch descriptor id this origins from TODO needed?
|
|
|
|
-- .sync .. link to sync that raised this delay.
|
|
|
|
-- .filename .. filename or nil (=dir itself)
|
|
|
|
-- (.movepeer) .. for MOVEFROM/MOVETO link to other delay
|
2010-10-22 08:37:15 +00:00
|
|
|
-- }
|
2010-10-26 11:26:57 +00:00
|
|
|
-- .delaywd [wd] = [#] .. a list of lists of all delays from a watch descriptor.
|
2010-10-21 12:37:27 +00:00
|
|
|
-- }
|
2010-10-22 12:58:57 +00:00
|
|
|
--
|
2010-10-25 17:38:57 +00:00
|
|
|
local origins = new_array()
|
2010-10-26 11:26:57 +00:00
|
|
|
local proto_origin = {actions=true, source=true, targetident=true, processes=true, delays=true, delaywd=true}
|
|
|
|
local proto_delay = {atype =true, alarm=true, wd=true, sync=true, filename=true, movepeer=true}
|
2010-10-17 15:24:55 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- all watches
|
2010-10-21 12:37:27 +00:00
|
|
|
--
|
|
|
|
-- structure:
|
|
|
|
-- [wd] = {
|
2010-10-22 12:58:57 +00:00
|
|
|
-- .wd .. the watch descriptor (TODO needed?)
|
|
|
|
-- .syncs = [#] { list of stuff to sync to
|
|
|
|
-- .origin .. link to origin
|
|
|
|
-- .path .. relative path of dir
|
|
|
|
-- .parent .. link to parent directory in watches
|
|
|
|
-- or nil for origin
|
|
|
|
-- }
|
2010-10-21 12:37:27 +00:00
|
|
|
-- }
|
|
|
|
--
|
2010-10-25 17:38:57 +00:00
|
|
|
local watches = new_count_array()
|
|
|
|
local proto_watch = {wd=true, syncs=true}
|
|
|
|
local proto_sync = {origin=true, path=true, parent=true}
|
2010-10-17 15:24:55 +00:00
|
|
|
|
2010-10-23 17:01:56 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- a dictionary of all processes lsyncd spawned.
|
|
|
|
--
|
|
|
|
-- structure
|
|
|
|
-- [pid] = {
|
|
|
|
-- target ..
|
2010-10-25 14:55:40 +00:00
|
|
|
-- atype ..
|
2010-10-23 17:01:56 +00:00
|
|
|
-- wd ..
|
|
|
|
-- sync ..
|
|
|
|
-- filename ..
|
|
|
|
--
|
2010-10-25 17:38:57 +00:00
|
|
|
local processes = new_count_array()
|
|
|
|
local proto_process = {pid=true, atype=true, wd=true, sync=true, filename=true}
|
2010-10-23 17:01:56 +00:00
|
|
|
|
2010-10-22 08:34:41 +00:00
|
|
|
|
2010-10-22 13:12:13 +00:00
|
|
|
-----
|
|
|
|
-- A list of names of the event types the core sends.
|
|
|
|
--
|
|
|
|
local event_names = {
|
|
|
|
[ATTRIB ] = "Attrib",
|
|
|
|
[MODIFY ] = "Modify",
|
|
|
|
[CREATE ] = "Create",
|
|
|
|
[DELETE ] = "Delete",
|
|
|
|
[MOVE ] = "Move",
|
|
|
|
[MOVEFROM ] = "MoveFrom",
|
|
|
|
[MOVETO ] = "MoveTo",
|
|
|
|
}
|
2010-10-25 17:38:57 +00:00
|
|
|
set_array(event_names)
|
2010-10-22 08:34:41 +00:00
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
--============================================================================
|
2010-10-25 14:55:40 +00:00
|
|
|
-- The lsyncd runner
|
2010-10-25 17:38:57 +00:00
|
|
|
--============================================================================
|
2010-10-25 14:55:40 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- Puts an action on the delay stack.
|
2010-10-23 10:58:43 +00:00
|
|
|
--
|
2010-10-27 09:41:14 +00:00
|
|
|
local function delay_action(atype, wd, sync, time, filename, filename2)
|
2010-10-24 14:18:14 +00:00
|
|
|
log(DEBUG, "delay_action "..event_names[atype].."("..wd..") ")
|
2010-10-26 11:26:57 +00:00
|
|
|
local o = sync.origin
|
|
|
|
local delays = o.delays
|
|
|
|
local delaywd = o.delaywd
|
2010-10-27 09:41:14 +00:00
|
|
|
|
|
|
|
if atype == MOVE and not o.actions.move then
|
|
|
|
-- if there is no move action defined, split a move as delete/create
|
|
|
|
log(DEBUG, "splitting MOVE into DELETE & CREATE")
|
|
|
|
delay_action(DELETE, wd, sync, time, filename, nil)
|
|
|
|
delay_action(CREATE, wd, sync, time, filename2, nil)
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
2010-10-26 11:26:57 +00:00
|
|
|
local newd = {atype = atype,
|
|
|
|
wd = wd,
|
|
|
|
sync = sync,
|
|
|
|
filename = filename }
|
|
|
|
set_prototype(newd, proto_delay)
|
|
|
|
if time and o.actions.delay then
|
|
|
|
newd.alarm = lsyncd.addto_clock(time, o.actions.delay)
|
|
|
|
else
|
|
|
|
newd.alarm = lsyncd.now()
|
|
|
|
end
|
|
|
|
|
|
|
|
local dwd = delaywd[wd]
|
|
|
|
if not dwd then
|
|
|
|
dwd = {}
|
|
|
|
delaywd[wd] = dwd
|
|
|
|
end
|
|
|
|
|
|
|
|
if dwd[filename] then
|
2010-10-27 09:41:14 +00:00
|
|
|
-- if there is already
|
2010-10-26 11:26:57 +00:00
|
|
|
local oldd = dwd[filename]
|
|
|
|
if newd.atype == MOVE_FROM or newd.atype == MOVE_TO or
|
|
|
|
oldd.atype == MOVE_FROM or oldd.atype == MOVE_TO then
|
|
|
|
-- do not collapse moves
|
|
|
|
log(NORMAL, "Not collapsing events with moves on "..filename)
|
|
|
|
-- TODO stackinfo
|
|
|
|
return
|
|
|
|
else
|
|
|
|
local col = o.actions.collapse_table[oldd.atype][newd.atype]
|
|
|
|
if col == -1 then
|
|
|
|
-- events cancel each other
|
|
|
|
log(NORMAL, "Nullfication: " ..event_names[newd.atype].." after "..
|
|
|
|
event_names[oldd.atype].." on "..filename)
|
|
|
|
oldd.atype = NONE
|
|
|
|
return
|
|
|
|
elseif col == 0 then
|
|
|
|
-- events tack
|
|
|
|
log(NORMAL, "Stacking " ..event_names[newd.atype].." after "..
|
|
|
|
event_names[oldd.atype].." on "..filename)
|
|
|
|
-- TODO stackinfo
|
|
|
|
else
|
|
|
|
log(NORMAL, "Collapsing "..event_names[newd.atype].." upon "..
|
|
|
|
event_names[oldd.atype].." to " ..
|
|
|
|
event_names[col].." on "..filename)
|
|
|
|
oldd.atype = col
|
|
|
|
return
|
|
|
|
end
|
|
|
|
end
|
|
|
|
table.insert(delays, newd)
|
2010-10-24 16:41:58 +00:00
|
|
|
else
|
2010-10-26 11:26:57 +00:00
|
|
|
dwd[filename] = newd
|
|
|
|
table.insert(delays, newd)
|
2010-10-22 23:14:11 +00:00
|
|
|
end
|
2010-10-22 08:34:41 +00:00
|
|
|
end
|
|
|
|
|
2010-10-16 18:21:01 +00:00
|
|
|
----
|
|
|
|
-- Adds watches for a directory including all subdirectories.
|
|
|
|
--
|
2010-10-22 12:58:57 +00:00
|
|
|
-- @param origin link to origins[] entry
|
|
|
|
-- @param path relative path of this dir to origin
|
2010-10-21 12:37:27 +00:00
|
|
|
-- @param parent link to parent directory in watches[]
|
2010-10-18 09:02:51 +00:00
|
|
|
--
|
2010-10-22 12:58:57 +00:00
|
|
|
local function attend_dir(origin, path, parent)
|
|
|
|
local op = origin.source .. path
|
2010-10-17 15:24:55 +00:00
|
|
|
-- register watch and receive watch descriptor
|
|
|
|
local wd = lsyncd.add_watch(op);
|
|
|
|
if wd < 0 then
|
|
|
|
-- failed adding the watch
|
2010-10-22 12:58:57 +00:00
|
|
|
log(ERROR, "Failure adding watch "..op.." -> ignored ")
|
2010-10-17 15:24:55 +00:00
|
|
|
return
|
|
|
|
end
|
|
|
|
|
2010-10-21 12:37:27 +00:00
|
|
|
local thiswatch = watches[wd]
|
2010-10-26 11:26:57 +00:00
|
|
|
if not thiswatch then
|
2010-10-17 15:24:55 +00:00
|
|
|
-- new watch
|
2010-10-22 12:58:57 +00:00
|
|
|
thiswatch = {wd = wd, syncs = {} }
|
2010-10-25 17:38:57 +00:00
|
|
|
set_prototype(thiswatch, proto_watch)
|
2010-10-21 12:37:27 +00:00
|
|
|
watches[wd] = thiswatch
|
2010-10-17 15:24:55 +00:00
|
|
|
end
|
2010-10-22 12:58:57 +00:00
|
|
|
local sync = { origin = origin, path = path, parent = parent }
|
2010-10-25 17:38:57 +00:00
|
|
|
set_prototype(sync, proto_sync)
|
2010-10-22 12:58:57 +00:00
|
|
|
table.insert(thiswatch.syncs, sync)
|
|
|
|
|
2010-10-27 09:41:14 +00:00
|
|
|
-- on a warmstart add a CREATE for the directory
|
2010-10-26 11:26:57 +00:00
|
|
|
if not origin.actions.startup then
|
2010-10-27 09:41:14 +00:00
|
|
|
delay_action(CREATE, wd, sync, nil, nil, nil)
|
2010-10-22 12:58:57 +00:00
|
|
|
end
|
2010-10-16 18:21:01 +00:00
|
|
|
|
2010-10-23 17:01:56 +00:00
|
|
|
-- registers and adds watches for all subdirectories
|
2010-10-21 12:37:27 +00:00
|
|
|
local subdirs = lsyncd.sub_dirs(op);
|
2010-10-25 14:55:40 +00:00
|
|
|
for _, dirname in ipairs(subdirs) do
|
2010-10-22 12:58:57 +00:00
|
|
|
attend_dir(origin, path..dirname.."/", thiswatch)
|
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-10-24 14:18:14 +00:00
|
|
|
log(DEBUG, "collected "..pid)
|
2010-10-24 13:52:28 +00:00
|
|
|
local process = processes[pid]
|
2010-10-26 11:26:57 +00:00
|
|
|
if not process then
|
2010-10-23 17:01:56 +00:00
|
|
|
return
|
|
|
|
end
|
2010-10-24 13:52:28 +00:00
|
|
|
local sync = process.sync
|
2010-10-25 17:38:57 +00:00
|
|
|
local o = sync.origin
|
|
|
|
print("collected ", pid, ": ", event_names[process.atype], o.source, "/", sync.path , process.filename, " = ", exitcode)
|
2010-10-24 13:52:28 +00:00
|
|
|
processes[pid] = nil
|
2010-10-25 17:38:57 +00:00
|
|
|
o.processes[pid] = nil
|
2010-10-23 17:01:56 +00:00
|
|
|
end
|
2010-10-23 12:36:55 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- TODO
|
|
|
|
--
|
|
|
|
--
|
2010-10-24 13:52:28 +00:00
|
|
|
local function invoke_action(delay)
|
2010-10-23 12:36:55 +00:00
|
|
|
local sync = delay.sync
|
|
|
|
local origin = sync.origin
|
|
|
|
local actions = origin.actions
|
|
|
|
local func = nil
|
2010-10-26 11:26:57 +00:00
|
|
|
local atype = delay.atype
|
|
|
|
if atype == NONE then
|
|
|
|
-- a removed action
|
|
|
|
return
|
|
|
|
elseif atype == CREATE then
|
|
|
|
func = actions.create or actions.default
|
|
|
|
elseif atype == ATTRIB then
|
|
|
|
func = actions.attrib or actions.default
|
|
|
|
elseif atype == MODIFY then
|
|
|
|
func = actions.modify or actions.default
|
|
|
|
elseif atype == DELETE then
|
|
|
|
func = actions.delete or actions.default
|
|
|
|
elseif atype == MOVE then
|
|
|
|
log(ERROR, "MOVE NOT YET IMPLEMENTED!") -- TODO
|
2010-10-23 12:36:55 +00:00
|
|
|
end
|
|
|
|
|
2010-10-26 11:26:57 +00:00
|
|
|
if func then
|
2010-10-25 14:55:40 +00:00
|
|
|
local pid = func(origin.source, sync.path, delay.filename, origin.targetident)
|
2010-10-26 11:26:57 +00:00
|
|
|
if pid and pid > 0 then
|
2010-10-25 14:55:40 +00:00
|
|
|
local process = {pid = pid,
|
2010-10-25 17:38:57 +00:00
|
|
|
atype = delay.atype,
|
|
|
|
wd = delay.wd,
|
|
|
|
sync = delay.sync,
|
|
|
|
filename = delay.filename
|
2010-10-23 17:01:56 +00:00
|
|
|
}
|
2010-10-25 17:38:57 +00:00
|
|
|
set_prototype(process, proto_process)
|
2010-10-24 13:52:28 +00:00
|
|
|
processes[pid] = process
|
|
|
|
origin.processes[pid] = process
|
2010-10-23 17:01:56 +00:00
|
|
|
end
|
2010-10-23 12:36:55 +00:00
|
|
|
end
|
|
|
|
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-10-25 14:55:40 +00:00
|
|
|
for _, o in ipairs(origins) do
|
2010-10-25 17:38:57 +00:00
|
|
|
if o.processes.size < o.actions.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
|
|
|
|
invoke_action(d)
|
2010-10-24 13:52:28 +00:00
|
|
|
table.remove(delays, 1)
|
2010-10-26 11:26:57 +00:00
|
|
|
o.delaywd[d.wd][d.filename] = nil
|
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()
|
|
|
|
io.stderr:write(
|
|
|
|
[[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-25 14:55:40 +00:00
|
|
|
-- From this point on, no globals may be created anymore
|
|
|
|
GLOBAL_lock(_G)
|
|
|
|
|
2010-10-27 09:06:13 +00:00
|
|
|
for i = 1, #args do
|
|
|
|
local a = args[i]
|
|
|
|
if a:sub(1, 1) ~= "-" then
|
|
|
|
io.stderr:write("Unknown option "..a..". Options must start with '-' or '--'.\n")
|
|
|
|
os.exit(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
if a:sub(1, 2) == "--" then
|
|
|
|
a = a:sub(3)
|
|
|
|
else
|
|
|
|
a = a:sub(2)
|
|
|
|
end
|
|
|
|
print(i, a)
|
|
|
|
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
|
|
|
|
if #origins == 0 then
|
|
|
|
log(ERROR, "nothing to watch. Use directory(SOURCEDIR, TARGET) in your config file.");
|
|
|
|
lsyncd.terminate(-1) -- ERRNO
|
|
|
|
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-10-26 11:26:57 +00:00
|
|
|
for _, o in ipairs(origins) do
|
2010-10-18 09:02:51 +00:00
|
|
|
-- resolves source to be an absolute path
|
2010-10-26 11:26:57 +00:00
|
|
|
local asrc = lsyncd.real_dir(o.source)
|
|
|
|
local actions = o.actions
|
|
|
|
if not asrc then
|
|
|
|
print("Cannot resolve source path: ", o.source)
|
2010-10-21 12:37:27 +00:00
|
|
|
lsyncd.terminate(-1) -- ERRNO
|
2010-10-18 09:02:51 +00:00
|
|
|
end
|
2010-10-26 11:26:57 +00:00
|
|
|
o.source = asrc
|
|
|
|
o.delays = new_count_array()
|
|
|
|
o.delaywd = new_array()
|
|
|
|
o.processes = new_count_array()
|
|
|
|
|
|
|
|
actions.max_processes =
|
|
|
|
actions.max_processes or
|
|
|
|
settings.max_processes or
|
|
|
|
defaults.max_processes
|
|
|
|
|
|
|
|
actions.collapse_table =
|
|
|
|
actions.collapse_table or
|
|
|
|
settings.collapse_table or
|
|
|
|
defaults.collapse_table
|
|
|
|
|
|
|
|
if actions.startup then
|
2010-10-22 12:58:57 +00:00
|
|
|
have_startup = true
|
|
|
|
end
|
2010-10-24 13:52:28 +00:00
|
|
|
|
2010-10-18 09:02:51 +00:00
|
|
|
-- and add the dir watch inclusively all subdirs
|
2010-10-26 11:26:57 +00:00
|
|
|
attend_dir(o, "", nil)
|
2010-10-17 15:24:55 +00:00
|
|
|
end
|
2010-10-22 10:35:26 +00:00
|
|
|
|
2010-10-22 12:58:57 +00:00
|
|
|
if have_startup then
|
|
|
|
log(NORMAL, "--- startup ---")
|
|
|
|
local pids = { }
|
2010-10-26 11:26:57 +00:00
|
|
|
for _, o in ipairs(origins) do
|
2010-10-22 12:58:57 +00:00
|
|
|
local pid
|
2010-10-26 11:26:57 +00:00
|
|
|
if o.actions.startup then
|
|
|
|
local pid = o.actions.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-10-25 17:38:57 +00:00
|
|
|
log(NORMAL, "--- Entering normal operation with "..watches.size.." monitored directories ---")
|
2010-10-22 12:58:57 +00:00
|
|
|
else
|
2010-10-25 17:38:57 +00:00
|
|
|
log(NORMAL, "--- Warmstart into normal operation with "..watches.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-10-25 14:55:40 +00:00
|
|
|
for _, o in ipairs(origins) do
|
2010-10-26 11:26:57 +00:00
|
|
|
if o.delays[1] and
|
2010-10-25 17:38:57 +00:00
|
|
|
o.processes.size < o.actions.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-10-20 10:25:34 +00:00
|
|
|
-----
|
|
|
|
-- Called by core on inotify event
|
|
|
|
--
|
2010-10-20 13:01:26 +00:00
|
|
|
-- @param etype enum (ATTRIB, MODIFY, CREATE, DELETE, MOVE)
|
|
|
|
-- @param wd watch descriptor (matches lsyncd.add_watch())
|
2010-10-24 16:41:58 +00:00
|
|
|
-- @param time time of event
|
2010-10-20 13:01:26 +00:00
|
|
|
-- @param filename string filename without path
|
|
|
|
-- @param filename2
|
2010-10-20 10:25:34 +00:00
|
|
|
--
|
2010-10-24 16:41:58 +00:00
|
|
|
function lsyncd_event(etype, wd, isdir, time, filename, filename2)
|
2010-10-22 08:34:41 +00:00
|
|
|
local ftype;
|
|
|
|
if isdir then
|
|
|
|
ftype = "directory"
|
|
|
|
else
|
|
|
|
ftype = "file"
|
|
|
|
end
|
|
|
|
-- TODO comment out to safe performance
|
2010-10-26 11:26:57 +00:00
|
|
|
if filename2 then
|
2010-10-22 12:58:57 +00:00
|
|
|
log(DEBUG, "got event "..event_names[etype].." of "..ftype.." "..filename.." to "..filename2)
|
2010-10-26 11:26:57 +00:00
|
|
|
else
|
|
|
|
log(DEBUG, "got event "..event_names[etype].." of "..ftype.." "..filename)
|
2010-10-21 12:37:27 +00:00
|
|
|
end
|
|
|
|
|
|
|
|
-- looks up the watch descriptor id
|
|
|
|
local w = watches[wd]
|
2010-10-26 11:26:57 +00:00
|
|
|
if not w then
|
2010-10-21 12:37:27 +00:00
|
|
|
log(NORMAL, "event belongs to unknown or deleted watch descriptor.")
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
-- works through all possible source->target pairs
|
2010-10-25 14:55:40 +00:00
|
|
|
for _, sync in ipairs(w.syncs) do
|
2010-10-27 09:41:14 +00:00
|
|
|
delay_action(etype, wd, sync, time, filename, filename2)
|
2010-10-22 13:12:13 +00:00
|
|
|
-- add subdirs for new directories
|
2010-10-23 10:58:43 +00:00
|
|
|
if isdir then
|
|
|
|
if etype == CREATE then
|
|
|
|
attend_dir(sync.origin, sync.path..filename.."/", w)
|
|
|
|
end
|
2010-10-22 08:34:41 +00:00
|
|
|
end
|
2010-10-21 12:37:27 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
-----
|
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
|
|
|
|
log(ERROR, "Startup process", pid, " failed")
|
|
|
|
lsyncd.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-10-22 10:35:26 +00:00
|
|
|
-- Adds one directory (incl. subdir) to be synchronized.
|
2010-10-21 12:37:27 +00:00
|
|
|
-- Users primary configuration device.
|
2010-10-18 09:02:51 +00:00
|
|
|
--
|
2010-10-22 08:34:41 +00:00
|
|
|
-- @param TODO
|
|
|
|
--
|
2010-10-22 10:40:59 +00:00
|
|
|
function sync(source_dir, target_identifier, actions)
|
2010-10-22 12:58:57 +00:00
|
|
|
local o = { actions = actions,
|
|
|
|
source = source_dir,
|
|
|
|
targetident = target_identifier,
|
|
|
|
}
|
2010-10-26 11:26:57 +00:00
|
|
|
set_prototype(o, proto_origin)
|
|
|
|
|
|
|
|
if not actions.max_actions then
|
|
|
|
actions.max_actions = 1 -- TODO move to init
|
2010-10-24 13:52:28 +00:00
|
|
|
end
|
2010-10-18 09:02:51 +00:00
|
|
|
table.insert(origins, o)
|
2010-10-22 10:35:26 +00:00
|
|
|
return
|
2010-10-17 15:24:55 +00:00
|
|
|
end
|
|
|
|
|
2010-10-19 16:40:49 +00:00
|
|
|
----
|
|
|
|
-- Called by core when an overflow happened.
|
|
|
|
function default_overflow()
|
2010-10-20 18:33:17 +00:00
|
|
|
log(ERROR, "--- OVERFLOW on inotify event queue ---")
|
2010-10-19 16:40:49 +00:00
|
|
|
lsyncd.terminate(-1) -- TODO reset instead.
|
|
|
|
|
|
|
|
end
|
|
|
|
overflow = default_overflow
|
|
|
|
|
2010-10-26 11:26:57 +00:00
|
|
|
--============================================================================
|
|
|
|
-- lsyncd default settings
|
|
|
|
--============================================================================
|
|
|
|
|
|
|
|
defaults = {
|
|
|
|
-----
|
|
|
|
-- TODO
|
|
|
|
--
|
|
|
|
max_processes = 1,
|
|
|
|
------
|
|
|
|
-- TODO
|
|
|
|
--
|
|
|
|
collapse_table = {
|
|
|
|
[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-25 14:55:40 +00:00
|
|
|
|