Changeset 12142

Timestamp:

09/12/07 09:05:58 (1 year ago)

Author:

piotras

Message:

Copied from trunk

Files:

• branches/branch-1-9/midgard/core/midgard/midgard/midgard_error.h (modified) (2 diffs)
• branches/branch-1-9/midgard/core/midgard/src/midgard_error.c (modified) (2 diffs)

branches/branch-1-9/midgard/core/midgard/midgard/midgard_error.h

@@ -126 +126 @@
-
-/**
+ * \ingroup midgard_error
+ *
+ * Default function for log messages.
+ *
+ * \param domain, domain for the given log message
+ * \param level, GLogLevelFlags
+ * \param msg, log message
+ * \param ptr, pointer to structure which holds loglevel 
+ *
+ * \c ptr pointer may be a pointer to MidgardConnection or MidgardTypeHolder
+ * structure. This function checks pointer type using MIDGARD_IS_CONNECTION
+ * convention macro. Next midgard_connection_get_loglevel is called to get loglevel.
+ * If MidgardConnection check fails , a typecast to MidgardTypeHolder is made.
+ * In this case, level member is used to get loglevel.
+ *
+ * You are responsible to correctly set MidgardConnection or MidgardTypeHolder
+ * before passing ptr argument. The main approach is to follow configuration's
+ * loglevel even if MidgardConnection pointer is not yet available.
+ *
+ * Use midgard_connection_set_loglevel to set log level.        
+ *
+ */
+extern void midgard_error_default_log(const gchar *domain, GLogLevelFlags level,
+                const gchar *msg, gpointer ptr);
+
+/**
+ * \ingroup midgard_error
+ *
+ * Get GLogLevelFlags value from loglevel string.
+ *
+ * \param levelstring, string which should be parsed
+ *
+ * \return GLogLevelFlags or -1 on failure
+ *
+ */
+extern gint midgard_error_parse_loglevel(const gchar *levelstring);
+
+/**
- * \ingroup midgard_error 
- *
@@ -134 +172 @@
-
-#define MIDGARD_ERRNO_SET(str, errcode)  \
-
+ 
-        midgard_set_error(str->_mgd, \
-
-
-
-
+
+
+
+
+
-
-G_END_DECLS

branches/branch-1-9/midgard/core/midgard/src/midgard_error.c

@@ -18 +18 @@
-
-#include <midgard/midgard_error.h>
-
+
+
+
+
-
-GQuark midgard_error_generic(void)
@@ -178 +181 @@
-        mgd->errstr = g_strdup(mgd->err->message);      
-
-        /* FIXME, remove later , this is legacy compatible stuff */
-        if(mgd->mgd)
-                mgd->mgd->errn = errcode;       
-        
-        return;         
-}
+
+/* Default function for log messages. */
+void midgard_error_default_log(const gchar *domain, GLogLevelFlags level,
+                const gchar *msg, gpointer ptr)
+{
+        gchar *level_ad = NULL;
+        guint mlevel;
+        GIOChannel *channel = NULL;
+        MidgardConnection *mgd;
+        MidgardTypeHolder *holder;
+
+        if(ptr == NULL) {
+
+                mlevel = G_LOG_LEVEL_WARNING;
+        
+        } else {
+                
+                if(MIDGARD_IS_CONNECTION((MidgardConnection *) ptr)) {
+                        
+                        mgd = MIDGARD_CONNECTION(ptr);
+                        mlevel = midgard_connection_get_loglevel(mgd);
+                        if(mgd->priv->config != NULL && mgd->priv->config->private != NULL)
+                                channel = mgd->priv->config->private->log_channel;
+                
+                } else {
+                        
+                        holder = (MidgardTypeHolder *) ptr;
+                        mlevel = holder->level;
+                }
+        }
+
+        switch (level) {
+                case G_LOG_FLAG_RECURSION:
+                        level_ad =  "RECURSION";
+                        break;
+                        
+                case G_LOG_FLAG_FATAL:
+                        level_ad = "FATAL! ";
+                        break;
+                        
+                case G_LOG_LEVEL_ERROR:
+                        level_ad =  "ERROR";
+                        break;
+                        
+                case G_LOG_LEVEL_CRITICAL:
+                        level_ad = "CRITICAL ";
+                        break;
+                        
+                case G_LOG_LEVEL_WARNING:
+                        level_ad =  "WARNING";
+                        break;
+                        
+                case G_LOG_LEVEL_MESSAGE:
+                        level_ad = "m";
+                        break;
+                
+                case G_LOG_LEVEL_INFO:
+                        level_ad = "info";
+                        break;
+                        
+                case G_LOG_LEVEL_DEBUG:
+                        level_ad = "debug";
+                        break;
+
+                default:
+                        level_ad = "midgard-unknown-log-level";
+                        break;
+                        
+        }
+
+        if (mlevel >= level) {
+        
+                GString *logstr = g_string_new("");
+                g_string_append_printf(logstr,
+                                "%s (pid:%ld):(%s):%s\n",
+                                domain,
+                                (unsigned long)getpid(),
+                                level_ad,
+                                msg);
+        
+                gchar *tmpstr = g_string_free(logstr, FALSE);
+
+                if(channel) {
+
+                        g_io_channel_write_chars(channel,
+                                        (const gchar *)tmpstr,
+                                        -1, NULL, NULL);
+                        g_io_channel_flush(channel, NULL);
+                        
+                } else {
+
+                        fprintf(stderr, "%s", tmpstr);
+                        fflush(stderr);
+                }
+
+                g_free(tmpstr);
+        }
+}
+
+/* Get GLogLevelFlags value from loglevel string */
+gint midgard_error_parse_loglevel(const gchar *levelstring)
+{
+        g_assert(levelstring != 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, "warning"))
+                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;
+                        }
+                        return  mask;
+                        break;
+
+                default:
+                        return -1;
+        }
+        
+        return -1;      
+}