lsyncd/lsyncd.lua

3247 lines
71 KiB
Lua
Raw Normal View History

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