🚀 go-pugleaf

"Alexei Akimov" <a_p_akimov@mtu-net.ru> wrote in message
news:3d9c5a6a@newsgroups.borland.com...

> The freeze is occuring on the server exactly at the line where while
> condition is checked:
> while ((currentLine = DataReader.readLine()) != null {
> ***
> }

I which case I find it rather more likely that you haven't got an EOL at the
end of your string. What happens if you change
  requestWriter.write(Text);
to
 requestWriter.printLn(Text);
?

If readLine() gets some data then it will be blocking until it gets an EOL
character or until an end of stream (-1) occurs (say if the peer socket
closed either the stream or the connection), or a socket timeout occurs.

>On the other hand the client starts waiting for server's response
> just after sending the file's content to server. So both the server and
the
> client are waiting for the data from each other and this is the freese. It
> looks like a deadlock.

No, because they're blocking on different entities - so long as /something/
sends some (valid) data before going into a blocking read things should keep
moving.

> > Have you verified that the Response class serializes ok?
> Yes, it implements serializable interface.

Ah, I meant have you actually serialized and subsequently deserialized an
instance (without going over a socket) to verify that it was behaving as
expected? It would have been / still will be, depending on whether it is an
EOL thing or not, a valuble eliminating step in tracking down the cause.

> > What are you doing with respect to threading on the server?
> The processSaveRequest is a member of the ServerThread class which extends
> Thread and it's run method is waiting for client connections:

  <snip>

>         fSocket = fServerSocket.accept();
>         ObjectInputStream requestStream = new ObjectInputStream(
>                 fSocket.getInputStream());
>         processRequest((Request)requestStream.readObject());

This will, of course, limit you to handling one client at a time on that
server socket - if you spawned a thread to perform the handling for each
socket returned by accept() then you could handle many requests
simultaenously.

Also, I would advocate putting the close methods on the socket in a finally
block to ensure that they get called, otherwise you'll be left with unclosed
connections hanging around if an exception is thrown.

hth
Owen