lsyncd/lsyncd.lua

4355 lines
77 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
--
2012-10-03 15:37:49 +00:00
-- This code assumes your editor is at least 100 chars wide.
--
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
2012-10-03 15:37:49 +00:00
-- ensures the runner is not being loaded twice
lsyncd.log(
'Error',
'You cannot use the lsyncd runner as configuration file!'
)
lsyncd.terminate( -1 )
2010-10-19 21:56:00 +00:00
end
2012-10-03 15:37:49 +00:00
2012-11-24 13:33:07 +00:00
lsyncd_version = '2.1.4'
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
--
-- Settings specified by command line.
--
local clSettings = { }
2012-10-08 07:10:03 +00:00
--
-- Settings specified by config scripts.
--
local uSettings = { }
--
-- A copy of the settings function to see if the
-- user script replaced the settings() by a table
-- ( pre Lsyncd 2.1 style )
--
local settingsSafe
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
2012-10-03 07:23:18 +00:00
--
-- 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
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +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',
2012-10-02 20:02:09 +00:00
d2.etype, ':', d2.path,
' replaces ',
2012-10-02 20:02:09 +00:00
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',
2012-10-02 20:02:09 +00:00
d2.etype, ':', d2.path,
' replaces ',
2012-10-02 20:02:09 +00:00
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
2012-10-02 20:02:09 +00:00
-- 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
2012-10-02 20:02:09 +00:00
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
2012-10-02 20:02:09 +00:00
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
2012-10-02 20:02:09 +00:00
-- on 'Attrib' or 'Modify' simply stack on moves
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 20:02:09 +00:00
--
2012-10-02 06:35:31 +00:00
-- a move event upon a move event
2012-10-02 20:02:09 +00:00
--
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 20:02:09 +00:00
log(
'Delay',
2012-10-02 06:35:31 +00:00
'Move:', d2.path, '->', d1.path2,
2012-10-02 20:02:09 +00:00
' splits on Move:',
d1.path, '->', d1.path2
)
2012-01-27 14:19:17 +00:00
return 'split'
end
2012-10-02 20:02:09 +00:00
return nil
end
2012-10-02 06:35:31 +00:00
error( 'reached impossible state' )
end
2012-10-03 07:23:18 +00:00
--
-- Public interface
--
2012-10-02 06:35:31 +00:00
return { combine = combine }
2012-10-02 20:02:09 +00:00
2012-10-02 06:35:31 +00:00
end )( )
2012-10-02 20:02:09 +00:00
--
-- Creates inlets for syncs: the user interface for events.
2010-11-08 12:14:10 +00:00
--
2012-10-02 20:02:09 +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.
2012-10-02 20:02:09 +00:00
--
local e2d = { }
2012-10-02 20:02:09 +00:00
--
-- Table to ensure the uniqueness of every event
-- related to a delay.
--
-- Keys are delay and values are events.
2012-10-02 20:02:09 +00:00
--
local e2d2 = { }
2012-10-02 20:02:09 +00:00
--
-- Allows the garbage collector to remove not refrenced
-- events.
2012-10-02 20:02:09 +00:00
--
setmetatable( e2d, { __mode = 'k' } )
setmetatable( e2d2, { __mode = 'v' } )
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
--
-- Removes the trailing slash from a path.
--
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
2012-10-02 20:02:09 +00:00
--
-- Gets the path of an event.
--
local function getPath( event )
2012-01-27 13:01:00 +00:00
if event.move ~= 'To' then
2012-10-02 20:02:09 +00:00
return e2d[ event ].path
2010-11-10 11:23:26 +00:00
else
2012-10-02 20:02:09 +00:00
return e2d[ event ].path2
2010-11-10 11:23:26 +00:00
end
end
2012-10-02 20:02:09 +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 = {
2012-10-02 20:02:09 +00:00
--
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.
--
2012-10-02 20:02:09 +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
--
2012-10-02 20:02:09 +00:00
inlet = function( event )
return e2d[ event ].sync.inlet
2010-11-13 19:22:05 +00:00
end,
2012-10-02 20:02:09 +00:00
--
2010-11-08 12:14:10 +00:00
-- Returns the type of the event.
2012-10-02 20:02:09 +00:00
--
2012-01-27 14:19:17 +00:00
-- Can be: 'Attrib', 'Create', 'Delete', 'Modify' or 'Move',
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
etype = function( event )
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
--
2012-10-02 20:02:09 +00:00
-- Events are not lists.
--
isList = function( )
2010-11-12 18:52:43 +00:00
return false
end,
2012-10-02 20:02:09 +00:00
--
-- Returns the status of the event.
--
-- Can be:
-- 'wait', 'active', 'block'.
2011-11-23 10:05:42 +00:00
--
2012-10-02 20:02:09 +00:00
status = function( event )
return e2d[ event ].status
2010-11-11 15:17:22 +00:00
end,
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
-- Returns true if event relates to a directory
--
isdir = function( event )
return string.byte( getPath( event ), -1 ) == 47
2010-11-08 12:14:10 +00:00
end,
2012-10-02 20:02:09 +00:00
--
2010-11-08 12:14:10 +00:00
-- Returns the name of the file/dir.
2012-10-02 20:02:09 +00:00
--
2010-11-08 12:14:10 +00:00
-- Includes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
name = function( event )
return string.match( getPath( event ), '[^/]+/?$' )
2010-11-08 12:14:10 +00:00
end,
2011-11-23 10:05:42 +00:00
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
-- Returns the name of the file/dir
-- excluding a trailing slash for dirs.
--
basename = function( event )
return string.match( getPath( event ), '([^/]+)/?$')
2010-11-08 12:14:10 +00:00
end,
2012-10-02 20:02:09 +00:00
---
2010-11-08 12:14:10 +00:00
-- Returns the file/dir relative to watch root
2012-10-02 20:02:09 +00:00
-- including a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
path = function( event )
return getPath( event )
2010-11-08 12:14:10 +00:00
end,
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +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.
--
2012-10-02 20:02:09 +00:00
pathdir = function( event )
return string.match( getPath( event ), '^(.*/)[^/]+/?' ) or ''
2010-11-17 18:52:55 +00:00
end,
2012-10-02 20:02:09 +00:00
--
2010-11-08 12:14:10 +00:00
-- Returns the file/dir relativ to watch root
2012-10-02 20:02:09 +00:00
-- excluding a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
pathname = function( event )
return cutSlash( getPath( event ) )
2010-11-08 12:14:10 +00:00
end,
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
---
2010-11-08 12:14:10 +00:00
-- Returns the absolute path of the watch root.
2012-10-02 20:02:09 +00:00
-- All symlinks are resolved.
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
source = function( event )
return e2d[ event ].sync.source
2010-11-08 12:14:10 +00:00
end,
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
-- Returns the absolute path of the file/dir
-- including a trailing slash for dirs.
--
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
--
2012-10-02 20:02:09 +00:00
-- Returns the absolute dir of the file/dir
-- including a trailing slash.
--
sourcePathdir = function( event )
return e2d[event].sync.source ..
2012-10-02 20:02:09 +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
------
2012-10-02 20:02:09 +00:00
-- Returns the absolute path of the file/dir
-- excluding a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +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
2012-01-27 11:08:10 +00:00
--
2012-10-02 20:02:09 +00:00
-- Returns the configured target
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
target = function( event )
return e2d[ event ].sync.config.target
2010-11-08 12:14:10 +00:00
end,
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
-- Returns the relative dir/file appended to the target
-- including a trailing slash for dirs.
--
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
--
2012-10-02 20:02:09 +00:00
-- Returns the dir of the dir/file appended to the target
-- including a trailing slash.
--
targetPathdir = function( event )
return e2d[ event ].sync.config.target ..
( string.match( getPath( event ), '^(.*/)[^/]+/?' ) or '' )
2010-11-29 16:37:46 +00:00
end,
2011-11-23 10:05:42 +00:00
2010-11-10 22:03:02 +00:00
--
2012-10-02 20:02:09 +00:00
-- Returns the relative dir/file appended to the target
-- excluding a trailing slash for dirs.
--
targetPathname = function( event )
return e2d[ event ].sync.config.target ..
cutSlash( getPath( event ) )
2010-11-08 12:14:10 +00:00
end,
}
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +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 = {
2012-10-02 20:02:09 +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-10-02 20:02:09 +00:00
error( 'event does not have field "'..field..'"', 2 )
2010-11-08 12:14:10 +00:00
end
2012-10-02 20:02:09 +00:00
return f( event )
2010-11-08 12:14:10 +00:00
end
2012-10-02 20:02:09 +00:00
2010-11-08 12:14:10 +00:00
}
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
--
-- Interface for user scripts to get list fields.
2010-11-12 18:52:43 +00:00
--
local eventListFuncs = {
2012-10-02 20:02:09 +00:00
--
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
--
2012-10-02 20:02:09 +00:00
getPaths = function( elist, mutator )
2010-11-30 22:56:34 +00:00
local dlist = e2d[elist]
2012-10-02 20:02:09 +00:00
2010-11-20 22:32:25 +00:00
if not dlist then
2012-10-02 20:02:09 +00:00
error( 'cannot find delay list from event list.' )
2010-11-12 18:52:43 +00:00
end
2012-10-02 20:02:09 +00:00
local result = { }
2010-12-11 23:00:33 +00:00
local resultn = 1
2012-10-02 20:02:09 +00:00
for k, d in ipairs( dlist ) do
2010-12-11 23:00:33 +00:00
local s1, s2
2012-10-02 20:02:09 +00:00
2010-12-11 23:00:33 +00:00
if mutator then
2012-10-02 20:02:09 +00:00
s1, s2 = mutator( d.etype, d.path, d.path2 )
2010-12-11 23:00:33 +00:00
else
s1, s2 = d.path, d.path2
end
2012-10-02 20:02:09 +00:00
result[ resultn ] = s1
2010-12-11 23:00:33 +00:00
resultn = resultn + 1
2012-10-02 20:02:09 +00:00
2010-12-11 23:00:33 +00:00
if s2 then
2012-10-02 20:02:09 +00:00
result[ resultn ] = s2
2010-12-11 23:00:33 +00:00
resultn = resultn + 1
2010-11-12 18:52:43 +00:00
end
end
2012-10-02 20:02:09 +00:00
2010-11-24 16:18:48 +00:00
return result
2012-10-02 20:02:09 +00:00
2010-11-30 22:56:34 +00:00
end
2010-11-12 18:52:43 +00:00
}
2012-10-02 20:02:09 +00:00
--
-- Retrievs event list fields for the user script
2010-11-12 18:52:43 +00:00
--
local eventListMeta = {
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
__index = function( elist, func )
if func == 'isList' then
return true
end
if func == 'config' then
return e2d[ elist ].sync.config
end
local f = eventListFuncs[ func ]
2010-11-12 18:52:43 +00:00
if not f then
2012-10-02 20:02:09 +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
2012-10-02 20:02:09 +00:00
return function( ... )
return f( elist, ... )
2010-11-12 18:52:43 +00:00
end
2012-10-02 20:02:09 +00:00
2010-11-12 18:52:43 +00:00
end
2012-10-02 20:02:09 +00:00
2010-11-12 18:52:43 +00:00
}
2010-11-30 22:56:34 +00:00
--
2012-10-02 20:02:09 +00:00
-- Table of all inlets with their syncs.
--
local inlets = { }
2010-11-30 22:56:34 +00:00
2012-10-02 20:02:09 +00:00
--
-- Allows the garbage collector to remove entries.
--
setmetatable( inlets, { __mode = 'v' } )
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +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
--
2012-10-02 20:02:09 +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
2012-10-02 20:02:09 +00:00
if eu then
return eu
end
local event = { }
setmetatable( event, eventMeta )
e2d[ event ] = delay
e2d2[ delay ] = event
return event
2012-10-02 20:02:09 +00:00
2010-11-10 12:59:51 +00:00
else
-- moves have 2 events - origin and destination
2012-10-02 20:02:09 +00:00
if eu then
return eu[1], eu[2]
end
local event = { move = 'Fr' }
local event2 = { move = 'To' }
2012-10-02 20:02:09 +00:00
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
2012-10-02 20:02:09 +00:00
2010-11-08 12:14:10 +00:00
end
end
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
--
2010-11-12 18:52:43 +00:00
-- Encapsulates a delay list into an event list for the user script.
--
2012-10-02 20:02:09 +00:00
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
2012-10-02 20:02:09 +00:00
2010-11-12 18:52:43 +00:00
end
2010-11-08 12:14:10 +00:00
2012-10-02 20:02:09 +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 = {
2012-10-02 20:02:09 +00:00
--
-- Adds an exclude.
2010-11-30 22:56:34 +00:00
--
2012-10-02 20:02:09 +00:00
addExclude = function( sync, pattern )
sync:addExclude( pattern )
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
--
2012-10-02 20:02:09 +00:00
-- Removes an exclude.
--
rmExclude = function( sync, pattern )
sync:rmExclude( pattern )
2010-11-30 22:56:34 +00:00
end,
2011-11-23 10:05:42 +00:00
2011-01-19 15:17:11 +00:00
--
2012-10-02 20:02:09 +00:00
-- Gets the list of excludes in their original rsynlike patterns form.
--
getExcludes = function( sync )
2011-01-19 15:17:11 +00:00
-- creates a copy
2012-10-02 20:02:09 +00:00
local e = { }
2011-01-19 15:17:11 +00:00
local en = 1;
2012-10-02 20:02:09 +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
2012-10-02 20:02:09 +00:00
2011-01-19 15:17:11 +00:00
return e;
end,
2012-10-02 20:02:09 +00:00
--
2010-11-30 22:56:34 +00:00
-- Creates a blanketEvent that blocks everything
-- and is blocked by everything.
--
2012-10-02 20:02:09 +00:00
createBlanketEvent = function( sync )
return d2e( sync:addBlanketDelay( ) )
2010-11-30 22:56:34 +00:00
end,
2010-11-11 15:17:22 +00:00
2012-10-02 20:02:09 +00:00
--
2010-11-30 22:56:34 +00:00
-- Discards a waiting event.
--
2012-10-02 20:02:09 +00:00
discardEvent = function( sync, event )
local delay = e2d[ event ]
2012-01-27 13:01:00 +00:00
if delay.status ~= 'wait' then
2012-10-02 20:02:09 +00:00
log(
'Error',
2012-01-27 13:01:00 +00:00
'Ignored cancel of a non-waiting event of type ',
2012-10-02 20:02:09 +00:00
event.etype
)
2010-11-30 22:56:34 +00:00
return
end
2012-10-02 20:02:09 +00:00
sync:removeDelay( delay )
2010-11-30 22:56:34 +00:00
end,
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
--
2010-11-30 22:56:34 +00:00
-- Gets the next not blocked event from queue.
--
2012-10-02 20:02:09 +00:00
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
2012-10-02 20:02:09 +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
--
2012-10-02 20:02:09 +00:00
getEvents = function( sync, test )
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
2012-10-02 20:02:09 +00:00
--
2010-11-30 22:56:34 +00:00
-- Returns the configuration table specified by sync{}
--
2012-10-02 20:02:09 +00:00
getConfig = function( sync )
2010-11-30 22:56:34 +00:00
-- TODO gives a readonly handler only.
return sync.config
end,
}
2010-11-08 12:14:10 +00:00
2012-10-02 20:02:09 +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 = {
2012-10-02 20:02:09 +00:00
__index = function( inlet, func )
local f = inletFuncs[ func ]
if not f then
error(
'inlet does not have function "'..func..'"',
2
)
end
return function( ... )
return f( inlets[ inlet ], ... )
end
2010-11-30 22:56:34 +00:00
end,
}
2010-11-08 12:14:10 +00:00
2012-10-02 20:02:09 +00:00
--
-- Creates a new inlet for Sync.
--
local function newInlet( sync )
-- Lsyncd runner controlled variables
local inlet = { }
2010-11-30 22:56:34 +00:00
-- sets use access methods
2012-10-02 20:02:09 +00:00
setmetatable( inlet, inletMeta )
inlets[ inlet ] = sync
2011-11-23 10:05:42 +00:00
return inlet
2010-11-08 12:14:10 +00:00
end
2012-10-02 20:02:09 +00:00
--
2010-11-12 18:52:43 +00:00
-- Returns the delay from a event.
2010-11-30 22:56:34 +00:00
--
2012-10-02 20:02:09 +00:00
local function getDelayOrList( event )
return e2d[ event ]
2010-11-12 18:52:43 +00:00
end
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
--
2010-11-30 22:56:34 +00:00
-- Returns the sync from an event or list
--
2012-10-02 20:02:09 +00:00
local function getSync( event )
return e2d[ event ].sync
2010-11-08 12:14:10 +00:00
end
2012-10-02 20:02:09 +00:00
--
-- Public interface.
--
2010-11-08 12:14:10 +00:00
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
2012-10-02 20:02:09 +00:00
end )( )
2010-11-13 16:59:46 +00:00
2012-10-02 20:02:09 +00:00
--
2010-11-13 16:59:46 +00:00
-- A set of exclude patterns
--
2012-10-02 20:02:09 +00:00
local Excludes = ( function( )
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
--
2010-11-13 16:59:46 +00:00
-- Turns a rsync like file pattern to a lua pattern.
2012-10-02 20:02:09 +00:00
-- ( at best it can )
2011-11-23 10:05:42 +00:00
--
2012-10-02 20:02:09 +00:00
local function toLuaPattern( p )
2010-11-13 16:59:46 +00:00
local o = p
2012-10-02 20:02:09 +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-10-02 20:02:09 +00:00
p = string.gsub( p, '%[%^/%]%*%[%^/%]%*', '.*' )
p = string.gsub( p, '^/', '^/' )
if p:sub( 1, 2 ) ~= '^/' then
-- if does not begin with '^/'
-- then all matches should begin with '/'.
p = '/' .. p;
2011-01-19 15:30:19 +00:00
end
2012-10-02 20:02:09 +00:00
log(
'Exclude',
'toLuaPattern "',
o, '" = "', p, '"'
)
2010-11-13 16:59:46 +00:00
return p
end
--
2012-10-02 20:02:09 +00:00
-- Adds a pattern to exclude
--
local function add( self, pattern )
if self.list[ pattern ] then
2010-11-13 16:59:46 +00:00
-- already in the list
return
end
2012-10-02 20:02:09 +00:00
local lp = toLuaPattern( pattern )
self.list[ pattern ] = lp
2010-11-13 16:59:46 +00:00
end
2011-11-23 10:05:42 +00:00
2012-10-02 20:02:09 +00:00
--
2010-11-13 19:22:05 +00:00
-- Removes a pattern to exclude.
--
2012-10-02 20:02:09 +00:00
local function remove( self, pattern )
if not self.list[ pattern ] then
-- already in the list?
log(
'Normal',
'Removing not excluded exclude "' .. pattern .. '"'
)
2010-11-13 19:22:05 +00:00
return
end
2012-10-02 20:02:09 +00:00
2010-11-13 19:22:05 +00:00
self.list[pattern] = nil
2012-10-02 20:02:09 +00:00
2010-11-13 19:22:05 +00:00
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
--
2012-10-02 20:02:09 +00:00
-- Loads the excludes from a file
--
local function loadFile( self, file )
f, err = io.open( file )
2010-11-13 16:59:46 +00:00
if not f then
2012-10-02 20:02:09 +00:00
log(
'Error',
'Cannot open exclude file "', file,'": ',
err
)
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-11-13 16:59:46 +00:00
end
2012-10-02 20:02:09 +00:00
2011-11-23 10:05:42 +00:00
for line in f:lines() do
2012-10-02 20:02:09 +00:00
2010-11-13 16:59:46 +00:00
-- lsyncd 2.0 does not support includes
2012-10-02 20:02:09 +00:00
2012-01-27 13:01:00 +00:00
if not string.match(line, '%s*+') then
2012-10-02 20:02:09 +00:00
local p = string.match(
line, '%s*-?%s*(.*)'
)
if p then
add(self, p)
end
2010-11-13 16:59:46 +00:00
end
end
2012-10-02 20:02:09 +00:00
f:close( )
2010-11-13 16:59:46 +00:00
end
2012-10-02 20:02:09 +00:00
--
-- Tests if 'path' is excluded.
2010-11-13 16:59:46 +00:00
--
2012-10-02 20:02:09 +00:00
local function test( self, path )
for _, p in pairs( self.list ) do
if p:byte( -1 ) == 36 then
-- ends with $
2012-10-02 20:02:09 +00:00
if path:match( p ) then
return true
end
else
2012-10-02 20:02:09 +00:00
2012-01-27 14:19:17 +00:00
-- ends either end with / or $
2012-10-02 20:02:09 +00:00
if path:match(p .. '/') or path:match(p .. '$') then
return true
end
2010-11-13 16:59:46 +00:00
end
end
2012-10-02 20:02:09 +00:00
2010-11-13 16:59:46 +00:00
return false
2012-10-02 20:02:09 +00:00
2010-11-13 16:59:46 +00:00
end
2012-10-02 20:02:09 +00:00
--
2010-11-13 16:59:46 +00:00
-- Cretes a new exclude set
--
2012-10-02 20:02:09 +00:00
local function new( )
2011-11-23 10:05:42 +00:00
return {
2012-10-02 20:02:09 +00:00
list = { },
2010-11-13 16:59:46 +00:00
-- 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
}
2012-10-02 20:02:09 +00:00
2010-11-13 16:59:46 +00:00
end
2012-10-02 20:02:09 +00:00
--
2010-11-13 16:59:46 +00:00
-- Public interface
2012-10-02 20:02:09 +00:00
--
2010-11-13 16:59:46 +00:00
return { new = new }
2012-10-03 07:23:18 +00:00
2012-10-02 20:02:09 +00:00
end )( )
2010-11-13 16:59:46 +00:00
2012-10-03 07:23:18 +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
--
2012-10-03 07:23:18 +00:00
local Sync = ( function( )
--
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
2012-10-03 07:23:18 +00:00
--
2010-11-13 19:22:05 +00:00
-- Adds an exclude.
--
2012-10-03 07:23:18 +00:00
local function addExclude( self, pattern )
return self.excludes:add( pattern )
2010-11-13 19:22:05 +00:00
end
2012-10-03 07:23:18 +00:00
--
2010-11-13 19:22:05 +00:00
-- Removes an exclude.
--
2012-10-03 07:23:18 +00:00
local function rmExclude( self, pattern )
return self.excludes:remove( pattern )
2010-11-13 19:22:05 +00:00
end
2012-10-03 07:23:18 +00:00
--
2010-11-11 15:17:22 +00:00
-- Removes a delay.
2010-11-12 20:43:27 +00:00
--
2012-10-03 07:23:18 +00:00
local function removeDelay( self, delay )
if self.delays[ delay.dpos ] ~= delay then
error( 'Queue is broken, delay not a dpos' )
2010-11-11 15:17:22 +00:00
end
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
--
-- Returns true if this Sync concerns about 'path'
--
2012-10-03 07:23:18 +00:00
local function concerns( self, path )
-- not concerned if watch rootdir doesnt match
2012-10-03 07:23:18 +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-10-03 07:23:18 +00:00
path:sub( #self.source, -1 ):match( '[^/]+/?' )
then
return false
end
-- concerned if not excluded
2012-10-03 07:23:18 +00:00
return not self.excludes:test( path:sub( #self.source ) )
end
2012-10-03 07:23:18 +00:00
--
2011-11-23 10:05:42 +00:00
-- Collects a child process
2010-11-08 12:14:10 +00:00
--
2012-10-03 07:23:18 +00:00
local function collect( self, pid, exitcode )
local delay = self.processes[ pid ]
2010-11-08 12:14:10 +00:00
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-10-03 07:23:18 +00:00
log( 'Delay', 'collected an event' )
2012-01-27 13:01:00 +00:00
if delay.status ~= 'active' then
error('collecting a non-active process')
2010-11-12 18:52:43 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-30 22:56:34 +00:00
local rc = self.config.collect(
2012-10-03 07:23:18 +00:00
InletFactory.d2e( delay ),
exitcode
)
2012-01-27 13:01:00 +00:00
if rc == 'die' then
2012-10-03 07:23:18 +00:00
log( 'Error', 'Critical exitcode.' );
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-11-13 20:21:12 +00:00
end
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
removeDelay( self, delay )
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'
2012-10-03 07:23:18 +00:00
2011-11-23 10:05:42 +00:00
local alarm = self.config.delay
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +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-10-03 07:23:18 +00:00
log(
'Delay',
'collected a list'
)
2010-11-30 22:56:34 +00:00
local rc = self.config.collect(
2012-10-03 07:23:18 +00:00
InletFactory.dl2el( delay ),
exitcode
)
2012-01-27 13:01:00 +00:00
if rc == 'die' then
2012-10-03 07:23:18 +00:00
log( 'Error', 'Critical exitcode.' );
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-11-13 20:21:12 +00:00
end
2012-10-03 07:23:18 +00:00
2012-01-27 13:01:00 +00:00
if rc == 'again' then
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
2010-11-29 20:32:54 +00:00
alarm = now() + alarm
2012-10-03 07:23:18 +00:00
for _, d in ipairs( delay ) do
2010-12-11 23:00:33 +00:00
d.alarm = alarm
2012-01-27 13:01:00 +00:00
d.status = 'wait'
2010-11-13 20:31:24 +00:00
end
end
2012-10-03 07:23:18 +00:00
for _, d in ipairs( delay ) do
2012-01-27 13:01:00 +00:00
if rc ~= 'again' then
2012-10-03 07:23:18 +00:00
removeDelay( self, d )
2010-12-11 23:00:33 +00:00
else
2012-01-27 13:01:00 +00:00
d.status = 'wait'
2010-11-12 18:52:43 +00:00
end
end
2012-10-03 07:23:18 +00:00
log( 'Delay','Finished list = ',exitcode )
2010-11-12 18:52:43 +00:00
end
2012-10-03 07:23:18 +00:00
self.processes[ pid ] = nil
2010-11-08 12:14:10 +00:00
end
2010-11-06 18:26:59 +00:00
2012-10-03 07:23:18 +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
--
2012-10-03 07:23:18 +00:00
local function stack( oldDelay, newDelay )
2012-01-27 13:01:00 +00:00
newDelay.status = 'block'
2012-10-03 07:23:18 +00:00
2010-11-12 09:45:22 +00:00
if not oldDelay.blocks then
2012-10-03 07:23:18 +00:00
oldDelay.blocks = { }
2010-11-12 09:45:22 +00:00
end
2012-10-03 07:23:18 +00:00
table.insert( oldDelay.blocks, newDelay )
2010-11-12 09:45:22 +00:00
end
2012-10-03 07:23:18 +00:00
--
2010-11-06 18:26:59 +00:00
-- Puts an action on the delay stack.
--
2012-10-03 07:23:18 +00:00
local function delay( self, etype, time, path, path2 )
log(
'Function',
'delay( ',
2012-10-03 07:23:18 +00:00
self.config.name, ', ',
etype, ', ',
path, ', ',
path2,
' )'
2012-10-03 07:23:18 +00:00
)
2012-02-16 15:49:34 +00:00
-- TODO
2012-10-03 07:23:18 +00:00
local function recurse( )
if etype == 'Create' and path:byte( -1 ) == 47 then
local entries = lsyncd.readdir( self.source .. path )
if entries then
2012-10-03 07:23:18 +00:00
for dirname, isdir in pairs(entries) do
2012-10-03 07:23:18 +00:00
local pd = path .. dirname
2012-10-03 07:23:18 +00:00
if isdir then
pd = pd..'/'
end
log(
'Delay',
'Create creates Create on ',
pd
)
delay( self, 'Create', time, pd, nil )
end
2012-10-03 07:23:18 +00:00
end
2012-10-03 07:23:18 +00:00
end
2012-10-03 07:23:18 +00:00
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-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
local ex1 = self.excludes:test( path )
local ex2 = self.excludes:test( path2 )
2010-11-13 16:59:46 +00:00
if ex1 and ex2 then
2012-10-03 07:23:18 +00:00
log(
'Exclude',
'excluded "',
etype,
' on "',
path,
'" -> "',
path2,
'"'
)
2010-11-13 16:59:46 +00:00
return
2012-10-03 07:23:18 +00:00
2010-11-13 16:59:46 +00:00
elseif not ex1 and ex2 then
2012-10-03 07:23:18 +00:00
2010-11-13 16:59:46 +00:00
-- splits the move if only partly excluded
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
2010-11-13 16:59:46 +00:00
elseif ex1 and not ex2 then
-- splits the move if only partly excluded
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
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'
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
2010-11-06 18:26:59 +00:00
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
2012-10-03 07:23:18 +00:00
alarm = now( )
2010-11-06 18:26:59 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-10 09:49:44 +00:00
-- new delay
2012-10-03 07:23:18 +00:00
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
-- always stack init or blanket events on the last event
log(
'Delay',
'Stacking ',
nd.etype,
' event.'
)
2010-12-11 20:00:48 +00:00
if self.delays.size > 0 then
2012-10-03 07:23:18 +00:00
stack( self.delays[ self.delays.last ], nd )
2010-11-12 09:45:22 +00:00
end
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
for il, od in Queue.qpairsReverse( self.delays ) do
2010-12-11 20:00:48 +00:00
-- asks Combiner what to do
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
Queue.remove( self.delays, il )
2012-01-27 13:01:00 +00:00
elseif ac == 'stack' then
2012-10-03 07:23:18 +00:00
stack( od, nd )
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
2012-10-03 07:23:18 +00:00
delay( self, 'Delete', time, path, nil )
delay( self, 'Create', time, path2, nil )
2011-11-23 10:05:42 +00:00
else
2012-10-03 07:23:18 +00:00
error( 'unknown result of combine()' )
2010-11-06 18:26:59 +00:00
end
2012-10-03 07:23:18 +00:00
recurse( )
return
2010-11-06 18:26:59 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-10 09:49:44 +00:00
il = il - 1
2010-11-06 18:26:59 +00:00
end
2012-10-03 07:23:18 +00:00
if nd.path2 then
2012-10-03 07:23:18 +00:00
log( 'Delay','New ',nd.etype,':',nd.path,'->',nd.path2 )
else
2012-10-03 07:23:18 +00:00
log( 'Delay','New ',nd.etype,':',nd.path )
end
2012-10-03 07:23:18 +00:00
-- no block or combo
2012-10-03 07:23:18 +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-06 21:29:22 +00:00
--
2012-10-03 07:23:18 +00:00
-- Returns the soonest alarm for this Sync.
--
local function getAlarm( self )
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
2012-10-03 07:23:18 +00:00
if self.processes:size( ) < self.config.maxProcesses then
2010-11-30 17:08:15 +00:00
-- finds the nearest delay waiting to be spawned
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +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
--
2012-10-03 07:23:18 +00:00
local function getDelays( self, test )
local dlist = { sync = self}
2010-12-11 23:00:33 +00:00
local dlistn = 1
2012-10-03 07:23:18 +00:00
local blocks = { }
2010-11-12 18:52:43 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-12 18:52:43 +00:00
-- inheritly transfers all blocks from delay
--
2012-10-03 07:23:18 +00:00
local function getBlocks( delay )
blocks[ delay ] = true
2010-11-13 18:04:37 +00:00
if delay.blocks then
2012-10-03 07:23:18 +00:00
for i, d in ipairs( delay.blocks ) do
getBlocks( d )
2010-11-13 18:04:37 +00:00
end
2010-11-08 12:14:10 +00:00
end
2010-11-12 18:52:43 +00:00
end
2012-10-03 07:23:18 +00:00
for i, d in Queue.qpairs( self.delays ) do
2012-01-27 14:19:17 +00:00
if d.status == 'active' or
2012-10-03 07:23:18 +00:00
( test and not test( InletFactory.d2e( d ) ) )
2010-11-13 18:04:37 +00:00
then
2012-10-03 07:23:18 +00:00
getBlocks( d )
elseif not blocks[ d ] then
dlist[ dlistn ] = d
2010-12-11 23:00:33 +00:00
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
2012-10-03 07:23:18 +00:00
--
2010-11-07 01:06:08 +00:00
-- Creates new actions
--
2012-10-03 07:23:18 +00:00
local function invokeActions( self, timestamp )
log(
'Function',
'invokeActions( "',
self.config.name, '", ',
timestamp,
' )'
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
for _, d in Queue.qpairs( self.delays ) do
-- if reached the global limit return
2012-10-08 07:10:03 +00:00
if uSettings.maxProcesses and
processCount >= uSettings.maxProcesses
2012-10-03 07:23:18 +00:00
then
2012-01-27 13:01:00 +00:00
log('Alarm', 'at global process limit.')
return
end
2012-10-03 07:23:18 +00:00
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-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
self.config.action( self.inlet )
else
2012-10-03 07:23:18 +00:00
self.config.init( InletFactory.d2e( d ) )
end
2012-10-03 07:23:18 +00:00
if self.processes:size( ) >= self.config.maxProcesses then
2010-11-08 12:14:10 +00:00
-- no further processes
return
end
end
2010-11-07 01:06:08 +00:00
end
end
2011-11-23 10:05:42 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-12 18:52:43 +00:00
-- Gets the next event to be processed.
--
2012-10-03 07:23:18 +00:00
local function getNextDelay( self, timestamp )
for i, d in Queue.qpairs( self.delays ) do
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 nil
end
2010-11-12 18:52:43 +00:00
end
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
2010-11-12 18:52:43 +00:00
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
--
2012-10-03 07:23:18 +00:00
local function addBlanketDelay( self )
local newd = Delay.new( 'Blanket', self, true, '' )
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
2012-10-03 07:23:18 +00:00
--
-- Adds and returns a blanket delay thats blocks all.
-- Used as startup marker to call init asap.
--
2012-10-03 07:23:18 +00:00
local function addInitDelay( self )
2012-10-03 07:23:18 +00:00
local newd = Delay.new( 'Init', self, true, '' )
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
--
2010-11-12 10:07:58 +00:00
-- Writes a status report about delays in this sync.
--
2012-10-03 07:23:18 +00:00
local function statusReport( self, f )
2012-01-27 13:01:00 +00:00
local spaces = ' '
2012-10-03 07:23:18 +00:00
f:write( self.config.name, ' source=', self.source, '\n' )
f:write( 'There are ', self.delays.size, ' delays\n')
for i, vd in Queue.qpairs( self.delays ) do
2010-11-12 11:04:45 +00:00
local st = vd.status
2012-10-03 07:23:18 +00:00
f:write( st, string.sub( spaces, 1, 7 - #st ) )
f:write( vd.etype, ' ' )
f:write( vd.path )
if vd.path2 then
f:write( ' -> ',vd.path2 )
2010-11-12 10:07:58 +00:00
end
2012-10-03 07:23:18 +00:00
2012-01-27 13:01:00 +00:00
f:write('\n')
2012-10-03 07:23:18 +00:00
2010-11-12 10:07:58 +00:00
end
2012-10-03 07:23:18 +00:00
f:write( 'Excluding:\n' )
2010-11-13 16:59:46 +00:00
local nothing = true
2012-10-03 07:23:18 +00:00
for t, p in pairs( self.excludes.list ) do
2010-11-13 16:59:46 +00:00
nothing = false
2012-10-03 07:23:18 +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-10-03 07:23:18 +00:00
f:write( '\n' )
2010-11-20 22:32:25 +00:00
end
2010-11-13 16:59:46 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-06 10:33:26 +00:00
-- Creates a new Sync
2010-11-02 14:11:26 +00:00
--
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
2010-11-02 14:11:26 +00:00
config = config,
2012-10-03 07:23:18 +00:00
delays = Queue.new( ),
2010-11-05 15:18:01 +00:00
source = config.source,
2012-10-03 07:23:18 +00:00
processes = CountArray.new( ),
excludes = Excludes.new( ),
2010-11-06 21:29:22 +00:00
-- functions
2012-10-03 07:23:18 +00:00
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
}
2012-10-03 07:23:18 +00:00
s.inlet = InletFactory.newInlet( s )
2010-11-30 22:56:34 +00:00
2010-11-06 18:26:59 +00:00
-- provides a default name if needed
if not config.name then
2012-10-03 07:23:18 +00:00
config.name = 'Sync' .. nextDefaultName
2010-11-06 18:26:59 +00:00
end
2012-10-03 07:23:18 +00:00
-- increments defaults if a config name was given or not
-- so Sync{n} 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
2012-10-03 07:23:18 +00:00
local te = type( config.exclude )
2012-01-27 13:01:00 +00:00
if te == 'table' then
2012-10-03 07:23:18 +00:00
s.excludes:addList( config.exclude )
2012-01-27 13:01:00 +00:00
elseif te == 'string' then
2012-10-03 07:23:18 +00:00
s.excludes:add( config.exclude )
2010-12-03 21:16:39 +00:00
else
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
2010-11-13 16:59:46 +00:00
if config.excludeFrom then
2012-10-03 07:23:18 +00:00
s.excludes:loadFile( config.excludeFrom )
2010-11-13 16:59:46 +00:00
end
2010-11-06 18:26:59 +00:00
return s
2010-11-02 14:11:26 +00:00
end
2010-11-08 12:14:10 +00:00
--
2012-10-03 07:23:18 +00:00
-- Public interface
--
return { new = new }
end )( )
2010-11-02 14:11:26 +00:00
2010-10-25 17:38:57 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-06 10:10:00 +00:00
-- Syncs - a singleton
2011-11-23 10:05:42 +00:00
--
2012-10-03 07:23:18 +00:00
-- Syncs maintains all configured syncs.
2010-11-02 14:11:26 +00:00
--
2012-10-03 07:23:18 +00:00
local Syncs = ( function( )
--
2010-11-06 10:33:26 +00:00
-- the list of all syncs
2010-11-06 18:26:59 +00:00
--
local syncsList = Array.new( )
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
--
-- The cycle( ) sheduler goes into the next round of roundrobin.
2012-10-03 07:23:18 +00:00
--
local function nextRound( )
round = round + 1;
2012-10-03 07:23:18 +00:00
if round > #syncsList then
round = 1
end
2012-10-03 07:23:18 +00:00
return round
end
2012-10-03 07:23:18 +00:00
--
-- Returns the round
2012-10-03 07:23:18 +00:00
--
local function getRound( )
return round
end
2012-10-03 07:23:18 +00:00
--
-- Returns sync at listpos i
2012-10-03 07:23:18 +00:00
--
local function get( i )
return syncsList[ i ];
end
2012-10-03 07:23:18 +00:00
--
-- Helper function for inherit
-- defined below
--
local inheritKV
--
-- Recurvely inherits a source table to a destionation table
-- copying all keys from source.
--
-- table copy source ( cs )
-- table copy destination ( cd )
--
-- All entries with integer keys are inherited as additional
-- sources for non-verbatim tables
2010-11-03 11:37:25 +00:00
--
2012-10-03 07:23:18 +00:00
local function inherit( cd, cs )
--
-- First copies all entries with non-integer keys
-- tables are merged, already present keys are not
-- overwritten
--
-- For verbatim tables integer keys are treated like
-- non integer keys
--
2012-10-03 07:23:18 +00:00
for k, v in pairs( cs ) do
if
(
type( k ) ~= 'number' or
cs._verbatim == true
)
and
(
type( cs._merge ) ~= 'table' or
cs._merge[ k ] == true
)
then
inheritKV( cd, k, v )
2010-11-03 15:53:20 +00:00
end
end
2012-10-03 07:23:18 +00:00
--
-- recursevely inherits all integer keyed tables
-- ( for non-verbatim tables )
--
if cs._verbatim ~= true then
local n = nil
for k, v in ipairs( cs ) do
n = k
if type( v ) == 'table' then
inherit( cd, v )
else
cd[ #cd + 1 ] = v
end
end
end
end
--
-- Helper to inherit. Inherits one key.
--
inheritKV = function( cd, k, v )
-- don't merge inheritance controls
if k == '_merge' or k == '_verbatim' then
return
end
local dtype = type( cd [ k ] )
if type( v ) == 'table' then
if dtype == 'nil' then
cd[ k ] = { }
inherit( cd[ k ], v )
elseif
dtype == 'table' and
v._merge ~= false
then
inherit( cd[ k ], v )
2010-11-03 11:37:25 +00:00
end
elseif dtype == 'nil' then
cd[ k ] = v
2010-11-02 20:18:05 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-02 20:18:05 +00:00
end
2011-11-23 10:05:42 +00:00
2012-10-03 07:23:18 +00:00
--
-- Adds a new sync (directory-tree to observe).
2010-11-03 11:37:25 +00:00
--
2012-10-03 07:23:18 +00:00
local function add( config )
-- workaround for backwards compatibility
-- FIXME: remove when dropping that
if settings ~= settingsSafe then
log(
'Warn',
'settings = { ... } is deprecated.\n'..
' please use settings{ ... } (without the equal sign)'
)
for k, v in pairs( settings ) do
uSettings[ k ] = v
end
settings = settingsSafe
end
-- Creates a new config table which inherits all keys/values
2010-11-06 10:10:00 +00:00
-- from integer keyed tables
2010-11-03 15:53:20 +00:00
local uconfig = config
2012-10-03 07:23:18 +00:00
config = { }
2011-11-23 10:05:42 +00:00
inherit( config, uconfig )
--
-- last and least defaults are inherited
--
inherit( config, default )
local inheritSettings = {
'delay',
'maxDelays',
'maxProcesses'
}
-- Lets settings override these values.
2012-10-08 07:10:03 +00:00
for _, v in ipairs( inheritSettings ) do
if uSettings[ v ] then
config[ v ] = uSettings[ v ]
end
end
-- Lets commandline override these values.
2012-10-08 07:10:03 +00:00
for _, v in ipairs( inheritSettings ) do
if clSettings[ v ] then
config[ v ] = clSettings[ v ]
end
end
--
-- lets the userscript 'prepare' function
-- check and complete the config
--
2012-10-03 07:23:18 +00:00
if type( config.prepare ) == 'function' then
-- prepare is given a writeable copy of config
2012-10-06 12:22:08 +00:00
config.prepare( config, 4 )
2012-01-27 11:08:10 +00:00
end
2010-11-11 15:17:22 +00:00
2012-10-03 07:23:18 +00:00
if not config[ 'source' ] then
local info = debug.getinfo( 3, 'Sl' )
log(
'Error',
info.short_src,':',
info.currentline,': source missing from sync.'
)
2012-10-03 15:37:49 +00:00
terminate( -1 )
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
--
2012-10-03 07:23:18 +00:00
local realsrc = lsyncd.realdir( config.source )
2010-11-10 22:03:02 +00:00
if not realsrc then
2012-10-03 07:23:18 +00:00
log(
'Error',
'Cannot access source directory: ',
config.source
)
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-11-02 14:11:26 +00:00
end
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
if
not config.action and
not config.onAttrib and
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-10-03 07:23:18 +00:00
local info = debug.getinfo( 3, 'Sl' )
log(
'Error',
info.short_src, ':',
info.currentline,
': no actions specified.'
2012-10-03 07:23:18 +00:00
)
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-11-02 20:18:05 +00:00
end
2010-11-28 10:47:57 +00:00
-- the monitor to use
2012-01-27 11:08:10 +00:00
config.monitor =
2012-10-08 07:10:03 +00:00
uSettings.monitor or
2012-10-03 07:23:18 +00:00
config.monitor or
Monitors.default( )
if
config.monitor ~= 'inotify' and
config.monitor ~= 'fsevents'
then
local info = debug.getinfo( 3, 'Sl' )
log(
'Error',
info.short_src, ':',
info.currentline,
': event monitor "',
config.monitor,
'" unknown.'
)
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-11-28 10:47:57 +00:00
end
2010-11-10 11:23:26 +00:00
--- creates the new sync
2012-10-03 07:23:18 +00:00
local s = Sync.new( config )
table.insert( syncsList, s )
2010-11-30 22:56:34 +00:00
return s
2010-11-02 14:11:26 +00:00
end
2012-10-03 07:23:18 +00:00
--
-- Allows a for-loop to walk through all syncs.
2010-11-06 18:26:59 +00:00
--
2012-10-03 07:23:18 +00:00
local function iwalk( )
return ipairs( syncsList )
2010-11-02 14:11:26 +00:00
end
2012-10-03 07:23:18 +00:00
--
-- Returns the number of syncs.
2010-11-06 18:26:59 +00:00
--
2012-10-03 07:23:18 +00:00
local size = function( )
return #syncsList
2010-11-02 14:11:26 +00:00
end
2012-10-03 07:23:18 +00:00
--
-- Tests if any sync is interested in a path.
--
2012-10-03 07:23:18 +00:00
local function concerns( path )
for _, s in ipairs( syncsList ) do
2012-10-03 07:23:18 +00:00
if s:concerns( path ) then
return true
end
end
2012-10-03 07:23:18 +00:00
return false
end
2012-10-03 07:23:18 +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
}
2012-10-03 07:23:18 +00:00
end )( )
2010-10-25 17:38:57 +00:00
2010-11-11 18:34:44 +00:00
2012-10-03 07:23:18 +00:00
--
-- Utility function,
-- Returns the relative part of absolute path if it
-- begins with root
--
2012-10-03 07:23:18 +00:00
local function splitPath( path, root )
2012-01-27 11:08:10 +00:00
local rlen = #root
2012-10-03 07:23:18 +00:00
local sp = string.sub( path, 1, rlen )
if sp == root then
2012-10-03 07:23:18 +00:00
return string.sub( path, rlen, -1 )
else
return nil
end
end
2010-10-28 17:56:33 +00:00
--
2012-10-03 07:23:18 +00:00
-- Interface to inotify.
2010-10-21 12:37:27 +00:00
--
2012-10-03 07:23:18 +00:00
-- watches recursively subdirs and sends events.
--
-- All inotify specific implementation is enclosed here.
--
local Inotify = ( function( )
--
2012-10-03 07:23:18 +00:00
-- A list indexed by inotify watch descriptors 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
--
2012-10-03 07:23:18 +00:00
-- The same vice versa,
-- all watch descriptors by their absolute paths.
--
local pathwds = { }
2010-11-17 18:52:55 +00:00
--
2012-10-03 07:23:18 +00:00
-- A list indexed by syncs containing yielding
-- the root paths the syncs are interested in.
--
local syncRoots = { }
2012-01-27 11:08:10 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-24 19:21:43 +00:00
-- Stops watching a directory
--
2012-10-03 07:23:18 +00:00
-- path ... absolute path to unwatch
-- core ... if false not actually send the unwatch to the kernel
-- (used in moves which reuse the watch)
2010-11-24 19:21:43 +00:00
--
2012-10-03 07:23:18 +00:00
local function removeWatch( path, core )
local wd = pathwds[ path ]
if not wd then
return
end
if core then
lsyncd.inotify.rmwatch( wd )
end
wdpaths[ wd ] = nil
pathwds[ path ] = nil
2010-11-24 19:21:43 +00:00
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
2012-10-08 07:10:03 +00:00
local inotifyMode = ( uSettings and uSettings.inotifyMode ) or '';
2012-10-03 07:23:18 +00:00
local wd = lsyncd.inotify.addwatch( path, inotifyMode) ;
2010-11-24 19:21:43 +00:00
if wd < 0 then
2012-10-03 07:23:18 +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.
2012-10-03 07:23:18 +00:00
local op = wdpaths[ wd ]
2010-11-24 19:21:43 +00:00
if op and op ~= path then
2012-10-03 07:23:18 +00:00
pathwds[ op ] = nil
end
2010-11-09 19:15:41 +00:00
end
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
local entries = lsyncd.readdir( path )
if not entries then
return
end
for dirname, isdir in pairs( entries ) do
if isdir then
addWatch( path .. dirname .. '/' )
end
2010-11-03 11:37:25 +00:00
end
end
2010-10-25 14:55:40 +00:00
2012-10-03 07:23:18 +00:00
--
-- Adds a Sync to receive events.
--
-- sync: Object to receive events
-- rootdir: root dir to watch
--
2012-10-03 07:23:18 +00:00
local function addSync( sync, rootdir )
if syncRoots[ sync ] then
error( 'duplicate sync in Inotify.addSync()' )
end
syncRoots[ sync ] = rootdir
addWatch( rootdir )
2010-11-09 19:15:41 +00:00
end
2010-11-03 11:37:25 +00:00
--
2012-10-03 07:23:18 +00:00
-- Called when an event has occured.
2010-11-03 11:37:25 +00:00
--
2012-10-03 07:23:18 +00:00
local function event(
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
if isdir then
2012-10-03 07:23:18 +00:00
filename = filename .. '/'
if filename2 then
filename2 = filename2 .. '/'
end
end
2010-11-03 11:37:25 +00:00
if filename2 then
2012-10-03 07:23:18 +00:00
log(
'Inotify',
'got event ',
etype,
' ',
filename,
'(', wd, ') to ',
filename2,
'(', wd2 ,')'
)
2012-01-27 11:08:10 +00:00
else
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
local path = wdpaths[ wd ]
if path then
path = path..filename
end
2012-01-27 11:08:10 +00:00
2012-10-03 07:23:18 +00:00
local path2 = wd2 and wdpaths[ wd2 ]
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
2012-10-03 07:23:18 +00:00
log(
'Inotify',
'Move from deleted directory ',
path2,
' becomes Create.'
)
path = path2
2010-11-22 10:04:04 +00:00
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
2012-10-03 07:23:18 +00:00
log(
'Inotify',
'event belongs to unknown watch descriptor.'
)
2010-11-22 10:04:04 +00:00
return
end
2012-10-03 07:23:18 +00:00
for sync, root in pairs( syncRoots ) do repeat
local relative = splitPath( path, root )
2012-01-30 14:01:18 +00:00
local relative2 = nil
2012-10-03 07:23:18 +00:00
if path2 then
2012-10-03 07:23:18 +00:00
relative2 = splitPath( path2, root )
end
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
if etyped == 'Move' then
2012-01-30 14:01:18 +00:00
if not relative2 then
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
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-10-03 07:23:18 +00:00
addWatch( path )
2012-01-30 14:01:18 +00:00
elseif etyped == 'Delete' then
2012-10-03 07:23:18 +00:00
removeWatch( path, true )
2012-01-30 14:01:18 +00:00
elseif etyped == 'Move' then
2012-10-03 07:23:18 +00:00
removeWatch( path, false )
addWatch( path2 )
2010-11-03 11:37:25 +00:00
end
end
2012-02-16 15:49:34 +00:00
2012-10-03 07:23:18 +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
--
2012-10-03 07:23:18 +00:00
-- Writes a status report about inotify to a file descriptor
--
local function statusReport( f )
f:write( 'Inotify watching ', wdpaths:size(), ' directories\n' )
for wd, path in wdpaths:walk( ) do
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
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
end)( )
2010-11-28 10:47:57 +00:00
--
2012-10-03 07:23:18 +00:00
-- Interface to OSX /dev/fsevents
2010-12-02 11:57:04 +00:00
--
2012-10-03 07:23:18 +00:00
-- This watches all the filesystems at once,
-- but needs root access.
--
-- All fsevents specific implementation are enclosed here.
--
local Fsevents = ( function( )
2010-12-07 15:42:46 +00:00
--
2012-10-03 07:23:18 +00:00
-- A list indexed by syncs yielding
-- the root path the sync is interested in.
--
local syncRoots = { }
2010-12-07 15:42:46 +00:00
2012-10-03 07:23:18 +00:00
--
-- Adds a Sync to receive events.
2010-12-07 15:42:46 +00:00
--
-- @param sync Object to receive events
-- @param dir dir to watch
--
2012-10-03 07:23:18 +00:00
local function addSync( sync, dir )
if syncRoots[ sync ] then
error( 'duplicate sync in Fanotify.addSync()' )
end
syncRoots[ sync ] = dir
2010-12-07 15:42:46 +00:00
end
--
2012-10-03 07:23:18 +00:00
-- Called when an event has occured.
2010-12-07 15:42:46 +00:00
--
2012-10-03 07:23:18 +00:00
local function event(
etype, -- 'Attrib', 'Modify', 'Create', 'Delete', 'Move'
isdir, -- true if filename is a directory
time, -- time of event
path, -- path of file
path2 -- path of target in case of 'Move'
)
2010-12-10 16:12:15 +00:00
if isdir then
2012-10-03 07:23:18 +00:00
path = path .. '/'
if path2 then
path2 = path2 .. '/'
end
2010-12-10 16:12:15 +00:00
end
2012-10-03 07:23:18 +00:00
log(
'Fsevents',
etype, ',',
isdir, ',',
time, ',',
path, ',',
path2
)
2012-01-27 11:08:10 +00:00
2012-01-27 13:12:58 +00:00
for _, sync in Syncs.iwalk() do repeat
2012-10-03 07:23:18 +00:00
2012-01-27 13:12:58 +00:00
local root = sync.source
2012-10-03 07:23:18 +00:00
-- TODO combine ifs
if not path:starts( root ) then
if not path2 or not path2:starts( root ) then
2012-01-27 13:12:58 +00:00
break -- continue
end
2010-12-10 15:30:45 +00:00
end
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
relative2 = splitPath( path2, root )
2010-12-10 15:30:45 +00:00
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-10-03 07:23:18 +00:00
sync:delay( etyped, time, relative, relative2 )
2010-12-10 15:30:45 +00:00
until true end
2012-10-03 07:23:18 +00:00
2010-12-07 15:42:46 +00:00
end
2012-10-03 07:23:18 +00:00
2010-12-07 15:42:46 +00:00
--
2012-10-03 07:23:18 +00:00
-- Writes a status report about fsevents to a filedescriptor.
--
local function statusReport( f )
2010-12-07 15:42:46 +00:00
-- TODO
end
2012-10-03 07:23:18 +00:00
--
-- Public interface
--
2012-01-27 11:08:10 +00:00
return {
2012-10-03 07:23:18 +00:00
addSync = addSync,
event = event,
2012-01-27 11:08:10 +00:00
statusReport = statusReport
2010-12-07 15:42:46 +00:00
}
2012-10-03 07:23:18 +00:00
end )( )
2010-11-28 10:47:57 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-28 09:37:43 +00:00
-- Holds information about the event monitor capabilities
-- of the core.
--
2012-10-03 07:23:18 +00:00
Monitors = ( function( )
2010-11-28 10:47:57 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-28 09:37:43 +00:00
-- The cores monitor list
2010-11-28 10:47:57 +00:00
--
2012-10-03 07:23:18 +00:00
local list = { }
2010-11-28 09:37:43 +00:00
2012-10-03 07:23:18 +00:00
--
2010-11-28 10:47:57 +00:00
-- The default event monitor.
--
2012-10-03 07:23:18 +00:00
local function default( )
return list[ 1 ]
2010-11-28 10:47:57 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-28 09:37:43 +00:00
--
2012-10-03 07:23:18 +00:00
-- Initializes with info received from core
--
local function initialize( clist )
for k, v in ipairs( clist ) do
list[ k ] = v
2010-11-28 09:37:43 +00:00
end
end
2012-10-03 07:23:18 +00:00
--
-- Public interface
--
return {
default = default,
list = list,
initialize = initialize
2010-11-28 09:37:43 +00:00
}
2012-10-03 07:23:18 +00:00
end)( )
2010-11-13 13:13:51 +00:00
--
2012-10-03 07:23:18 +00:00
-- Writes functions for the user for layer 3 configurations.
--
local functionWriter = ( function( )
2010-11-13 13:13:51 +00:00
2012-10-03 07:23:18 +00:00
--
-- All variables known to layer 3 configs.
--
2010-11-13 13:13:51 +00:00
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
}
2012-01-27 11:08:10 +00:00
--
2012-10-03 07:23:18 +00:00
-- Splits a user string into its arguments.
-- Returns a table of arguments
2010-11-13 13:13:51 +00:00
--
2012-10-03 07:23:18 +00:00
local function splitStr(
str -- a string where parameters are seperated by spaces.
)
local args = { }
2012-01-30 14:01:18 +00:00
while str ~= '' do
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
-- break where argument stops
local bp = #str
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
-- in a quote
local inQuote = false
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
-- tests characters to be space and not within quotes
2012-10-03 07:23:18 +00:00
for i=1, #str do
local c = string.sub( str, i, i )
2010-11-13 13:13:51 +00:00
if c == '"' then
inQuote = not inQuote
elseif c == ' ' and not inQuote then
bp = i - 1
break
end
end
2012-10-03 07:23:18 +00:00
local arg = string.sub( str, 1, bp )
arg = string.gsub( arg, '"', '\\"' )
table.insert( args, arg )
str = string.sub( str, bp + 1, -1 )
str = string.match( str, '^%s*(.-)%s*$' )
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
return args
end
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
--
2012-10-03 07:23:18 +00:00
-- Translates a call to a binary to a lua function.
-- TODO this has a little too blocking.
2010-11-13 13:13:51 +00:00
--
2012-10-03 07:23:18 +00:00
local function translateBinary( str )
2010-11-13 13:13:51 +00:00
-- splits the string
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
for ia, iv in ipairs( args ) do
-- a list of arguments this arg is being split into
2012-10-03 07:23:18 +00:00
local a = { { true, iv } }
2010-11-13 13:13:51 +00:00
-- goes through all translates
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
if a[ ai ][ 1 ] then
2012-01-27 11:08:10 +00:00
local pre, post =
string.match( a[ ai ][ 2 ], '(.*)'..v[1]..'(.*)' )
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
if pre then
2012-10-03 07:23:18 +00:00
if v[3] > 1 then
haveEvent2 = true
end
2012-10-03 07:23:18 +00:00
2012-01-27 14:19:17 +00:00
if pre ~= '' then
2012-10-03 07:23:18 +00:00
table.insert( a, ai, { true, pre } )
2010-11-13 13:13:51 +00:00
ai = ai + 1
end
2012-10-03 07:23:18 +00:00
a[ ai ] = { false, v[ 2 ] }
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
2012-10-03 07:23:18 +00:00
for _, v in ipairs( a ) do
2010-11-13 13:13:51 +00:00
if not first then
2012-01-30 14:01:18 +00:00
as = as..' .. '
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
if v[ 1 ] then
as = as .. '"' .. v[ 2 ] .. '"'
2012-01-27 11:08:10 +00:00
else
2012-10-03 07:23:18 +00:00
as = as .. v[ 2 ]
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
first = false
end
2012-10-03 07:23:18 +00:00
args[ ia ] = as
2010-11-13 13:13:51 +00:00
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-10-03 07:23:18 +00:00
ft = ft ..
" log('Normal', 'Event ', event.etype, \n" ..
" ' spawns action \"".. str.."\"')\n" ..
2012-01-27 14:52:42 +00:00
" spawn(event"
2012-10-03 07:23:18 +00:00
for _, v in ipairs( args ) do
ft = ft .. ',\n ' .. v
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
ft = ft .. ')\nend'
2010-11-13 13:13:51 +00:00
return ft
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
--
2010-11-13 13:13:51 +00:00
-- Translates a call using a shell to a lua function
--
2012-10-03 07:23:18 +00:00
local function translateShell( str )
2010-11-13 13:13:51 +00:00
local argn = 1
2012-10-03 07:23:18 +00:00
local args = { }
2010-11-13 13:13:51 +00:00
local cmd = str
2010-11-13 13:44:51 +00:00
local lc = str
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
-- true if there is a second event
local haveEvent2 = false
2012-10-03 07:23:18 +00:00
for _, v in ipairs( transVars ) do
2010-11-13 13:13:51 +00:00
local occur = false
2012-10-03 07:23:18 +00:00
cmd = string.gsub(
cmd,
v[ 1 ],
function( )
2010-11-13 13:44:51 +00:00
occur = true
2012-10-03 07:23:18 +00:00
return '"$' .. argn .. '"'
end
)
lc = string.gsub(
lc,
v[1],
']]..' .. v[2] .. '..[['
)
2010-11-13 13:13:51 +00:00
if occur then
argn = argn + 1
2012-10-03 07:23:18 +00:00
table.insert( args, v[ 2 ] )
if v[ 3 ] > 1 then
2010-11-13 13:13:51 +00:00
haveEvent2 = true
end
end
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
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-10-03 07:23:18 +00:00
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.."]]"
2012-10-03 07:23:18 +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-10-03 07:23:18 +00:00
ft = ft .. ')\nend'
2010-11-13 13:13:51 +00:00
return ft
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
--
-- Writes a lua function for a layer 3 user script.
--
local function translate( str )
2012-01-27 11:08:10 +00:00
-- trim spaces
2012-10-03 07:23:18 +00:00
str = string.match( str, '^%s*(.-)%s*$' )
2010-11-13 13:13:51 +00:00
local ft
2012-10-03 07:23:18 +00:00
if string.byte( str, 1, 1 ) == 47 then
-- starts with /
2012-10-03 07:23:18 +00:00
ft = translateBinary( str )
elseif string.byte( str, 1, 1 ) == 94 then
-- starts with ^
2012-10-03 07:23:18 +00:00
ft = translateShell( str:sub( 2, -1 ) )
2010-11-13 13:13:51 +00:00
else
2012-10-03 07:23:18 +00:00
ft = translateShell( str )
2010-11-13 13:13:51 +00:00
end
2012-10-03 07:23:18 +00:00
log(
'FWrite',
'translated "',
str,
'" to \n',
ft
)
2010-11-13 13:13:51 +00:00
return ft
end
2012-10-03 07:23:18 +00:00
2010-11-13 13:13:51 +00:00
--
2012-10-03 07:23:18 +00:00
-- Public interface.
--
return { translate = translate }
end )( )
2010-11-13 13:13:51 +00:00
2010-10-28 17:56:33 +00:00
--
2012-10-03 07:23:18 +00:00
-- Writes a status report file at most every [statusintervall] seconds.
2010-11-06 10:10:57 +00:00
--
2012-10-03 07:23:18 +00:00
local StatusFile = ( function( )
2012-10-03 07:23:18 +00:00
--
2010-11-06 10:10:57 +00:00
-- Timestamp when the status file has been written.
2012-10-03 07:23:18 +00:00
--
2010-11-06 10:10:57 +00:00
local lastWritten = false
2012-10-03 07:23:18 +00:00
--
-- Timestamp when a status file should be written.
--
2010-11-06 10:10:57 +00:00
local alarm = false
2012-10-03 07:23:18 +00:00
--
-- Returns the alarm when the status file should be written-
2010-11-06 10:10:57 +00:00
--
local function getAlarm()
return alarm
end
2012-10-03 07:23:18 +00:00
--
2010-11-06 10:10:57 +00:00
-- Called to check if to write a status file.
--
2012-10-03 07:23:18 +00:00
local function write( timestamp )
log(
'Function',
'write( ',
timestamp,
' )'
2012-10-03 07:23:18 +00:00
)
2012-10-08 07:10:03 +00:00
--
2012-10-03 07:23:18 +00:00
-- takes care not write too often
2012-10-08 07:10:03 +00:00
--
if uSettings.statusInterval > 0 then
2012-10-03 07:23:18 +00:00
-- already waiting?
2010-11-29 20:32:54 +00:00
if alarm and timestamp < alarm then
2012-10-03 07:23:18 +00:00
log(
'Statusfile',
'waiting(',
timestamp,
' < ',
alarm,
')'
)
2010-11-06 10:10:57 +00:00
return
end
2012-10-03 07:23:18 +00:00
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-10-08 07:10:03 +00:00
2012-01-27 11:08:10 +00:00
local nextWrite =
2012-10-08 07:10:03 +00:00
lastWritten and timestamp +
uSettings.statusInterval
2012-10-03 07:23:18 +00:00
2010-11-29 20:32:54 +00:00
if nextWrite and timestamp < nextWrite then
2012-10-03 07:23:18 +00:00
log(
'Statusfile',
'setting alarm: ',
nextWrite
)
2010-11-06 10:10:57 +00:00
alarm = nextWrite
2012-10-03 07:23:18 +00:00
2010-11-06 10:10:57 +00:00
return
end
end
2012-10-03 07:23:18 +00:00
2010-11-29 20:32:54 +00:00
lastWritten = timestamp
2010-11-06 10:10:57 +00:00
alarm = false
end
2012-10-03 07:23:18 +00:00
log( 'Statusfile', 'writing now' )
2012-10-08 07:10:03 +00:00
local f, err = io.open( uSettings.statusFile, 'w' )
2012-10-03 07:23:18 +00:00
2010-11-06 10:10:57 +00:00
if not f then
2012-10-03 07:23:18 +00:00
log(
'Error',
'Cannot open status file "' ..
2012-10-08 07:10:03 +00:00
uSettings.statusFile ..
2012-10-03 07:23:18 +00:00
'" :' ..
err
)
2010-11-06 10:10:57 +00:00
return
end
2012-10-03 07:23:18 +00:00
f:write( 'Lsyncd status report at ', os.date( ), '\n\n' )
for i, s in Syncs.iwalk( ) do
s:statusReport( f )
f:write( '\n' )
2010-11-12 10:07:58 +00:00
end
2012-01-27 11:08:10 +00:00
2012-10-03 07:23:18 +00:00
Inotify.statusReport( f )
f:close( )
2010-11-05 18:04:29 +00:00
end
2010-11-06 10:10:57 +00:00
2010-10-28 17:56:33 +00:00
2012-10-03 07:23:18 +00:00
--
-- Public interface
--
return {
write = write,
getAlarm = getAlarm
}
end )( )
2010-11-30 23:14:17 +00:00
--
2012-10-03 07:23:18 +00:00
-- Lets userscripts make their own alarms.
--
local UserAlarms = ( function( )
2010-11-30 23:14:17 +00:00
2012-10-03 07:23:18 +00:00
local alarms = { }
--
-- Calls the user function at timestamp.
2010-11-30 23:14:17 +00:00
--
2012-10-03 07:23:18 +00:00
local function alarm( timestamp, func, extra )
2012-01-27 11:08:10 +00:00
local idx
2012-10-03 07:23:18 +00:00
for k, v in ipairs( alarms ) do
2010-11-30 23:14:17 +00:00
if timestamp < v.timestamp then
idx = k
break
end
end
2012-10-03 07:23:18 +00:00
local a = {
timestamp = timestamp,
func = func,
extra = extra
}
2010-11-30 23:14:17 +00:00
if idx then
2012-10-03 07:23:18 +00:00
table.insert( alarms, idx, a )
2010-11-30 23:14:17 +00:00
else
2012-10-03 07:23:18 +00:00
table.insert( alarms, a )
2010-11-30 23:14:17 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-30 23:14:17 +00:00
end
2012-10-03 07:23:18 +00:00
2010-11-30 23:14:17 +00:00
--
2012-10-03 07:23:18 +00:00
-- Retrieves the soonest alarm.
--
local function getAlarm( )
2010-11-30 23:14:17 +00:00
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
2012-10-03 07:23:18 +00:00
2010-11-30 23:14:17 +00:00
end
2012-10-03 07:23:18 +00:00
--
-- Calls user alarms.
2010-11-30 23:14:17 +00:00
--
2012-10-03 07:23:18 +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 )
2010-11-30 23:14:17 +00:00
end
end
2012-10-03 07:23:18 +00:00
--
-- Public interface
--
return {
alarm = alarm,
getAlarm = getAlarm,
invoke = invoke
}
end )( )
2010-11-30 23:14:17 +00:00
2010-11-10 15:57:37 +00:00
--============================================================================
2012-10-03 07:23:18 +00:00
-- Lsyncd runner's plugs. These functions are called from core.
2010-11-10 15:57:37 +00:00
--============================================================================
2012-10-03 07:23:18 +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
2010-11-29 20:32:54 +00:00
--
2012-10-03 07:23:18 +00:00
-- The cores interface to the runner.
--
local runner = { }
2010-11-10 15:57:37 +00:00
--
-- Last time said to be waiting for more child processes
--
local lastReportedWaiting = false
2012-10-03 07:23:18 +00:00
--
-- Called from core whenever Lua code failed.
--
2010-11-10 15:57:37 +00:00
-- Logs a backtrace
--
2012-10-03 07:23:18 +00:00
function runner.callError( message )
log('Error', 'in Lua: ', message )
2010-11-10 15:57:37 +00:00
-- prints backtrace
local level = 2
while true do
2012-10-03 07:23:18 +00:00
local info = debug.getinfo( level, 'Sl' )
2010-11-10 15:57:37 +00:00
if not info then
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-11-10 15:57:37 +00:00
end
2012-10-03 07:23:18 +00:00
log(
'Error',
'Backtrace ',
level - 1, ' :',
info.short_src, ':',
info.currentline
)
2010-11-10 15:57:37 +00:00
level = level + 1
end
end
2012-10-03 07:23:18 +00:00
--
-- Called from core whenever a child process has finished and
-- the zombie process was collected by core.
2010-11-10 15:57:37 +00:00
--
2012-10-03 07:23:18 +00:00
function runner.collectProcess( pid, exitcode )
processCount = processCount - 1
2012-10-03 07:23:18 +00:00
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
2012-10-03 07:23:18 +00:00
2010-11-10 15:57:37 +00:00
end
2012-10-03 07:23:18 +00:00
--
2010-11-05 18:04:29 +00:00
-- Called from core everytime a masterloop cycle runs through.
2012-10-03 07:23:18 +00:00
--
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
--
2012-10-03 07:23:18 +00:00
function runner.cycle(
timestamp -- the current kernel time (in jiffies)
)
2012-01-30 14:01:18 +00:00
if lsyncdStatus == 'fade' then
if processCount > 0 then
if
lastReportedWaiting == false or
timestamp >= lastReportedWaiting + 60
then
lastReportedWaiting = timestamp
log(
'Normal',
'waiting for ',
processCount,
' more child processes.'
)
end
2010-11-14 09:11:09 +00:00
return true
else
2010-11-14 09:11:09 +00:00
return false
end
end
2012-10-03 07:23:18 +00:00
2012-01-30 14:01:18 +00:00
if lsyncdStatus ~= 'run' then
2012-10-03 07:23:18 +00:00
error( 'runner.cycle() called while not running!' )
2010-11-14 09:11:09 +00:00
end
2012-10-03 07:23:18 +00:00
--
-- goes through all syncs and spawns more actions
-- if possibly. But only let Syncs invoke actions if
-- not at global limit
--
if
2012-10-08 07:10:03 +00:00
not uSettings.maxProcesses or
processCount < uSettings.maxProcesses
2012-10-03 07:23:18 +00:00
then
local start = Syncs.getRound( )
local ir = start
2012-10-03 07:23:18 +00:00
repeat
2012-10-03 07:23:18 +00:00
local s = Syncs.get( ir )
s:invokeActions( timestamp )
ir = ir + 1
2012-10-03 07:23:18 +00:00
if ir > Syncs.size( ) then
ir = 1
end
until ir == start
2012-10-03 07:23:18 +00:00
Syncs.nextRound( )
2010-11-08 12:14:10 +00:00
end
2010-11-30 23:14:17 +00:00
2012-10-03 07:23:18 +00:00
UserAlarms.invoke( timestamp )
2010-11-30 23:14:17 +00:00
2012-10-08 07:10:03 +00:00
if uSettings.statusFile then
2012-10-03 07:23:18 +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
2012-10-03 07:23:18 +00:00
--
-- Called by core if '-help' or '--help' is in
2010-10-27 09:06:13 +00:00
-- the arguments.
--
2012-10-03 07:23:18 +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)
2012-10-03 15:37:49 +00:00
os.exit( -1 )
2010-10-27 09:06:13 +00:00
end
2012-10-03 07:23:18 +00:00
--
2010-11-03 21:02:14 +00:00
-- Called from core to parse the command line arguments
--
2012-10-03 07:23:18 +00:00
-- returns a string as user script to load.
-- or simply 'true' if running with rsync bevaiour
--
-- terminates on invalid arguments.
--
function runner.configure( args, monitors )
2010-11-28 09:37:43 +00:00
Monitors.initialize( monitors )
2012-10-03 07:23:18 +00:00
2012-10-08 07:10:03 +00:00
--
2012-10-03 07:23:18 +00:00
-- a list of all valid options
--
-- first paramter is the number of parameters an option takes
2012-10-03 15:37:49 +00:00
-- if < 0 the called function has to check the presence of
-- optional arguments.
2012-10-03 07:23:18 +00:00
--
-- second paramter is the function to call
2010-11-28 09:37:43 +00:00
--
2010-11-03 21:02:14 +00:00
local options = {
2012-10-03 15:37:49 +00:00
2010-11-03 21:02:14 +00:00
-- log is handled by core already.
2012-10-03 15:37:49 +00:00
2012-10-03 07:23:18 +00:00
delay =
{
1,
function( secs )
clSettings.delay = secs
end
},
insist =
{
0,
function( )
clSettings.insist = true
end
},
log =
{
1,
nil
},
2012-10-03 15:37:49 +00:00
logfile =
2012-10-03 07:23:18 +00:00
{
1,
function( file )
clSettings.logfile = file
end
},
2012-01-27 11:08:10 +00:00
monitor =
2012-10-03 07:23:18 +00:00
{
-1,
function( monitor )
if not monitor then
2012-10-03 15:37:49 +00:00
io.stdout:write( 'This Lsyncd supports these monitors:\n' )
2012-10-03 07:23:18 +00:00
for _, v in ipairs(Monitors.list) do
io.stdout:write(' ',v,'\n')
end
2012-10-03 15:37:49 +00:00
io.stdout:write('\n')
lsyncd.terminate(-1)
2012-10-03 07:23:18 +00:00
else
2012-10-03 15:37:49 +00:00
clSettings.monitor = monitor
2010-11-28 09:37:43 +00:00
end
end
2012-10-03 07:23:18 +00:00
},
2012-01-27 11:08:10 +00:00
nodaemon =
2012-10-03 07:23:18 +00:00
{
0,
function( )
clSettings.nodaemon = true
end
},
2012-10-03 15:37:49 +00:00
pidfile =
2012-10-03 07:23:18 +00:00
{
1,
function( file )
clSettings.pidfile=file
end
},
2012-01-27 11:08:10 +00:00
rsync =
2012-10-03 07:23:18 +00:00
{
2,
function( src, trg )
clSettings.syncs = clSettings.syncs or { }
table.insert(
clSettings.syncs,
{ 'rsync', src, trg }
)
end
},
2012-01-27 11:08:10 +00:00
rsyncssh =
2012-10-03 07:23:18 +00:00
{
3,
function( src, host, tdir )
clSettings.syncs = clSettings.syncs or { }
table.insert(
clSettings.syncs,
{ 'rsyncssh', src, host, tdir }
)
end
},
2012-01-27 11:08:10 +00:00
direct =
2012-10-03 07:23:18 +00:00
{
2,
function( src, trg )
clSettings.syncs = clSettings.syncs or { }
table.insert(
clSettings.syncs,
{ 'direct', src, trg }
)
end
},
2012-10-03 15:37:49 +00:00
version =
2012-10-03 07:23:18 +00:00
{
0,
function( )
io.stdout:write( 'Version: ', lsyncd_version, '\n' )
os.exit( 0 )
end
}
2010-11-03 21:02:14 +00:00
}
2012-10-03 07:23:18 +00:00
-- non-opts is filled with all args that were no part dash options
2012-10-03 15:37:49 +00:00
2012-10-03 07:23:18 +00:00
local nonopts = { }
2012-10-03 15:37:49 +00:00
local i = 1
2010-11-03 21:02:14 +00:00
while i <= #args do
2012-10-03 07:23:18 +00:00
2012-10-03 15:37:49 +00:00
local a = args[ i ]
2012-10-03 07:23:18 +00:00
if a:sub( 1, 1 ) ~= '-' then
table.insert( nonopts, args[ i ] )
2010-11-03 21:02:14 +00:00
else
2012-10-03 07:23:18 +00:00
if a:sub( 1, 2 ) == '--' then
a = a:sub( 3 )
2010-11-03 21:02:14 +00:00
else
2012-10-03 07:23:18 +00:00
a = a:sub( 2 )
2010-11-03 21:02:14 +00:00
end
2012-10-03 07:23:18 +00:00
local o = options[ a ]
if not o then
2012-10-03 15:37:49 +00:00
log(
'Error',
'unknown option command line option ',
args[i]
)
os.exit( -1 )
2010-11-03 21:02:14 +00:00
end
2012-10-03 07:23:18 +00:00
2012-10-03 15:37:49 +00:00
if o[ 1 ] >= 0 and i + o[ 1 ] > #args then
log( 'Error', a ,' needs ', o[ 1 ],' arguments' )
os.exit( -1 )
elseif o[1] < 0 then
2012-10-03 15:37:49 +00:00
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
2012-10-03 15:37:49 +00:00
2010-11-03 21:02:14 +00:00
end
2010-11-13 20:47:45 +00:00
if clSettings.syncs then
2012-10-03 15:37:49 +00:00
2010-11-13 20:47:45 +00:00
if #nonopts ~= 0 then
2012-10-03 15:37:49 +00:00
log(
'Error',
'There cannot be command line syncs and config file together.'
)
os.exit( -1 )
2010-11-13 20:47:45 +00:00
end
2012-10-03 15:37:49 +00:00
2010-11-13 20:47:45 +00:00
else
2012-10-03 15:37:49 +00:00
2010-11-13 20:47:45 +00:00
if #nonopts == 0 then
2012-10-03 15:37:49 +00:00
runner.help( args[ 0 ] )
2010-11-13 20:47:45 +00:00
elseif #nonopts == 1 then
2012-10-03 15:37:49 +00:00
return nonopts[ 1 ]
2012-01-27 11:08:10 +00:00
else
2012-10-03 15:37:49 +00:00
-- TODO make this possible
log(
'Error',
'There can only be one config file in command line.'
)
os.exit( -1 )
2010-11-13 20:47:45 +00:00
end
2012-10-03 15:37:49 +00:00
2010-11-03 21:02:14 +00:00
end
end
2012-10-03 15:37:49 +00:00
--
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
--
2012-10-03 15:37:49 +00:00
-- firstTime:
-- true when Lsyncd startups the first time,
-- false on resets, due to HUP signal or monitor queue overflow.
2012-01-27 11:08:10 +00:00
--
2012-10-03 15:37:49 +00:00
function runner.initialize( firstTime )
2012-10-08 07:10:03 +00:00
if settings ~= settingsSafe then
log(
'Warn',
'settings = { ... } is deprecated.\n'..
' please use settings{ ... } (without the equal sign)'
)
for k, v in pairs( settings ) do
uSettings[ k ] = v
end
2012-10-08 07:10:03 +00:00
end
2012-01-27 11:08:10 +00:00
lastReportedWaiting = false
--
2010-10-25 14:55:40 +00:00
-- From this point on, no globals may be created anymore
--
lockGlobals( )
2010-10-25 14:55:40 +00:00
--
-- copies simple settings with numeric keys to 'key = true' settings.
--
2012-10-08 07:10:03 +00:00
-- FIXME this can be removed when
-- Lsyncd 2.0.x backwards compatibility is dropped
--
for k, v in ipairs( uSettings ) do
2012-10-03 15:37:49 +00:00
2012-10-08 07:10:03 +00:00
if uSettings[ v ] then
2012-10-03 15:37:49 +00:00
log(
'Error',
'Double setting "' .. v.. '"'
)
os.exit( -1 )
2010-11-13 21:50:21 +00:00
end
2012-10-03 15:37:49 +00:00
2012-10-08 07:10:03 +00:00
uSettings[ v ]= true
2010-11-13 21:50:21 +00:00
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
--
2012-10-03 15:37:49 +00:00
for k, v in pairs( clSettings ) do
2012-01-30 14:01:18 +00:00
if k ~= 'syncs' then
2012-10-08 07:10:03 +00:00
uSettings[ k ] = v
2010-11-13 21:50:21 +00:00
end
end
2012-02-15 15:47:18 +00:00
--
-- implicitly forces 'insist' on Lsyncd resets.
--
2011-08-29 09:21:40 +00:00
if not firstTime then
2012-10-08 07:10:03 +00:00
uSettings.insist = true
2011-08-29 09:21:40 +00:00
end
2010-11-13 21:50:21 +00:00
--
2010-11-13 21:50:21 +00:00
-- adds syncs specified by command line.
--
2010-11-13 21:50:21 +00:00
if clSettings.syncs then
2012-10-03 15:37:49 +00:00
for _, s in ipairs( clSettings.syncs ) do
if s[ 1 ] == 'rsync' then
2012-10-03 15:37:49 +00:00
sync{
default.rsync,
source = s[ 2 ],
target = s[ 3 ]
}
elseif s[ 1 ] == 'rsyncssh' then
2012-10-03 15:37:49 +00:00
sync{
default.rsyncssh,
source = s[ 2 ],
host = s[ 3 ],
targetdir=s[ 4 ]
}
elseif s[ 1 ] == 'direct' then
sync{
default.direct,
source=s[ 2 ],
target=s[ 3 ]
}
2010-11-13 21:50:21 +00:00
end
2012-10-03 15:37:49 +00:00
2010-11-13 21:50:21 +00:00
end
2012-10-03 15:37:49 +00:00
2010-11-13 21:50:21 +00:00
end
2012-10-08 07:10:03 +00:00
if uSettings.nodaemon then
lsyncd.configure( 'nodaemon' )
2010-11-13 21:50:21 +00:00
end
2012-10-03 15:37:49 +00:00
2012-10-08 07:10:03 +00:00
if uSettings.logfile then
lsyncd.configure( 'logfile', uSettings.logfile )
2010-11-13 21:50:21 +00:00
end
2012-10-03 15:37:49 +00:00
2012-10-08 07:10:03 +00:00
if uSettings.logident then
lsyncd.configure( 'logident', uSettings.logident )
end
2012-10-03 15:37:49 +00:00
2012-10-08 07:10:03 +00:00
if uSettings.logfacility then
lsyncd.configure( 'logfacility', uSettings.logfacility )
end
2012-10-03 15:37:49 +00:00
2012-10-08 07:10:03 +00:00
if uSettings.pidfile then
lsyncd.configure( 'pidfile', uSettings.pidfile )
end
2012-10-03 15:37:49 +00:00
--
2012-10-08 07:10:03 +00:00
-- Transfers some defaults to uSettings
2012-10-03 15:37:49 +00:00
--
2012-10-08 07:10:03 +00:00
if uSettings.statusInterval == nil then
uSettings.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-10-03 15:37:49 +00:00
log(
'Error',
'Nothing to watch!'
)
os.exit( -1 )
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';
2012-10-03 15:37:49 +00:00
lsyncd.configure( 'running' );
2012-01-27 11:08:10 +00:00
2010-11-13 13:44:51 +00:00
local ufuncs = {
2012-10-03 15:37:49 +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
2010-11-13 13:44:51 +00:00
-- checks if any user functions is a layer 3 string.
local config = s.config
2010-11-13 13:44:51 +00:00
for _, fn in ipairs(ufuncs) do
2010-11-13 13:44:51 +00:00
if type(config[fn]) == 'string' then
2010-11-13 13:44:51 +00:00
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
2010-11-13 13:44:51 +00:00
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
2012-10-03 15:37:49 +00:00
for _, s in Syncs.iwalk( ) do
2012-01-30 14:01:18 +00:00
if s.config.monitor == 'inotify' then
2012-10-03 15:37:49 +00:00
Inotify.addSync( s, s.source )
2012-01-30 14:01:18 +00:00
elseif s.config.monitor == 'fsevents' then
2012-10-03 15:37:49 +00:00
Fsevents.addSync( s, s.source )
2010-11-28 10:47:57 +00:00
else
2012-10-03 15:37:49 +00:00
error(
'sync ' ..
s.config.name ..
' has no known event monitor interface.'
)
2010-11-28 10:47:57 +00:00
end
2012-10-03 15:37:49 +00:00
-- if the sync has an init function, the init delay
-- is stacked which causes the init function to be called.
2010-11-07 09:53:39 +00:00
if s.config.init then
2012-10-03 15:37:49 +00:00
s:addInitDelay( )
2010-10-22 10:35:26 +00:00
end
end
2012-10-03 15:37:49 +00:00
2010-10-17 15:24:55 +00:00
end
2012-10-03 15:37:49 +00:00
--
-- Called by core to query the 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)
--
2012-10-03 15:37:49 +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
2012-10-03 15:37:49 +00:00
2010-11-05 18:20:33 +00:00
local alarm = false
2012-10-03 15:37:49 +00:00
--
-- Checks if 'a' is sooner than the 'alarm' up-value.
2010-11-06 21:29:22 +00:00
--
2012-10-03 15:37:49 +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
2012-10-03 15:37:49 +00:00
2010-11-08 12:14:10 +00:00
if alarm == true or not a then
2012-10-03 15:37:49 +00:00
-- 'alarm' is already immediate or
-- a not a new alarm
2010-12-01 13:25:05 +00:00
return
2010-11-06 21:29:22 +00:00
end
2012-10-03 15:37:49 +00:00
-- sets 'alarm' to a if a is sooner
2010-12-01 13:17:04 +00:00
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
2012-10-03 15:37:49 +00:00
2010-10-24 16:41:58 +00:00
end
2010-11-06 21:29:22 +00:00
2012-10-03 15:37:49 +00:00
--
-- checks all syncs for their earliest alarm,
-- but only if the global process limit is not yet reached.
2012-10-03 15:37:49 +00:00
--
if
2012-10-08 07:10:03 +00:00
not uSettings.maxProcesses or
processCount < uSettings.maxProcesses
2012-10-03 15:37:49 +00:00
then
for _, s in Syncs.iwalk( ) do
checkAlarm( s:getAlarm ( ))
end
else
2012-10-03 15:37:49 +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
2012-10-03 15:37:49 +00:00
checkAlarm( StatusFile.getAlarm( ) )
2010-11-30 23:14:17 +00:00
-- checks for an userAlarm
2012-10-03 15:37:49 +00:00
checkAlarm( UserAlarms.getAlarm( ) )
log(
'Alarm',
'runner.getAlarm returns: ',
alarm
)
2010-11-06 10:10:57 +00:00
2010-11-05 18:20:33 +00:00
return alarm
2012-10-03 15:37:49 +00:00
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
2012-10-03 15:37:49 +00:00
--
-- Called when an file system monitor events arrive
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
--
2012-10-03 15:37:49 +00:00
-- Collector for every child process that finished in startup phase
2010-10-21 12:37:27 +00:00
--
2012-10-03 15:37:49 +00:00
function runner.collector(
pid, -- pid of the child process
exitcode -- exitcode of the child process
)
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')
2012-10-03 15:37:49 +00:00
terminate( -1 )
2010-10-20 13:01:26 +00:00
end
2012-10-03 15:37:49 +00:00
2010-10-21 12:37:27 +00:00
return 0
2010-10-20 10:25:34 +00:00
end
2012-10-03 15:37:49 +00:00
--
2010-11-10 15:57:37 +00:00
-- Called by core when an overflow happened.
--
2012-10-03 15:37:49 +00:00
function runner.overflow( )
log(
'Normal',
'--- OVERFLOW in event queue ---'
)
2012-01-30 14:01:18 +00:00
lsyncdStatus = 'fade'
2012-10-03 15:37:49 +00:00
2010-11-14 09:11:09 +00:00
end
2012-10-03 15:37:49 +00:00
--
2010-11-14 09:11:09 +00:00
-- Called by core on a hup signal.
--
2012-10-03 15:37:49 +00:00
function runner.hup( )
log(
'Normal',
'--- HUP signal, resetting ---'
)
2012-01-30 14:01:18 +00:00
lsyncdStatus = 'fade'
2012-10-03 15:37:49 +00:00
2010-11-14 09:11:09 +00:00
end
2012-10-03 15:37:49 +00:00
--
2010-11-14 09:11:09 +00:00
-- Called by core on a term signal.
--
2012-10-03 15:37:49 +00:00
function runner.term( )
log(
'Normal',
'--- TERM signal, fading ---'
)
2012-01-30 14:01:18 +00:00
lsyncdStatus = 'fade'
2012-10-03 15:37:49 +00:00
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
--============================================================================
2012-10-03 15:37:49 +00:00
-- Lsyncd runner's user interface
2010-10-25 17:38:57 +00:00
--============================================================================
2010-10-17 15:24:55 +00:00
2012-10-03 15:37:49 +00:00
--
2010-11-05 15:18:01 +00:00
-- Main utility to create new observations.
--
2012-10-03 15:37:49 +00:00
-- Returns an Inlet to that sync.
--
function sync( opts )
2012-01-30 14:01:18 +00:00
if lsyncdStatus ~= 'init' then
2012-10-03 15:37:49 +00:00
error(
'Sync can only be created during initialization.',
2
)
2010-11-05 15:18:01 +00:00
end
2012-10-03 15:37:49 +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
--
2012-10-03 15:37:49 +00:00
-- Spawns a new child process.
2010-11-07 01:06:08 +00:00
--
2012-10-03 15:37:49 +00:00
function spawn(
agent, -- the reason why a process is spawned.
-- a delay or delay list for a sync
-- it will mark the related files as blocked.
binary, -- binary to call
... -- arguments
)
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
2012-10-03 15:37:49 +00:00
log(
'Normal',
'ignored process spawning while fading'
)
2012-01-30 14:01:18 +00:00
return
2010-11-14 09:11:09 +00:00
end
2012-10-03 15:37:49 +00:00
if type( binary ) ~= 'string' then
error(
'calling spawn(agent, binary, ...): binary is not a string',
2
)
end
2012-10-03 15:37:49 +00:00
local dol = InletFactory.getDelayOrList( agent )
2012-10-03 15:37:49 +00:00
if not dol then
error(
'spawning with an unknown agent',
2
)
end
--
-- checks if a spawn is called on an already active event
--
if dol.status then
2012-10-03 15:37:49 +00:00
-- is an event
if dol.status ~= 'wait' then
2012-01-30 14:01:18 +00:00
error('spawn() called on an non-waiting event', 2)
end
2012-10-03 15:37:49 +00:00
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
2012-10-03 15:37:49 +00:00
end
2012-10-03 15:37:49 +00:00
--
-- tries to spawn the process
--
local pid = lsyncd.exec( binary, ... )
if pid and pid > 0 then
2012-10-03 15:37:49 +00:00
processCount = processCount + 1
2012-10-03 15:37:49 +00:00
if
2012-10-08 07:10:03 +00:00
uSettings.maxProcesses and
processCount > uSettings.maxProcesses
2012-10-03 15:37:49 +00:00
then
error( 'Spawned too much processes!' )
end
2012-10-03 15:37:49 +00:00
local sync = InletFactory.getSync( agent )
2010-11-30 22:56:34 +00:00
-- delay or list
if dol.status then
2012-10-03 15:37:49 +00:00
2010-11-30 22:56:34 +00:00
-- is a delay
2012-01-30 14:01:18 +00:00
dol.status = 'active'
2012-10-03 15:37:49 +00:00
sync.processes[ pid ] = dol
2012-02-15 15:47:18 +00:00
else
2012-10-03 15:37:49 +00:00
2010-11-30 22:56:34 +00:00
-- is a list
2012-10-03 15:37:49 +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
2012-10-03 15:37:49 +00:00
sync.processes[ pid ] = dol
2010-11-12 18:52:43 +00:00
end
2012-10-03 15:37:49 +00:00
2010-11-07 01:06:08 +00:00
end
2010-11-05 13:34:02 +00:00
end
2012-10-03 15:37:49 +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
--
2012-10-03 15:37:49 +00:00
function spawnShell(
agent, -- the delay(list) to spawn the command for
command, -- the shell command
... -- additonal arguments
)
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
--
2012-10-03 15:37:49 +00:00
function observefd(
fd, -- file descriptor
ready, -- called when fd is ready to be read
writey -- called when fd is ready to be written
)
return lsyncd.observe_fd(
fd,
ready,
writey
)
2010-12-01 12:19:17 +00:00
end
--
2012-10-03 15:37:49 +00:00
-- Stops observeing a filedescriptor
--
function nonobservefd(
fd -- file descriptor
)
return lsyncd.nonobserve_fd( fd )
2010-12-01 12:19:17 +00:00
end
2012-10-03 15:37:49 +00:00
--
2010-11-30 23:14:17 +00:00
-- Calls func at timestamp.
2012-10-03 15:37:49 +00:00
--
2010-11-30 23:14:17 +00:00
-- Use now() to receive current timestamp
2012-10-03 15:37:49 +00:00
-- add seconds with '+' to it
2010-11-30 23:14:17 +00:00
--
alarm = UserAlarms.alarm
2012-10-03 15:37:49 +00:00
--
2010-11-10 11:23:26 +00:00
-- Comfort routine also for user.
-- Returns true if 'String' starts with 'Start'
--
2012-10-03 15:37:49 +00:00
function string.starts( String, Start )
return string.sub( String, 1, #Start )==Start
2010-11-10 11:23:26 +00:00
end
2012-10-03 15:37:49 +00:00
--
2010-11-10 11:23:26 +00:00
-- Comfort routine also for user.
-- Returns true if 'String' ends with 'End'
--
2012-10-03 15:37:49 +00:00
function string.ends( String, End )
return End == '' or string.sub( String, -#End ) == End
2010-11-10 11:23:26 +00:00
end
--
2012-10-08 07:10:03 +00:00
-- The Lsyncd 2.1 settings call
2012-10-03 15:37:49 +00:00
--
2012-10-08 07:10:03 +00:00
function settings( a1 )
-- if a1 is a string this is a get operation
2012-11-23 13:03:52 +00:00
if type( a1 ) == 'string' then
return uSettings[ a1 ]
end
-- if its a table it sets all the value of the bale
2012-10-08 07:10:03 +00:00
for k, v in pairs( a1 ) do
if type( k ) ~= 'number' then
uSettings[ k ] = v
else
uSettings[ v ] = true
end
end
end
settingsSafe = settings
2012-10-03 15:37:49 +00:00
--
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