Merge branch 'master' of git.labocleo.org:lodel2

.gitignore

@@ -6,3 +6,5 @@ settings_local.py
 doc/html
 doc/*.sqlite3.db
 .*.swp
+Makefile
+Makefile.in

Makefile.am

@@ -1,5 +1,5 @@
-SUBDIRS = lodel progs plugins
-EXTRA_DIST = plugins runtest examples tests runtest.sh debian
+SUBDIRS = lodel progs lodelsites
+EXTRA_DIST = runtest examples tests debian
 CLEANFILES = runtest
 
 lodel2_localstate_DATA =
@@ -27,7 +27,7 @@ doc_graphviz:
 
 do_subst = sed -e 's,\[@\]INSTALLMODEL_DIR\[@\],$(install_model_dir),g' 
 
-runtest: runtest.sh
+runtest: ./runtest.sh
 	$(do_subst) < $(srcdir)/runtest.sh > runtest
 	chmod +x runtest
 
@@ -43,10 +43,18 @@ deb: dist
 em_test: em_test.py
 	$(python) em_test.py
 
+# Test em update ( examples/em_test.pickle )
+em_simple: editorial_models/em_simple.py
+	$(python) editorial_models/em_simple.py
+	
 # generate leapi dynamic code
 dyncode: examples/em_test.pickle
 	$(python) scripts/refreshdyn.py examples/em_test.pickle $(dyncode_filename) && echo -e "\n\nCode generated in $(dyncode_filename)"
 
+# generate leapi dynamic code
+dyncode_simple: examples/em_simple.pickle
+	$(python) scripts/refreshdyn.py examples/em_simple.pickle $(dyncode_filename) && echo -e "\n\nCode generated in $(dyncode_filename)"
+
 # run tests
 checks: runtest
 	./runtest -v

README

@@ -90,6 +90,9 @@ NOTE: You have to run in root to use this below
 		- generate a nginx conf for all instances :
 			slim -a --nginx-conf
 
+		- set logger to warning level and log in file :
+			slim -a -s --set-logger test:WARNING:/var/log/lodel2/%l.%s.log
+
 		- get some help for more options & actions :
 			slim -h
 
@@ -130,19 +133,39 @@ Mass deployments tricks & tips:
 	#Reactivate auth
 	sed -i -e 's/^noauth = /#noauth =/' -e 's/^#auth = /auth =/' /etc/mongodb.conf
 	#Test connection
-	echo "exit" | mongo --quiet -u $mongoadmin -p $mongopass admin && echo "Connection ok" || echo "connection fails"
+	echo "exit" | mongo --quiet -u $mongoadmin -p $mongopass admin && echo "Connection ok" || echo "connection fails"
 	#Indicate mongodb credentials to mass_deploy
 	echo -e "MONGODB_ADMIN_USER='$mongoadmin'\nMONGODB_ADMIN_PASSWORD='$mongopass'\n" >> /etc/lodel2/mass_deploy.cfg
 	#Deploying 50 instances
 	NINSTANCE=50
 	#Running mass_deploy
 	/usr/share/lodel2/scripts/mass_deploy $NINSTANCE
+
+	#FOLLOWING INSTRUCTIONS ARE FOR STARTING APPS WITH UWSGI
+	# for standalone instructions see bellow
+
 	#Updating nginx conf (delete /etc/nginx/sites-enabled/default if exists)
 	slim --nginx-conf -a > /etc/nginx/sites-enabled/lodel2
 	/etc/init.d/nginx reload
 	#Start all instances and check if they managed to start
 	slim --start -a && sleep 2 && slim -l
 
+	# FOLLOWING INSTRUCTIONS ARE FOR STANDALONE LODEL2 WEBSERVER
+	
+	#Configure nginx & restart it
+	export lodel2_install_dir="/usr/lib/python3/dist-packages";
+	echo -e "server {\n\tlisten 80 default_server;\n\tlisten [::]:80 default_server;\n\tlocation / {\n\t\tproxy_pass http://localhost:1337/;\n\t}\n\t\n\tlocation /static/ {\n\t\talias $lodel2_install_dir/lodel/plugins/webui/templates/;\n\t}\n\t\n}\n" > /etc/nginx/sites-enabled/default
+	/etc/init.d/nginx restart
+	#Build dyncode for instances
+	slim -a -m
+	#Copy the multisite loader in lodel instances root folder
+	cp /usr/lib/python3/dist-packages/lodel/plugins/multisite/loader.py /tmp/lodel2_instances/
+	cd /tmp/lodel2_instances/
+	#Start the server
+	python3 loader.py
+	#Now you can access to the app in HTTP via nginx throught port 80 
+	#or directly via the python server throught the port 1337
+
 
 	Cleaning mongodb + instances :
 	------------------------------

configure.ac

@@ -15,7 +15,8 @@ AC_CONFIG_FILES([Makefile \
 	lodel/utils/Makefile \
 	progs/Makefile \
 	progs/slim/Makefile \
-	plugins/Makefile \
+	lodel/plugins/Makefile \
+	lodelsites/Makefile \
 ])
 
 

debian/control

@@ -9,6 +9,6 @@ Package: lodel2
 Section: python
 Description: lodel2 debian package
 Architecture: any
-Depends: python3, python3-lxml, python3-jinja2, python3-werkzeug, python3-pymongo, uwsgi-plugin-python3
+Depends: python3, python3-lxml, python3-jinja2, python3-werkzeug, python3-pymongo, uwsgi-plugin-python3, make
 Suggests: pwgen, wamerican, mongodb-server
 Provides: lodel

editorial_models/em_simple.py

@@ -0,0 +1,697 @@
+#!/usr/bin/python3
+#-*- coding: utf-8 -*-
+import sys
+import os, os.path
+
+sys.path.append(os.path.dirname(os.getcwd()+'/..'))
+from lodel.context import LodelContext
+LodelContext.init()
+
+from lodel.settings.settings import Settings as settings
+settings('globconf.d')
+from lodel.settings import Settings
+
+from lodel.editorial_model.components import *
+from lodel.editorial_model.exceptions import *
+from lodel.editorial_model.model import EditorialModel
+
+em = EditorialModel('simpleem', 'Simple editorial model')
+
+base_group = em.new_group(  'base_group',
+                            display_name = 'Base group',
+                            help_text = 'Base group that implements base EM features (like classtype)'
+)
+
+####################
+#   Lodel Object   #
+####################
+em_abstract = em.new_class( 'abstract_object',
+    display_name = 'Abstract lodel object',
+    help_text = 'For testing purpose',
+    group = base_group,
+    abstract = True)
+
+em_object = em.new_class(   'object',
+                            display_name = 'Object',
+                            help_text = 'Main class for all Em objects',
+                            group = base_group,
+                            abstract = True,
+                            parents = em_abstract,
+)
+em_object.new_field(    'lodel_id',
+                        display_name = 'Lodel identifier',
+                        help_text = 'Uniq ID that identify every lodel object',
+                        group = base_group,
+                        data_handler = 'uniqid',
+                        internal = True,
+)
+em_object.new_field(    'date_create',
+                        display_name = 'Creation date',
+                        group = base_group,
+                        data_handler = 'datetime',
+                        now_on_create = True,
+                        internal = True,
+)
+em_object.new_field(    'date_update',
+                        display_name = 'Last update',
+                        group = base_group,
+                        data_handler = 'datetime',
+                        now_on_update = True,
+                        internal = True,
+)
+entitie = em.new_class( 'entitie',
+                        display_name = 'entitie',
+                        help_text = 'Replace old entity classtype',
+                        abstract = True,
+                        group = base_group,
+                        parents = em_object,
+)
+########################
+# Base group
+########################
+
+person = em.new_class(  'person',
+                        display_name = 'Person',
+                        help_text = 'Person type',
+                        abstract = False,
+                        group = base_group,
+                        parents = em_object,
+)
+
+person.new_field(   'firstname',
+                    display_name = {
+                        'eng': 'Firstname',
+                        'fre': 'Prénom',
+                    },
+                    data_handler = 'varchar',
+                    group = base_group,
+)
+person.new_field(   'lastname',
+                    display_name = {
+                        'eng': 'Lastname',
+                        'fre': 'Nom de famille',
+                    },
+                    data_handler = 'varchar',
+                    group = base_group,
+)
+
+# person.new_field(   'role',
+#                     display_name = {
+#                         'eng': 'Role',
+#                         'fre': 'Rôle',
+#                     },
+#                     data_handler = 'varchar',
+#                     group = base_group,
+# )
+
+entry = em.new_class(   'entry',
+                        display_name = 'Entry',
+                        help_text = 'Entry type',
+                        abstract = False,
+                        group = base_group,
+                        parents = em_object,
+)
+entry.new_field(    'name',
+                    display_name = {
+                        'eng': 'Name',
+                        'fre': 'Nom',
+                    },
+                    data_handler = 'varchar',
+                    group = base_group,
+)
+entry.new_field(    'description',
+                    display_name = {
+                        'eng': 'Description',
+                        'fre': 'Description',
+                    },
+                    data_handler = 'text',
+                    group = base_group,
+)
+
+entry.new_field(    'role',
+                    display_name = {
+                        'eng': 'Role',
+                        'fre': 'Rôle',
+                    },
+                    data_handler = 'varchar',
+                    group = base_group,
+)
+
+#####################
+# Editorial classes #
+#####################
+
+editorial_group = em.new_group( 'editorial_abstract',
+                                display_name = 'Editorial base',
+                                help_text = {
+                                    'eng': 'Contains abstract class to handler editorial contents',
+                                    'fre': 'Contient les classes abstraites permetant la gestion de contenu éditorial'
+                                },
+                                depends = (base_group,)
+)
+
+################################### Texts ##########################################################
+# Classe texte
+text = em.new_class(   'text',
+                        display_name = 'Text',
+                        help_text = 'Abstract class that represent texts',
+                        group = editorial_group,
+                        abstract = True,
+                        parents = entitie,
+)
+
+text.new_field(    'title',
+                    display_name = {'eng': 'Title', 'fre': 'Titre'},
+                    group = editorial_group,
+                    data_handler = 'text',
+                    nullable = True,)
+text.new_field(    'subtitle',
+                    display_name = {
+                        'eng': 'Subtitle',
+                        'fre': 'Sous-titre',
+                    },
+                    group = editorial_group,
+                    data_handler = 'text',
+                    nullable = True,
+                    default = None)
+text.new_field(    'language',
+                    display_name = {
+                        'eng': 'Language',
+                        'fre': 'Langue',
+                    },
+                    group = editorial_group,
+                    data_handler = 'varchar',
+                    nullable = True,
+                    default = None)
+text.new_field(    'text',
+                    display_name = {
+                        'eng': 'Text',
+                        'fre': 'Texte',
+                    },
+                    group = editorial_group,
+                    data_handler = 'text',
+                    nullable = True,
+                    default = None)
+text.new_field(    'pub_date',
+                    display_name = {
+                        'eng': 'Publication date',
+                        'fre': 'Date de publication',
+                    },
+                    group = editorial_group,
+                    data_handler = 'datetime',
+                    nullable = True,
+                    default = None)
+text.new_field(    'footnotes',
+                    display_name = {
+                        'eng': 'Footnotes',
+                        'fre': 'Notes de bas de page',
+                    },
+                    group = editorial_group,
+                    data_handler = 'text',
+                    nullable = True,
+                    default = None)
+text.new_field(    'linked_entries',
+                    display_name = {
+                        'eng': 'Related entries',
+                        'fre': 'Indices liés',
+                    },
+                    group = editorial_group,
+                    data_handler = 'list',
+                    nullable = True,
+                    allowed_classes = [entry],
+                    back_reference = ('entry', 'linked_texts'),
+                    default = None
+)
+entry.new_field(    'linked_texts',
+                    display_name = {
+                        'eng': 'Related text',
+                        'fre': 'Texte lié ',
+                    },
+                    data_handler = 'list',
+                    nullable = True,
+                    allowed_classes = [text],
+                    group = editorial_group,
+                    back_reference = ('text', 'linked_entries'),
+                    default = None
+)
+# Classe article
+article = em.new_class( 'article',
+                        display_name = 'Article',
+                        group = editorial_group,
+                        abstract = False,
+                        parents = text)
+article.new_field(  'abstract',
+                    display_name = {
+                        'eng': 'Abstract',
+                        'fre': 'Résumé',
+                    },
+                    group = editorial_group,
+                    data_handler = 'text'
+)
+article.new_field(  'appendix',
+                    display_name = {
+                        'eng': 'Appendix',
+                        'fre': 'Appendice',
+                    },
+                    group = editorial_group,
+                    data_handler = 'text'
+)
+article.new_field(  'bibliography',
+                    display_name = {
+                        'eng': 'Bibliography',
+                        'fre': 'Bibliographie',
+                    },
+                    group = editorial_group,
+                    data_handler = 'text'
+)
+article.new_field(  'author_note',
+                    display_name = {
+                        'eng': 'Author note',
+                        'fre': "Note de l'auteur",
+                    },
+                    group = editorial_group,
+                    data_handler = 'text'
+)
+# Classe Review 
+review = em.new_class( 'review',
+                        display_name = 'Review',
+                        group = editorial_group,
+                        abstract = False,
+                        parents = text)
+review.new_field(   'reference',
+                    display_name = {
+                        'eng': 'Reference',
+                        'fre': "Référence",
+                    },
+                    group = editorial_group,
+                    data_handler = 'text'
+)
+
+###################################### Containers ###########################################
+# Classe container
+container = em.new_class(  'container',
+                            display_name = 'Container',
+                            group = editorial_group,
+                            abstract = True,
+                            parents = entitie)
+container.new_field(   'title',
+                        display_name = 'Title',
+                        group = editorial_group,
+                        data_handler = 'text'
+)
+container.new_field(   'subtitle',
+                        display_name = 'Subtitle',
+                        group = editorial_group,
+                        data_handler = 'text'
+)
+container.new_field(   'language',
+                        display_name = {
+                            'eng' : 'Language',
+                            'fre' : 'Langue',
+                        },
+                        group = editorial_group,
+                        data_handler = 'varchar'
+)
+container.new_field(    'linked_directors',
+                    display_name = {
+                        'eng': 'Directors',
+                        'fre': 'Directeurs',
+                    },
+                    group = editorial_group,
+                    data_handler = 'list',
+                    nullable = True,
+                    allowed_classes = [person],
+                    back_reference = ('person', 'linked_containers'),
+                    default = None
+)
+person.new_field(   'linked_containers',
+                    display_name = {
+                        'eng': 'Director of ',
+                        'fre': 'Directeur de ',
+                    },
+                    group = editorial_group,
+                    data_handler = 'list',
+                    nullable = True,
+                    allowed_classes = [container],
+                    back_reference = ('container', 'linked_directors'),
+                    default = None
+)
+container.new_field(    'description',
+                    display_name = {
+                        'eng': 'Description',
+                        'fre': 'Description',
+                    },
+                    data_handler = 'text',
+                    group = editorial_group,
+)
+container.new_field(    'publisher_note',
+                    display_name = {
+                        'eng': 'Publisher note',
+                        'fre': "Note de l'éditeur",
+                    },
+                    data_handler = 'text',
+                    group = editorial_group,
+)
+
+# Classe collection
+collection = em.new_class(  'collection',
+                            display_name = 'Collection',
+                            group = editorial_group,
+                            abstract = False,
+                            parents = container)
+collection.new_field(    'issn',
+                    display_name = {
+                        'eng': 'ISSN',
+                        'fre': "ISSN",
+                    },
+                    data_handler = 'varchar',
+                    group = editorial_group,
+)
+# Classe Publication : Pour gérer les back_references vers issue ou part
+publication = em.new_class(  'publication',
+                            display_name = 'Publication',
+                            group = editorial_group,
+                            abstract = True,
+                            parents = container)
+publication.new_field(  'linked_texts',
+                        display_name = {
+                            'eng': 'Text',
+                            'fre': 'Texte',
+                        },
+                      data_handler = 'list',
+                    nullable = True,
+                    allowed_classes = [text],
+                    group = editorial_group,
+                    back_reference = ('text', 'linked_container'),
+                    default = None
+)
+text.new_field(    'linked_container',
+                    display_name = {
+                        'eng': 'Container',
+                        'fre': 'Conteneur',
+                    },
+                    data_handler = 'link',
+                    nullable = True,
+                    allowed_classes = [publication],
+                    group = editorial_group,
+                    back_reference = ('publication', 'linked_texts'),
+                    default = None
+)
+# Classe Issue
+issue = em.new_class( 'issue',
+                        display_name = 'Issue',
+                        group = editorial_group,
+                        abstract = False,
+                        parents = publication)
+issue.new_field(    'isbn',
+                  display_name = 'ISBN',
+                  data_handler = 'varchar',
+                  group = editorial_group,
+)
+issue.new_field(    'print_isbn',
+                  display_name = {
+                    'eng': 'Printed ISBN',
+                    'fre': "ISBN imprimé",
+                  },
+                  data_handler = 'varchar',
+                  group = editorial_group,
+)
+issue.new_field(    'number',
+                    display_name = {
+                        'eng': 'Number',
+                        'fre': 'Numéro',
+                    },
+                  data_handler = 'varchar',
+                  group = editorial_group,
+)
+issue.new_field(    'cover',
+                    display_name = {
+                        'eng': 'Cover',
+                        'fre': 'Couverture',
+                    },
+                  data_handler = 'varchar',
+                  group = editorial_group,
+)
+issue.new_field(    'print_pub_date',
+                    display_name = {
+                        'eng': 'Print date',
+                        'fre': "Date d'impression",
+                    },
+                  data_handler = 'datetime',
+                  group = editorial_group,
+)     
+issue.new_field(    'e_pub_date',
+                    display_name = {
+                        'eng': 'Electronic publication date',
+                        'fre': 'Date de publication électronique',
+                    },
+                  data_handler = 'datetime',
+                  group = editorial_group,
+)  
+issue.new_field(    'abstract',
+                    display_name = {
+                        'eng': 'Abstract',
+                        'fre': 'Résumé',
+                    },
+                  data_handler = 'text',
+                  group = editorial_group,
+) 
+issue.new_field(    'collection',
+                    display_name = {
+                        'eng': 'Collection',
+                        'fre': 'Collection',
+                    },
+                    data_handler = 'link',
+                    nullable = True,
+                    allowed_classes = [collection],
+                    group = editorial_group,
+                    back_reference = ('collection', 'linked_issues'),
+                    default = None
+)
+collection.new_field(   'linked_issues',
+                        display_name = {
+                        'eng': 'Linked issues',
+                        'fre': 'Numéros',
+                    },
+                    data_handler = 'hierarch',
+                    back_reference = ('Issue', 'collection'),
+                    group = editorial_group,
+                    allowed_classes = [issue],
+                    default = None,
+                    nullable = True)
+# Classe Part
+part = em.new_class(  'part',
+                            display_name = 'Part',
+                            group = editorial_group,
+                            abstract = False,
+                            parents = publication,)
+part.new_field(     'publication',
+                    display_name = {
+                        'eng': 'Publication',
+                        'fre': 'Publication',
+                    },
+                    data_handler = 'link',
+                    nullable = True,
+                    allowed_classes = [publication],
+                    group = editorial_group,
+                    back_reference = ('publication', 'linked_parts'),
+                    default = None
+)
+publication.new_field(  'linked_parts',
+                        display_name = {
+                            'eng': 'Parts',
+                            'fre': 'Parties',
+                        },
+                      data_handler = 'hierarch',
+                    nullable = True,
+                    allowed_classes = [part],
+                    group = editorial_group,
+                    back_reference = ('part', 'publication'),
+                    default = None
+)
+
+#####################
+# Persons & authors #
+#####################
+
+editorial_person_group = em.new_group(  'editorial_person',
+                                        display_name = 'Editorial person',
+                                        help_text = {
+                                            'eng': 'Introduce the concept of editorial person (author, translator, director)',
+                                            'fre': 'Contient les classes servant à la gestion des personnes éditoriales (auteur, traducteur, directeur...)',
+                                        },
+                                        depends = (editorial_group,)
+)
+text_person = em.new_class( 'text_person',
+                            display_name = {
+                                'eng': 'TextPerson',
+                                'fre': 'TextePersonne',
+                            },
+                            help_text = {
+                                'eng': 'Represent a link between someone and a text',
+                                'fre': 'Représente un lien entre une personne et un texte',
+                            },
+                            group = editorial_person_group,
+                            abstract = True,
+                            parents = entitie,
+)
+bref_textperson_text = text_person.new_field(  'text',
+                                                display_name = {
+                                                    'eng': 'Linked text',
+                                                    'fre': 'Texte lié',
+                                                },
+                                                data_handler = 'link',
+                                                allowed_classes = [text],
+                                                group = editorial_person_group
+)
+bref_textperson_person = text_person.new_field( 'person',
+                                                display_name = {
+                                                    'eng': 'Linked person',
+                                                    'fre': 'Personne liée',
+                                                },
+                                                data_handler = 'link',
+                                                allowed_classes = [person],
+                                                group = editorial_person_group,
+)
+text_person.new_field(  'role',
+                        display_name = {
+                            'eng': 'Person role',
+                            'fre': 'Role de la personne',
+                        },
+                        data_handler = 'varchar',
+                        group = editorial_person_group
+)
+
+# simple example of linked text / person
+person.new_field(   'linked_texts',
+                    display_name = {
+                        'eng': 'Linked texts',
+                        'fre': 'Textes liés',
+                    },
+                    data_handler = 'list',
+                    back_reference = ('Text', 'linked_persons'),
+                    group = editorial_person_group,
+                    allowed_classes = [text],
+                    default = None,
+                    nullable = True)
+
+text.new_field( 'linked_persons',
+                display_name = {
+                    'eng': 'Linked persons',
+                    'fre': 'Personnes liées',
+                },
+                data_handler = 'list',
+                back_reference = ('Person', 'linked_texts'),
+                group = editorial_person_group,
+                allowed_classes = [person],
+                default = None,
+                nullable = True)
+
+#####################
+# Index classes     # <--- Note :   using a different datasource for testing
+#####################               purpose
+
+index_group = em.new_group( 'index_group',
+                            display_name = 'Indexes',
+                            help_text = {
+                                'eng': 'EM class that represents indexes'},
+                            depends = (editorial_group,))
+
+index_abstract = em.new_class(
+    'indexAbs',
+    display_name = {'eng': 'Abstract Index'},
+    help_text = {'eng': 'Abstract class common to each Index classes'},
+    abstract = True,
+    group = index_group,
+    datasources = 'dummy2',
+    parents = em_object)
+
+index_name = index_abstract.new_field(
+    'name',
+    display_name = {
+        'eng': 'name',
+        'fre': 'nom'},
+    data_handler = 'text',
+    group = index_group)
+
+index_value = index_abstract.new_field(
+    'value',
+    display_name = {
+        'eng': 'value',
+        'fre': 'valeur'},
+    data_handler = 'varchar',
+    group = index_group)
+
+text.new_field( 'indexes',
+    display_name = {
+        'eng': 'Indexes',
+        'fre': 'Indexes'},
+    data_handler = 'list',
+    back_reference = ('Indexabs', 'texts'),
+    allowed_classes = [index_abstract],
+    default = None,
+    nullable = True,
+    group = index_group)
+
+index_abstract.new_field( 'texts',
+    display_name = {
+        'eng': 'Text referenced by this index',
+        'fre': 'Texte contenant cette index'},
+    data_handler = 'list',
+    back_reference = ('Text', 'indexes'),
+    allowed_classes = [text],
+    group = index_group)
+
+index_theme = em.new_class(
+    'indexTheme',
+    display_name = {
+        'eng': 'Thematic index',
+        'fre': 'Index thématique'},
+    group = index_group,
+    datasources = 'dummy2',
+    parents = index_abstract)
+
+index_theme_theme = index_abstract.new_field(
+    'theme',
+    display_name = {
+        'eng': 'theme'},
+    data_handler = 'varchar',
+    group = index_group)
+
+#############
+#   USERS   #
+#############
+
+user_group = em.new_group(
+    'users', display_name = 'Lodel users',
+    help_text = 'Group that handle users en perm')
+
+user = em.new_class(
+    'user', display_name = 'Lodel user', help_text = 'Represent a lodel user',
+    group = user_group, abstract = False)
+
+user.new_field(
+    'id', display_name = 'user identifier', help_text = 'Uniq ID',
+    group = user_group, data_handler = 'uniqid', internal = True)
+
+user.new_field(
+    'firstname', display_name = 'Firstname',
+    group = user_group, data_handler = 'varchar', internal = False)
+
+user.new_field(
+    'lastname', display_name = 'Lastname',
+    group = user_group, data_handler = 'varchar', internal = False)
+
+user.new_field(
+    'login', display_name = 'user login', help_text = 'login',
+    group = user_group, data_handler = 'varchar', uniq = True, internal = False)
+
+user.new_field(
+    'password', display_name = 'Password',
+    group = user_group, data_handler = 'password', internal = False)
+
+
+#em.save('xmlfile', filename = 'examples/em_test.xml')
+pickle_file = 'examples/em_simple.pickle'
+em.save('picklefile', filename = pickle_file)
+print("Output written in %s" % pickle_file)

em_test.py

@@ -1,6 +1,9 @@
 #!/usr/bin/python3
 #-*- coding: utf-8 -*-
 
+from lodel.context import LodelContext
+LodelContext.init()
+
 from lodel.settings.settings import Settings as settings
 settings('globconf.d')
 from lodel.settings import Settings
@@ -188,6 +191,8 @@ publication.new_field(  'collection',
                         display_name = 'Collection',
                         group = editorial_group,
                         data_handler = 'link',
+                        default = None,
+                        nullable = True,
                         allowed_classes = [collection],
                         back_reference = ('collection', 'publications'))
 collection.new_field(   'publications',
@@ -226,6 +231,8 @@ subsection.new_field(   'parent',
                         display_name = 'Parent',
                         group = editorial_group,
                         data_handler = 'link',
+                        default = None,
+                        nullable = True,
                         allowed_classes = [section],
                         back_reference = ('section', 'childs'))
 

lodel/Makefile.am

@@ -1,5 +1,5 @@
-SUBDIRS=auth editorial_model leapi plugin settings utils
-
+SUBDIRS=auth editorial_model leapi plugin settings utils plugins
+EXTRA_DIST = plugins
 lodel_PYTHON = *.py
 CLEANFILES = buildconf.py
 

lodel/auth/client.py

@@ -5,12 +5,14 @@ import sys
 import warnings
 import inspect
 
-from lodel.settings import Settings
-from lodel import logger
-from lodel.plugin.hooks import LodelHook
-from lodel.plugin import SessionHandlerPlugin as SessionHandler
-from .exceptions import *
-from ..leapi.query import LeGetQuery
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings': ['Settings'],
+    'lodel.logger': 'logger',
+    'lodel.plugin': [('SessionHandlerPlugin', 'SessionHandler')],
+    'lodel.auth.exceptions': ['ClientError', 'ClientAuthenticationFailure',
+        'ClientPermissionDenied', 'ClientAuthenticationError'],
+    'lodel.leapi.query': ['LeGetQuery'],})
 
 ##@brief Client metaclass designed to implements container accessor on 
 #Client Class
@@ -241,7 +243,7 @@ a session is allready started !!!")
     #informations on login and password location (LeApi object & field)
     @classmethod
     def fetch_settings(cls):
-        from lodel import dyncode
+        LodelContext.expose_dyncode(globals(), 'dyncode')
         if cls._infos_fields is None:
             cls._infos_fields = list()
         else:

lodel/auth/exceptions.py

@@ -1,5 +1,8 @@
-from lodel import logger
-from lodel.plugin.hooks import LodelHook
+from lodel.context import LodelContext
+
+LodelContext.expose_modules(globals(), {
+    'lodel.logger': 'logger',
+    'lodel.plugin.hooks': ['LodelHook']})
 
 ##@brief Handles common errors with a Client
 class ClientError(Exception):

lodel/context.py

@@ -0,0 +1,471 @@
+import importlib
+import importlib.machinery
+import importlib.abc
+import sys
+import types
+import os
+import os.path
+import re
+import copy
+
+import warnings #For the moment no way to use the logger in this file (I guess)
+
+#A try to avoid circular dependencies problems
+if 'lodel' not in sys.modules: 
+    import lodel
+else:
+    globals()['lodel'] = sys.modules['lodel']
+
+if 'lodelsites' not in sys.modules:
+    import lodelsites
+else:
+    globals()['lodelsites'] = sys.modules['lodelsites']
+
+##@brief Name of the package that will contains all the virtual lodel
+#packages
+CTX_PKG = "lodelsites"
+
+##@brief Reserved context name for loading steps
+#@note This context is designed to be set at loading time, allowing lodel2
+#main process to use lodel packages
+LOAD_CTX = "__loader__"
+
+
+#
+#   Following exception classes are written here to avoid circular dependencies
+#   problems.
+#
+
+##@brief Designed to be raised by the context manager
+class ContextError(Exception):
+    pass
+
+##@brief Raised when an error concerning context modules occurs
+class ContextModuleError(ContextError):
+    pass
+
+def dir_for_context(site_identifier):
+    return os.path.join(lodelsites.__path__[0], site_identifier)
+    
+
+##@brief Designed to permit dynamic packages creation from the lodel package
+#
+#The class is added in first position in the sys.metapath variable. Doing this
+#we override the earlier steps of the import mechanism.
+#
+#When called the find_spec method determine wether the imported module is
+#a part of a virtual lodel package, else  it returns None and the standart
+#import mechanism go further.
+#If it's a submodule of a virtual lodel package we create a symlink
+#to represent the lodel package os the FS and then we make python import
+#files from the symlink.
+#
+#@note Current implementation is far from perfection. In fact no deletion
+#mechanisms is written and the virtual package cannot be a subpackage of
+#the lodel package for the moment...
+#@note Current implementation asserts that all plugins are in CWD
+#a symlink will be done to create a copy of the plugins folder in 
+#lodelsites/SITENAME/ folder
+class LodelMetaPathFinder(importlib.abc.MetaPathFinder):
+    
+    def find_spec(fullname, path, target = None):
+        if fullname.startswith(CTX_PKG):
+            spl = fullname.split('.')
+            site_identifier = spl[1]
+            #creating a symlink to represent the lodel site package
+            mod_path = dir_for_context(site_identifier)
+            if not os.path.exists(mod_path):
+                os.symlink(lodel.__path__[0], mod_path, True)
+            #Cache invalidation after we "created" the new package
+            #importlib.invalidate_caches()
+        return None
+
+
+##@brief Class designed to handle context switching and virtual module
+#exposure
+#
+#@note a dedicated context named LOAD_CTX is used as context for the 
+#loading process
+class LodelContext(object):
+    
+    ##@brief FLag telling that the context handler is in single context mode
+    MONOSITE = 1
+    ##@brief Flag telling that the context manager is in multi context mode
+    MULTISITE = 2
+
+    ##@brief Static property storing current context name
+    _current = None
+    ##@brief Stores the context type (single or multiple)
+    _type = None
+    ##@brief Stores the contexts
+    _contexts = None
+
+    ##@brief Flag indicating if the classe is initialized
+    __initialized = False
+    
+    ##@brief Create a new context
+    #@see LodelContext.new()
+    def __init__(self, site_id, instance_path = None):
+        if site_id is None and self.multisite():
+            site_id = LOAD_CTX
+        if self.multisite() and site_id is not LOAD_CTX:
+            with LodelContext.with_context(None) as ctx:
+                ctx.expose_modules(globals(), {'lodel.logger': 'logger'})
+                logger.info("New context instanciation named '%s'" % site_id)
+        if site_id is None:
+            self.__id = "MONOSITE"
+            #Monosite instanciation
+            if self.multisite():
+                raise ContextError("Cannot instanciate a context with \
+site_id set to None when we are in MULTISITE beahavior")
+            else:
+                #More verification can be done here (singleton specs ? )
+                self.__class__._current = self.__class__._contexts = self
+                self.__pkg_name = 'lodel'
+                self.__package = lodel
+                self.__instance_path = os.getcwd()
+                return
+        else:
+            #Multisite instanciation
+            if not self.multisite():
+                raise ContextError("Cannot instanciate a context with a \
+site_id when we are in MONOSITE beahvior")
+            if not self.validate_identifier(site_id):
+                raise ContextError("Given context name is not a valide identifier \
+    : '%s'" % site_id)
+            if site_id in self.__class__._contexts:
+                raise ContextError(
+                    "A context named '%s' allready exists." % site_id)
+            self.__id = site_id
+            self.__pkg_name = '%s.%s' % (CTX_PKG, site_id)
+
+            if instance_path is None:
+                """
+                raise ContextError("Cannot create a context without an \
+instance path")
+                """
+                warnings.warn("It can be a really BAD idea to create a \
+a context without a path......")
+                self.__instance_path = None
+            else:
+                self.__instance_path = os.path.realpath(instance_path)
+            #Importing the site package to trigger its creation
+            self.__package = importlib.import_module(self.__pkg_name)
+            self.__class__._contexts[site_id] = self
+        #Designed to be use by with statement
+        self.__previous_ctx = None
+    
+    ##@brief Expose a module from the context
+    #@param globs globals : globals where we have to expose the module
+    #@param spec tuple : first item is module name, second is the alias
+    def expose(self, globs, spec):
+        if len(spec) != 2:
+            raise ContextError("Invalid argument given. Expected a tuple of \
+length == 2 but got : %s" % spec)
+        module_fullname, exposure_spec = spec
+        module_fullname = self._translate(module_fullname)
+        if isinstance(exposure_spec, str):
+            self._expose_module(globs, module_fullname, exposure_spec)
+        else:
+            self._expose_objects(globs, module_fullname, exposure_spec)
+
+    ##@brief Return a module from current context
+    def get_module(self, fullname):
+        fullname = self._translate(fullname)
+        module = importlib.import_module(fullname)
+        return module
+        
+    
+    ##@brief Delete a site's context
+    #@param site_id str : the site's name to remove the context
+    def remove(cls, site_id):
+        if site_id is None:
+            if cls._type == cls.MULTISITE:
+                raise ContextError("Cannot have a context with \
+site_id set to None when we are in MULTISITE beahavior")
+            del cls._contexts
+        else:
+            if cls._type == cls.MULTISITE:
+                if site_id in cls._contexts:
+                    del cls._contexts[site_id]
+                else:
+                    raise ContextError("No site %s exist" % site_id)
+            else:
+                raise ContextError("Cannot have a context with \
+    site_id set when we are in MONOSITE beahavior")
+    
+    ##@return True if the class is in MULTISITE mode
+    @classmethod
+    def multisite(cls):
+        return cls._type == cls.MULTISITE
+    
+    ##@brief helper class to use LodeContext with with statement
+    #@note alias to get method
+    #@note maybe useless
+    #@todo delete me
+    @classmethod
+    def with_context(cls, target_ctx_id):
+        return cls.get(target_ctx_id)
+
+    ##@brief Set a context as active
+    #@param site_id str : site identifier (identify a context)
+    @classmethod
+    def set(cls, site_id):
+        if cls._type == cls.MONOSITE:
+            raise ContextError("Context cannot be set in MONOSITE beahvior")
+        site_id = LOAD_CTX if site_id is None else site_id
+        if not cls.validate_identifier(site_id):
+            raise ContextError("Given context name is not a valide identifier \
+: '%s'" % site_id)
+        if site_id not in cls._contexts:
+            raise ContextError("No context named '%s' found." % site_id)
+        wanted_ctx = cls._contexts[site_id]
+        if hasattr(wanted_ctx, '__instance_path'):
+            os.chdir(self.__instance_path) #May cause problems
+        cls._current = wanted_ctx
+        return cls._current
+    
+    ##@brief Getter for contexts
+    #@param ctx_id str | None | False : if False return the current context
+    #@return A LodelContext instance
+    @classmethod
+    def get(cls, ctx_id = False):
+        if ctx_id is False:
+            if cls._current is None:
+                raise ContextError("No context loaded")
+            return cls._current
+        ctx_id = LOAD_CTX if ctx_id is None else ctx_id
+        if ctx_id not in cls._contexts:
+            raise ContextError("No context identified by '%s'" % ctx_id)
+        return cls._contexts[ctx_id]
+    
+    ##@brief Returns the name of the loaded context
+    @classmethod
+    def get_name(cls):
+        if cls._current is None:
+            raise ContextError("No context loaded")
+        return copy.copy(cls._current.__id)
+        
+
+    ##@brief Create a new context given a context name
+    #
+    #@note It's just an alias to the LodelContext.__init__ method
+    #@param site_id str : context name
+    #@return the context instance
+    @classmethod
+    def new(cls, site_id, instance_path = None):
+        if site_id is None:
+            site_id = LOAD_CTX
+        return cls(site_id, instance_path)
+
+    ##@brief Helper function that import and expose specified modules
+    #
+    #The specs given is a dict. Each element is indexed by a module
+    #fullname. Items can be of two types :
+    #@par Simple import with alias
+    #In this case items of specs is a string representing the alias name
+    #for the module we are exposing
+    #@par from x import i,j,k equivalent
+    #In this case items are lists of object name to expose as it in globals.
+    #You can specify an alias by giving a tuple instead of a string as 
+    #list element. In this case the first element of the tuple is the object
+    #name and the second it's alias in the globals
+    #
+    #@todo make the specs format more consitant
+    #@param cls : bultin params
+    #@param globs dict : the globals dict of the caller module
+    #@param specs dict : specs of exposure (see comments of this method)
+    #@todo implements relative module imports. (maybe by looking for 
+    #"calling" package in globs dict)
+    @classmethod
+    def expose_modules(cls, globs, specs):
+        ctx = cls.get()
+        for spec in specs.items():
+            ctx.expose(globs, spec)
+    
+    ##@brief Return a module from current context
+    #@param fullname str : module fullname
+    @classmethod
+    def module(cls, fullname):
+        return cls.get().get_module(fullname)
+        
+    ##@brief Expose leapi_dyncode module
+    @classmethod
+    def expose_dyncode(cls, globs, alias = 'leapi_dyncode'):
+        cls.get()._expose_dyncode(globs, alias)
+
+    ##@brief Initialize the context manager
+    #
+    #@note Add the LodelMetaPathFinder class to sys.metapath if type is
+    #LodelContext.MULTISITE
+    #@param type FLAG : takes value in LodelContext.MONOSITE or
+    #LodelContext.MULTISITE
+    @classmethod
+    def init(cls, type=MONOSITE):
+        if cls._current is not None:
+            raise ContextError("Context allready started and used. Enable to \
+initialize it anymore")
+        if type not in ( cls.MONOSITE, cls.MULTISITE):
+            raise ContextError("Invalid flag given : %s" % type)
+        cls._type = type
+        if cls._type == cls.MULTISITE:
+            cls._contexts = dict()
+            #Add custom MetaPathFinder allowing implementing custom imports
+            sys.meta_path = [LodelMetaPathFinder] + sys.meta_path
+            #Create and set __loader__ context
+            cls.new(LOAD_CTX)
+            cls.set(LOAD_CTX)
+        else:
+            #Add a single context with no site_id
+            cls._contexts = cls._current = cls(None)
+        cls.__initialized = True
+    
+    ##@return True if the class is initialized
+    @classmethod
+    def is_initialized(cls):
+        return cls.__initialized
+    
+    ##@brief Return the directory of the package of the current loaded context
+    @classmethod
+    def context_dir(cls):
+        if cls._type == cls.MONOSITE:
+            return './'
+        return dir_for_context(cls._current.__id)
+        
+
+    ##@brief Validate a context identifier
+    #@param identifier str : the identifier to validate
+    #@return true if the name is valide else false
+    @staticmethod
+    def validate_identifier(identifier):
+        if identifier == LOAD_CTX:
+            return True
+        return identifier is None or \
+            re.match(r'^[a-zA-Z0-9][a-zA-Z0-9_]', identifier)
+    
+    ##@brief Safely expose a module in globals using an alias name
+    #
+    #@note designed to implements warning messages or stuff like that
+    #when doing nasty stuff
+    #
+    #@warning Logging stuffs may lead in a performance issue
+    #
+    #@todo try to use the logger module instead of warnings
+    #@param globs globals : the globals where we want to expose our
+    #module alias
+    #@param obj object : the object we want to expose
+    #@param alias str : the alias name for our module
+    @staticmethod
+    def safe_exposure(globs, obj, alias):
+        if alias in globs:
+            if globs[alias] != obj:
+                print("Context '%s' : A module exposure leads in globals overwriting for \
+key '%s' with a different value : %s != %s" % (LodelContext.get_name(), alias, globs[alias], obj))
+                """#Uncomment this bloc to display a stack trace for dangerous modules overwriting
+                print("DEBUG INFOS : ")
+                import traceback
+                traceback.print_stack()
+                """
+            else:
+                print("Context '%s' : A module exposure leads in a useless replacement for \
+key '%s'" % (LodelContext.get_name(),alias))
+        globs[alias] = obj
+        
+    ##@brief Create a context from a path and returns the context name
+    #@param path str : the path from which we extract a sitename
+    #@return the site identifier
+    @classmethod
+    def from_path(cls, path):
+        if cls._type != cls.MULTISITE:
+            raise ContextError("Cannot create a context from a path in \
+MONOSITE mode")
+        site_id = os.path.basename(path.strip('/'))
+        path = os.path.realpath(path)
+        if not cls.validate_identifier(site_id):
+            raise ContextError(
+                "Unable to create a context named '%s'" % site_id)
+        cls.new(site_id, path)
+        return site_id
+
+
+
+    ##@brief Utility method to expose a module with an alias name in globals
+    #@param globs globals() : concerned globals dict
+    #@param fullname str : module fullname
+    #@param alias str : alias name
+    @classmethod
+    def _expose_module(cls, globs, fullname, alias):
+        module = importlib.import_module(fullname)
+        cls.safe_exposure(globs, module, alias)
+    
+    ##@brief Utility mehod to expose objects like in a from x import y,z
+    #form
+    #@param globs globals() : dict of globals
+    #@param fullename str : module fullname
+    #@param objects list : list of object names to expose
+    @classmethod
+    def _expose_objects(cls, globs, fullname, objects):
+        errors = []
+        module = importlib.import_module(fullname)
+        for o_name in objects:
+            if isinstance(o_name, str):
+                alias = o_name
+            else:
+                o_name, alias = o_name
+            if not hasattr(module, o_name):
+                errors.append(o_name)
+            else:
+                cls.safe_exposure(globs, getattr(module, o_name), alias)
+        if len(errors) > 0:
+            msg = "Module %s does not have any of [%s] as attribute" % (
+                fullname, ','.join(errors))
+            raise ImportError(msg)
+    
+    ##@brief Implements LodelContext::expose_dyncode()
+    #@todo change hardcoded leapi_dyncode.py filename
+    def _expose_dyncode(self, globs, alias = 'leapi_dyncode'):
+        fullname = '%s.%s.dyncode' % (CTX_PKG, self.__id)
+        if fullname in sys.modules:
+            dyncode = sys.modules[fullname]
+        else:
+            path = os.path.join(self.__instance_path, 'leapi_dyncode.py')
+            sfl = importlib.machinery.SourceFileLoader(fullname, path)
+            dyncode = sfl.load_module()
+        self.safe_exposure(globs, dyncode, alias)
+    
+    ##@brief Translate a module fullname to the context equivalent
+    #@param module_fullname str : a module fullname
+    #@return The module name in the current context
+    def _translate(self, module_fullname):
+        if not module_fullname.startswith('lodel'):
+            raise ContextModuleError("Given module is not lodel or any \
+submodule : '%s'" % module_fullname)
+        return module_fullname.replace('lodel', self.__pkg_name)
+
+    ##@brief Implements the with statement behavior
+    #@see https://www.python.org/dev/peps/pep-0343/
+    #@see https://wiki.python.org/moin/WithStatement
+    def __enter__(self):
+        if not self.multisite:
+            warnings.warn("Using LodelContext with with statement in \
+MONOSITE mode")
+        if self.__previous_ctx is not None:
+            raise ContextError("__enter__ called but a previous context \
+is allready registered !!! Bailout")
+        current = LodelContext.get().__id
+        if current != self.__id:
+            #Only switch if necessary
+            self.__previous_ctx = LodelContext.get().__id
+            LodelContext.set(self.__id)
+        return self
+
+    ##@brief Implements the with statement behavior
+    #@see https://www.python.org/dev/peps/pep-0343/
+    #@see https://wiki.python.org/moin/WithStatement
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        prev = self.__previous_ctx
+        self.__previous_ctx = None
+        if prev is not None:
+            #Only restore if needed
+            LodelContext.set(self.__previous_ctx)
+

lodel/editorial_model/components.py

@@ -9,11 +9,12 @@ import warnings
 import copy
 import hashlib
 
-from lodel.utils.mlstring import MlString
-
-from lodel.settings import Settings
-from lodel.editorial_model.exceptions import *
-from lodel.leapi.leobject import CLASS_ID_FIELDNAME
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.utils.mlstring': ['MlString'],
+    'lodel.settings': ['Settings'],
+    'lodel.editorial_model.exceptions': ['EditorialModelError', 'assert_edit'],
+    'lodel.leapi.leobject': ['CLASS_ID_FIELDNAME']})
 
 ##@brief Abstract class to represent editorial model components
 # @see EmClass EmField

lodel/editorial_model/model.py

@@ -4,13 +4,15 @@ import hashlib
 import importlib
 import copy
 
-from lodel.utils.mlstring import MlString
-from lodel import logger
-from lodel.settings import Settings
-from lodel.settings.utils import SettingsError
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.utils.mlstring': ['MlString'],
+    'lodel.logger': 'logger',
+    'lodel.settings': ['Settings'],
+    'lodel.settings.utils': ['SettingsError'],
+    'lodel.editorial_model.exceptions': ['EditorialModelError', 'assert_edit'],
+    'lodel.editorial_model.components': ['EmClass', 'EmField', 'EmGroup']})
 
-from lodel.editorial_model.exceptions import *
-from lodel.editorial_model.components import EmClass, EmField, EmGroup
 
 ##@brief Describe an editorial model
 #@ingroup lodel2_em

lodel/editorial_model/translator/xmlfile.py

@@ -3,9 +3,13 @@
 import lxml
 import os
 from lxml import etree
-from lodel.editorial_model.model import EditorialModel
-from lodel.editorial_model.components import *
-from lodel.utils.mlstring import MlString
+
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.editorial_model.model': ['EditorialModel'],
+    'lodel.editorial_model.components': ['EmComponent', 'EmClass', 'EmField',
+        'EmGroup'],
+    'lodel.utils.mlstring': ['MlString']})
 
 ##@package lodel.editorial_model.translator.xmlfile Translator module designed
 #to load & save EM in XML

lodel/exceptions.py

@@ -42,3 +42,4 @@ class DataNoneValid(Exception):
 #@note Designed to be raised in DataHandler
 class FieldValidationError(Exception):
     pass
+

lodel/leapi/datahandlers/base_classes.py

@@ -2,14 +2,20 @@
 
 ## @package lodel.leapi.datahandlers.base_classes Define all base/abstract class for data handlers
 #
-# Contains custom exceptions too
+# Contains custom exceptions too
 
 import copy
 import importlib
 import inspect
 import warnings
-from lodel.exceptions import *
-from lodel import logger
+
+from lodel.context import LodelContext
+
+LodelContext.expose_modules(globals(), {
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError'],
+    'lodel.leapi.datahandlers.exceptions': ['LodelDataHandlerConsistencyException', 'LodelDataHandlerException'],
+    'lodel.logger': 'logger'})
 
 
 ##@brief Base class for all data handlers
@@ -20,7 +26,7 @@ class DataHandler(object):
     ##@brief Stores the DataHandler childs classes indexed by name
     _base_handlers = None
     ##@brief Stores custom datahandlers classes indexed by name
-    # @todo do it ! (like plugins, register handlers... blablabla)
+    # @todo do it ! (like plugins, register handlers... blablabla)
     __custom_handlers = dict()
 
     help_text = 'Generic Field Data Handler'
@@ -330,6 +336,12 @@ class Reference(DataHandler):
             logger.warning('Object referenced does not exist')
             return False
         return True
+    
+    ##@brief Utility method designed to fetch referenced objects
+    #@param value mixed : the field value
+    #@throw NotImplementedError
+    def get_referenced(self, value):
+        raise NotImplementedError
 
 
 ##@brief This class represent a data_handler for single reference to another object
@@ -338,7 +350,7 @@ class Reference(DataHandler):
 class SingleRef(Reference):
 
     def __init__(self, allowed_classes=None, **kwargs):
-        super().__init__(allowed_classes=allowed_classes)
+        super().__init__(allowed_classes=allowed_classes, **kwargs)
 
 
     ##@brief Check and cast value in appropriate type
@@ -352,6 +364,17 @@ class SingleRef(Reference):
         #    raise FieldValidationError("List or string expected for a set field")
         return value
 
+    ##@brief Utility method designed to fetch referenced objects
+    #@param value mixed : the field value
+    #@return A LeObject child class instance
+    #@throw LodelDataHandlerConsistencyException if no referenced object found
+    def get_referenced(self, value):
+        for leo_cls in self.linked_classes:
+            res = leo_cls.get_from_uid(value)
+            if res is not None:
+                return res
+        raise LodelDataHandlerConsistencyException("Unable to find \
+referenced object with uid %s" % value)
 
 
 ##@brief This class represent a data_handler for multiple references to another object
@@ -397,70 +420,27 @@ class MultipleRef(Reference):
             raise FieldValidationError("MultipleRef have for invalid values [%s]  :" % (",".join(error_list)))
         return new_val
 
-    ##@brief Construct a multiple ref data
-    def construct_data(self, emcomponent, fname, datas, cur_value):
-        cur_value = super().construct_data(emcomponent, fname, datas, cur_value)
-        if cur_value is not None:
-            if self.back_reference is not None:
-                br_class = self.back_reference[0]
-                for br_id in cur_value:
-                    query_filters = list()
-                    query_filters.append((br_class.uid_fieldname()[0], '=', br_id))
-                    br_obj = br_class.get(query_filters)
-                    if len(br_obj) != 0:
-                        br_list = br_obj[0].data(self.back_reference[1])
-                        if br_list is None:
-                            br_list = list()
-                        if br_id not in br_list:
-                            br_list.append(br_id)
-        return cur_value
-
-    ## @brief Checks the backreference, updates it if it is not complete
-    # @param emcomponent EmComponent : An EmComponent child class instance
-    # @param fname : the field name
-    # @param datas dict : dict storing fields values
-    # @note Not done in case of delete
-    def make_consistency(self, emcomponent, fname, datas, type_query):
-        dh = emcomponent.field(fname)
-        logger.info('Warning : multiple uid capabilities are broken here')
-        uid = datas[emcomponent.uid_fieldname()[0]]
-        if self.back_reference is not None:
-            target_class = self.back_reference[0]
-            target_field = self.back_reference[1]
-            target_uidfield = target_class.uid_fieldname()[0]
-            l_value = datas[fname]
-
-            if l_value is not None:
-                for value in l_value:
-                    query_filters = list()
-                    query_filters.append((target_uidfield, '=', value))
-                    obj = target_class.get(query_filters)
-                    if len(obj) == 0:
-                        logger.warning('Object referenced does not exist')
-                        return False
-                    l_uids_ref = obj[0].data(target_field)
-                    if l_uids_ref is None:
-                        l_uids_ref = list()
-                    if uid not in l_uids_ref:
-                        l_uids_ref.append(uid)
-                        obj[0].set_data(target_field, l_uids_ref)
-                        obj[0].update()
-
-            if type_query == 'update':
-                query_filters = list()
-                query_filters.append((uid, ' in ', target_field))
-                objects = target_class.get(query_filters)
-                if l_value is None:
-                    l_value = list()
-                if len(objects) != len(l_value):
-                    for obj in objects:
-                        l_uids_ref = obj.data(target_field)
-                        if obj.data(target_uidfield) not in l_value:
-                            l_uids_ref.remove(uid)
-                            obj.set_data(target_field, l_uids_ref)
-                            obj.update()
-
-
+    ##@brief Utility method designed to fetch referenced objects
+    #@param value mixed : the field value
+    #@return A list of LeObject child class instance
+    #@throw LodelDataHandlerConsistencyException if some referenced objects
+    #were not found
+    def get_referenced(self, values):
+        if values is None or len(values) == 0:
+            return list()
+        left = set(values)
+        values = set(values)
+        res = list()
+        for leo_cls in self.linked_classes:
+            uidname = leo_cls.uid_fieldname()[0] #MULTIPLE UID BROKEN HERE
+            tmp_res = leo_cls.get(('%s in (%s)' % (uidname, ','.join(
+                [str(l) for l in left]))))
+            left ^= set(( leo.uid() for leo in tmp_res))
+            res += tmp_res
+            if len(left) == 0:
+                return res
+        raise LodelDataHandlerConsistencyException("Unable to find \
+some referenced objects. Followinf uid were not found : %s" % ','.join(left))
 
 ## @brief Class designed to handle datas access will fieldtypes are constructing datas
 #@ingroup lodel2_datahandlers

lodel/leapi/datahandlers/datas.py

@@ -1,10 +1,17 @@
 #-*- coding: utf-8 -*-
 import warnings
 import inspect
-from lodel.leapi.datahandlers.datas_base import *
-from lodel.exceptions import *
 import re
 
+from lodel.context import LodelContext
+
+LodelContext.expose_modules(globals(), {
+    'lodel.leapi.datahandlers.datas_base': ['Boolean', 'Integer', 'Varchar',
+        'DateTime', 'Text', 'File'],
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
+
+
 ##@brief Data field designed to handle formated strings
 class FormatString(Varchar):
 

lodel/leapi/datahandlers/datas_base.py

@@ -4,8 +4,11 @@ import datetime
 import time
 import os
 
-from lodel.leapi.datahandlers.base_classes import DataField
-from lodel.exceptions import *
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.leapi.datahandlers.base_classes': ['DataField'],
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
 
 ##@brief Data field designed to handle boolean values

lodel/leapi/datahandlers/exceptions.py

@@ -1,2 +1,5 @@
 def LodelDataHandlerException(Exception):
     pass
+
+def LodelDataHandlerConsistencyException(LodelDataHandlerException):
+    pass

lodel/leapi/datahandlers/references.py

@@ -1,7 +1,12 @@
 # -*- coding: utf-8 -*-
-from lodel.leapi.datahandlers.base_classes import Reference, MultipleRef, SingleRef
-from lodel.exceptions import *
-from lodel import logger
+
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.leapi.datahandlers.base_classes': ['Reference', 'MultipleRef',
+        'SingleRef'],
+    'lodel.logger': 'logger',
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
 class Link(SingleRef):
     pass

lodel/leapi/exceptions.py

@@ -1,6 +1,8 @@
 #-*- coding: utf-8 -*-
 
-from lodel.exceptions import LodelExceptions, LodelException
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.exceptions': ['LodelExceptions', 'LodelException']})
 
 class LeApiError(LodelException):
     pass

lodel/leapi/lefactory.py

@@ -2,10 +2,14 @@
 
 import os, os.path
 import functools
-from lodel.editorial_model.components import *
-from lodel.leapi.leobject import LeObject
-from lodel.leapi.datahandlers.base_classes import DataHandler
-from lodel import logger
+
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.editorial_model.components': ['EmComponent', 'EmClass', 'EmField',
+        'EmGroup'],
+    'lodel.leapi.leobject': ['LeObject'],
+    'lodel.leapi.datahandlers.base_classes': ['DataHandler'],
+    'lodel.logger': 'logger'})
 
 ##@brief Generate python module code from a given model
 # @param model lodel.editorial_model.model.EditorialModel
@@ -15,9 +19,11 @@ def dyncode_from_em(model):
     cls_code, modules, bootstrap_instr = generate_classes(model)
 
     # Header
-    imports = """from lodel.leapi.leobject import LeObject
-from lodel.leapi.datahandlers.base_classes import DataField
-from lodel.plugin.hooks import LodelHook
+    imports = """from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.leapi.leobject': ['LeObject'],
+    'lodel.leapi.datahandlers.base_classes': ['DataField'],
+    'lodel.plugin.hooks': ['LodelHook']})
 """
     for module in modules:
         imports += "import %s\n" % module

lodel/leapi/lefactory_common.py

@@ -5,7 +5,6 @@
 #- All lines that begins with #- will be deleted from dynamically generated
 #- code...
 
-
 ##@brief Return a dynamically generated class given it's name
 #@param name str : The dynamic class name
 #@return False or a child class of LeObject
@@ -32,6 +31,6 @@ def lowername2class(name):
 def lodel2_dyncode_datasources_init(self, caller, payload):
     for cls in dynclasses:
         cls._init_datasources()
-    from lodel.plugin.hooks import LodelHook
+    LodelContext.expose_modules(globals(), {'lodel.plugin.hooks': ['LodelHook']})
     LodelHook.call_hook("lodel2_dyncode_loaded", __name__, dynclasses)
 

lodel/leapi/leobject.py

@@ -4,16 +4,23 @@ import importlib
 import warnings
 import copy
 
-from lodel import logger
-from lodel.settings import Settings
-from lodel.settings.utils import SettingsError
-from .query import LeInsertQuery, LeUpdateQuery, LeDeleteQuery, LeGetQuery
-from .exceptions import *
-from lodel.plugin.exceptions import *
-from lodel.plugin.hooks import LodelHook
-from lodel.plugin import Plugin, DatasourcePlugin
-from lodel.leapi.datahandlers.base_classes import DatasConstructor
-from lodel.leapi.datahandlers.base_classes import Reference
+from lodel.context import LodelContext
+
+LodelContext.expose_modules(globals(), {
+    'lodel.logger': 'logger',
+    'lodel.settings': 'Settings',
+    'lodel.settings.utils': 'SettingsError',
+    'lodel.leapi.query': ['LeInsertQuery', 'LeUpdateQuery', 'LeDeleteQuery',
+        'LeGetQuery'],
+    'lodel.leapi.exceptions': ['LeApiError', 'LeApiErrors',
+        'LeApiDataCheckError', 'LeApiDataCheckErrors', 'LeApiQueryError',
+        'LeApiQueryErrors'],
+    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
+        'LodelScriptError', 'DatasourcePluginError'],
+    'lodel.exceptions': ['LodelFatalError'],
+    'lodel.plugin.hooks': ['LodelHook'],
+    'lodel.plugin': ['Plugin', 'DatasourcePlugin'],
+    'lodel.leapi.datahandlers.base_classes': ['DatasConstructor', 'Reference']})
 
 ##@brief Stores the name of the field present in each LeObject that indicates
 #the name of LeObject subclass represented by this object
@@ -160,7 +167,7 @@ class LeObject(object):
     def reference_handlers(cls, with_backref = True):
         return {    fname: fdh 
                     for fname, fdh in cls.fields(True).items()
-                    if issubclass(fdh.__class__, Reference) and \
+                    if fdh.is_reference() and \
                         (not with_backref or fdh.back_reference is not None)}
     
     ##@brief Return a LeObject child class from a name
@@ -621,8 +628,22 @@ construction and consitency when datas are not complete\n")
     #@todo broken multiple UID
     @classmethod
     def get_from_uid(cls, uid):
+        if cls.uid_fieldname() is None:
+            raise LodelFatalError(
+                "No uid defined for class %s" % cls.__name__)
         uidname = cls.uid_fieldname()[0] #Brokes composed UID
         res = cls.get([(uidname,'=', uid)])
+        
+        #dedoublonnage vu que query ou la datasource est bugué
+        if len(res) > 1:
+            res_cp = res
+            res = []
+            while len(res_cp) > 0:
+                cur_res = res_cp.pop()
+                if cur_res.uid() in [ r.uid() for r in res_cp]:
+                    logger.error("DOUBLON detected in query results !!!")
+                else:
+                    res.append(cur_res)
         if len(res) > 1:
             raise LodelFatalError("Get from uid returned more than one \
 object ! For class %s with uid value = %s" % (cls, uid))

lodel/leapi/query.py

@@ -5,9 +5,13 @@ import copy
 import inspect
 import warnings
 
-from .exceptions import *
-from lodel.plugin.hooks import LodelHook
-from lodel import logger
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.leapi.exceptions': ['LeApiError', 'LeApiErrors', 
+        'LeApiDataCheckError', 'LeApiDataCheckErrors', 'LeApiQueryError',
+        'LeApiQueryErrors'],
+    'lodel.plugin.hooks': ['LodelHook'],
+    'lodel.logger': ['logger']})
 
 
 ##@todo check datas when running query
@@ -44,11 +48,11 @@ class LeQuery(object):
             self._target_class.prepare_datas(datas) #not yet implemented
         if self._hook_prefix is None:
             raise NotImplementedError("Abstract method")
-        LodelHook.call_hook(self._hook_prefix+'_pre',
+        LodelHook.call_hook(self._hook_prefix+'pre',
                                 self._target_class,
                                 datas)
         ret = self._query(datas=datas)
-        ret = LodelHook.call_hook(self._hook_prefix+'_post',
+        ret = LodelHook.call_hook(self._hook_prefix+'post',
                                     self._target_class,
                                     ret)
         return ret

lodel/logger.py

@@ -13,17 +13,21 @@ handlers = dict() # Handlers list (generated from settings)
 ##@brief Stores sent messages until module is able to be initialized
 msg_buffer = []
 
-# Fetching default root logger
-logger = logging.getLogger()
+# Fetching logger for current context
+from lodel.context import LodelContext
+logger = logging.getLogger(LodelContext.get_name())
 
 ##@brief Module initialisation from settings
 #@return True if inited else False
 def __init_from_settings():
+    from lodel.context import LodelContext
     try:
-        from lodel.settings import Settings
+        LodelContext.expose_modules(globals(), {
+            'lodel.settings': ['Settings']})
     except Exception:
         return False
-    from lodel.settings.settings import Settings as Lodel2Settings
+    LodelContext.expose_modules(globals(), {
+        'lodel.settings.settings': [('Settings', 'Lodel2Settings')]})
     if not Lodel2Settings.started():
         return False
     # capture warning disabled, because the custom format raises error (unable
@@ -49,7 +53,7 @@ def __init_from_settings():
 # @param name str : The handler name
 # @param logging_opt dict : dict containing options ( see above )
 def add_handler(name, logging_opt):
-    logger = logging.getLogger()
+    logger = logging.getLogger(LodelContext.get_name())
     if name in handlers:
         raise KeyError("A handler named '%s' allready exists")
     
@@ -115,6 +119,9 @@ def log(lvl, msg, *args, **kwargs):
         else:
             for s_kwargs, args in msg_buffer:
                 log(*args, **s_kwargs)
+    from lodel.context import LodelContext
+    if LodelContext.multisite():
+        msg = "CTX(%s) %s" % (LodelContext.get_name(), msg)
     caller = logger.findCaller() # Opti warning : small overhead
     extra = {
         '_pathname': os.path.abspath(caller[0]),

lodel/plugin/__init__.py

@@ -93,9 +93,11 @@
 # - @ref lodel.plugin.sessionhandler.SessionHandlerPlugin "SessionHandlerPlugin"
 #
 
-from .hooks import LodelHook
-from .plugins import Plugin, CustomMethod
-from .datasource_plugin import DatasourcePlugin
-from .sessionhandler import SessionHandlerPlugin
-from .interface import InterfacePlugin
-from .extensions import Extension
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin.hooks': ['LodelHook'],
+    'lodel.plugin.plugins': ['Plugin', 'CustomMethod'],
+    'lodel.plugin.datasource_plugin': ['DatasourcePlugin'],
+    'lodel.plugin.sessionhandler': ['SessionHandlerPlugin'],
+    'lodel.plugin.interface': ['InterfacePlugin'],
+    'lodel.plugin.extensions': ['Extension']})

lodel/plugin/core_hooks.py

@@ -1,8 +1,10 @@
 #-*- coding: utf-8 -*-
 
-from lodel.plugin import LodelHook
-from lodel.settings import Settings
-from lodel import logger
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin': ['LodelHook'],
+    'lodel.settings': ['Settings'],
+    'lodel.logger': 'logger'})
 
 ##@package lodel.plugin.core_hooks
 #@brief Lodel2 internal hooks declaration
@@ -38,7 +40,8 @@ def datasources_bootstrap_hook(hook_name, caller, payload):
 ##@brief Bootstrap hook that print debug infos about registered hooks
 @LodelHook('lodel2_bootstraped')
 def list_hook_debug_hook(name, caller, payload):
-    from lodel import logger
+    LodelContext.expose_modules(globals(), {
+        'lodel.logger': 'logger'})
     hlist = LodelHook.hook_list()
     for name, reg_hooks in hlist.items():
         for hook, priority in reg_hooks:
@@ -55,5 +58,6 @@ def list_hook_debug_hook(name, caller, payload):
 ##@brief Hooks that trigger custom methods injection in dynmic classes
 @LodelHook("lodel2_dyncode_loaded")
 def lodel2_plugins_custom_methods(self, caller, dynclasses):
-    from lodel.plugin.plugins import CustomMethod
+    LodelContext.expose_modules(globals(), {
+        'lodel.plugin.plugins': ['CustomMethod']})
     CustomMethod.set_registered(dynclasses)

lodel/plugin/core_scripts.py

@@ -1,4 +1,6 @@
-import lodel.plugin.scripts as lodel_script
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin.scripts': 'lodel_script'})
 
 ##@package lodel.plugin.core_scripts
 #@brief Lodel2 internal scripts declaration

lodel/plugin/datasource_plugin.py

@@ -1,8 +1,11 @@
-from .plugins import Plugin
-from .exceptions import *
-from lodel.exceptions import *
-from lodel.settings.validator import SettingValidator
-
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin.plugins': ['Plugin'],
+    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
+        'LodelScriptError', 'DatasourcePluginError'],
+    'lodel.settings.validator': ['SettingValidator'],
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
 _glob_typename = 'datasource'
 
@@ -93,7 +96,7 @@ class DatasourcePlugin(Plugin):
     _plist_confspecs = {
         'section': 'lodel2',
         'key': 'datasource_connectors',
-        'default': None,
+        'default': 'dummy_datasource',
         'validator': SettingValidator(
             'custom_list', none_is_valid = False,
             validator_name = 'plugin', validator_kwargs = {
@@ -162,7 +165,8 @@ migration handler !!!")
     #false
     @staticmethod
     def plugin_name(ds_name, ro):
-        from lodel.settings import Settings
+        LodelContext.expose_modules(globals(), {
+            'lodel.settings': ['Settings']})
         # fetching connection identifier given datasource name
         try:
             ds_identifier = getattr(Settings.datasources, ds_name)
@@ -198,7 +202,8 @@ DS_PLUGIN_NAME.DS_INSTANCE_NAME. But got %s" % ds_identifier)
     #@throw NameError if a datasource plugin or instance cannot be found
     @staticmethod
     def _get_ds_connection_conf(ds_identifier,ds_plugin_name):
-        from lodel.settings import Settings
+        LodelContext.expose_modules(globals(), {
+            'lodel.settings': ['Settings']})
         if ds_plugin_name not in Settings.datasource._fields:
             msg = "Unknown or unconfigured datasource plugin %s"
             msg %= ds_plugin_name

lodel/plugin/exceptions.py

@@ -1,7 +1,7 @@
 class PluginError(Exception):
     pass
 
-class PluginTypeErrror(PluginError):
+class PluginTypeError(PluginError):
     pass
 
 class LodelScriptError(Exception):

lodel/plugin/extensions.py

@@ -1,8 +1,13 @@
-from .plugins import Plugin
-from .exceptions import *
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin.plugins': ['Plugin'],
+    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
+        'LodelScriptError', 'DatasourcePluginError'],
+    'lodel.settings.validator': ['SettingValidator']})
 
 _glob_typename = 'extension'
+
+
 class Extension(Plugin):
     
     _plist_confspecs = {

lodel/plugin/hooks.py

@@ -2,7 +2,7 @@
 
 import os
 import copy
-from importlib.machinery import SourceFileLoader
+from lodel.context import LodelContext
 
 
 ##@brief Class designed to handle a hook's callback with a priority
@@ -64,11 +64,11 @@ class LodelHook(object):
     # @return modified payload
     @classmethod
     def call_hook(cls, hook_name, caller, payload):
-        from lodel import logger
-        logger.info("Calling hook '%s'" % hook_name)
+        LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+        logger.debug("Calling hook '%s'" % hook_name)
         if hook_name in cls._hooks:
             for hook in cls._hooks[hook_name]:
-                logger.info("Lodel hook '%s' calls %s" % (
+                logger.debug("Lodel hook '%s' calls %s" % (
                     hook_name, hook))
                 payload = hook(hook_name, caller, payload)
         return payload

lodel/plugin/interface.py

@@ -1,9 +1,13 @@
-from .plugins import Plugin
-from .exceptions import *
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin.plugins': ['Plugin'],
+    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
+        'LodelScriptError', 'DatasourcePluginError'],
+    'lodel.settings.validator': ['SettingValidator']})
 
 _glob_typename = 'ui'
 
+
 ##@brief Handles interfaces plugin
 #@note It's a singleton class. Only 1 interface allowed by instance.
 class InterfacePlugin(Plugin):

lodel/plugin/plugins.py

@@ -5,12 +5,17 @@ import os.path
 import importlib
 import copy
 import json
-from importlib.machinery import SourceFileLoader, SourcelessFileLoader
-
-from lodel import logger
-from lodel.settings.utils import SettingsError
-from .exceptions import *
-from lodel.exceptions import *
+from importlib.machinery import SourceFileLoader
+
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.logger': 'logger',
+    'lodel.settings.utils': ['SettingsError'],
+    'lodel.plugin.hooks': ['LodelHook'],
+    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
+        'LodelScriptError', 'DatasourcePluginError'],
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
 ## @package lodel.plugins Lodel2 plugins management
 #@ingroup lodel2_plugins
@@ -50,7 +55,7 @@ ACTIVATE_METHOD_NAME = '_activate'
 ##@brief Discover stage cache filename
 DISCOVER_CACHE_FILENAME = '.plugin_discover_cache.json'
 ##@brief Default & failover value for plugins path list
-DEFAULT_PLUGINS_PATH_LIST = ['./plugins']
+DEFAULT_PLUGINS_PATH_LIST = [os.path.join(LodelContext.context_dir(),'plugins')]
 
 ##@brief List storing the mandatory variables expected in a plugin __init__.py
 #file
@@ -292,13 +297,7 @@ class Plugin(object, metaclass=MetaPlugType):
         # Importing __init__.py infos in it
         plugin_module = '%s.%s' % (VIRTUAL_PACKAGE_NAME,
                                     plugin_name)
-
-        init_source = os.path.join(self.path, INIT_FILENAME)
-        try:
-            loader = SourceFileLoader(plugin_module, init_source)
-            self.module = loader.load_module()
-        except (ImportError,FileNotFoundError) as e:
-             raise PluginError("Failed to load plugin '%s'. It seems that the plugin name is not valid or the plugin do not exists" % plugin_name)
+        self.module = LodelContext.module(plugin_module)
 
         # loading confspecs
         try:
@@ -374,6 +373,11 @@ name differ from the one found in plugin's init file"
     #@throw AttributeError if varname not found
     #@throw ImportError if the file fails to be imported
     #@throw PluginError if the filename was not valid
+    #@todo Some strange things append :
+    #when loading modules in test self.module.__name__ does not contains
+    #the package... but in prod cases the self.module.__name__ is 
+    #the module fullname... Just a reminder note to explain the dirty
+    #if on self_modname
     def _import_from_init_var(self, varname):
         # Read varname
         try:
@@ -392,11 +396,15 @@ name differ from the one found in plugin's init file"
                 fname = filename,
                 name = self.name)
             raise PluginError(msg)
-        # importing the file in varname
-        module_name = self.module.__name__+"."+varname
-        filename = os.path.join(self.path, filename)
-        loader = SourceFileLoader(module_name, filename)
-        return loader.load_module()
+        #See the todo
+        if len(self.module.__name__.split('.')) == 1:
+            self_modname = self.module.__package__
+        else:
+            self_modname = self.module.__name__
+        #extract module name from filename
+        base_mod = '.'.join(filename.split('.')[:-1])
+        module_name = self_modname+"."+base_mod
+        return importlib.import_module(module_name)
    
     ##@brief Check dependencies of plugin
     #@return A list of plugin name to be loaded before
@@ -426,7 +434,6 @@ name differ from the one found in plugin's init file"
     #
     # @note Maybe we have to exit everything if a plugin cannot be loaded...
     def activable(self):
-        from lodel import logger
         try:
             test_fun = getattr(self.module, ACTIVATE_METHOD_NAME)
         except AttributeError:
@@ -448,7 +455,6 @@ name differ from the one found in plugin's init file"
     def _load(self):
         if self.loaded:
             return
-        from lodel import logger
         #Test that plugin "wants" to be activated
         activable = self.activable()
         if not(activable is True):
@@ -520,7 +526,6 @@ name differ from the one found in plugin's init file"
                 msg += "\n\t%20s : %s" % (name,e)
             msg += "\n"
             raise PluginError(msg)
-        from lodel.plugin.hooks import LodelHook
         LodelHook.call_hook(
             "lodel2_plugins_loaded", cls, cls._plugin_instances)
    
@@ -548,7 +553,8 @@ name differ from the one found in plugin's init file"
     # etc...
     @classmethod
     def plugin_list_confspec(cls):
-        from lodel.settings.validator import confspec_append
+        LodelContext.expose_modules(globals(), {
+            'lodel.settings.validator': ['confspec_append']})
         res = dict()
         for pcls in cls.plugin_types():
             plcs = pcls.plist_confspec()
@@ -705,7 +711,6 @@ file : '%s'. Running discover again..." % DISCOVER_CACHE_FILENAME)
                 #dropped
                 pass
         result = {'path_list': paths, 'plugins': result}
-        print("DEUG ",result['plugins'])
         #Writing to cache
         if not no_cache:
             with open(DISCOVER_CACHE_FILENAME, 'w+') as pdcache:
@@ -810,6 +815,8 @@ file : '%s'. Running discover again..." % DISCOVER_CACHE_FILENAME)
     ##@brief Import init file from a plugin path
     #@param path str : Directory path
     #@return a tuple (init_module, module_name)
+    #@todo replace by LodelContext usage !!! (not mandatory, this fun
+    #is only used in plugin discover method)
     @classmethod
     def import_init(cls, path):
         cls._mod_cnt += 1 # in order to ensure module name unicity
@@ -828,11 +835,21 @@ file : '%s'. Running discover again..." % DISCOVER_CACHE_FILENAME)
             raise PluginError("Unable to import initfile")
         return (res_module, temp_module)
 
+    @classmethod
+    def debug_wrapper(cls, updglob = None):
+        if updglob is not None:
+            for k, v in updglob.items():
+                globals()[k] = v
+        print(logger)
+
     ##@brief Reccursiv plugin discover given a path
     #@param path str : the path to walk through
     #@return A dict with plugin_name as key and {'path':..., 'version':...} as value
     @classmethod
     def _discover(cls, path):
+        #Ensure plugins symlink creation
+        LodelContext.expose_modules(globals(), {
+            'lodel.plugins': 'plugins'})
         res = []
         to_explore = [path]
         while len(to_explore) > 0:
@@ -849,6 +866,8 @@ file : '%s'. Running discover again..." % DISCOVER_CACHE_FILENAME)
                         to_explore.append(f_path)
         return res
 
+def debug_wrapper_mod():
+    print("MOD : ",logger)
 
 ##@brief Decorator class designed to allow plugins to add custom methods
 #to LeObject childs (dyncode objects)
@@ -961,3 +980,6 @@ with %s" % (custom_method._method_name, custom_method))
                         custom_method.__get_method())
                     logger.debug(
                         "Custom method %s added to target" % custom_method)
+
+def wrapper_debug_fun():
+    print(logger)

lodel/plugin/scripts.py

@@ -1,8 +1,11 @@
 import argparse
 import sys
 
-from lodel import logger
-from lodel.exceptions import *
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.logger': 'logger',
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
 ##@defgroup lodel2_script Administration scripts
 #@ingroup lodel2_plugins
@@ -16,6 +19,7 @@ from lodel.exceptions import *
 #@todo store it in MetaLodelScript
 __registered_scripts = dict()
 
+
 ##@brief LodelScript metaclass that allows to "catch" child class
 #declaration
 #@ingroup lodel2_script

lodel/plugin/sessionhandler.py

@@ -1,6 +1,10 @@
-from .plugins import Plugin, MetaPlugType
-from .exceptions import *
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin.plugins': ['Plugin', 'MetaPlugType'],
+    'lodel.plugin.exceptions': ['PluginError', 'PluginTypeError',
+        'LodelScriptError', 'DatasourcePluginError'],
+    'lodel.settings.validator': ['SettingValidator']})
+
 
 ##@brief SessionHandlerPlugin metaclass designed to implements a wrapper
 #between SessionHandlerPlugin classmethod and plugin loader functions

plugins/dummy/__init__.py → lodel/plugins/dummy/__init__.py

@@ -1,4 +1,6 @@
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 
 __plugin_name__ = "dummy"
 __version__ = '0.0.1' #or __version__ = [0,0,1]
@@ -6,7 +8,7 @@ __loader__ = "main.py"
 __confspec__ = "confspec.py"
 __author__ = "Lodel2 dev team"
 __fullname__ = "Dummy plugin"
-__name__ = 'yweber.dummy'
+__name__ = 'dummy'
 __plugin_type__ = 'extension'
 
 

plugins/dummy/confspec.py → lodel/plugins/dummy/confspec.py

@@ -1,6 +1,8 @@
 #-*- coding: utf-8 -*-
 
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 
 CONFSPEC = {
     'lodel2.section1': {

plugins/dummy/main.py → lodel/plugins/dummy/main.py

@@ -1,6 +1,9 @@
 #-*- coding: utf-8 -*-
 
-from lodel.plugin import LodelHook, CustomMethod
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin': ['LodelHook', 'CustomMethod'],
+    'lodel.settings' : 'settings'})
 
 @LodelHook('leapi_get_post')
 @LodelHook('leapi_update_pre')
@@ -10,7 +13,7 @@ from lodel.plugin import LodelHook, CustomMethod
 @LodelHook('leapi_insert_pre')
 @LodelHook('leapi_insert_post')
 def dummy_callback(hook_name, caller, payload):
-    if Lodel.settings.Settings.debug:
+    if settings.Settings.debug:
         print("\tHook %s\tcaller %s with %s" % (hook_name, caller, payload))
     return payload
 
@@ -26,9 +29,3 @@ def dummy_instance_method(self):
     print("Hello world !\
 I'm a custom method on class %s" % self.__class__)
 
-
-@LodelHook('lodel2_loader_main')
-def foofun(hname, caller, payload):
-    from lodel import dyncode
-    print("Hello world ! I read dyncode from lodel.dyncode : ",
-        dyncode.dynclasses)

plugins/dummy_datasource/__init__.py → lodel/plugins/dummy_datasource/__init__.py

@@ -1,4 +1,6 @@
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 from .datasource import DummyDatasource as Datasource
 
 __plugin_type__ = 'datasource'

plugins/dummy_datasource/datasource.py → lodel/plugins/dummy_datasource/datasource.py

@@ -1,6 +1,8 @@
 #-*- coding:utf-8 -*-
 
-from lodel.plugin.datasource_plugin import AbstractDatasource
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin.datasource_plugin': ['AbstractDatasource']})
 
 class DummyDatasource(AbstractDatasource):
     

plugins/dummy_datasource/main.py → lodel/plugins/dummy_datasource/main.py

@@ -1,6 +1,8 @@
 #-*- coding:utf-8 -*-
 
-from lodel.plugin import LodelHook
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin': ['LodelHook']})
 from .datasource import DummyDatasource as Datasource
 
 def migration_handler_class():

plugins/filesystem_session/__init__.py → lodel/plugins/filesystem_session/__init__.py

@@ -1,4 +1,6 @@
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 
 __plugin_name__ = 'filesystem_session'
 __version__ = [0,0,1]

plugins/filesystem_session/confspec.py → lodel/plugins/filesystem_session/confspec.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 
 CONFSPEC = {
     'lodel2.sessions':{

plugins/filesystem_session/main.py → lodel/plugins/filesystem_session/main.py

@@ -6,9 +6,11 @@ import pickle
 import re
 import time
 
-from lodel import logger
-from lodel.auth.exceptions import ClientAuthenticationFailure
-from lodel.settings import Settings
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.logger': 'logger',
+    'lodel.auth.exceptions': ['ClientAuthenticationFailure'],
+    'lodel.settings': ['Settings']})
 
 from .filesystem_session import FileSystemSession
 

plugins/mongodb_datasource/__init__.py → lodel/plugins/mongodb_datasource/__init__.py

@@ -17,7 +17,7 @@ __fullname__ = "MongoDB plugin"
 #
 # @return bool|str : True if all the checks are OK, an error message if not
 def _activate():
-    from lodel import buildconf
+    from lodel import buildconf #NOTE : this one do not have to pass through the context
     return buildconf.PYMONGO
 
 #

plugins/mongodb_datasource/confspec.py → lodel/plugins/mongodb_datasource/confspec.py

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
 
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 
 ##@brief Mongodb datasource plugin confspec
 #@ingroup plugin_mongodb_datasource

plugins/mongodb_datasource/datasource.py → lodel/plugins/mongodb_datasource/datasource.py

@@ -9,11 +9,13 @@ from collections import OrderedDict
 import pymongo
 from pymongo.errors import BulkWriteError
 
-from lodel import logger
-from lodel.leapi.leobject import CLASS_ID_FIELDNAME
-from lodel.leapi.datahandlers.base_classes import Reference, MultipleRef
-from lodel.exceptions import LodelException, LodelFatalError
-from lodel.plugin.datasource_plugin import AbstractDatasource
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.logger': 'logger',
+    'lodel.leapi.leobject': ['CLASS_ID_FIELDNAME'],
+    'lodel.leapi.datahandlers.base_classes': ['Reference', 'MultipleRef'],
+    'lodel.exceptions': ['LodelException', 'LodelFatalError'],
+    'lodel.plugin.datasource_plugin': ['AbstractDatasource']})
 
 from . import utils
 from .exceptions import *
@@ -113,9 +115,9 @@ class MongoDbDatasource(AbstractDatasource):
             #Here we may implement the group
             #If sorted query we have to sort again
             if order is not None:
-                results = sorted(results,
-                    key=functools.cmp_to_key(
-                        self.__generate_lambda_cmp_order(order)))
+                key_fun = functools.cmp_to_key(
+                    self.__generate_lambda_cmp_order(order))
+                results = sorted(results, key=key_fun)
             #If limit given apply limit again
             if offset > len(results):
                 results = list()
@@ -301,7 +303,7 @@ abstract, preparing reccursiv calls" % (target, filters, relational_filters))
             old_datas_l = self.__collection(target).find(
                 mongo_filters)
             old_datas_l = list(old_datas_l)
-            
+        
         uidname = target.uid_fieldname()[0] #MULTIPLE UID BROKEN HERE
         for old_datas in old_datas_l:
             self.__update_backref(
@@ -364,7 +366,7 @@ abstract, preparing reccursiv calls" % (target, filters, relational_filters))
                 continue
             bref_cls = fdh.back_reference[0]
             bref_fname = fdh.back_reference[1]
-            if issubclass(fdh.__class__, MultipleRef):
+            if not fdh.is_singlereference():
                 #fdh is a multiple ref. So the update preparation will be
                 #divided into two loops :
                 #- one loop for deleting old datas
@@ -477,7 +479,7 @@ abstract, preparing reccursiv calls" % (target, filters, relational_filters))
         newdd = 'new' in values
         if bref_val is None:
             bref_val = bref_dh.empty()
-        if issubclass(bref_dh.__class__, MultipleRef):
+        if not bref_dh.is_singlereference():
             if oldd and newdd:
                 if tuid not in bref_val:
                     raise MongoDbConsistencyError("The value we want to \
@@ -544,7 +546,7 @@ value : in %s field %s" % (bref_leo,fname))
             raise MongoDbConsistencyError("Unable to get the object we make \
 reference to : %s with uid = %s" % (bref_cls, repr(uidv)))
         bref_dh = bref_leo.data_handler(bref_fname)
-        if not isinstance(bref_dh, Reference):
+        if not bref_dh.is_reference():
             raise LodelFatalError("Found a back reference field that \
 is not a reference : '%s' field '%s'" % (bref_leo, bref_fname))
         bref_val = bref_leo.data(bref_fname)
@@ -564,13 +566,17 @@ is not a reference : '%s' field '%s'" % (bref_leo, bref_fname))
     def __act_on_abstract(self,
         target, filters, relational_filters, act, **kwargs):
 
+        logger.debug("Abstract %s, running reccursiv select \
+on non abstract childs" % act.__name__)
         result = list() if act == self.select else 0
         if not target.is_abstract():
-            target_childs = target
+            target_childs = [target]
         else:
             target_childs = [tc for tc in target.child_classes()
                 if not tc.is_abstract()]
         for target_child in target_childs:
+            logger.debug(
+                "Abstract %s on %s" % (act.__name__, target_child.__name__))
             #Add target_child to filter
             new_filters = copy.copy(filters)
             for i in range(len(filters)):
@@ -807,7 +813,7 @@ by an equality filter")
         #Converting lodel2 wildcarded string into a case insensitive
         #mongodb re
         if mongop in cls.mongo_op_re:
-            if value.startswith('(') and value.endswith(')') and ',' in value:
+            if value.startswith('(') and value.endswith(')'):
                 if (dhdl.cast_type is not None):
                     mongoval = [ dhdl.cast_type(item) for item in mongoval[1:-1].split(',') ]
                 else:
@@ -849,7 +855,7 @@ field/operator couple in a query. We will keep only the first one")
         glco = cls.__generate_lambda_cmp_order
         fname, cmpdir = order[0]
         order = order[1:]
-        return lambda a,b: glco(order) if a[fname] == b[fname] else (\
+        return lambda a,b: glco(order)(a,b) if a[fname] == b[fname] else (\
             1 if (a[fname]>b[fname] if cmpdir == 'ASC' else a[fname]<b[fname])\
             else -1)
 

plugins/mongodb_datasource/exceptions.py → lodel/plugins/mongodb_datasource/exceptions.py

@@ -1,6 +1,9 @@
-from lodel.exceptions import *
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.exceptions': ['LodelException', 'LodelExceptions',
+        'LodelFatalError', 'DataNoneValid', 'FieldValidationError']})
 
-##@ingroup plugin_mongodb_datasource
+#@ingroup plugin_mongodb_datasource
 class MongoDbDataSourceError(Exception):
     pass
 

plugins/mongodb_datasource/main.py → lodel/plugins/mongodb_datasource/main.py

@@ -1,4 +1,6 @@
-from lodel.plugin import LodelHook
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin': ['LodelHook']})
 
 from .datasource import MongoDbDatasource as Datasource
 

plugins/mongodb_datasource/migration_handler.py → lodel/plugins/mongodb_datasource/migration_handler.py

@@ -1,15 +1,19 @@
 # -*- coding: utf-8 -*-
 import datetime
 
-from lodel.editorial_model.components import EmClass, EmField
-from lodel.editorial_model.model import EditorialModel
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.editorial_model.components': ['EmClass', 'EmField'],
+    'lodel.editorial_model.model': ['EditorialModel'],
+    'lodel.leapi.datahandlers.base_classes': ['DataHandler'],
+    'lodel.plugin': ['LodelHook'],
+    'lodel.logger': 'logger'})
+
+from leapi_dyncode import * #<-- TODO : handle this !!!
+
 from .utils import connect, object_collection_name, mongo_fieldname
-from lodel.leapi.datahandlers.base_classes import DataHandler
-from lodel.plugin import LodelHook
-from leapi_dyncode import *
 from .datasource import MongoDbDatasource
 from .exceptions import *
-from lodel import logger
 
 class MigrationHandler(object):
 

plugins/mongodb_datasource/utils.py → lodel/plugins/mongodb_datasource/utils.py

@@ -3,8 +3,10 @@
 import pymongo
 from pymongo import MongoClient
 
-from lodel.settings.settings import Settings as settings
-from lodel import logger
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.settings': [('Settings', 'settings')],
+    'lodel.logger': 'logger'})
 
 common_collections = {
     'object': 'objects',

lodel/plugins/multisite/__init__.py

@@ -0,0 +1,23 @@
+from lodel.context import LodelContext, ContextError
+try:
+    LodelContext.expose_modules(globals(), {
+        'lodel.settings.validator': ['SettingValidator']})
+
+    __plugin_name__ = "multisite"
+    __version__ = '0.0.1' #or __version__ = [0,0,1]
+    __loader__ = "main.py"
+    __author__ = "Lodel2 dev team"
+    __fullname__ = "Multisite plugin"
+    __name__ = 'yweber.dummy'
+    __plugin_type__ = 'extension'
+
+    CONFSPEC = {
+        'lodel2.server': {
+            'port': (80,SettingValidator('int')),
+            'listen_addr': ('', SettingValidator('string')),
+        }
+    }
+
+except ContextError:
+    pass
+

lodel/plugins/multisite/confspecs.py

@@ -0,0 +1,34 @@
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
+
+#Define a minimal confspec used by multisite loader
+LODEL2_CONFSPECS = {
+    'lodel2': {
+        'debug': (True, SettingValidator('bool'))
+    },
+    'lodel2.server': {
+        'listen_address': ('127.0.0.1', SettingValidator('dummy')),
+        #'listen_address': ('', SettingValidator('ip')), #<-- not implemented
+        'listen_port': ( 1337, SettingValidator('int')),
+        'uwsgi_workers': (8, SettingValidator('int')),
+        'uwsgicmd': ('/usr/bin/uwsgi', SettingValidator('dummy')),
+        'virtualenv': (None, SettingValidator('path', none_is_valid = True)),
+    },
+    'lodel2.logging.*' : {
+        'level': (  'ERROR',
+                    SettingValidator('loglevel')),
+        'context': (    False,
+                        SettingValidator('bool')),
+        'filename': (   None,
+                        SettingValidator('errfile', none_is_valid = True)),
+        'backupcount': (    10,
+                            SettingValidator('int', none_is_valid = False)),
+        'maxbytes': (   1024*10,
+                        SettingValidator('int', none_is_valid = False)),
+    },
+    'lodel2.datasources.*': {
+        'read_only': (False, SettingValidator('bool')),
+        'identifier': ( None, SettingValidator('string')),
+    }
+}

lodel/plugins/multisite/example_lodel2.ini

@@ -0,0 +1,21 @@
+[lodel2.logging.templog]
+level = INFO
+filename = /tmp/log
+context = True
+
+[lodel2.server]
+listen_address = 
+listen_port = 1337
+max_children = 100
+
+[lodel2.logging.stderr]
+level = WARNING
+filename = -
+context = True
+
+
+[lodel2.datasources.default]
+identifier = dummy_datasource.default
+
+[lodel2.datasource.dummy_datasource.default]
+dummy = dummy

lodel/plugins/multisite/loader.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+import shlex
+import warnings
+
+#Here we have to bootstrap a minimal __loader__ context in order
+#to be able to load the settings
+#
+#This file (once bootstraped) start a new process for uWSGI. uWSGI then
+#run lodel.plugins.multisite.run.application function
+try:
+    from lodel.context import LodelContext
+except ImportError:
+    LODEL_BASE_DIR = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from lodel.context import LodelContext
+
+from lodel import buildconf
+
+LodelContext.init(LodelContext.MULTISITE)
+LodelContext.set(None) #Loading context creation
+#Multisite instance settings loading
+CONFDIR = os.path.join(os.getcwd(), 'conf.d')
+if not os.path.isdir(CONFDIR):
+    warnings.warn('%s do not exists, default settings used' % CONFDIR)
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.settings': [('Settings', 'settings')],
+    'lodel.plugins.multisite.confspecs': 'multisite_confspecs'})
+if not settings.started():
+    settings('./conf.d', multisite_confspecs.LODEL2_CONFSPECS)
+
+LodelContext.expose_modules(globals(), {
+    'lodel.settings': ['Settings']})
+
+##@brief Starts uwsgi in background using settings
+def uwsgi_fork():
+    
+    sockfile = os.path.join(buildconf.LODEL2VARDIR, 'uwsgi_sockets/')
+    if not os.path.isdir(sockfile):
+        os.mkdir(sockfile)
+    sockfile = os.path.join(sockfile, 'uwsgi_lodel2_multisite.sock')
+    logfile = os.path.join(
+        buildconf.LODEL2LOGDIR, 'uwsgi_lodel2_multisite.log')
+        
+    cmd='{uwsgi} --plugin python3 --http-socket {addr}:{port} --module \
+lodel.plugins.multisite.run --socket {sockfile} --logto {logfile} -p {uwsgiworkers}'
+    cmd = cmd.format(
+                addr = Settings.server.listen_address,
+                port = Settings.server.listen_port,
+                uwsgi= Settings.server.uwsgicmd,
+                sockfile=sockfile,
+                logfile = logfile,
+                uwsgiworkers = Settings.server.uwsgi_workers)
+    if Settings.server.virtualenv is not None:
+        cmd += " --virtualenv %s" % Settings.webui.virtualenv
+
+    try:
+        args = shlex.split(cmd)
+        print("Running %s" % cmd)
+        exit(os.execl(args[0], *args))
+    except Exception as e:
+        print("Webui plugin uwsgi execl fails cmd was '%s' error : " % cmd,
+            e, file=sys.stderr)
+        exit(1)
+
+if __name__ == '__main__':
+    uwsgi_fork()
+        

lodel/plugins/multisite/run.py

@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+import os
+import os.path
+import warnings
+
+#This file expose common function to process a wsgi request and the
+#uWSGI application callback
+
+
+#preloading all instances
+FAST_APP_EXPOSAL_CACHE = dict()
+
+LODEL2_INSTANCES_DIR = '.'
+EXCLUDE_DIR = {'conf.d', '__pycache__'}
+
+try:
+    from lodel.context import LodelContext
+except ImportError:
+    LODEL_BASE_DIR = os.path.dirname(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    from lodel.context import LodelContext, ContextError
+
+LodelContext.init(LodelContext.MULTISITE)
+LodelContext.set(None) #Loading context creation
+
+#Multisite instance settings loading
+CONFDIR = os.path.join(os.getcwd(), 'conf.d')
+if not os.path.isdir(CONFDIR):
+    warnings.warn('%s do not exists, default settings used' % CONFDIR)
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.settings': [('Settings', 'settings')],
+    'lodel.plugins.multisite.confspecs': 'multisite_confspecs'})
+if not settings.started():
+    settings('./conf.d', multisite_confspecs.LODEL2_CONFSPECS)
+
+#Fetching insrtance list from subdirectories
+lodelsites_list = [ os.path.realpath(os.path.join(LODEL2_INSTANCES_DIR,sitename)) 
+    for sitename in os.listdir(LODEL2_INSTANCES_DIR)
+    if os.path.isdir(sitename) and sitename not in EXCLUDE_DIR]
+
+#Bootstraping instances
+for lodelsite_path in lodelsites_list:
+    ctx_name = LodelContext.from_path(lodelsite_path)
+    #Switch to new context
+    LodelContext.set(ctx_name)
+    os.chdir(lodelsite_path)
+    # Loading settings
+    LodelContext.expose_modules(globals(), {
+        'lodel.settings.settings': [('Settings', 'settings')]})
+    if not settings.started():
+        settings('./conf.d')
+    LodelContext.expose_modules(globals(), {'lodel.settings': ['Settings']})
+
+    # Loading hooks & plugins
+    LodelContext.expose_modules(globals(), {
+        'lodel.plugin': ['LodelHook'],
+        'lodel.plugin.core_hooks': 'core_hooks',
+        'lodel.plugin.core_scripts': 'core_scripts'
+    })
+
+    #Load plugins
+    LodelContext.expose_modules(globals(), {
+        'lodel.logger': 'logger',
+        'lodel.plugin': ['Plugin']})
+    logger.debug("Loader.start() called")
+    Plugin.load_all()
+    #Import & expose dyncode
+    LodelContext.expose_dyncode(globals())
+    #Next hook triggers dyncode datasource instanciations
+    LodelHook.call_hook('lodel2_plugins_loaded', '__main__', None)
+    #Next hook triggers call of interface's main loop
+    LodelHook.call_hook('lodel2_bootstraped', '__main__', None)
+    #FAST_APP_EXPOSAL_CACHE populate
+    FAST_APP_EXPOSAL_CACHE[ctx_name] = LodelContext.module(
+    	'lodel.plugins.webui.run')
+    LodelContext
+    #a dirty & quick attempt to fix context unwanted exite via
+    #hooks
+    for name in ( 'LodelHook', 'core_hooks', 'core_scripts',
+            'Settings', 'settings', 'logger', 'Plugin'):
+        del(globals()[name])
+    #switch back to loader context
+    LodelContext.set(None)
+
+#
+# From here lodel2 multisite instances are loaded and ready to run
+#
+
+
+##@brief Utility function to return quickly an error
+def http_error(env, start_response, status = '500 internal server error', \
+        extra = None):
+    headers = [('Content-type', 'text/plain; charset=utf-8')]
+    start_response(status, headers)
+    msg = status
+    if extra is not None:
+        msg = extra
+    return [msg.encode('utf-8')]
+
+
+##@brief utility function to extract site id from an url
+#@param url str : 
+def site_id_from_url(url):
+    res = ''
+    for c in url[1:]:
+        if c == '/':
+            break
+        res += c
+    if len(res) == 0:
+        return None
+    return res
+
+##@brief This method is run in a child process by the handler
+def application(env, start_response):
+    #Attempt to load a context
+    site_id = site_id_from_url(env['PATH_INFO'])
+    if site_id is None:
+        #It can be nice to provide a list of instances here
+        return http_error(env, start_response, '404 Not Found')
+    try:
+        LodelContext.set(site_id)
+        #We are in the good context
+
+    except ContextError as e:
+        print(e)
+        return http_error(env, start_response, '404 Not found',
+            "No site named '%s'" % site_id)
+    #Calling webui
+    return FAST_APP_EXPOSAL_CACHE[site_id].application(env, start_response)
+    #LodelContext.expose_modules(globals(), {
+    #    'lodel.plugins.webui.run': ['application']})
+    #return application(env, start_response)
+

plugins/ram_sessions/__init__.py → lodel/plugins/ram_sessions/__init__.py

@@ -1,6 +1,8 @@
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 
-__plugin_name__ = 'ram_session'
+__plugin_name__ = 'ram_sessions'
 __version__ = [0,0,1]
 __plugin_type__ = 'session_handler'
 __loader__ = 'main.py'

plugins/ram_sessions/main.py → lodel/plugins/ram_sessions/main.py

@@ -3,9 +3,12 @@ import os
 import copy
 import binascii
 
-from lodel import logger
-from lodel.settings import Settings
-from lodel.auth.exceptions import *
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.logger': 'logger',
+    'lodel.settings': ['Settings'],
+    'lodel.auth.exceptions': ['ClientError', 'ClientAuthenticationFailure',
+        'ClientPermissionDenied', 'ClientAuthenticationError']})
 
 __sessions = dict()
 

plugins/webui/client.py → lodel/plugins/webui/client.py

@@ -1,4 +1,5 @@
-from lodel.auth.client import Client
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {'lodel.auth.client': ['Client']})
 
 class WebUiClient(Client):
     

plugins/webui/confspec.py → lodel/plugins/webui/confspec.py

@@ -1,4 +1,6 @@
-from lodel.settings.validator import SettingValidator
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings.validator': ['SettingValidator']})
 
 CONFSPEC = {
     'lodel2.webui': {

plugins/webui/exceptions.py → lodel/plugins/webui/exceptions.py

@@ -1,6 +1,7 @@
 #-*- coding: utf-8 -*-
 
 from werkzeug.wrappers import Response
+from lodel.context import LodelContext
 
 class HttpException(Exception):
 
@@ -23,8 +24,23 @@ class HttpException(Exception):
         self.status_code = status_code
         self.tpl = tpl
         self.custom = custom
+    
+    ##@brief Log exception with lodel logger
+    def log(self):
+        LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+        msg = "Webui HTTP exception : %s" % self
+        if self.status_code / 100 == 4:
+            logger.security(msg)
+        elif self.status_code / 100 == 5:
+            logger.error(msg)
+        else:
+            logger.warning(msg)
+    
+    def __str__(self):
+        return "HTTP:%d '%s'" % (self.status_code, self.custom)
 
     def render(self, request):
+        self.log()
         from .interface.template.loader import TemplateLoader
         loader = TemplateLoader()
         tpl_vars = {
@@ -47,5 +63,31 @@ class HttpException(Exception):
             return HttpException.STATUS_STR[status_fam][status_code]
 
 
+##@brief Render multiple errors
+class HttpErrors(HttpException):
+    
+    def __init__(self, errors, title = None, status_code = 400):
+        super().__init__(status_code = status_code, tpl = 'errors.html',
+            custom = title)
+        self.errors = errors
+
+    def __str__(self):
+        ret = super().__str__()
+        ret += ', '.join([ '%s: %s' % val for val in self.errors.items()])
+        return ret
+
+    def render(self, request):
+        self.log()
+        from .interface.template.loader import TemplateLoader
+        loader = TemplateLoader()
+        tpl_vars = {
+            'status_code': self.status_code,
+            'errors': self.errors,
+            'title': self.custom }
+        response = Response(
+            loader.render_to_response(self.tpl, template_vars = tpl_vars),
+            mimetype = 'text/html')
+        response.status_code = self.status_code
+        return response
 
         

plugins/webui/interface/controllers/admin.py → lodel/plugins/webui/interface/controllers/admin.py

@@ -2,13 +2,17 @@
 from ...exceptions import *
 from .base import get_response
 
-from lodel.leapi.exceptions import *
-from lodel import logger
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.leapi.exceptions': [],
+    'lodel.logger': 'logger',
+    'lodel.leapi.datahandlers.base_classes': ['MultipleRef'],
+    'lodel.leapi.exceptions': ['LeApiDataCheckErrors'],
+    'lodel.exceptions': ['LodelExceptions']})
+LodelContext.expose_dyncode(globals(), 'dyncode')
 
 from ...client import WebUiClient
-import leapi_dyncode as dyncode
 import warnings
-from lodel.leapi.datahandlers.base_classes import MultipleRef
 
 LIST_SEPARATOR = ','
 
@@ -35,54 +39,24 @@ def admin_update(request):
     #    return get_response('users/signin.html')
     msg=''
     
-    # If the form has been submitted
-    if request.method == 'POST':
-        error = None
-        datas = list()
-        classname = request.form['classname']
-        logger.warning('Composed uids broken here')
-        uid = request.form['uid']
+    datas = process_form(request)
+    if not(datas is False):
+        if 'lodel_id' not in datas:
+            raise HttpException(400)
+        target_leo = dyncode.Object.name2class(datas['classname'])
+        leo = target_leo.get_from_uid(datas['lodel_id'])
+        if leo is None:
+            raise HttpException(404,
+                custom = 'No %s with id %s' % (
+                    target_leo.__name__, datas['lodel_id']))
         try:
-            target_leo = dyncode.Object.name2class(classname)
-        except LeApiError:
-            classname = None
-        if classname is None or target_leo.is_abstract():
-            raise HttpException(400, custom = "Bad classname given")
-
-        leo_to_update = target_leo.get_from_uid(uid)
-        
-        errors = dict()
-        for fieldname, value in request.form.items():
-            #We want to drop 2 input named 'classname' and 'uid'
-            if len(fieldname) > 12:
-                #Other input names are : field_input_FIELDNAME
-                #Extract the fieldname
-                fieldname = fieldname[12:]
-                try:
-                    dh = leo_to_update.data_handler(fieldname)
-                except NameError as e:
-                    errors[fieldname] = e
-                    continue
-                #Multiple ref list preparation
-                if issubclass(dh.__class__, MultipleRef):
-                    value=[spl for spl in [
-                           v.strip() for v in value.split(LIST_SEPARATOR)]
-                        if len(spl) > 0]
-                elif len(value.strip()) == 0:
-                    value = None
-                try:
-                    leo_to_update.set_data(fieldname, value)
-                except Exception as e:
-                    errors[fieldname] = e
-                    continue
-        if len(errors) > 0:
-            custom_msg = '<h1>Errors in datas</h1><ul>'
-            for fname, error in errors.items():
-                custom_msg += '<li>%s : %s</li>' % (
-                    fname, error)
-            custom_msg += '</ul>'
-            raise HttpException(400, custom = custom_msg)
-        leo_to_update.update()
+            leo.update(
+                { f:datas[f] for f in datas if f not in ('classname', 'lodel_id')})
+        except LeApiDataCheckErrors as e:
+            raise HttpErrors(
+                title='Form validation errors', errors = e._exceptions)
+            
+            
 
     # Display of the form with the object's values to be updated
     if 'classname' in request.GET:
@@ -132,45 +106,25 @@ def admin_create(request):
     # temporary, the acl will be more restrictive
     #if WebUiClient.is_anonymous():
     #    return get_response('users/signin.html')
-    classname = None
-     # If the form has been submitted
-    if request.method == 'POST':
-        error = None
-        datas = list()
-        classname = request.form['classname']
-        try:
-            target_leo = dyncode.Object.name2class(classname)
-        except LeApiError:
-            classname = None
-        if classname is None or target_leo.is_abstract():
-            raise HttpException(400)
-        fieldnames = target_leo.fieldnames()
-        fields = dict()
 
-        for in_put, in_value in request.form.items():
-            # The classname is handled by the datasource, we are not allowed to modify it
-            # both are hidden in the form, to identify the object here
-            if in_put != 'classname' and in_value != '':
-                dhl = target_leo.data_handler(in_put[12:])
-                if dhl.is_reference() and in_value != '' and not dhl.is_singlereference():
-                    logger.info(in_value)
-                    in_value.replace(" ","")
-                    in_value=in_value.split(',')
-                    in_value=list(in_value)
-                fields[in_put[12:]] = in_value
-            if in_value == '':
-                fields[in_put[12:]] = None             
-
-        # Insertion in the database of the values corresponding to a new object
-        new_uid = target_leo.insert(fields)
-        
-        # reurn to the form with a confirmation or error message
-        if not new_uid is None:
-            msg = 'Successfull creation';
+    datas = process_form(request)
+    if not(datas is False):
+        target_leo = dyncode.Object.name2class(datas['classname'])
+        if 'lodel_id' in datas:
+            raise HttpException(400)
+        try:
+            new_uid = target_leo.insert(
+                { f:datas[f] for f in datas if f != 'classname'})
+        except LeApiDataCheckErrors as e:
+            raise HttpErrors(
+                title='Form validation errors', errors = e._exceptions)
+        if new_uid is None:
+            raise HttpException(400, "Creation fails")
         else:
-            msg = 'Oops something wrong happened...object not saved'
-        return get_response('admin/admin_create.html', target=target_leo, msg = msg)
-    
+            return get_response(
+                'admin/admin_create.html', target=target_leo,
+                msg = "Created with uid %s" % new_uid)
+
     # Display of an empty form
     if 'classname' in request.GET:
         # We need the class to create an object in
@@ -318,4 +272,63 @@ def search_object(request):
         # TODO The get method must be implemented here
     return get_response('admin/admin_search.html', my_classes = dyncode.dynclasses)
 
+##@brief Process a form POST and return the posted datas
+#@param request : the request object
+#@return a dict with datas as value and fieldname as key
+def process_form(request):
+    if request.method != 'POST':
+        return False
+    res = dict()
+    errors = dict()
+    #Fetch concerned LeObject
+    if 'classname' not in request.form:
+        logger.error("Received a form without classname !")
+        raise HttpException(400)
+    res['classname'] = classname = request.form['classname']
+    try:
+        target_leo = dyncode.Object.name2class(classname)
+    except LeApiError:
+        logger.error(
+            "Received a form with an invalid leo name : '%s'" % classname)
+        raise HttpException(400, "No leobject named '%s'" % classname)
+    if target_leo.is_abstract():
+        logger.error(
+            "Received a form with an abstract leo : '%s'" % classname)
+        raise HttpException(400, '%s is abstract' % classname)
+    #Process input fields
+    for fieldname, value in request.form.items():
+        if fieldname == 'classname':
+            continue
+        elif fieldname == 'uid':
+            fieldname = 'lodel_id' #wow
+        elif fieldname.startswith('field_input_'):
+            fieldname = fieldname[12:]
+        try:
+            dh = target_leo.data_handler(fieldname)
+        except NameError as e:
+            errors[fieldname] = e
+            continue
+        if dh.is_reference() and not dh.is_singlereference():
+            #Converting multiple references fields
+            value = value.strip()
+            if len(value) == 0:
+                #handling default value for empty string
+                if hasattr(dh, 'default'):
+                    value = dh.default
+                else:
+                    #if not explicit default value, enforcing default as 
+                    #an empty list
+                    value = []
+            else:
+                value = [ v.strip() for v in value.split(LIST_SEPARATOR) ]
+                value = [ v for v in value if len(v) > 0]
+        else:
+            #Handling default value for empty string
+            if len(value.strip()) == 0 and hasattr(dh, 'default'):
+                value = dh.default
+        res[fieldname] = value
+    if len(errors) > 0:
+        del(res)
+        raise HttpErrors(errors, title="Form validation error")
+    return res
 

plugins/webui/interface/controllers/listing.py → lodel/plugins/webui/interface/controllers/listing.py

@@ -1,8 +1,10 @@
 # -*- coding: utf-8 -*-
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+LodelContext.expose_dyncode(globals(), 'dyncode')
+
 from .base import get_response
 from ...exceptions import *
-from lodel import logger
-import leapi_dyncode as dyncode
 
 ##@brief These functions are called by the rules defined in ../urls.py
 ## To browse the editorial model

plugins/webui/interface/controllers/users.py → lodel/plugins/webui/interface/controllers/users.py

@@ -3,8 +3,9 @@ from .base import get_response
 from ...exceptions import *
 from ...client import WebUiClient as WebUiClient
 
-from lodel import logger
-import leapi_dyncode as dyncode
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {'lodel.logger': 'logger'})
+LodelContext.expose_dyncode(globals(), 'dyncode')
 
 ##@brief These functions are called by the rules defined in ../urls.py
 ## Their goal is to handle the user authentication
@@ -33,4 +34,4 @@ def signin(request):
 # @note the response is given in the login html page 
 def signout(request):
     WebUiClient.destroy()
-    return get_response('users/signin.html')
+    return get_response('users/signin.html')

plugins/webui/interface/router.py → lodel/plugins/webui/interface/router.py

@@ -4,7 +4,10 @@ import re
 from .controllers import *
 from .urls import urls
 from ..main import root_url
-from lodel.settings import Settings
+
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.settings': ['Settings']})
 
 def format_url_rule(url_rule):
     if url_rule.startswith('^'):

plugins/webui/interface/template/loader.py → lodel/plugins/webui/interface/template/loader.py

@@ -2,9 +2,11 @@
 import jinja2
 import os
 
-from lodel.settings import Settings
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {'lodel.settings': ['Settings']})
+LodelContext.expose_dyncode(globals())
+
 from ...client import WebUiClient as WebUiClient
-import leapi_dyncode
 
 from .api import api_lodel_templates
 from .exceptions.not_allowed_custom_api_key_error import NotAllowedCustomAPIKeyError

plugins/webui/main.py → lodel/plugins/webui/main.py

@@ -3,9 +3,13 @@
 import os, os.path
 import sys
 import shlex
-from lodel.plugin import LodelHook
-from lodel.settings import Settings
-from lodel import buildconf
+
+from lodel.context import LodelContext
+LodelContext.expose_modules(globals(), {
+    'lodel.plugin': ['LodelHook'],
+    'lodel.settings': ['Settings']})
+
+from lodel import buildconf #<-- This one is common to the build
 
 PLUGIN_PATH = os.path.dirname(__file__)
 

plugins/webui/run.py → lodel/plugins/webui/run.py

@@ -1,18 +1,26 @@
 # -*- coding: utf-8 -*-
-import loader # Lodel2 loader
+from lodel.context import LodelContext
+
+if not LodelContext.is_initialized():
+    import loader # Lodel2 loader
 
 import os
 import hashlib
 import time
+import sys
 
 from werkzeug.wrappers import Response
 
-from lodel.settings import Settings
+LodelContext.expose_modules(globals(), {
+    'lodel.settings': ['Settings'],
+    'lodel.logger': 'logger',
+    'lodel.auth.exceptions': ['ClientError', 'ClientAuthenticationFailure',
+        'ClientPermissionDenied', 'ClientAuthenticationError']})
+
 from .interface.router import get_controller
 from .interface.lodelrequest import LodelRequest
 from .exceptions import *
 from .client import WebUiClient
-from lodel.auth.exceptions import *
 
 try:
     SESSION_FILES_BASE_DIR = Settings.webui.sessions.directory
@@ -55,11 +63,11 @@ def empty_cookie(response):
     response.set_cookie(COOKIE_SESSION_ID, '')
 
 #Starting instance
-loader.start()
+try:
+    loader.start() #Works only in MONOSITE mode
+except NameError:
+    pass
 #providing access to dyncode
-import lodel
-import leapi_dyncode as dyncode
-lodel.dyncode = dyncode
 
 
 # WSGI Application