int main (int argc, char **argv) { midgard_init (); MidgardConfig *config = midgard_config_new (); midgard_config_read_file_at_path (config, "/tmp/test_SQLITE.conf", NULL); MidgardConnection *mgd = midgard_connection_new (); midgard_connection_open_config (mgd, config); //midgard_storage_create_base_storage (mgd); //midgard_storage_create (mgd,"midgard_snippetdir"); MidgardObject *obj = midgard_object_new (mgd, "midgard_snippetdir", NULL); midgard_object_create (obj); MidgardObject *obja = midgard_object_new (mgd, "midgard_snippetdir", NULL); midgard_object_create (obja); MidgardObject *objb = midgard_object_new (mgd, "midgard_snippetdir", NULL); midgard_object_create (objb); MidgardObject *objc = midgard_object_new (mgd, "midgard_snippetdir", NULL); midgard_object_create (objc); MidgardObject *objd = midgard_object_new (mgd, "midgard_snippetdir", NULL); midgard_object_create (objd); g_print ("END TEST FUNC \n"); return 0; }
void midgard_test_lock_root_objects(MidgardConnection *mgd, MidgardUser *user) { g_assert(user != NULL); /* Lock root user */ MgdObject *person = midgard_user_get_person(user); g_assert(person != NULL); if(!midgard_object_is_locked(person)) { gboolean user_locked = midgard_object_lock(person); if(!user_locked) g_print("Can not lock because %s \n", midgard_connection_get_error_string(mgd)); g_assert(user_locked != FALSE); } /* Lock its membership */ /* FIXME, it's naive to get member with id 1, but will work */ GValue val = {0, }; g_value_init(&val, G_TYPE_UINT); g_value_set_uint(&val, 1); MgdObject *member = midgard_object_new(mgd->mgd, "midgard_member", &val); g_assert(member != NULL); g_value_unset(&val); if(!midgard_object_is_locked(member)) { gboolean member_locked = midgard_object_lock(member); g_assert(member_locked != FALSE); } g_object_unref(member); }
int main (int argc, char **argv) { midgard_init (); MidgardConfig *config = midgard_config_new (); midgard_config_read_file_at_path (config, "/tmp/test_SQLITE.conf", NULL); MidgardConnection *mgd = midgard_connection_new (); midgard_connection_open_config (mgd, config); GThreadPool *pool = g_thread_pool_new (pool_func, (gpointer) mgd, 10, TRUE, NULL); //midgard_storage_create_base_storage (mgd); //midgard_storage_create (mgd,"midgard_snippetdir"); g_print ("START OPERATIONS \n"); MidgardObject *obj = midgard_object_new (mgd, "midgard_snippetdir", NULL); g_thread_pool_push (pool, (gpointer) obj, NULL); MidgardObject *obja = midgard_object_new (mgd, "midgard_snippetdir", NULL); g_thread_pool_push (pool, (gpointer) obja, NULL); MidgardObject *objb = midgard_object_new (mgd, "midgard_snippetdir", NULL); g_thread_pool_push (pool, (gpointer) objb, NULL); MidgardObject *objc = midgard_object_new (mgd, "midgard_snippetdir", NULL); g_thread_pool_push (pool, (gpointer) objc, NULL); MidgardObject *objd = midgard_object_new (mgd, "midgard_snippetdir", NULL); g_thread_pool_push (pool, (gpointer) objd, NULL); g_print ("END OPERATIONS \n"); g_print ("THREADS REMAIN (%d) \n", g_thread_pool_unprocessed (pool)); g_thread_pool_free (pool, FALSE, TRUE); return 0; }
MidgardObject *midgard_core_object_parameters_create( MidgardConnection *mgd, const gchar *class_name, const gchar *guid, guint n_params, const GParameter *parameters) { g_assert(mgd != NULL); g_assert(class_name != NULL); g_assert(guid != NULL); g_assert(n_params > 0); guint i; GParamSpec *pspec = NULL; GValue pval; const gchar *prop_name; MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(class_name); MidgardObject *object = midgard_object_new(mgd, class_name, NULL); /* Check if properties in parameters are registered for given class */ for ( i = 0; i < n_params; i++) { prop_name = parameters[i].name; pval = parameters[i].value; pspec = g_object_class_find_property(G_OBJECT_CLASS(klass), prop_name); if(!pspec) { MIDGARD_ERRNO_SET(mgd, MGD_ERR_INVALID_PROPERTY); g_warning("Property '%s' not registered for '%s' class", parameters[i].name, class_name); g_object_unref(object); return NULL; } g_object_set_property(G_OBJECT(object), prop_name, &pval); } /* Set parentguid so we definitely define parameter or attachment*/ g_object_set(object, "parentguid", guid, NULL); if(!midgard_object_create(object)) { g_object_unref(object); /* error code is set by create method */ return NULL; } return object; }
MidgardObject *midgard_test_object_basic_new(MidgardConnection *mgd, const gchar *name, GValue *value) { MidgardObject *object = midgard_object_new(mgd, name, value); g_assert(object != NULL); MIDGARD_TEST_ERROR_OK(mgd); guint id = 0; gchar *guid = NULL; g_object_get(object, "id", &id, "guid", &guid, NULL); if(value == NULL) { g_assert_cmpint(id, ==, 0); g_assert_cmpstr(guid, ==, NULL); g_assert_cmpint(id, !=, 1); g_assert_cmpstr(guid, !=, ""); } else {
/** * midgard_object_set_parameter: * @self: #MidgardObject instance * @domain: parameter's domain string * @name: parameter's name string * @value: a GValue value which should be set for domain&name pair * * Creates object's parameter object if it doesn't exists, updates otherwise. * * Returns: %TRUE on success, %FALSE otherwise */ gboolean midgard_object_set_parameter (MidgardObject *self, const gchar *domain, const gchar *name, GValue *value) { g_return_val_if_fail (self != NULL, FALSE); if(!__is_guid_valid(self)) return FALSE; MidgardObject *param; const gchar *value_string = g_value_get_string(value); gboolean delete_parameter = FALSE; gboolean do_return_true = FALSE; if(g_str_equal(value_string, "")) delete_parameter = TRUE; const GValue *get_value = midgard_object_get_parameter(self, domain, name); MidgardCollector *domain_collector = __get_parameters_collector(self, domain); if(!domain_collector) { domain_collector = __create_domain_collector(MGD_OBJECT_CNC (self), domain); __register_domain_collector(self, domain, domain_collector); } /* This is the case when set_parameter is invoked * before any get_parameter */ if(get_value == NULL && delete_parameter) { MIDGARD_ERRNO_SET(MGD_OBJECT_CNC (self), MGD_ERR_NOT_EXISTS); return FALSE; } /* Parameter doesn't exist. We have to create it */ if(get_value == NULL && !delete_parameter){ param = midgard_object_new(MGD_OBJECT_CNC (self), "midgard_parameter", NULL); g_object_set(param, "domain", domain, "name", name, "parentguid", MGD_OBJECT_GUID (self), NULL); g_object_set_property(G_OBJECT(param), "value", value); if(midgard_object_create(param)) { if(domain_collector) { if(!midgard_collector_set(domain_collector, name, "value", value)){ g_warning("Failed to update parameter's cache"); } } g_object_unref(param); return TRUE; } else { /* Error should be already set by create */ g_object_unref(param); return FALSE; } /* Parameter exists. if value is '' we delete it. * In any other case we update it */ } else { MidgardQueryBuilder *builder = midgard_query_builder_new(MGD_OBJECT_CNC (self), "midgard_parameter"); GValue gval = {0,}; g_value_init(&gval, G_TYPE_STRING); g_value_set_string(&gval, MGD_OBJECT_GUID (self)); midgard_query_builder_add_constraint(builder, "parentguid", "=", &gval); g_value_unset(&gval); g_value_init(&gval, G_TYPE_STRING); g_value_set_string(&gval, domain); midgard_query_builder_add_constraint(builder, "domain", "=", &gval); g_value_unset(&gval); g_value_init(&gval, G_TYPE_STRING); g_value_set_string(&gval, name); midgard_query_builder_add_constraint(builder, "name", "=", &gval); g_value_unset(&gval); guint n_objects; GObject **ret_object = midgard_query_builder_execute(builder, &n_objects); g_object_unref(builder); if(!ret_object){ return FALSE; } if(delete_parameter){ if(midgard_object_delete( MIDGARD_OBJECT(ret_object[0]), FALSE)) { midgard_collector_remove_key( domain_collector, name); do_return_true = TRUE; } } else { g_object_set(ret_object[0], "value", value_string, NULL); if(midgard_object_update( MIDGARD_OBJECT(ret_object[0]))) { if(domain_collector) { midgard_collector_set(domain_collector, name, "value", value); } do_return_true = TRUE; } } g_object_unref(ret_object[0]); g_free(ret_object); if(do_return_true) return TRUE; } return FALSE; }
/** * midgard_replicator_import_from_xml: * @mgd: #MidgardConnection instance * @xml: data buffer which holds serialized object * @force: toggle to force import * * This method tries to import all objects which could be unserialized from gievn xml. * It's not atomic. Check error code returned from midgard_connection_get_error(). * */ void midgard_replicator_import_from_xml (MidgardConnection *mgd, const gchar *xml, gboolean force) { g_return_if_fail (mgd != NULL); g_return_if_fail (xml != NULL); xmlDoc *doc = NULL; xmlNode *root_node = NULL; midgard_core_object_get_xml_doc(mgd, xml, &doc, &root_node); if(doc == NULL || root_node == NULL) return; xmlNodePtr child = _get_type_node(root_node->children); if(!child) { g_warning("Can not get midgard type name from the given xml"); xmlFreeDoc(doc); return; } GType object_type = g_type_from_name((const gchar *)child->name); if(object_type == MIDGARD_TYPE_BLOB) { /* it will destroy xmlDoc */ __import_blob_from_xml(mgd, doc, child); return; } xmlChar *attr, *guid_attr; MidgardObject *dbobject; for(; child; child = _get_type_node(child->next)) { attr = xmlGetProp(child, BAD_CAST "purge"); guid_attr = xmlGetProp(child, BAD_CAST "guid"); if(attr && g_str_equal(attr, "yes")) { dbobject = midgard_schema_object_factory_get_object_by_guid (mgd, (const gchar *)guid_attr); if(dbobject || ( !dbobject && (mgd->errnum == MGD_ERR_OBJECT_DELETED) )) { midgard_object_purge(dbobject, FALSE); if(dbobject) g_object_unref(dbobject); xmlFree(attr); xmlFree(guid_attr); continue; } } xmlFree(attr); MidgardObject *object = midgard_object_new(mgd, (const gchar *)child->name, NULL); if(!object) { g_warning("Can not create %s instance", child->name); xmlFreeDoc(doc); xmlFree(attr); xmlFree(guid_attr); continue; } if (guid_attr) { MGD_OBJECT_GUID (object) = (const gchar *)g_strdup((gchar *)guid_attr); } if(!_nodes2object(G_OBJECT(object), child->children, force)) { xmlFree(guid_attr); g_object_unref(object); continue; } if (!midgard_replicator_import_object (MIDGARD_DBOBJECT (object), force)) { xmlFree (guid_attr); g_object_unref (object); continue; } else { xmlFree (guid_attr); g_object_unref (object); } } xmlFreeDoc (doc); }
void midgard_test_object_tree_create(MidgardObjectTest *mot, gconstpointer data) { g_assert(mot != NULL); MidgardObject *_object = MIDGARD_OBJECT(mot->object); MidgardConnection *mgd = MIDGARD_CONNECTION(midgard_object_get_connection(_object)); MidgardObjectClass *klass = MIDGARD_OBJECT_GET_CLASS(_object); /* Get parent (in tree) class and check if parent has the same child declared */ const gchar *pname = midgard_schema_object_tree_get_parent_name(_object); if(!pname) return; MidgardObjectClass *pklass = MIDGARD_OBJECT_GET_CLASS_BY_NAME(pname); g_assert(pklass != NULL); /* Check if class has unique property */ const gchar *unique_name = midgard_reflector_object_get_property_unique (G_OBJECT_CLASS_NAME (klass)); if (!unique_name) return; /* Check if class has 'name' property registered */ GParamSpec *unique_name_pspec = g_object_class_find_property(G_OBJECT_CLASS(klass), unique_name); g_assert (unique_name_pspec != NULL); /* Empty name */ MidgardObject *object = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL); g_object_set(object, unique_name, "", NULL); /* Workaround */ const gchar *parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass)); if (parent_property) g_object_set(object, parent_property, 1, NULL); gboolean created = midgard_object_create(object); MIDGARD_TEST_ERROR_OK(mgd); g_assert(created != FALSE); gboolean purged = midgard_object_purge(object, TRUE); g_assert(purged != FALSE); g_object_unref(object); object = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL); g_object_set(object, "name", "", NULL); /* Workaround */ parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass)); if (parent_property) g_object_set(object, parent_property, 1, NULL); created = midgard_object_create(object); MIDGARD_TEST_ERROR_OK(mgd); g_assert(created != FALSE); purged = midgard_object_purge(object, TRUE); g_assert(purged != FALSE); g_object_unref(object); /* Unique name */ object = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL); g_object_set(object, unique_name, "Unique", NULL); /* Workaround */ parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass)); if (parent_property) g_object_set(object, parent_property, 1, NULL); created = midgard_object_create(object); MIDGARD_TEST_ERROR_OK(mgd); g_assert(created != FALSE); MidgardObject *dupobject = midgard_object_new(mgd, G_OBJECT_TYPE_NAME(_object), NULL); g_object_set(dupobject, unique_name, "Unique", NULL); /* Workaround */ parent_property = midgard_reflector_object_get_property_parent (G_OBJECT_CLASS_NAME (klass)); if (parent_property) g_object_set(dupobject, parent_property, 1, NULL); gboolean dupcreated = midgard_object_create(dupobject); MIDGARD_TEST_ERROR_ASSERT(mgd, MGD_ERR_DUPLICATE); g_assert(dupcreated != TRUE); g_object_unref(dupobject); purged = midgard_object_purge(object, TRUE); g_assert(purged != FALSE); g_object_unref(object); }