mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2025-08-02 15:33:39 +02:00
Added. Added. Added. Added. Added. Added. Added. Added. Added. Added.
2008-03-14 Alexander Larsson <alexl@redhat.com> * Makefile.am: * fen/Makefile.am: Added. * fen/fen-data.[ch]: Added. * fen/fen-dump.[ch]: Added. * fen/fen-helper.[ch]: Added. * fen/fen-kernel.[ch]: Added. * fen/fen-missing.[ch]: Added. * fen/fen-node.[ch]: Added. * fen/fen-sub.[ch]: Added. * fen/gfendirectorymonitor.[ch]: Added. * fen/gfenfilemonitor.[ch]: Added. * giomodule.c: Added Solaris FEN file notification backend. Patch from Lin Ma <Lin.Ma@Sun.COM> svn path=/trunk/; revision=6702
This commit is contained in:
Alexander Larsson
committed by
Alexander Larsson
Alexander Larsson
parent
553b3b613b
commit
7dc75d707c
708
gio/fen/fen-data.c
Normal file
708
gio/fen/fen-data.c
Normal file
@@ -0,0 +1,708 @@
|
||||
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
||||
/* vim:set expandtab ts=4 shiftwidth=4: */
|
||||
/*
|
||||
* Copyright (C) 2008 Sun Microsystem.
|
||||
*
|
||||
* This library is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation; either
|
||||
* version 2 of the License, or (at your option) any later version.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
* Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General
|
||||
* Public License along with this library; if not, write to the
|
||||
* Free Software Foundation, Inc., 59 Temple Place, Suite 330,
|
||||
* Boston, MA 02111-1307, USA.
|
||||
*
|
||||
* Authors: Lin Ma <lin.ma@sun.com>
|
||||
*/
|
||||
|
||||
#include "config.h"
|
||||
#include <port.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/time.h>
|
||||
#include <sys/stat.h>
|
||||
#include <errno.h>
|
||||
#include <glib.h>
|
||||
#include "fen-data.h"
|
||||
#include "fen-kernel.h"
|
||||
#include "fen-missing.h"
|
||||
#include "fen-dump.h"
|
||||
|
||||
#define PROCESS_EVENTQ_TIME 10 /* in milliseconds */
|
||||
#define PAIR_EVENTS_TIMEVAL 00000 /* in microseconds */
|
||||
#define PAIR_EVENTS_INC_TIMEVAL 0000 /* in microseconds */
|
||||
#define SCAN_CHANGINGS_TIME 50 /* in milliseconds */
|
||||
#define SCAN_CHANGINGS_MAX_TIME (4*100) /* in milliseconds */
|
||||
#define SCAN_CHANGINGS_MIN_TIME (4*100) /* in milliseconds */
|
||||
#define INIT_CHANGES_NUM 2
|
||||
#define BASE_NUM 2
|
||||
|
||||
#define FD_W if (fd_debug_enabled) g_warning
|
||||
static gboolean fd_debug_enabled = FALSE;
|
||||
|
||||
G_LOCK_EXTERN (fen_lock);
|
||||
static GList *deleting_data = NULL;
|
||||
static guint deleting_data_id = 0;
|
||||
|
||||
static void (*emit_once_cb) (fdata *f, int events, gpointer sub);
|
||||
static void (*emit_cb) (fdata *f, int events);
|
||||
static int (*_event_converter) (int event);
|
||||
|
||||
static gboolean fdata_delete (fdata* f);
|
||||
static gint fdata_sub_find (gpointer a, gpointer b);
|
||||
static void scan_children (node_t *f);
|
||||
static void scan_known_children (node_t* f);
|
||||
|
||||
node_t*
|
||||
add_missing_cb (node_t* parent, gpointer user_data)
|
||||
{
|
||||
g_assert (parent);
|
||||
FD_W ("%s p:0x%p %s\n", __func__, parent, (gchar*)user_data);
|
||||
return add_node (parent, (gchar*)user_data);
|
||||
}
|
||||
|
||||
gboolean
|
||||
pre_del_cb (node_t* node, gpointer user_data)
|
||||
{
|
||||
fdata* data;
|
||||
|
||||
g_assert (node);
|
||||
data = node_get_data (node);
|
||||
FD_W ("%s node:0x%p %s\n", __func__, node, NODE_NAME(node));
|
||||
if (data != NULL) {
|
||||
if (!FN_IS_PASSIVE(data)) {
|
||||
return FALSE;
|
||||
}
|
||||
fdata_delete (data);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static guint
|
||||
_pow (guint x, guint y)
|
||||
{
|
||||
guint z = 1;
|
||||
g_assert (x >= 0 && y >= 0);
|
||||
for (; y > 0; y--) {
|
||||
z *= x;
|
||||
}
|
||||
return z;
|
||||
}
|
||||
|
||||
static guint
|
||||
get_scalable_scan_time (fdata* data)
|
||||
{
|
||||
guint sleep_time;
|
||||
/* Caculate from num = 0 */
|
||||
sleep_time = _pow (BASE_NUM, data->changed_event_num) * SCAN_CHANGINGS_TIME;
|
||||
if (sleep_time < SCAN_CHANGINGS_MIN_TIME) {
|
||||
sleep_time = SCAN_CHANGINGS_MIN_TIME;
|
||||
} else if (sleep_time > SCAN_CHANGINGS_MAX_TIME) {
|
||||
sleep_time = SCAN_CHANGINGS_MAX_TIME;
|
||||
data->change_update_id = INIT_CHANGES_NUM;
|
||||
}
|
||||
FD_W ("SCALABE SCAN num:time [ %4u : %4u ] %s\n", data->changed_event_num, sleep_time, FN_NAME(data));
|
||||
return sleep_time;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
g_timeval_lt (GTimeVal *val1, GTimeVal *val2)
|
||||
{
|
||||
if (val1->tv_sec < val2->tv_sec)
|
||||
return TRUE;
|
||||
|
||||
if (val1->tv_sec > val2->tv_sec)
|
||||
return FALSE;
|
||||
|
||||
/* val1->tv_sec == val2->tv_sec */
|
||||
if (val1->tv_usec < val2->tv_usec)
|
||||
return TRUE;
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* If all active children nodes are ported, then cancel monitor the parent node
|
||||
*
|
||||
* Unsafe, need lock.
|
||||
*/
|
||||
static void
|
||||
scan_known_children (node_t* f)
|
||||
{
|
||||
GDir *dir;
|
||||
GError *err = NULL;
|
||||
fdata* pdata;
|
||||
|
||||
FD_W ("%s %s [0x%p]\n", __func__, NODE_NAME(f), f);
|
||||
pdata = node_get_data (f);
|
||||
/*
|
||||
* Currect fdata must is directly monitored. Be sure it is 1 level monitor.
|
||||
*/
|
||||
dir = g_dir_open (NODE_NAME(f), 0, &err);
|
||||
if (dir) {
|
||||
const char *basename;
|
||||
|
||||
while ((basename = g_dir_read_name (dir)))
|
||||
{
|
||||
node_t* childf = NULL;
|
||||
fdata* data;
|
||||
GList *idx;
|
||||
/*
|
||||
* If the node is existed, and isn't ported, then emit created
|
||||
* event. Ignore others.
|
||||
*/
|
||||
childf = children_find (f, basename);
|
||||
if (childf &&
|
||||
(data = node_get_data (childf)) != NULL &&
|
||||
!FN_IS_PASSIVE (data)) {
|
||||
if (!is_monitoring (data) &&
|
||||
port_add (&data->fobj, &data->len, data)) {
|
||||
fdata_emit_events (data, FN_EVENT_CREATED);
|
||||
}
|
||||
}
|
||||
}
|
||||
g_dir_close (dir);
|
||||
} else {
|
||||
FD_W (err->message);
|
||||
g_error_free (err);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
scan_children (node_t *f)
|
||||
{
|
||||
GDir *dir;
|
||||
GError *err = NULL;
|
||||
fdata* pdata;
|
||||
|
||||
FD_W ("%s %s [0x%p]\n", __func__, NODE_NAME(f), f);
|
||||
pdata = node_get_data (f);
|
||||
/*
|
||||
* Currect fdata must is directly monitored. Be sure it is 1 level monitor.
|
||||
*/
|
||||
dir = g_dir_open (NODE_NAME(f), 0, &err);
|
||||
if (dir) {
|
||||
const char *basename;
|
||||
|
||||
while ((basename = g_dir_read_name (dir)))
|
||||
{
|
||||
node_t* childf = NULL;
|
||||
fdata* data;
|
||||
GList *idx;
|
||||
|
||||
childf = children_find (f, basename);
|
||||
if (childf == NULL) {
|
||||
gchar *filename;
|
||||
|
||||
filename = g_build_filename (NODE_NAME(f), basename, NULL);
|
||||
childf = add_node (f, filename);
|
||||
g_assert (childf);
|
||||
data = fdata_new (childf, FALSE);
|
||||
g_free (filename);
|
||||
}
|
||||
if ((data = node_get_data (childf)) == NULL) {
|
||||
data = fdata_new (childf, FALSE);
|
||||
}
|
||||
/* Be sure data isn't ported and add to port successfully */
|
||||
/* Don't need delete it, it will be deleted by the parent */
|
||||
if (is_monitoring (data)) {
|
||||
/* Ignored */
|
||||
} else if (/* !is_ported (data) && */
|
||||
port_add (&data->fobj, &data->len, data)) {
|
||||
fdata_emit_events (data, FN_EVENT_CREATED);
|
||||
}
|
||||
}
|
||||
g_dir_close (dir);
|
||||
} else {
|
||||
FD_W (err->message);
|
||||
g_error_free (err);
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
scan_deleting_data (gpointer data)
|
||||
{
|
||||
fdata *f;
|
||||
GList* i;
|
||||
GList* deleted_list = NULL;
|
||||
gboolean ret = TRUE;
|
||||
|
||||
if (G_TRYLOCK (fen_lock)) {
|
||||
for (i = deleting_data; i; i = i->next) {
|
||||
f = (fdata*)i->data;
|
||||
if (fdata_delete (f)) {
|
||||
deleted_list = g_list_prepend (deleted_list, i);
|
||||
}
|
||||
}
|
||||
|
||||
for (i = deleted_list; i; i = i->next) {
|
||||
deleting_data = g_list_remove_link (deleting_data,
|
||||
(GList *)i->data);
|
||||
g_list_free_1 ((GList *)i->data);
|
||||
}
|
||||
g_list_free (deleted_list);
|
||||
|
||||
if (deleting_data == NULL) {
|
||||
deleting_data_id = 0;
|
||||
ret = FALSE;
|
||||
}
|
||||
G_UNLOCK (fen_lock);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
gboolean
|
||||
is_monitoring (fdata* data)
|
||||
{
|
||||
return is_ported (data) || data->change_update_id > 0;
|
||||
}
|
||||
|
||||
fdata*
|
||||
get_parent_data (fdata* data)
|
||||
{
|
||||
if (FN_NODE(data) && !IS_TOPNODE(FN_NODE(data))) {
|
||||
return node_get_data (FN_NODE(data)->parent);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
node_t*
|
||||
get_parent_node (fdata* data)
|
||||
{
|
||||
if (FN_NODE(data)) {
|
||||
return (FN_NODE(data)->parent);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
fdata *
|
||||
fdata_new (node_t* node, gboolean is_mondir)
|
||||
{
|
||||
fdata *f = NULL;
|
||||
|
||||
g_assert (node);
|
||||
if ((f = g_new0 (fdata, 1)) != NULL) {
|
||||
FN_NODE(f) = node;
|
||||
FN_NAME(f) = g_strdup (NODE_NAME(node));
|
||||
f->is_dir = is_mondir;
|
||||
f->eventq = g_queue_new ();
|
||||
FD_W ("[ %s ] 0x%p %s\n", __func__, f, FN_NAME(f));
|
||||
node_set_data (node, f);
|
||||
}
|
||||
return f;
|
||||
}
|
||||
|
||||
static gboolean
|
||||
fdata_delete (fdata *f)
|
||||
{
|
||||
fnode_event_t *ev;
|
||||
|
||||
FD_W ("[ TRY %s ] 0x%p id[%4d:%4d] %s\n", __func__, f, f->eventq_id, f->change_update_id, FN_NAME(f));
|
||||
g_assert (FN_IS_PASSIVE(f));
|
||||
|
||||
port_remove (f);
|
||||
/* missing_remove (f); */
|
||||
|
||||
if (f->node != NULL) {
|
||||
node_set_data (f->node, NULL);
|
||||
f->node = NULL;
|
||||
}
|
||||
|
||||
if (f->change_update_id > 0 || f->eventq_id > 0) {
|
||||
if (FN_IS_LIVING(f)) {
|
||||
f->is_cancelled = TRUE;
|
||||
deleting_data = g_list_prepend (deleting_data, f);
|
||||
if (deleting_data_id == 0) {
|
||||
deleting_data_id = g_idle_add (scan_deleting_data, NULL);
|
||||
g_assert (deleting_data_id > 0);
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
FD_W ("[ %s ] 0x%p %s\n", __func__, f, FN_NAME(f));
|
||||
|
||||
while ((ev = g_queue_pop_head (f->eventq)) != NULL) {
|
||||
fnode_event_delete (ev);
|
||||
}
|
||||
|
||||
g_queue_free (f->eventq);
|
||||
g_free (FN_NAME(f));
|
||||
g_free (f);
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
void
|
||||
fdata_reset (fdata* data)
|
||||
{
|
||||
fnode_event_t *ev;
|
||||
|
||||
g_assert (data);
|
||||
|
||||
while ((ev = g_queue_pop_head (data->eventq)) != NULL) {
|
||||
fnode_event_delete (ev);
|
||||
}
|
||||
}
|
||||
|
||||
static gint
|
||||
fdata_sub_find (gpointer a, gpointer b)
|
||||
{
|
||||
if (a != b) {
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
fdata_sub_add (fdata *f, gpointer sub)
|
||||
{
|
||||
FD_W ("[%s] [data: 0x%p ] [s: 0x%p ] %s\n", __func__, f, sub, FN_NAME(f));
|
||||
g_assert (g_list_find_custom (f->subs, sub, (GCompareFunc)fdata_sub_find) == NULL);
|
||||
f->subs = g_list_prepend (f->subs, sub);
|
||||
}
|
||||
|
||||
void
|
||||
fdata_sub_remove (fdata *f, gpointer sub)
|
||||
{
|
||||
GList *l;
|
||||
FD_W ("[%s] [data: 0x%p ] [s: 0x%p ] %s\n", __func__, f, sub, FN_NAME(f));
|
||||
g_assert (g_list_find_custom (f->subs, sub, (GCompareFunc)fdata_sub_find) != NULL);
|
||||
l = g_list_find_custom (f->subs, sub, (GCompareFunc)fdata_sub_find);
|
||||
g_assert (l);
|
||||
g_assert (sub == l->data);
|
||||
f->subs = g_list_delete_link (f->subs, l);
|
||||
}
|
||||
|
||||
/**
|
||||
* Adjust self on failing to Port
|
||||
*/
|
||||
void
|
||||
fdata_adjust_deleted (fdata* f)
|
||||
{
|
||||
node_t* parent;
|
||||
fdata* pdata;
|
||||
node_op_t op = {NULL, NULL, pre_del_cb, NULL};
|
||||
|
||||
/*
|
||||
* It's a top node. We move it to missing list.
|
||||
*/
|
||||
parent = get_parent_node (f);
|
||||
pdata = get_parent_data (f);
|
||||
if (!FN_IS_PASSIVE(f) ||
|
||||
children_num (FN_NODE(f)) > 0 ||
|
||||
(pdata && !FN_IS_PASSIVE(pdata))) {
|
||||
if (parent) {
|
||||
if (pdata == NULL) {
|
||||
pdata = fdata_new (parent, FALSE);
|
||||
}
|
||||
g_assert (pdata);
|
||||
if (!port_add (&pdata->fobj, &pdata->len, pdata)) {
|
||||
fdata_adjust_deleted (pdata);
|
||||
}
|
||||
} else {
|
||||
/* f is root */
|
||||
g_assert (IS_TOPNODE(FN_NODE(f)));
|
||||
missing_add (f);
|
||||
}
|
||||
} else {
|
||||
#ifdef GIO_COMPILATION
|
||||
pending_remove_node (FN_NODE(f), &op);
|
||||
#else
|
||||
remove_node (FN_NODE(f), &op);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
static gboolean
|
||||
fdata_adjust_changed (fdata *f)
|
||||
{
|
||||
fnode_event_t *ev;
|
||||
struct stat buf;
|
||||
node_t* parent;
|
||||
fdata* pdata;
|
||||
|
||||
G_LOCK (fen_lock);
|
||||
parent = get_parent_node (f);
|
||||
pdata = get_parent_data (f);
|
||||
|
||||
if (!FN_IS_LIVING(f) ||
|
||||
(children_num (FN_NODE(f)) == 0 &&
|
||||
FN_IS_PASSIVE(f) &&
|
||||
pdata && FN_IS_PASSIVE(pdata))) {
|
||||
f->change_update_id = 0;
|
||||
G_UNLOCK (fen_lock);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
FD_W ("[ %s ] %s\n", __func__, FN_NAME(f));
|
||||
if (FN_STAT (FN_NAME(f), &buf) != 0) {
|
||||
FD_W ("LSTAT [%-20s] %s\n", FN_NAME(f), g_strerror (errno));
|
||||
goto L_delete;
|
||||
}
|
||||
f->is_dir = S_ISDIR (buf.st_mode) ? TRUE : FALSE;
|
||||
if (f->len != buf.st_size) {
|
||||
FD_W ("LEN [%lld:%lld] %s\n", f->len, buf.st_size, FN_NAME(f));
|
||||
f->len = buf.st_size;
|
||||
ev = fnode_event_new (FILE_MODIFIED, TRUE, f);
|
||||
if (ev != NULL) {
|
||||
ev->is_pending = TRUE;
|
||||
fdata_add_event (f, ev);
|
||||
}
|
||||
/* Fdata is still changing, so scalable scan */
|
||||
f->change_update_id = g_timeout_add (get_scalable_scan_time (f),
|
||||
(GSourceFunc)fdata_adjust_changed,
|
||||
(gpointer)f);
|
||||
G_UNLOCK (fen_lock);
|
||||
return FALSE;
|
||||
} else {
|
||||
f->changed_event_num = 0;
|
||||
f->fobj.fo_atime = buf.st_atim;
|
||||
f->fobj.fo_mtime = buf.st_mtim;
|
||||
f->fobj.fo_ctime = buf.st_ctim;
|
||||
if (FN_IS_DIR(f)) {
|
||||
if (FN_IS_MONDIR(f)) {
|
||||
scan_children (FN_NODE(f));
|
||||
} else {
|
||||
scan_known_children (FN_NODE(f));
|
||||
if ((children_num (FN_NODE(f)) == 0 &&
|
||||
FN_IS_PASSIVE(f) &&
|
||||
pdata && FN_IS_PASSIVE(pdata))) {
|
||||
port_remove (f);
|
||||
goto L_exit;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!port_add_simple (&f->fobj, f)) {
|
||||
L_delete:
|
||||
ev = fnode_event_new (FILE_DELETE, FALSE, f);
|
||||
if (ev != NULL) {
|
||||
fdata_add_event (f, ev);
|
||||
}
|
||||
}
|
||||
}
|
||||
L_exit:
|
||||
f->change_update_id = 0;
|
||||
G_UNLOCK (fen_lock);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void
|
||||
fdata_emit_events_once (fdata *f, int event, gpointer sub)
|
||||
{
|
||||
emit_once_cb (f, _event_converter (event), sub);
|
||||
}
|
||||
|
||||
void
|
||||
fdata_emit_events (fdata *f, int event)
|
||||
{
|
||||
emit_cb (f, _event_converter (event));
|
||||
}
|
||||
|
||||
static gboolean
|
||||
process_events (gpointer udata)
|
||||
{
|
||||
node_op_t op = {NULL, NULL, pre_del_cb, NULL};
|
||||
fdata* f;
|
||||
fnode_event_t* ev;
|
||||
int e;
|
||||
|
||||
/* FD_W ("IN <======== %s\n", __func__); */
|
||||
|
||||
f = (fdata*)udata;
|
||||
FD_W ("%s 0x%p id:%-4d %s\n", __func__, f, f->eventq_id, FN_NAME(f));
|
||||
|
||||
G_LOCK (fen_lock);
|
||||
|
||||
if (!FN_IS_LIVING(f)) {
|
||||
f->eventq_id = 0;
|
||||
G_UNLOCK (fen_lock);
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if ((ev = (fnode_event_t*)g_queue_pop_head (f->eventq)) != NULL) {
|
||||
/* Send events to clients. */
|
||||
e = ev->e;
|
||||
if (!ev->is_pending) {
|
||||
#ifdef GIO_COMPILATION
|
||||
if (ev->has_twin) {
|
||||
fdata_emit_events (f, FILE_ATTRIB);
|
||||
}
|
||||
#endif
|
||||
fdata_emit_events (f, ev->e);
|
||||
}
|
||||
|
||||
fnode_event_delete (ev);
|
||||
ev = NULL;
|
||||
|
||||
/* Adjust node state. */
|
||||
/*
|
||||
* Node the node has been created, so we can delete create event in
|
||||
* optimizing. To reduce the statings, we add it to Port on discoving
|
||||
* it then emit CREATED event. So we don't need to do anything here.
|
||||
*/
|
||||
switch (e) {
|
||||
case FILE_MODIFIED:
|
||||
case MOUNTEDOVER:
|
||||
case UNMOUNTED:
|
||||
/* If the event is a changed event, then pending process it */
|
||||
if (f->change_update_id == 0) {
|
||||
f->change_update_id = g_timeout_add (get_scalable_scan_time(f),
|
||||
(GSourceFunc)fdata_adjust_changed,
|
||||
(gpointer)f);
|
||||
g_assert (f->change_update_id > 0);
|
||||
}
|
||||
break;
|
||||
case FILE_ATTRIB: /* Ignored */
|
||||
case FILE_DELETE:
|
||||
break;
|
||||
default:
|
||||
g_assert_not_reached ();
|
||||
break;
|
||||
}
|
||||
/* Process one event a time */
|
||||
G_UNLOCK (fen_lock);
|
||||
return TRUE;
|
||||
}
|
||||
f->eventq_id = 0;
|
||||
G_UNLOCK (fen_lock);
|
||||
/* FD_W ("OUT ========> %s\n", __func__); */
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/**
|
||||
* fdata_add_event:
|
||||
*
|
||||
*/
|
||||
void
|
||||
fdata_add_event (fdata *f, fnode_event_t *ev)
|
||||
{
|
||||
node_op_t op = {NULL, NULL, pre_del_cb, NULL};
|
||||
fnode_event_t *tail;
|
||||
|
||||
if (!FN_IS_LIVING(f)) {
|
||||
fnode_event_delete (ev);
|
||||
return;
|
||||
}
|
||||
|
||||
FD_W ("%s %d\n", __func__, ev->e);
|
||||
g_get_current_time (&ev->t);
|
||||
/*
|
||||
* If created/deleted events of child node happened, then we use parent
|
||||
* event queue to handle.
|
||||
* If child node emits deleted event, it seems no changes for the parent
|
||||
* node, but the attr is changed. So we may try to cancel processing the
|
||||
* coming changed events of the parent node.
|
||||
*/
|
||||
tail = (fnode_event_t*)g_queue_peek_tail (f->eventq);
|
||||
switch (ev->e) {
|
||||
case FILE_RENAME_FROM:
|
||||
case FILE_RENAME_TO:
|
||||
case FILE_ACCESS:
|
||||
fnode_event_delete (ev);
|
||||
g_assert_not_reached ();
|
||||
return;
|
||||
case FILE_DELETE:
|
||||
/* clear changed event number */
|
||||
f->changed_event_num = 0;
|
||||
/*
|
||||
* We will cancel all previous events.
|
||||
*/
|
||||
if (tail) {
|
||||
g_queue_pop_tail (f->eventq);
|
||||
do {
|
||||
fnode_event_delete (tail);
|
||||
} while ((tail = (fnode_event_t*)g_queue_pop_tail (f->eventq)) != NULL);
|
||||
}
|
||||
/*
|
||||
* Given a node "f" is deleted, process it ASAP.
|
||||
*/
|
||||
fdata_emit_events (f, ev->e);
|
||||
fnode_event_delete (ev);
|
||||
fdata_adjust_deleted (f);
|
||||
return;
|
||||
case FILE_MODIFIED:
|
||||
case UNMOUNTED:
|
||||
case MOUNTEDOVER:
|
||||
/* clear changed event number */
|
||||
f->changed_event_num ++;
|
||||
case FILE_ATTRIB:
|
||||
default:
|
||||
/*
|
||||
* If in the time range, we will try optimizing
|
||||
* (changed+) to (changed)
|
||||
* (attrchanged changed) to ([changed, attrchanged])
|
||||
* (event attrchanged) to ([event, attrchanged])
|
||||
*/
|
||||
if (tail) {
|
||||
do {
|
||||
if (tail->e == ev->e) {
|
||||
if (g_timeval_lt (&ev->t, &tail->t)) {
|
||||
g_queue_peek_tail (f->eventq);
|
||||
/* Add the increment */
|
||||
g_time_val_add (&ev->t, PAIR_EVENTS_INC_TIMEVAL);
|
||||
/* skip the previous event */
|
||||
FD_W ("SKIPPED -- %s\n", _event_string (tail->e));
|
||||
fnode_event_delete (tail);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
} else if (tail->e == FILE_ATTRIB && ev->e == FILE_MODIFIED) {
|
||||
ev->has_twin = TRUE;
|
||||
fnode_event_delete (tail);
|
||||
} else if (ev->e == FILE_ATTRIB) {
|
||||
tail->has_twin = TRUE;
|
||||
/* skip the current event */
|
||||
fnode_event_delete (ev);
|
||||
return;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
} while ((tail = (fnode_event_t*)g_queue_peek_tail (f->eventq)) != NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/* must add the threshold time */
|
||||
g_time_val_add (&ev->t, PAIR_EVENTS_TIMEVAL);
|
||||
|
||||
g_queue_push_tail (f->eventq, ev);
|
||||
|
||||
/* starting process_events */
|
||||
if (f->eventq_id == 0) {
|
||||
f->eventq_id = g_timeout_add (PROCESS_EVENTQ_TIME,
|
||||
process_events,
|
||||
(gpointer)f);
|
||||
g_assert (f->eventq_id > 0);
|
||||
}
|
||||
FD_W ("%s 0x%p id:%-4d %s\n", __func__, f, f->eventq_id, FN_NAME(f));
|
||||
}
|
||||
|
||||
gboolean
|
||||
fdata_class_init (void (*user_emit_cb) (fdata*, int),
|
||||
void (*user_emit_once_cb) (fdata*, int, gpointer),
|
||||
int (*user_event_converter) (int event))
|
||||
{
|
||||
FD_W ("%s\n", __func__);
|
||||
if (user_emit_cb == NULL) {
|
||||
return FALSE;
|
||||
}
|
||||
if (user_emit_once_cb == NULL) {
|
||||
return FALSE;
|
||||
}
|
||||
if (user_event_converter == NULL) {
|
||||
return FALSE;
|
||||
}
|
||||
emit_cb = user_emit_cb;
|
||||
emit_once_cb = user_emit_once_cb;
|
||||
_event_converter = user_event_converter;
|
||||
|
||||
if (!port_class_init (fdata_add_event)) {
|
||||
FD_W ("port_class_init failed.");
|
||||
return FALSE;
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
Reference in New Issue
Block a user