Bonjour

Dans notre boite, notre erp développé maison (a long time ago) est basé sur "base de données" memfile (accès séquentiel) (crée par société française memsoft).
Je suis en partie là pour maintenir/ évoluer le truc... (Ca serait moi on changerait car on est très fragile, produit obsolète,.. mais là n'est pas le sujet)

On se peut pas accéder du tout par un autre langage avec odbc ou autre à notre base de données hormis le langage du memsoft (le membasic)
Une application serveur memfile gère les accès fichier.
Grâce à wireshark et de l'analyse de paquet, je suis parvenu à dialoguer par socket (ouverture fichier, lire, suivant, précdent, mise a jour, écriture..).
Heureusement il n y avait pas de cryptage!

Maintenant que la communication avec le monde extérieure est possible, on souhaite mettre en place un site web qui a accès à notre super base de données.
Le but est de permettre à nos clients de consulter en real time leur stock/ commandes / embarquement/ ...

Dans un premier temps, j'avais retranscrit mon module python en php qui communiquait sur notre programme serveur memfile..
Ça fonctionne moyennement.. un des problème : les sessions restent actives sur notre serveur memfile (et nous sommes limités à 255 sessions moins nos 150 sessions environ en interne )

J'avais idée (peut être mauvaise) de réaliser une 'passerelle' python qui :
- gère les accés (pouvant limiter à 10 sessions par exemple)
- déconnecter les sessions inactives depuis 10 minutes
- controler dans la mesure du possible les données recues du web pour pas faire planter notre serveur memfile
- autoriser les connexions sur telle plage horaire
- ...

D'où mon intervention sur le sujet, j'ai fait une ébauche de script pour faire la passerelle, ça semble fonctionner pour les échanges..

Dans le code ci dessous, je complète un tableau avec mes threads clients connectés..
Dans chacun de ces threads client, j'ai des infos basiques(heure inscription, nbre requête, login,..)
Je veux faire apparaître ces infos dans une vue (QTableView).. c'est là que je bloque dans la réflexion.
En passant par un model (QAbstractTableModel) qui se base sur mon tableau?
Et à coup de SIGNAL pour rafraichir ma table?
Mais où? par les threadClients? par un timer?

Soyez indulgent, ce n'est qu'une ébauche

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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
# -*- coding: utf-8 -*- 
import socket
import sys
import binascii
import os
import threading
from PyQt4 import QtGui
from PyQt4 import QtCore
 
WEB_PORT = 5002
 
 
MEMFILE_PORT = 5001
MEMFILE_HOST = '192.168.0.205'
 
class modelClient(QtCore.QAbstractTableModel):
  def __init__(self, parent=None):
		super(modelClient,self).__init__(parent)
 
 
class ThreadClient(QtCore.QThread):
  def __init__(self, conn):
    super(ThreadClient, self).__init__()
    self.conn_web = conn    # Connexion web
    self.login = self.conn_web.recv(1024)      # Login
    self.nb_req_envoi = 0   # Nbre requete vers web
    self.nb_req_recu  = 1   # Nbre requete du web
    self.heure_connex = QtCore.QTime.currentTime() # Heure d'inscription
    self.connex_Memfile()
 
  def connex_Memfile(self): # Connexion serveur Memfile
    stream_c = '500060000000000000000000000000000000760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000530000'
    try:
      self.conn_mf.connect((MEMFILE_HOST, MEMFILE_PORT))
      self.conn_mf.send(binascii.unhexlify(stream_c))
      rec = self.conn_mf.recv(1024)
      session = rec[16:17]
      self.session = binascii.hexlify(session)
      self.conn_web.send(rec)
      self.nb_req_envoi +=1
    except :
      print 'erreur de connexion'
 
  def run(self):
    while True:
      msgWeb = self.conn_web.recv(5120)
      self.nb_req_recu +=1
      self.conn_mf.send(msgWeb)         # envoi au serveur memfile
      rep = self.conn_mf.recv(5120)     # reception du serveur memfile
      self.conn_web.send(rep)           # envoi reponse au web
      self.nb_req_envoi +=1
 
 
 
class ThreadServeur(QtCore.QThread):
  def __init__(self, parent):
    super(ThreadServeur, self).__init__()
    self.parent  = parent
    try:
      self.parent.webSocket.bind(('localhost',WEB_PORT))
      self.parent.webSocket.listen(5)
    except socket.error:
      print "erreur liaison socket"
 
  def run(self): # socket connexion web
    while True:
      connexion, adresse = self.parent.webSocket.accept()
      th = ThreadClient(connexion)
      self.parent.clients.append(th)
      th.run()
 
 
class WidgServeur(QtGui.QMainWindow):
  def __init__(self, parent=None):
    super(WidgServeur, self).__init__(parent)
    self.setup()
    self.clients = []
 
  def setup(self):
    self.statusBar().showMessage(u'')
    self.setActions()
    self.setMenu()
    self.widg = QtGui.QWidget() #------------------  Widget central
    self.widg.setLayout(QtGui.QHBoxLayout())   
    self.wTools = QtGui.QWidget() #----------------  Barre outils 
    self.wTools.setLayout(QtGui.QVBoxLayout())
    self.wTools.setFixedWidth(100)
    self.butStart = QtGui.QPushButton('Start!')
    self.butStart.clicked.connect(self.startServeur)
    self.butOptions = QtGui.QPushButton('Options')
    self.butQuit = QtGui.QPushButton('Quitter')
 
    self.wTools.layout().addWidget(self.butStart)
    self.wTools.layout().addSpacing(40)
    self.wTools.layout().addWidget(self.butOptions)
    self.wTools.layout().addStretch()
    self.wTools.layout().addWidget(self.butQuit)
    self.table = QtGui.QTableView() #------------  Table 
    #self.table.setMinimumWidth(500)
    #self.table.setMinimumHeight(300)
    #self.table.setColumnCount(3)
    #self.table.setHorizontalHeaderLabels(["Session","Connexion","Derniere activite"])
    #self.table.setRowCount(5)
 
    self.widg.layout().addWidget(self.table)
    self.widg.layout().addWidget(self.wTools)
    self.setCentralWidget(self.widg)
 
  def setActions(self):
    self.quitAct =  QtGui.QAction(QtGui.QIcon(os.path.dirname(__file__)+"\\png\\exit.png"), "&Quitter",
      self, shortcut=QtGui.QKeySequence.Quit,
      statusTip="Quitter", triggered=QtGui.qApp.closeAllWindows)
 
  def setMenu(self):
    self.fileMenu = self.menuBar().addMenu("&Commandes")
    self.fileMenu.addAction(self.quitAct)
 
 
  def startServeur(self):
    self.webSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    self.thServeur = ThreadServeur(self)
    #self.connect(self.thServeur, QtCore.SIGNAL("newConnexion(PyQt_PyObject)"), self.newConnexion)
    self.thServeur.start()
 
  #def newConnexion(self, obj):
  #  r = self.table.rowCount()
  #  login , adresse, port = obj
  # # print "new!"
  #  self.table.insertRow(r)
  #  self.table.setItem(r , 0, QtGui.QTableWidgetItem(login))
  #  self.table.setItem(r , 1, QtGui.QTableWidgetItem(adresse))
  #  self.table.setItem(r , 2, QtGui.QTableWidgetItem(port))
 
 
if __name__=="__main__":
  app = QtGui.QApplication(sys.argv) 
  ui = WidgServeur()
  ui.show()
 
  sys.exit(app.exec_())