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-11-06 16:54:45 +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-11-04 13:43:57 +00:00
|
|
|
lsyncd.log("Error",
|
|
|
|
"You cannot use the lsyncd runner as configuration file!")
|
|
|
|
lsyncd.terminate(-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-11-05 18:20:33 +00:00
|
|
|
-----
|
|
|
|
-- Hides the core interface from user scripts
|
|
|
|
--
|
|
|
|
_l = lsyncd
|
|
|
|
lsyncd = nil
|
|
|
|
local lsyncd = _l
|
|
|
|
_l = nil
|
|
|
|
|
2010-11-06 16:54:45 +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
|
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
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-11-03 11:37:25 +00:00
|
|
|
-- returns the count
|
|
|
|
local function size(self)
|
|
|
|
return self._size
|
|
|
|
end
|
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
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-31 22:25:34 +00:00
|
|
|
----
|
2010-11-01 16:38:39 +00:00
|
|
|
-- Locks globals,
|
|
|
|
-- no more globals can be created
|
|
|
|
--
|
2010-11-06 18:26:59 +00:00
|
|
|
local function lockGlobals()
|
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
|
2010-11-05 13:34:02 +00:00
|
|
|
error("Access of non-existing global '"..k.."'", 2)
|
2010-11-01 19:57:53 +00:00
|
|
|
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
|
|
|
-----
|
2010-11-06 10:33:26 +00:00
|
|
|
-- Holds information about a delayed event for one Sync.
|
2010-11-02 14:11:26 +00:00
|
|
|
--
|
2010-11-04 13:43:57 +00:00
|
|
|
-- valid stati are:
|
|
|
|
-- delay
|
|
|
|
-- active
|
|
|
|
-- TODO
|
|
|
|
--
|
2010-11-02 14:11:26 +00:00
|
|
|
local Delay = (function()
|
|
|
|
-----
|
|
|
|
-- Creates a new delay.
|
|
|
|
--
|
|
|
|
-- @param TODO
|
2010-11-06 17:40:12 +00:00
|
|
|
local function new(ename, path, alarm)
|
2010-11-02 14:11:26 +00:00
|
|
|
local o = {
|
2010-11-06 17:40:12 +00:00
|
|
|
ename = ename, -- TODO rename
|
2010-11-02 14:11:26 +00:00
|
|
|
alarm = alarm,
|
2010-11-06 17:40:12 +00:00
|
|
|
path = path,
|
2010-11-04 13:43:57 +00:00
|
|
|
status = "delay",
|
2010-11-02 14:11:26 +00:00
|
|
|
}
|
|
|
|
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
|
|
|
--
|
2010-11-06 10:10:00 +00:00
|
|
|
local Sync = (function()
|
2010-11-06 18:26:59 +00:00
|
|
|
-----
|
|
|
|
-- Syncs that have no name specified get an incremental default name
|
|
|
|
--
|
|
|
|
local nextDefaultName = 1
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Puts an action on the delay stack.
|
|
|
|
--
|
|
|
|
local function delay(self, ename, time, path, path2)
|
|
|
|
log("Function", "delay(", self, ", ", ename, ", ", path, ")")
|
|
|
|
local delays = self.delays
|
|
|
|
local delayname = self.delayname
|
|
|
|
|
|
|
|
if ename == "Move" and not self.config.move then
|
|
|
|
-- if there is no move action defined, split a move as delete/create
|
|
|
|
log("Debug", "splitting Move into Delete & Create")
|
|
|
|
delay(self, "Delete", time, path, nil)
|
|
|
|
delay(self, "Create", time, path2, nil)
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
-- creates the new action
|
|
|
|
local alarm
|
|
|
|
if time and self.config.delay then
|
|
|
|
alarm = lsyncd.addtoclock(time, self.config.delay)
|
|
|
|
else
|
|
|
|
alarm = lsyncd.now()
|
|
|
|
end
|
|
|
|
local newd = Delay.new(ename, path, alarm)
|
|
|
|
|
|
|
|
local oldd = delayname[path]
|
|
|
|
if oldd then
|
|
|
|
-- if there is already a delay on this path.
|
|
|
|
-- 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
|
|
|
|
log("Normal", "Not collapsing events with moves on ", path)
|
|
|
|
-- TODO stackinfo
|
|
|
|
return
|
|
|
|
else
|
|
|
|
local col = self.config.collapseTable[oldd.ename][newd.ename]
|
|
|
|
if col == -1 then
|
|
|
|
-- events cancel each other
|
|
|
|
log("Normal", "Nullfication: ", newd.ename, " after ",
|
|
|
|
oldd.ename, " on ", path)
|
|
|
|
oldd.ename = "None"
|
|
|
|
return
|
|
|
|
elseif col == 0 then
|
|
|
|
-- events tack
|
|
|
|
log("Normal", "Stacking ", newd.ename, " after ",
|
|
|
|
oldd.ename, " on ", path)
|
|
|
|
-- TODO Stack pointer
|
|
|
|
else
|
|
|
|
log("Normal", "Collapsing ", newd.ename, " upon ",
|
|
|
|
oldd.ename, " to ", col, " on ", path)
|
|
|
|
oldd.ename = col
|
|
|
|
return
|
|
|
|
end
|
|
|
|
end
|
|
|
|
table.insert(delays, newd)
|
|
|
|
else
|
|
|
|
delayname[path] = newd
|
|
|
|
table.insert(delays, newd)
|
|
|
|
end
|
|
|
|
end
|
2010-11-06 21:29:22 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- Return the nearest alarm for this Sync.
|
|
|
|
--
|
|
|
|
local function getAlarm(self)
|
|
|
|
-- first checks if more processses could be spawned
|
|
|
|
if self.processes:size() >= self.config.maxProcesses then
|
|
|
|
return nil
|
|
|
|
end
|
|
|
|
|
|
|
|
if self.delays[1] then
|
|
|
|
return self.delays[1].alarm
|
|
|
|
end
|
|
|
|
end
|
2010-11-06 18:26:59 +00:00
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-11-06 10:33:26 +00:00
|
|
|
-- Creates a new Sync
|
2010-11-02 14:11:26 +00:00
|
|
|
--
|
2010-11-05 15:18:01 +00:00
|
|
|
local function new(config)
|
2010-11-06 18:26:59 +00:00
|
|
|
local s = {
|
2010-11-06 21:29:22 +00:00
|
|
|
-- TODO document.
|
2010-11-02 14:11:26 +00:00
|
|
|
config = config,
|
|
|
|
delays = CountArray.new(),
|
|
|
|
delayname = {},
|
2010-11-05 15:18:01 +00:00
|
|
|
source = config.source,
|
2010-11-02 14:11:26 +00:00
|
|
|
processes = CountArray.new(),
|
2010-11-06 21:29:22 +00:00
|
|
|
|
|
|
|
-- functions
|
2010-11-06 18:26:59 +00:00
|
|
|
delay = delay,
|
2010-11-06 21:29:22 +00:00
|
|
|
getAlarm = getAlarm,
|
2010-11-02 14:11:26 +00:00
|
|
|
}
|
2010-11-06 18:26:59 +00:00
|
|
|
-- provides a default name if needed
|
|
|
|
if not config.name then
|
|
|
|
config.name = "Sync" .. nextDefaultName
|
|
|
|
end
|
|
|
|
-- increment default nevertheless to cause less confusion
|
|
|
|
nextDefaultName = nextDefaultName + 1
|
|
|
|
return s
|
2010-11-02 14:11:26 +00:00
|
|
|
end
|
|
|
|
|
2010-11-06 18:26:59 +00:00
|
|
|
-----
|
2010-11-02 14:11:26 +00:00
|
|
|
-- public interface
|
|
|
|
return {new = new}
|
|
|
|
end)()
|
|
|
|
|
2010-10-25 17:38:57 +00:00
|
|
|
|
2010-11-02 14:11:26 +00:00
|
|
|
-----
|
2010-11-06 10:10:00 +00:00
|
|
|
-- Syncs - a singleton
|
2010-11-02 14:11:26 +00:00
|
|
|
--
|
|
|
|
-- It maintains all configured directories to be synced.
|
|
|
|
--
|
2010-11-06 10:10:00 +00:00
|
|
|
local Syncs = (function()
|
2010-11-06 18:26:59 +00:00
|
|
|
-----
|
2010-11-06 10:33:26 +00:00
|
|
|
-- the list of all syncs
|
2010-11-06 18:26:59 +00:00
|
|
|
--
|
2010-11-02 14:11:26 +00:00
|
|
|
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 15:53:20 +00:00
|
|
|
-- first copies from source all
|
|
|
|
-- non-defined non-integer keyed values
|
|
|
|
for k, v in pairs(cs) do
|
|
|
|
if type(k) ~= "number" and not cd[k] then
|
|
|
|
cd[k] = v
|
|
|
|
end
|
|
|
|
end
|
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
|
|
|
|
end
|
|
|
|
|
|
|
|
-----
|
2010-11-03 11:37:25 +00:00
|
|
|
-- Adds a new directory to observe.
|
|
|
|
--
|
|
|
|
local function add(config)
|
2010-11-06 10:10:00 +00:00
|
|
|
-----
|
|
|
|
-- Creates a new config table and inherit all keys/values
|
|
|
|
-- from integer keyed tables
|
2010-11-06 18:26:59 +00:00
|
|
|
--
|
2010-11-03 15:53:20 +00:00
|
|
|
local uconfig = config
|
|
|
|
config = {}
|
|
|
|
inherit(config, uconfig)
|
2010-11-02 20:18:05 +00:00
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-11-06 10:10:00 +00:00
|
|
|
-- raises an error if @param name isnt in opts
|
2010-11-02 20:18:05 +00:00
|
|
|
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")
|
|
|
|
|
2010-11-02 14:11:26 +00:00
|
|
|
-- absolute path of source
|
2010-11-06 15:08:17 +00:00
|
|
|
local real_src = lsyncd.realdir(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-06 10:10:00 +00:00
|
|
|
config._source = config.source
|
2010-11-02 20:18:05 +00:00
|
|
|
config.source = real_src
|
|
|
|
|
2010-11-06 10:10:00 +00:00
|
|
|
if not config.action and not config.onAttrib and
|
2010-11-05 15:18:01 +00:00
|
|
|
not config.onCreate and not config.onModify and
|
|
|
|
not config.onDelete and not config.onMove
|
2010-11-02 20:18:05 +00:00
|
|
|
then
|
2010-11-05 15:18:01 +00:00
|
|
|
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
|
|
|
": 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-06 10:10:57 +00:00
|
|
|
optional("maxProcesses")
|
|
|
|
optional("collapseTable")
|
2010-11-06 10:10:00 +00:00
|
|
|
local s = Sync.new(config)
|
|
|
|
table.insert(list, s)
|
2010-11-02 14:11:26 +00:00
|
|
|
end
|
|
|
|
|
2010-11-06 18:26:59 +00:00
|
|
|
-----
|
2010-11-06 10:33:26 +00:00
|
|
|
-- allows to walk through all syncs
|
2010-11-06 18:26:59 +00:00
|
|
|
--
|
2010-11-02 17:07:42 +00:00
|
|
|
local function iwalk()
|
2010-11-02 14:11:26 +00:00
|
|
|
return ipairs(list)
|
|
|
|
end
|
|
|
|
|
2010-11-06 18:26:59 +00:00
|
|
|
-----
|
2010-11-06 10:33:26 +00:00
|
|
|
-- returns the number of syncs
|
2010-11-06 18:26:59 +00:00
|
|
|
--
|
2010-11-02 14:11:26 +00:00
|
|
|
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.
|
2010-11-06 10:33:26 +00:00
|
|
|
-- Contains a list of all syncs observing this directory
|
2010-11-03 11:37:25 +00:00
|
|
|
-- (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.
|
|
|
|
--
|
2010-11-05 18:04:29 +00:00
|
|
|
-- @param root+path directory to observe
|
|
|
|
-- @param recurse true if recursing into subdirs or
|
|
|
|
-- the relative path to root for recursed inotifies
|
2010-11-06 10:33:26 +00:00
|
|
|
-- @param sync link to the observer to be notified.
|
2010-11-05 18:04:29 +00:00
|
|
|
-- Note: Inotifies should handle this opaquely
|
2010-11-06 10:33:26 +00:00
|
|
|
local function add(root, path, recurse, sync)
|
2010-11-05 18:04:29 +00:00
|
|
|
log("Function",
|
2010-11-06 10:33:26 +00:00
|
|
|
"Inotifies.add(",root,", ",path,", ",recurse,", ",sync,")")
|
2010-11-05 18:04:29 +00:00
|
|
|
-- registers watch
|
|
|
|
local wd = lsyncd.add_watch(root .. path);
|
2010-11-03 11:37:25 +00:00
|
|
|
if wd < 0 then
|
2010-11-05 18:04:29 +00:00
|
|
|
log("Error","Failure adding watch ",dir," -> ignored ")
|
2010-11-03 11:37:25 +00:00
|
|
|
return
|
|
|
|
end
|
2010-10-22 08:34:41 +00:00
|
|
|
|
2010-11-05 18:04:29 +00:00
|
|
|
if not wdlist[wd] then
|
|
|
|
wdlist[wd] = Array.new()
|
2010-11-03 11:37:25 +00:00
|
|
|
end
|
2010-11-05 18:04:29 +00:00
|
|
|
table.insert(wdlist[wd], {
|
|
|
|
root = root,
|
|
|
|
path = path,
|
|
|
|
recurse = recurse,
|
2010-11-06 10:33:26 +00:00
|
|
|
sync = sync
|
2010-11-05 18:04:29 +00:00
|
|
|
})
|
2010-11-03 11:37:25 +00:00
|
|
|
|
|
|
|
-- registers and adds watches for all subdirectories
|
|
|
|
if recurse then
|
2010-11-06 15:08:17 +00:00
|
|
|
local subdirs = lsyncd.subdirs(root .. path)
|
2010-11-03 11:37:25 +00:00
|
|
|
for _, dirname in ipairs(subdirs) do
|
2010-11-06 10:33:26 +00:00
|
|
|
add(root, path..dirname.."/", true, sync)
|
2010-11-03 11:37:25 +00:00
|
|
|
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"
|
2010-11-05 13:34:02 +00:00
|
|
|
filename = filename .. "/"
|
|
|
|
if filename2 then
|
|
|
|
filename2 = filename2 .. "/"
|
|
|
|
end
|
2010-11-03 11:37:25 +00:00
|
|
|
end
|
|
|
|
if filename2 then
|
2010-11-05 13:34:02 +00:00
|
|
|
log("Inotify", "got event ", ename, " ", filename,
|
2010-11-03 11:37:25 +00:00
|
|
|
" to ", filename2)
|
|
|
|
else
|
2010-11-05 13:34:02 +00:00
|
|
|
log("Inotify", "got event ", ename, " ", filename)
|
2010-11-03 11:37:25 +00:00
|
|
|
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
|
2010-11-05 13:34:02 +00:00
|
|
|
log("Inotify", "event belongs to unknown watch descriptor.")
|
2010-11-03 11:37:25 +00:00
|
|
|
return
|
|
|
|
end
|
|
|
|
|
|
|
|
-- works through all observers interested in this directory
|
|
|
|
for _, inotify in ipairs(ilist) do
|
2010-11-06 17:40:12 +00:00
|
|
|
local path = inotify.path .. filename
|
|
|
|
local path2
|
2010-11-03 11:37:25 +00:00
|
|
|
if filename2 then
|
2010-11-06 17:40:12 +00:00
|
|
|
path2 = inotify.path..filename2
|
2010-11-03 11:37:25 +00:00
|
|
|
end
|
2010-11-06 18:26:59 +00:00
|
|
|
inotify.sync:delay(ename, time, path, path2)
|
2010-11-04 13:43:57 +00:00
|
|
|
-- adds subdirs for new directories
|
2010-11-03 11:37:25 +00:00
|
|
|
if inotify.recurse and isdir then
|
|
|
|
if ename == "Create" then
|
2010-11-06 17:40:12 +00:00
|
|
|
add(inotify.root, path, true, inotify.sync)
|
2010-11-05 13:34:02 +00:00
|
|
|
elseif ename == "Delete" then
|
|
|
|
-- TODO
|
2010-11-03 11:37:25 +00:00
|
|
|
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
|
|
|
|
--
|
2010-11-05 18:04:29 +00:00
|
|
|
local function status_report(f)
|
|
|
|
f:write("Watching ",wdlist:size()," directories\n")
|
2010-11-03 11:37:25 +00:00
|
|
|
for wd, v in wdlist:iwalk() do
|
2010-11-05 18:04:29 +00:00
|
|
|
f:write(" ",wd,": ")
|
|
|
|
local sep = ""
|
2010-11-03 11:37:25 +00:00
|
|
|
for _, v in ipairs(v) do
|
2010-11-05 18:04:29 +00:00
|
|
|
f:write(v.root,"/",v.path or "",sep)
|
|
|
|
sep = ", "
|
2010-11-03 11:37:25 +00:00
|
|
|
end
|
2010-11-05 18:04:29 +00:00
|
|
|
f:write("\n")
|
2010-11-03 11:37:25 +00:00
|
|
|
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
|
2010-11-04 13:43:57 +00:00
|
|
|
return {
|
|
|
|
add = add,
|
|
|
|
size = size,
|
|
|
|
event = event,
|
|
|
|
status_report = status_report
|
|
|
|
}
|
2010-11-03 11:37:25 +00:00
|
|
|
end)()
|
|
|
|
|
|
|
|
--============================================================================
|
|
|
|
-- lsyncd runner plugs. These functions will be called from core.
|
|
|
|
--============================================================================
|
|
|
|
|
2010-11-05 15:18:01 +00:00
|
|
|
-----
|
|
|
|
-- true after lsyncd_initalized()
|
|
|
|
--
|
|
|
|
local running = false
|
|
|
|
|
2010-11-03 11:37:25 +00:00
|
|
|
-----
|
|
|
|
-- 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
|
2010-11-06 10:33:26 +00:00
|
|
|
local sync = nil
|
2010-11-06 10:10:00 +00:00
|
|
|
for _, s in Syncs.iwalk() do
|
|
|
|
delay = s.processes[pid]
|
2010-11-01 17:54:09 +00:00
|
|
|
if delay then
|
2010-11-06 10:33:26 +00:00
|
|
|
sync = s
|
2010-11-01 17:54:09 +00:00
|
|
|
break
|
|
|
|
end
|
|
|
|
end
|
|
|
|
if not delay then
|
2010-10-23 17:01:56 +00:00
|
|
|
return
|
|
|
|
end
|
2010-11-05 18:20:33 +00:00
|
|
|
log("Debug", "collected ",pid, ": ",delay.ename," of ",
|
2010-11-06 17:40:12 +00:00
|
|
|
sync.source, delay.path," = ",exitcode)
|
2010-11-06 10:33:26 +00:00
|
|
|
sync.processes[pid] = nil
|
2010-10-23 17:01:56 +00:00
|
|
|
end
|
2010-10-23 12:36:55 +00:00
|
|
|
|
2010-11-04 13:43:57 +00:00
|
|
|
-----
|
|
|
|
-- User interface to grap events
|
2010-11-01 14:16:35 +00:00
|
|
|
--
|
2010-11-04 13:43:57 +00:00
|
|
|
-- inlet_control is the Luas runner part to control the interface
|
|
|
|
-- hidden from the user.
|
|
|
|
--
|
|
|
|
local Inlet, inlet_control = (function()
|
2010-11-05 13:34:02 +00:00
|
|
|
-- lua runner controlled variables
|
2010-11-06 10:33:26 +00:00
|
|
|
local sync = true
|
|
|
|
local delay = true
|
2010-11-01 16:38:39 +00:00
|
|
|
|
2010-11-05 13:34:02 +00:00
|
|
|
-- event to be passed to the user
|
|
|
|
local event = {}
|
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
-----
|
|
|
|
-- removes the trailing slash from a path
|
|
|
|
local function cutSlash(path)
|
|
|
|
if string.byte(path, -1) == 47 then
|
|
|
|
return string.sub(path, 1, -2)
|
|
|
|
else
|
|
|
|
return path
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-11-05 18:20:33 +00:00
|
|
|
-----
|
|
|
|
-- Interface for the user to get fields.
|
2010-11-06 17:40:12 +00:00
|
|
|
local eventFields = {
|
2010-11-05 13:34:02 +00:00
|
|
|
config = function()
|
2010-11-06 10:33:26 +00:00
|
|
|
return sync.config
|
2010-11-05 13:34:02 +00:00
|
|
|
end,
|
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
-----
|
|
|
|
-- Returns the type of the event.
|
|
|
|
-- Can be:
|
|
|
|
-- "Attrib"
|
|
|
|
-- "Create"
|
|
|
|
-- "Delete"
|
|
|
|
-- "Modify"
|
|
|
|
-- "Move"
|
2010-11-05 13:34:02 +00:00
|
|
|
etype = function()
|
|
|
|
return delay.ename
|
|
|
|
end,
|
2010-11-06 17:40:12 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- Returns true if event relates to a directory.
|
|
|
|
isdir = function()
|
|
|
|
return string.byte(delay.path, -1) == 47
|
|
|
|
end,
|
2010-11-05 13:34:02 +00:00
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
-----
|
|
|
|
-- Returns the name of the file/dir.
|
|
|
|
-- Includes a trailing slash for dirs.
|
2010-11-05 13:34:02 +00:00
|
|
|
name = function()
|
2010-11-06 17:40:12 +00:00
|
|
|
return string.match(delay.path, "[^/]+/?$")
|
2010-11-05 13:34:02 +00:00
|
|
|
end,
|
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
-----
|
|
|
|
-- Returns the name of the file/dir.
|
|
|
|
-- Excludes a trailing slash for dirs.
|
2010-11-05 13:34:02 +00:00
|
|
|
basename = function()
|
2010-11-06 17:40:12 +00:00
|
|
|
return string.match(delay.path, "([^/]+)/?$")
|
2010-11-05 13:34:02 +00:00
|
|
|
end,
|
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
-----
|
|
|
|
-- Returns the file/dir relative to watch root
|
|
|
|
-- Includes a trailing slash for dirs.
|
|
|
|
path = function()
|
|
|
|
return delay.path
|
2010-11-05 13:34:02 +00:00
|
|
|
end,
|
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
-----
|
|
|
|
-- Returns the file/dir relativ to watch root
|
|
|
|
-- Excludes a trailing slash for dirs.
|
|
|
|
pathname = function()
|
|
|
|
return cutSlash(delay.path)
|
2010-11-05 13:34:02 +00:00
|
|
|
end,
|
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
------
|
|
|
|
-- Returns the absolute path of the watch root.
|
|
|
|
-- All symlinks will have been resolved.
|
|
|
|
source = function()
|
2010-11-06 10:33:26 +00:00
|
|
|
return sync.source
|
2010-11-05 13:34:02 +00:00
|
|
|
end,
|
2010-11-06 17:40:12 +00:00
|
|
|
|
|
|
|
------
|
|
|
|
-- Returns the absolute path of the file/dir.
|
|
|
|
-- Includes a trailing slash for dirs.
|
|
|
|
sourcePath = function()
|
|
|
|
return sync.source .. delay.path
|
|
|
|
end,
|
|
|
|
|
|
|
|
------
|
|
|
|
-- Returns the absolute path of the file/dir.
|
|
|
|
-- Excludes a trailing slash for dirs.
|
|
|
|
sourcePathname = function()
|
|
|
|
return sync.source .. cutSlash(delay.path)
|
|
|
|
end,
|
|
|
|
|
|
|
|
------
|
|
|
|
-- Returns the target.
|
|
|
|
-- Just for user comfort, for most case
|
|
|
|
-- (Actually except of here, the lsyncd.runner itself
|
|
|
|
-- does not care event about the existance of "target",
|
|
|
|
-- this is completly up to the action scripts.)
|
|
|
|
target = function()
|
|
|
|
return sync.config.target
|
|
|
|
end,
|
|
|
|
|
|
|
|
------
|
|
|
|
-- Returns the relative dir/file appended to the target.
|
|
|
|
-- Includes a trailing slash for dirs.
|
|
|
|
targetPath = function()
|
|
|
|
return sync.config.target .. delay.path
|
|
|
|
end,
|
|
|
|
|
|
|
|
------
|
|
|
|
-- Returns the relative dir/file appended to the target.
|
|
|
|
-- Excludes a trailing slash for dirs.
|
|
|
|
targetPathname = function()
|
|
|
|
return sync.config.target .. cutSlash(delay.path)
|
|
|
|
end,
|
2010-11-05 13:34:02 +00:00
|
|
|
}
|
2010-11-06 17:40:12 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- Calls event functions for the user.
|
|
|
|
local eventMeta = {
|
2010-11-05 13:34:02 +00:00
|
|
|
__index = function(t, k)
|
2010-11-06 17:40:12 +00:00
|
|
|
local f = eventFields[k]
|
2010-11-05 13:34:02 +00:00
|
|
|
if not f then
|
|
|
|
error("event does not have field '"..k.."'", 2)
|
|
|
|
end
|
|
|
|
return f()
|
|
|
|
end
|
|
|
|
}
|
2010-11-06 17:40:12 +00:00
|
|
|
setmetatable(event, eventMeta)
|
2010-11-05 13:34:02 +00:00
|
|
|
|
|
|
|
-----
|
|
|
|
-- Interface for lsyncd runner to control what
|
|
|
|
-- the inlet will present the user.
|
|
|
|
--
|
2010-11-06 10:33:26 +00:00
|
|
|
local function control(set_sync, set_delay)
|
|
|
|
sync = set_sync
|
|
|
|
delay = set_delay
|
2010-11-04 13:43:57 +00:00
|
|
|
end
|
2010-11-01 19:57:53 +00:00
|
|
|
|
2010-11-04 13:43:57 +00:00
|
|
|
-----
|
2010-11-05 13:34:02 +00:00
|
|
|
-- Gets the next event from queue.
|
|
|
|
--
|
2010-11-04 13:43:57 +00:00
|
|
|
local function get_event()
|
2010-11-05 13:34:02 +00:00
|
|
|
-- TODO actually aquire here
|
|
|
|
return event
|
2010-11-04 13:43:57 +00:00
|
|
|
end
|
2010-11-01 14:16:35 +00:00
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-11-05 13:34:02 +00:00
|
|
|
-- Returns the configuration table specified by sync{}
|
|
|
|
--
|
2010-11-04 13:43:57 +00:00
|
|
|
local function get_config()
|
|
|
|
-- TODO give a readonly handler only.
|
2010-11-06 10:33:26 +00:00
|
|
|
return sync.config
|
2010-11-04 13:43:57 +00:00
|
|
|
end
|
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-11-04 13:43:57 +00:00
|
|
|
-- public interface
|
|
|
|
return {get_event = get_event, get_config = get_config}, control
|
|
|
|
end)()
|
2010-11-01 14:16:35 +00:00
|
|
|
|
2010-10-23 12:36:55 +00:00
|
|
|
-----
|
|
|
|
-- TODO
|
|
|
|
--
|
|
|
|
--
|
2010-11-06 10:33:26 +00:00
|
|
|
local function invoke_action(sync, delay)
|
2010-11-01 19:57:53 +00:00
|
|
|
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-04 13:43:57 +00:00
|
|
|
|
2010-11-06 10:33:26 +00:00
|
|
|
inlet_control(sync, delay)
|
|
|
|
local pid = sync.config.action(Inlet)
|
2010-11-01 19:57:53 +00:00
|
|
|
if pid and pid > 0 then
|
2010-11-04 13:43:57 +00:00
|
|
|
delay.status = "active"
|
2010-11-06 10:33:26 +00:00
|
|
|
sync.processes[pid] = delay
|
2010-10-23 12:36:55 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
2010-10-28 17:56:33 +00:00
|
|
|
----
|
2010-11-06 10:10:57 +00:00
|
|
|
-- Writes a status report file at most every [statusintervall] seconds.
|
2010-10-28 17:56:33 +00:00
|
|
|
--
|
2010-11-06 10:10:57 +00:00
|
|
|
--
|
|
|
|
local StatusFile = (function()
|
|
|
|
-----
|
|
|
|
-- Timestamp when the status file has been written.
|
|
|
|
local lastWritten = false
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Timestamp when a statusfile should be written
|
|
|
|
local alarm = false
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Returns when the statusfile should be written
|
|
|
|
--
|
|
|
|
local function getAlarm()
|
|
|
|
return alarm
|
|
|
|
end
|
|
|
|
|
|
|
|
-----
|
|
|
|
-- Called to check if to write a status file.
|
|
|
|
--
|
|
|
|
local function write(now)
|
|
|
|
log("Function", "write(", now, ")")
|
|
|
|
|
|
|
|
-- some logic to not write too often
|
|
|
|
if settings.statusIntervall > 0 then
|
|
|
|
-- already waiting
|
2010-11-06 17:40:12 +00:00
|
|
|
if alarm and lsyncd.clockbefore(now, alarm) then
|
2010-11-06 10:33:26 +00:00
|
|
|
log("Statusfile", "waiting(",now," < ",alarm,")")
|
2010-11-06 10:10:57 +00:00
|
|
|
return
|
|
|
|
end
|
2010-11-06 10:33:26 +00:00
|
|
|
-- determines when a next write will be possible
|
2010-11-06 10:10:57 +00:00
|
|
|
if not alarm then
|
|
|
|
local nextWrite = lastWritten and
|
2010-11-06 15:08:17 +00:00
|
|
|
lsyncd.addtoclock(now, settings.statusIntervall)
|
2010-11-06 17:40:12 +00:00
|
|
|
if nextWrite and lsyncd.clockbefore(now, nextWrite) then
|
2010-11-06 10:33:26 +00:00
|
|
|
log("Statusfile", "setting alarm: ", nextWrite)
|
2010-11-06 10:10:57 +00:00
|
|
|
alarm = nextWrite
|
|
|
|
return
|
|
|
|
end
|
|
|
|
end
|
|
|
|
lastWritten = now
|
|
|
|
alarm = false
|
|
|
|
end
|
|
|
|
|
|
|
|
log("Statusfile", "writing now")
|
|
|
|
local f, err = io.open(settings.statusfile, "w")
|
|
|
|
if not f then
|
|
|
|
log("Error", "Cannot open statusfile '"..settings.statusfile..
|
|
|
|
"' :"..err)
|
|
|
|
return
|
|
|
|
end
|
|
|
|
f:write("Lsyncd status report at ", os.date(), "\n\n")
|
|
|
|
Inotifies.status_report(f)
|
|
|
|
f:close()
|
2010-11-05 18:04:29 +00:00
|
|
|
end
|
2010-11-06 10:10:57 +00:00
|
|
|
|
|
|
|
-- public interface
|
|
|
|
return {write = write, getAlarm = getAlarm}
|
|
|
|
end)()
|
2010-10-28 17:56:33 +00:00
|
|
|
|
2010-10-22 23:14:11 +00:00
|
|
|
----
|
2010-11-05 18:04:29 +00:00
|
|
|
-- Called from core everytime a masterloop cycle runs through.
|
|
|
|
-- This happens in case of
|
|
|
|
-- * an expired alarm.
|
|
|
|
-- * a returned child process.
|
|
|
|
-- * received inotify events.
|
|
|
|
-- * received a HUP or TERM signal.
|
2010-10-23 12:36:55 +00:00
|
|
|
--
|
2010-11-05 18:04:29 +00:00
|
|
|
-- @param now the current kernel time (in jiffies)
|
2010-10-23 12:36:55 +00:00
|
|
|
--
|
2010-11-05 18:04:29 +00:00
|
|
|
function lsyncd_cycle(now)
|
2010-10-24 13:52:28 +00:00
|
|
|
-- goes through all targets and spawns more actions
|
|
|
|
-- if possible
|
2010-11-05 18:04:29 +00:00
|
|
|
if settings.statusfile then
|
2010-11-06 10:10:57 +00:00
|
|
|
StatusFile.write(now)
|
2010-11-05 18:04:29 +00:00
|
|
|
end
|
2010-11-06 10:10:00 +00:00
|
|
|
for _, s in Syncs.iwalk() do
|
2010-11-06 10:33:26 +00:00
|
|
|
if s.processes:size() < s.config.maxProcesses then
|
2010-11-06 10:10:00 +00:00
|
|
|
local delays = s.delays
|
2010-10-26 11:26:57 +00:00
|
|
|
local d = delays[1]
|
2010-11-06 15:08:17 +00:00
|
|
|
if d and lsyncd.clockbeforeq(d.alarm, now) then
|
2010-11-06 10:10:00 +00:00
|
|
|
invoke_action(s, d)
|
2010-10-24 13:52:28 +00:00
|
|
|
table.remove(delays, 1)
|
2010-11-06 17:40:12 +00:00
|
|
|
s.delayname[d.path] = 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-11-04 13:43:57 +00:00
|
|
|
[[
|
|
|
|
USAGE:
|
|
|
|
run a config file:
|
|
|
|
lsyncd [OPTIONS] [CONFIG-FILE]
|
|
|
|
|
|
|
|
default rsync behaviour:
|
|
|
|
lsyncd [OPTIONS] -rsync [SOURCE] [TARGET1] [TARGET2] ...
|
|
|
|
|
|
|
|
OPTIONS:
|
|
|
|
-help Shows this
|
|
|
|
-log all Logs everything
|
|
|
|
-log scarce Logs errors only
|
2010-11-04 14:23:34 +00:00
|
|
|
-log [Category] Turns on logging for a debug category
|
|
|
|
-runner FILE Loads lsyncds lua part from FILE
|
2010-11-04 13:43:57 +00:00
|
|
|
|
|
|
|
LICENSE:
|
|
|
|
GPLv2 or any later version.
|
|
|
|
|
|
|
|
SEE:
|
|
|
|
`man lsyncd` for further information.
|
|
|
|
|
2010-10-27 09:06:13 +00:00
|
|
|
]])
|
|
|
|
os.exit(-1) -- ERRNO
|
|
|
|
end
|
|
|
|
|
|
|
|
|
2010-11-03 21:02:14 +00:00
|
|
|
-----
|
|
|
|
-- Called from core to parse the command line arguments
|
|
|
|
-- @returns a string as user script to load.
|
|
|
|
-- or simply 'true' if running with rsync bevaiour
|
|
|
|
-- terminates on invalid arguments
|
|
|
|
--
|
|
|
|
function lsyncd_configure(args)
|
|
|
|
-- a list of all valid --options
|
|
|
|
local options = {
|
|
|
|
-- log is handled by core already.
|
|
|
|
log = {1},
|
|
|
|
|
|
|
|
}
|
|
|
|
-- filled with all args that were non --options
|
|
|
|
local nonopts = {}
|
|
|
|
local i = 1
|
|
|
|
while i <= #args do
|
|
|
|
local a = args[i]
|
|
|
|
if a:sub(1, 1) ~= "-" then
|
|
|
|
table.insert(nonopts, args[i])
|
|
|
|
else
|
|
|
|
if a:sub(1, 2) == "--" then
|
|
|
|
a = a:sub(3)
|
|
|
|
else
|
|
|
|
a = a:sub(2)
|
|
|
|
end
|
|
|
|
local o = options[a]
|
2010-11-06 10:10:00 +00:00
|
|
|
if o then
|
2010-11-03 21:02:14 +00:00
|
|
|
-- TODO --
|
|
|
|
i = i + o[1]
|
|
|
|
end
|
|
|
|
end
|
|
|
|
i = i + 1
|
|
|
|
end
|
|
|
|
|
|
|
|
if #nonopts == 0 then
|
2010-11-04 13:43:57 +00:00
|
|
|
lsyncd_help(args[0])
|
2010-11-03 21:02:14 +00:00
|
|
|
elseif #nonopts == 1 then
|
|
|
|
return nonopts[1]
|
|
|
|
else
|
|
|
|
-- TODO
|
|
|
|
return true
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
|
2010-10-17 15:24:55 +00:00
|
|
|
----
|
|
|
|
-- Called from core on init or restart after user configuration.
|
|
|
|
--
|
2010-11-03 21:02:14 +00:00
|
|
|
function lsyncd_initialize()
|
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-06 18:26:59 +00:00
|
|
|
lockGlobals()
|
2010-10-25 14:55:40 +00:00
|
|
|
|
2010-11-06 10:33:26 +00:00
|
|
|
-- TODO
|
|
|
|
if settings.statusIntervall == nil then
|
|
|
|
settings.statusIntervall = default.statusIntervall
|
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-06 10:10:00 +00:00
|
|
|
if Syncs.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-11-06 10:33:26 +00:00
|
|
|
-- set to true if at least one sync has a startup function
|
2010-10-22 12:58:57 +00:00
|
|
|
local have_startup = false
|
2010-11-06 10:33:26 +00:00
|
|
|
-- runs through the syncs table filled by user calling directory()
|
2010-11-06 10:10:00 +00:00
|
|
|
for _, s in Syncs.iwalk() do
|
|
|
|
if s.config.onStartup 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-06 10:33:26 +00:00
|
|
|
Inotifies.add(s.source, "", true, s)
|
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-05 15:18:01 +00:00
|
|
|
running = true;
|
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-06 10:10:00 +00:00
|
|
|
for _, s in Syncs.iwalk() do
|
2010-10-22 12:58:57 +00:00
|
|
|
local pid
|
2010-11-06 10:10:00 +00:00
|
|
|
if s.config.onStartup then
|
|
|
|
local pid = s.config.onStartup(s.config)
|
2010-10-22 12:58:57 +00:00
|
|
|
table.insert(pids, pid)
|
|
|
|
end
|
2010-10-22 10:35:26 +00:00
|
|
|
end
|
2010-11-06 15:08:17 +00:00
|
|
|
lsyncd.waitpids(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
|
|
|
--
|
2010-11-05 18:20:33 +00:00
|
|
|
-- @return false ... no alarm, core can in untimed sleep, or
|
|
|
|
-- times ... the alarm time (only read if number is 1)
|
|
|
|
--
|
2010-10-19 10:12:11 +00:00
|
|
|
function lsyncd_get_alarm()
|
2010-11-05 18:20:33 +00:00
|
|
|
local alarm = false
|
2010-11-06 21:29:22 +00:00
|
|
|
|
|
|
|
----
|
|
|
|
-- checks if current nearest alarm or a is earlier
|
|
|
|
--
|
|
|
|
local function checkAlarm(a)
|
|
|
|
if not a then
|
|
|
|
return
|
|
|
|
end
|
|
|
|
if not alarm then
|
|
|
|
alarm = a
|
|
|
|
else
|
|
|
|
alarm = lsyncd.earlier(alarm, a)
|
2010-10-24 16:41:58 +00:00
|
|
|
end
|
|
|
|
end
|
2010-11-06 21:29:22 +00:00
|
|
|
|
|
|
|
-- checks all syncs for their earliest alarm
|
|
|
|
for _, s in Syncs.iwalk() do
|
|
|
|
checkAlarm(s:getAlarm())
|
2010-11-06 10:10:57 +00:00
|
|
|
end
|
2010-11-06 21:29:22 +00:00
|
|
|
-- checks if a statusfile write has been delayed
|
|
|
|
checkAlarm(StatusFile.getAlarm())
|
2010-11-06 10:10:57 +00:00
|
|
|
|
2010-11-05 18:20:33 +00:00
|
|
|
log("Debug", "lysncd_get_alarm returns: ",alarm)
|
|
|
|
return 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-05 15:18:01 +00:00
|
|
|
-----
|
|
|
|
-- Main utility to create new observations.
|
|
|
|
--
|
|
|
|
function sync(opts)
|
|
|
|
if running then
|
|
|
|
error("Cannot add syncs while running!")
|
|
|
|
end
|
2010-11-06 10:10:00 +00:00
|
|
|
Syncs.add(opts)
|
2010-11-05 15:18:01 +00:00
|
|
|
end
|
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, ...)
|
2010-11-05 13:34:02 +00:00
|
|
|
return lsyncd.exec("/bin/sh", "-c", command, "/bin/sh", ...)
|
|
|
|
end
|
|
|
|
|
|
|
|
function exec(...)
|
|
|
|
return lsyncd.exec(...)
|
2010-10-27 11:31:18 +00:00
|
|
|
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
|
|
|
|
--
|
2010-11-06 15:08:17 +00:00
|
|
|
local defaultRsync = {
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-10-27 19:34:56 +00:00
|
|
|
-- Called for every sync/target pair on startup
|
2010-11-06 17:40:12 +00:00
|
|
|
startup = function(source, config)
|
2010-11-02 21:04:01 +00:00
|
|
|
log("Normal", "startup recursive rsync: ", source, " -> ", target)
|
2010-11-06 17:40:12 +00:00
|
|
|
return exec("/usr/bin/rsync", "-ltrs", source, target)
|
2010-10-27 19:34:56 +00:00
|
|
|
end,
|
|
|
|
|
2010-11-06 17:40:12 +00:00
|
|
|
default = function(inlet)
|
|
|
|
-- TODO
|
|
|
|
--return exec("/usr/bin/rsync", "--delete", "-ltds",
|
|
|
|
-- 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)
|
2010-11-04 13:43:57 +00:00
|
|
|
local event = inlet.get_event()
|
2010-11-05 15:18:01 +00:00
|
|
|
local config = inlet.get_config()
|
|
|
|
local func = config["on".. event.etype]
|
2010-11-02 20:18:05 +00:00
|
|
|
if func then
|
2010-11-05 15:18:01 +00:00
|
|
|
-- TODO Moves?
|
2010-11-06 17:40:12 +00:00
|
|
|
return func(event)
|
2010-11-02 20:18:05 +00:00
|
|
|
else
|
|
|
|
return -1
|
|
|
|
end
|
|
|
|
end,
|
|
|
|
|
2010-10-26 11:26:57 +00:00
|
|
|
-----
|
|
|
|
-- TODO
|
|
|
|
--
|
2010-11-06 10:10:57 +00:00
|
|
|
maxProcesses = 1,
|
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-11-06 10:10:57 +00:00
|
|
|
-- Minimum seconds between two writes of a status file.
|
|
|
|
--
|
2010-11-06 10:33:26 +00:00
|
|
|
statusIntervall = 10,
|
2010-10-27 19:34:56 +00:00
|
|
|
|
2010-11-06 16:54:45 +00:00
|
|
|
-----
|
2010-10-26 11:26:57 +00:00
|
|
|
-- TODO
|
|
|
|
--
|
2010-11-06 10:10:57 +00:00
|
|
|
collapseTable = {
|
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
|
|
|
},
|
|
|
|
|
2010-11-06 15:08:17 +00:00
|
|
|
rsync = defaultRsync
|
2010-10-26 11:26:57 +00:00
|
|
|
}
|
|
|
|
|
2010-11-06 15:13:02 +00:00
|
|
|
return "x3x"
|