Das deutsche Python-Forum

Code: Alles auswählen

import SocketServer
from threading import *
import Queue

PORT = 9999

class Service(SocketServer.StreamRequestHandler):
        #queue wird nach erzeugen der Klasse als Varianble 'WarteschlangeRaus' angef�gt
        
    def ParseLabel(self, daten):
        """Das Label Heraussuchen, mit dem Hinweis ack versehen
        und als String zur Empfangsbestätigung zurückgeben"""
        Labelende = daten.find("]") +1 
        Label = daten[:Labelende]
        ack = Label +"ack\r\n"
        return(ack)

    def AufgabeAnClientSenden(self):
        """von P900App ausgehende Aufgaben abarbeiten"""
        print"nun sollte die ausgehende Warteschlange abgearbeitet werden"
        if self.ServerWarteschlangeAusgehend.empty() == False:
            return self.ServerWarteschlangeAusgehend.get()
        else:
            return "[ClientBored]NONE\r\n"
        
    def handle(self):
        """Eigener TCP- Handler für Serverklasse"""
        #auf übertragene Daten warten
        data = self.rfile.readline()
        
        #Nachrichtentyp herausfinden und client Accnowledge senden
        LabelAcc = self.ParseLabel(data)
        if LabelAcc <> "[ClientBored]ack\r\n":
            self.wfile.write(LabelAcc)
            #daten per queue an die P900App schicken
            self.ServerWarteschlangeEingehend.put(data)
            #client mit in die Queue schreiben und an die P900App übergeben
            client = "[TCPClient]" + self.client_address[0]
            self.ServerWarteschlangeEingehend.put(client)
            
            #wenn Clientanfrage nach Aufgaben kam -> nachsehen ob Aufgaben vorhanden sind
        else:
            ClientAufgabe = self.AufgabeAnClientSenden()
            self.wfile.write(ClientAufgabe)
            #client in die Queue schreiben und an die P900App übergeben
            client = "[TCPClient]" + self.client_address[0]
            self.ServerWarteschlangeEingehend.put(client)
            
class Server(Thread):
    """Serverklasse """
    def __init__(self, notify_window, ServerWarteschlangeEingehend, ServerWarteschlangeAusgehend):
        """Init Worker Thread Class."""
        Thread.__init__(self)
        
        #Warteschlangen für den Server
        self.ServerWarteschlangeEingehend = ServerWarteschlangeEingehend
        self.ServerWarteschlangeAusgehend = ServerWarteschlangeAusgehend
        
        #beim initieren gibt es noch keinen dispacher und service
        self.dispatcher = None
        self.HTTPService = None
        
        #bei schliessen des Main-Threads auch Server beenden
        self.setDaemon(True)

        self.start()

    def run(self):
        """TCPServer auf PORT starten"""
        self.HTTPService = Service
        #Queue für externe Daten die an die App gehen an den Service weitergeben
        self.HTTPService.ServerWarteschlangeEingehend = self.ServerWarteschlangeEingehend
        #Queue für interne Daten die an den Client gehen an den Service weitergeben
        self.HTTPService.ServerWarteschlangeAusgehend = self.ServerWarteschlangeAusgehend
        
        self.dispatcher = SocketServer.TCPServer(('', PORT), self.HTTPService)
        #server starten
        self.dispatcher.serve_forever()
    

Code: Alles auswählen

----------------------------------------Exception happened during processing of request from ('192.168.68.1', 4153)
----------------------------------------
Traceback (most recent call last):
 File "E:\Programme\Python2_5\lib\SocketServer.py", line 222, in handle_request
self.process_request(request, client_address)
 File "E:\Programme\Python2_5\lib\SocketServer.py", line 241, in process_request
self.finish_request(request, client_address)
 File "E:\Programme\Python2_5\lib\SocketServer.py", line 254, in finish_request
self.RequestHandlerClass(request, client_address, self)
 File "E:\Programme\Python2_5\lib\SocketServer.py", line 522, in __init__
self.handle()
 File "E:\Eigene Dateien\Projekte\Client-ServerP900\Working\Python\TCPServer.py", line 57, in handle
data = self.rfile.readline()
AttributeError: Service instance has no attribute 'rfile'

Code: Alles auswählen

class StreamRequestHandler(BaseRequestHandler):

    """Define self.rfile and self.wfile for stream sockets."""

    # Default buffer sizes for rfile, wfile.
    # We default rfile to buffered because otherwise it could be
    # really slow for large data (a getc() call per byte); we make
    # wfile unbuffered because (a) often after a write() we want to
    # read and we need to flush the line; (b) big writes to unbuffered
    # files are typically optimized by stdio even when big reads
    # aren't.
    rbufsize = -1
    wbufsize = 0

    def setup(self):
        self.connection = self.request
        self.rfile = self.connection.makefile('rb', self.rbufsize)
        self.wfile = self.connection.makefile('wb', self.wbufsize)

    def finish(self):
        if not self.wfile.closed:
            self.wfile.flush()
        self.wfile.close()
        self.rfile.close()

Code: Alles auswählen

            #auf übertragene Daten warten - timeout abfangen
            try:
                data = self.rfile.readline()
            except: 
                #bei Fehler stream schliessen
                data = ""

Code: Alles auswählen

class Service(SocketServer.StreamRequestHandler):

def setup(self):
           
        self.connection = self.request
        self.connection.settimeout(30)
        self.rfile = self.connection.makefile('rb', -1)
        self.wfile = self.connection.makefile('wb', 0)

Code: Alles auswählen

class Service(SocketServer.StreamRequestHandler):
    def setup(self):
        self.request.settimeout(30)
        SocketServer.StreamRequestHandler.setup(self)

Code: Alles auswählen

    def handle(self):
        """
        Eigener TCP- Handler für Serverklasse
        """
        
        while  self.StreamOffen:
            
            #auf übertragene Daten warten - timeout abfangen
            try:
                data = self.rfile.readline()
            
            #bei bei Timeout stream schliessen
            except socket.timeout:   
                data = ""
            
            #wenn Leerzeilen eingelesen werden wurde Verbindung unterbrochen
            if data == "":
                self.StreamOffen = False
                print "Debug- TCP-Handle leere Daten gelesen"
                self.QueueIn.put("[MSG]Verbindung mit Client unterbrochen  \n")
                
                
            else:
                #print "debug TCP-Handler: Got  bytes from s" , self.client_address
                print "debug TCP-Handler: Nachricht: ", data
   
        
        print "stream wird geschlossen..."