Transcript Rangkaian Komputer TK6383

Socket-based ClientServer Application
Client-Server application architecture
Choosing services – Connectionless
atau Connection-oriented
1
Evolution of Application Architecture
2
3-tier Client-server application
architecture
3
Internet Protocol and Network
Application

Internet protocol supports:



General-purpose service for reliable data transmission
Mechanism for connecting hosts
Network application programs:


Use Internet Protocol to connect to other application
Provide user-level services
4
Client-Server Model

Server Application acts as a “listener”




Waits for incoming messages
Executes services
Returns the results/outcomes
Client Application makes connection


Sends messages to the server
Waits for response
5
Features of a Client






An application program
 Becomes a client when a network service
is needed
 It can also executes other calculation
Is directly created by the users
Is executed locally by at the users’ computer
Initiates connection to a server
Able to access various services (at a given
time)
Does not require a special device or
operating system
6
Features of a Server




Special-purpose application for providing
a network service
Is executed on a remote computer
(usually is centralised and shared)
Waits and receives request for services
from the clients
Requires high-performance device and
operating system
7
Transport Protocol and ClientServer


Client and server exchange messages via
transport protocol such as TCP or UDP
Both client and server must have the same
protocol stack and both interact with the
transport layer
8
Transport Protocol and ClientServer
9
Several Services on a Server
10
Identifying a Service


Every service has a unique identifier which is used by
the client and server
Example - TCP uses port number protocol
(port_num) as identifier
 Server is registered under a specific port number
for a service
 Client asks for a session with the port number for
the service
 Every transport session contains 2 unique
indentifier
 (IP address, port number) at the server
 (IP address, port number) at the client
11
Connection-oriented and
Connectionless Transport Protocol


Which one should be chosen?
UDP - connectionless





Client builds a message
Client sends the message to a server
The server responds
Message must be loaded into a UDP datagram
TCP - connection-oriented



Client makes a connection to a server
Client and server exchange messages
Client terminates the connection
12
UDP


UDP is a connectionless transport protocol,
i.e. it doesn't guarantee either packet
delivery or that packets arrive in sequential
order.
With UDP, bytes of data are grouped
together in discrete packets which are sent
over the network.
13



Packets may travel along different paths
depending on the state of the network.
No two packets are guaranteed the same
route.
Each packet has a time-to-live (TTL)
counter, which is updated when it is routed
along to the next point in the network.
When the timer expires, it will be discarded,
and the recipient will not be notified.
14

If a packet does arrive, it will always arrive
intact. Packets that are corrupt or only
partially delivered are discarded.
15
Advantages of UDP



UDP communication can be more efficient
than guaranteed-delivery data streams.
Unlike TCP streams, which establish a
connection, UDP causes fewer overheads.
Real-time applications that demand up-tothe-second or better performance may be
candidates for UDP, as there are fewer
delays due to error checking and flow
control of TCP.
16


UDP sockets can receive data from more
than one host machine.
Some network protocols specify UDP as the
transport mechanism.
17
Java Support for UDP

Two classes are provided:


DatagramPacket class (java.net)
DatagramSocket class (java.net)
18
DatagramPacket Class



A DatagramPacket object represents a
data packet intended for transmission using
UDP.
It contains addressing information such as
an IP address and a port.
When a DatagramPacket is read from a
UDP socket, the IP address/port number of
the packet represents the address/port
number of the sender.
19

When a DatagramPacket is used to send
a UDP packet, the IP address/port
represents the address/port of the recipient.
DatagramPacket
IP address (java.net.InetAddr)
Port address (int)
Packet data (byte[])
20
Creating a DatagramPacket

Constructor to use for creating a
DatagramPacket for receiving incoming UDP
packets:
DatagramPacket(byte[] buffer, int length)

Example:
DatagramPacket packet;
packet = new DatagramPacket(new byte[256], 256);
21

Constructor to use for sending a
DatagramPacket to a remote machine
DatagramPacket(byte[] buffer, int length,
InetAddress dest_addr,
int dest_port)

Example:
DatagramPacket packet;
InetAddress addr;
addr = InetAddress.getByName("192.168.0.1");
packet = new DatagramPacket(new byte[128],
128,addr, 2000);
22
DatagramPacket Methods








InetAddress getAddress()
byte[] getData()
int getLength()
int getPort()
void setAddress(InetAddress addr)
void setData(byte[] buffer)
void setLength(int length)
void setPort(int port)
23
DatagramSocket Class



The DatagramSocket class provides
access to a UDP socket, which allows UDP
packets to be sent and received.
The same DatagramSocket can be used
to receive as well as to send packets.
Read operations are blocking - i.e. the
application will continue to wait until a
packet arrives.
24


Each DatagramSocket binds to a port on
the local machine. The port number need
not match the port number of the remote
machine.
If the application is a UDP server, it will
usually bind to a specific port number.
25
Creating a DatagramSocket

Constructor to use for creating a client
DatagramSocket:
DatagramSocket() throws java.net.SocketException

Example:
DatagramSocket socket;
try {
socket = new DatagramSocket();
} catch (SocketException exception) {
…
}
26

Constructor to use for creating a server
DatagramSocket:
DatagramSocket(int port) throws
java.net.SocketException

Example:
DatagramSocket socket;
try {
socket = new DatagramSocket(2000);
} catch (SocketException exception) {
…
}
27
DatagramSocket Methods

void close()
void connect(InetAddress r_addr, int r_port)
void disconnect()
InetAddress getInetAddress()
int getPort()
InetAddress getLocalAddress()
int getLocalPort()

int getReceiveBufferSize() throws java.net.SocketException






28

int getSendBufferSize() throws java.net.SocketException

int getSoTimeout() throws java.net.SocketException
void receive(DatagramPacket packet) throws
java.io.IOException
void send(DatagramPacket packet) throws
java.io.IOException
int setReceiveBufferSize(int length) throws
java.net.SocketException
int setSendBufferSize(int length) throws
java.net.SocketException
void setSoTimeout(int duration) throws
java.net.SocketException





29
Listening for UDP Packets

Before an application can read UDP
packets, it must


bind a socket to a local UDP port using
DatagramSocket
create a DatagramPacket that will contain the
data.
30
Packet
Reads packets
DatagramSocket
DatagramPacket
Translates packets
Into a DatagramPacket
UDP application
31

The following code illustrates the process
for reading UDP packets.
DatagramPacket packet;
DatagramSocket socket;
packet = new DatagramPacket(new byte[256], 256);
socket = new DatagramSocket(2000);
boolean finished = false;
while (!finished) {
socket.receive(packet);
// process the packet
}
socket.close();
32

Java I/O streams are usually used to
access the contents of the byte array in a
DatagramPacket. See example later.
DatagramPacket
ByteArrayInputStream
IP address (java.net.InetAddr)
Port address (int)
Packet data (byte[])
DataInputStream
UDP
application
33
Sending UDP Packets


When sending a packet, the application
must create a DatagramPacket that will
contain the data. The address and port
information must also be set.
When the packet is ready for transmission,
the send method of DatagramSocket
should be invoked.
34
DatagramSocket
Binds to a
UDP port
UDP application
Send DatagramPacket
using DatagramSocket
Packet
Constructs
packet
DatagramPacket
35

The following code illustrates the process
for sending UDP packets.
DatagramPacket packet;
DatagramSocket socket;
packet = new DatagramPacket(new byte[256], 256);
socket = new DatagramSocket(2000);
packet.setAddress(…);
packet.setPort(2000);
boolean finished = false;
while (!finished) {
// write data to packet buffer
socket.send(packet);
…
}
socket.close();
36
User Datagram Protocol Example

Run receiving application
java PacketReceiveDemo

Run sending application
java PacketSendDemo
37
38
PacketSendDemo
print(str)
PrintStream
DatagramPacket
ByteArrayOutputStream
toByteArray()
send(packet)
DatagramSocket
39
DatagramSocket
receive(packet)
DatagramPacket
getData()
ByteArrayInputStream
read()
PacketReceiveDemo
40
Building a UDP Client/Server

Run echo server
java EchoServer

Run echo client
java EchoClient
41
Algorithm for Echo Server
1.
2.
3.
Create socket
Create an empty packet
Repeat the following forever
1.
2.
Wait for a packet
Send the packet back to sender
42
Algorithm for Echo Client
Create socket
Set timeout value for socket
Repeat the following ten times
1.
2.
3.
1.
2.
3.
4.
5.
Create the message to be sent
Create packet containing the message as well as the
destination IP and the port
Send the packet through socket
Wait for packet from receiver through socket or timeout
if packet received
1.
2.
6.
Create an input stream to access data in the packet
Use the input stream to read the data and then display it on
the screen.
Sleep for a second
43
Overcoming UDP Limitations

UDP limitations:
 Lack of Guaranteed Delivery
 Lack of Guaranteed Packet Sequencing
 Lack of Flow Control
44
Lack of Guaranteed Delivery




Packets sent via UDP may become lost in
transit.
UDP packets can also become damaged or
lost.
For some applications, the loss of individual
packets may not have a noticeable effect
(e.g. video streams).
For other applications, loss of packets is not
acceptable (e.g. file transfers).
45

If guaranteed delivery is required,
 avoid packet-based communication, and
use a more suitable transport mechanism
(e.g. TCP).
 send acknowledgement to sender after
receiving packets.
46
Lack of Guaranteed Packet
Sequencing


Applications that require sequential access
to data should include a sequence number
in the contents of a datagram packet.
This enables detection of duplicate packets
and also missing packets.
47
Lack of Flow Control


The technique of flow control is important to
avoid flooding a system with more data than
it can handle due to limited bandwidth.
One technique of flow control is to limit the
number of unacknowledged packets. E.g.:
increase control when number of
acknowledgement packets received is
much less than the number of packets sent.
48
Transmission
Control Protocol
49
Overview


Unlike UDP which is concerned with the
transmission of packets of data, TCP
establishes a "virtual connection" between
two machines through which streams of
data may be sent.
TCP guarantees delivery and order,
providing a reliable byte communication
stream between client and server that
supports two-way communication.
50
Establish a virtual connection
Transmit data back and forth
Terminate the connection
51



TCP uses IP (Internet Protocol) to establish
the connection between machines.
This connection provides an interface that
allows streams of bytes to be sent and
received, and transparently converts the
data into IP datagram packets.
The virtual connection between two
machines is represented by a socket.
52

TCP sockets are different from UDP
sockets:


TCP sockets are connected to a single machine.
UDP sockets only send and receive packets of
data. TCP allows tansmission of data through
byte streams. They are converted into datagram
packets for transmission over the network without
programmer intervention.
53
Advantages of TCP over UDP

Automatic Error Control


Data transmission is more dependable. Delivery
of data is guaranteed - lost data packets are
retransmitted.
By means of a timer, TCP retransmits a packet if
an acknowledgement is not received from the
recipient within a specified amount of time.
54

Reliability

As packets are delivered by IP, they will
frequently arrive out of order. However, each
packet contains a sequence number. Using this
sequence number and queuing out-of-order
packets, TCP is able to pass arriving packets to
the application in the correct sequence.
55

Ease of Use

Network programmers will find programming
communication via TCP sockets far simpler than
via datagram packets. This is because data sent
and received can be treated as a continuous
stream (like I/O streams). The data need not be
packaged into discrete units like UDP.
56
Communication Using Ports


Both UDP and TCP uses the concept of a
communications port, which distinguishes
one application from another.
When a TCP socket establishes a
connection to another machine, the
following information will be required:


the IP address of the remote machine
the port number
57


Like ports in UDP, ports in TCP are also
represented by a number in the range 1 65535.
Ports below 1024 are restricted to use by
well-known services. For example,




Telnet (port 23)
SMTP (port 25)
HTTP (port 80)
POP3 (port 110)
58
Socket Operations

TCP sockets can perform a variety of
operations:




Establish a connection to a remote host
Send data to a remote host
Receive data from a remote host
Close a connection
59

There is a special type of socket that
provides a service that will bind to a specific
port number. Normally used only in
servers, this socket can perform the
following operations:



Bind to a local port
Accept incoming connections from remote hosts
Unbind from a local port
60
TCP and the Client/Server Paradigm



In network programming, applications that
use sockets are divided into clients and
servers.
A client is software that initiates a
connection and sends requests.
A server is software that listens for
connections and processes requests.
61


Note that in the context of UDP
programming, no actual connection is
established. UDP applications may both
initiate and receive requests on the same
socket.
In the client/server paradigm, when there is
a connection between two applications, one
must be a client and the other must be a
server.
62
Network Clients



Network clients initiate connections and
control network transactions.
The server fulfills the requests of the client
but not the other way round.
The network client speaks to the server
using a network protocol. E.g an HTTP
client communicates with an HTTP server
using HTTP.
63

Port numbers are used to enable clients to
locate servers. E.g. a web server uses port
80.
64
Network Servers



The role of the network server is to bind to a
specific port and to listen for new
connections.
Unlike the client, the server must run
continually in the hope that some client will
want its services.
The server runs indefinitely. Normally, it is
automatically started when the host
computer of the server is started.
65



Some servers can handle only one
connection at a time, while others can
handle many connections concurrently,
through the use of threads.
Some protocols (e.g. HTTP/1.0) normally
allow only one request per connection.
Others, like POP3, support a sequence of
requests.
Servers answer the client request by
sending either a response or an error
message.
66
TCP Sockets and Java

Java provide the following classes for TCP
sockets:




java.net.Socket
java.net.ServerSocket
The Socket class should be used when
writing client software.
The ServerSocket class should be used
when writing server software.
67
Socket Class

Socket objects represent client sockets,
and is a communication channel between
two TCP communications ports belonging
to one or two machines.
68


There are several constructors for the Socket
class.
The easiest way to create a socket is shown
below:
Socket mySocket;
try {
mySocket = new Socket("www.aol.com", 80);
} catch (Exception e) {
…
}
69

Some of the other constructors:

Socket(InetAddress addr, int port)


Socket(InetAddress rAddr, int rPort,
InetAddress lAddr, int lPort)


Throws java.io.IOException,
java.lang.SecurityException
Throws java.io.IOException,
java.lang.SecurityException
Socket(String rHost, int rPort,
InetAddress lAddr, int lPort)

Throws java.net.UnknownHostException,
java.io.IOException,
java.lang.SecurityException
70
Using a Socket

Refer section 6.4.2 (pg 150) for a
description of some of the methods of the
Socket class.
71
Reading from and Writing to TCP
Sockets

In Java, once a socket is created, it is
connected and ready to read/write by using
the socket's input and output streams. Use
the methods getInputStream() and
getOutputStream() to access those
streams.
72
 Example:
Socket socket;
InputStreamReader isr;
BufferedReader br;
PrintStream ps;
try {
socket = new Socket("www.aol.com",80);
isr = new
InputStreamReader(socket.getInputStream());
br = new BufferedReader(isr);
ps = new PrintStream(socket.getOutputStream());
} catch (Exception e) {
…
}
73
SO_TIMEOUT Socket Option


Socket options are settings that modify how
sockets work. They can affect the performance of
applications.
SO_TIMEOUT is the most useful socket option. It
allows a timer to be started when a read request is
made on a socket. When no data arrives in time
and the timer expires, a
java.io.InterruptedIOException is thrown
which can be caught to check for a timeout.
74
the setSoTimeout() method to set
the duration of the timer. Example:
 Use
socket.setSoTimeout(5000);
 The getSoTimeout()
method can be
used to get the duration of the timer. A
value of zero means that timeouts are
disabled and read operations will block
indefinitely.
75
Creating a TCP Server

The given example is a TCP server which
returns the current day and time to the
client.
76
SocketServer Class



The server socket is a special type of
socket used to provide TCP services.
Client sockets bind to any free port on the
local machine, and connect to a specific
port and host.
The difference with server sockets is that
they bind to a specific port on the local
machine so that remote clients may locate a
service.
77
 Client
socket connections will connect to
only one machine, whereas server
sockets are capable of fulfilling the
requests of multiple clients.
78
Creating a ServerSocket



Once a server socket is created, it will be
bound to a local port and ready to accept
incoming connections.
When clients attempt to connect, they are
placed into a queue.
When this queue is full, further clients are
refused.
79

There are several constructors for the
ServerSocket class.

The easiest way to create a socket is shown
below:
ServerSocket mySocket;
try {
mySocket = new ServerSocket(80);
} catch (Exception e) {
…
}
80

Some of the other constructors:

ServerSocket(int port)

Throws java.io.IOException,
java.lang.SecurityException
If port is 0, then any free port will be used.

By default, the queue size is set to 50.


ServerSocket(int port, int maxClients)


Throws java.io.IOException,
java.lang.SecurityException
Allocates sufficient space to the queue to support the
specified number of client sockets.
81
Using a ServerSocket

Refer section 6.6.2 (pg 161-Reilly) for a
description of some of the methods of the
ServerSocket class.

The most important method is the
accept() method, which accepts client
connection requests.
82
Accepting and Processing Requests
from TCP Clients


The most important function of a server socket is
to accept client sockets. Once a client socket is
obtained, the server can perform all the "real work"
of server programming, which involves reading
from and writing to the socket to implement a
network protocol.
Example: a mail server that provides access to
stored messages would listen to commands and
send back message contents.
83
 Example:
ServerSocket server;
BufferedReader reader;
PrintWriter writer;
server = new ServerSocket(13);
while (true) {
Socket client = server.accept();
reader = new BufferedReader(
new InputStreamReader(
client.getInputStream()));
writer = new PrintWriter(
new OutputStreamWriter(
client.getOutputStream()));
…
}
84
Client Application


In this example, there are 2 java programs
The client program is implemented as a
class NyietInSengClient
85
import java.io.*;
import java.net.*;
BufferedReader stdIn = new
BufferedReader(new
InputStreamReader(System.in));
String fromServer;
String fromUser;
public class NyietInSengClient {
public static void main(String[] args)
throws IOException {
Socket nisSocket = null;
PrintWriter out = null;
BufferedReader in = null;
while ((fromServer = in.readLine()) != null) {
System.out.println("Server: " +
fromServer);
if (fromServer.equals("tata titi tutu"))
break;
try {
nisSocket = new Socket("localhost", 8888);
out = new
PrintWriter(nisSocket.getOutputStream(), true);
in = new BufferedReader(new
InputStreamReader(nisSocket.getInputStream()));
} catch (UnknownHostException e) {
System.err.println("Don't know about host:
localhost.");
System.exit(1);
} catch (IOException e) {
System.err.println("Couldn't get I/O for the
connection to: localhost.");
System.exit(1);
}
fromUser = stdIn.readLine();
if (fromUser != null) {
System.out.println("Client: " +
fromUser);
out.println(fromUser);
}
}
out.close();
in.close();
stdIn.close();
nisSocket.close();
}
}
86
Server Application

Server application is implemented using 2
classes:

NyietInSengServer

NyietInSengServer contains method main() for
the server program. It listens at a port for incoming
connection, accept the connection and reads
messages from client/writes responses to the
client through a socket
87
PrintWriter out = new
PrintWriter(clientSocket.getOutputStream(), true);
BufferedReader in = new BufferedReader(
new
InputStreamReader(clientSocket.getInputStream()
));
String inputLine, outputLine;
NyietInSengProtocol nis = new
NyietInSengProtocol();
import java.net.*;
import java.io.*;
public class NyietInSengServer {
public static void main(String[] args) throws
IOException {
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(8888);
} catch (IOException e) {
System.err.println("Could not listen on
port: 8888.");
System.exit(1);
}
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
} catch (IOException e) {
System.err.println("Accept failed.");
System.exit(1);
}
outputLine = nis.processInput(null);
out.println(outputLine);
while ((inputLine = in.readLine()) != null) {
outputLine = nis.processInput(inputLine);
out.println(outputLine);
if (outputLine.equals("tata titi tutu"))
break;
}
out.close();
in.close();
clientSocket.close();
serverSocket.close();
}
}
88
Protocol class (part of server app)

NyietInSengProtocol


NyietInSengProtocol provides the jokes. It tracks
the current joke, the current status
(SENTTOKTOK, SENTCLUE, etc) and returns
joke text based on the current status.
It implements a communication protocol (a
language) agreed by the client and server.
89
Server App.
Begins by creating a ServerSocket object to listen
(wait) at a certain port. When selecting a port no., pick
one that is not reserved for other services.
 NyietInSengServer waits at port 8888 as the port 8888
is not used in my computer environment:
try {
serverSocket = new ServerSocket(8888);
}
catch (IOException e) {
System.out.println("Could not listen on port: 8888");
System.exit(-1);
}

90
Server App.


The constructor for ServerSocket throws
an exception if it fail to listen the specified
port (say if it is being used)
In this case NyietInSengServer has no
other choice than to exit.
91

If the server is able to connect to the specified
port, then a ServerSocket object is created and
the server app. Will perform the following steps
– accept connection from client (in bold):
Socket clientSocket = null;
try {
clientSocket = serverSocket.accept();
} catch (IOException e) {
System.out.println("Accept failed: 8888");
System.exit(-1);
}
92
Server App.





Method accept() waits until a client program is executed
and requesting for connection at a specified host and
port (example, host : localhost and port : 8888.
When connection between the client and server is
succesfully created, method accept() will return a new
Socket object (in example :clientSocket) which is bound
to a new port.
NyietInSengServer can communicate with
NyietInSengClient through this new socket.
It can keep listening and waiting for new incoming
connection using the original ServerSocket (in example
: serverSocket)
However, in the example, the server application is not
able to cater for more than 1 client.
93
Read/Write Process
1.
Gets the socket's input and output stream
and opens readers and writers on them
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(),
true);
BufferedReader in = new BufferedReader( new InputStreamReader(
clientSocket.getInputStream()));
String inputLine, outputLine;
94
Server App.

After the server successfully establishes a
connection with a client, it communicates
with the client using this code:

// initiate conversation with client
NyietInSengProtocol nis = new NyietInSengProtocol();
outputLine = nis.processInput(null);
out.println(outputLine);
2.
Initiates communication with the client by
writing to the socket (shown in bold).
95