discovery.c

Go to the documentation of this file.

#include <projectcommon.h>
#define DISCOVERY_SUBCLASS
#include <discovery.h>
#include <assert.h>

FSTATIC char *          _discovery_instancename(const Discovery* self);
FSTATIC void            _discovery_flushcache(Discovery* self);
FSTATIC guint           _discovery_discoverintervalsecs(const Discovery* self);
FSTATIC gboolean        _discovery_rediscover(gpointer vself);
FSTATIC void            _discovery_ghash_destructor(gpointer gdiscovery);

DEBUGDECLARATIONS

FSTATIC char *
_discovery_instancename(const Discovery* self)  
{
        return self->_instancename;
}

FSTATIC void
_discovery_flushcache(Discovery* self)  
{
        (void)self;
}

FSTATIC guint
_discovery_discoverintervalsecs(const Discovery* self)  
{
        (void)self;
        return 0;
}
static GHashTable * _discovery_timers = NULL;

FSTATIC void
_discovery_finalize(AssimObj* gself)    
{
        Discovery*      self = CASTTOCLASS(Discovery, gself);
        char *          instancename = self->_instancename;
        
        if (self->_timerid > 0) {
                g_source_remove(self->_timerid);
                self->_timerid = 0;
        }
        if (self->_config) {
                UNREF(self->_config);
        }
        if (_discovery_timers && instancename) {
                self->_instancename = NULL;     // Avoid infinite recursion...
                g_hash_table_remove(_discovery_timers, instancename);
        }
        if (instancename) {
                g_free(instancename);
                self->_instancename = instancename = NULL;
        }
        
        FREECLASSOBJ(self); self=NULL;
}

FSTATIC void
_discovery_ghash_destructor(gpointer gdiscovery)
{
        Discovery*      self = CASTTOCLASS(Discovery, gdiscovery);
        // We take steps in discovery_finalize() to avoid infinite recursion...
        UNREF(self);
}

FSTATIC gboolean
_discovery_rediscover(gpointer vself)   
{
        Discovery*      self = CASTTOCLASS(Discovery, vself);

        return self->discover(self);
}

Discovery*
discovery_new(const char *      instname,       
              NetGSource*       iosource,       
              ConfigContext*    context,        
              gsize objsize)                    
{
        gsize   size = objsize < sizeof(Discovery) ? sizeof(Discovery) : objsize;
        Discovery * ret = NEWSUBCLASS(Discovery, assimobj_new(size));
        g_return_val_if_fail(ret != NULL, NULL);
        BINDDEBUG(Discovery);
        ret->_instancename              = g_strdup(instname);
        ret->instancename               = _discovery_instancename;
        ret->discoverintervalsecs       = _discovery_discoverintervalsecs;
        ret->baseclass._finalize        = _discovery_finalize;
        ret->discover                   = NULL;
        ret->_timerid                   = 0;
        ret->_iosource                  = iosource;
        ret->_config                    = context;
        REF(ret->_config);
        return ret;
}


void
discovery_register(Discovery* self)     
{
        gint    timeout;
        if (NULL == _discovery_timers) {
                _discovery_timers = g_hash_table_new_full(g_str_hash, g_str_equal
                ,       NULL, _discovery_ghash_destructor);
                assert(_discovery_timers != NULL);
        }
        self->discover(self);
        timeout = self->discoverintervalsecs(self);
        if (timeout > 0) {
                self->_timerid = g_timeout_add_seconds(timeout, _discovery_rediscover, self);
        }
        REF(self);
        g_hash_table_replace(_discovery_timers, self->instancename(self), self);
}
FSTATIC void
discovery_unregister(const char* instance)
{
        if (_discovery_timers) {
                g_hash_table_remove(_discovery_timers, instance);
        }
}

void
discovery_unregister_all(void)
{
        if (_discovery_timers != NULL) {
                GHashTable*     timers = _discovery_timers;
                _discovery_timers = NULL;
                g_hash_table_remove_all(timers);
                g_hash_table_destroy(timers); timers = NULL;
        }else{
                DEBUGMSG1("Discovery timers were NULL");
        }
}