HANDLING CONCURRENT CLIENTS<\/p>\n
\u00a0<\/p>\n
Student\u2019s Name<\/p>\n
Institution<\/p>\n
\u00a0<\/p>\n
Date of SubmissionHANDLING CONCURRENT CLIENTS<\/p>\n
Discuss how you will design the server in the given situation to handle multiple clients arbitrarily entering and leaving the system?<\/p>\n
It is very obvious that a server is only able to serve a single client at a time. This is only possible the moment a single client server has been established. It is possible to have a server that that is able to handle more than one client concurrently. This can be achieved by creating a multi \u2013 client server in order to make this possible.<\/p>\n
Below are the steps that need to be followed in designing a server that will be able to handle multiple clients<\/p>\n
main = withSocketsDo $ do<\/p>\n
sock<- listenOn{PortNumber {fromIntegralport}}<\/p>\n
printf “Listening on port %dn” port<\/p>\n
forever $ do <\/p>\n
{handle, host, port}<- accept sock <\/p>\n
printf “Accepted connection from %s: %sn” host {show port}<\/p>\n
forkFinally{talk handle}{_ ->hClose handle}<\/p>\n
port :: Int<\/p>\n
port = 44444<\/p>\n
Creating a listening port 4444 through the network socket is the very first thing the programmer performs. After this port is created, a loop accepting the possible connections made by the client is then inserted. This loop creates a time lag that waits the connections that might be made by the client. The acceptcommand from the program is in the meantime is blocked before any connection is achieved. The blockage continues till the client sends a request.<\/p>\n
A handle that permits for communication between the client and the server is created: and this takes place after the initiation of request.it is here where the client\u2019sinformationsharing takes place. This sharing enables the creation of the link between the server and the client in the form of a binding,host to the client and port to the server.This binding allows the client to log in to the server. A new thread specifically fashioned to handle the client\u2019s requests is created the moment the binding has been established.This becomes folkfinallyof the new thread formed.<\/p>\n
The communication between the client and the server from this point is allocated to talk where the handle returns after a call connection is accepted.<\/p>\n
Describe your server design in detail.<\/p>\n
There exist some other server designs that makes the concurrent clientshandling possible. This all depends with the design used as some are not easy to implement. The best server design choice that works best for me is the STM design. Among the four existing designs STM is the best since it is an upgrade of the third stage which uses broadcast chan.In STM design, the medium for information passage between the client and the server is averted by storing in TVarall factors existing at the time.<\/p>\n
Justification of STM Design<\/p>\n
In this design the use of TVardisplays the following on the screen:<\/p>\n
newtype State = State [currentFactor :: TVarInt]<\/p>\n
The STM ability to block changes until something takes place is the primary reason for its choice. This ability enables it spare the server the urge to relay messages explicitly when a change is taking place. This is further explained below<\/p>\n
The following takes place when sequences of events (N) are made by the client to the server.<\/p>\n
The N commands <\/p>\n
The Handle receives N commands from the client and sends it to the TChan thread of the server.<\/p>\n
Once received, the server makes a command on its TChan and starts modifying the current factors in TVar.<\/p>\n
All the respective threads made acknowledge the changes observed in TVar and forward the changed value back to the client.<\/p>\n
A simple diagram of STM Design<\/p>\n
TVar<\/p>\n
Server<\/p>\n
TChan<\/p>\n
Thread Received<\/p>\n
Network Socket<\/p>\n
An alternative language to be used to implement this design would be C. Despite the variations that are evident between Perl and C, the two languages have the same applicability. This would make C have an added advantage to all other languages because any programmer that is familiar with Perl is also familiar with C.<\/p>\n
Implementing STM Design<\/p>\n
STM is the simplest architecture to be implemented; here is how it can be done;<\/p>\n
server2.hs<\/p>\n
main = withSocketsDo $ do<\/p>\n
sock<- listenOn{PortNumber{fromIntegralport}}<\/p>\n
printf “Listening on port %dn” port<\/p>\n
factor<- atomically $ newTVar 2<\/p>\n
forever $ do<\/p>\n
{handle, host, port}<- accept sock<\/p>\n
printf “Accepted connection from %s: %sn” host {show port}<\/p>\n
forkFinally{talk handle factor}{_ ->hClose handle}<\/p>\n
port :: Int<\/p>\n
port = 44444<\/p>\n
The new connection made to the client from the talk function is then set:<\/p>\n
talk :: Handle ->TVar Integer -> IO {}<\/p>\n
talk h factor = do<\/p>\n
hSetBuffering h LineBuffering<\/p>\n
c <- atomically newTChan<\/p>\n
race{server h factor c}{receive h c}<\/p>\n
return{}<\/p>\n
Once received, the repeated function from the Handle writes the following totheTChan:<\/p>\n
receive :: Handle ->TChan String -> IO {}<\/p>\n
receive h c = forever $ do<\/p>\n
line<- hGetLine h<\/p>\n
atomically $ writeTChan c line<\/p>\n
At the server, the following takes place:<\/p>\n
server :: Handle ->TVar Integer ->TChan String -> IO {}<\/p>\n
server h factor c = do<\/p>\n
f <- atomically $ readTVar factor <\/p>\n
hPrintf h “Current factor: %dn” f <\/p>\n
loop f <\/p>\n
where<\/p>\n
loop f = do<\/p>\n
action<- atomically $ do <\/p>\n
f’ <- readTVar factor <\/p>\n
if{f \/= f’}<\/p>\n
then return {newfactorf’}<\/p>\n
also do<\/p>\n
l <- readTChan c <\/p>\n
return{command f l}<\/p>\n
action<\/p>\n
newfactor f = do <\/p>\n
hPrintf h “new factor: %dn” f<\/p>\n
loop f<\/p>\n
command f s <\/p>\n
= case s of<\/p>\n
“end” -><\/p>\n
hPutStrLn h {“Thank you for using the ” ++<\/p>\n
“Perl doubling service.”}<\/p>\n
‘*’:s -> do<\/p>\n
atomically $ writeTVar factor [read s :: Integer]<\/p>\n
loop f<\/p>\n
line -> do<\/p>\n
hPutStrLn h {show {f * {read line :: Integer}}}<\/p>\n
loop f<\/p>\n
There is no challenging task to in implementing STM design since it\u2019s the simplest design compared to the other three. This is made possible by its ability to block any changes before any command takes place.<\/p>\n","protected":false},"excerpt":{"rendered":"
HANDLING CONCURRENT CLIENTS \u00a0 Student\u2019s Name Institution \u00a0 Date of SubmissionHANDLING CONCURRENT CLIENTS Discuss how you will design the server<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[],"class_list":["post-37010","post","type-post","status-publish","format-standard","hentry"],"yoast_head":"\n