Discussion :

[shell13010]

Bonjour tout le monde,

J'ai pour projet de créer un système de plugins pour une simple application, mais les exemples,tutoriel "reprenez moi si je me trompe" en python sur se type de structure ne cours pas les rues?

Auriez-vous des exemples, Livres ou autre qui traite se sujet? , car j'ai trouver un très bon article Création d'un système de plugins en java mais malheureusement il est en java.

[wiztricks]

Salut,

J'ai pour projet de créer un système de plugins pour une simple application, mais les exemples,tutoriel "reprenez moi si je me trompe" en python sur se type de structure ne cours pas les rues?

Réaliser un système de pluggins avec Python est si simple qu'une recherche avec votre moteur favoris sur les mots clés "python pluggins" devrait vous donner l'embarras du choix.
Pourquoi n'y trouvez vous pas votre bonheur?

- W

[shell13010]

Salut wiztricks,

Merci du retour,

le soucis c'est que j'aurais aimer analysé une structure de base d'un système de plugins avec la gestion des données pour sécurisé l'application principal.

j'ai trouver quelque exemple intéressant, mais je ne comprend pas comment on peux gérer les données d'un plugins et vérifié qu'il ne fasse pas n'importe quoi,

étant donner que c'est la première fois que je souhaite créer un système de se type, il y a des points que je chercher a approfondir.

[wiztricks]

Salut,

mais je ne comprend pas comment on peux gérer les données d'un plugins et vérifié qu'il ne fasse pas n'importe quoi

Je ne comprend pas ce que vous entendez par "gérer les données d'un plugins". Un exemple peut être?
Pour le reste, a partir du moment ou un "plugins" peut être écrit pas un utilisateur lambda, il peut faire n'importe quoi.
Comme "n'importe quoi" est assez ouvert, il faut préciser ce que vous ne voulez pas et évaluer les contre-mesures à mettre en face.

- W

[shell13010]

Salut,

Voilà une image tirer d'un article d'une structure complète d'un système de plugins en java (encore):



Lien de l'article : http://www.javaranch.com/journal/200607/Plugins.html

la plupart des articles et exemple que j'ai lus c'est dernier jours ne traite pas se sujet(securité), voilà en résumer le schéma d'un système de plugins en python d'après mes recherches:



J'aimerais savoir comment je pourrais produire un système similaire en python comme cité plus haut, mais bizarrement j'ai trouver aucun exemple concret ou la plupart des tutoriels sur se sujet ne parle jamais de sécurité avec python

Ou peut-être que je suis complétement dans le flou et que je suis partie dans un délire bizarre?

[tyrtamos]

Bonjour,

Il est vrai qu'on a du mal à trouver des principes généraux sur les plugins en Python. En tout cas, même si on trouve des sites qui en parle, le mot "plugin" n'existe pas dans la doc officielle.

Mais c'est un sujet intéressant! Voilà quelques idées.

Qu'est-ce c'est qu'un plugin? C'est un module réalisé après coup et (éventuellement) par quelqu'un d'autre, qu'on ajoute si nécessaire à un programme pour lui donner des fonctionnalités supplémentaires.

Il faut, bien entendu:
1- que le programme ait été conçu dès l'origine pour recevoir de tels plugins
2- que les plugins ajoutés soient construits en respectant des spécifications précises pour pouvoir être intégrés dans le programme.

Prenons un exemple simplifié: on va faire une calculatrice à laquelle on va pouvoir ajouter sous forme de plugins des fonctions supplémentaires.

On va considérer que tous les plugins se trouvent dans le répertoire "plugins". Ainsi, l'installation d'un nouveau plugin consistera tout simplement à le recopier dans le répertoire "plugins".

Voilà un plugin appelé "arithmetique.py" dans lequel on va placer 2 fonctions: fact(n) = factorielle de n, et rack(n, k=2) = racine kième entière de n. On met ce fichier dans le répertoire "plugins".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3
 
__all__ = ["fact", "rack"] # <== on place ici toutes les fonctions conçues pour être importées
 
#############################################################################
def fact(n):
    """fact(n): calcule la factorielle de n (entier >= 0)"""
    x = 1
    for i in range(2, n + 1):
        x *= i
    return x
 
#############################################################################
def rack(n, k=2):
    """Racine kième entière d'un nb entier n
       (généralisation de la méthode de Heron d'Alexandrie)
       génère une exception si n<0 et k paire
    """
    # traitement des nb négatifs ou nuls
    if n < 1:
        if n == 0:
            return 0
        if k % 2 == 0:
            raise ValueError("Erreur: racine kième (k paire) d'un nombre négatif ")
        signe, n = -1, -n
    else:
        signe = 1
    # calcul d'une valeur approchée de la racine (important pour les grands nombres)
    rac1, p = 1, 1
    while p <= n:
        rac1 <<= 1
        p <<= k
    rac1 >>= 1
    # calcul de la racine en partant de la racine approchée r1
    km1 = k - 1
    while True:
        rac2 = (km1 * rac1 + n // rac1 ** km1) // k
        if rac2 == rac1:
            return signe * rac2
        rac1 = rac2

Voilà maintenant la calculatrice: au lancement, elle va chercher les fichiers python du sous-répertoire plugins, et va les importer:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Python 3
 
import sys, os
import glob
from math import *
 
#############################################################################
def calculatrice():
    """boucle "read-eval-print" de la calculatrice"""
    while True:
        expression = input("=>").strip()
        if expression == "":
            continue
        if expression.upper() == "QUIT":
            break
        try:
            valeur = eval(expression)
        except Exception as msgerr:
            valeur = msgerr
        print(valeur)
 
#############################################################################
if __name__ == '__main__':
 
    # répertoire de la calculatrice
    repprog = os.path.dirname(os.path.abspath(__file__))
    # répertoire des plugins
    repplugins = os.path.join(repprog, "plugins")
    # liste des fichiers python du répertoire plugins
    listeplugins = glob.glob(os.path.join(repplugins, "*.py"))
 
    # importation des plugins
    for plugin in listeplugins:
        nommodule = os.path.splitext(os.path.split(plugin)[1])[0]
        if nommodule == "__init__":
            continue
        print("Importation du module:", nommodule)
        # importation (désolé: il faudra trouver mieux!!!)
        exec("from %s import *" % ("plugins." + nommodule,))
    print()
 
    # lancement de la calculatrice
    calculatrice()
 
    print("Fin")

Et voilà!

Quand on lance la calculatrice, elle trouve et importe les plugins trouvés, et lance la boucle "read-eval-print" de la calculatrice. Voilà un exemple d'utilisation:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
Importation du module: arithmetique
 
=>2+3
5
=>sin(0.5)
0.479425538604203
=>fact(50)
30414093201713378043612608166064768844377641568960512000000000000
=>rack(2*10**100)
141421356237309504880168872420969807856967187537694
=>quit
Fin

Il s'agit, bien entendu, d'un exemple simplifié: il faudrait prendre en compte les erreurs possibles, ainsi que la sécurité: il ne faudrait pas qu'un plugin défectueux (ou pirate) conduise à des fuites d'informations ou à des dégâts.

[wiztricks]

Salut,

La "Java VM" a la possibilité de remplacer l'environnement d'exploitation qui est dessous.
Vous avez la possibilité de partager une JVM par plusieurs applications (via des serveurs d'application Java comme JBoss).
L'environnement Java doit donc offrir les outils qui permettent de gérer cela et offrir aux développeurs les API Java ad hoc.

Python n'a pas cette ambition!
La sécurité d'accès reste celle héritée de l'OS et est accessible via des modules spécifiques qui masquent (ou pas) les différences.
Chaque application Python tourne dans sa propre VM Python et l’étanchéité (la sécurité) entre les différentes applications est héritée de l'environnement d'exploitation.

Il n'y a donc pas d'équivalent à java.lang.SecurityManager et ses fichiers "policy" associés.
Mais ce genre de "features" n'existe pas en C/C++ sans nous empêcher d'écrire des "plugins".

- W