# Problem beim Übertragen einer Datei



## Rontu (26. Mrz 2008)

Hallo zusammen,
ich habe ein kleines Problem mit einer Client/Server Kombination. Mein Server soll auf einen Client warten und wenn sich dieser anmeldet eine Datei verschicken. Auf der Clientseite wird diese empfangene Datei dann wieder auf die Festplatte geschrieben. Währenddessen soll der Client die Zeit messen, die für den Vorgang benötigt wird und diese nach erfolgreichem Empfang der Daten an den Server zurücksenden. Ist zwar noch nicht geschrieben, ist aber nicht das Problem, im Moment deshalb nur ein Platzhalter. 
Jedoch bleibt meine Schleife, die die Daten empfängt nach Erhalt hängen und das Programm läuft nicht weiter. Merkwürdigerweise liegt jedoch die Datei schon komplett auf der Festplatte und ist mit dem Original auch identisch.

Hier mal ein Ausschnitt aus dem Client ...


```
public void run() {

            try {
                // Öffnen des Sockets, der zu schreibenden Datei,
                // den Streams und den benötigten Variablen
                Socket socket = new Socket(this.serverName, this.port);
                File file = new File("C:/Temp/" + this.fileName);
                FileOutputStream outStream = new FileOutputStream(file);
                InputStream inStream = socket.getInputStream();
                PrintWriter cltOut = new PrintWriter(socket.getOutputStream(), true);
                byte[] buffer = new byte[16384];
                int length = 0;
                int msg_time = 0;
                
                System.out.println("Verbindung zum Server hergestellt.");
                
                // Schreiben der empfangenen Daten in die Datei
                while ((length = inStream.read(buffer)) > 0) {
                    outStream.write(buffer, 0, length);
                }
                System.out.println("Datei empfangen.");
                
                // Übertragung der benötigten Zeit
                msg_time = 1093; // derzeit noch ein Testwert
                cltOut.print(msg_time);
                System.out.println("Uebertragungszeit: " + msg_time + " ms");

                // Schließen der Streams und des Sockets
                outStream.close();
                inStream.close();
                cltOut.close();
                socket.close();

            } catch (Exception e) {
                e.printStackTrace();
            }
```

... und der entsprechende Abschnitt aus dem Server


```
// Initialisierung der Streams und Variablen
                                FileInputStream fis = new FileInputStream(tmFile);
                                OutputStream os = socket.getOutputStream();
                                BufferedReader is = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                                byte[] buffer = new byte[16384];
                                int bytesRead = 0;
                                int msg_time = 0;
                                
                                // Senden der Testdatei
                                while ((bytesRead = fis.read(buffer)) > 0) {
                                    os.write(buffer, 0, bytesRead);
                                }
                                System.out.println("Datei uebertragen.");
                                
                                // Empfangen der Übertragungsdauert
                                msg_time = Integer.valueOf(is.readLine());
    				System.out.println("Uebertragungszeit: " + msg_time + " ms");
                                
                                // Schließen der Streams
                                is.close();
                                fis.close();
                                os.close();
```

Wenn ich nur die Datei verschicke und keine Antwort sende, läuft der Client. Das gleiche Spiel auch bei dem Versenden der benötigten Zeit, wenn nur dieser Wert übertragen werden soll. Vielleicht hat jemand von euch eine Idee, wo mein Problem zu suchen ist. Bei Bedarf gibt es auch noch mehr Quelltext.


----------



## tuxedo (26. Mrz 2008)

Klar hab ich ne Idee:

Wenn du am Server auf die Zeit wartest die der Client für's senden gebraucht hat, und dieser die Zeit nicht sendet wartet sich der Server zu Tode. Und weil er sich zu tode wartet schließt er die Verbinmdung nicht. Und weil er die Verbindung nicht schließt kommt der Client zu keinem Ende weil der Client auf's schließen der Verbindung durch den Server wartet.

Ein Teufelskreis ...

- Alex


----------



## Rontu (26. Mrz 2008)

Also wenn ich dich richtig verstanden habe muss ich auf der Server-Seite den OutputStream schließen, nachdem ich die Datei übertragen habe. Wenn ich das mache läuft das Programm weiter, jedoch schließt der scheinbar dadurch auch direkt meinen Socket. Gibt es denn eine Möglichkeit den Stream zu beenden, jedoch den Socket geöffnet zu lassen?


----------



## Pappenheimer++ (26. Mrz 2008)

Mach das doch einfach so: Am Anfang überträgt der Server erstmal die Größe der Datei in Byte. Dann weiß der Client auch, wann Schluss ist (ohne im bio hängen zu bleiben). Dann kannst du noch irgendwelche Abschlussinformationen übertragen lassen und alles klappt ganz goat ~


----------



## tuxedo (26. Mrz 2008)

Ihr stellt euch an. Lass doch den Client einfach das senden worauf der Server wartet...
Macht ja keinen Sinn nur halbe Sachen zu implementieren und sich dann zu wundern dass nur die hälfte geht.

- Alex


----------



## Rontu (27. Mrz 2008)

alex0801 hat gesagt.:
			
		

> Ihr stellt euch an. Lass doch den Client einfach das senden worauf der Server wartet...



Dann erklär mir doch bitte, wie ich aus der Schleife springe, nachdem die Datei übertragen wurde, oder woran genau das liegt. Scheinbar kennst du darauf ja ne Antwort. 
Es kann doch nicht sein, dass die komplette Datei geschrieben wird und er anschließend trotzdem nicht aus der Schleife springt, obwohl gar keine Daten mehr aus dem Stream ausgelesen werden können.


----------



## HoaX (27. Mrz 2008)

zeile 10: lies doch mal nach wann read welchen rückgabewert hat ...


----------



## Rontu (27. Mrz 2008)

Read liest das nächste Byte aus, oder liefert -1 wenn keine Daten mehr gelesen werden können. Das ist mir auch klar. Aber der Server läuft doch durch, er liest alle Daten der übertragenen Datei aus und verschickt sie über den Stream an den Client. Dort tritt ja das Problem auf.


----------



## tuxedo (27. Mrz 2008)

@Rontu:

read() bricht im Client erst ab, wenn der Stream abbricht, sprich beendet wurde. Und nicht wenn der Server aufhört bytes zu senden. Und der Stream wird nunmal vom Server abgebrochen. Aber erst, wenn der Client ihm mitgeteilt hat, wie lange er für das Empfangen gebraucht hat. 

Verstehst du die Problematik? Die warten gegenseitig auf sich -> Deadlock. 

Mach's doch, wie weiter oben schon erwähnt wurde so:

Bevor der Server die Datei an den Client schickt, schickt er ihm mittels DataOutputStream einen Long-Wert, der dem Client signalisiert: Jetzt kommt eine Datei die XYZ Byte groß ist. 
Erst dann schickt der Server die Bytes der Datei durch den Stream. Der Client weiß, bevor die Datei kommt genau, wieviele Bytes er empfangen muss. D.h. du kannst einen Zähler in deiner Schleife mitlaufen lassen und die Schleife abbrechen wenn der Zähler "voll" ist. 
Vor der Schleife merkst du dir System.currentTimeMillis(), danach nochmal und errechnest die Differenz. Die errechnete Differenz überträgst du dann wieder mit dem DataOutputStream als Long (oder als int, würde aber long nehmen, sicher ist sicher) zum Server. Der Server, der mittlerweile die Datei komplett gesendet hat, wartet ja schon auf den Zeitwert. Diesen bekommt er nun vom Client und kann die Stream und den Socket schließen.

Fertig. Ist doch kein Hexenwerk. Man muss halt nur die API Doc lesen können und kapieren wann read() abbricht.

- Alex


----------



## Rontu (27. Mrz 2008)

Ah, jetzt hab ich das Problem auch verstanden und hab kappiert wie das abgearbeitet werden muss. Hab es auch schon wie beschrieben umgesetzt und es funktioniert alles einwandfrei. Vielen Dank.


----------

