Discussion :

[quentinb56]

Bonjour,

Je ne souhaite pas installer de librairies et je les ai donc téléchargé et placé dans un répertoire lib de mon projet.



Cependant je suis obligé de renseigner le path à chaque reprises et dans chacune de mes classes.
Auriez-vous une solution pour gérer cela ?

J'ai remarqué dans certains projets que les gens géraient les imports dans les __init__ de chaque packages.
Est ce une bonne pratique et cela me permettrait t'il de faire une seule fois le path et ensuite d'appeler via from . import ou from .. import ?

Ma seconde question ...

Mon programme possède deux classes qui héritent de Thread.

Ma première classe est un serveur web sous Flask.
La seconde classe est un serveur Socket.

L'idée est la suivante. Lorsque l'utilisateur réalise une action, celle-ci est transmise à tous les clients qui écoutent le serveur socket.

Pour cela mon serveur web doit pouvoir accéder aux fonctions du serveur Socket.

Cependant je ne peux pas importer mon serveur socket dans mon serveur web si non je suis en présence d'une boucle (les deux serveurs étant tous deux appelés dans un seul serveur).

Ci-joint mon code (qui n'est qu'une ébauche), j'ai trouvé une solution qui ne me plait pas... J'ai passé mon objet serveur socket à ma classe serveur Flask (partie commentée dans mon code)

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
#!/usr/bin/env python -B
# -*- coding: utf-8 -*-
 
from utils.debugger import printer
from controller.server.zWeb import ZwebServer
from controller.server.zSocket import ZsocketServer
 
class ZServeurMain():
    def __init__(self, pArgs):
        printer('__init__()', __file__)
        self.args = pArgs
        #self.runSocketServer()
        self.runWebServer()
 
        print 'Démarrage des deux serveurs'
        self.zWeb.join()
        print 'Extinction du server web'
        #self.zSocket.set_isRunning(False)
        #self.zSocket.join()
        print 'stop all thread'
        exit(0)
 
    def runWebServer(self):
        printer('runWebServer()', __file__)
        #self.zWeb = ZwebServer(self.zSocket,'', self.args.get_web_port())
        self.zWeb = ZwebServer(None,'', self.args.get_web_port())
        self.zWeb.start()
 
    def runSocketServer(self):
        printer('runSocketServer()', __file__)
        self.zSocket = ZsocketServer('',5000)
        self.zSocket.start()

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
#/usr/bin/env python
# -*- coding:utf-8 -*-
 
import os
import sys
import socket, select
 
from threading import Thread
from utils.debugger import printer
from utils.utilsFonction import init_var
from utils.globals import RECV_BUFFER, DEFAULT_SOC_PORT, DEFAULT_SOC_HOST
 
HOST = DEFAULT_SOC_HOST
PORT = DEFAULT_SOC_PORT
 
class ZsocketServer(Thread):
 
    def __init__(self, pHost, pPort):
        printer('__init__()', __file__)
 
        global HOST, PORT
        HOST = init_var(HOST,pHost)
        PORT = init_var(PORT,pPort)
 
        Thread.__init__(self)
 
        self.isRunning = True
        self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.server_socket.bind((HOST, PORT))
        self.server_socket.listen(10)
        self.connection_list = []
        self.connection_list.append(self.server_socket)
 
    def run(self):
        while self.isRunning:
            print 'on boucle'
            read_sockets,write_sockets,error_sockets = select.select(self.connection_list,[],[])
            print 'on boucle 1'
            for sock in read_sockets:
                if sock == self.server_socket:
                    sockfd, addr = self.server_socket.accept()
                    self.connection_list.append(sockfd)
                    print "Client (%s, %s) connected" % addr
 
                    self.broadcast_data(sockfd, "essai")
                else:
                    try:
                        data = sock.recv(RECV_BUFFER)
                        if data:
                            self.broadcast_data(sock, "\r" + '<' + str(sock.getpeername()) + '> ' + data)
                    except:
                        self.broadcast_data(sock, "Client (%s, %s) is offline" % addr)
                        print "Client (%s, %s) is offline" % addr
                        sock.close()
                        self.connection_list.remove(sock)
                        continue
        print 'fermeture socket'
        self.server_socket.close()
 
    def broadcast_data (self, sock, message):
        for socket in self.connection_list:
            if socket != self.server_socket and socket != sock :
                try :
                    socket.send(message)
                except :
                    socket.close()
                    self.connection_list.remove(socket)
 
    def transmitte_order(self, message):
        for socket in self.connection_list:
            if socket != self.server_socket:
                try :
                    socket.send(message)
                except:
                    socket.close()
                    self.connection_list.remove(socket)
 
    def get_isRunning(self):
        return self.isRunning
 
    def set_isRunning(self, pValue):
        self.isRunning = pValue
        print 'passage à {}'.format(pValue)

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#/usr/bin/env python
# -*- coding:utf-8 -*-
 
import os
import sys
 
sys.path.append(os.path.abspath('{}/../../../../lib/'.format(os.path.realpath(__file__))))
 
from flask import Flask, request, render_template, make_response
from threading import Thread
from utils.debugger import printer
from utils.utilsFonction import init_var
from utils.globals import DEFAULT_WEB_HOST, DEFAULT_WEB_PORT
 
print os.path.abspath('{}/../../../view/templates'.format(os.path.realpath(__file__)))
app = Flask(__name__, template_folder=os.path.abspath('{}/../../../view/templates'.format(os.path.realpath(__file__))))
 
HOST = DEFAULT_WEB_HOST
PORT = DEFAULT_WEB_PORT
SOCKET = None
 
class ZwebServer(Thread):
 
	def __init__(self, pSocket, pHost, pPort):
		printer('__init__()', __file__)
 
		global HOST, PORT, SOCKET
		HOST = init_var(HOST,pHost)
		PORT = init_var(PORT,pPort)
		SOCKET = init_var(SOCKET,pSocket)
		Thread.__init__(self)
 
	def run(self):
		app.run(host=HOST, port=PORT)
 
        @app.route('/shutdown', methods=['GET', 'POST'])
	def shutdown():
		shutdown_server()
		return 'Server shutting down...'
 
        @app.route('/', methods=['GET', 'POST'])
	def pg_accueil():
	    return 'Accueil !'
 
        @app.route('/acc')
	def pg_acc():
		return render_template('accueil.html')
 
        @app.route('/transmit', methods=['GET', 'POST'])
	def pg_transmitte():
		SOCKET.transmitte_order('test')
		return 'Transmit !'
 
        @app.errorhandler(404)
	def ma_page_404(error):
		return "Ma jolie page error 404"
 
 
def shutdown_server():
	func = request.environ.get('werkzeug.server.shutdown')
	if func is None:
		raise RuntimeError('Not running with the Werkzeug Server')
	func()

Je suis à l'écoute de toutes les critiques possibles sur mon code pour pouvoir l'améliorer !!!

En vous remerciant d'avance.

Cordialement Quentin

[wiztricks]

Cependant je suis obligé de renseigner le path à chaque reprises et dans chacune de mes classes.
Auriez-vous une solution pour gérer cela ?

renseigner la variable d'environnement PYTHONPATH ou utiliser un virtualenv?

J'ai remarqué dans certains projets que les gens géraient les imports dans les __init__ de chaque packages.
Est ce une bonne pratique et cela me permettrait t'il de faire une seule fois le path et ensuite d'appeler via from . import ou from .. import ?

"import" charge un package s'il n'est pas déjà chargé et définit une ou plusieurs variables globales associé aux objets importés.
La portée d'une variable globale étant limité au module, çà ne devrait pas changer grand chose.

Ma seconde question ...

Désolé j'ai rien compris.

- W

[quentinb56]

Code :

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

sys.path.append(os.path.abspath('{}/../../../../lib/'.format(os.path.realpath(__file__))))

Je donne la localisation du répertoire des librairies à utiliser. Je n'utilise pas de virtualenv.

Je souhaite comme je le disais éviter de devoir répéter dans plusieurs classes cette ligne (sans à avoir à installer les librairies)

pour ma seconde question.

Je pense que le code parle de lui même.

Il s'agit de deux classes qui héritent de Thread, l'exécution est donc parallèle. L'une des deux classes à besoins de l'autre pour exécuter certaines de ces méthodes.

Je souhaite donc lancer des fonctions dans mon serveur web (exemple : def pg_transmitte() qui appelle transmitte_order() en évitant de passer en paramètre de la classe la seconde classe.

[wiztricks]

Code :

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

sys.path.append(os.path.abspath('{}/../../../../lib/'.format(os.path.realpath(__file__))))

Je donne la localisation du répertoire des librairies à utiliser. Je n'utilise pas de virtualenv.

C'est bien dommage. Il vous reste donc à envisager d'utiliser PYTHONPATH.

Je pense que le code parle de lui même.

Le problème n'est pas le code mais l'impression que vous donnez de ré-inventer les SocketIO.
Soit vous ne connaissez pas et vous vous lancez à coder un truc sans avoir fait le tour de l'état de l'art, soit vous avez la prétention de réaliser une meilleure implémentation, soit vous pensez que vous n'avez pas besoin de tout çà et qu'écrire un truc sur un coin de table sera bien suffisant.

Je souhaite donc lancer des fonctions dans mon serveur web (exemple : def pg_transmitte() qui appelle transmitte_order() en évitant de passer en paramètre de la classe la seconde classe.

Dans le cas de communication thread à thread, appeler la méthode d'un autre thread c'est comme envoyer un message.
Et si vous ne savez pas à qui/comment l'envoyer, çà ne pourra pas fonctionner. Mais vous pouvez le déposer dans une Queue lue par le thread destinataire.

- W

[quentinb56]

Je ne souhaitais pas donner l'impression de ré-inventer la roue, je n'en ai pas la prétention ni les capacités (mais contrairement à certaines personnes j'en ai conscience).

Il ne s'agit pas de ma première remarque envers tes réponses qui manquent de diplomaties. Tu oublies régulièrement que tu n'as pas toujours eu ses connaissances et que tu as débuté en tant que qu'initié.

Je suis à la recherche de remarques constructives qui me permettront d'appréhender mes erreurs. Ma manière de coder n'est pas la meilleure mais comme indiqué dans le premier post je recherche des conseils et des avis constructifs.

En l'occurence je sais à qui/ et ou l'envoyer mais ne sait pas comment le mettre en oeuvre.

Le message est émis par les méthodes du thread du serveur web.
Le message est émis à des méthodes du thread du serveur de socket.

Comment mettre en place une pile FIFO pour qu'elle soit accessible par les deux threads ?

Merci du temps que tu accordes au sujet, avec plus de diplomaties les débutants ne seraient pas résignés à coder d'une mauvaise manière par peur d'être pris pour cible par un membre qui relèvera l'emploi inapproprié d'un mot... ou de mauvaises méthodes

A bonne entendeur !

[wiztricks]

Je ne souhaitais pas donner l'impression de ré-inventer la roue, je n'en ai pas la prétention ni les capacités (mais contrairement à certaines personnes j'en ai conscience).

Il ne s'agit pas de ma première remarque envers tes réponses qui manquent de diplomaties. Tu oublies régulièrement que tu n'as pas toujours eu ses connaissances et que tu as débuté en tant que qu'initié.

Vous n'êtes pas en train d’essayer de faire l'exercice d'un tuto mais de réaliser un vrai projet où il serait mieux d'avoir un peu plus que les compétences d'un débutant pour le mener à bien.

Comment mettre en place une pile FIFO pour qu'elle soit accessible par les deux threads ?

Je vous ai déjà indiqué le module Queue.

- W