Client Server Model and Distributed Computing

CSN-341
Computer Networks
CLIENT SERVER MODEL
& DISTRIBUTED COMPUTING
Group 7 Members:
Abhishek Jaisingh (14114002)
Amandeep (14114008)
Amit Saharan (14114010)
Tirth Patel (14114036)

What is Client Server Model?
The client-server model is a distributed communication framework of network
processes among service requesters, clients and service providers. The client-server
connection is established through a network or the Internet.
The client-server model is a core network computing concept also building
functionality for email exchange and Web/database access. Web technologies and
protocols built around the client-server model are:
● Hypertext Transfer Protocol (HTTP)
● Domain Name System (DNS)
● Simple Mail Transfer Protocol (SMTP)
● Telnet
Clients include Web browsers, chat applications, and email software, among others.
Servers include Web, database, application, chat and email, etc.
A server manages most processes and stores all data. A client requests specified
data or processes. The server relays process output to the client. Clients sometimes
handle processing, but require server data resources for completion.
The client-server model differs from a peer-to-peer (P2P) model where
communicating systems are the client or server, each with equal status and
responsibilities. The P2P model is decentralized networking. The client-server
model is centralized networking.
Problems with Client-server Model
1. Network Blocking or Network Congestion
As the number of simultaneous client requests to a given server increases, the
server can become overloaded. Contrast that to a P2P network, where its
bandwidth actually increases as more nodes are added, since the P2P network's
2

overall bandwidth can be roughly computed as the sum of the bandwidths of
every node in that network. In addition to this, the server is also susceptible to
DOS(Denial of Service) attacks.
2. Single Point of Failure
As the number of simultaneous client requests to a given server increases,
the server can become overloaded. Contrast that to a P2P network, where its
bandwidth actually increases as more nodes are added, since the P2P
network's overall bandwidth can be roughly computed as the sum of the
bandwidths of every node in that network. When a server goes down all the
operations associated with it are ceased.
3. Lack of Scalability
As the number of simultaneous client requests to a given server increases,
the load on the server increases and hence it is not a scalable system. New
and better quality servers must be added to improve system performance,
which is a very tedious task. Scalability can only be done in the vertical
direction.
4. High Costs
Servers are especially designed to be robust, reliable and high performance
and none of this is cheap. The operating system is also more costly that the
standard stand-alone types as it has to deal with a networked environment.
Distributed Computing
Distributed computing is a field of computer science that studies distributed
systems. A distributed system is a model in which components located on
networked computers communicate and coordinate their actions by passing
messages. The components interact with each other in order to achieve a common
goal. Three significant characteristics of distributed systems are: concurrency of
3

components, lack of a global clock, and independent failure of components.
Examples of distributed systems vary from SOA-based systems to massively
multiplayer online games to peer-to-peer applications.
There are many alternatives for the message passing mechanism, including pure
HTTP, RPC-like connectors and message queues.
A goal and challenge pursued by some computer scientists and practitioners in
distributed systems is location transparency; however, this goal has fallen out of
favour in industry, as distributed systems are different from conventional
non-distributed systems, and the differences, such as network partitions, partial
system failures, and partial upgrades, cannot simply be "papered over" by attempts
at "transparency" (CAP theorem).
Distributed computing also refers to the use of distributed systems to solve
computational problems. In distributed computing, a problem is divided into many
tasks, each of which is solved by one or more computers, which communicate with
each other by message passing.
4

a), (b): a distributed system.
(c): a parallel system.
5

Challenges in Distributed Computing
1. Fault Tolerance or Partition Tolerance
Failures are inevitable in any system. Some components may stop functioning
while others continue running normally. So naturally we need a way to:
● Detect Failures – Various mechanisms can be employed such as
checksums.
● Mask Failures – retransmit upon failure to receive acknowledgement
● Recover from failures – if a server crashes roll back to previous state
● Build Redundancy – Redundancy is the best way to deal with failures. It is
achieved by replicating data so that if one sub system crashes another may
still be able to provide the required information.
2. Concurrency
Concurrency issues arise when several clients attempt to request a shared
resource at the same time. This is problematic as the outcome of any such
data may depend on the execution order, and so synchronisation is required.
A lot of research is also focussed on understanding the asynchronous nature
of distributed systems.
3. Availability
Every request receives a response, without guarantee that if it contains the
most recent version of the information.
Achieving availability in a distributed system requires that the system
remains operational 100% of the time. Every client gets a response,
regardless of the state of any individual node in the system.
4. Transparency
6

A distributed system must be able to offer transparency to its users. As a
user of a distributed system you do not care if we are using 20 or 100’s of
machines, so we hide this information, presenting the structure as a normal
centralized system.
■ Access Transparency – where resources are accessed in a uniform manner
regardless of location
■ Location Transparency – the physical location of a resource is hidden from
the user
■ Failure Transparency – Always try and Hide failures from users
5. Security
The issues surrounding security are those of
■ Confidentiality
■ Availability
To combat these issues encryption techniques such as those of cryptography
can help but they are still not absolute. Denial of Service attacks can still
occur, where a server or service is bombarded with false requests usually by
botnets (zombie computers).
7

Client Server Model in Distributed System
The client-server model is basic to distributed systems. It is a response to the
limitations presented by the traditional mainframe client-host model, in which a
single mainframe provides shared data access to many dumb terminals. The
client-server model is also a response to the local area network (LAN) model, in
which many isolated systems access a file server that provides no processing
power.
Client-server architecture provides integration of data and services and allows
clients to be isolated from inherent complexities, such as communication protocols.
The simplicity of the client-server architecture allows clients to make requests that
are routed to the appropriate server. These requests are made in the form of
transactions. Client transactions are often SQL or PL/SQL procedures and functions
that access individual databases and services.
The system is structured as a set of processes, called servers, that offer services to
the users, called clients.
The client-server model is usually based on a simple request/reply protocol,
implemented with send/receive primitives or using remote procedure calls (RPC)
or remote method invocation (RMI).
RPC/RMI :
1. The client sends a request (invocation) message to the server asking for
some service
2. The server does the work and returns a result (e.g. the data requested) or an
error code if the work could not be performed.
Sequence of events :
8

1. The client calls the client stub. The call is a local procedure call, with
parameters pushed on to the stack in the normal way.
2. The client stub packs the parameters into a message and makes a system call
to send the message. Packing the parameters is called marshalling.
3. The client's local operating system sends the message from the client
machine to the server machine.
4. The local operating system on the server machine passes the incoming
packets to the server stub.
5. The server stub unpacks the parameters from the message. Unpacking the
parameters is called unmarshalling.
6. Finally, the server stub calls the server procedure. The reply traces the same
steps in the reverse direction.
9

Client Server Model and Distributed Computing

Recommended

More Related Content

What's hot (20)

Similar to Client Server Model and Distributed Computing (20)

More from Abhishek Jaisingh (10)

Recently uploaded (20)

Client Server Model and Distributed Computing