src/midgard_connection.c

/* 
 * Copyright (C) 2006 Piotr Pokora <piotr.pokora@infoglob.pl>
 *
 * This program 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 program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "midgard/midgard_connection.h"
#include "midgard/midgard_error.h"
#include "schema.h"
#include "midgard/midgard_legacy.h"

struct _MidgardConnectionPrivate{

        MidgardConfig *config;
        guint loghandler;
        guint loglevel;
        const gchar *sitegroup;
        const gchar *lang;
        guint lang_id;
        MidgardSchema *schema;  
}; 

static void _midgard_connection_finalize(GObject *object)
{
        g_assert(object != NULL);
        MidgardConnection *self = (MidgardConnection *) object;

        self->private->loghandler = 0;
        if(self->private->sitegroup)
                g_free((gchar *) self->private->sitegroup);
        if(self->private->lang)
                g_free((gchar *) self->private->lang);
        g_clear_error(&self->err);
        g_free(self->private);
}

static void _midgard_connection_class_init(
                gpointer g_class, gpointer g_class_data)
{
        GObjectClass *gobject_class = G_OBJECT_CLASS (g_class);
        MidgardConnectionClass *klass = MIDGARD_CONNECTION_CLASS (g_class);

        gobject_class->finalize = _midgard_connection_finalize;
        klass->open = midgard_connection_open;
        klass->open_config = midgard_connection_open_config;
        klass->close = midgard_connection_close;
        klass->set_sitegroup = midgard_connection_set_sitegroup;
        klass->get_sitegroup = midgard_connection_get_sitegroup;
        klass->set_lang = midgard_connection_set_lang; 
        klass->get_lang = midgard_connection_get_lang;
        klass->set_loglevel = midgard_connection_set_loglevel;
        klass->get_loglevel = midgard_connection_get_loglevel;
        klass->set_loghandler = midgard_connection_set_loghandler;
        klass->get_loghandler = midgard_connection_get_loghandler;
}

static void _midgard_connection_instance_init(
                GTypeInstance *instance, gpointer g_class)
{
        MidgardConnection *self = (MidgardConnection *) instance;
        self->private = g_new(MidgardConnectionPrivate, 1);

        self->private->config = NULL;
        self->private->loghandler = 0;
        self->private->loglevel = 0; 
        self->private->sitegroup = NULL;
        self->private->lang = NULL;
        self->private->lang_id = 0;
        self->err = NULL;
        self->errstr = NULL;
}

/* Registers the type as  a fundamental GType unless already registered. */
GType midgard_connection_get_type(void)
{
        static GType type = 0;
        if (type == 0) {
                static const GTypeInfo info = {
                        sizeof (MidgardConnectionClass),
                        NULL,           /* base_init */
                        NULL,           /* base_finalize */
                        (GClassInitFunc) _midgard_connection_class_init,
                        NULL,           /* class_finalize */
                        NULL,           /* class_data */
                        sizeof (MidgardConnection),
                        0,              /* n_preallocs */
                        (GInstanceInitFunc) _midgard_connection_instance_init /* instance_init */
                };
                type = g_type_register_static (G_TYPE_OBJECT,
                                "midgard_connection",
                                &info, 0);
        }
        return type;
}

/* Creates new MidgardConnection object instance. */ 
MidgardConnection *midgard_connection_new(void){
        
        MidgardConnection *self = 
                g_object_new(MIDGARD_TYPE_CONNECTION, NULL);
        
        return self;
}

gboolean __midgard_connection_open(
                MidgardConnection *mgd, MidgardConfig *config, GError *err)
{
        gchar *host, *dbname, *dbuser, *dbpass, *schemafile, *loglevel;
        g_object_get(G_OBJECT(mgd->private->config),
                        "host", &host,
                        "database", &dbname,
                        "dbuser", &dbuser,
                        "dbpass", &dbpass,
                        "schema", &schemafile,
                        "loglevel", &loglevel,
                        NULL);
        
        /* FIXME when we switch to libgda usage */
        midgard *legacy_mgd = mgd_connect(
                        host,
                        dbname,
                        dbuser,
                        dbpass);

        if(!legacy_mgd) {
                midgard_set_error(mgd,
                                MGD_GENERIC_ERROR,
                                MGD_ERR_NOT_CONNECTED,
                                "Database %s@%s.", dbname, host);
                g_warning("%s", err->message);
                g_clear_error(&err); 
                return FALSE;
        }

        MidgardSchema *schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL);
        midgard_schema_init(schema);
        midgard_schema_read_dir(schema, MIDGARD_LSCHEMA_DIR);

        mgd->private->schema = schema;
        midgard_connection_set_loglevel(mgd, loglevel);
                
        /* Set legacy midgard connection handler's data*/
        gchar *mgduser = NULL, *mgdpass = NULL, *blobdir;
        g_object_get(mgd->private->config,
                        "midgardusername", &mgduser,
                        "midgardpassword", &mgdpass,
                        "blobdir", &blobdir,
                        NULL);

        legacy_mgd->blobdir = blobdir;
        legacy_mgd->loglevel = midgard_connection_get_loglevel(mgd);
        mgd->mgd = legacy_mgd;
        legacy_mgd->_mgd = mgd;
        
        /* This is commented:
         1. I am not sure if this is application specific
                -  requires special config object  management
                ( like check for root id when getting some secret data )
         2. Core's loghandler should be initialized before to avoid 
         unconditional debug logs before we switch to application's log handler
         and log function
        */ 
        /* if((mgduser != NULL) && (mgdpass != NULL))
                mgd_auth(legacy_mgd, mgduser, mgdpass, 1);
        */
        g_free(host);
        g_free(dbname);
        g_free(dbuser);
        g_free(dbpass);
        g_free(schemafile);
        g_free(loglevel);
        g_free(mgduser);
        g_free(mgdpass);
        g_free(blobdir);
        
        return TRUE;
}

/* Opens a connection to the named Midgard database. */
gboolean midgard_connection_open(
                MidgardConnection *mgd, const char *name, GError *err)
{       
        g_assert(mgd != NULL);
        g_assert (name != NULL);
        g_assert(err == NULL);
        
        if(mgd->private->config != NULL){
                midgard_set_error(mgd,
                                MGD_GENERIC_ERROR,
                                MGD_ERR_USER_DATA,
                                "MidgardConfig already associated with "
                                "MidgardConnection");
                g_warning("%s", err->message);
                return FALSE;
        }
        
        MidgardConfig *config = midgard_config_new();
        if(!midgard_config_read_file(config, name))
                return FALSE;
        
        mgd->private->config = config;

        if(!__midgard_connection_open(mgd, config, err))
                return FALSE;

        return TRUE;    
}

/* Opens a Midgard connection with the given configuration. */
gboolean midgard_connection_open_config(
                MidgardConnection *mgd, MidgardConfig *config, GError *err)
{
        g_assert(mgd != NULL);  
        g_assert(config != NULL);
        g_assert(err == NULL);

        mgd->private->config = config;
        
        if(!__midgard_connection_open(mgd, config, err))
                return FALSE;
        
        return TRUE;
}

/* Closes database connection. */ 
void midgard_connection_close(MidgardConnection *mgd)
{
        g_assert(mgd != NULL);
        
        if(mgd->mgd)
                mgd_close(mgd->mgd);

        g_object_unref(G_OBJECT(mgd));
        
        return;
}

/* Sets sitegroup's value for the given MidgardConnection. */ 
gboolean midgard_connection_set_sitegroup(
                MidgardConnection *mgd, const gchar *guid)
{
        g_assert(mgd != NULL);
        g_assert(guid != NULL);

        if((mgd->private->sitegroup = (const gchar *)g_strdup(guid)))
                return TRUE;
        
        return FALSE;
}

/* Return the sitegroup of the given MidgardConnection. */ 
const gchar *midgard_connection_get_sitegroup(
                MidgardConnection *mgd)
{
        g_assert(mgd != NULL);
        g_assert(mgd->private->sitegroup != NULL);

        return mgd->private->sitegroup;
}

/* Sets the language of the given Midgard connection. */
gboolean midgard_connection_set_lang(
                MidgardConnection *mgd, const char *language)
{
        g_assert(mgd != NULL);
        g_assert(language != NULL);

        if((mgd->private->lang = (const gchar *)g_strdup(language)))
                return TRUE;
        
        return FALSE;
}

/* Returns language of the given MidgardConnection. */
const gchar *midgard_connection_get_lang(MidgardConnection *mgd)
{
        g_assert(mgd != NULL);
        
        return mgd->private->lang;
}

/* Sets log level of the given MidgardConnection. */
void midgard_connection_set_loglevel(
                MidgardConnection *mgd, const gchar *levelstring)
{
        g_assert(mgd != NULL);

        guint level = 0, mask = 0;
        guint len = strlen(levelstring);
        gchar *newlevel = g_ascii_strdown(levelstring, len);

        if(g_str_equal(newlevel, "error")) 
                level = G_LOG_LEVEL_ERROR;
        if(g_str_equal(newlevel, "critical"))
                level = G_LOG_LEVEL_CRITICAL;
        if(g_str_equal(newlevel, "warn"))
                level = G_LOG_LEVEL_WARNING;
        if(g_str_equal(newlevel, "message"))    
                level = G_LOG_LEVEL_MESSAGE;
        if(g_str_equal(newlevel, "info"))
                level = G_LOG_LEVEL_INFO;
        if(g_str_equal(newlevel, "debug"))
                level = G_LOG_LEVEL_DEBUG;

        g_free(newlevel);
        
        switch(level){

                case G_LOG_LEVEL_ERROR:
                case G_LOG_LEVEL_CRITICAL:
                case G_LOG_LEVEL_WARNING:
                case G_LOG_LEVEL_MESSAGE:
                case G_LOG_LEVEL_INFO:
                case G_LOG_LEVEL_DEBUG:
                        for (; level && level > G_LOG_FLAG_FATAL; level >>= 1) {
                                mask |= level;
                        }
                        mgd->private->loglevel = mask;
                        break;

                default:
                        midgard_set_error(mgd,
                                        MGD_GENERIC_ERROR,
                                        MGD_ERR_INTERNAL,
                                        "Unknown log level.");
                        g_error("%s", mgd->err->message);
        }
        return;
}

/* Get loglevel's value. */
guint midgard_connection_get_loglevel(MidgardConnection *mgd)
{
        g_assert(mgd != NULL);

        return mgd->private->loglevel;
}

/* Sets loghandler of the given MidgardConnection. */
void midgard_connection_set_loghandler(
                MidgardConnection *mgd, guint loghandler){

        g_assert(mgd != NULL);

        if(mgd->private->loghandler == 0) 
                mgd->private->loghandler = loghandler;

        return;
}

/* Get loghandler associated with MidgardConnection. */
guint midgard_connection_get_loghandler(MidgardConnection *mgd)
{
        g_assert(mgd != NULL);
        
        return mgd->private->loghandler;
}

---