mirror of
https://github.com/octoleo/lsyncd.git
synced 2024-05-29 06:30:46 +00:00
dropping fsevents
This commit is contained in:
parent
220053df9d
commit
c3c140a8d3
|
@ -16,25 +16,11 @@ set( LSYNCD_SRC lsyncd.c runner.c defaults.c )
|
|||
|
||||
# selecting the file notification mechanisms to compile against
|
||||
option( WITH_INOTIFY "Compile with inotify file notifications (Linux)" ON )
|
||||
option( WITH_FSEVENTS "Compile with inotify file notifications (OSX)" OFF )
|
||||
|
||||
if( WITH_INOTIFY )
|
||||
set( LSYNCD_SRC ${LSYNCD_SRC} inotify.c )
|
||||
endif( WITH_INOTIFY )
|
||||
|
||||
if( WITH_FSEVENTS )
|
||||
set( LSYNCD_SRC ${LSYNCD_SRC} fsevents.c )
|
||||
|
||||
option( XNU_DIR "Path to the xnu sources" )
|
||||
|
||||
# if( NOT XNU_DIR/bsd/sys/fsevents.h )
|
||||
# message( SEND_ERROR "Cannot find bsd/sys/fsevents.h in XNU_DIR" )
|
||||
# endif( )
|
||||
|
||||
include_directories( ${XNU_DIR} )
|
||||
endif( WITH_FSEVENTS )
|
||||
|
||||
|
||||
# generating the config.h file
|
||||
configure_file (
|
||||
"${PROJECT_SOURCE_DIR}/config.h.in"
|
||||
|
|
|
@ -1,5 +1,6 @@
|
|||
????-??-??: 3.0.0
|
||||
change: switched to systemd-style daemon (that is Lsyncd will no longer fork itself)
|
||||
change: dropping /dev/fsevents hack (OSX support)
|
||||
|
||||
2018-03-09: 2.2.3
|
||||
enhaencement: supporting includes with new filter and filterFrom options
|
||||
|
|
7
INSTALL
7
INSTALL
|
@ -6,7 +6,7 @@ Prerequisites
|
|||
|
||||
CMake
|
||||
|
||||
Lsyncd now uses CMake as configuration tool
|
||||
Lsyncd uses CMake as configuration tool
|
||||
|
||||
Common compiler stuff
|
||||
|
||||
|
@ -48,9 +48,4 @@ Building
|
|||
cmake .
|
||||
make
|
||||
|
||||
On OSX you yet need to get the xnu sources.
|
||||
For example:
|
||||
cmake -DWITH_INOTIFY=OFF -DWITH_FSEVENTS=ON -DXNU_DIR=/path/to/xnu-VERSION
|
||||
make
|
||||
|
||||
FIXME make install not yet done
|
||||
|
|
440
fsevents.c
440
fsevents.c
|
@ -1,440 +0,0 @@
|
|||
/** fsevents.c from Lsyncd - Live (Mirror) Syncing Demon
|
||||
*
|
||||
* License: GPLv2 (see COPYING) or any later version
|
||||
*
|
||||
* Authors: Axel Kittenberger <axkibe@gmail.com>
|
||||
* Damian Steward <damian.stewart@gmail.com>
|
||||
*
|
||||
* -----------------------------------------------------------------------
|
||||
*
|
||||
* Event interface for MacOS 10.5 (Leopard) /dev/fsevents interface.
|
||||
*
|
||||
* Special thanks go to Amit Singh and his fslogger demonstration that showed
|
||||
* how apples /dev/fsevents can be used. http://osxbook.com/software/fslogger/
|
||||
*
|
||||
* -- WARNING -- Quoting http://www.osxbook.com/software/fslogger/ --
|
||||
*
|
||||
* The interface that fslogger [and thus Lsyncd] uses is private to Apple.
|
||||
* Currently, there is a caveat regarding the use of this interface by third
|
||||
* parties (including fslogger [and thus Lsyncd]). While the change
|
||||
* notification interface supports multiple clients, there is a single kernel
|
||||
* buffer for holding events that are to be delivered to one or more
|
||||
* subscribers, with the primary subscriber being Spotlight. Now, the kernel
|
||||
* must hold events until it has notified all subscribers that are interested
|
||||
* in them. Since there is a single buffer, a slow subscriber can cause it to
|
||||
* overflow. If this happens, events will be dropped — for all subscribers,
|
||||
* including Spotlight. Consequently, Spotlight may need to look at the entire
|
||||
* volume to determine "what changed".
|
||||
*/
|
||||
#include "lsyncd.h"
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "bsd/sys/fsevents.h"
|
||||
|
||||
#include <lua.h>
|
||||
#include <lualib.h>
|
||||
#include <lauxlib.h>
|
||||
|
||||
|
||||
/* the fsevents pseudo-device */
|
||||
#define DEV_FSEVENTS "/dev/fsevents"
|
||||
|
||||
/* buffer for reading from the device */
|
||||
#define FSEVENT_BUFSIZ 131072
|
||||
|
||||
/* limited by MAX_KFS_EVENTS */
|
||||
#define EVENT_QUEUE_SIZE 4096
|
||||
|
||||
#define KFS_NUM_ARGS FSE_MAX_ARGS
|
||||
|
||||
/* OS 10.5 structuce */
|
||||
/* an event argument */
|
||||
struct kfs_event_arg {
|
||||
/* argument type */
|
||||
u_int16_t type;
|
||||
|
||||
/* size of argument data that follows this field */
|
||||
u_int16_t len;
|
||||
|
||||
union {
|
||||
struct vnode *vp;
|
||||
char *str;
|
||||
void *ptr;
|
||||
int32_t int32;
|
||||
dev_t dev;
|
||||
ino_t ino;
|
||||
int32_t mode;
|
||||
uid_t uid;
|
||||
gid_t gid;
|
||||
uint64_t timestamp;
|
||||
} data;
|
||||
};
|
||||
|
||||
/* OS 10.5 structuce */
|
||||
/* an event */
|
||||
struct kfs_event {
|
||||
|
||||
/* event type */
|
||||
int32_t type;
|
||||
|
||||
/* pid of the process that performed the operation */
|
||||
pid_t pid;
|
||||
|
||||
/* event arguments */
|
||||
struct kfs_event_arg* args[FSE_MAX_ARGS];
|
||||
};
|
||||
|
||||
/**
|
||||
* fsevents (cloned) filedescriptor
|
||||
*/
|
||||
static int fsevents_fd = -1;
|
||||
|
||||
/* event names */
|
||||
/*static const char *eventNames[FSE_MAX_EVENTS] = {
|
||||
"CREATE_FILE",
|
||||
"DELETE",
|
||||
"STAT_CHANGED",
|
||||
"RENAME",
|
||||
"CONTENT_MODIFIED",
|
||||
"EXCHANGE",
|
||||
"FINDER_INFO_CHANGED",
|
||||
"CREATE_DIR",
|
||||
"CHOWN",
|
||||
"XATTR_MODIFIED",
|
||||
"XATTR_REMOVED",
|
||||
};*/
|
||||
|
||||
/* argument names*/
|
||||
/*static const char *argNames[] = {
|
||||
"UNKNOWN",
|
||||
"VNODE",
|
||||
"STRING",
|
||||
"PATH",
|
||||
"INT32",
|
||||
"INT64",
|
||||
"RAW",
|
||||
"INO",
|
||||
"UID",
|
||||
"DEV",
|
||||
"MODE",
|
||||
"GID",
|
||||
"FINFO",
|
||||
};*/
|
||||
|
||||
/**
|
||||
* The read buffer
|
||||
*/
|
||||
static size_t const readbuf_size = 131072;
|
||||
static char * readbuf = NULL;
|
||||
|
||||
/**
|
||||
* The event buffer
|
||||
*/
|
||||
static size_t const eventbuf_size = FSEVENT_BUFSIZ;
|
||||
static char* eventbuf = NULL;
|
||||
|
||||
/**
|
||||
* Handles one fsevents event
|
||||
*/
|
||||
static void
|
||||
handle_event(lua_State *L, struct kfs_event *event, ssize_t mlen)
|
||||
{
|
||||
int32_t atype;
|
||||
const char *path = NULL;
|
||||
const char *trg = NULL;
|
||||
const char *etype = NULL;
|
||||
int isdir = -1;
|
||||
|
||||
if (event->type == FSE_EVENTS_DROPPED) {
|
||||
logstring("Fsevents", "Events dropped!");
|
||||
load_runner_func(L, "overflow");
|
||||
if (lua_pcall(L, 0, 0, -2)) {
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
lua_pop(L, 1);
|
||||
hup = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
atype = event->type & FSE_TYPE_MASK;
|
||||
/*uint32_t aflags = FSE_GET_FLAGS(event->type);*/
|
||||
|
||||
if ((atype < FSE_MAX_EVENTS) && (atype >= -1)) {
|
||||
/*printlogf(L, "Fsevents", "got event %s", eventNames[atype]);
|
||||
if (aflags & FSE_COMBINED_EVENTS) {
|
||||
logstring("Fsevents", "combined events");
|
||||
}
|
||||
if (aflags & FSE_CONTAINS_DROPPED_EVENTS) {
|
||||
logstring("Fsevents", "contains dropped events");
|
||||
}*/
|
||||
} else {
|
||||
printlogf(
|
||||
L,
|
||||
"Error",
|
||||
"unknown event(%d) in fsevents.",
|
||||
atype
|
||||
);
|
||||
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
|
||||
{
|
||||
/* assigns the expected arguments */
|
||||
int whichArg = 0;
|
||||
while (whichArg < FSE_MAX_ARGS) {
|
||||
struct kfs_event_arg * arg = event->args[whichArg++];
|
||||
if (arg->type == FSE_ARG_DONE) {
|
||||
break;
|
||||
}
|
||||
|
||||
switch (arg->type) {
|
||||
case FSE_ARG_STRING :
|
||||
switch(atype) {
|
||||
case FSE_RENAME :
|
||||
if (path) {
|
||||
// for move events second string is target
|
||||
trg = (char *) &arg->data.str;
|
||||
}
|
||||
// fallthrough
|
||||
case FSE_CHOWN :
|
||||
case FSE_CONTENT_MODIFIED :
|
||||
case FSE_CREATE_FILE :
|
||||
case FSE_CREATE_DIR :
|
||||
case FSE_DELETE :
|
||||
case FSE_STAT_CHANGED :
|
||||
if (!path) path = (char *)&arg->data.str;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case FSE_ARG_MODE :
|
||||
switch(atype) {
|
||||
case FSE_RENAME :
|
||||
case FSE_CHOWN :
|
||||
case FSE_CONTENT_MODIFIED :
|
||||
case FSE_CREATE_FILE :
|
||||
case FSE_CREATE_DIR :
|
||||
case FSE_DELETE :
|
||||
case FSE_STAT_CHANGED :
|
||||
isdir = arg->data.mode & S_IFDIR ? 1 : 0;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
switch(atype) {
|
||||
case FSE_CHOWN :
|
||||
case FSE_STAT_CHANGED :
|
||||
etype = "Attrib";
|
||||
break;
|
||||
case FSE_CREATE_DIR :
|
||||
case FSE_CREATE_FILE :
|
||||
etype = "Create";
|
||||
break;
|
||||
case FSE_DELETE :
|
||||
etype = "Delete";
|
||||
break;
|
||||
case FSE_RENAME :
|
||||
etype = "Move";
|
||||
break;
|
||||
case FSE_CONTENT_MODIFIED :
|
||||
etype = "Modify";
|
||||
break;
|
||||
}
|
||||
|
||||
if (etype) {
|
||||
if (!path) {
|
||||
printlogf(L, "Error", "Internal fail, fsevents, no path.");
|
||||
exit(-1);
|
||||
}
|
||||
if (isdir < 0) {
|
||||
printlogf(L, "Error", "Internal fail, fsevents, neither dir nor file.");
|
||||
exit(-1);
|
||||
}
|
||||
load_runner_func(L, "fsEventsEvent");
|
||||
lua_pushstring(L, etype);
|
||||
lua_pushboolean(L, isdir);
|
||||
l_now(L);
|
||||
lua_pushstring(L, path);
|
||||
if (trg) {
|
||||
lua_pushstring(L, trg);
|
||||
} else {
|
||||
lua_pushnil(L);
|
||||
}
|
||||
|
||||
if (lua_pcall(L, 5, 0, -7)) {
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
lua_pop(L, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when fsevents has something to read
|
||||
*/
|
||||
static void
|
||||
fsevents_ready(lua_State *L, struct observance *obs)
|
||||
{
|
||||
if (obs->fd != fsevents_fd) {
|
||||
logstring("Error", "Internal, fsevents_fd != ob->fd");
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
|
||||
ptrdiff_t len = read (fsevents_fd, readbuf, readbuf_size);
|
||||
int err = errno;
|
||||
if (len == 0) {
|
||||
return;
|
||||
}
|
||||
if (len < 0) {
|
||||
if (err == EAGAIN) {
|
||||
/* nothing more */
|
||||
return;
|
||||
} else {
|
||||
printlogf(L, "Error", "Read fail on fsevents");
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
}
|
||||
{
|
||||
int off = 0;
|
||||
while (off < len && !hup && !term) {
|
||||
/* deals with alignment issues on 64 bit by copying data bit by bit */
|
||||
struct kfs_event* event = (struct kfs_event *) eventbuf;
|
||||
event->type = *(int32_t*)(readbuf+off);
|
||||
off += sizeof(int32_t);
|
||||
event->pid = *(pid_t*)(readbuf+off);
|
||||
off += sizeof(pid_t);
|
||||
/* arguments */
|
||||
int whichArg = 0;
|
||||
int eventbufOff = sizeof(struct kfs_event);
|
||||
size_t ptrSize = sizeof(void*);
|
||||
if ((eventbufOff % ptrSize) != 0) {
|
||||
eventbufOff += ptrSize-(eventbufOff%ptrSize);
|
||||
}
|
||||
while (off < len && whichArg < FSE_MAX_ARGS) {
|
||||
/* assign argument pointer to eventbuf based on
|
||||
known current offset into eventbuf */
|
||||
uint16_t argLen = 0;
|
||||
event->args[whichArg] = (struct kfs_event_arg *) (eventbuf + eventbufOff);
|
||||
/* copy type */
|
||||
uint16_t argType = *(uint16_t*)(readbuf + off);
|
||||
event->args[whichArg]->type = argType;
|
||||
off += sizeof(uint16_t);
|
||||
if (argType == FSE_ARG_DONE) {
|
||||
/* done */
|
||||
break;
|
||||
} else {
|
||||
/* copy data length */
|
||||
argLen = *(uint16_t *)(readbuf + off);
|
||||
event->args[whichArg]->len = argLen;
|
||||
off += sizeof(uint16_t);
|
||||
/* copy data */
|
||||
memcpy(&(event->args[whichArg]->data), readbuf + off, argLen);
|
||||
off += argLen;
|
||||
}
|
||||
/* makes sure alignment is correct for 64 bit systems */
|
||||
size_t argStructLen = sizeof(uint16_t) + sizeof(uint16_t);
|
||||
if ((argStructLen % ptrSize) != 0) {
|
||||
argStructLen += ptrSize-(argStructLen % ptrSize);
|
||||
}
|
||||
argStructLen += argLen;
|
||||
if ((argStructLen % ptrSize) != 0) {
|
||||
argStructLen += ptrSize-(argStructLen % ptrSize);
|
||||
}
|
||||
eventbufOff += argStructLen;
|
||||
whichArg++;
|
||||
}
|
||||
handle_event(L, event, len);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Called to close/tidy fsevents
|
||||
*/
|
||||
static void
|
||||
fsevents_tidy(struct observance *obs)
|
||||
{
|
||||
if (obs->fd != fsevents_fd) {
|
||||
logstring("Error", "Internal, fsevents_fd != ob->fd");
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
close(fsevents_fd);
|
||||
free(readbuf);
|
||||
readbuf = NULL;
|
||||
free(eventbuf);
|
||||
eventbuf = NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* opens and initalizes fsevents.
|
||||
*/
|
||||
extern void
|
||||
open_fsevents(lua_State *L)
|
||||
{
|
||||
int8_t event_list[] = { // action to take for each event
|
||||
FSE_REPORT, // FSE_CREATE_FILE
|
||||
FSE_REPORT, // FSE_DELETE
|
||||
FSE_REPORT, // FSE_STAT_CHANGED
|
||||
FSE_REPORT, // FSE_RENAME
|
||||
FSE_REPORT, // FSE_CONTENT_MODIFIED
|
||||
FSE_REPORT, // FSE_EXCHANGE
|
||||
FSE_REPORT, // FSE_FINDER_INFO_CHANGED
|
||||
FSE_REPORT, // FSE_CREATE_DIR
|
||||
FSE_REPORT, // FSE_CHOWN
|
||||
FSE_REPORT, // FSE_XATTR_MODIFIED
|
||||
FSE_REPORT, // FSE_XATTR_REMOVED
|
||||
};
|
||||
struct fsevent_clone_args fca = {
|
||||
.event_list = (int8_t *) event_list,
|
||||
.num_events = sizeof(event_list)/sizeof(int8_t),
|
||||
.event_queue_depth = EVENT_QUEUE_SIZE,
|
||||
.fd = &fsevents_fd,
|
||||
};
|
||||
int fd = open(DEV_FSEVENTS, O_RDONLY);
|
||||
int err = errno;
|
||||
printlogf(L, "Warn",
|
||||
"Using /dev/fsevents which is considered an OSX internal interface.");
|
||||
printlogf(L, "Warn",
|
||||
"Functionality might break across OSX versions (This is for 10.5.X)");
|
||||
printlogf(L, "Warn",
|
||||
"A hanging Lsyncd might cause Spotlight/Timemachine doing extra work.");
|
||||
|
||||
if (fd < 0) {
|
||||
printlogf(L, "Error",
|
||||
"Cannot access %s monitor! (%d:%s)",
|
||||
DEV_FSEVENTS, err, strerror(err));
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
|
||||
if (ioctl(fd, FSEVENTS_CLONE, (char *)&fca) < 0) {
|
||||
printlogf(L, "Error",
|
||||
"Cannot control %s monitor! (%d:%s)",
|
||||
DEV_FSEVENTS, errno, strerror(errno));
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
|
||||
if (readbuf) {
|
||||
logstring("Error",
|
||||
"internal fail, inotify readbuf!=NULL in open_inotify()")
|
||||
exit(-1); // ERRNO
|
||||
}
|
||||
readbuf = s_malloc(readbuf_size);
|
||||
eventbuf = s_malloc(eventbuf_size);
|
||||
// fd has been cloned, closes access fd
|
||||
close(fd);
|
||||
close_exec_fd(fsevents_fd);
|
||||
non_block_fd(fsevents_fd);
|
||||
observe_fd(fsevents_fd, fsevents_ready, NULL, fsevents_tidy, NULL);
|
||||
}
|
||||
|
||||
|
8
lsyncd.c
8
lsyncd.c
|
@ -73,10 +73,6 @@ static char *monitors[] = {
|
|||
"inotify",
|
||||
#endif
|
||||
|
||||
#ifdef WITH_FSEVENTS
|
||||
"fsevents",
|
||||
#endif
|
||||
|
||||
NULL,
|
||||
};
|
||||
|
||||
|
@ -2800,10 +2796,6 @@ main1( int argc, char *argv[] )
|
|||
open_inotify( L );
|
||||
#endif
|
||||
|
||||
#ifdef WITH_FSEVENTS
|
||||
open_fsevents( L );
|
||||
#endif
|
||||
|
||||
// adds signal handlers
|
||||
// listens to SIGCHLD, but blocks it until pselect( )
|
||||
// opens the signal handler up
|
||||
|
|
134
lsyncd.lua
134
lsyncd.lua
|
@ -3354,7 +3354,6 @@ local Syncs = ( function
|
|||
Monitors.default( )
|
||||
|
||||
if config.monitor ~= 'inotify'
|
||||
and config.monitor ~= 'fsevents'
|
||||
then
|
||||
local info = debug.getinfo( 3, 'Sl' )
|
||||
|
||||
|
@ -3762,133 +3761,6 @@ local Inotify = ( function
|
|||
end)( )
|
||||
|
||||
|
||||
--
|
||||
-- Interface to OSX /dev/fsevents
|
||||
--
|
||||
-- This watches all the filesystems at once,
|
||||
-- but needs root access.
|
||||
--
|
||||
-- All fsevents specific implementation are enclosed here.
|
||||
--
|
||||
local Fsevents = ( function
|
||||
( )
|
||||
--
|
||||
-- A list indexed by syncs yielding
|
||||
-- the root path the sync is interested in.
|
||||
--
|
||||
local syncRoots = { }
|
||||
|
||||
--
|
||||
-- Adds a Sync to receive events.
|
||||
--
|
||||
local function addSync
|
||||
(
|
||||
sync, -- object to receive events
|
||||
dir -- dir to watch
|
||||
)
|
||||
if syncRoots[ sync ]
|
||||
then
|
||||
error( 'duplicate sync in Fanotify.addSync()' )
|
||||
end
|
||||
|
||||
syncRoots[ sync ] = dir
|
||||
|
||||
end
|
||||
|
||||
--
|
||||
-- Called when an event has occured.
|
||||
--
|
||||
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'
|
||||
)
|
||||
if isdir
|
||||
then
|
||||
path = path .. '/'
|
||||
|
||||
if path2 then path2 = path2 .. '/' end
|
||||
end
|
||||
|
||||
log( 'Fsevents', etype, ',', isdir, ',', time, ',', path, ',', path2 )
|
||||
|
||||
for _, sync in Syncs.iwalk()
|
||||
do repeat
|
||||
|
||||
local root = sync.source
|
||||
|
||||
-- TODO combine ifs
|
||||
if not path:starts( root )
|
||||
then
|
||||
if not path2 or not path2:starts( root )
|
||||
then
|
||||
break -- continue
|
||||
end
|
||||
end
|
||||
|
||||
local relative = splitPath( path, root )
|
||||
|
||||
local relative2
|
||||
|
||||
if path2
|
||||
then
|
||||
relative2 = splitPath( path2, root )
|
||||
end
|
||||
|
||||
-- possibly change etype for this iteration only
|
||||
local etyped = etype
|
||||
|
||||
if etyped == 'Move'
|
||||
then
|
||||
if not relative2
|
||||
then
|
||||
log( 'Normal', 'Transformed Move to Delete for ', sync.config.name )
|
||||
|
||||
etyped = 'Delete'
|
||||
|
||||
elseif not relative
|
||||
then
|
||||
relative = relative2
|
||||
|
||||
relative2 = nil
|
||||
|
||||
log( 'Normal', 'Transformed Move to Create for ', sync.config.name )
|
||||
|
||||
etyped = 'Create'
|
||||
end
|
||||
end
|
||||
|
||||
sync:delay( etyped, time, relative, relative2 )
|
||||
|
||||
until true end
|
||||
|
||||
end
|
||||
|
||||
|
||||
--
|
||||
-- Writes a status report about fsevents to a filedescriptor.
|
||||
--
|
||||
local function statusReport
|
||||
(
|
||||
f
|
||||
)
|
||||
-- TODO
|
||||
end
|
||||
|
||||
--
|
||||
-- Public interface
|
||||
--
|
||||
return {
|
||||
addSync = addSync,
|
||||
event = event,
|
||||
statusReport = statusReport
|
||||
}
|
||||
end )( )
|
||||
|
||||
|
||||
--
|
||||
-- Holds information about the event monitor capabilities
|
||||
-- of the core.
|
||||
|
@ -4628,7 +4500,7 @@ SEE:
|
|||
|
||||
--
|
||||
-- -monitor NAME Uses operating systems event montior NAME
|
||||
-- (inotify/fanotify/fsevents)
|
||||
-- (currently only inotify)
|
||||
|
||||
os.exit( -1 )
|
||||
end
|
||||
|
@ -5042,9 +4914,6 @@ function runner.initialize( firstTime )
|
|||
if s.config.monitor == 'inotify'
|
||||
then
|
||||
Inotify.addSync( s, s.source )
|
||||
elseif s.config.monitor == 'fsevents'
|
||||
then
|
||||
Fsevents.addSync( s, s.source )
|
||||
else
|
||||
error(
|
||||
'sync ' ..
|
||||
|
@ -5134,7 +5003,6 @@ end
|
|||
-- Called when an file system monitor events arrive
|
||||
--
|
||||
runner.inotifyEvent = Inotify.event
|
||||
runner.fsEventsEvent = Fsevents.event
|
||||
|
||||
--
|
||||
-- Collector for every child process that finished in startup phase
|
||||
|
|
|
@ -14,7 +14,6 @@ local tdir, srcdir, trgdir = mktemps( )
|
|||
churn( srcdir, 100, true )
|
||||
|
||||
local logs = { }
|
||||
-- logs = { "-log", "Delay", "-log", "Fsevents" }
|
||||
local pid = spawn(
|
||||
'./lsyncd',
|
||||
'-nodaemon',
|
||||
|
|
Loading…
Reference in New Issue
Block a user