lsyncd/lsyncd.lua

1587 lines
36 KiB
Lua
Raw Normal View History

2010-10-25 17:38:57 +00:00
--============================================================================
2010-10-19 10:20:27 +00:00
-- lsyncd.lua Live (Mirror) Syncing Demon
--
-- License: GPLv2 (see COPYING) or any later version
--
-- Authors: Axel Kittenberger <axkibe@gmail.com>
--
-- This is the "runner" part of lsyncd. It containts all its high-level logic.
-- It works closely together with the lsyncd core in lsyncd.c. This means it
-- cannot be runned directly from the standard lua interpreter.
2010-10-25 17:38:57 +00:00
--============================================================================
2010-10-16 18:21:01 +00:00
2010-11-06 16:54:45 +00:00
-----
2010-10-19 10:20:27 +00:00
-- A security measurement.
2010-10-18 17:09:59 +00:00
-- Core will exit if version ids mismatch.
2010-10-25 14:55:40 +00:00
--
2010-10-26 11:26:57 +00:00
if lsyncd_version then
2010-10-22 08:37:15 +00:00
-- checks if the runner is being loaded twice
2010-11-04 13:43:57 +00:00
lsyncd.log("Error",
"You cannot use the lsyncd runner as configuration file!")
lsyncd.terminate(-1) -- ERRNO
2010-10-19 21:56:00 +00:00
end
2010-10-27 11:31:18 +00:00
lsyncd_version = "2.0beta1"
2010-10-18 17:09:59 +00:00
2010-11-05 18:20:33 +00:00
-----
-- Hides the core interface from user scripts
--
_l = lsyncd
lsyncd = nil
local lsyncd = _l
_l = nil
2010-11-06 16:54:45 +00:00
-----
2010-10-21 12:37:27 +00:00
-- Shortcuts (which user is supposed to be able to use them as well)
2010-10-22 12:58:57 +00:00
--
2010-10-22 10:35:26 +00:00
log = lsyncd.log
2010-10-27 19:34:56 +00:00
terminate = lsyncd.terminate
2010-10-20 18:33:17 +00:00
2010-10-25 17:38:57 +00:00
--============================================================================
2010-11-08 12:14:10 +00:00
-- Lsyncd Prototypes
2010-10-25 17:38:57 +00:00
--============================================================================
2010-10-25 14:55:40 +00:00
2010-10-25 17:38:57 +00:00
-----
2010-11-02 13:18:34 +00:00
-- The array objects are tables that error if accessed with a non-number.
2010-10-25 14:55:40 +00:00
--
2010-11-02 13:18:34 +00:00
local Array = (function()
-- Metatable
local mt = {}
-- on accessing a nil index.
mt.__index = function(t, k)
2010-10-25 17:38:57 +00:00
if type(k) ~= "number" then
2010-11-02 13:18:34 +00:00
error("Key '"..k.."' invalid for Array", 2)
2010-10-25 14:55:40 +00:00
end
2010-10-25 17:38:57 +00:00
return rawget(t, k)
2010-11-02 13:18:34 +00:00
end
-- on assigning a new index.
mt.__newindex = function(t, k, v)
2010-10-25 17:38:57 +00:00
if type(k) ~= "number" then
2010-11-02 13:18:34 +00:00
error("Key '"..k.."' invalid for Array", 2)
2010-10-25 17:38:57 +00:00
end
rawset(t, k, v)
2010-10-25 14:55:40 +00:00
end
2010-11-02 13:18:34 +00:00
-- creates a new object
2010-11-02 17:07:42 +00:00
local function new()
2010-11-02 13:18:34 +00:00
local o = {}
setmetatable(o, mt)
return o
end
-- objects public interface
return {new = new}
end)()
2010-10-25 14:55:40 +00:00
2010-10-25 17:38:57 +00:00
-----
2010-11-02 13:18:34 +00:00
-- The count array objects are tables that error if accessed with a non-number.
-- Additionally they maintain their length as "size" attribute.
2010-10-25 17:38:57 +00:00
-- Lua's # operator does not work on tables which key values are not
-- strictly linear.
--
2010-11-02 13:18:34 +00:00
local CountArray = (function()
-- Metatable
local mt = {}
2010-11-03 11:37:25 +00:00
-----
2010-11-02 13:18:34 +00:00
-- key to native table
local k_nt = {}
2010-11-03 11:37:25 +00:00
-----
2010-11-02 13:18:34 +00:00
-- on accessing a nil index.
mt.__index = function(t, k)
2010-10-25 17:38:57 +00:00
if type(k) ~= "number" then
2010-11-02 13:18:34 +00:00
error("Key '"..k.."' invalid for CountArray", 2)
2010-10-25 17:38:57 +00:00
end
2010-11-02 13:18:34 +00:00
return t[k_nt][k]
end
2010-10-25 17:38:57 +00:00
2010-11-03 11:37:25 +00:00
-----
2010-11-02 13:18:34 +00:00
-- on assigning a new index.
mt.__newindex = function(t, k, v)
2010-10-25 17:38:57 +00:00
if type(k) ~= "number" then
2010-11-02 13:18:34 +00:00
error("Key '"..k.."' invalid for CountArray", 2)
2010-10-25 17:38:57 +00:00
end
2010-11-02 13:18:34 +00:00
-- value before
local vb = t[k_nt][k]
2010-10-25 17:38:57 +00:00
if v and not vb then
2010-11-03 11:37:25 +00:00
t._size = t._size + 1
2010-10-25 17:38:57 +00:00
elseif not v and vb then
2010-11-03 11:37:25 +00:00
t._size = t._size - 1
2010-10-25 17:38:57 +00:00
end
2010-11-02 13:18:34 +00:00
t[k_nt][k] = v
end
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-06 16:54:45 +00:00
-----
2010-11-03 11:37:25 +00:00
-- returns the count
2010-11-09 19:15:41 +00:00
--
2010-11-03 11:37:25 +00:00
local function size(self)
return self._size
end
2010-11-06 16:54:45 +00:00
-----
2010-11-02 13:18:34 +00:00
-- creates a new count array
2010-11-09 19:15:41 +00:00
--
2010-11-02 17:07:42 +00:00
local function new()
2010-11-02 13:18:34 +00:00
-- k_nt is native table, private for this object.
2010-11-09 19:15:41 +00:00
local o = {_size = 0, walk = walk, size = size, [k_nt] = {} }
2010-11-02 13:18:34 +00:00
setmetatable(o, mt)
return o
2010-10-25 14:55:40 +00:00
end
2010-11-02 13:18:34 +00:00
2010-11-09 19:15:41 +00:00
-----
-- public interface
--
2010-11-02 13:18:34 +00:00
return {new = new}
end)()
2010-10-25 14:55:40 +00:00
2010-10-31 22:25:34 +00:00
----
2010-11-01 16:38:39 +00:00
-- Locks globals,
-- no more globals can be created
--
2010-11-06 18:26:59 +00:00
local function lockGlobals()
2010-11-01 16:38:39 +00:00
local t = _G
2010-10-31 22:25:34 +00:00
local mt = getmetatable(t) or {}
2010-11-01 19:57:53 +00:00
mt.__index = function(t, k)
if (k~="_" and string.sub(k, 1, 2) ~= "__") then
2010-11-05 13:34:02 +00:00
error("Access of non-existing global '"..k.."'", 2)
2010-11-01 19:57:53 +00:00
else
rawget(t, k)
end
end
2010-11-01 16:38:39 +00:00
mt.__newindex = function(t, k, v)
if (k~="_" and string.sub(k, 1, 2) ~= "__") then
2010-11-08 12:14:10 +00:00
error("Lsyncd does not allow GLOBALS to be created on the fly. " ..
2010-11-01 16:38:39 +00:00
"Declare '" ..k.."' local or declare global on load.", 2)
else
rawset(t, k, v)
end
end
2010-10-31 22:25:34 +00:00
setmetatable(t, mt)
end
2010-11-02 14:11:26 +00:00
-----
2010-11-10 22:03:02 +00:00
-- Holds information about a delayed event of one Sync.
2010-11-04 13:43:57 +00:00
--
2010-11-02 14:11:26 +00:00
local Delay = (function()
-----
-- Creates a new delay.
--
2010-11-11 19:52:20 +00:00
-- @params see below
--
2010-11-10 09:49:44 +00:00
local function new(etype, 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
-----
-- Latest point in time this should be catered for.
-- This value is in kernel ticks, return of the C's
-- 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
-- to the syncs root.
-- for the directories it contains a trailing slash
--
2010-11-06 17:40:12 +00:00
path = path,
2010-11-10 22:03:02 +00:00
------
-- only not nil for 'Move's.
-- path and file/dirname of a move destination.
--
2010-11-10 09:49:44 +00:00
path2 = path2,
2010-11-10 22:03:02 +00:00
------
2010-11-11 15:17:22 +00:00
-- Status of the event. Valid stati are:
-- 'wait' ... the event is ready to be handled.
-- 'active' ... there is process running catering for this event.
-- 'blocked' ... this event waits for another to be handled first.
-- 'done' ... event has been collected. This should never be
-- visible as all references should be droped on
-- collection, nevertheless seperat status for
-- insurrance.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
status = "wait",
2010-11-02 14:11:26 +00:00
}
return o
end
2010-10-31 22:25:34 +00:00
2010-11-02 14:11:26 +00:00
return {new = new}
end)()
2010-11-08 12:14:10 +00:00
-----
-- User interface to grap events
--
2010-11-10 22:03:02 +00:00
-- InletControl is the runners part to control the interface
2010-11-08 12:14:10 +00:00
-- hidden from the user.
--
local Inlet, InletControl = (function()
-- lua runner controlled variables
local sync
2010-11-10 11:23:26 +00:00
-- key variables for delays hidden from user
2010-11-08 12:14:10 +00:00
local delayKey = {}
2010-11-10 11:23:26 +00:00
-- nil for non move events
-- 0 for move source events
-- 1 for move desination events
local moveDestKey = {}
2010-11-08 12:14:10 +00:00
-----
-- removes the trailing slash from a path
local function cutSlash(path)
if string.byte(path, -1) == 47 then
return string.sub(path, 1, -2)
else
return path
end
end
2010-11-10 11:23:26 +00:00
local function getPath(event)
if not event[moveDestKey] then
return event[delayKey].path
else
return event[delayKey].path2
end
end
2010-11-08 12:14:10 +00:00
-----
2010-11-10 22:03:02 +00:00
-- Interface for userscripts to get event fields..
--
2010-11-08 12:14:10 +00:00
local eventFields = {
2010-11-10 22:03:02 +00:00
-----
-- Returns a copy of the configuration as called by sync.
-- But including all inherited data and default values.
--
-- TODO give user a readonly version.
--
2010-11-08 12:14:10 +00:00
config = function(event)
return event[delayKey].sync.config
end,
-----
-- Returns the type of the event.
-- Can be:
2010-11-10 22:03:02 +00:00
-- "Attrib",
-- "Create",
-- "Delete",
-- "Modify",
2010-11-08 12:14:10 +00:00
-- "Move"
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
etype = function(event)
return event[delayKey].etype
end,
2010-11-11 15:17:22 +00:00
-----
-- Status
status = function(event)
return event[delayKey].status
end,
2010-11-08 12:14:10 +00:00
-----
-- Returns true if event relates to a directory.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
isdir = function(event)
2010-11-10 11:23:26 +00:00
return string.byte(getPath(event), -1) == 47
2010-11-08 12:14:10 +00:00
end,
-----
-- Returns the name of the file/dir.
-- Includes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-10 11:23:26 +00:00
name = function(event)
return string.match(getPath(event), "[^/]+/?$")
2010-11-08 12:14:10 +00:00
end,
-----
-- Returns the name of the file/dir.
-- Excludes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-10 11:23:26 +00:00
basename = function(event)
return string.match(getPath(event), "([^/]+)/?$")
2010-11-08 12:14:10 +00:00
end,
-----
-- Returns the file/dir relative to watch root
-- Includes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
path = function(event)
2010-11-10 11:23:26 +00:00
return getPath(event)
2010-11-08 12:14:10 +00:00
end,
-----
-- Returns the file/dir relativ to watch root
-- Excludes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
pathname = function(event)
2010-11-10 11:23:26 +00:00
return cutSlash(getPath(event))
2010-11-08 12:14:10 +00:00
end,
------
-- Returns the absolute path of the watch root.
-- All symlinks will have been resolved.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
source = function(event)
return sync.source
end,
------
-- Returns the absolute path of the file/dir.
-- Includes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
sourcePath = function(event)
2010-11-10 11:23:26 +00:00
return sync.source ..getPath(event)
2010-11-08 12:14:10 +00:00
end,
------
-- Returns the absolute path of the file/dir.
-- Excludes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
sourcePathname = function(event)
2010-11-10 11:23:26 +00:00
return sync.source .. cutSlash(getPath(event))
2010-11-08 12:14:10 +00:00
end,
------
-- Returns the target.
-- Just for user comfort, for most case
-- (Actually except of here, the lsyncd.runner itself
-- does not care event about the existance of "target",
-- this is completly up to the action scripts.)
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
target = function(event)
return sync.config.target
end,
------
-- Returns the relative dir/file appended to the target.
-- Includes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
targetPath = function(event)
2010-11-10 11:23:26 +00:00
return sync.config.target .. getPath(event)
2010-11-08 12:14:10 +00:00
end,
------
-- Returns the relative dir/file appended to the target.
-- Excludes a trailing slash for dirs.
2010-11-10 22:03:02 +00:00
--
2010-11-08 12:14:10 +00:00
targetPathname = function(event)
2010-11-10 11:23:26 +00:00
return sync.config.target .. cutSlash(getPath(event))
2010-11-08 12:14:10 +00:00
end,
}
-----
2010-11-10 22:03:02 +00:00
-- Retrievs event fields for the user.
--
2010-11-08 12:14:10 +00:00
local eventMeta = {
__index = function(t, k)
local f = eventFields[k]
if not f then
2010-11-10 11:23:26 +00:00
if k == moveDestKey then
-- possibly undefined
return nil
end
2010-11-08 12:14:10 +00:00
error("event does not have field '"..k.."'", 2)
end
return f(t)
end
}
-----
-- Encapsulates a delay to an event for the user
--
-- TODO this hidden key technique can be circumvented with
-- pairs(), use a weak table as referencer instead.
--
local function toEvent(delay)
2010-11-10 12:59:51 +00:00
if delay.etype ~= "Move" then
if not delay.event then
2010-11-10 11:23:26 +00:00
delay.event = {}
setmetatable(delay.event, eventMeta)
delay.event[delayKey] = delay
end
2010-11-10 12:59:51 +00:00
return delay.event
else
-- moves have 2 events - origin and destination
if not delay.event then
2010-11-10 11:23:26 +00:00
delay.event = {}
delay.event2 = {}
2010-11-10 12:59:51 +00:00
2010-11-10 11:23:26 +00:00
setmetatable(delay.event, eventMeta)
setmetatable(delay.event2, eventMeta)
2010-11-10 12:59:51 +00:00
2010-11-10 11:23:26 +00:00
delay.event[delayKey] = delay
delay.event2[delayKey] = delay
2010-11-10 12:59:51 +00:00
delay.event[moveDestKey] = false
delay.event2[moveDestKey] = true
end
return delay.event, delay.event2
2010-11-08 12:14:10 +00:00
end
end
-----
-- Creates a blanketEvent that blocks everything
-- and is blocked by everything.
--
2010-11-10 09:49:44 +00:00
local function createBlanketEvent()
2010-11-08 12:14:10 +00:00
return toEvent(sync:addBlanketDelay())
end
2010-11-11 15:17:22 +00:00
-----
-- Cancels a waiting event.
--
local function cancelEvent(event)
local delay = event[delayKey]
2010-11-11 19:52:20 +00:00
if delay.status ~= "wait" then
2010-11-11 15:17:22 +00:00
log("Error", "Ignored try to cancel a non-waiting event of type ",
event.etype)
return
end
delay.sync:removeDelay(delay)
end
2010-11-08 12:14:10 +00:00
-----
2010-11-10 22:03:02 +00:00
-- Gets the next not blocked event from queue.
2010-11-08 12:14:10 +00:00
--
local function getEvent()
return toEvent(sync:getNextDelay(lysncd.now()))
end
-----
-- Returns the configuration table specified by sync{}
--
local function getConfig()
-- TODO give a readonly handler only.
return sync.config
end
-----
-- Interface for lsyncd runner to control what
-- the inlet will present the user.
--
2010-11-10 09:49:44 +00:00
local function setSync(setSync)
2010-11-08 12:14:10 +00:00
sync = setSync
end
-----
-- Return the inner config
-- not to be called from user
local function getInterior(event)
return sync, event[delayKey]
end
-----
-- public interface.
-- this one is split, one for user one for runner.
return {
getEvent = getEvent,
getConfig = getConfig,
2010-11-10 09:49:44 +00:00
createBlanketEvent = createBlanketEvent,
2010-11-08 12:14:10 +00:00
}, {
2010-11-10 09:49:44 +00:00
setSync = setSync,
getInterior = getInterior, -- TODO <- remove
toEvent = toEvent,
2010-11-08 12:14:10 +00:00
}
end)()
2010-11-02 14:11:26 +00:00
-----
2010-11-03 11:37:25 +00:00
-- Holds information about one observed directory inclusively subdirs.
2010-11-02 14:11:26 +00:00
--
2010-11-06 10:10:00 +00:00
local Sync = (function()
2010-11-08 12:14:10 +00:00
2010-11-06 18:26:59 +00:00
-----
2010-11-10 22:03:02 +00:00
-- Syncs that have no name specified by the user script
-- get an incremental default name 'Sync[X]'
2010-11-06 18:26:59 +00:00
--
local nextDefaultName = 1
2010-11-08 12:14:10 +00:00
2010-11-11 15:17:22 +00:00
-----
-- Removes a delay.
local function removeDelay(self, delay)
local found
for i, d in ipairs(self.delays) do
if d == delay then
found = true
table.remove(self.delays, i)
break
end
end
if not found then
error("Did not find a delay to be removed!")
end
end
2010-11-08 12:14:10 +00:00
-----
-- Collects a child process
--
local function collect(self, pid, exitcode)
local delay = self.processes[pid]
if not delay then
-- not a child of this sync.
return
end
if delay.status ~= "active" then
error("internal fail, collecting a non-active process")
end
2010-11-11 09:36:56 +00:00
InletControl.setSync(self)
2010-11-10 22:03:02 +00:00
2010-11-11 15:17:22 +00:00
local rc = self.config.collect(InletControl.toEvent(delay), exitcode)
-- TODO honor return codes of the collect
removeDelay(self, delay)
2010-11-10 22:03:02 +00:00
log("Delay","Finish of ",delay.etype," on ",
2010-11-10 11:23:26 +00:00
self.source,delay.path," = ",exitcode)
2010-11-08 12:14:10 +00:00
self.processes[pid] = nil
end
2010-11-06 18:26:59 +00:00
-----
-- Puts an action on the delay stack.
--
2010-11-07 09:53:39 +00:00
local function delay(self, etype, time, path, path2)
2010-11-10 09:49:44 +00:00
log("Function", "delay(", self.config.name,", ",etype,", ",path,")")
if path2 then
log("Function", "...delay(+",path2,")")
end
2010-11-06 18:26:59 +00:00
2010-11-10 09:49:44 +00:00
if etype == "Move" and not self.config.onMove then
2010-11-06 18:26:59 +00:00
-- if there is no move action defined, split a move as delete/create
2010-11-10 22:03:02 +00:00
log("Delay", "splitting Move into Delete & Create")
2010-11-06 18:26:59 +00:00
delay(self, "Delete", time, path, nil)
delay(self, "Create", time, path2, nil)
return
end
-- creates the new action
local alarm
if time and self.config.delay then
alarm = lsyncd.addtoclock(time, self.config.delay)
else
alarm = lsyncd.now()
end
2010-11-10 09:49:44 +00:00
-- new delay
local nd = Delay.new(etype, alarm, path, path2)
2010-11-10 22:03:02 +00:00
if nd.etype == "Blanket" then
-- always stack blanket events.
log("Delay", "Stacking blanket event.")
table.insert(self.delays, nd)
return
end
2010-11-10 09:49:44 +00:00
if nd.etype == "Move" then
2010-11-10 22:03:02 +00:00
log("Delay", "Stacking a move event ",path," -> ",path2)
2010-11-10 09:49:44 +00:00
table.insert(self.delays, nd)
2010-11-10 12:59:51 +00:00
return
2010-11-10 09:49:44 +00:00
end
-----
-- detects blocks and collapses by working from back til
-- front through the fifo
InletControl.setSync(self)
2010-11-10 11:23:26 +00:00
local ne = InletControl.toEvent(nd)
2010-11-10 09:49:44 +00:00
local il = #self.delays -- last delay
2010-11-10 11:23:26 +00:00
2010-11-10 09:49:44 +00:00
while il > 0 do
local od = self.delays[il]
2010-11-10 11:23:26 +00:00
-- tries to collapse identical paths
local oe, oe2 = InletControl.toEvent(od)
local ne = InletControl.toEvent(nd) -- TODO more logic on moves
2010-11-10 22:03:02 +00:00
if oe.etype == "Blanket" then
-- everything is blocked by a blanket event.
log("Delay", "Stacking ",nd.etype," upon blanket event.")
table.insert(self.delays, nd)
return
end
-- this mini loop repeats the collapse a second
-- time for move events
2010-11-10 11:23:26 +00:00
local oel = oe
while oel do
local c = self.config.collapse(oel, ne, self.config)
if c == 0 then
-- events nullificate each ether
od.etype = "None" -- TODO better remove?
2010-11-10 22:03:02 +00:00
return
2010-11-10 11:23:26 +00:00
elseif c == 1 then
2010-11-10 22:03:02 +00:00
log("Delay",nd.etype," is absored by event ",
od.etype," on ",path)
return
2010-11-10 11:23:26 +00:00
elseif c == 2 then
2010-11-10 22:03:02 +00:00
log("Delay",nd.etype," replaces event ",
od.etype," on ",path)
2010-11-10 11:23:26 +00:00
self.delays[il] = nd
2010-11-10 22:03:02 +00:00
return
2010-11-10 11:23:26 +00:00
elseif c == 3 then
2010-11-10 22:03:02 +00:00
log("Delay", "Stacking ",nd.etype," upon ",
od.etype," on ",path)
break
end
-- after first iteration check move destination
-- after second stop eitherway
2010-11-10 11:23:26 +00:00
if oel == oe2 then
oel = false
else
oel = oe2
2010-11-06 18:26:59 +00:00
end
end
2010-11-10 09:49:44 +00:00
il = il - 1
2010-11-06 18:26:59 +00:00
end
2010-11-10 11:23:26 +00:00
if il <= 0 then
2010-11-10 22:03:02 +00:00
log("Delay", "Stacking ",nd.etype," on ",path)
2010-11-10 11:23:26 +00:00
end
2010-11-10 09:49:44 +00:00
-- there was no hit on collapse or it decided to stack.
table.insert(self.delays, nd)
2010-11-06 18:26:59 +00:00
end
2010-11-06 21:29:22 +00:00
2010-11-10 22:03:02 +00:00
-----
2010-11-08 12:14:10 +00:00
-- Returns the nearest alarm for this Sync.
2010-11-06 21:29:22 +00:00
--
local function getAlarm(self)
-- first checks if more processses could be spawned
if self.processes:size() >= self.config.maxProcesses then
return nil
end
2010-11-11 19:52:20 +00:00
-- finds the nearest delay waiting to be spawned
for _, d in ipairs(self.delays) do
if d.status == "wait" then
return d.alarm
end
2010-11-06 21:29:22 +00:00
end
2010-11-11 19:52:20 +00:00
-- nothing to spawn.
return nil
2010-11-06 21:29:22 +00:00
end
2010-11-11 15:17:22 +00:00
2010-11-08 12:14:10 +00:00
-----
-- Gets the next event to be processed.
--
local function getNextDelay(self, now)
for i, d in ipairs(self.delays) do
if d.alarm ~= true and lsyncd.clockbefore(now, d.alarm) then
-- reached point in stack where delays are in future
return nil
end
if d.status == "wait" then
-- found a waiting delay
return d
end
end
end
2010-11-07 01:06:08 +00:00
-----
-- Creates new actions
--
2010-11-08 12:14:10 +00:00
local function invokeActions(self, now)
log("Function", "invokeActions('",self.config.name,"',",now,")")
2010-11-07 01:06:08 +00:00
if self.processes:size() >= self.config.maxProcesses then
2010-11-08 12:14:10 +00:00
-- no new processes
2010-11-07 01:06:08 +00:00
return
end
2010-11-08 12:14:10 +00:00
for _, d in ipairs(self.delays) do
if d.alarm ~= true and lsyncd.clockbefore(now, d.alarm) then
-- reached point in stack where delays are in future
return
end
if d.status == "wait" then
-- found a waiting delay
2010-11-10 09:49:44 +00:00
InletControl.setSync(self)
2010-11-08 12:14:10 +00:00
self.config.action(Inlet)
if self.processes:size() >= self.config.maxProcesses then
-- no further processes
return
end
end
2010-11-07 01:06:08 +00:00
end
end
2010-11-08 12:14:10 +00:00
2010-11-07 09:53:39 +00:00
------
2010-11-08 12:14:10 +00:00
-- adds and returns a blanket delay thats blocks all
-- (used in startup)
2010-11-07 09:53:39 +00:00
--
2010-11-08 12:14:10 +00:00
local function addBlanketDelay(self)
2010-11-10 22:03:02 +00:00
local newd = Delay.new("Blanket", true, "")
2010-11-08 12:14:10 +00:00
table.insert(self.delays, newd)
return newd
2010-11-07 09:53:39 +00:00
end
2010-11-06 16:54:45 +00:00
-----
2010-11-06 10:33:26 +00:00
-- Creates a new Sync
2010-11-02 14:11:26 +00:00
--
2010-11-05 15:18:01 +00:00
local function new(config)
2010-11-06 18:26:59 +00:00
local s = {
2010-11-10 09:49:44 +00:00
-- fields
2010-11-02 14:11:26 +00:00
config = config,
delays = CountArray.new(),
2010-11-05 15:18:01 +00:00
source = config.source,
2010-11-02 14:11:26 +00:00
processes = CountArray.new(),
2010-11-06 21:29:22 +00:00
-- functions
2010-11-08 12:14:10 +00:00
collect = collect,
delay = delay,
addBlanketDelay = addBlanketDelay,
getAlarm = getAlarm,
getNextDelay = getNextDelay,
invokeActions = invokeActions,
2010-11-11 15:17:22 +00:00
removeDelay = removeDelay,
2010-11-02 14:11:26 +00:00
}
2010-11-06 18:26:59 +00:00
-- provides a default name if needed
if not config.name then
config.name = "Sync" .. nextDefaultName
end
2010-11-08 12:14:10 +00:00
-- increments default nevertheless to cause less confusion
-- so name will be the n-th call to sync{}
2010-11-06 18:26:59 +00:00
nextDefaultName = nextDefaultName + 1
return s
2010-11-02 14:11:26 +00:00
end
2010-11-06 18:26:59 +00:00
-----
2010-11-02 14:11:26 +00:00
-- public interface
2010-11-08 12:14:10 +00:00
--
2010-11-02 14:11:26 +00:00
return {new = new}
end)()
2010-10-25 17:38:57 +00:00
2010-11-02 14:11:26 +00:00
-----
2010-11-06 10:10:00 +00:00
-- Syncs - a singleton
2010-11-02 14:11:26 +00:00
--
-- It maintains all configured directories to be synced.
--
2010-11-06 10:10:00 +00:00
local Syncs = (function()
2010-11-06 18:26:59 +00:00
-----
2010-11-06 10:33:26 +00:00
-- the list of all syncs
2010-11-06 18:26:59 +00:00
--
2010-11-02 14:11:26 +00:00
local list = Array.new()
2010-11-02 20:18:05 +00:00
-----
2010-11-03 11:37:25 +00:00
-- inheritly copies all non integer keys from
2010-11-02 20:18:05 +00:00
-- @cd copy destination
2010-11-03 11:37:25 +00:00
-- to
2010-11-02 20:18:05 +00:00
-- @cs copy source
2010-11-03 11:37:25 +00:00
-- all integer keys are treated as new copy sources
--
2010-11-02 20:18:05 +00:00
local function inherit(cd, cs)
2010-11-03 15:53:20 +00:00
-- first copies from source all
-- non-defined non-integer keyed values
for k, v in pairs(cs) do
if type(k) ~= "number" and not cd[k] then
cd[k] = v
end
end
2010-11-03 11:37:25 +00:00
-- first recurses into all integer keyed tables
for i, v in ipairs(cs) do
if type(v) == "table" then
inherit(cd, v)
end
2010-11-02 20:18:05 +00:00
end
end
-----
2010-11-03 11:37:25 +00:00
-- Adds a new directory to observe.
--
local function add(config)
2010-11-06 10:10:00 +00:00
-----
-- Creates a new config table and inherit all keys/values
-- from integer keyed tables
2010-11-06 18:26:59 +00:00
--
2010-11-03 15:53:20 +00:00
local uconfig = config
config = {}
inherit(config, uconfig)
2010-11-11 15:17:22 +00:00
-- at very first let the userscript 'prepare' function
-- fill out more values.
if type(config.prepare) == "function" then
-- give explicitly a writeable copy of config.
config.prepare(config)
end
if not config["source"] then
local info = debug.getinfo(3, "Sl")
log("Error", info.short_src, ":", info.currentline,
": source missing from sync.")
terminate(-1) -- ERRNO
2010-11-02 20:18:05 +00:00
end
2010-11-11 15:17:22 +00:00
2010-11-02 14:11:26 +00:00
-- absolute path of source
2010-11-10 22:03:02 +00:00
local realsrc = lsyncd.realdir(config.source)
if not realsrc then
2010-11-10 09:49:44 +00:00
log("Error", "Cannot access source directory: ",config.source)
2010-11-02 14:11:26 +00:00
terminate(-1) -- ERRNO
end
2010-11-06 10:10:00 +00:00
config._source = config.source
2010-11-10 22:03:02 +00:00
config.source = realsrc
2010-11-02 20:18:05 +00:00
2010-11-06 10:10:00 +00:00
if not config.action and not config.onAttrib and
2010-11-05 15:18:01 +00:00
not config.onCreate and not config.onModify and
not config.onDelete and not config.onMove
2010-11-02 20:18:05 +00:00
then
2010-11-05 15:18:01 +00:00
local info = debug.getinfo(3, "Sl")
2010-11-02 21:04:01 +00:00
log("Error", info.short_src, ":", info.currentline,
2010-11-02 20:18:05 +00:00
": no actions specified, use e.g. 'config=default.rsync'.")
terminate(-1) -- ERRNO
end
-- loads a default value for an option if not existent
2010-11-10 12:59:51 +00:00
local defaultValues =
2010-11-11 15:17:22 +00:00
{'action', 'collapse', 'collapseTable',
'collect', 'maxProcesses', 'init'
}
2010-11-10 12:59:51 +00:00
for _, dn in pairs(defaultValues) do
2010-11-10 11:23:26 +00:00
if config[dn] == nil then
2010-11-10 12:59:51 +00:00
config[dn] = settings[dn] or default[dn]
2010-11-02 20:18:05 +00:00
end
end
2010-11-02 14:11:26 +00:00
2010-11-10 11:23:26 +00:00
--- creates the new sync
2010-11-06 10:10:00 +00:00
local s = Sync.new(config)
table.insert(list, s)
2010-11-02 14:11:26 +00:00
end
2010-11-06 18:26:59 +00:00
-----
2010-11-06 10:33:26 +00:00
-- allows to walk through all syncs
2010-11-06 18:26:59 +00:00
--
2010-11-02 17:07:42 +00:00
local function iwalk()
2010-11-02 14:11:26 +00:00
return ipairs(list)
end
2010-11-06 18:26:59 +00:00
-----
2010-11-06 10:33:26 +00:00
-- returns the number of syncs
2010-11-06 18:26:59 +00:00
--
2010-11-02 14:11:26 +00:00
local size = function()
return #list
end
-- public interface
return {add = add, iwalk = iwalk, size = size}
end)()
2010-10-25 17:38:57 +00:00
2010-11-11 18:34:44 +00:00
2010-10-17 15:24:55 +00:00
-----
2010-11-03 11:37:25 +00:00
-- Interface to inotify, watches recursively subdirs and
-- sends events.
2010-10-28 17:56:33 +00:00
--
2010-11-03 11:37:25 +00:00
-- All inotify specific implementation should be enclosed here.
-- So lsyncd can work with other notifications mechanisms just
-- by changing this.
2010-10-21 12:37:27 +00:00
--
2010-11-03 11:37:25 +00:00
local Inotifies = (function()
-----
-- A list indexed by inotifies watch descriptor.
2010-11-06 10:33:26 +00:00
-- Contains a list of all syncs observing this directory
2010-11-03 11:37:25 +00:00
-- (directly or by recurse)
local wdlist = CountArray.new()
2010-10-17 15:24:55 +00:00
2010-11-09 19:15:41 +00:00
-----
-- A list indexed by sync's containing a list of all paths
-- watches by this sync pointing to the watch descriptor.
local syncpaths = {}
2010-11-03 11:37:25 +00:00
-----
-- Adds watches for a directory including all subdirectories.
--
2010-11-05 18:04:29 +00:00
-- @param root+path directory to observe
-- @param recurse true if recursing into subdirs or
-- the relative path to root for recursed inotifies
2010-11-06 10:33:26 +00:00
-- @param sync link to the observer to be notified.
2010-11-05 18:04:29 +00:00
-- Note: Inotifies should handle this opaquely
2010-11-06 10:33:26 +00:00
local function add(root, path, recurse, sync)
2010-11-05 18:04:29 +00:00
log("Function",
2010-11-06 10:33:26 +00:00
"Inotifies.add(",root,", ",path,", ",recurse,", ",sync,")")
2010-11-05 18:04:29 +00:00
-- registers watch
2010-11-09 19:15:41 +00:00
local wd = lsyncd.inotifyadd(root .. path);
2010-11-03 11:37:25 +00:00
if wd < 0 then
2010-11-05 18:04:29 +00:00
log("Error","Failure adding watch ",dir," -> ignored ")
2010-11-03 11:37:25 +00:00
return
end
2010-10-22 08:34:41 +00:00
2010-11-05 18:04:29 +00:00
if not wdlist[wd] then
wdlist[wd] = Array.new()
2010-11-03 11:37:25 +00:00
end
2010-11-05 18:04:29 +00:00
table.insert(wdlist[wd], {
root = root,
path = path,
2010-11-09 19:15:41 +00:00
recurse = recurse,
2010-11-06 10:33:26 +00:00
sync = sync
2010-11-05 18:04:29 +00:00
})
2010-11-09 19:15:41 +00:00
-- create an entry for receival of with sync/path keys
local sp = syncpaths[sync]
if not sp then
sp = {}
syncpaths[sync] = sp
end
sp[path] = wd
2010-11-03 11:37:25 +00:00
-- registers and adds watches for all subdirectories
if recurse then
2010-11-06 15:08:17 +00:00
local subdirs = lsyncd.subdirs(root .. path)
2010-11-03 11:37:25 +00:00
for _, dirname in ipairs(subdirs) do
2010-11-06 10:33:26 +00:00
add(root, path..dirname.."/", true, sync)
2010-11-03 11:37:25 +00:00
end
end
end
2010-10-25 14:55:40 +00:00
2010-11-09 19:15:41 +00:00
-----
-- Removes one event receiver from a directory.
--
2010-11-11 18:34:44 +00:00
local function removeSync(sync, path)
2010-11-09 19:15:41 +00:00
local sp = syncpaths[sync]
if not sp then
2010-11-11 15:17:22 +00:00
error("internal fail, removeSync, nonexisting sync: ")
2010-11-09 19:15:41 +00:00
end
local wd = sp[path]
if not wd then
2010-11-11 15:17:22 +00:00
error("internal fail, removeSync, nonexisting wd.")
2010-11-09 19:15:41 +00:00
end
local ilist = wdlist[wd]
if not ilist then
2010-11-11 15:17:22 +00:00
error("internal fail, removeSync, nonexisting ilist.")
2010-11-09 19:15:41 +00:00
end
-- TODO optimize for 1 entry only case
local i, found
for i, v in ipairs(ilist) do
if v.sync == sync then
found = true
break
end
end
if not found then
2010-11-11 15:17:22 +00:00
error("internal fail, removeSync, nonexisiting i.")
2010-11-09 19:15:41 +00:00
end
table.remove(ilist, i)
if #ilist == 0 then
wdlist[wd] = nil
lsyncd.inotifyrm(wd)
end
sp[path] = nil
end
2010-11-03 11:37:25 +00:00
-----
-- Called when an event has occured.
--
2010-11-07 09:53:39 +00:00
-- @param etype "Attrib", "Mofify", "Create", "Delete", "Move")
2010-11-10 22:03:02 +00:00
-- @param wd watch descriptor (matches lsyncd.inotifyadd())
2010-11-03 11:37:25 +00:00
-- @param isdir true if filename is a directory
-- @param time time of event
-- @param filename string filename without path
-- @param filename2
--
2010-11-11 18:34:44 +00:00
local function event(etype, wd, isdir, time, filename, filename2)
2010-11-03 11:37:25 +00:00
local ftype;
if isdir then
ftype = "directory"
2010-11-05 13:34:02 +00:00
filename = filename .. "/"
if filename2 then
filename2 = filename2 .. "/"
end
2010-11-03 11:37:25 +00:00
end
if filename2 then
2010-11-07 09:53:39 +00:00
log("Inotify", "got event ", etype, " ", filename,
2010-11-03 11:37:25 +00:00
" to ", filename2)
else
2010-11-07 09:53:39 +00:00
log("Inotify", "got event ", etype, " ", filename)
2010-11-03 11:37:25 +00:00
end
2010-10-22 08:34:41 +00:00
2010-11-03 11:37:25 +00:00
local ilist = wdlist[wd]
-- looks up the watch descriptor id
if not ilist then
-- this is normal in case of deleted subdirs
2010-11-05 13:34:02 +00:00
log("Inotify", "event belongs to unknown watch descriptor.")
2010-11-03 11:37:25 +00:00
return
end
-- works through all observers interested in this directory
for _, inotify in ipairs(ilist) do
2010-11-06 17:40:12 +00:00
local path = inotify.path .. filename
local path2
2010-11-03 11:37:25 +00:00
if filename2 then
2010-11-09 19:15:41 +00:00
path2 = inotify.path .. filename2
2010-11-03 11:37:25 +00:00
end
2010-11-07 09:53:39 +00:00
inotify.sync:delay(etype, time, path, path2)
2010-11-04 13:43:57 +00:00
-- adds subdirs for new directories
2010-11-10 11:23:26 +00:00
if isdir and inotify.recurse then
if etype == "Create" then
2010-11-06 17:40:12 +00:00
add(inotify.root, path, true, inotify.sync)
2010-11-07 09:53:39 +00:00
elseif etype == "Delete" then
2010-11-09 19:15:41 +00:00
removeSync(inotify.sync, path)
2010-11-10 11:23:26 +00:00
elseif etype == "Move" then
2010-11-11 15:17:22 +00:00
removeSync(inotify.sync, path)
2010-11-10 11:23:26 +00:00
add(inotify.root, path2, true, inotify.sync)
2010-11-03 11:37:25 +00:00
end
end
end
2010-10-17 15:24:55 +00:00
end
2010-11-03 11:37:25 +00:00
-----
-- Writes a status report about inotifies to a filedescriptor
--
2010-11-10 12:59:51 +00:00
local function statusReport(f)
2010-11-05 18:04:29 +00:00
f:write("Watching ",wdlist:size()," directories\n")
2010-11-09 19:15:41 +00:00
for wd, v in wdlist:walk() do
2010-11-05 18:04:29 +00:00
f:write(" ",wd,": ")
local sep = ""
2010-11-03 11:37:25 +00:00
for _, v in ipairs(v) do
2010-11-05 18:04:29 +00:00
f:write(v.root,"/",v.path or "",sep)
sep = ", "
2010-11-03 11:37:25 +00:00
end
2010-11-05 18:04:29 +00:00
f:write("\n")
2010-11-03 11:37:25 +00:00
end
2010-10-17 15:24:55 +00:00
end
2010-10-22 12:58:57 +00:00
2010-11-03 11:37:25 +00:00
-----
-- Returns the number of directories watched in total.
local function size()
return wdlist:size()
2010-10-22 12:58:57 +00:00
end
2010-10-16 18:21:01 +00:00
2010-11-03 11:37:25 +00:00
-- public interface
2010-11-04 13:43:57 +00:00
return {
add = add,
size = size,
event = event,
2010-11-10 12:59:51 +00:00
statusReport = statusReport
2010-11-04 13:43:57 +00:00
}
2010-11-03 11:37:25 +00:00
end)()
2010-10-23 12:36:55 +00:00
2010-10-28 17:56:33 +00:00
----
2010-11-06 10:10:57 +00:00
-- Writes a status report file at most every [statusintervall] seconds.
2010-10-28 17:56:33 +00:00
--
2010-11-06 10:10:57 +00:00
--
local StatusFile = (function()
-----
-- Timestamp when the status file has been written.
local lastWritten = false
-----
-- Timestamp when a statusfile should be written
local alarm = false
-----
-- Returns when the statusfile should be written
--
local function getAlarm()
return alarm
end
-----
-- Called to check if to write a status file.
--
local function write(now)
log("Function", "write(", now, ")")
-- some logic to not write too often
if settings.statusIntervall > 0 then
-- already waiting
2010-11-06 17:40:12 +00:00
if alarm and lsyncd.clockbefore(now, alarm) then
2010-11-06 10:33:26 +00:00
log("Statusfile", "waiting(",now," < ",alarm,")")
2010-11-06 10:10:57 +00:00
return
end
2010-11-06 10:33:26 +00:00
-- determines when a next write will be possible
2010-11-06 10:10:57 +00:00
if not alarm then
local nextWrite = lastWritten and
2010-11-06 15:08:17 +00:00
lsyncd.addtoclock(now, settings.statusIntervall)
2010-11-06 17:40:12 +00:00
if nextWrite and lsyncd.clockbefore(now, nextWrite) then
2010-11-06 10:33:26 +00:00
log("Statusfile", "setting alarm: ", nextWrite)
2010-11-06 10:10:57 +00:00
alarm = nextWrite
return
end
end
lastWritten = now
alarm = false
end
log("Statusfile", "writing now")
local f, err = io.open(settings.statusfile, "w")
if not f then
log("Error", "Cannot open statusfile '"..settings.statusfile..
"' :"..err)
return
end
f:write("Lsyncd status report at ", os.date(), "\n\n")
2010-11-10 12:59:51 +00:00
Inotifies.statusReport(f)
2010-11-06 10:10:57 +00:00
f:close()
2010-11-05 18:04:29 +00:00
end
2010-11-06 10:10:57 +00:00
-- public interface
return {write = write, getAlarm = getAlarm}
end)()
2010-10-28 17:56:33 +00:00
2010-11-10 15:57:37 +00:00
--============================================================================
-- lsyncd runner plugs. These functions will be called from core.
--============================================================================
-----
2010-11-11 19:52:20 +00:00
-- Current status of lsyncd.
2010-11-10 15:57:37 +00:00
--
2010-11-11 19:52:20 +00:00
-- "init" ... on (re)init
-- "run" ... normal operation
-- "fade" ... waits for remaining processes
--
local lsyncdStatus = "init"
2010-11-10 15:57:37 +00:00
----
-- the cores interface to the runner
local runner = {}
-----
-- Called from core whenever lua code failed.
-- Logs a backtrace
--
function runner.callError(message)
log("Error", "IN LUA: ", message)
-- prints backtrace
local level = 2
while true do
local info = debug.getinfo(level, "Sl")
if not info then
terminate(-1) -- ERRNO
end
log("Error", "Backtrace ", level - 1, " :",
info.short_src, ":", info.currentline)
level = level + 1
end
end
-----
-- Called from code whenever a child process finished and
-- zombie process was collected by core.
--
2010-11-10 22:03:02 +00:00
function runner.collectProcess(pid, exitcode)
2010-11-10 15:57:37 +00:00
for _, s in Syncs.iwalk() do
if s:collect(pid, exitcode) then
return
end
end
end
2010-10-22 23:14:11 +00:00
----
2010-11-05 18:04:29 +00:00
-- Called from core everytime a masterloop cycle runs through.
-- This happens in case of
-- * an expired alarm.
-- * a returned child process.
-- * received inotify events.
-- * received a HUP or TERM signal.
2010-10-23 12:36:55 +00:00
--
2010-11-05 18:04:29 +00:00
-- @param now the current kernel time (in jiffies)
2010-10-23 12:36:55 +00:00
--
2010-11-10 15:57:37 +00:00
function runner.cycle(now)
2010-11-08 12:14:10 +00:00
-- goes through all syncs and spawns more actions
2010-10-24 13:52:28 +00:00
-- if possible
2010-11-08 12:14:10 +00:00
for _, s in Syncs.iwalk() do
s:invokeActions(now)
end
2010-11-05 18:04:29 +00:00
if settings.statusfile then
2010-11-06 10:10:57 +00:00
StatusFile.write(now)
2010-11-05 18:04:29 +00:00
end
2010-10-22 23:14:11 +00:00
end
2010-10-27 09:06:13 +00:00
-----
-- Called by core before anything is "-help" or "--help" is in
-- the arguments.
--
2010-11-10 15:57:37 +00:00
function runner.help()
2010-10-27 19:34:56 +00:00
io.stdout:write(
2010-11-04 13:43:57 +00:00
[[
USAGE:
run a config file:
lsyncd [OPTIONS] [CONFIG-FILE]
default rsync behaviour:
lsyncd [OPTIONS] -rsync [SOURCE] [TARGET1] [TARGET2] ...
OPTIONS:
-help Shows this
-log all Logs everything
-log scarce Logs errors only
2010-11-04 14:23:34 +00:00
-log [Category] Turns on logging for a debug category
-runner FILE Loads lsyncds lua part from FILE
2010-11-04 13:43:57 +00:00
LICENSE:
GPLv2 or any later version.
SEE:
`man lsyncd` for further information.
2010-10-27 09:06:13 +00:00
]])
os.exit(-1) -- ERRNO
end
2010-11-03 21:02:14 +00:00
-----
-- Called from core to parse the command line arguments
-- @returns a string as user script to load.
-- or simply 'true' if running with rsync bevaiour
-- terminates on invalid arguments
--
2010-11-10 15:57:37 +00:00
function runner.configure(args)
2010-11-03 21:02:14 +00:00
-- a list of all valid --options
local options = {
-- log is handled by core already.
log = {1},
}
-- filled with all args that were non --options
local nonopts = {}
local i = 1
while i <= #args do
local a = args[i]
if a:sub(1, 1) ~= "-" then
table.insert(nonopts, args[i])
else
if a:sub(1, 2) == "--" then
a = a:sub(3)
else
a = a:sub(2)
end
local o = options[a]
2010-11-06 10:10:00 +00:00
if o then
2010-11-03 21:02:14 +00:00
-- TODO --
i = i + o[1]
end
end
i = i + 1
end
if #nonopts == 0 then
2010-11-10 22:03:02 +00:00
runner.help(args[0])
2010-11-03 21:02:14 +00:00
elseif #nonopts == 1 then
return nonopts[1]
else
-- TODO
return true
end
end
2010-10-17 15:24:55 +00:00
----
-- Called from core on init or restart after user configuration.
--
2010-11-10 15:57:37 +00:00
function runner.initialize()
2010-10-27 19:34:56 +00:00
-- creates settings if user didnt
settings = settings or {}
2010-10-25 14:55:40 +00:00
-- From this point on, no globals may be created anymore
2010-11-06 18:26:59 +00:00
lockGlobals()
2010-10-25 14:55:40 +00:00
2010-11-10 12:59:51 +00:00
-----
-- transfers some defaults to settings
-- TODO: loop
2010-11-06 10:33:26 +00:00
if settings.statusIntervall == nil then
settings.statusIntervall = default.statusIntervall
2010-10-27 09:06:13 +00:00
end
2010-10-25 21:41:45 +00:00
2010-10-21 12:37:27 +00:00
-- makes sure the user gave lsyncd anything to do
2010-11-06 10:10:00 +00:00
if Syncs.size() == 0 then
2010-11-02 21:04:01 +00:00
log("Error", "Nothing to watch!")
log("Error", "Use sync(SOURCE, TARGET, BEHAVIOR) in your config file.");
2010-10-27 19:34:56 +00:00
terminate(-1) -- ERRNO
2010-10-21 12:37:27 +00:00
end
2010-11-03 11:37:25 +00:00
-- from now on use logging as configured instead of stdout/err.
2010-11-11 19:52:20 +00:00
lsyncdStatus = "run";
2010-11-01 18:08:03 +00:00
lsyncd.configure("running");
2010-11-07 09:53:39 +00:00
-- runs through the syncs table filled by user calling directory()
for _, s in Syncs.iwalk() do
Inotifies.add(s.source, "", true, s)
if s.config.init then
2010-11-10 09:49:44 +00:00
InletControl.setSync(s)
2010-11-07 09:53:39 +00:00
s.config.init(Inlet)
2010-10-22 10:35:26 +00:00
end
end
2010-10-17 15:24:55 +00:00
end
2010-10-19 10:12:11 +00:00
----
2010-10-21 12:37:27 +00:00
-- Called by core to query soonest alarm.
2010-10-19 10:12:11 +00:00
--
2010-11-05 18:20:33 +00:00
-- @return false ... no alarm, core can in untimed sleep, or
2010-11-08 12:14:10 +00:00
-- true ... immediate action
2010-11-05 18:20:33 +00:00
-- times ... the alarm time (only read if number is 1)
--
2010-11-10 22:03:02 +00:00
function runner.getAlarm()
2010-11-05 18:20:33 +00:00
local alarm = false
2010-11-06 21:29:22 +00:00
----
-- checks if current nearest alarm or a is earlier
--
local function checkAlarm(a)
2010-11-08 12:14:10 +00:00
if alarm == true or not a then
-- already immediate or no new alarm
2010-11-06 21:29:22 +00:00
return
end
if not alarm then
alarm = a
else
alarm = lsyncd.earlier(alarm, a)
2010-10-24 16:41:58 +00:00
end
end
2010-11-06 21:29:22 +00:00
-- checks all syncs for their earliest alarm
for _, s in Syncs.iwalk() do
checkAlarm(s:getAlarm())
2010-11-06 10:10:57 +00:00
end
2010-11-06 21:29:22 +00:00
-- checks if a statusfile write has been delayed
checkAlarm(StatusFile.getAlarm())
2010-11-06 10:10:57 +00:00
2010-11-10 22:03:02 +00:00
log("Debug", "getAlarm returns: ",alarm)
2010-11-05 18:20:33 +00:00
return alarm
2010-10-19 10:12:11 +00:00
end
2010-10-17 15:24:55 +00:00
2010-11-10 15:57:37 +00:00
-----
-- Called when an inotify event arrived.
-- Simply forwards it directly to the object.
2010-11-10 22:03:02 +00:00
runner.inotifyEvent = Inotifies.event
2010-10-21 12:37:27 +00:00
-----
2010-10-24 13:52:28 +00:00
-- Collector for every child process that finished in startup phase
2010-10-21 12:37:27 +00:00
--
-- Parameters are pid and exitcode of child process
--
-- Can return either a new pid if one other child process
-- has been spawned as replacement (e.g. retry) or 0 if
-- finished/ok.
--
2010-11-10 15:57:37 +00:00
function runner.collector(pid, exitcode)
2010-10-21 12:37:27 +00:00
if exitcode ~= 0 then
2010-11-02 21:04:01 +00:00
log("Error", "Startup process", pid, " failed")
2010-10-27 19:34:56 +00:00
terminate(-1) -- ERRNO
2010-10-20 13:01:26 +00:00
end
2010-10-21 12:37:27 +00:00
return 0
2010-10-20 10:25:34 +00:00
end
2010-11-10 15:57:37 +00:00
----
-- Called by core when an overflow happened.
--
function runner.overflow()
log("Error", "--- OVERFLOW on inotify event queue ---")
terminate(-1) -- TODO reset instead.
end
2010-10-21 12:37:27 +00:00
2010-10-25 17:38:57 +00:00
--============================================================================
2010-10-17 15:24:55 +00:00
-- lsyncd user interface
2010-10-25 17:38:57 +00:00
--============================================================================
2010-10-17 15:24:55 +00:00
2010-11-05 15:18:01 +00:00
-----
-- Main utility to create new observations.
--
function sync(opts)
2010-11-11 19:52:20 +00:00
if lsyncdStatus ~= "init" then
error("Sync can only be created on initialization.", 2)
2010-11-05 15:18:01 +00:00
end
2010-11-06 10:10:00 +00:00
Syncs.add(opts)
2010-11-05 15:18:01 +00:00
end
2010-10-17 15:24:55 +00:00
2010-10-19 16:40:49 +00:00
2010-10-27 11:31:18 +00:00
-----
2010-11-07 01:06:08 +00:00
-- Spawn a new child process
2010-10-27 11:31:18 +00:00
--
2010-11-07 01:06:08 +00:00
-- @param agent the reason why a process is spawned.
-- normally this is a delay/event of a sync.
-- it will mark the related files as blocked.
-- or it is a string saying "all", that this
-- process blocks all events and is blocked by all
-- this is used on startup.
-- @param collect a table of exitvalues and the action that shall taken.
2010-11-07 09:53:39 +00:00
-- @param binary binary to call
-- @param ... arguments
2010-11-07 01:06:08 +00:00
--
2010-11-11 09:36:56 +00:00
function spawn(agent, binary, ...)
2010-11-11 15:17:22 +00:00
if agent == nil then
error("spawning with a nil agent", 2)
end
2010-11-07 09:53:39 +00:00
local pid = lsyncd.exec(binary, ...)
2010-11-07 01:06:08 +00:00
if pid and pid > 0 then
local sync, delay = InletControl.getInterior(agent)
delay.status = "active"
sync.processes[pid] = delay
end
2010-11-05 13:34:02 +00:00
end
2010-11-07 01:06:08 +00:00
-----
-- Spawns a child process using bash.
--
2010-11-11 09:36:56 +00:00
function spawnShell(agent, command, ...)
return spawn(agent, "/bin/sh", "-c", command, "/bin/sh", ...)
2010-10-27 11:31:18 +00:00
end
2010-11-10 11:23:26 +00:00
-----
-- Comfort routine also for user.
-- Returns true if 'String' starts with 'Start'
--
function string.starts(String,Start)
return string.sub(String,1,string.len(Start))==Start
end
-----
-- Comfort routine also for user.
-- Returns true if 'String' ends with 'End'
--
function string.ends(String,End)
return End=='' or string.sub(String,-string.len(End))==End
end
2010-10-26 11:26:57 +00:00
--============================================================================
-- lsyncd default settings
--============================================================================
2010-10-27 19:34:56 +00:00
-----
-- lsyncd classic - sync with rsync
--
2010-11-06 15:08:17 +00:00
local defaultRsync = {
2010-11-06 16:54:45 +00:00
-----
2010-10-27 19:34:56 +00:00
-- Called for every sync/target pair on startup
2010-11-06 17:40:12 +00:00
startup = function(source, config)
2010-11-02 21:04:01 +00:00
log("Normal", "startup recursive rsync: ", source, " -> ", target)
2010-11-06 17:40:12 +00:00
return exec("/usr/bin/rsync", "-ltrs", source, target)
2010-10-27 19:34:56 +00:00
end,
2010-11-06 17:40:12 +00:00
default = function(inlet)
-- TODO
--return exec("/usr/bin/rsync", "--delete", "-ltds",
-- source.."/"..path, target.."/"..path)
2010-10-27 19:34:56 +00:00
end
}
-----
2010-11-02 20:18:05 +00:00
-- The default table for the user to access
-- TODO make readonly
--
default = {
2010-11-11 19:52:20 +00:00
2010-11-02 20:18:05 +00:00
-----
2010-11-11 19:52:20 +00:00
-- Default action calls user scripts on**** functions.
2010-11-02 20:18:05 +00:00
--
action = function(inlet)
2010-11-10 11:23:26 +00:00
-- in case of moves getEvent returns the origin and dest of the move
local event, event2 = inlet.getEvent()
2010-11-08 12:14:10 +00:00
local config = inlet.getConfig()
2010-11-05 15:18:01 +00:00
local func = config["on".. event.etype]
2010-11-02 20:18:05 +00:00
if func then
2010-11-10 11:23:26 +00:00
func(event, event2)
2010-11-02 20:18:05 +00:00
end
end,
2010-11-10 09:49:44 +00:00
-----
2010-11-11 19:52:20 +00:00
-- Called to see if two events can be collapsed.
--
-- Default function uses the collapseTable.
--
2010-11-10 09:49:44 +00:00
-- @param event1 first event
-- @param event2 second event
2010-11-10 11:23:26 +00:00
-- @return -1 ... no interconnection
-- 0 ... drop both events.
-- 1 ... keep first event only
-- 2 ... keep second event only
-- 3 ... events block.
--
2010-11-10 09:49:44 +00:00
collapse = function(event1, event2, config)
2010-11-10 11:23:26 +00:00
if event1.path == event2.path then
if event1.etype == "Move" or event2.etype == "Move" then
-- currently moves are always blocks
return 3
else
-- asks the collapseTable what to do
return config.collapseTable[event1.etype][event2.etype]
end
end
-----
-- Block events if one is a parent directory of another
--
2010-11-10 22:03:02 +00:00
if event1.isdir and string.starts(event2.path, event1.path) then
2010-11-10 11:23:26 +00:00
return 3
end
2010-11-10 22:03:02 +00:00
if event2.isdir and string.starts(event1.path, event2.path) then
2010-11-10 09:49:44 +00:00
return 3
end
2010-11-10 11:23:26 +00:00
return -1
2010-11-10 09:49:44 +00:00
end,
-----
-- used by default collapse function
--
collapseTable = {
Attrib = { Attrib = 1, Modify = 2, Create = 2, Delete = 2 },
Modify = { Attrib = 1, Modify = 1, Create = 2, Delete = 2 },
Create = { Attrib = 1, Modify = 1, Create = 1, Delete = 0 },
Delete = { Attrib = 1, Modify = 1, Create = 3, Delete = 1 },
},
2010-11-11 09:36:56 +00:00
-----
-- Called when collecting a finished child process
--
collect = function(event, exitcode)
if event.etype == "Blanket" then
if exitcode == 0 then
2010-11-11 15:17:22 +00:00
log("Normal", "Startup of '",event.source,"' finished.")
2010-11-11 09:36:56 +00:00
else
2010-11-11 15:17:22 +00:00
log("Error", "Failure on startup of '",event.source,"'.")
2010-11-11 09:36:56 +00:00
terminate(-1) -- ERRNO
end
return
end
2010-11-11 15:17:22 +00:00
log("Normal", "Finished ",event.etype,
2010-11-11 18:34:44 +00:00
" on ",event.sourcePath," = ",exitcode)
2010-11-11 09:36:56 +00:00
end,
-----
-- called on (re)initalizing of lsyncd.
--
init = function(inlet)
local config = inlet.getConfig()
-- creates a prior startup if configured
if type(config.onStartup) == "function" then
local event = inlet.createBlanketEvent()
2010-11-11 15:17:22 +00:00
local startup = config.onStartup(event)
2010-11-11 19:52:20 +00:00
if event.status == "wait" then
2010-11-11 15:17:22 +00:00
-- user script did not spawn anything
-- thus the blanket event is deleted again.
inlet.cancelEvent(event)
end
-- TODO honor some return codes of startup like "warmstart".
2010-11-11 09:36:56 +00:00
end
end,
2010-10-26 11:26:57 +00:00
-----
2010-11-11 15:17:22 +00:00
-- The maximum number of processes lsyncd will spawn simultanously for
-- one sync.
2010-10-26 11:26:57 +00:00
--
2010-11-06 10:10:57 +00:00
maxProcesses = 1,
2010-11-06 16:54:45 +00:00
-----
2010-11-10 09:49:44 +00:00
-- a default rsync configuration for easy usage.
2010-11-11 15:17:22 +00:00
--
2010-11-10 09:49:44 +00:00
rsync = defaultRsync,
2010-10-27 19:34:56 +00:00
2010-11-06 16:54:45 +00:00
-----
2010-11-10 09:49:44 +00:00
-- Minimum seconds between two writes of a status file.
2010-10-26 11:26:57 +00:00
--
2010-11-10 09:49:44 +00:00
statusIntervall = 10,
2010-10-26 11:26:57 +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