midgardmodule.c

Revision 19140, 10.2 kB (checked in by piotras, 2 days ago)
Set default log handler for GLib and GLib-GObject domains. Set ERROR flag as critical one
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`

Line
1	/*
2	* Copyright (C) 2007 Piotr Pokora <piotrek.pokora@gmail.com>
3	*
4	* This program is free software; you can redistribute it and/or modify it
5	* under the terms of the GNU Lesser General Public License as published
6	* by the Free Software Foundation; either version 2 of the License, or
7	* (at your option) any later version.
8	*
9	* This program is distributed in the hope that it will be useful,
10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	* GNU General Public License for more details.
13	*
14	* You should have received a copy of the GNU General Public License
15	* along with this program; if not, write to the Free Software
16	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17	*/
18
19	#ifdef HAVE_CONFIG_H
20	#include "config.h"
21	#endif
22
23	#define G_LOG_DOMAIN "midgard-core"
24
25	#include "py_midgard.h"
26
27	static PyTypeObject *_MPyGObject_Type;
28	#define PyGObject_Type (*_MPyGObject_Type)
29
30	void py_midgard_init(void);
31	static MidgardSchema *midgard_global_schema = NULL;
32
33	static guint global_loghandler = 0;
34
35	void
36	py_midgard_register_classes(PyObject *d)
37	{
38	PyObject *module;
39
40	if ((module = PyImport_ImportModule("gobject")) != NULL) {
41
42	_MPyGObject_Type = (PyTypeObject )PyObject_GetAttrString(module, "GObject"*);
43
44	if (_MPyGObject_Type == NULL) {
45
46	PyErr_SetString(PyExc_ImportError,
47	"cannot import name GObject from gobject");
48	return ;
49	}
50
51	} else {
52
53	PyErr_SetString(PyExc_ImportError, "could not import gobject");
54
55	return ;
56	}
57
58	py_midgard_config_register_class(d, &PyGObject_Type);
59	py_midgard_connection_register_class(d, &PyGObject_Type);
60	py_midgard_query_builder_register_class(d, &PyGObject_Type);
61	py_midgard_blob_register_class(d, &PyGObject_Type);
62	py_midgard_reflection_property_register_class(d, &PyGObject_Type);
63	py_midgard_replicator_register_class(d, &PyGObject_Type);
64	py_midgard_dbus_register_class(d, &PyGObject_Type);
65
66	py_midgard_object_class_register_class(d, &PyGObject_Type);
67
68	PyTypeObject pto = py_midgard_query_builder_get_type_object();
69
70	if(&pto == NULL)
71	g_warning("Can not handle query builder type pointer");
72
73	PyObject mmodule = PyImport_ImportModule("_midgard"*);
74	PyTypeObject qbot = (PyTypeObject )PyObject_GetAttrString(mmodule, "query_builder");
75	py_midgard_collector_register_class(d, &qbot);
76	}
77
78	static void
79	py_midgard_register_schema_classes(PyObject *d)
80	{
81	PyObject *module;
82
83	if ((module = PyImport_ImportModule("gobject")) != NULL) {
84
85	_MPyGObject_Type = (PyTypeObject )PyObject_GetAttrString(module, "GObject"*);
86
87	if (_MPyGObject_Type == NULL) {
88
89	PyErr_SetString(PyExc_ImportError,
90	"cannot import name GObject from gobject");
91	return ;
92	}
93
94	} else {
95
96	PyErr_SetString(PyExc_ImportError, "could not import gobject");
97
98	return ;
99	}
100
101	py_midgard_object_register_class(d, &PyGObject_Type);
102	}
103
104	void
105	py_midgard_register_db_classes(PyObject *d)
106	{
107	PyObject *module;
108
109	if ((module = PyImport_ImportModule("gobject")) != NULL) {
110
111	_MPyGObject_Type = (PyTypeObject )PyObject_GetAttrString(module, "GObject"*);
112
113	if (_MPyGObject_Type == NULL) {
114
115	PyErr_SetString(PyExc_ImportError,
116	"cannot import name GObject from gobject");
117	return ;
118	}
119
120	} else {
121
122	PyErr_SetString(PyExc_ImportError, "could not import gobject");
123
124	return ;
125	}
126
127	py_midgard_dbobject_register_class(d, &PyGObject_Type);
128	py_midgard_user_register_class(d, &PyGObject_Type);
129	}
130
131	static const PyMethodDef py_midgard_functions[] = {
132	{ NULL, NULL, 0, NULL }
133	};
134
135	static py_midgard_define_constants(PyObject *m)
136	{
137	/ Register properties' midgard types /
138	PyModule_AddIntConstant(m, "TYPE_NONE", MGD_TYPE_NONE);
139	PyModule_AddIntConstant(m, "TYPE_STRING", MGD_TYPE_STRING);
140	PyModule_AddIntConstant(m, "TYPE_INT", MGD_TYPE_INT);
141	PyModule_AddIntConstant(m, "TYPE_UINT", MGD_TYPE_UINT);
142	PyModule_AddIntConstant(m, "TYPE_FLOAT", MGD_TYPE_FLOAT);
143	PyModule_AddIntConstant(m, "TYPE_BOOLEAN", MGD_TYPE_BOOLEAN);
144	PyModule_AddIntConstant(m, "TYPE_TIMESTAMP", MGD_TYPE_TIMESTAMP);
145	PyModule_AddIntConstant(m, "TYPE_LONGTEXT", MGD_TYPE_LONGTEXT);
146	PyModule_AddIntConstant(m, "TYPE_GUID", MGD_TYPE_GUID);
147
148	/ Register midgard_user and auth constants /
149	PyModule_AddIntConstant(m, "USER_HASH_LEGACY", MIDGARD_USER_HASH_LEGACY);
150	PyModule_AddIntConstant(m, "USER_HASH_LEGACY_PLAIN", MIDGARD_USER_HASH_LEGACY_PLAIN);
151	PyModule_AddIntConstant(m, "USER_HASH_CRYPT", MIDGARD_USER_HASH_CRYPT);
152	PyModule_AddIntConstant(m, "USER_HASH_MD5", MIDGARD_USER_HASH_MD5);
153	PyModule_AddIntConstant(m, "USER_HASH_PLAIN", MIDGARD_USER_HASH_PLAIN);
154	PyModule_AddIntConstant(m, "USER_HASH_SHA1", MIDGARD_USER_HASH_SHA1);
155	PyModule_AddIntConstant(m, "USER_HASH_PAM", MIDGARD_USER_HASH_PAM);
156
157	/ Register errcode constants /
158	PyModule_AddIntConstant(m, "ERR_OK", MGD_ERR_OK);
159	PyModule_AddIntConstant(m, "ERR_ERROR", MGD_ERR_ERROR);
160	PyModule_AddIntConstant(m, "ERR_ACCESS_DENIED", MGD_ERR_ACCESS_DENIED);
161	PyModule_AddIntConstant(m, "ERR_SITEGROUP_VIOLATION", MGD_ERR_SITEGROUP_VIOLATION);
162	PyModule_AddIntConstant(m, "ERR_NOT_OBJECT", MGD_ERR_NOT_OBJECT);
163	PyModule_AddIntConstant(m, "ERR_NOT_EXISTS", MGD_ERR_NOT_EXISTS);
164	PyModule_AddIntConstant(m, "ERR_INVALID_NAME", MGD_ERR_INVALID_NAME);
165	PyModule_AddIntConstant(m, "ERR_DUPLICATE", MGD_ERR_DUPLICATE);
166	PyModule_AddIntConstant(m, "ERR_HAS_DEPENDANTS", MGD_ERR_HAS_DEPENDANTS);
167	PyModule_AddIntConstant(m, "ERR_RANGE", MGD_ERR_RANGE);
168	PyModule_AddIntConstant(m, "ERR_NOT_CONNECTED", MGD_ERR_NOT_CONNECTED);
169	PyModule_AddIntConstant(m, "ERR_SG_NOTFOUND", MGD_ERR_SG_NOTFOUND);
170	PyModule_AddIntConstant(m, "ERR_INVALID_OBJECT", MGD_ERR_INVALID_OBJECT);
171	PyModule_AddIntConstant(m, "ERR_QUOTA", MGD_ERR_QUOTA);
172	PyModule_AddIntConstant(m, "ERR_INTERNAL", MGD_ERR_INTERNAL);
173	PyModule_AddIntConstant(m, "ERR_OBJECT_NAME_EXISTS", MGD_ERR_OBJECT_NAME_EXISTS);
174	PyModule_AddIntConstant(m, "ERR_OBJECT_NO_STORAGE", MGD_ERR_OBJECT_NO_STORAGE);
175	PyModule_AddIntConstant(m, "ERR_OBJECT_NO_PARENT", MGD_ERR_OBJECT_NO_PARENT);
176	PyModule_AddIntConstant(m, "ERR_INVALID_PROPERTY_VALUE", MGD_ERR_INVALID_PROPERTY_VALUE);
177	PyModule_AddIntConstant(m, "ERR_INVALID_PROPERTY", MGD_ERR_INVALID_PROPERTY);
178	PyModule_AddIntConstant(m, "ERR_USER_DATA", MGD_ERR_USER_DATA);
179	PyModule_AddIntConstant(m, "ERR_OBJECT_DELETED", MGD_ERR_OBJECT_DELETED);
180	PyModule_AddIntConstant(m, "ERR_OBJECT_PURGED", MGD_ERR_OBJECT_PURGED);
181	PyModule_AddIntConstant(m, "ERR_OBJECT_EXPORTED", MGD_ERR_OBJECT_EXPORTED);
182	PyModule_AddIntConstant(m, "ERR_OBJECT_IMPORTED", MGD_ERR_OBJECT_IMPORTED);
183	PyModule_AddIntConstant(m, "ERR_MISSED_DEPENDENCE", MGD_ERR_MISSED_DEPENDENCE);
184	PyModule_AddIntConstant(m, "ERR_TREE_IS_CIRCULAR", MGD_ERR_TREE_IS_CIRCULAR);
185	}
186
187	DL_EXPORT(void)
188	init_midgard(void)
189	{
190	PyObject m, d, tuple, o, sm, dm;
191
192	/ initialise pygobject /
193	init_pygobject_check(2, 12, 0);
194	g_assert(pygobject_register_class != NULL);
195
196	midgard_init();
197
198	global_loghandler =
199	g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_MASK,
200	midgard_error_default_log, NULL);
201
202	if(!g_type_from_name("midgard_article")
203	&& midgard_global_schema == NULL) {
204
205	/ FIXME, we need to unref it when module is unloaded! /
206	midgard_global_schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL);
207	midgard_schema_init((MidgardSchema *) midgard_global_schema);
208	midgard_schema_read_dir((MidgardSchema *) midgard_global_schema,
209	MIDGARD_LSCHEMA_DIR);
210	}
211
212	m = Py_InitModule("_midgard", (PyMethodDef*)py_midgard_functions);
213
214	if(!m) g_warning("InitModule FAILED");
215
216	d = PyModule_GetDict(m);
217
218	if(!d) g_warning("Module_GetDict FAILED");
219
220	tuple = Py_BuildValue("s", midgard_version());
221	PyDict_SetItemString(d, "version", tuple);
222	Py_DECREF(tuple);
223
224	tuple = Py_BuildValue("(iii)", 0, 0, 1);
225	PyDict_SetItemString(d, "module_version", tuple);
226	Py_DECREF(tuple);
227
228	py_midgard_define_constants(m);
229	py_midgard_register_classes(d);
230
231	/ Core DB objects /
232	dm = Py_InitModule("__db__", NULL);
233	d = PyModule_GetDict(dm);
234	PyModule_AddObject(m, "db", dm);
235	py_midgard_register_db_classes(d);
236
237	/ Mgdschema module /
238	sm = Py_InitModule("__mgdschema__", NULL);
239	if(!sm)
240	g_warning("Failed to initialize mgdschema module");
241	PyObject *sd = PyModule_GetDict(sm);
242	PyModule_AddObject(m, "mgdschema", sm);
243	py_midgard_register_schema_classes(sd);
244
245	/ Globals /
246
247	/ Set null connection "superglobal" /
248	tuple = Py_BuildValue("i", 0);
249	d = PyModule_GetDict(m);
250	PyDict_SetItemString(d, "_connection", tuple);
251
252	g_log_set_handler("GLib-GObject", G_LOG_LEVEL_MASK,
253	g_log_default_handler, NULL);
254	g_log_set_handler("GLib", G_LOG_LEVEL_MASK,
255	g_log_default_handler, NULL);
256	g_log_set_always_fatal(G_LOG_LEVEL_ERROR);
257	}
258
259	/ ROUTINES /
260
261	guint get_global_log_handler(void)
262	{
263	return global_loghandler;
264	}
265
266	GValue gvalue_from_pyobject(PyObject *pyval)
267	{
268	GValue value = {0, };
269
270	if(PyString_Check(pyval)) {
271	g_value_init(&value, G_TYPE_STRING);
272	return value;
273
274	} else if(PyInt_Check(pyval)) {
275	g_value_init(&value, G_TYPE_INT);
276	return value;
277
278	} else if(PyLong_Check(pyval)) {
279	g_value_init(&value, G_TYPE_INT);
280	return value;
281
282	} else if(PyBool_Check(pyval)) {
283	g_value_init(&value, G_TYPE_BOOLEAN);
284	return value;
285
286	} else if(PyFloat_Check(pyval)) {
287	g_value_init(&value, G_TYPE_FLOAT);
288	return value;
289
290	} else if(PyUnicode_Check(pyval)) {
291	g_value_init(&value, G_TYPE_STRING);
292	return value;
293
294	} else {
295	g_warning("Unhandled value type");
296	g_value_init(&value, G_TYPE_NONE);
297	return value;
298	}
299	}
300
301	GParameter *_py_midgard_parameters_from_args(PyObject args, guint n_params)
302	{
303	if(!args)
304	return NULL;
305
306	gint i = 0;
307	GParameter *params = NULL;
308
309	*n_params = (guint) PyDict_Size(args);
310
311	if(*n_params < 1)
312	return NULL;
313
314	Py_ssize_t pos = 0;
315	PyObject *key;
316	PyObject *value;
317
318	params = g_new0(GParameter, *n_params);
319
320	while (PyDict_Next (args, &pos, &key, &value)) {
321
322	const gchar *key_str = PyString_AsString (key);
323	params[i].name = key_str;
324
325	params[i].value = gvalue_from_pyobject(value);
326	pyg_value_from_pyobject(&params[i].value, value);
327
328	i++;
329	}
330
331	return params;
332	}
333
334	gchar *_py_midgard_format_string(const gchar *msg , ...)
335	{
336	va_list args;
337	va_start(args, msg);
338	gchar *_msg = g_strdup_vprintf(msg, args);
339	va_end(args);
340
341	return _msg;
342	}

Note: See TracBrowser for help on using the browser.

root/trunk/midgard/apis/python/midgardmodule.c

Download in other formats: