mirror of
https://github.com/octoleo/lsyncd.git
synced 2024-12-13 14:43:09 +00:00
3067 lines
70 KiB
Lua
3067 lines
70 KiB
Lua
--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
-- lsyncd.lua Live (Mirror) Syncing Demon
|
|
--
|
|
-- 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.
|
|
--
|
|
-- License: GPLv2 (see COPYING) or any later version
|
|
-- Authors: Axel Kittenberger <axkibe@gmail.com>
|
|
--
|
|
--~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
|
|
|
-- require('profiler')
|
|
-- profiler.start()
|
|
|
|
-----
|
|
-- A security measurement.
|
|
-- Core will exit if version ids mismatch.
|
|
--
|
|
if lsyncd_version then
|
|
-- checks if the runner is being loaded twice
|
|
lsyncd.log('Error', 'You cannot use the lsyncd runner as configuration file!')
|
|
lsyncd.terminate(-1) -- ERRNO
|
|
end
|
|
lsyncd_version = '2.0.7'
|
|
|
|
-----
|
|
-- Hides the core interface from user scripts
|
|
--
|
|
local _l = lsyncd
|
|
lsyncd = nil
|
|
local lsyncd = _l
|
|
_l = nil
|
|
|
|
-----
|
|
-- Shortcuts (which user is supposed to be able to use them as well)
|
|
--
|
|
log = lsyncd.log
|
|
terminate = lsyncd.terminate
|
|
now = lsyncd.now
|
|
readdir = lsyncd.readdir
|
|
-- just to safe from userscripts changing this.
|
|
local log = log
|
|
local terminate = terminate
|
|
local now = now
|
|
|
|
------
|
|
-- Predeclarations
|
|
--
|
|
local Monitors
|
|
|
|
-----
|
|
-- Global: total number of processess running
|
|
local processCount = 0
|
|
|
|
--============================================================================
|
|
-- Lsyncd Prototypes
|
|
--============================================================================
|
|
|
|
-----
|
|
-- The array objects are tables that error if accessed with a non-number.
|
|
--
|
|
local Array = (function()
|
|
-- Metatable
|
|
local mt = {}
|
|
|
|
-- on accessing a nil index.
|
|
mt.__index = function(t, k)
|
|
if type(k) ~= 'number' then
|
|
error('Key "'..k..'" invalid for Array', 2)
|
|
end
|
|
return rawget(t, k)
|
|
end
|
|
|
|
-- on assigning a new index.
|
|
mt.__newindex = function(t, k, v)
|
|
if type(k) ~= 'number' then
|
|
error('Key "'..k..'" invalid for Array', 2)
|
|
end
|
|
rawset(t, k, v)
|
|
end
|
|
|
|
-- creates a new object
|
|
local function new()
|
|
local o = {}
|
|
setmetatable(o, mt)
|
|
return o
|
|
end
|
|
|
|
-- objects public interface
|
|
return {new = new}
|
|
end)()
|
|
|
|
|
|
-----
|
|
-- The count array objects are tables that error if accessed with a non-number.
|
|
-- Additionally they maintain their length as 'size' attribute.
|
|
-- Lua's # operator does not work on tables which key values are not
|
|
-- strictly linear.
|
|
--
|
|
local CountArray = (function()
|
|
-- Metatable
|
|
local mt = {}
|
|
|
|
-----
|
|
-- key to native table
|
|
local k_nt = {}
|
|
|
|
-----
|
|
-- on accessing a nil index.
|
|
mt.__index = function(t, k)
|
|
if type(k) ~= 'number' then
|
|
error('Key "'..k..'" invalid for CountArray', 2)
|
|
end
|
|
return t[k_nt][k]
|
|
end
|
|
|
|
-----
|
|
-- on assigning a new index.
|
|
mt.__newindex = function(t, k, v)
|
|
if type(k) ~= 'number' then
|
|
error('Key "'..k..'" invalid for CountArray', 2)
|
|
end
|
|
-- value before
|
|
local vb = t[k_nt][k]
|
|
if v and not vb then
|
|
t._size = t._size + 1
|
|
elseif not v and vb then
|
|
t._size = t._size - 1
|
|
end
|
|
t[k_nt][k] = v
|
|
end
|
|
|
|
-----
|
|
-- Walks through all entries in any order.
|
|
--
|
|
local function walk(self)
|
|
return pairs(self[k_nt])
|
|
end
|
|
|
|
-----
|
|
-- returns the count
|
|
--
|
|
local function size(self)
|
|
return self._size
|
|
end
|
|
|
|
-----
|
|
-- creates a new count array
|
|
--
|
|
local function new()
|
|
-- k_nt is native table, private for this object.
|
|
local o = {_size = 0, walk = walk, size = size, [k_nt] = {} }
|
|
setmetatable(o, mt)
|
|
return o
|
|
end
|
|
|
|
-----
|
|
-- public interface
|
|
--
|
|
return {new = new}
|
|
end)()
|
|
|
|
-----
|
|
-- Queue
|
|
-- optimized for pushing on the right and poping on the left.
|
|
--
|
|
--
|
|
Queue = (function()
|
|
-----
|
|
-- Creates a new queue.
|
|
--
|
|
local function new()
|
|
return { first = 1, last = 0, size = 0};
|
|
end
|
|
|
|
-----
|
|
-- Pushes a value on the queue.
|
|
-- Returns the last value
|
|
--
|
|
local function push(list, value)
|
|
if not value then
|
|
error('Queue pushing nil value', 2)
|
|
end
|
|
local last = list.last + 1
|
|
list.last = last
|
|
list[last] = value
|
|
list.size = list.size + 1
|
|
return last
|
|
end
|
|
|
|
-----
|
|
-- Removes item at pos from Queue.
|
|
--
|
|
local function remove(list, pos)
|
|
if list[pos] == nil then
|
|
error('Removing nonexisting item in Queue', 2)
|
|
end
|
|
list[pos] = nil
|
|
|
|
-- if removing first element, move list on.
|
|
if pos == list.first then
|
|
local last = list.last
|
|
while list[pos] == nil and pos <= list.last do
|
|
pos = pos + 1
|
|
end
|
|
list.first = pos
|
|
elseif pos == list.last then
|
|
while list[pos] == nil and pos >= list.first do
|
|
pos = pos - 1
|
|
end
|
|
list.last = pos
|
|
end
|
|
|
|
-- reset indizies if list is empty
|
|
if list.last < list.first then
|
|
list.first = 1
|
|
list.last = 0
|
|
end
|
|
list.size = list.size - 1
|
|
end
|
|
|
|
-----
|
|
-- Queue iterator (stateless)
|
|
--
|
|
local function iter(list, pos)
|
|
pos = pos + 1
|
|
while list[pos] == nil and pos <= list.last do
|
|
pos = pos + 1
|
|
end
|
|
if pos > list.last then
|
|
return nil
|
|
end
|
|
return pos, list[pos]
|
|
end
|
|
|
|
-----
|
|
-- Reverse queue iterator. (stateless)
|
|
--
|
|
local function iterReverse(list, pos)
|
|
pos = pos - 1
|
|
while list[pos] == nil and pos >= list.first do
|
|
pos = pos - 1
|
|
end
|
|
if pos < list.first then
|
|
return nil
|
|
end
|
|
return pos, list[pos]
|
|
end
|
|
|
|
-----
|
|
-- Iteraters through the queue
|
|
-- returning all non-nil pos-value entries
|
|
--
|
|
local function qpairs(list)
|
|
return iter, list, list.first - 1
|
|
end
|
|
|
|
-----
|
|
-- Iteraters backwards through the queue
|
|
-- returning all non-nil pos-value entries
|
|
--
|
|
local function qpairsReverse(list)
|
|
return iterReverse, list, list.last + 1
|
|
end
|
|
|
|
return {new = new,
|
|
push = push,
|
|
remove = remove,
|
|
qpairs = qpairs,
|
|
qpairsReverse = qpairsReverse}
|
|
end)()
|
|
|
|
-----
|
|
-- Locks globals,
|
|
-- no more globals can be created
|
|
--
|
|
local function lockGlobals()
|
|
local t = _G
|
|
local mt = getmetatable(t) or {}
|
|
mt.__index = function(t, k)
|
|
if (k~='_' and string.sub(k, 1, 2) ~= '__') then
|
|
error('Access of non-existing global "'..k..'"', 2)
|
|
else
|
|
rawget(t, k)
|
|
end
|
|
end
|
|
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
|
|
setmetatable(t, mt)
|
|
end
|
|
|
|
-----
|
|
-- Holds information about a delayed event of one Sync.
|
|
--
|
|
local Delay = (function()
|
|
-----
|
|
-- Creates a new delay.
|
|
--
|
|
-- @params see below
|
|
--
|
|
local function new(etype, sync, alarm, path, path2)
|
|
local o = {
|
|
-----
|
|
-- Type of event.
|
|
-- Can be 'Create', 'Modify', 'Attrib', 'Delete' and 'Move'
|
|
etype = etype,
|
|
|
|
------
|
|
-- Sync this delay belongs to
|
|
sync = sync,
|
|
|
|
-----
|
|
-- Latest point in time this should be catered for.
|
|
-- This value is in kernel ticks, return of the C's
|
|
-- times(NULL) call.
|
|
alarm = alarm,
|
|
|
|
-----
|
|
-- path and filename or dirname of the delay relative
|
|
-- to the syncs root.
|
|
-- for the directories it contains a trailing slash
|
|
--
|
|
path = path,
|
|
|
|
------
|
|
-- only not nil for 'Move's.
|
|
-- path and file/dirname of a move destination.
|
|
path2 = path2,
|
|
|
|
------
|
|
-- Status of the event. Valid stati are:
|
|
-- 'wait' ... the event is ready to be handled.
|
|
-- 'active' ... there is process running catering for this event.
|
|
-- 'blocked' ... this event waits for another to be handled first.
|
|
-- 'done' ... event has been collected. This should never be
|
|
-- visible as all references should be droped on
|
|
-- collection, nevertheless seperat status for
|
|
-- insurrance.
|
|
status = 'wait',
|
|
|
|
-----
|
|
-- Position in the queue
|
|
dpos = -1,
|
|
}
|
|
return o
|
|
end
|
|
|
|
-- public interface
|
|
return {new = new}
|
|
end)()
|
|
|
|
-----
|
|
-- combines delays
|
|
--
|
|
local Combiner = (function()
|
|
|
|
----
|
|
-- new delay absorbed by old
|
|
--
|
|
local function abso(d1, d2)
|
|
log('Delay',d2.etype,':',d2.path,' absorbed by ',d1.etype,':',d1.path)
|
|
return 'absorb'
|
|
end
|
|
|
|
----
|
|
-- new delay replaces the old one if it is a file
|
|
--
|
|
local function refi(d1, d2)
|
|
if d2.path:byte(-1) == 47 then
|
|
log('Delay',d2.etype,':',d2.path,' blocked by ',d1.etype,':',d1.path)
|
|
return 'stack'
|
|
end
|
|
log('Delay',d2.etype,':',d2.path,' replaces ',d1.etype,':',d1.path)
|
|
return 'replace'
|
|
end
|
|
|
|
----
|
|
-- new delay replaces the old one
|
|
--
|
|
local function repl(d1, d2)
|
|
log('Delay',d2.etype,':',d2.path,' replaces ',d1.etype,':',d1.path)
|
|
return 'replace'
|
|
end
|
|
|
|
----
|
|
-- delays nullificate each other
|
|
--
|
|
local function null(d1, d2)
|
|
log('Delay',d2.etype,':',d2.path,' nullifies ',d1.etype,':',d1.path)
|
|
return 'remove'
|
|
end
|
|
|
|
-----
|
|
-- Table how to combine events that dont involve a move.
|
|
--
|
|
local combineNoMove = {
|
|
Attrib = {Attrib=abso, Modify=repl, Create=repl, Delete=repl },
|
|
Modify = {Attrib=abso, Modify=abso, Create=repl, Delete=repl },
|
|
Create = {Attrib=abso, Modify=abso, Create=abso, Delete=repl },
|
|
Delete = {Attrib=abso, Modify=abso, Create=refi, Delete=abso },
|
|
}
|
|
|
|
------
|
|
-- combines two delays
|
|
--
|
|
local function combine(d1, d2)
|
|
if d1.etype == 'Init' or d1.etype == 'Blanket' then
|
|
-- everything is blocked by init or blanket delays.
|
|
if d2.path2 then
|
|
log('Delay',d2.etype,':',d2.path,'->',d2.path2,' blocked by ',d1.etype,' event')
|
|
else
|
|
log('Delay',d2.etype,':',d2.path,' blocked by ',d1.etype,' event')
|
|
end
|
|
return 'stack'
|
|
end
|
|
|
|
-- Two normal events
|
|
if d1.etype ~= 'Move' and d2.etype ~= 'Move' then
|
|
if d1.path == d2.path then
|
|
if d1.status == 'active' then
|
|
return 'stack'
|
|
end
|
|
return combineNoMove[d1.etype][d2.etype](d1, d2)
|
|
end
|
|
|
|
-- blocks events if one is a parent directory of another
|
|
if d1.path:byte(-1) == 47 and string.starts(d2.path, d1.path) or
|
|
d2.path:byte(-1) == 47 and string.starts(d1.path, d2.path)
|
|
then
|
|
return 'stack'
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Normal upon a Move
|
|
if d1.etype == 'Move' and d2.etype ~= 'Move' then
|
|
-- stacks the move if the from field could anyway be damaged
|
|
if d1.path == d2.path or
|
|
d2.path:byte(-1) == 47 and string.starts(d1.path, d2.path) or
|
|
d1.path:byte(-1) == 47 and string.starts(d2.path, d1.path)
|
|
then
|
|
log('Delay',d2.etype,':',d2.path,' blocked by ','Move :',d1.path,'->',d1.path2)
|
|
return 'stack'
|
|
end
|
|
|
|
-- Event does something with the move destination
|
|
if d1.path2 == d2.path then
|
|
if d2.etype == 'Delete' or d2.etype == 'Create' then
|
|
if d1.status == 'active' then
|
|
return 'stack'
|
|
end
|
|
log('Delay',d2.etype,':',d2.path,' turns ',
|
|
'Move :',d1.path,'->',d1.path2,' into ','Delete:',d1.path)
|
|
d1.etype = 'Delete'
|
|
d1.path2 = nil
|
|
return 'stack'
|
|
end
|
|
-- on 'Attrib' or 'Modify' simply wait for the move first
|
|
return 'stack'
|
|
end
|
|
|
|
if d2.path :byte(-1) == 47 and string.starts(d1.path2, d2.path) or
|
|
d1.path2:byte(-1) == 47 and string.starts(d2.path, d1.path2)
|
|
then
|
|
log('Delay',d2.etype,':',d2.path,' blocked by ','Move:',d1.path,'->',d1.path2)
|
|
return 'stack'
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Move upon a single event
|
|
if d1.etype ~= 'Move' and d2.etype == 'Move' then
|
|
if d1.path == d2.path or d1.path == d2.path2 or
|
|
d1.path :byte(-1) == 47 and string.starts(d2.path, d1.path) or
|
|
d1.path :byte(-1) == 47 and string.starts(d2.path2, d1.path) or
|
|
d2.path :byte(-1) == 47 and string.starts(d1.path, d2.path) or
|
|
d2.path2:byte(-1) == 47 and string.starts(d1.path, d2.path2)
|
|
then
|
|
log('Delay','Move:',d2.path,'->',d2.path2,' splits on ',d1.etype,':',d1.path)
|
|
return 'split'
|
|
end
|
|
return nil
|
|
end
|
|
|
|
-- Move upon move
|
|
if d1.etype == 'Move' and d2.etype == 'Move' then
|
|
-- TODO combine moves,
|
|
|
|
if d1.path == d2.path or d1.path == d2.path2 or
|
|
d1.path2 == d2.path or d2.path2 == d2.path or
|
|
d1.path :byte(-1) == 47 and string.starts(d2.path, d1.path) or
|
|
d1.path :byte(-1) == 47 and string.starts(d2.path2, d1.path) or
|
|
d1.path2:byte(-1) == 47 and string.starts(d2.path, d1.path2) or
|
|
d1.path2:byte(-1) == 47 and string.starts(d2.path2, d1.path2) or
|
|
d2.path :byte(-1) == 47 and string.starts(d1.path, d2.path) or
|
|
d2.path :byte(-1) == 47 and string.starts(d1.path2, d2.path) or
|
|
d2.path2:byte(-1) == 47 and string.starts(d1.path, d2.path2) or
|
|
d2.path2:byte(-1) == 47 and string.starts(d1.path2, d2.path2)
|
|
then
|
|
log('Delay','Move:',d2.path,'->',d1.path2,
|
|
' splits on Move:',d1.path,'->',d1.path2)
|
|
return 'split'
|
|
end
|
|
return nil
|
|
end
|
|
|
|
error('reached impossible state')
|
|
end
|
|
|
|
-- public interface
|
|
return {combine = combine}
|
|
end)()
|
|
|
|
-----
|
|
-- Creates inlets for syncs: the user interface for events.
|
|
--
|
|
local InletFactory = (function()
|
|
-----
|
|
-- table to receive the delay of an event
|
|
-- or the delay list of an event list.
|
|
--
|
|
-- Keys are events and values are delays.
|
|
local e2d = {}
|
|
|
|
-----
|
|
-- table to ensure the uniqueness of every event
|
|
-- related to a delay.
|
|
--
|
|
-- Keys are delay and values are events.
|
|
local e2d2 = {}
|
|
|
|
-----
|
|
-- allows the garbage collector to remove not refrenced
|
|
-- events.
|
|
setmetatable(e2d, { __mode = 'k' })
|
|
setmetatable(e2d2, { __mode = 'v' })
|
|
|
|
-----
|
|
-- 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
|
|
|
|
local function getPath(event)
|
|
if event.move ~= 'To' then
|
|
return e2d[event].path
|
|
else
|
|
return e2d[event].path2
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Interface for user scripts to get event fields.
|
|
--
|
|
local eventFields = {
|
|
-----
|
|
-- Returns a copy of the configuration as called by sync.
|
|
-- But including all inherited data and default values.
|
|
--
|
|
-- TODO give user a readonly version.
|
|
--
|
|
config = function(event)
|
|
return e2d[event].sync.config
|
|
end,
|
|
|
|
-----
|
|
-- Returns the inlet belonging to an event.
|
|
--
|
|
inlet = function(event)
|
|
return e2d[event].sync.inlet
|
|
end,
|
|
|
|
-----
|
|
-- Returns the type of the event.
|
|
-- Can be: 'Attrib', 'Create', 'Delete', 'Modify' or 'Move',
|
|
--
|
|
etype = function(event)
|
|
return e2d[event].etype
|
|
end,
|
|
|
|
-----
|
|
-- Tells this isn't a list.
|
|
--
|
|
isList = function()
|
|
return false
|
|
end,
|
|
|
|
-----
|
|
-- Return the status of the event.
|
|
-- Can be:
|
|
-- 'wait', 'active', 'block'.
|
|
--
|
|
status = function(event)
|
|
return e2d[event].status
|
|
end,
|
|
|
|
-----
|
|
-- Returns true if event relates to a directory.
|
|
--
|
|
isdir = function(event)
|
|
return string.byte(getPath(event), -1) == 47
|
|
end,
|
|
|
|
-----
|
|
-- Returns the name of the file/dir.
|
|
-- Includes a trailing slash for dirs.
|
|
--
|
|
name = function(event)
|
|
return string.match(getPath(event), '[^/]+/?$')
|
|
end,
|
|
|
|
-----
|
|
-- Returns the name of the file/dir.
|
|
-- Excludes a trailing slash for dirs.
|
|
--
|
|
basename = function(event)
|
|
return string.match(getPath(event), '([^/]+)/?$')
|
|
end,
|
|
|
|
-----
|
|
-- Returns the file/dir relative to watch root
|
|
-- Includes a trailing slash for dirs.
|
|
--
|
|
path = function(event)
|
|
return getPath(event)
|
|
end,
|
|
|
|
-----
|
|
-- Returns the directory of the file/dir relative to watch root
|
|
-- Always includes a trailing slash.
|
|
--
|
|
pathdir = function(event)
|
|
return string.match(getPath(event), '^(.*/)[^/]+/?') or ''
|
|
end,
|
|
|
|
-----
|
|
-- Returns the file/dir relativ to watch root
|
|
-- Excludes a trailing slash for dirs.
|
|
--
|
|
pathname = function(event)
|
|
return cutSlash(getPath(event))
|
|
end,
|
|
|
|
------
|
|
-- Returns the absolute path of the watch root.
|
|
-- All symlinks will have been resolved.
|
|
--
|
|
source = function(event)
|
|
return e2d[event].sync.source
|
|
end,
|
|
|
|
------
|
|
-- Returns the absolute path of the file/dir.
|
|
-- Includes a trailing slash for dirs.
|
|
--
|
|
sourcePath = function(event)
|
|
return e2d[event].sync.source .. getPath(event)
|
|
end,
|
|
|
|
------
|
|
-- Returns the absolute dir of the file/dir.
|
|
-- Includes a trailing slash.
|
|
--
|
|
sourcePathdir = function(event)
|
|
return e2d[event].sync.source ..
|
|
(string.match(getPath(event), '^(.*/)[^/]+/?') or '')
|
|
end,
|
|
|
|
------
|
|
-- Returns the absolute path of the file/dir.
|
|
-- Excludes a trailing slash for dirs.
|
|
--
|
|
sourcePathname = function(event)
|
|
return e2d[event].sync.source .. cutSlash(getPath(event))
|
|
end,
|
|
|
|
------
|
|
-- Returns the target.
|
|
-- Just for user comfort
|
|
--
|
|
-- (except here, the lsyncd.runner does not care event about the
|
|
-- existance of 'target', this is up to the scripts.)
|
|
--
|
|
target = function(event)
|
|
return e2d[event].sync.config.target
|
|
end,
|
|
|
|
------
|
|
-- Returns the relative dir/file appended to the target.
|
|
-- Includes a trailing slash for dirs.
|
|
--
|
|
targetPath = function(event)
|
|
return e2d[event].sync.config.target .. getPath(event)
|
|
end,
|
|
|
|
------
|
|
-- Returns the dir of the dir/file appended to the target.
|
|
-- Includes a trailing slash.
|
|
--
|
|
targetPathdir = function(event)
|
|
return e2d[event].sync.config.target ..
|
|
(string.match(getPath(event), '^(.*/)[^/]+/?') or '')
|
|
end,
|
|
|
|
------
|
|
-- Returns the relative dir/file appended to the target.
|
|
-- Excludes a trailing slash for dirs.
|
|
--
|
|
targetPathname = function(event)
|
|
return e2d[event].sync.config.target ..
|
|
cutSlash(getPath(event))
|
|
end,
|
|
}
|
|
|
|
-----
|
|
-- Retrievs event fields for the user script.
|
|
--
|
|
local eventMeta = {
|
|
__index = function(event, field)
|
|
local f = eventFields[field]
|
|
if not f then
|
|
if field == 'move' then
|
|
-- possibly undefined
|
|
return nil
|
|
end
|
|
error('event does not have field "'..field..'"', 2)
|
|
end
|
|
return f(event)
|
|
end
|
|
}
|
|
|
|
-----
|
|
-- Interface for user scripts to get event fields.
|
|
--
|
|
local eventListFuncs = {
|
|
-----
|
|
-- Returns a list of paths of all events in list.
|
|
--
|
|
-- @param elist -- handle returned by getevents()
|
|
-- @param mutator -- if not nil called with (etype, path, path2)
|
|
-- returns one or two strings to add.
|
|
--
|
|
getPaths = function(elist, mutator)
|
|
local dlist = e2d[elist]
|
|
if not dlist then
|
|
error('cannot find delay list from event list.')
|
|
end
|
|
local result = {}
|
|
local resultn = 1
|
|
for k, d in ipairs(dlist) do
|
|
local s1, s2
|
|
if mutator then
|
|
s1, s2 = mutator(d.etype, d.path, d.path2)
|
|
else
|
|
s1, s2 = d.path, d.path2
|
|
end
|
|
result[resultn] = s1
|
|
resultn = resultn + 1
|
|
if s2 then
|
|
result[resultn] = s2
|
|
resultn = resultn + 1
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
}
|
|
|
|
-----
|
|
-- Retrievs event list fields for the user script.
|
|
--
|
|
local eventListMeta = {
|
|
__index = function(elist, func)
|
|
if func == 'isList' then return true end
|
|
|
|
if func == 'config' then return e2d[elist].sync.config end
|
|
|
|
local f = eventListFuncs[func]
|
|
if not f then
|
|
error('event list does not have function "'..func..'"', 2)
|
|
end
|
|
|
|
return function(...)
|
|
return f(elist, ...)
|
|
end
|
|
end
|
|
}
|
|
|
|
-----
|
|
-- table of all inlets with their syncs
|
|
--
|
|
local inlets = {}
|
|
|
|
-----
|
|
-- allows the garbage collector to remove entries.
|
|
-- TODO check memory use
|
|
setmetatable(inlets, { __mode = 'v' })
|
|
|
|
-----
|
|
-- Encapsulates a delay into an event for the user script.
|
|
--
|
|
local function d2e(delay)
|
|
-- already created?
|
|
local eu = e2d2[delay]
|
|
|
|
if delay.etype ~= 'Move' then
|
|
if eu then return eu end
|
|
|
|
local event = {}
|
|
setmetatable(event, eventMeta)
|
|
e2d[event] = delay
|
|
e2d2[delay] = event
|
|
return event
|
|
else
|
|
-- moves have 2 events - origin and destination
|
|
if eu then return eu[1], eu[2] end
|
|
|
|
local event = { move = 'Fr' }
|
|
local event2 = { move = 'To' }
|
|
setmetatable(event, eventMeta)
|
|
setmetatable(event2, eventMeta)
|
|
e2d[event] = delay
|
|
e2d[event2] = delay
|
|
e2d2[delay] = { event, event2 }
|
|
-- move events have a field 'move'
|
|
return event, event2
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Encapsulates a delay list into an event list for the user script.
|
|
--
|
|
local function dl2el(dlist)
|
|
local eu = e2d2[dlist]
|
|
if eu then return eu end
|
|
|
|
local elist = {}
|
|
setmetatable(elist, eventListMeta)
|
|
e2d[elist] = dlist
|
|
e2d2[dlist] = elist
|
|
return elist
|
|
end
|
|
|
|
-----
|
|
-- The functions the inlet provides.
|
|
--
|
|
local inletFuncs = {
|
|
-----
|
|
-- adds an exclude.
|
|
--
|
|
addExclude = function(sync, pattern)
|
|
sync:addExclude(pattern)
|
|
end,
|
|
|
|
-----
|
|
-- removes an exclude.
|
|
--
|
|
rmExclude = function(sync, pattern)
|
|
sync:rmExclude(pattern)
|
|
end,
|
|
|
|
-----
|
|
-- gets the list of excludes in their original rsynlike patterns form.
|
|
--
|
|
getExcludes = function(sync)
|
|
-- creates a copy
|
|
local e = {}
|
|
local en = 1;
|
|
for k, _ in pairs(sync.excludes.list) do
|
|
e[en] = k;
|
|
en = en + 1;
|
|
end
|
|
return e;
|
|
end,
|
|
|
|
-----
|
|
-- Creates a blanketEvent that blocks everything
|
|
-- and is blocked by everything.
|
|
--
|
|
createBlanketEvent = function(sync)
|
|
return d2e(sync:addBlanketDelay())
|
|
end,
|
|
|
|
-----
|
|
-- Discards a waiting event.
|
|
--
|
|
discardEvent = function(sync, event)
|
|
local delay = e2d[event]
|
|
if delay.status ~= 'wait' then
|
|
log('Error',
|
|
'Ignored cancel of a non-waiting event of type ',
|
|
event.etype)
|
|
return
|
|
end
|
|
sync:removeDelay(delay)
|
|
end,
|
|
|
|
-----
|
|
-- Gets the next not blocked event from queue.
|
|
--
|
|
getEvent = function(sync)
|
|
return d2e(sync:getNextDelay(now()))
|
|
end,
|
|
|
|
-----
|
|
-- Gets all events that are not blocked by active events.
|
|
--
|
|
-- @param if not nil a function to test each delay
|
|
--
|
|
getEvents = function(sync, test)
|
|
local dlist = sync:getDelays(test)
|
|
return dl2el(dlist)
|
|
end,
|
|
|
|
-----
|
|
-- Returns the configuration table specified by sync{}
|
|
--
|
|
getConfig = function(sync)
|
|
-- TODO gives a readonly handler only.
|
|
return sync.config
|
|
end,
|
|
}
|
|
|
|
-----
|
|
-- Forwards access to inlet functions.
|
|
--
|
|
local inletMeta = {
|
|
__index = function(inlet, func)
|
|
local f = inletFuncs[func]
|
|
if not f then error('inlet does not have function "'..func..'"', 2) end
|
|
return function(...) return f(inlets[inlet], ...) end
|
|
end,
|
|
}
|
|
|
|
-----
|
|
-- Creates a new inlet for Sync
|
|
local function newInlet(sync)
|
|
-- lua runner controlled variables
|
|
local inlet = {}
|
|
|
|
-- sets use access methods
|
|
setmetatable(inlet, inletMeta)
|
|
inlets[inlet] = sync
|
|
return inlet
|
|
end
|
|
|
|
-----
|
|
-- Returns the delay from a event.
|
|
--
|
|
local function getDelayOrList(event)
|
|
return e2d[event]
|
|
end
|
|
|
|
-----
|
|
-- Returns the sync from an event or list
|
|
--
|
|
local function getSync(event)
|
|
return e2d[event].sync
|
|
end
|
|
|
|
-----
|
|
-- public interface.
|
|
-- this one is split, one for user one for runner.
|
|
return {
|
|
getDelayOrList = getDelayOrList,
|
|
d2e = d2e,
|
|
dl2el = dl2el,
|
|
getSync = getSync,
|
|
newInlet = newInlet,
|
|
}
|
|
end)()
|
|
|
|
|
|
-----
|
|
-- A set of exclude patterns
|
|
--
|
|
local Excludes = (function()
|
|
|
|
-----
|
|
-- Turns a rsync like file pattern to a lua pattern.
|
|
--
|
|
local function toLuaPattern(p)
|
|
local o = p
|
|
p = string.gsub(p, '%%', '%%%%')
|
|
p = string.gsub(p, '%^', '%%^')
|
|
p = string.gsub(p, '%$', '%%$')
|
|
p = string.gsub(p, '%(', '%%(')
|
|
p = string.gsub(p, '%)', '%%)')
|
|
p = string.gsub(p, '%.', '%%.')
|
|
p = string.gsub(p, '%[', '%%[')
|
|
p = string.gsub(p, '%]', '%%]')
|
|
p = string.gsub(p, '%+', '%%+')
|
|
p = string.gsub(p, '%-', '%%-')
|
|
p = string.gsub(p, '%?', '[^/]')
|
|
p = string.gsub(p, '%*', '[^/]*')
|
|
-- this was a ** before
|
|
p = string.gsub(p, '%[%^/%]%*%[%^/%]%*', '.*')
|
|
p = string.gsub(p, '^/', '^/')
|
|
if p:sub(1,2) ~= '^/' then -- does not begin with '^/'
|
|
-- all matches should begin with '/'.
|
|
p = '/'..p;
|
|
end
|
|
log('Exclude', 'toLuaPattern "',o,'" = "',p,'"')
|
|
return p
|
|
end
|
|
|
|
-----
|
|
-- Adds a pattern to exclude.
|
|
--
|
|
local function add(self, pattern)
|
|
if self.list[pattern] then
|
|
-- already in the list
|
|
return
|
|
end
|
|
local lp = toLuaPattern(pattern)
|
|
self.list[pattern] = lp
|
|
end
|
|
|
|
-----
|
|
-- Removes a pattern to exclude.
|
|
--
|
|
local function remove(self, pattern)
|
|
if not self.list[pattern] then
|
|
-- already in the list
|
|
log('Normal', 'Removing not excluded exclude "'..pattern..'"')
|
|
return
|
|
end
|
|
self.list[pattern] = nil
|
|
end
|
|
|
|
|
|
-----
|
|
-- Adds a list of patterns to exclude.
|
|
--
|
|
local function addList(self, plist)
|
|
for _, v in ipairs(plist) do
|
|
add(self, v)
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- loads excludes from a file
|
|
--
|
|
local function loadFile(self, file)
|
|
f, err = io.open(file)
|
|
if not f then
|
|
log('Error', 'Cannot open exclude file "',file,'": ', err)
|
|
terminate(-1) -- ERRNO
|
|
end
|
|
for line in f:lines() do
|
|
-- lsyncd 2.0 does not support includes
|
|
if not string.match(line, '%s*+') then
|
|
local p = string.match(line, '%s*-?%s*(.*)')
|
|
if p then add(self, p) end
|
|
end
|
|
end
|
|
f:close()
|
|
end
|
|
|
|
-----
|
|
-- Tests if 'path' is excluded.
|
|
--
|
|
local function test(self, path)
|
|
for _, p in pairs(self.list) do
|
|
if p:byte(-1) == 36 then
|
|
-- ends with $
|
|
if path:match(p) then return true end
|
|
else
|
|
-- ends either end with / or $
|
|
if path:match(p..'/') or path:match(p..'$') then return true end
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-----
|
|
-- Cretes a new exclude set
|
|
--
|
|
local function new()
|
|
return {
|
|
list = {},
|
|
|
|
-- functions
|
|
add = add,
|
|
addList = addList,
|
|
loadFile = loadFile,
|
|
remove = remove,
|
|
test = test,
|
|
}
|
|
end
|
|
|
|
-----
|
|
-- Public interface
|
|
return { new = new }
|
|
end)()
|
|
|
|
-----
|
|
-- Holds information about one observed directory inclusively subdirs.
|
|
--
|
|
local Sync = (function()
|
|
-----
|
|
-- Syncs that have no name specified by the user script
|
|
-- get an incremental default name 'Sync[X]'
|
|
--
|
|
local nextDefaultName = 1
|
|
|
|
-----
|
|
-- Adds an exclude.
|
|
--
|
|
local function addExclude(self, pattern)
|
|
return self.excludes:add(pattern)
|
|
end
|
|
|
|
-----
|
|
-- Removes an exclude.
|
|
--
|
|
local function rmExclude(self, pattern)
|
|
return self.excludes:remove(pattern)
|
|
end
|
|
|
|
-----
|
|
-- Removes a delay.
|
|
--
|
|
local function removeDelay(self, delay)
|
|
if self.delays[delay.dpos] ~= delay then
|
|
error('Queue is broken, delay not a dpos')
|
|
end
|
|
Queue.remove(self.delays, delay.dpos)
|
|
|
|
-- free all delays blocked by this one.
|
|
if delay.blocks then
|
|
for i, vd in pairs(delay.blocks) do
|
|
vd.status = 'wait'
|
|
end
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Returns true if this Sync concerns about 'path'
|
|
--
|
|
local function concerns(self, path)
|
|
-- not concerned if watch rootdir doesnt match
|
|
if not path:starts(self.source) then
|
|
return false
|
|
end
|
|
|
|
-- a sub dir and not concerned about subdirs
|
|
if self.config.subdirs == false and
|
|
path:sub(#self.source, -1):match('[^/]+/?')
|
|
then
|
|
return false
|
|
end
|
|
|
|
-- concerned if not excluded
|
|
return not self.excludes:test(path:sub(#self.source))
|
|
end
|
|
|
|
-----
|
|
-- Collects a child process
|
|
--
|
|
local function collect(self, pid, exitcode)
|
|
local delay = self.processes[pid]
|
|
if not delay then
|
|
-- not a child of this sync.
|
|
return
|
|
end
|
|
|
|
if delay.status then
|
|
log('Delay', 'collected an event')
|
|
if delay.status ~= 'active' then
|
|
error('collecting a non-active process')
|
|
end
|
|
local rc = self.config.collect(
|
|
InletFactory.d2e(delay),
|
|
exitcode)
|
|
if rc == 'die' then
|
|
log('Error', 'Critical exitcode.');
|
|
terminate(-1) --ERRNO
|
|
end
|
|
if rc ~= 'again' then
|
|
-- if its active again the collecter restarted the event
|
|
removeDelay(self, delay)
|
|
log('Delay', 'Finish of ',delay.etype,' on ',self.source,delay.path,' = ',exitcode)
|
|
else
|
|
-- sets the delay on wait again
|
|
delay.status = 'wait'
|
|
local alarm = self.config.delay
|
|
-- delays at least 1 second
|
|
if alarm < 1 then
|
|
alarm = 1
|
|
end
|
|
delay.alarm = now() + alarm
|
|
end
|
|
else
|
|
log('Delay', 'collected a list')
|
|
local rc = self.config.collect(
|
|
InletFactory.dl2el(delay),
|
|
exitcode)
|
|
if rc == 'die' then
|
|
log('Error', 'Critical exitcode.');
|
|
terminate(-1) --ERRNO
|
|
end
|
|
if rc == 'again' then
|
|
-- sets the delay on wait again
|
|
delay.status = 'wait'
|
|
local alarm = self.config.delay
|
|
-- delays at least 1 second
|
|
if alarm < 1 then
|
|
alarm = 1
|
|
end
|
|
alarm = now() + alarm
|
|
for _, d in ipairs(delay) do
|
|
d.alarm = alarm
|
|
d.status = 'wait'
|
|
end
|
|
end
|
|
for _, d in ipairs(delay) do
|
|
if rc ~= 'again' then
|
|
removeDelay(self, d)
|
|
else
|
|
d.status = 'wait'
|
|
end
|
|
end
|
|
log('Delay','Finished list = ',exitcode)
|
|
end
|
|
self.processes[pid] = nil
|
|
end
|
|
|
|
-----
|
|
-- Stacks a newDelay on the oldDelay,
|
|
-- the oldDelay blocks the new Delay.
|
|
--
|
|
-- A delay can block 'n' other delays,
|
|
-- but is blocked at most by one, the latest delay.
|
|
--
|
|
local function stack(oldDelay, newDelay)
|
|
newDelay.status = 'block'
|
|
if not oldDelay.blocks then
|
|
oldDelay.blocks = {}
|
|
end
|
|
table.insert(oldDelay.blocks, newDelay)
|
|
end
|
|
|
|
-----
|
|
-- Puts an action on the delay stack.
|
|
--
|
|
local function delay(self, etype, time, path, path2)
|
|
log('Function', 'delay(',self.config.name,', ',etype,', ',path,', ',path2,')')
|
|
|
|
-- TODO
|
|
local function recurse()
|
|
if etype == 'Create' and path:byte(-1) == 47 then
|
|
local entries = lsyncd.readdir(self.source .. path)
|
|
if entries then
|
|
for dirname, isdir in pairs(entries) do
|
|
local pd = path .. dirname
|
|
if isdir then pd = pd..'/' end
|
|
log('Delay', 'Create creates Create on ',pd)
|
|
delay(self, 'Create', time, pd, nil)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- exclusion tests
|
|
if not path2 then
|
|
-- simple test for single path events
|
|
if self.excludes:test(path) then
|
|
log('Exclude', 'excluded ',etype,' on "',path,'"')
|
|
return
|
|
end
|
|
else
|
|
-- for double paths (move) it might result into a split
|
|
local ex1 = self.excludes:test(path)
|
|
local ex2 = self.excludes:test(path2)
|
|
if ex1 and ex2 then
|
|
log('Exclude', 'excluded "',etype,' on "',path,'" -> "',path2,'"')
|
|
return
|
|
elseif not ex1 and ex2 then
|
|
-- splits the move if only partly excluded
|
|
log('Exclude', 'excluded destination transformed ',etype,' to Delete ',path)
|
|
delay(self, 'Delete', time, path, nil)
|
|
return
|
|
elseif ex1 and not ex2 then
|
|
-- splits the move if only partly excluded
|
|
log('Exclude', 'excluded origin transformed ',etype,' to Create.',path2)
|
|
delay(self, 'Create', time, path2, nil)
|
|
return
|
|
end
|
|
end
|
|
|
|
if etype == 'Move' and not self.config.onMove then
|
|
-- if there is no move action defined,
|
|
-- split a move as delete/create
|
|
-- layer 1 scripts which want moves events have to
|
|
-- set onMove simply to 'true'
|
|
log('Delay', '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 = time + self.config.delay
|
|
else
|
|
alarm = now()
|
|
end
|
|
-- new delay
|
|
local nd = Delay.new(etype, self, alarm, path, path2)
|
|
if nd.etype == 'Init' or nd.etype == 'Blanket' then
|
|
-- always stack blanket events on the last event
|
|
log('Delay', 'Stacking ',nd.etype,' event.')
|
|
if self.delays.size > 0 then
|
|
stack(self.delays[self.delays.last], nd)
|
|
end
|
|
nd.dpos = Queue.push(self.delays, nd)
|
|
recurse()
|
|
return
|
|
end
|
|
|
|
-- detects blocks and combos by working from back until
|
|
-- front through the fifo
|
|
for il, od in Queue.qpairsReverse(self.delays) do
|
|
-- asks Combiner what to do
|
|
local ac = Combiner.combine(od, nd)
|
|
|
|
if ac then
|
|
if ac == 'remove' then
|
|
Queue.remove(self.delays, il)
|
|
elseif ac == 'stack' then
|
|
stack(od, nd)
|
|
nd.dpos = Queue.push(self.delays, nd)
|
|
elseif ac == 'absorb' then
|
|
-- nada
|
|
elseif ac == 'replace' then
|
|
od.etype = nd.etype
|
|
od.path = nd.path
|
|
od.path2 = nd.path2
|
|
elseif ac == 'split' then
|
|
delay(self, 'Delete', time, path, nil)
|
|
delay(self, 'Create', time, path2, nil)
|
|
else
|
|
error('unknown result of combine()')
|
|
end
|
|
recurse()
|
|
return
|
|
end
|
|
il = il - 1
|
|
end
|
|
if nd.path2 then
|
|
log('Delay','New ',nd.etype,':',nd.path,'->',nd.path2)
|
|
else
|
|
log('Delay','New ',nd.etype,':',nd.path)
|
|
end
|
|
-- no block or combo
|
|
nd.dpos = Queue.push(self.delays, nd)
|
|
recurse()
|
|
end
|
|
|
|
-----
|
|
-- Returns the nearest alarm for this Sync.
|
|
--
|
|
local function getAlarm(self)
|
|
if self.processes:size() >= self.config.maxProcesses then
|
|
return false
|
|
end
|
|
|
|
-- first checks if more processes could be spawned
|
|
if self.processes:size() < self.config.maxProcesses then
|
|
-- finds the nearest delay waiting to be spawned
|
|
for _, d in Queue.qpairs(self.delays) do
|
|
if d.status == 'wait' then return d.alarm end
|
|
end
|
|
end
|
|
|
|
-- nothing to spawn
|
|
return false
|
|
end
|
|
|
|
-----
|
|
-- Gets all delays that are not blocked by active delays.
|
|
--
|
|
-- @param test function to test each delay
|
|
--
|
|
local function getDelays(self, test)
|
|
local dlist = { sync = self}
|
|
local dlistn = 1
|
|
local blocks = {}
|
|
|
|
----
|
|
-- inheritly transfers all blocks from delay
|
|
--
|
|
local function getBlocks(delay)
|
|
blocks[delay] = true
|
|
if delay.blocks then
|
|
for i, d in ipairs(delay.blocks) do
|
|
getBlocks(d)
|
|
end
|
|
end
|
|
end
|
|
|
|
for i, d in Queue.qpairs(self.delays) do
|
|
if d.status == 'active' or
|
|
(test and not test(InletFactory.d2e(d)))
|
|
then
|
|
getBlocks(d)
|
|
elseif not blocks[d] then
|
|
dlist[dlistn] = d
|
|
dlistn = dlistn + 1
|
|
end
|
|
end
|
|
|
|
return dlist
|
|
end
|
|
|
|
-----
|
|
-- Creates new actions
|
|
--
|
|
local function invokeActions(self, timestamp)
|
|
log('Function', 'invokeActions("',self.config.name,'",',timestamp,')')
|
|
if self.processes:size() >= self.config.maxProcesses then
|
|
-- no new processes
|
|
return
|
|
end
|
|
for _, d in Queue.qpairs(self.delays) do
|
|
-- if reached the global limit return
|
|
if settings.maxProcesses and processCount >= settings.maxProcesses then
|
|
log('Alarm', 'at global process limit.')
|
|
return
|
|
end
|
|
if self.delays.size < self.config.maxDelays then
|
|
-- time constrains are only concerned if not maxed
|
|
-- the delay FIFO already.
|
|
if d.alarm ~= true and timestamp < d.alarm then
|
|
-- reached point in stack where delays are in future
|
|
return
|
|
end
|
|
end
|
|
if d.status == 'wait' then
|
|
-- found a waiting delay
|
|
if d.etype ~= 'Init' then
|
|
self.config.action(self.inlet)
|
|
else
|
|
self.config.init(InletFactory.d2e(d))
|
|
end
|
|
if self.processes:size() >= self.config.maxProcesses then
|
|
-- no further processes
|
|
return
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Gets the next event to be processed.
|
|
--
|
|
local function getNextDelay(self, timestamp)
|
|
for i, d in Queue.qpairs(self.delays) do
|
|
if self.delays.size < self.config.maxDelays then
|
|
-- time constrains are only concerned if not maxed
|
|
-- the delay FIFO already.
|
|
if d.alarm ~= true and timestamp < d.alarm then
|
|
-- reached point in stack where delays are in future
|
|
return nil
|
|
end
|
|
end
|
|
if d.status == 'wait' then
|
|
-- found a waiting delay
|
|
return d
|
|
end
|
|
end
|
|
end
|
|
|
|
------
|
|
-- Adds and returns a blanket delay thats blocks all.
|
|
-- Used as custom marker.
|
|
--
|
|
local function addBlanketDelay(self)
|
|
local newd = Delay.new('Blanket', self, true, '')
|
|
newd.dpos = Queue.push(self.delays, newd)
|
|
return newd
|
|
end
|
|
|
|
------
|
|
-- Adds and returns a blanket delay thats blocks all.
|
|
-- Used as startup marker to call init asap.
|
|
--
|
|
local function addInitDelay(self)
|
|
local newd = Delay.new('Init', self, true, '')
|
|
newd.dpos = Queue.push(self.delays, newd)
|
|
return newd
|
|
end
|
|
|
|
-----
|
|
-- Writes a status report about delays in this sync.
|
|
--
|
|
local function statusReport(self, f)
|
|
local spaces = ' '
|
|
f:write(self.config.name,' source=',self.source,'\n')
|
|
f:write('There are ',self.delays.size, ' delays\n')
|
|
for i, vd in Queue.qpairs(self.delays) do
|
|
local st = vd.status
|
|
f:write(st, string.sub(spaces, 1, 7 - #st))
|
|
f:write(vd.etype,' ')
|
|
f:write(vd.path)
|
|
if (vd.path2) then
|
|
f:write(' -> ',vd.path2)
|
|
end
|
|
f:write('\n')
|
|
end
|
|
f:write('Excluding:\n')
|
|
local nothing = true
|
|
for t, p in pairs(self.excludes.list) do
|
|
nothing = false
|
|
f:write(t,'\n')
|
|
end
|
|
if nothing then
|
|
f:write(' nothing.\n')
|
|
end
|
|
f:write('\n')
|
|
end
|
|
|
|
-----
|
|
-- Creates a new Sync
|
|
--
|
|
local function new(config)
|
|
local s = {
|
|
-- fields
|
|
config = config,
|
|
delays = Queue.new(),
|
|
source = config.source,
|
|
processes = CountArray.new(),
|
|
excludes = Excludes.new(),
|
|
|
|
-- functions
|
|
addBlanketDelay = addBlanketDelay,
|
|
addExclude = addExclude,
|
|
addInitDelay = addInitDelay,
|
|
collect = collect,
|
|
concerns = concerns,
|
|
delay = delay,
|
|
getAlarm = getAlarm,
|
|
getDelays = getDelays,
|
|
getNextDelay = getNextDelay,
|
|
invokeActions = invokeActions,
|
|
removeDelay = removeDelay,
|
|
rmExclude = rmExclude,
|
|
statusReport = statusReport,
|
|
}
|
|
s.inlet = InletFactory.newInlet(s)
|
|
|
|
-- provides a default name if needed
|
|
if not config.name then
|
|
config.name = 'Sync'..nextDefaultName
|
|
end
|
|
-- increments default nevertheless to cause less confusion
|
|
-- so name will be the n-th call to sync{}
|
|
nextDefaultName = nextDefaultName + 1
|
|
|
|
-- loads exclusions
|
|
if config.exclude then
|
|
local te = type(config.exclude)
|
|
if te == 'table' then
|
|
s.excludes:addList(config.exclude)
|
|
elseif te == 'string' then
|
|
s.excludes:add(config.exclude)
|
|
else
|
|
error('type for exclude must be table or string', 2)
|
|
end
|
|
end
|
|
if config.excludeFrom then
|
|
s.excludes:loadFile(config.excludeFrom)
|
|
end
|
|
|
|
return s
|
|
end
|
|
|
|
-----
|
|
-- public interface
|
|
--
|
|
return {new = new}
|
|
end)()
|
|
|
|
|
|
-----
|
|
-- Syncs - a singleton
|
|
--
|
|
-- It maintains all configured directories to be synced.
|
|
--
|
|
local Syncs = (function()
|
|
-----
|
|
-- the list of all syncs
|
|
--
|
|
local list = Array.new()
|
|
|
|
-----
|
|
-- The round robin pointer. In case of global limited maxProcesses
|
|
-- gives every sync equal chances to spawn the next process.
|
|
--
|
|
local round = 1
|
|
|
|
-----
|
|
-- The cycle() sheduler goes into the next round of roundrobin.
|
|
local function nextRound()
|
|
round = round + 1;
|
|
if round > #list then
|
|
round = 1
|
|
end
|
|
return round
|
|
end
|
|
|
|
-----
|
|
-- Returns the round
|
|
local function getRound()
|
|
return round
|
|
end
|
|
|
|
-----
|
|
-- Returns sync at listpos i
|
|
local function get(i)
|
|
return list[i];
|
|
end
|
|
|
|
-----
|
|
-- Inheritly copies all non integer keys from
|
|
-- copy source (cs) to copy destination (cd).
|
|
--
|
|
-- all entries with integer keys are treated as new sources to copy
|
|
--
|
|
local function inherit(cd, cs)
|
|
-- first copies from source all
|
|
-- non-defined non-integer keyed values
|
|
for k, v in pairs(cs) do
|
|
if type(k) ~= 'number' and cd[k] == nil then
|
|
cd[k] = v
|
|
end
|
|
end
|
|
-- first recurses into all integer keyed tables
|
|
for i, v in ipairs(cs) do
|
|
if type(v) == 'table' then
|
|
inherit(cd, v)
|
|
end
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Adds a new sync (directory-tree to observe).
|
|
--
|
|
local function add(config)
|
|
-- Creates a new config table and inherit all keys/values
|
|
-- from integer keyed tables
|
|
local uconfig = config
|
|
config = {}
|
|
inherit(config, uconfig)
|
|
|
|
-- Lets settings or commandline override delay values.
|
|
if settings then
|
|
config.delay = settings.delay or config.delay
|
|
end
|
|
|
|
-- at very first lets the userscript 'prepare' function
|
|
-- fill out more values.
|
|
if type(config.prepare) == 'function' then
|
|
-- explicitly gives a writeable copy of config.
|
|
config.prepare(config)
|
|
end
|
|
|
|
if not config['source'] then
|
|
local info = debug.getinfo(3, 'Sl')
|
|
log('Error', info.short_src,':',info.currentline,': source missing from sync.')
|
|
terminate(-1) -- ERRNO
|
|
end
|
|
|
|
-- absolute path of source
|
|
local realsrc = lsyncd.realdir(config.source)
|
|
if not realsrc then
|
|
log('Error', 'Cannot access source directory: ',config.source)
|
|
terminate(-1) -- ERRNO
|
|
end
|
|
config._source = config.source
|
|
config.source = realsrc
|
|
|
|
if not config.action and not config.onAttrib and
|
|
not config.onCreate and not config.onModify and
|
|
not config.onDelete and not config.onMove
|
|
then
|
|
local info = debug.getinfo(3, 'Sl')
|
|
log('Error', info.short_src, ':', info.currentline,
|
|
': no actions specified, use e.g. "config = default.rsync".')
|
|
terminate(-1) -- ERRNO
|
|
end
|
|
|
|
-- loads a default value for an option if not existent
|
|
if not settings then
|
|
settings = {}
|
|
end
|
|
local defaultValues = {
|
|
'action',
|
|
'collect',
|
|
'init',
|
|
'maxDelays',
|
|
'maxProcesses',
|
|
}
|
|
for _, dn in pairs(defaultValues) do
|
|
if config[dn] == nil then
|
|
config[dn] = settings[dn] or default[dn]
|
|
end
|
|
end
|
|
|
|
-- the monitor to use
|
|
config.monitor =
|
|
settings.monitor or config.monitor or Monitors.default()
|
|
if config.monitor ~= 'inotify' and config.monitor ~= 'fsevents' then
|
|
local info = debug.getinfo(3, 'Sl')
|
|
log('Error',info.short_src,':',info.currentline,
|
|
': event monitor "',config.monitor,'" unknown.')
|
|
terminate(-1) -- ERRNO
|
|
end
|
|
|
|
--- creates the new sync
|
|
local s = Sync.new(config)
|
|
table.insert(list, s)
|
|
return s
|
|
end
|
|
|
|
-----
|
|
-- Allows a for-loop to walk through all syncs.
|
|
--
|
|
local function iwalk()
|
|
return ipairs(list)
|
|
end
|
|
|
|
-----
|
|
-- Returns the number of syncs.
|
|
--
|
|
local size = function()
|
|
return #list
|
|
end
|
|
|
|
------
|
|
-- Tests if any sync is interested in a path.
|
|
--
|
|
local function concerns(path)
|
|
for _, s in ipairs(list) do
|
|
if s:concerns(path) then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
-- public interface
|
|
return {
|
|
add = add,
|
|
get = get,
|
|
getRound = getRound,
|
|
concerns = concerns,
|
|
iwalk = iwalk,
|
|
nextRound = nextRound,
|
|
size = size
|
|
}
|
|
end)()
|
|
|
|
|
|
-----
|
|
-- Utility function, returns the relative part of absolute path if it
|
|
-- begins with root
|
|
--
|
|
local function splitPath(path, root)
|
|
local rlen = #root
|
|
local sp = string.sub(path, 1, rlen)
|
|
|
|
if sp == root then
|
|
return string.sub(path, rlen, -1)
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Interface to inotify, watches recursively subdirs and
|
|
-- sends events.
|
|
--
|
|
-- All inotify specific implementation should be enclosed here.
|
|
--
|
|
local Inotify = (function()
|
|
|
|
-----
|
|
-- A list indexed by inotifies watch descriptor yielding the
|
|
-- directories absolute paths.
|
|
--
|
|
local wdpaths = CountArray.new()
|
|
|
|
-----
|
|
-- The same vice versa, all watch descriptors by its
|
|
-- absolute path.
|
|
--
|
|
local pathwds = {}
|
|
|
|
-----
|
|
-- A list indexed by sync's containing the root path this
|
|
-- sync is interested in.
|
|
--
|
|
local syncRoots = {}
|
|
|
|
-----
|
|
-- Stops watching a directory
|
|
--
|
|
-- @param path absolute path to unwatch
|
|
-- @param core if false not actually send the unwatch to the kernel
|
|
-- (used in moves which reuse the watch)
|
|
--
|
|
local function removeWatch(path, core)
|
|
local wd = pathwds[path]
|
|
if not wd then return end
|
|
if core then lsyncd.inotify.rmwatch(wd) end
|
|
wdpaths[wd] = nil
|
|
pathwds[path] = nil
|
|
end
|
|
|
|
-----
|
|
-- Adds watches for a directory (optionally) including all subdirectories.
|
|
--
|
|
-- @param path absolute path of directory to observe
|
|
-- @param recurse true if recursing into subdirs
|
|
--
|
|
local function addWatch(path)
|
|
log('Function','Inotify.addWatch(',path,')')
|
|
|
|
if not Syncs.concerns(path) then
|
|
log('Inotify', 'not concerning "',path,'"')
|
|
return
|
|
end
|
|
|
|
-- registers the watch
|
|
local inotifyMode = (settings and settings.inotifyMode) or '';
|
|
local wd = lsyncd.inotify.addwatch(path, inotifyMode);
|
|
if wd < 0 then
|
|
log('Inotify','Unable to add watch "',path,'"')
|
|
return
|
|
end
|
|
|
|
do
|
|
-- If this watch descriptor is registered already
|
|
-- the kernel reuses it since old dir is gone.
|
|
local op = wdpaths[wd]
|
|
if op and op ~= path then
|
|
pathwds[op] = nil
|
|
end
|
|
end
|
|
pathwds[path] = wd
|
|
wdpaths[wd] = path
|
|
|
|
-- registers and adds watches for all subdirectories
|
|
local entries = lsyncd.readdir(path)
|
|
if not entries then return end
|
|
for dirname, isdir in pairs(entries) do
|
|
if isdir then addWatch(path .. dirname .. '/') end
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Adds a Sync to receive events.
|
|
--
|
|
-- sync: Object to receive events
|
|
-- rootdir: root dir to watch
|
|
--
|
|
local function addSync(sync, rootdir)
|
|
if syncRoots[sync] then error('duplicate sync in Inotify.addSync()') end
|
|
syncRoots[sync] = rootdir
|
|
addWatch(rootdir)
|
|
end
|
|
|
|
-----
|
|
-- Called when an event has occured.
|
|
--
|
|
-- etype: 'Attrib', 'Modify', 'Create', 'Delete', 'Move'
|
|
-- wd: watch descriptor, matches lsyncd.inotifyadd()
|
|
-- isdir: true if filename is a directory
|
|
-- time: time of event
|
|
-- filename: string filename without path
|
|
-- wd2: watch descriptor for target if it's a Move
|
|
-- filename2: string filename without path of Move target
|
|
--
|
|
local function event(etype, wd, isdir, time, filename, wd2, filename2)
|
|
if isdir then
|
|
filename = filename..'/'
|
|
if filename2 then filename2 = filename2..'/' end
|
|
end
|
|
|
|
if filename2 then
|
|
log('Inotify','got event ',etype,' ',filename,'(',wd,') to ',filename2,'(',wd2,')')
|
|
else
|
|
log('Inotify','got event ',etype,' ',filename,'(',wd,')')
|
|
end
|
|
|
|
-- looks up the watch descriptor id
|
|
local path = wdpaths[wd]
|
|
if path then path = path..filename end
|
|
|
|
local path2 = wd2 and wdpaths[wd2]
|
|
if path2 and filename2 then path2 = path2..filename2 end
|
|
|
|
if not path and path2 and etype == 'Move' then
|
|
log('Inotify', 'Move from deleted directory ',path2,' becomes Create.')
|
|
path = path2
|
|
path2 = nil
|
|
etype = 'Create'
|
|
end
|
|
|
|
if not path then
|
|
-- this is normal in case of deleted subdirs
|
|
log('Inotify', 'event belongs to unknown watch descriptor.')
|
|
return
|
|
end
|
|
|
|
for sync, root in pairs(syncRoots) do repeat
|
|
local relative = splitPath(path, root)
|
|
local relative2 = nil
|
|
if path2 then
|
|
relative2 = splitPath(path2, root)
|
|
end
|
|
if not relative and not relative2 then
|
|
-- sync is not interested in this dir
|
|
break -- continue
|
|
end
|
|
|
|
-- makes a copy of etype to possibly change it
|
|
local etyped = etype
|
|
if etyped == 'Move' then
|
|
if not relative2 then
|
|
log('Normal', 'Transformed Move to Delete for ', sync.config.name)
|
|
etyped = 'Delete'
|
|
elseif not relative then
|
|
relative = relative2
|
|
relative2 = nil
|
|
log('Normal', 'Transformed Move to Create for ', sync.config.name)
|
|
etyped = 'Create'
|
|
end
|
|
end
|
|
|
|
if isdir then
|
|
if etyped == 'Create' then
|
|
addWatch(path)
|
|
elseif etyped == 'Delete' then
|
|
removeWatch(path, true)
|
|
elseif etyped == 'Move' then
|
|
removeWatch(path, false)
|
|
addWatch(path2)
|
|
end
|
|
end
|
|
|
|
sync:delay(etyped, time, relative, relative2)
|
|
until true end
|
|
end
|
|
|
|
-----
|
|
-- Writes a status report about inotifies to a filedescriptor
|
|
--
|
|
local function statusReport(f)
|
|
f:write('Inotify watching ',wdpaths:size(),' directories\n')
|
|
for wd, path in wdpaths:walk() do
|
|
f:write(' ',wd,': ',path,'\n')
|
|
end
|
|
end
|
|
|
|
-- public interface
|
|
return {
|
|
addSync = addSync,
|
|
event = event,
|
|
statusReport = statusReport,
|
|
}
|
|
end)()
|
|
|
|
----
|
|
-- Interface to OSX /dev/fsevents, watches the whole filesystems
|
|
--
|
|
-- All fsevents specific implementation should be enclosed here.
|
|
--
|
|
local Fsevents = (function()
|
|
|
|
-----
|
|
-- A list indexed by sync's containing the root path this
|
|
-- sync is interested in.
|
|
--
|
|
local syncRoots = {}
|
|
|
|
-----
|
|
-- adds a Sync to receive events
|
|
--
|
|
-- @param sync Object to receive events
|
|
-- @param dir dir to watch
|
|
--
|
|
local function addSync(sync, dir)
|
|
if syncRoots[sync] then error('duplicate sync in Fanotify.addSync()') end
|
|
syncRoots[sync] = dir
|
|
end
|
|
|
|
-----
|
|
-- Called when any event has occured.
|
|
--
|
|
-- etype: 'Attrib', 'Modify', 'Create', 'Delete', 'Move')
|
|
-- isdir: true if filename is a directory
|
|
-- time: time of event
|
|
-- path: path of file
|
|
-- path2: path of target in case of 'Move'
|
|
--
|
|
local function event(etype, isdir, time, path, path2)
|
|
if isdir then
|
|
path = path..'/'
|
|
if path2 then path2 = path2..'/' end
|
|
end
|
|
|
|
log('Fsevents',etype,',',isdir,',',time,',',path,',',path2)
|
|
|
|
for _, sync in Syncs.iwalk() do repeat
|
|
local root = sync.source
|
|
if not path:starts(root) then
|
|
if not path2 or not path2:starts(root) then
|
|
break -- continue
|
|
end
|
|
end
|
|
local relative = splitPath(path, root)
|
|
local relative2
|
|
if path2 then
|
|
relative2 = splitPath(path2, root)
|
|
end
|
|
|
|
-- possibly change etype for this iteration only
|
|
local etyped = etype
|
|
if etyped == 'Move' then
|
|
if not relative2 then
|
|
log('Normal', 'Transformed Move to Delete for ', sync.config.name)
|
|
etyped = 'Delete'
|
|
elseif not relative then
|
|
relative = relative2
|
|
relative2 = nil
|
|
log('Normal', 'Transformed Move to Create for ', sync.config.name)
|
|
etyped = 'Create'
|
|
end
|
|
end
|
|
sync:delay(etyped, time, relative, relative2)
|
|
until true end
|
|
end
|
|
|
|
-----
|
|
-- Writes a status report about inotifies to a filedescriptor
|
|
--
|
|
local function statusReport(f)
|
|
-- TODO
|
|
end
|
|
|
|
-- public interface
|
|
return {
|
|
addSync = addSync,
|
|
event = event,
|
|
statusReport = statusReport
|
|
}
|
|
end)()
|
|
|
|
-----
|
|
-- Holds information about the event monitor capabilities
|
|
-- of the core.
|
|
--
|
|
Monitors = (function()
|
|
|
|
-----
|
|
-- The cores monitor list
|
|
--
|
|
local list = {}
|
|
|
|
-----
|
|
-- The default event monitor.
|
|
--
|
|
local function default()
|
|
return list[1]
|
|
end
|
|
|
|
-----
|
|
-- initializes with info received from core
|
|
--
|
|
local function initialize(clist)
|
|
for k, v in ipairs(clist) do
|
|
list[k] = v
|
|
end
|
|
end
|
|
|
|
-- public interface
|
|
return { default = default,
|
|
list = list,
|
|
initialize = initialize
|
|
}
|
|
end)()
|
|
|
|
------
|
|
-- Writes functions for the user for layer 3 configuration.
|
|
--
|
|
local functionWriter = (function()
|
|
|
|
-----
|
|
-- all variables for layer 3
|
|
transVars = {
|
|
{ '%^pathname', 'event.pathname', 1 },
|
|
{ '%^pathdir', 'event.pathdir', 1 },
|
|
{ '%^path', 'event.path', 1 },
|
|
{ '%^sourcePathname', 'event.sourcePathname', 1 },
|
|
{ '%^sourcePathdir', 'event.sourcePathdir', 1 },
|
|
{ '%^sourcePath', 'event.sourcePath', 1 },
|
|
{ '%^source', 'event.source', 1 },
|
|
{ '%^targetPathname', 'event.targetPathname', 1 },
|
|
{ '%^targetPathdir', 'event.targetPathdir', 1 },
|
|
{ '%^targetPath', 'event.targetPath', 1 },
|
|
{ '%^target', 'event.target', 1 },
|
|
{ '%^o%.pathname', 'event.pathname', 1 },
|
|
{ '%^o%.path', 'event.path', 1 },
|
|
{ '%^o%.sourcePathname', 'event.sourcePathname', 1 },
|
|
{ '%^o%.sourcePathdir', 'event.sourcePathdir', 1 },
|
|
{ '%^o%.sourcePath', 'event.sourcePath', 1 },
|
|
{ '%^o%.targetPathname', 'event.targetPathname', 1 },
|
|
{ '%^o%.targetPathdir', 'event.targetPathdir', 1 },
|
|
{ '%^o%.targetPath', 'event.targetPath', 1 },
|
|
{ '%^d%.pathname', 'event2.pathname', 2 },
|
|
{ '%^d%.path', 'event2.path', 2 },
|
|
{ '%^d%.sourcePathname', 'event2.sourcePathname', 2 },
|
|
{ '%^d%.sourcePathdir', 'event2.sourcePathdir', 2 },
|
|
{ '%^d%.sourcePath', 'event2.sourcePath', 2 },
|
|
{ '%^d%.targetPathname', 'event2.targetPathname', 2 },
|
|
{ '%^d%.targetPathdir', 'event2.targetPathdir', 2 },
|
|
{ '%^d%.targetPath', 'event2.targetPath', 2 },
|
|
}
|
|
|
|
-----
|
|
-- Splits a user string into its arguments
|
|
--
|
|
-- @param a string where parameters are seperated by spaces.
|
|
--
|
|
-- @return a table of arguments
|
|
--
|
|
local function splitStr(str)
|
|
local args = {}
|
|
while str ~= '' do
|
|
-- break where argument stops
|
|
local bp = #str
|
|
-- in a quote
|
|
local inQuote = false
|
|
-- tests characters to be space and not within quotes
|
|
for i=1,#str do
|
|
local c = string.sub(str, i, i)
|
|
if c == '"' then
|
|
inQuote = not inQuote
|
|
elseif c == ' ' and not inQuote then
|
|
bp = i - 1
|
|
break
|
|
end
|
|
end
|
|
local arg = string.sub(str, 1, bp)
|
|
arg = string.gsub(arg, '"', '\\"')
|
|
table.insert(args, arg)
|
|
str = string.sub(str, bp + 1, -1)
|
|
str = string.match(str, '^%s*(.-)%s*$')
|
|
end
|
|
return args
|
|
end
|
|
|
|
-----
|
|
-- Translates a call to a binary to a lua function.
|
|
--
|
|
-- TODO this has a little too much coding blocks.
|
|
--
|
|
local function translateBinary(str)
|
|
-- splits the string
|
|
local args = splitStr(str)
|
|
|
|
-- true if there is a second event
|
|
local haveEvent2 = false
|
|
|
|
for ia, iv in ipairs(args) do
|
|
-- a list of arguments this arg is being split into
|
|
local a = {{true, iv}}
|
|
-- goes through all translates
|
|
for _, v in ipairs(transVars) do
|
|
local ai = 1
|
|
while ai <= #a do
|
|
if a[ai][1] then
|
|
local pre, post =
|
|
string.match(a[ai][2], '(.*)"..v[1].."(.*)')
|
|
if pre then
|
|
if v[3] > 1 then
|
|
haveEvent2 = true
|
|
end
|
|
if pre ~= '' then
|
|
table.insert(a, ai, {true, pre})
|
|
ai = ai + 1
|
|
end
|
|
a[ai] = {false, v[2]}
|
|
if post ~= '' then table.insert(a, ai + 1, {true, post}) end
|
|
end
|
|
end
|
|
ai = ai + 1
|
|
end
|
|
end
|
|
|
|
-- concats the argument pieces into a string.
|
|
local as = ''
|
|
local first = true
|
|
for _, v in ipairs(a) do
|
|
if not first then
|
|
as = as..' .. '
|
|
end
|
|
if v[1] then
|
|
as = as..'"'..v[2]..'"'
|
|
else
|
|
as = as..v[2]
|
|
end
|
|
first = false
|
|
end
|
|
args[ia] = as
|
|
end
|
|
|
|
local ft
|
|
if not haveEvent2 then
|
|
ft = 'function(event)\n'
|
|
else
|
|
ft = 'function(event, event2)\n'
|
|
end
|
|
ft = ft..
|
|
" log('Normal', 'Event ', event.etype, \n"..
|
|
" ' spawns action \"".. str.."\"')\n"..
|
|
" spawn(event"
|
|
for _, v in ipairs(args) do
|
|
ft = ft..',\n '..v
|
|
end
|
|
ft = ft..')\nend'
|
|
return ft
|
|
end
|
|
|
|
-----
|
|
-- Translates a call using a shell to a lua function
|
|
--
|
|
local function translateShell(str)
|
|
local argn = 1
|
|
local args = {}
|
|
local cmd = str
|
|
local lc = str
|
|
-- true if there is a second event
|
|
local haveEvent2 = false
|
|
|
|
for _, v in ipairs(transVars) do
|
|
local occur = false
|
|
cmd = string.gsub(cmd, v[1],
|
|
function()
|
|
occur = true
|
|
return '"$'..argn..'"'
|
|
end)
|
|
lc = string.gsub(lc, v[1], ']]..'..v[2]..'..[[')
|
|
if occur then
|
|
argn = argn + 1
|
|
table.insert(args, v[2])
|
|
if v[3] > 1 then
|
|
haveEvent2 = true
|
|
end
|
|
end
|
|
end
|
|
local ft
|
|
if not haveEvent2 then
|
|
ft = 'function(event)\n'
|
|
else
|
|
ft = 'function(event, event2)\n'
|
|
end
|
|
-- TODO do array joining instead
|
|
ft = ft..
|
|
" log('Normal', 'Event ',event.etype,\n"..
|
|
" [[ spawns shell \""..lc.."\"]])\n"..
|
|
" spawnShell(event, [["..cmd.."]]"
|
|
for _, v in ipairs(args) do
|
|
ft = ft..',\n '..v
|
|
end
|
|
ft = ft..')\nend'
|
|
return ft
|
|
end
|
|
|
|
-----
|
|
-- writes a lua function for a layer 3 user script.
|
|
local function translate(str)
|
|
-- trim spaces
|
|
str = string.match(str, '^%s*(.-)%s*$')
|
|
|
|
local ft
|
|
if string.byte(str, 1, 1) == 47 then
|
|
-- starts with /
|
|
ft = translateBinary(str)
|
|
elseif string.byte(str, 1, 1) == 94 then
|
|
-- starts with ^
|
|
ft = translateShell(str:sub(2, -1))
|
|
else
|
|
ft = translateShell(str)
|
|
end
|
|
log('FWrite','translated "',str,'" to \n',ft)
|
|
return ft
|
|
end
|
|
|
|
-----
|
|
-- public interface
|
|
--
|
|
return {translate = translate}
|
|
end)()
|
|
|
|
|
|
----
|
|
-- Writes a status report file at most every [statusintervall] seconds.
|
|
--
|
|
--
|
|
local StatusFile = (function()
|
|
|
|
-----
|
|
-- Timestamp when the status file has been written.
|
|
local lastWritten = false
|
|
|
|
-----
|
|
-- Timestamp when a status file should be written
|
|
local alarm = false
|
|
|
|
-----
|
|
-- Returns when the status file should be written
|
|
--
|
|
local function getAlarm()
|
|
return alarm
|
|
end
|
|
|
|
-----
|
|
-- Called to check if to write a status file.
|
|
--
|
|
local function write(timestamp)
|
|
log('Function', 'write(', timestamp, ')')
|
|
|
|
-- some logic to not write too often
|
|
if settings.statusInterval > 0 then
|
|
-- already waiting
|
|
if alarm and timestamp < alarm then
|
|
log('Statusfile', 'waiting(',timestamp,' < ',alarm,')')
|
|
return
|
|
end
|
|
-- determines when a next write will be possible
|
|
if not alarm then
|
|
local nextWrite =
|
|
lastWritten and timestamp + settings.statusInterval
|
|
if nextWrite and timestamp < nextWrite then
|
|
log('Statusfile', 'setting alarm: ', nextWrite)
|
|
alarm = nextWrite
|
|
return
|
|
end
|
|
end
|
|
lastWritten = timestamp
|
|
alarm = false
|
|
end
|
|
|
|
log('Statusfile', 'writing now')
|
|
local f, err = io.open(settings.statusFile, 'w')
|
|
if not f then
|
|
log('Error', 'Cannot open status file "'..settings.statusFile.. '" :'..err)
|
|
return
|
|
end
|
|
f:write('Lsyncd status report at ',os.date(),'\n\n')
|
|
for i, s in Syncs.iwalk() do
|
|
s:statusReport(f)
|
|
f:write('\n')
|
|
end
|
|
|
|
Inotify.statusReport(f)
|
|
f:close()
|
|
end
|
|
|
|
-- public interface
|
|
return {write = write, getAlarm = getAlarm}
|
|
end)()
|
|
|
|
------
|
|
-- Lets the userscript make its own alarms.
|
|
--
|
|
local UserAlarms = (function()
|
|
local alarms = {}
|
|
|
|
-----
|
|
-- Calls the user function at timestamp.
|
|
--
|
|
local function alarm(timestamp, func, extra)
|
|
local idx
|
|
for k, v in ipairs(alarms) do
|
|
if timestamp < v.timestamp then
|
|
idx = k
|
|
break
|
|
end
|
|
end
|
|
local a = {timestamp = timestamp,
|
|
func = func,
|
|
extra = extra}
|
|
if idx then
|
|
table.insert(alarms, idx, a)
|
|
else
|
|
table.insert(alarms, a)
|
|
end
|
|
end
|
|
|
|
----
|
|
-- Retrieves the nearest alarm.
|
|
--
|
|
local function getAlarm()
|
|
if #alarms == 0 then
|
|
return false
|
|
else
|
|
return alarms[1].timestamp
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Calls user alarms.
|
|
--
|
|
local function invoke(timestamp)
|
|
while #alarms > 0 and alarms[1].timestamp <= timestamp do
|
|
alarms[1].func(alarms[1].timestamp, alarms[1].extra)
|
|
table.remove(alarms, 1)
|
|
end
|
|
end
|
|
|
|
-- public interface
|
|
return { alarm = alarm,
|
|
getAlarm = getAlarm,
|
|
invoke = invoke }
|
|
end)()
|
|
|
|
--============================================================================
|
|
-- lsyncd runner plugs. These functions will be called from core.
|
|
--============================================================================
|
|
|
|
-----
|
|
-- Current status of lsyncd.
|
|
--
|
|
-- 'init' ... on (re)init
|
|
-- 'run' ... normal operation
|
|
-- 'fade' ... waits for remaining processes
|
|
--
|
|
local lsyncdStatus = 'init'
|
|
|
|
----
|
|
-- the cores interface to the runner
|
|
--
|
|
local runner = {}
|
|
|
|
-----
|
|
-- Called from core whenever lua code failed.
|
|
-- Logs a backtrace
|
|
--
|
|
function runner.callError(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
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Called from code whenever a child process finished and
|
|
-- zombie process was collected by core.
|
|
--
|
|
function runner.collectProcess(pid, exitcode)
|
|
processCount = processCount - 1
|
|
if processCount < 0 then error('negative number of processes!') end
|
|
|
|
for _, s in Syncs.iwalk() do
|
|
if s:collect(pid, exitcode) then return end
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Called from core everytime a masterloop cycle runs through.
|
|
-- This happens in case of
|
|
-- * an expired alarm.
|
|
-- * a returned child process.
|
|
-- * received filesystem events.
|
|
-- * received a HUP or TERM signal.
|
|
--
|
|
-- @param timestamp the current kernel time (in jiffies)
|
|
--
|
|
function runner.cycle(timestamp)
|
|
-- goes through all syncs and spawns more actions
|
|
-- if possible
|
|
if lsyncdStatus == 'fade' then
|
|
if processCount > 0 then
|
|
log('Normal', 'waiting for ',processCount,' more child processes.')
|
|
return true
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
if lsyncdStatus ~= 'run' then
|
|
error('runner.cycle() called while not running!')
|
|
end
|
|
|
|
--- only let Syncs invoke actions if not on global limit
|
|
if not settings.maxProcesses or processCount < settings.maxProcesses then
|
|
local start = Syncs.getRound()
|
|
local ir = start
|
|
repeat
|
|
local s = Syncs.get(ir)
|
|
s:invokeActions(timestamp)
|
|
ir = ir + 1
|
|
if ir > Syncs.size() then
|
|
ir = 1
|
|
end
|
|
until ir == start
|
|
Syncs.nextRound()
|
|
end
|
|
|
|
UserAlarms.invoke(timestamp)
|
|
|
|
if settings.statusFile then
|
|
StatusFile.write(timestamp)
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
-----
|
|
-- Called by core before anything is '-help' or '--help' is in
|
|
-- the arguments.
|
|
--
|
|
function runner.help()
|
|
io.stdout:write(
|
|
[[
|
|
|
|
USAGE:
|
|
runs a config file:
|
|
lsyncd [OPTIONS] [CONFIG-FILE]
|
|
|
|
default rsync behaviour:
|
|
lsyncd [OPTIONS] -rsync [SOURCE] [TARGET]
|
|
|
|
default rsync with mv's through ssh:
|
|
lsyncd [OPTIONS] -rsyncssh [SOURCE] [HOST] [TARGETDIR]
|
|
|
|
default local copying mechanisms (cp|mv|rm):
|
|
lsyncd [OPTIONS] -direct [SOURCE] [TARGETDIR]
|
|
|
|
OPTIONS:
|
|
-delay SECS Overrides default delay times
|
|
-help Shows this
|
|
-insist Continues startup even if it cannot connect
|
|
-log all Logs everything (debug)
|
|
-log scarce Logs errors only
|
|
-log [Category] Turns on logging for a debug category
|
|
-logfile FILE Writes log to FILE (DEFAULT: uses syslog)
|
|
-nodaemon Does not detach and logs to stdout/stderr
|
|
-pidfile FILE Writes Lsyncds PID into FILE
|
|
-runner FILE Loads Lsyncds lua part from FILE
|
|
-version Prints versions and exits
|
|
|
|
LICENSE:
|
|
GPLv2 or any later version.
|
|
|
|
SEE:
|
|
`man lsyncd` for further information.
|
|
|
|
]])
|
|
|
|
--
|
|
-- -monitor NAME Uses operating systems event montior NAME
|
|
-- (inotify/fanotify/fsevents)
|
|
|
|
os.exit(-1) -- ERRNO
|
|
end
|
|
|
|
|
|
-----
|
|
-- settings specified by command line.
|
|
--
|
|
local clSettings = {}
|
|
|
|
-----
|
|
-- 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 runner.configure(args, monitors)
|
|
Monitors.initialize(monitors)
|
|
|
|
-- a list of all valid --options
|
|
-- first paramter is number of options
|
|
-- if < 0 the function checks existance
|
|
-- second paramter is function to call when in args
|
|
--
|
|
local options = {
|
|
-- log is handled by core already.
|
|
delay =
|
|
{1, function(secs)
|
|
clSettings.delay = secs
|
|
end},
|
|
insist =
|
|
{0, function()
|
|
clSettings.insist = true
|
|
end},
|
|
log =
|
|
{1, nil},
|
|
logfile =
|
|
{1, function(file)
|
|
clSettings.logfile = file
|
|
end},
|
|
monitor =
|
|
{-1, function(monitor)
|
|
if not monitor then
|
|
io.stdout:write('This Lsyncd supports these monitors:\n')
|
|
for _, v in ipairs(Monitors.list) do
|
|
io.stdout:write(' ',v,'\n')
|
|
end
|
|
io.stdout:write('\n');
|
|
lsyncd.terminate(-1); -- ERRNO
|
|
else
|
|
clSettings.monitor=monitor
|
|
end
|
|
end},
|
|
nodaemon =
|
|
{0, function()
|
|
clSettings.nodaemon = true
|
|
end},
|
|
pidfile =
|
|
{1, function(file)
|
|
clSettings.pidfile=file
|
|
end},
|
|
rsync =
|
|
{2, function(src, trg)
|
|
clSettings.syncs = clSettings.syncs or {}
|
|
table.insert(clSettings.syncs, {'rsync', src, trg})
|
|
end},
|
|
rsyncssh =
|
|
{3, function(src, host, tdir)
|
|
clSettings.syncs = clSettings.syncs or {}
|
|
table.insert(clSettings.syncs, {'rsyncssh', src, host, tdir})
|
|
end},
|
|
direct =
|
|
{2, function(src, trg)
|
|
clSettings.syncs = clSettings.syncs or {}
|
|
table.insert(clSettings.syncs, {'direct', src, trg})
|
|
end},
|
|
version =
|
|
{0, function()
|
|
io.stdout:write('Version: ',lsyncd_version,'\n')
|
|
os.exit(0)
|
|
end}
|
|
}
|
|
-- nonopts is filled with all args that were no part dash 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]
|
|
if not o then
|
|
log('Error','unknown option command line option ', args[i])
|
|
os.exit(-1) -- ERRNO
|
|
end
|
|
if o[1] >= 0 and i + o[1] > #args then
|
|
log('Error',a,' needs ',o[1],' arguments')
|
|
os.exit(-1) -- ERRNO
|
|
elseif o[1] < 0 then
|
|
o[1] = -o[1]
|
|
end
|
|
if o[2] then
|
|
if o[1] == 0 then
|
|
o[2]()
|
|
elseif o[1] == 1 then
|
|
o[2](args[i + 1])
|
|
elseif o[1] == 2 then
|
|
o[2](args[i + 1], args[i + 2])
|
|
elseif o[1] == 3 then
|
|
o[2](args[i + 1], args[i + 2], args[i + 3])
|
|
end
|
|
end
|
|
i = i + o[1]
|
|
end
|
|
i = i + 1
|
|
end
|
|
|
|
if clSettings.syncs then
|
|
if #nonopts ~= 0 then
|
|
log('Error', 'There cannot be command line default syncs with a config file.')
|
|
os.exit(-1) -- ERRNO
|
|
end
|
|
else
|
|
if #nonopts == 0 then
|
|
runner.help(args[0])
|
|
elseif #nonopts == 1 then
|
|
return nonopts[1]
|
|
else
|
|
log('Error', 'There can only be one config file in command line.')
|
|
os.exit(-1) -- ERRNO
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
----
|
|
-- Called from core on init or restart after user configuration.
|
|
--
|
|
-- @firstTime true the first time Lsyncd startup, false on resets
|
|
-- due to HUP signal or monitor queue OVERFLOW.
|
|
--
|
|
function runner.initialize(firstTime)
|
|
-- creates settings if user didnt
|
|
settings = settings or {}
|
|
|
|
-- From this point on, no globals may be created anymore
|
|
lockGlobals()
|
|
|
|
-- copies simple settings with numeric keys to 'key=true' settings.
|
|
for k, v in ipairs(settings) do
|
|
if settings[v] then
|
|
log('Error', 'Double setting "'..v..'"')
|
|
os.exit(-1) -- ERRNO
|
|
end
|
|
settings[v]=true
|
|
end
|
|
|
|
-- all command line settings overwrite config file settings
|
|
for k, v in pairs(clSettings) do
|
|
if k ~= 'syncs' then
|
|
settings[k]=v
|
|
end
|
|
end
|
|
|
|
-- implicitly force insist to be true on Lsyncd resets.
|
|
if not firstTime then
|
|
settings.insist = true
|
|
end
|
|
|
|
-- adds syncs specified by command line.
|
|
if clSettings.syncs then
|
|
for _, s in ipairs(clSettings.syncs) do
|
|
if s[1] == 'rsync' then
|
|
sync{default.rsync, source=s[2], target=s[3]}
|
|
elseif s[1] == 'rsyncssh' then
|
|
sync{default.rsyncssh, source=s[2], host=s[3], targetdir=s[4]}
|
|
elseif s[1] == 'direct' then
|
|
sync{default.direct, source=s[2], target=s[3]}
|
|
end
|
|
end
|
|
end
|
|
|
|
if settings.nodaemon then
|
|
lsyncd.configure('nodaemon')
|
|
end
|
|
if settings.logfile then
|
|
lsyncd.configure('logfile', settings.logfile)
|
|
end
|
|
if settings.logident then
|
|
lsyncd.configure('logident', settings.logident)
|
|
end
|
|
if settings.logfacility then
|
|
lsyncd.configure('logfacility', settings.logfacility)
|
|
end
|
|
if settings.pidfile then
|
|
lsyncd.configure('pidfile', settings.pidfile)
|
|
end
|
|
|
|
-----
|
|
-- transfers some defaults to settings
|
|
if settings.statusInterval == nil then
|
|
settings.statusInterval = default.statusInterval
|
|
end
|
|
|
|
-- makes sure the user gave Lsyncd anything to do
|
|
if Syncs.size() == 0 then
|
|
log('Error', 'Nothing to watch!')
|
|
os.exit(-1) -- ERRNO
|
|
end
|
|
|
|
-- from now on use logging as configured instead of stdout/err.
|
|
lsyncdStatus = 'run';
|
|
lsyncd.configure('running');
|
|
|
|
local ufuncs = {
|
|
'onAttrib', 'onCreate', 'onDelete',
|
|
'onModify', 'onMove', 'onStartup',
|
|
}
|
|
|
|
-- translates layer 3 scripts
|
|
for _, s in Syncs.iwalk() do
|
|
-- checks if any user functions is a layer 3 string.
|
|
local config = s.config
|
|
for _, fn in ipairs(ufuncs) do
|
|
if type(config[fn]) == 'string' then
|
|
local ft = functionWriter.translate(config[fn])
|
|
config[fn] = assert(loadstring('return '..ft))()
|
|
end
|
|
end
|
|
end
|
|
|
|
-- runs through the Syncs created by users
|
|
for _, s in Syncs.iwalk() do
|
|
if s.config.monitor == 'inotify' then
|
|
Inotify.addSync(s, s.source)
|
|
elseif s.config.monitor == 'fsevents' then
|
|
Fsevents.addSync(s, s.source)
|
|
else
|
|
error('sync '..s.config.name..' has no known event monitor interface.')
|
|
end
|
|
-- if the sync has an init function, stacks an init delay
|
|
-- that will cause the init function to be called.
|
|
if s.config.init then
|
|
s:addInitDelay()
|
|
end
|
|
end
|
|
end
|
|
|
|
----
|
|
-- Called by core to query soonest alarm.
|
|
--
|
|
-- @return false ... no alarm, core can in untimed sleep, or
|
|
-- true ... immediate action
|
|
-- times ... the alarm time (only read if number is 1)
|
|
--
|
|
function runner.getAlarm()
|
|
if lsyncdStatus ~= 'run' then
|
|
return false
|
|
end
|
|
local alarm = false
|
|
----
|
|
-- checks if current nearest alarm or a is earlier
|
|
--
|
|
local function checkAlarm(a)
|
|
if a == nil then
|
|
error('got nil alarm')
|
|
end
|
|
if alarm == true or not a then
|
|
-- already immediate or no new alarm
|
|
return
|
|
end
|
|
-- returns the ealier time
|
|
if not alarm or a < alarm then
|
|
alarm = a
|
|
end
|
|
end
|
|
|
|
-- checks all syncs for their earliest alarm
|
|
-- but only if the global process limit is not yet reached.
|
|
if not settings.maxProcesses or processCount < settings.maxProcesses then
|
|
for _, s in Syncs.iwalk() do
|
|
checkAlarm(s:getAlarm())
|
|
end
|
|
else
|
|
log('Alarm', 'at global process limit.')
|
|
end
|
|
|
|
-- checks if a statusfile write has been delayed
|
|
checkAlarm(StatusFile.getAlarm())
|
|
-- checks for an userAlarm
|
|
checkAlarm(UserAlarms.getAlarm())
|
|
|
|
log('Alarm', 'runner.getAlarm returns: ',alarm)
|
|
return alarm
|
|
end
|
|
|
|
|
|
-----
|
|
-- Called when an inotify event arrived.
|
|
-- Simply forwards it directly to the object.
|
|
--
|
|
runner.inotifyEvent = Inotify.event
|
|
runner.fsEventsEvent = Fsevents.event
|
|
|
|
-----
|
|
-- Collector 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.
|
|
--
|
|
function runner.collector(pid, exitcode)
|
|
if exitcode ~= 0 then
|
|
log('Error', 'Startup process',pid,' failed')
|
|
terminate(-1) -- ERRNO
|
|
end
|
|
return 0
|
|
end
|
|
|
|
-----
|
|
-- Called by core when an overflow happened.
|
|
--
|
|
function runner.overflow()
|
|
log('Normal', '--- OVERFLOW in event queue ---')
|
|
lsyncdStatus = 'fade'
|
|
end
|
|
|
|
-----
|
|
-- Called by core on a hup signal.
|
|
--
|
|
function runner.hup()
|
|
log('Normal', '--- HUP signal, resetting ---')
|
|
lsyncdStatus = 'fade'
|
|
end
|
|
|
|
-----
|
|
-- Called by core on a term signal.
|
|
--
|
|
function runner.term()
|
|
log('Normal', '--- TERM signal, fading ---')
|
|
lsyncdStatus = 'fade'
|
|
end
|
|
|
|
--============================================================================
|
|
-- Lsyncd user interface
|
|
--============================================================================
|
|
|
|
-----
|
|
-- Main utility to create new observations.
|
|
-- @returns an Inlet to that sync.
|
|
--
|
|
function sync(opts)
|
|
if lsyncdStatus ~= 'init' then
|
|
error('Sync can only be created during initialization.', 2)
|
|
end
|
|
return Syncs.add(opts).inlet
|
|
end
|
|
|
|
|
|
-----
|
|
-- Spawns a new child process.
|
|
--
|
|
-- @param agent the reason why a process is spawned.
|
|
-- normally this is a delay/event of a sync.
|
|
-- it will mark the related files as blocked.
|
|
-- @param binary binary to call
|
|
-- @param ... arguments
|
|
--
|
|
function spawn(agent, binary, ...)
|
|
if agent == nil or type(agent) ~= 'table' then
|
|
error('spawning with an invalid agent', 2)
|
|
end
|
|
|
|
if lsyncdStatus == 'fade' then
|
|
log('Normal', 'ignored process spawning while fading')
|
|
return
|
|
end
|
|
|
|
if type(binary) ~= 'string' then
|
|
error('calling spawn(agent, binary, ...), binary is not a string', 2)
|
|
end
|
|
|
|
local dol = InletFactory.getDelayOrList(agent)
|
|
if not dol then error('spawning with an unknown agent', 2) end
|
|
|
|
-- checks if spawn is called on already active event
|
|
if dol.status then
|
|
if dol.status ~= 'wait' then
|
|
error('spawn() called on an non-waiting event', 2)
|
|
end
|
|
else -- is a list
|
|
for _, d in ipairs(dol) do
|
|
if d.status ~= 'wait' and d.status ~= 'block' then
|
|
error('spawn() called on an non-waiting event list', 2)
|
|
end
|
|
end
|
|
end
|
|
|
|
local pid = lsyncd.exec(binary, ...)
|
|
|
|
if pid and pid > 0 then
|
|
processCount = processCount + 1
|
|
if settings.maxProcesses and processCount > settings.maxProcesses then
|
|
error('Spawned too much processes!')
|
|
end
|
|
local sync = InletFactory.getSync(agent)
|
|
-- delay or list
|
|
if dol.status then
|
|
-- is a delay
|
|
dol.status = 'active'
|
|
sync.processes[pid] = dol
|
|
else
|
|
-- is a list
|
|
for _, d in ipairs(dol) do
|
|
d.status = 'active'
|
|
end
|
|
sync.processes[pid] = dol
|
|
end
|
|
end
|
|
end
|
|
|
|
-----
|
|
-- Spawns a child process using the default shell.
|
|
--
|
|
function spawnShell(agent, command, ...)
|
|
return spawn(agent, '/bin/sh', '-c', command, '/bin/sh', ...)
|
|
end
|
|
|
|
-----
|
|
-- Observes a filedescriptor
|
|
--
|
|
function observefd(fd, ready, writey)
|
|
return lsyncd.observe_fd(fd, ready, writey)
|
|
end
|
|
|
|
-----
|
|
-- Nonobserves a filedescriptor
|
|
--
|
|
function nonobservefd(fd)
|
|
return lsyncd.nonobserve_fd(fd)
|
|
end
|
|
|
|
-----
|
|
-- Calls func at timestamp.
|
|
-- Use now() to receive current timestamp
|
|
-- add seconds with '+' to it)
|
|
--
|
|
alarm = UserAlarms.alarm
|
|
|
|
-----
|
|
-- Comfort routine also for user.
|
|
-- Returns true if 'String' starts with 'Start'
|
|
--
|
|
function string.starts(String,Start)
|
|
return string.sub(String,1,#Start)==Start
|
|
end
|
|
|
|
-----
|
|
-- Comfort routine also for user.
|
|
-- Returns true if 'String' ends with 'End'
|
|
--
|
|
function string.ends(String,End)
|
|
return End=='' or string.sub(String,-#End)==End
|
|
end
|
|
|
|
-----
|
|
-- provides a default empty settings table.
|
|
--
|
|
settings = {}
|
|
|
|
-----
|
|
-- Returns the core the runners function interface.
|
|
--
|
|
return runner
|