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);
}
