Changeset 21895

Show
Ignore:
Timestamp:
04/20/09 12:31:45 (1 year ago)
Author:
piotras
Message:

Configuration file allows to declare any paths. Fixes #1074.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • branches/vinland/core/midgard/conf.d/midgard.conf.example

    r21745 r21895  
    22# Do not create config files with conf extension 
    33 
    4 [Database] 
     4[MidgardDir] 
     5 
     6# Shared files, architecture independent 
     7# Default is $prefix/share/midgard 
     8#ShareDir= 
     9 
     10# Application specific files 
     11# Default is /var(/local)/lib/midgard 
     12#VarDir= 
     13 
     14# Directory to store binary data 
     15# Default is /var(/local)/lib/midgard/blobs/DBNAME 
     16#BlobDir= 
     17 
     18# Directory for cached data 
     19# Default is /var/cache/midgard 
     20#CacheDir= 
     21 
     22[MidgardDatabase] 
    523 
    624#Database type, by default MySQL 
     
    2240#Default language used by application. Unknown by default. 
    2341#DefaultLanguage=pl 
    24  
    25 #Full path to directory where blobs are stored. 
    26 #By default we set /var/lib/midgard/blobs/DATABASE_NAME 
    27 #/var/lib depends on prefix which was set for midgard-core 
    28 Blobdir= 
    29  
    30 #Full path to local schema directory. 
    31 #By default all schema are read from /usr/share/midgard/schema directory. 
    32 #/usr/share depends on prefix which was set for midgard-core 
    33 #SchemaDir= 
    3442 
    3543#Full path to logfile. In none is defined output will be printed to stdout. 
  • branches/vinland/core/midgard/src/mgdschema.c

    r21745 r21895  
    15191519 
    15201520/* Initializes basic Midgard classes */ 
    1521 void midgard_schema_init(MidgardSchema *self
     1521void midgard_schema_init(MidgardSchema *self, const gchar *path
    15221522{        
    15231523        g_assert(self != NULL); 
    15241524 
    1525         /* Check if common MgdObjects.xml exists. And read. */ 
    1526         const gchar *path = MIDGARD_GLOBAL_SCHEMA; 
     1525        if (path == NULL) 
     1526               path = MIDGARD_GLOBAL_SCHEMA; 
    15271527 
    15281528        if (g_file_test(path, G_FILE_TEST_IS_DIR)) { 
     
    15341534        if (!g_file_test(path, G_FILE_TEST_EXISTS)) { 
    15351535 
    1536                 g_debug("Common MgdObject.xml file (%s) doesn't exist. Ignoring common types then.", path); 
     1536                g_warning("Common MgdObjects.xml file (%s) doesn't exist.", path); 
    15371537                return; 
    15381538        } 
  • branches/vinland/core/midgard/src/midgard.c

    r21569 r21895  
    3131#include "midgard_sitegroup.h" 
    3232#include "midgard_collector.h" 
     33#include <libgda/libgda.h> 
    3334 
    3435const char *midgard_version() 
     
    4041{        
    4142        GType type; 
     43        /* g_type_init_with_debug_flags(G_TYPE_DEBUG_OBJECTS | G_TYPE_DEBUG_NONE); */ 
    4244 
    43         g_type_init(); 
    44         /* g_type_init_with_debug_flags(G_TYPE_DEBUG_OBJECTS | G_TYPE_DEBUG_NONE); */ 
     45#ifdef HAVE_LIBGDA_4 
     46        gda_init (); 
     47#else 
     48        gda_init ("midgard-core-gda", midgard_version(), 0, NULL); 
     49#endif 
    4550 
    4651        type = MIDGARD_TYPE_BLOB; 
  • branches/vinland/core/midgard/src/midgard_config.c

    r21803 r21895  
    4949        MIDGARD_CONFIG_DBPASS,  
    5050        MIDGARD_CONFIG_HOST, 
    51         MIDGARD_CONFIG_BLOBDIR, 
    5251        MIDGARD_CONFIG_LOGFILENAME, 
    53         MIDGARD_CONFIG_SCHEMADIR, 
    5452        MIDGARD_CONFIG_DEFAULT_LANG, 
    5553        MIDGARD_CONFIG_LOGLEVEL, 
     
    6159        MIDGARD_CONFIG_MGDPASSWORD, 
    6260        MIDGARD_CONFIG_AUTHTYPE, 
    63         MIDGARD_CONFIG_PAMFILE 
     61        MIDGARD_CONFIG_PAMFILE, 
     62        MIDGARD_CONFIG_BLOBDIR, 
     63        MIDGARD_CONFIG_SHAREDIR, 
     64        MIDGARD_CONFIG_VARDIR, 
     65        MIDGARD_CONFIG_CACHEDIR 
    6466}; 
    6567 
     
    104106        iconf = g_new(mdirs,1); 
    105107         
    106         if (g_ascii_strcasecmp(MIDGARD_LIB_PREFIX, "/usr") == 0 ) { 
     108        if (g_str_equal(MIDGARD_LIB_PREFIX, "/usr")) { 
     109 
    107110                /* Set typical FSH directory */ 
    108111                iconf->confdir = g_strconcat("/etc/", MIDGARD_PACKAGE_NAME, "/conf.d", NULL); 
    109112                iconf->blobdir = g_strconcat("/var/lib/", MIDGARD_PACKAGE_NAME, "/blobs", NULL); 
     113                iconf->cachedir = g_strconcat("/var/cache/", MIDGARD_PACKAGE_NAME, NULL); 
     114                iconf->vardir = g_strconcat("/var/lib/", MIDGARD_PACKAGE_NAME, NULL); 
     115 
    110116        } else { 
     117 
    111118                /* Set any directory which follows midgard prefix */ 
    112119                iconf->confdir = g_strconcat(MIDGARD_LIB_PREFIX, "/etc/",  
     
    114121                iconf->blobdir = g_strconcat(MIDGARD_LIB_PREFIX, "/var/lib/",  
    115122                                MIDGARD_PACKAGE_NAME, "/blobs", NULL); 
     123                iconf->cachedir = g_strconcat(MIDGARD_LIB_PREFIX, "/var/cache/",  
     124                                MIDGARD_PACKAGE_NAME, NULL); 
     125                iconf->vardir = g_strconcat(MIDGARD_LIB_PREFIX, "/var/lib/",  
     126                                MIDGARD_PACKAGE_NAME, NULL); 
    116127        } 
    117128 
    118129        /* Set blobdir to /var/local when /usr/local was set as prefix */ 
    119130        if (g_str_equal(MIDGARD_LIB_PREFIX, "/usr/local")) { 
     131 
    120132                iconf->blobdir = g_strconcat("/var/local/lib/", MIDGARD_PACKAGE_NAME,  
    121133                                "/blobs", NULL); 
     134                iconf->cachedir = g_strconcat("/var/local/cache/", MIDGARD_PACKAGE_NAME, NULL); 
     135                iconf->vardir = g_strconcat("/var/local/lib/", MIDGARD_PACKAGE_NAME, NULL); 
     136 
    122137        } 
    123138         
     
    126141 
    127142        return iconf; 
    128  
    129         /* TODO, this probably could be ignored, but te point is  
    130          * to check if configuration dir ( usualy /etc/midgard/conf.d )  
    131          * is readable. However it fails when user manages his own home 
    132          * configuration file. Error handling shoudl be done when configuration  
    133          * file ( particular one ) is opened. */ 
    134         /* 
    135         dir = g_dir_open(iconf->confdir, 0, NULL); 
    136         if (dir == NULL ) { 
    137                 // No idea at this moment how to create this directory and copy example file 
    138                 // when midgard-core is installed   
    139                 g_error("Unable to open %s directory" , iconf->confdir); 
    140                 g_free(iconf->confdir); 
    141                 g_free(iconf->blobdir); 
    142                 g_free(iconf->sharedir); 
    143                 iconf = NULL; 
    144                 return NULL; 
    145         } else { 
    146                 g_dir_close(dir); 
    147                 return iconf; 
    148         } 
    149         */ 
    150  
    151         /* should not be reached */ 
    152         iconf = NULL; 
    153         return NULL; 
    154143} 
    155144 
     
    157146{ 
    158147        if (!(iconf && *iconf)) return; 
     148 
    159149        g_free((*iconf)->confdir); 
    160150        g_free((*iconf)->blobdir); 
    161151        g_free((*iconf)->sharedir); 
     152        g_free((*iconf)->vardir); 
     153        g_free((*iconf)->cachedir); 
    162154 
    163155        g_free(*iconf); 
     
    194186void __create_log_dir(const gchar *path) 
    195187{ 
    196         if(path == NULL) 
    197                 return; 
    198          
    199         if(g_str_equal(path, "")) 
     188        if(path == NULL || *path == '\0') 
    200189                return; 
    201190         
     
    224213        /* Get database type */ 
    225214        self->priv->dbtype = MIDGARD_DB_TYPE_MYSQL; 
    226         tmpstr = g_key_file_get_string(keyfile, "Database", "Type", NULL); 
    227  
    228         if(!tmpstr || g_str_equal(tmpstr, "")) { 
     215        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "Type", NULL); 
     216        if(tmpstr == NULL || *tmpstr == '\0') { 
    229217                g_free(tmpstr); 
    230218                tmpstr = g_strdup("MySQL"); 
    231219        } 
    232  
     220         
    233221        __set_dbtype(self, tmpstr); 
    234222        g_free(tmpstr); 
    235223                 
    236224        /* Get host name or IP */ 
    237         tmpstr = g_key_file_get_string(keyfile, "Database", "Host", NULL); 
     225        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "Host", NULL); 
    238226        if(tmpstr == NULL) 
    239227                tmpstr = g_strdup("localhost"); 
     
    244232                         
    245233        /* Get database name */ 
    246         tmpstr = g_key_file_get_string(keyfile, "Database", "Name", NULL); 
    247         if(tmpstr == NULL) 
    248                 tmpstr = g_strdup("midgard"); 
    249         if(self->database) 
     234        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "Name", NULL); 
     235        if(tmpstr != NULL && *tmpstr != '\0') { 
    250236                g_free(self->database); 
    251         self->database = g_strdup(tmpstr); 
     237                self->database = g_strdup(tmpstr); 
     238        }        
    252239        g_free(tmpstr); 
    253240         
     241         
    254242        /* Get database's username */ 
    255         tmpstr = g_key_file_get_string(keyfile, "Database", "Username", NULL); 
    256         if(tmpstr == NULL) 
    257                 tmpstr = g_strdup("midgard"); 
    258         if(self->dbuser) 
     243        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "Username", NULL); 
     244        if(tmpstr != NULL && *tmpstr != '\0') { 
    259245                g_free(self->dbuser); 
    260         self->dbuser = g_strdup(tmpstr); 
     246                self->dbuser = g_strdup(tmpstr); 
     247        } 
    261248        g_free(tmpstr); 
    262249                 
    263250        /* Get password for database user */ 
    264         tmpstr = g_key_file_get_string(keyfile, "Database", "Password", NULL); 
    265         if(tmpstr == NULL) 
    266                 tmpstr = g_strdup("midgard"); 
    267         if(self->dbpass) 
     251        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "Password", NULL); 
     252        if(tmpstr != NULL && *tmpstr != '\0') { 
    268253                g_free(self->dbpass); 
    269         self->dbpass = g_strdup(tmpstr); 
     254                self->dbpass = g_strdup(tmpstr); 
     255        } 
    270256        g_free(tmpstr); 
    271257 
    272258        /* Get default language */ 
    273         tmpstr = g_key_file_get_string(keyfile, "Database", "DefaultLanguage", NULL);  
    274         if(tmpstr == NULL) 
    275                 self->default_lang = NULL; 
    276         else  
     259        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "DefaultLanguage", NULL);  
     260        if(tmpstr != NULL && *tmpstr != '\0') { 
     261                g_free(self->default_lang); 
    277262                self->default_lang = g_strdup(tmpstr); 
    278  
     263        } 
    279264        g_free(tmpstr); 
    280  
    281         /* Get blobs' path */ 
    282         tmpstr = g_key_file_get_string(keyfile, "Database", "Blobdir", NULL); 
    283         if(tmpstr == NULL) { 
    284                 self->blobdir =  
    285                         g_strconcat(iconf->blobdir, "/", self->database, NULL); 
    286         } else { 
    287                 self->blobdir = g_strdup(tmpstr); 
    288                 g_free(tmpstr); 
    289         } 
    290                  
    291         /* Get schema file */ 
    292         tmpstr = g_key_file_get_string(keyfile, "Database", "SchemaDir", NULL); 
    293         if(tmpstr) { 
    294                 self->schemadir = g_strdup(tmpstr); 
    295                 g_free(tmpstr); 
    296                 tmpstr = NULL; 
    297         } 
    298          
     265                         
    299266        /* Get log filename */ 
    300         tmpstr = g_key_file_get_string(keyfile, "Database", "Logfile", NULL); 
     267        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "Logfile", NULL); 
    301268        GIOChannel *channel = NULL; 
    302269        if(tmpstr != NULL && !g_str_equal(tmpstr, "")) { 
     
    328295         
    329296        /* Get log level */ 
    330         tmpstr = g_key_file_get_string(keyfile, "Database", "Loglevel", NULL); 
     297        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "Loglevel", NULL); 
    331298        if(tmpstr == NULL) 
    332299                tmpstr = g_strdup("warn"); 
     
    338305 
    339306        /* Get database creation mode */ 
    340         tmpbool = g_key_file_get_boolean(keyfile, "Database", "TableCreate", NULL); 
     307        tmpbool = g_key_file_get_boolean(keyfile, "MidgardDatabase", "TableCreate", NULL); 
    341308        self->tablecreate = tmpbool; 
    342309         
    343310 
    344311        /* Get database update mode */ 
    345         tmpbool = g_key_file_get_boolean(keyfile, "Database", "TableUpdate", NULL); 
     312        tmpbool = g_key_file_get_boolean(keyfile, "MidgardDatabase", "TableUpdate", NULL); 
    346313        self->tableupdate = tmpbool; 
    347314 
    348315        /* Get SG admin username */ 
    349         tmpstr = g_key_file_get_string(keyfile, "Database", "MidgardUsername", NULL); 
    350         if(tmpstr != NULL) { 
     316        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "MidgardUsername", NULL); 
     317        if(tmpstr != NULL && *tmpstr != '\0') { 
    351318                if(self->mgdusername) 
    352319                        g_free(self->mgdusername); 
     
    356323         
    357324        /* Get SG admin password */ 
    358         tmpstr = g_key_file_get_string(keyfile, "Database", "MidgardPassword", NULL); 
    359         if(tmpstr != NULL) { 
     325        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "MidgardPassword", NULL); 
     326        if(tmpstr != NULL && *tmpstr != '\0') { 
    360327                if(self->mgdpassword) 
    361328                        g_free(self->mgdpassword); 
     
    365332         
    366333        /* Get test mode */ 
    367         tmpbool = g_key_file_get_boolean(keyfile, "Database", "TestUnit", NULL); 
     334        tmpbool = g_key_file_get_boolean(keyfile, "MidgardDatabase", "TestUnit", NULL); 
    368335        self->testunit = tmpbool; 
    369336         
    370337        /* Get auth type */ 
    371         tmpstr = g_key_file_get_string(keyfile, "Database", "AuthType", NULL); 
     338        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "AuthType", NULL); 
    372339        midgard_config_set_authtype(self, (const gchar *)tmpstr); 
    373340        g_free(tmpstr); 
    374341         
    375342        /* Get Pam file */ 
    376         tmpstr = g_key_file_get_string(keyfile, "Database", "PamFile", NULL); 
     343        tmpstr = g_key_file_get_string(keyfile, "MidgardDatabase", "PamFile", NULL); 
    377344        if(tmpstr == NULL) 
    378345                tmpstr = g_strdup("midgard"); 
     
    381348 
    382349        /* Disable threads */ 
    383         tmpbool = g_key_file_get_boolean(keyfile, "Database", "GdaThreads", NULL); 
     350        tmpbool = g_key_file_get_boolean(keyfile, "MidgardDatabase", "GdaThreads", NULL); 
    384351        self->gdathreads = tmpbool; 
     352 
     353        /* DIRECTORIES */ 
     354         
     355        /* BlobDir */ 
     356        tmpstr = g_key_file_get_string(keyfile, "MidgardDir", "BlobDir", NULL); 
     357        if(tmpstr != NULL && *tmpstr != '\0') { 
     358 
     359                g_free(self->blobdir); 
     360                self->blobdir = g_strdup(tmpstr); 
     361                g_free(tmpstr); 
     362         
     363        } else { 
     364 
     365                g_free(self->blobdir); 
     366                self->blobdir =  
     367                        g_strconcat(iconf->blobdir, "/", self->database, NULL); 
     368 
     369        } 
     370 
     371        /* ShareDir */ 
     372        tmpstr = g_key_file_get_string(keyfile, "MidgardDir", "ShareDir", NULL); 
     373        if(tmpstr == NULL || *tmpstr == '\0') { 
     374 
     375                g_free(self->sharedir); 
     376                self->sharedir = g_strdup(iconf->sharedir); 
     377 
     378        } else { 
     379 
     380                g_free(self->sharedir); 
     381                self->sharedir = g_strdup(tmpstr); 
     382                g_free(tmpstr); 
     383        } 
     384 
     385        /* VarDir */ 
     386        tmpstr = g_key_file_get_string(keyfile, "MidgardDir", "VarDir", NULL); 
     387        if(tmpstr == NULL || *tmpstr == '\0') { 
     388 
     389                g_free(self->vardir); 
     390                self->vardir = g_strdup(iconf->vardir); 
     391 
     392        } else { 
     393 
     394                g_free(self->vardir); 
     395                self->vardir = g_strdup(tmpstr); 
     396                g_free(tmpstr); 
     397        } 
     398 
     399        /* CacheDir */ 
     400        tmpstr = g_key_file_get_string(keyfile, "MidgardDir", "ShareDir", NULL); 
     401        if(tmpstr == NULL || *tmpstr == '\0') { 
     402 
     403                g_free(self->cachedir); 
     404                self->cachedir = g_strdup(iconf->cachedir); 
     405 
     406        } else { 
     407 
     408                g_free(self->cachedir); 
     409                self->cachedir = g_strdup(tmpstr); 
     410                g_free(tmpstr); 
     411        } 
     412 
     413        /* SchemaDir */ 
     414        g_free(self->schemadir); 
     415        self->schemadir = g_build_path(G_DIR_SEPARATOR_S, self->sharedir, "schema", NULL); 
    385416 
    386417        /* We will free it when config is unref */ 
     
    742773                g_object_get_property(G_OBJECT(self), (gchar*)props[i]->name, &pval); 
    743774 
     775                const gchar *keygroup = "MidgardDatabase"; 
     776 
     777                if (g_str_equal(props[i]->name, "sharedir") 
     778                                || g_str_equal(props[i]->name, "vardir") 
     779                                || g_str_equal(props[i]->name, "cachedir") 
     780                                || g_str_equal(props[i]->name, "blobdir"))  
     781                {        
     782                        keygroup = "MidgardDir"; 
     783                } 
     784 
     785 
    744786                switch(props[i]->value_type){ 
    745787         
     
    749791                                        tmpstr = ""; 
    750792                                g_key_file_set_string(self->priv->keyfile, 
    751                                                 "Database"
     793                                                keygroup
    752794                                                nick, tmpstr); 
    753795                                break; 
     
    755797                        case G_TYPE_BOOLEAN: 
    756798                                g_key_file_set_boolean(self->priv->keyfile, 
    757                                                 "Database",  
     799                                                keygroup,  
    758800                                                nick,  
    759801                                                g_value_get_boolean(&pval)); 
     
    761803                } 
    762804 
    763                 g_key_file_set_comment(self->priv->keyfile, "Database", nick, 
     805                g_key_file_set_comment(self->priv->keyfile, keygroup, nick, 
    764806                                g_param_spec_get_blurb(props[i]), NULL); 
    765807                g_value_unset(&pval); 
     
    10571099static void __config_struct_new(MidgardConfig *self) 
    10581100{ 
     1101        self->dbtype = g_strdup("MySQL"); 
    10591102        self->mgdusername = g_strdup("root"); 
    10601103        self->mgdpassword = g_strdup("password"); 
     
    10631106        self->dbuser = g_strdup("midgard"); 
    10641107        self->dbpass = g_strdup("midgard"); 
    1065         self->blobdir = NULL; 
    10661108        self->logfilename = NULL; 
    1067         self->schemadir = g_strdup(MIDGARD_LSCHEMA_DIR);; 
    10681109        self->default_lang = NULL; 
    10691110        self->loglevel = g_strdup("warn"); 
    10701111        self->pamfile = NULL; 
     1112 
     1113        /* MidgardDir */ 
     1114        self->blobdir = NULL; 
     1115        self->sharedir = NULL; 
     1116        self->vardir = NULL; 
     1117        self->cachedir = NULL; 
     1118        self->schemadir = NULL; 
     1119        self->schemadir = g_strdup(MIDGARD_LSCHEMA_DIR); 
    10711120} 
    10721121 
     
    10851134        if(self->dbpass) 
    10861135                g_free(self->dbpass); 
    1087         if(self->blobdir) 
    1088                 g_free(self->blobdir); 
    10891136        if(self->logfilename) 
    10901137                g_free(self->logfilename); 
     
    11091156                self = NULL; 
    11101157        } 
     1158 
     1159        /* MidgardDir */ 
     1160        if(self->blobdir) 
     1161                g_free(self->blobdir); 
     1162        self->blobdir = NULL; 
     1163 
     1164        if(self->sharedir) 
     1165                g_free(self->sharedir); 
     1166        self->sharedir = NULL; 
     1167 
     1168        if(self->cachedir) 
     1169                g_free(self->cachedir); 
     1170        self->cachedir = NULL; 
     1171 
     1172        if(self->vardir) 
     1173                g_free(self->vardir); 
     1174        self->vardir = NULL; 
    11111175} 
    11121176 
     
    14341498                        break; 
    14351499 
    1436                 case MIDGARD_CONFIG_BLOBDIR: 
    1437                         g_free(self->blobdir); 
    1438                         self->blobdir = g_value_dup_string(value); 
    1439                         break; 
    1440  
    14411500                case MIDGARD_CONFIG_LOGFILENAME: 
    14421501                        g_free(self->logfilename); 
    14431502                        self->logfilename = g_value_dup_string(value); 
    1444                         break; 
    1445  
    1446                 case MIDGARD_CONFIG_SCHEMADIR: 
    1447                         g_free(self->schemadir); 
    1448                         self->schemadir = g_value_dup_string(value); 
    14491503                        break; 
    14501504 
     
    14901544                        break; 
    14911545 
     1546                /* MidgardDir */ 
     1547                case MIDGARD_CONFIG_BLOBDIR: 
     1548                        g_free(self->blobdir); 
     1549                        self->blobdir = g_value_dup_string(value); 
     1550                        break; 
     1551 
     1552                case MIDGARD_CONFIG_SHAREDIR: 
     1553                        g_free(self->sharedir); 
     1554                        self->sharedir = g_value_dup_string(value); 
     1555                        break; 
     1556 
     1557                case MIDGARD_CONFIG_VARDIR: 
     1558                        g_free(self->vardir); 
     1559                        self->vardir = g_value_dup_string(value); 
     1560                        break; 
     1561 
     1562                case MIDGARD_CONFIG_CACHEDIR: 
     1563                        g_free(self->cachedir); 
     1564                        self->cachedir = g_value_dup_string(value); 
     1565                        break; 
     1566 
    14921567                default: 
    14931568                        G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec); 
     
    15241599                        break; 
    15251600 
    1526                 case MIDGARD_CONFIG_BLOBDIR: 
    1527                         g_value_set_string (value, self->blobdir); 
    1528                         break; 
    1529  
    15301601                case MIDGARD_CONFIG_LOGFILENAME: 
    15311602                        g_value_set_string (value, self->logfilename); 
    1532                         break; 
    1533  
    1534                 case MIDGARD_CONFIG_SCHEMADIR: 
    1535                         g_value_set_string (value, self->schemadir); 
    15361603                        break; 
    15371604 
     
    15711638                        g_value_set_string(value, self->pamfile); 
    15721639                        break; 
    1573                          
     1640                 
     1641                /* MidgardDir */ 
     1642                case MIDGARD_CONFIG_BLOBDIR: 
     1643                        g_value_set_string (value, self->blobdir); 
     1644                        break; 
     1645 
     1646                case MIDGARD_CONFIG_SHAREDIR: 
     1647                        g_value_set_string (value, self->sharedir); 
     1648                        break; 
     1649 
     1650                case MIDGARD_CONFIG_VARDIR: 
     1651                        g_value_set_string (value, self->vardir); 
     1652                        break; 
     1653 
     1654                case MIDGARD_CONFIG_CACHEDIR: 
     1655                        g_value_set_string (value, self->cachedir); 
     1656                        break; 
     1657 
    15741658                default: 
    15751659                        G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec); 
     
    16471731                        MIDGARD_CONFIG_DBPASS, 
    16481732                        pspec); 
    1649  
    1650         pspec = g_param_spec_string ("blobdir", 
    1651                         "Blobdir", 
    1652                         "Location of the blobs directory", 
    1653                         "", 
    1654                         G_PARAM_READWRITE); 
    1655         g_object_class_install_property (gobject_class, 
    1656                         MIDGARD_CONFIG_BLOBDIR, 
    1657                         pspec); 
    16581733         
    16591734        pspec = g_param_spec_string ("logfilename", 
     
    16661741                        pspec); 
    16671742 
    1668         pspec = g_param_spec_string ("schemadir", 
    1669                         "SchemaDir",   
    1670                         "Location of the schema file", 
    1671                         "", 
    1672                         G_PARAM_READWRITE); 
    1673         g_object_class_install_property (gobject_class, 
    1674                         MIDGARD_CONFIG_SCHEMADIR, 
    1675                         pspec); 
    1676  
    16771743        pspec = g_param_spec_string ("defaultlang", 
    16781744                        "DefaultLanguage",   
     
    17501816        g_object_class_install_property (gobject_class, 
    17511817                        MIDGARD_CONFIG_AUTHTYPE, 
    1752                         pspec);          
     1818                        pspec);  
     1819 
     1820        /* MidgardDir */         
     1821        pspec = g_param_spec_string ("blobdir", 
     1822                        "BlobDir", 
     1823                        "Location of the blobs directory.", 
     1824                        "", 
     1825                        G_PARAM_READWRITE); 
     1826        g_object_class_install_property (gobject_class, 
     1827                        MIDGARD_CONFIG_BLOBDIR, 
     1828                        pspec); 
     1829 
     1830        pspec = g_param_spec_string ("sharedir", 
     1831                        "ShareDir", 
     1832                        "Directory for shared, architecture independent files.", 
     1833                        "", 
     1834                        G_PARAM_READWRITE); 
     1835        g_object_class_install_property (gobject_class, 
     1836                        MIDGARD_CONFIG_SHAREDIR, 
     1837                        pspec); 
     1838         
     1839        pspec = g_param_spec_string ("vardir", 
     1840                        "VarDir", 
     1841                        "Application specific directories.", 
     1842                        "", 
     1843                        G_PARAM_READWRITE); 
     1844        g_object_class_install_property (gobject_class, 
     1845                        MIDGARD_CONFIG_VARDIR, 
     1846                        pspec); 
     1847         
     1848        pspec = g_param_spec_string ("cachedir", 
     1849                        "CacheDir", 
     1850                        "Cached files", 
     1851                        "", 
     1852                        G_PARAM_READWRITE); 
     1853        g_object_class_install_property (gobject_class, 
     1854                        MIDGARD_CONFIG_CACHEDIR, 
     1855                        pspec); 
     1856 
    17531857} 
    17541858 
  • branches/vinland/core/midgard/src/midgard_config.h

    r21803 r21895  
    5858        GObject parent; 
    5959         
     60        /* MidgardDatabase */ 
    6061        gchar *dbtype; 
    6162        gchar *host; 
     
    6465        gchar *dbuser; 
    6566        gchar *dbpass; 
    66         gchar *blobdir; 
    6767        gchar *logfilename; 
    6868        gchar *schemadir; 
     
    8080        gchar *pamfile; 
    8181        gboolean gdathreads; 
     82 
     83        /* MidgardDir */ 
     84        gchar *blobdir; 
     85        gchar *sharedir; 
     86        gchar *vardir; 
     87        gchar *cachedir; 
    8288 
    8389        /* < private > */ 
  • branches/vinland/core/midgard/src/midgard_connection.c

    r21745 r21895  
    324324                        if(self->priv->cache->lang_ids) 
    325325                                id_list_free(self->priv->cache->lang_ids); 
    326  
    327                         if(self->priv->configname) { 
    328                                 g_free(self->priv->configname); 
    329                                 self->priv->configname = NULL; 
    330                         } 
    331326 
    332327                        g_free(self->priv->cache); 
     
    948943                         
    949944                        MidgardSchema *schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL); 
    950                         midgard_schema_init(schema); 
     945                        gchar *path = g_build_path(G_DIR_SEPARATOR_S, config->sharedir, "MgdObjects.xml", NULL); 
     946                        midgard_schema_init(schema, (const gchar *)path); 
     947                        g_free(path); 
    951948                        midgard_schema_read_dir(schema, config->schemadir); 
    952949                         
     
    972969        } 
    973970         
    974         mgd->priv->configname = g_strdup(mgd->priv->config->priv->configname); 
    975971        return TRUE; 
    976972} 
     
    18241820        *n_objects = i; 
    18251821 
    1826         return objects; 
     1822        return (const GObject**) objects; 
    18271823} 
    18281824 
     
    18781874 
    18791875        new_mgd->priv->config = conn->priv->config; 
    1880         new_mgd->priv->configname = conn->priv->configname; 
    18811876        new_mgd->priv->loghandler = 0; 
    18821877        new_mgd->priv->loglevel = conn->priv->loglevel; 
  • branches/vinland/core/midgard/src/midgard_core_config.h

    r20201 r21895  
    2929        gchar *blobdir; 
    3030        gchar *sharedir; 
     31        gchar *vardir; 
     32        gchar *cachedir; 
    3133}mdirs; 
    3234 
    3335/* a cached version of paths */ 
    34 extern const mdirs *midgard_core_config_get_config_dirs(void); 
    35  
    36 extern void midgard_core_config_dirs_free(mdirs **dirs); 
    37  
    38 extern gchar *midgard_core_config_build_path( 
    39                 const gchar **dirs, const gchar *filename, gboolean user); 
     36const mdirs     *midgard_core_config_get_config_dirs    (void); 
     37void            midgard_core_config_dirs_free           (mdirs **dirs); 
     38gchar           *midgard_core_config_build_path         (const gchar **dirs, const gchar *filename, gboolean user); 
    4039 
    4140#endif /* MIDGARD_CORE_CONFIG_H */ 
  • branches/vinland/core/midgard/src/midgard_dbus.c

    r21654 r21895  
    110110        } 
    111111 
    112         if(!mgd->priv->configname) { 
    113                 g_warning("No configuration associated with Midgard connection"); 
    114                 return NULL; 
    115         } 
    116  
    117112        gchar *sg_guid = NULL; 
    118113        const GObject *sg = mgd->priv->current_sitegroup; 
     
    125120                        sg_guid = midgard_uuid_new(); 
    126121                } 
     122 
    127123        } else { 
    128124                 
  • branches/vinland/core/midgard/src/midgard_schema.h

    r15454 r21895  
    104104 * internal schema structures allocated for this object instance. 
    105105 */ 
    106 extern void midgard_schema_init(MidgardSchema *self); 
     106extern void midgard_schema_init(MidgardSchema *self, const gchar *path); 
    107107 
    108108/** 
  • branches/vinland/core/midgard/src/midgard_utils.h

    r21560 r21895  
    2424const char *midgard_version(); 
    2525void midgard_init(); 
     26void midgard_close(); 
    2627 
    2728#endif /* _MIDGARD_UTIL_H_ */ 
  • branches/vinland/core/midgard/test/midgard-schema.c

    r20560 r21895  
    1717 */ 
    1818 
    19 #include <libgda/libgda.h> 
    2019#include "src/midgard_error.h" 
    2120#include "src/midgard_object_class.h" 
     
    145144        gchar **args = { NULL }; 
    146145 
    147 #ifdef HAVE_LIBGDA_4 
    148         gda_init (); 
    149 #else 
    150         gda_init ("MIDGARD-SCHEMA", midgard_version(), 0, args); 
    151 #endif 
     146        midgard_init(); 
    152147 
    153148        MidgardConnection *mgd = midgard_connection_new(); 
     
    257252        g_free(mgdpassword); 
    258253        g_object_unref(mgd); 
     254 
     255        midgard_close(); 
     256 
    259257        return 0; 
    260258}