Block 7: Socket 2

1. Block 7: Socket 2 Jin Sa Client-server Programming

2. Outline of Block 7 • Iterative server • Concurrent server • Stateful server • Developing an example Client-server Programming

3. Iterative server • Version 1: Acceptor only accept connection request once. Not very useful server. • Server tends to be “always-on”. • Version 2: Modify Acceptor so that it can accept connection requests from many clients Client-server Programming

4. Acceptor (Server) import java.net.*; import java.io.*; public class Acceptor { public static void main(String[] args) { try { // Create a serverSocket // listen for connection request and create a data socket -- // see slide Acceptor (1) // get an output stream for writing to the data socket – // see slide Acceptor (2) // write a message into the data stream – // see slide Acceptor (3) // close the data socket and // close the serversocket – // see slide Acceptor (4) } // end try catch (Exception ex) { ex.printStackTrace( ); } //end catch } // end main } // end class Client-server Programming

5. AccporMore: example of an iterative server • Use a single serverSocket to connection request • Use a loop to process the connection requests. • Once the server has finished processing each client request, it is ready to accept another client connection request. Client-server Programming

6. AcceptorMore (iterative server) import java.net.*; import java.io.*; public class AcceptorMore { public static void main(String[] args) { try { // Create a serverSocket //loop for each connection request while (true){ // listen for connection request and create a data socket // get an output stream for writing to the data socket // write a message into the data stream // close the data socket and } // close the serversocket – } // end try catch (Exception ex) { ex.printStackTrace( ); } //end catch } // end main } // end class Client-server Programming

7. Issues with iterative server • The AcceptorMore server services one client at a time. • If the duration of each client session is significant, then the turnaround time of a client request becomes unacceptable if the number of concurrent client processes is large. Client-server Programming

8. Concurrent server (1) • To improve the turnaround time, a server process spawns a child process or child thread to process the protocol for each client. Such a server is termed a concurrent server, compared to an iterative server. Client-server Programming

9. Concurrent server (2) • A concurrent server can be implemented using multiple threads. • A concurrent server uses its main thread to accept connections, and spawns a child thread to process the protocol for each client. • Clients queue for connection, then are served concurrently. The concurrency reduces latency significantly. Client-server Programming

10. AcceptorConc: example of a concurrent server • Similar to an iterative server, a concurrent Acceptor server uses a single server socket to listen for connections. • But the concurrent server creates a new thread to conduct a service session with each new client. • This frees the server to handle connection requests from other clients. • Once a service session with a client is finished, the thread is terminated. Client-server Programming

11. AcceptorThread • The AcceptorThread class extends Thread. • Each Thread class has a run method. It defines the behaviour of the thread. Client-server Programming

12. AcceptorThread template public class AcceptorThread extends Thread { private Socket dataSocket; public AcceptorThread(Socket mySocket) { dataSocket=mySocket; } public void run(){ //behaviour of the tread } } Client-server Programming

13. AcceptorConc (concurrent server) public class AcceptorConc { public static void main(String[] args) { try { // Create a serverSocket //loop for each connection request while (true) { // listen for connection request and create a data socket AcceptorThread aThread = new AcceptorThread(dataSocket); aThread.start(); } // close the serversocket } // end try } Client-server Programming

14. Iterative server vs Concurrent server • Iterative server • Trivial to implement. Easy to serialize accesses to a central database. • Server is locked while dealing with a request. If the request does take longer than allowed, no other clients can get service. • Concurrent server • Individual client requests can be of any complexity and duration • Complexity inherent in concurrent processing. Client-server Programming

15. Stateful server • The examples so far are stateless servers, i.e. The server handles the client request, sends back the response, the connection is dropped. • No need to keep any state information to relate different connections from the same client. • However many applications need to relate different connections from the same clients, e.g. file transfer, shopping basket. • Server needs to keep some state information to decide on the correction actions, e.g. knowing which block of the file to send. Client-server Programming

16. An example of stateful server • In Sun’s tutorial on sockets, it has a server that serves up the “Knock-knock” jokes. • Server: "Knock knock!"Client: "Who's there?"Server: “Turnip."Client: “Turnip who?"Server: “Turnip the heat, it’s cold here.“ • The server needs to know where the client and the server are in their conversation in order to serves up the proper response. • The server keeps track the current state (sent knock knock, sent clue, and so on), and returns the various text pieces of the joke depending on the current state. Client-server Programming

17. Stateful vs Stateless Servers • Stateless Server: • Client connects to the server • Client makes one request • Server handles request • Client and server drop connection • Stateful Server • Client connects to the server • Client makes one request • Server handles request C • Client makes another request • Server handles request etc. • Client and server drop connection when done • Server needs to remember information about the client while the client is connected - the state of the connection • Stateful servers are much more complicated than stateless servers Client-server Programming

18. Developing a simple application using TCP socket - scenario • A client reads a line from keyboard and sends to the server • The server reads a line from its socket. • The server converts the line to uppercase. • The server sends the modified line back to client • The client reads the line and displays it. Client-server Programming

19. Example: Java server (TCP) import java.io.*; import java.net.*; class TCPServer { public static void main(String argv[]) throws Exception { String clientSentence; String responseSentence; while(true) { Create welcoming socket at port 6789 Wait, on welcoming socket for contact by client Create input stream, attached to socket Client-server Programming

20. Example: Java server (TCP), cont Create output stream, attached to socket Read in line from socket Write out line to socket End of while loop, loop back and wait for another client connection Client-server Programming

21. Example: Java client (TCP) import java.io.*; import java.net.*; class TCPClient { public static void main(String argv[]) throws Exception { String sentence; String modifiedSentence; Create scanner Create client socket, connect to server Create output stream attached to socket Client-server Programming

22. Example: Java client (TCP), cont. Create input stream attached to socket Send line to server Read line from server Client-server Programming

23. Example: Java server (TCP) import java.io.*; import java.net.*; class TCPServer { public static void main(String argv[]) throws Exception { String clientSentence; String responseSentence; ServerSocket welcomeSocket = new ServerSocket(6789); while(true) { Socket dataSocket = welcomeSocket.accept(); BufferedReader inFromClient = new BufferedReader(new InputStreamReader(dataSocket.getInputStream())); Create welcoming socket at port 6789 Wait, on welcoming socket for contact by client Create input stream, attached to socket Client-server Programming

24. Example: Java server (TCP), cont PrintWriter outToClient = new PrintWriter( new OutputStreamWriter( dataSocket.getOutputStream())); clientSentence = inFromClient.readLine(); responseSentence = clientSentence.toUpperCase(); outToClient.printLine(responseSentence); } } } Create output stream, attached to socket Read in line from socket Write out line to socket End of while loop, loop back and wait for another client connection Client-server Programming

25. Example: Java client (TCP) import java.io.*; import java.net.*; class TCPClient { public static void main(String argv[]) throws Exception { String sentence; String modifiedSentence; Scanner inFromUser = new Scanner(System.in); Socket clientSocket = new Socket("hostname", 6789); PrintWriter outToServer = new PrintWriter( new OutputStreamWriter( clientSocket.getOutputStream())); Create scanner Create client socket, connect to server Create output stream attached to socket Client-server Programming

26. Example: Java client (TCP), cont. Create input stream attached to socket BufferedReader inFromServer = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())); sentence = inFromUser.nextLine(); outToServer.println(sentence); modifiedSentence = inFromServer.readLine(); System.out.println("FROM SERVER: " + modifiedSentence); clientSocket.close(); } } Send line to server Read line from server Client-server Programming