mirror of https://github.com/octoleo/lsyncd.git
242 lines
6.5 KiB
Lua
242 lines
6.5 KiB
Lua
------------------------------------------------------------------------------
|
|
-- 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.
|
|
------------------------------------------------------------------------------
|
|
|
|
----
|
|
-- A security measurement.
|
|
-- Core will exit if version ids mismatch.
|
|
if lsyncd_version ~= nil then
|
|
print("You cannot use the lsyncd runner as configuration file!")
|
|
os.exit(-1)
|
|
end
|
|
lsyncd_version = "2.0b1"
|
|
|
|
----
|
|
-- Shortcuts (which user is supposed to be able to use them as well)
|
|
log = lsyncd.log
|
|
|
|
----
|
|
-- Table of all directories to watch,
|
|
-- filled and used only during initialization.
|
|
origins = {}
|
|
|
|
----
|
|
-- a array of all targets
|
|
--
|
|
-- structure:
|
|
-- [#] {
|
|
-- .targetident .. the identifier of target (like string "host:dir")
|
|
-- for lsyncd this passed competly opaquely to the action handlers
|
|
-- }
|
|
targets = {}
|
|
|
|
-----
|
|
-- all watches
|
|
--
|
|
-- structure:
|
|
-- [wd] = {
|
|
-- .wd .. the watch descriptor (TODO needed?)
|
|
-- .attends = [#] {
|
|
-- .odir .. origin source dir
|
|
-- .path .. path of dir
|
|
-- .target .. link to targets[#]
|
|
-- .parent .. link to parent directory in watches
|
|
-- or nil for origin
|
|
-- }
|
|
-- }
|
|
--
|
|
watches = {}
|
|
|
|
----
|
|
-- Adds watches for a directory including all subdirectories.
|
|
--
|
|
-- @param odir origin dir
|
|
-- @param path path in this dir
|
|
-- @param target link to target in [targets]
|
|
-- @param parent link to parent directory in watches[]
|
|
--
|
|
local function attend_dir(odir, path, target, parent)
|
|
-- actual dir = origin + path
|
|
local op = odir .. path
|
|
-- register watch and receive watch descriptor
|
|
local wd = lsyncd.add_watch(op);
|
|
if wd < 0 then
|
|
-- failed adding the watch
|
|
log(ERROR, "Failure adding watch " .. op .." -> ignored ")
|
|
-- TODO die?
|
|
return
|
|
end
|
|
|
|
local thiswatch = watches[wd]
|
|
if thiswatch == nil then
|
|
-- new watch
|
|
thiswatch = {wd = wd, attends = {} }
|
|
watches[wd] = thiswatch
|
|
end
|
|
table.insert(thiswatch.attends, { odir = odir, path = path, target = target, parent = parent })
|
|
|
|
-- register all subdirectories
|
|
local subdirs = lsyncd.sub_dirs(op);
|
|
for i, dirname in ipairs(subdirs) do
|
|
attend_dir(odir, path .. dirname .. "/", target, thiswatch)
|
|
end
|
|
end
|
|
|
|
----
|
|
-- Called from core on init or restart after user configuration.
|
|
--
|
|
function lsyncd_initialize()
|
|
-- 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
|
|
|
|
-- runs through the origins table filled by user calling directory()
|
|
for i, o in ipairs(origins) do
|
|
-- resolves source to be an absolute path
|
|
local asrc = lsyncd.real_dir(o.source)
|
|
if asrc == nil then
|
|
print("Cannot resolve source path: ", o.source)
|
|
lsyncd.terminate(-1) -- ERRNO
|
|
end
|
|
|
|
-- appends the target on target lists
|
|
local target = { ident = o.targetident }
|
|
table.insert(targets, target)
|
|
o.target = target -- TODO needed?
|
|
|
|
-- and add the dir watch inclusively all subdirs
|
|
attend_dir(asrc, "", target)
|
|
end
|
|
end
|
|
|
|
----
|
|
-- Called by core to query soonest alarm.
|
|
--
|
|
-- @return two variables.
|
|
-- number -1 means ... alarm is in the past.
|
|
-- 0 means ... no alarm, core can in untimed sleep
|
|
-- 1 means ... alarm time specified.
|
|
-- times ... the alarm time (only read if number is 1)
|
|
function lsyncd_get_alarm()
|
|
return 0, 0
|
|
end
|
|
|
|
-----
|
|
-- A list of names of the event types the core sends.
|
|
--
|
|
local event_names = {
|
|
[ATTRIB] = "Attrib",
|
|
[MODIFY] = "Modify",
|
|
[CREATE] = "Create",
|
|
[DELETE] = "Delete",
|
|
[MOVE ] = "Move",
|
|
}
|
|
|
|
-----
|
|
-- Called by core on inotify event
|
|
--
|
|
-- @param etype enum (ATTRIB, MODIFY, CREATE, DELETE, MOVE)
|
|
-- @param wd watch descriptor (matches lsyncd.add_watch())
|
|
-- @param filename string filename without path
|
|
-- @param filename2
|
|
--
|
|
function lsyncd_event(etype, wd, filename, filename2)
|
|
if filename2 == nil then
|
|
log(DEBUG, "got event " .. event_names[etype] .. " of " .. filename)
|
|
else
|
|
log(DEBUG, "got event " .. event_names[etype] .. " of " .. filename .. " to " .. filename2)
|
|
end
|
|
|
|
-- looks up the watch descriptor id
|
|
local w = watches[wd]
|
|
if w == nil then
|
|
log(NORMAL, "event belongs to unknown or deleted watch descriptor.")
|
|
return
|
|
end
|
|
|
|
-- works through all possible source->target pairs
|
|
for i, a in ipairs(w.attends) do
|
|
log(DEBUG, "odir = " .. a.odir .. " path = " .. a.path)
|
|
end
|
|
|
|
end
|
|
|
|
-----
|
|
-- Called by the core for every child process that
|
|
-- finished in startup phase
|
|
--
|
|
-- 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.
|
|
--
|
|
local function startup_collector(pid, exitcode)
|
|
if exitcode ~= 0 then
|
|
log(ERROR, "Startup process", pid, " failed")
|
|
lsyncd.terminate(-1) -- ERRNO
|
|
end
|
|
return 0
|
|
end
|
|
|
|
|
|
------------------------------------------------------------------------------
|
|
-- lsyncd user interface
|
|
------------------------------------------------------------------------------
|
|
|
|
----
|
|
-- Adds one directory to be watched.
|
|
-- Users primary configuration device.
|
|
--
|
|
function directory(source_dir, target_identifier)
|
|
local o = { source = source_dir, targetident = target_identifier }
|
|
table.insert(origins, o)
|
|
return o
|
|
end
|
|
|
|
----
|
|
-- Called by core when an overflow happened.
|
|
function default_overflow()
|
|
log(ERROR, "--- OVERFLOW on inotify event queue ---")
|
|
lsyncd.terminate(-1) -- TODO reset instead.
|
|
|
|
end
|
|
overflow = default_overflow
|
|
|
|
-----
|
|
-- Called by core after initialization.
|
|
--
|
|
-- Default function will start an simultanous action for every
|
|
-- source -> destination pair. And waits for these processes to finish
|
|
--
|
|
-- The user can override this function by specifing his/her own
|
|
-- "startup". (and yet may still call default startup)
|
|
--
|
|
function default_startup()
|
|
log(NORMAL, "--- startup ---")
|
|
local pids = { }
|
|
for i, o in ipairs(origins) do
|
|
startup_action(o.source, o.targetident)
|
|
table.insert(pids, pid)
|
|
end
|
|
lsyncd.wait_pids(pids, "startup_collector")
|
|
log(NORMAL, "--- Entering normal operation with " .. #watches .. " monitored directories ---")
|
|
end
|
|
startup = default_startup
|
|
|
|
|
|
----
|
|
-- other functions the user might want to use
|
|
exec = lsyncd.exec
|
|
|