fen-data.c

this is a glib for c language

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* vim:set expandtab ts=4 shiftwidth=4: */
/* 
 * Copyright (C) 2008 Sun Microsystems, Inc. All rights reserved.
 * Use is subject to license terms.
 *
 * 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 <[e-mail]>
 */

#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

#ifdef GIO_COMPILATION
#define FD_W if (fd_debug_enabled) g_warning
static gboolean fd_debug_enabled = FALSE;
#else
#include "gam_error.h"
#define FD_W(...) GAM_DEBUG(DEBUG_INFO, __VA_ARGS__)
#endif

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 {