IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING

YEARS 2018-19

Practical No: 1
Aim: Show the implementation of client server communication model
PRACTICAL 1A : A Client Server TCP based chatting application
Code:
1.ChatServer.java
import java.net.*;
import java.io.*;
public class chatServer
{
public static void main( String args[]) throws Exception
{
ServerSocket srs = new ServerSocket(1234);
System.out.println("Server is running...");
Socket ss=srs.accept();
System.out.println("connection establised");
BufferedReader kb = new BufferedReader(new InputStreamReader(System.in));
BufferedReader br = new BufferedReader(new InputStreamReader(ss.getInputStream()));
DataOutputStream dos = new DataOutputStream(ss.getOutputStream());
while(true)
{
//System.out.println("server repeat as long as client not send null");
String s2,s3;
while((s2=br.readLine())!=null)
{
System.out.println("Client said : "+s2);
System.out.println("Enter text ");
s3 = kb.readLine();
//System.out.println("Answer send to client machine");
dos.writeBytes(s3+"\n");
}
System.out.println("Terminated..");
ss.close();
srs.close();
dos.close();
kb.close();
System.exit(0);
}
}
}

1
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

2.ChatClient.java
import java.net.*;
import java.io.*;
public class ChatClient
{
public static void main( String args[]) throws Exception
{
Socket cs = new Socket("localhost",1234);
BufferedReader kb = new BufferedReader(new InputStreamReader(System.in));
BufferedReader br = new BufferedReader(new InputStreamReader(cs.getInputStream()));
DataOutputStream dos = new DataOutputStream(cs.getOutputStream());
System.out.println(" Enter text..");
System.out.println(" if client 'quit' type exit");
String s1,s4=null;
while(!(s1=kb.readLine()).equals("exit"))
{
//System.out.println(" data send to server machine");
dos.writeBytes(s1+"\n");
s4 = br.readLine();
//System.out.println(" data receive from server machine");
System.out.println("Server said : "+s4);
System.out.println("Enter text ");
}
System.out.println("Terminated..");
cs.close();
dos.close();
kb.close();
}
}

2
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

3
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Practical 1B: A client server based program using UDP to find factorial of
a number
Code:
1.udpServerFact.java
import java.net.*;
public class udpServerFact
{
public static void main (String args[])
{
try
{
DatagramSocket ds = new DatagramSocket(2000);
byte b[] = new byte[1024];
DatagramPacket dp = new DatagramPacket(b,b.length);
ds.receive(dp);
String str = new String(dp.getData(),0,dp.getLength());
System.out.println(str);
int a = Integer.parseInt(str);
int f = 1,i;
String s = new String();
for(i=1;i<=a;i++)
{
f=f*i;
}
s = Integer.toString(f);
String str1 = "The Factorial of " + str + " is :" +f;
byte b1[]= new byte[1024];
b1 = str1.getBytes();
DatagramPacket dp1 = new DatagramPacket(b1,b1.length,InetAddress.getLocalHost(),1000);
ds.send(dp1);
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

4
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

2.udpClientFact.java
import java.io.*;
import java.net.*;
public class udpClientFact
{
public static void main(String args[])
{
try
{
DatagramSocket ds =new DatagramSocket(1000);
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter a number :");
String num = br.readLine();
byte b[]= new byte[1024];
b= num.getBytes();
DatagramPacket dp= new DatagramPacket(b,b.length,InetAddress.getLocalHost(),2000);
ds.send(dp);
byte b1[]=new byte[1024];
DatagramPacket dp1 = new DatagramPacket(b1,b1.length);
ds.receive(dp1);
String str = new String(dp1.getData(),0,dp1.getLength());
System.out.println(str);
}
catch(Exception e)
{
e.printStackTrace();
}
}
}

5
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

6
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Practical No:2
AIM: Write a program to show object communication model using RMI
Practical 2A : An RMI based application program to display current date and time
Code:
1.InterDate.java
import java.rmi.*;
public interface InterDate extends Remote
{
public String display() throws Exception;
}
2.ServerDate.java
import java.rmi.*;
import java.rmi.server.*;
import java.util.*;
public class ServerDate extends UnicastRemoteObject implements InterDate
{
public ServerDate() throws Exception
{}
public String display() throws Exception
{
String str ="";
Date d = new Date();
str= d.toString();
return str;
}
public static void main(String args[]) throws Exception
{
ServerDate s1 = new ServerDate();
Naming.bind("DS",s1);
System.out.println("Object registered....");
}
}
3.ClientDate.java
import java.rmi.*;
import java.io.*;
public class ClientDate
{
public static void main(String args[]) throws Exception
{
String s1;
InterDate h1= (InterDate)Naming.lookup("DS");
s1=h1.display();
System.out.println(s1);
}
}

7
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

8
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Practical No: 3
AIM: Write a program to show the implementation of RPC
Practical 3A : Write a program to implement simple calculator operations like
addition, subtraction, multiplication and division
Code:
1.RPCServer.java
import java.util.*;
import java.net.*;
public class RPCServer
{
DatagramSocket ds;
DatagramPacket dp;
String str,methodName,result;
int val1,val2;
{
try
{
ds=new DatagramSocket(1200);
byte b[]=new byte[4096];
while(true)
{
dp=new DatagramPacket(b,b.length);
ds.receive(dp);
str=new String(dp.getData(),0,dp.getLength());
if(str.equalsIgnoreCase("q"))
{
System.exit(1);
}
else
{
StringTokenizer st=new StringTokenizer(str," ");
int i=0;
while(st.hasMoreTokens())
{
String token = st.nextToken();
methodName = token;
{
val1 = Integer.parseInt(st.nextToken());
val2 = Integer.parseInt(st.nextToken());
}
}
System.out.println(str);
InetAddress ia = InetAddress.getLocalHost();
if(methodName.equalsIgnoreCase("add"))
{
result = ""+add(val1, val2);
}
else if(methodName.equalsIgnoreCase("sub"))

9
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

{
result = ""+sub(val1, val2);
}
else if(methodName.equalsIgnoreCase("mul"))
{
result = ""+mul(val1, val2);
}
else if(methodName.equalsIgnoreCase("div"))
{
result = ""+div(val1, val2);
}
byte b1[] = result.getBytes();
DatagramSocket ds1 = new DatagramSocket();
DatagramPacket dp1 = new DatagramPacket(b1, b1.length, InetAddress.getLocalHost(),
1300);
System.out.println("result:"+result+"\n");
ds.send(dp1);
}
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
public int add(int val1, int val2)
{
return val1 + val2;
}
public int sub(int val1, int val2)
{
return val1 - val2;
}
public int mul(int val1, int val2)
{
return val1 * val2;
}
public int div(int val1, int val2)
{
return val1 / val2;
}
public static void main(String[] args)
{
new RPCServer();
}
}

10
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

2.RPCClient.java
import java.io.*;
import java.net.*;
class RPCClient
{
RPCClient()
{
try
{
InetAddress ia = InetAddress.getLocalHost();
DatagramSocket ds = new DatagramSocket();
DatagramSocket ds1 = new DatagramSocket(1300);
//DatagramPacket dp = new DatagramPacket();
System.out.println("\nRPC Client");
System.out.println("Enter the method name and the parameter like add 34:\n");
while(true)
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
byte b[] = str.getBytes();
DatagramPacket dp = new DatagramPacket(b, b.length, ia, 1200);
ds.send(dp);
dp = new DatagramPacket(b, b.length);
ds1.receive(dp);
String s = new String(dp.getData(), 0, dp.getLength());
System.out.println("\nResult = " + s + "\n");
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
new RPCClient();
}
}

11
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

12
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

PRACTICAL 3B: Write a program that finds the square, square root, cube and cube
root of the entered number
1.RPCNumServer.java
Code:
import java.util.*;
import java.io.*;
import java.net.*;
class RPCNumServer
{
DatagramSocket ds;
DatagramPacket dp;
String str, methodName, result;
int val;

RPCNumServer()
{
try
{
ds = new DatagramSocket(1200);
byte b[] = new byte[4096];
while(true)
{
dp = new DatagramPacket(b, b.length);
ds.receive(dp);
str = new String(dp.getData(), 0, dp.getLength());
if(str.equalsIgnoreCase("q"))
{
System.exit(1);
}
else
{
StringTokenizer st = new StringTokenizer(str, " ");
int i = 0;
while(st.hasMoreTokens())
{
String token = st.nextToken();
methodName = token;
val = Integer.parseInt(st.nextToken());
}
}
System.out.println(str);
InetAddress ia = InetAddress.getLocalHost();
if(methodName.equalsIgnoreCase("square"))
{
result = "" + square(val);
}
else if(methodName.equalsIgnoreCase("squareroot"))
{

13
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

result = "" + squareroot(val);

}
else if(methodName.equalsIgnoreCase("cube"))
{
result = "" + cube(val);
}
else if(methodName.equalsIgnoreCase("cuberoot"))
{
result = "" + cuberoot(val);
}
byte b1[] = result.getBytes();
DatagramSocket ds1 = new DatagramSocket();
DatagramPacket dp1 = new DatagramPacket(b1, b1.length, InetAddress.getLocalHost(),
1300);
System.out.println("result:"+result+"\n");
ds1.send(dp1);
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
public double square(int a) throws Exception
{
double ans;
ans = a * a;
return ans;
}
public double squareroot(int a) throws Exception
{
double ans;
ans = Math.sqrt(a);
return ans;
}
public double cube(int a) throws Exception
{
double ans;
ans = a*a*a;
return ans;
}
public double cuberoot(int a)
{
double ans;
ans = Math.cbrt(a);
return ans;
}
public static void main(String[] args)
{

14
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

new RPCNumServer();
}
}

2.RPCNumClient.java
import java.io.*;
import java.net.*;
class RPCNumClient
{
RPCNumClient()
{
try
{
InetAddress ia = InetAddress.getLocalHost();
DatagramSocket ds = new DatagramSocket();
DatagramSocket ds1 = new DatagramSocket(1300);
//DatagramPacketdp = new DatagramPacket();
System.out.println("\nRPC Client");
System.out.println("1. Square of a number\n2. Square Root of the Number\n3. Cube of a
Number\n4. Cube Root of a Number");
System.out.println("\nEnter the method name and the number");
while(true)
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
byte b[] = str.getBytes();
DatagramPacket dp = new DatagramPacket(b, b.length, ia, 1200);
ds.send(dp);
dp = new DatagramPacket(b, b.length);
ds1.receive(dp);
String s = new String(dp.getData(), 0, dp.getLength());
System.out.println("\nResult = " + s + "\n");
}
}
catch(Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
new RPCNumClient();
}
}

15
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

16
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Practical No: 4
AIM : Write a program to execute any one mutual exclusion algorithm.
Code:
1.tserver.java
import java.io.*;
import java.net.*;
public class tserver {
public static void main(String args[]) throws Exception {
while (true) {
Server1 sr = new Server1();
sr.recData();
}
}
}
class Server1 {
boolean hasToken = false;
boolean sendData = false;
void recData() throws Exception {
byte buff[] = new byte[256];
DatagramSocket ds;
DatagramPacket dp;
String str;
ds = new DatagramSocket(6789);
dp = new DatagramPacket(buff,buff.length);
ds.receive(dp);
ds.close();
str = new String(dp.getData(),0,dp.getLength());
System.out.println("The Message is "+str);
}
}

2.tc1.java
import java.net.*;
import java.io.*;
public class tc1 {
public static void main(String args[]) throws Exception {
DatagramSocket udpsock =null;
boolean hasToken = true;
while (true) {
String str = "token";
udpsock = new DatagramSocket();
DatagramSocket udpsock1 = new DatagramSocket();
byte[] m = str.getBytes();
InetAddress aHost = InetAddress.getLocalHost();

17
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

int ServerPort = 6789;

int client1sendport = 8000;
int client1receiveport = 9000;
String ans, msg;
if (hasToken == true) {
DataInputStream in = new DataInputStream(System.in);
System.out.println("Do you want to enter data : (y/n)");
ans = in.readLine();
if (ans.equalsIgnoreCase("y")) {
System.out.println("Enter your Message");
msg = in.readLine();
byte[] m1 = msg.getBytes();
DatagramPacket request = new DatagramPacket(m1,m1.length, aHost, 6789);
udpsock.send(request);
System.out.println("Data send to the Server : ");
udpsock.close();
}
if (ans.equalsIgnoreCase("n")) {
DatagramPacket sentTokenpacket = new DatagramPacket(m,m.length,aHost,8000);
udpsock.send(sentTokenpacket);
hasToken = false;
System.out.println("Token sent to the client:");
udpsock1.close();
}
} else {
System.out.println("Enter receiving mode");
byte[] buffer = new byte[1000];
DatagramSocket ds;
DatagramPacket dp;
ds = new DatagramSocket(9000);
dp = new DatagramPacket(buffer,buffer.length);
ds.receive(dp);
System.out.println("Token received");
String msgstr = new String(dp.getData(),0,dp.getLength());
hasToken = true;
ds.close();
}
}
}
}

18
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

19
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Practical No: 5
AIM :Write a program to implement any one Election Algorithm.
Code:
#include<stdio.h>
#include<conio.h>
#include<process.h>
structproc
{
int live;
int identifier;
}
process[10];
int n,live, cordinator = 1;

/*******************DISPLAY PROCESS*******************/
void display()
{
inti;
printf("\nPROCESSES ARE:\n\n");
printf("Processes:\n");
for(i=1; i<=n; i++)
{
printf("P%d\t",i);
}
printf("\nLIVE");
for(i=1;i<=n;i++)
{
printf("%d\t",process[i], live);
}
printf("\nIdentifier ");
for(i=1;i<=n;i++)
{
printf("%d\t",process[i], identifier);
}
}

/******************BULLY ALGORITHM**************************/
void bully()
{
intch, c, live, id, i=0, cordinator, init, max=99;
cordinator=i;
for(i=1;i<=n;i++)
{
if(process[cordinator], identifier<process[i].identifier&& process[i].live == 1)
cordinator = i;
}

20
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

printf("\nCURRENT CO-ORDINATOR IS = P%d", cordinator);

while(ch != 4)
{
printf("\n\n\nBULLY ALGORITHM");
printf("\n1. Crash a process\n2. Activate a process\n3. Display\n4. Exit");
printf("\nEnter your choice:");
scanf("%d", &ch);
switch(ch)
{
case 1 :
printf("\nEnter the process ID to crash:");
scanf("%d", &init);
if(process[id].live == 0)
{
printf("\nAlready crashed process");
}
else
{
process[id].live = 0;
printf("Process P%d has been crashed",id);
if(id == cordinator)
{
while(1)
{
printf("\nEnter the process ID that initiates the election");
scanf("%d", &init);
if(process[init].live == 0)
{
printf("\nThe selected process has been crashed");
}
else
{
for(i=1;i<=n;i++)
{
if(i!=init&& process[i].identifier>process[init].identifier)
{
printf("\nOK from %d to %d", i, init);
}
}
}
for(i=1;i<=n;i++)
{
if(max<process[i].identifier&& process[i].live!=0)
{
cordinator=i;
max = process[i].identifier;
}
}
printf("\n\nNEW CO-ORDINATOR IS = P%d", cordinator);

21
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

break;
}
}
}

case 2:
printf("\nEnter the process ID to activate");
scanf("%d", &id);
if(process[id].live==1)
{
printf("\nProcess is already active");
}
else
{
process[id].live = 1;
printf("\nProcess %d activated",id);
}
if(process[id].identifier> process[cordinator].identifier)
{
cordinator = id;
printf("\n NEW CO-ORDINATOR IS: P%d\n\n",id);
}
break;

case 3:
display();
break;

case 4:
break;
}
}
}

/************************RING ALGORITHM*************************/
void ring()
{
intch, id, c, i=0, init, max=-99, last;
for(i=1;i<=n;i++)
{
if(process[cordinator].identifier<process[i].live==1)
{
cordinator = i;
}
printf("\n\nCurrentco-ordinator is = P%d",cordinator);
while(ch != 4)
{
printf("\n\n******RING ALGORITHM******");
printf("\n1. Crash a process\n2. Activate a Process\n3. Display\n4. Exit");

22
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

printf("\nEnter your choice:");

scanf("%d",&ch);
switch(ch)
{
case 1:
printf("\nEnter the process ID to crash:");
scanf("%d",&ch);
if(process[id].live == 0)
{
printf("\nAlready crashed process");
}
else
{
process[id].live=0;
printf("\nProcessP%d is crashed",id);
if(id==cordinator)
{
while(1)
{
printf("\nEnter process ID who initiates election");
scanf("%d", &init);
if(process[init].live==0)
{
printf("\nThe selected process has been crashed");
}
else
{
last = init;
printf("\nELECTION MESSAGE SENT FROM = %d", last);
for(i=init+1;i<=n;i++)
{
if(i != init)
{
printf("->%d",i);
last = i;
}
for(i=init;i<=init;i++)
{
cordinator=i;
max = process[i].identifier;
}
}
}
for(i=1;i<=init;i++)
{
if(max<process[i].identifier&& process[i].live == 1)
{
cordinator = i;
max = process[i].identifier;

23
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

}
}
printf("The NEW COR-ORDINATOR IS P%d", cordinator);
break;
}
}
}

break;
case 2:
printf("\nEnter the process ID to activate:");
scanf("%d",&id);
if(process[id].identifier> process[cordinator].identifier)
{
printf("\n NEW CO-ORDINATOR IS P%d\n\n",id);
cordinator = id;
}
break;
case 3:
display();
break;
case 4:
break;
}
}
}
void main()
{
intch i,c;
clrscr();
printf(“\n ENTER THE NUMBER OF PROCESSES”);
scanf(“%d”,&n);
for(i=1;i<=n;i++)
{
printf(“\n Enter P%d process live or not(0/1)”,i);
scanf(“%d”, &process[i].live);
printf(“\n Enter P%d process identifier”,i);
scanf(“%d”,&process[i].identifier);
}
display();
while(1)
{
printf(“\n\n\n ****ELECTION ALGORITHM *****”);
printf(“\n1. BULLY ALGORITHM\n2.RING ALGORITHM\n3.EXIT”);
printf(“Enter your choice”);
scanf(“%d”,&ch);
switch(ch);
{
case 1:

24
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

bully();
break;
case 2:
ring();
break;
case 3:
exit(0);
}}}

25
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

26
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

27
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

28
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

29
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

30
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

31
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

32
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Practical No: 6
AIM :Show the implementation of any one clock synchronization algorithm
1.SCServer.java
Code:
import java.io.*;
import java.net.*;
import java.sql.*;
public class SCServer
{
public static void main(String args[]) throws Exception
{
InetAddress lclhost;
lclhost=InetAddress.getLocalHost();
long maxtime,skewtime,datatime;
String maxtimestr,skewtimestr;
BufferedReader br;
ClntServer ser=new ClntServer(lclhost);
System.out.println("Enter the maximum time:");
br= new BufferedReader(new InputStreamReader(System.in));
maxtimestr=br.readLine();
System.out.println("Enter the maximum skew time");
br = new BufferedReader(new InputStreamReader(System.in));
skewtimestr=br.readLine();
maxtime=Long.parseLong(maxtimestr);
skewtime=Long.parseLong(skewtimestr);
while(true)
{
datatime=System.currentTimeMillis();
long G=datatime-maxtime-skewtime;
System.out.println("G="+G);
ser.setTimeStamp(new Timestamp(G));
ser.recPort(8001);
ser.recData();
}
}
}
class ClntServer
{
InetAddress lclhost;
int recport;
Timestamp obtmp;
ClntServer(InetAddress lclhost)
{
this.lclhost=lclhost;
}
void recPort(int recport)
{

33
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

this.recport=recport;
}
void setTimeStamp(Timestamp obtmp)
{
this.obtmp=obtmp;
}
void recData() throws Exception
{
String msgstr="";
DatagramSocket ds;
DatagramPacket dp;
BufferedReader br;
byte buf[]= new byte[256];
ds = new DatagramSocket(recport);
dp=new DatagramPacket(buf,buf.length);
ds.receive(dp);
ds.close();
msgstr=new String(dp.getData(),0,dp.getLength());
System.out.println(msgstr);
Timestamp obtmp=new Timestamp(Long.parseLong(msgstr));
if(this.obtmp.before(obtmp)==true)
{
System.out.println("The Message is accepted");
}
else
{
System.out.println("The message is rejected");
}
}
}

34
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

2.SCClient.java
import java.io.*;
import java.net.*;
public class SCClient
{
public static void main(String args[]) throws Exception
{
InetAddress lclhost;
lclhost=InetAddress.getLocalHost();
while(true)
{
Client cntl=new Client(lclhost);
cntl.sendPort(9001);
cntl.sendData();
}
}
}
class Client
{
InetAddress lclhost;
int senport;
Client(InetAddress lclhost)
{
this.lclhost=lclhost;
}
void sendPort(int senport)
{
this.senport=senport;
}
void sendData() throws Exception
{
DatagramPacket dp;
DatagramSocket ds;
BufferedReader br;
br= new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the data");
String str= br.readLine();
ds=new DatagramSocket(senport);
dp=new DatagramPacket(str.getBytes(),str.length(),lclhost,senport-1000);
ds.send(dp);
ds.close();
}
}

35
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

36
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Practical No: 7
AIM : Write a program to implement 2 Phase Commit Protocol
1. Server.java
Code:
import java.io.*;
import java.net.*;
import java.util.*;
public class Server
{
boolean closed=false,inputFromAll=false;
List<clientThread> t;
List<String> data;
Server()
{
t=new ArrayList<clientThread>();
data=new ArrayList<String>();
}
public static void main(String args[])
{
Socket ClientSocket=null;
ServerSocket serverSocket=null;
int port_number=1111;
Server ser=new Server();
try
{
serverSocket=new ServerSocket(port_number);
}
catch(IOException e)
{
System.out.println(e);
}
while(!ser.closed)
{
try
{
ClientSocket=serverSocket.accept();
clientThread th=new clientThread(ser,ClientSocket);
(ser.t).add(th);
System.out.println("Now Total Clients are:" +(ser.t).size());
(ser.data).add("NOT SENT");
th.start();

}
catch(IOException e)
{
}
}

37
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

try
{
serverSocket.close();
}
catch(Exception e1)
{
;
}
}
}
class clientThread extends Thread
{
DataInputStream is=null;
String line;
String destClient="";
String name;
PrintStream os=null;
Socket clientSocket=null;
String clientIdentity;
Server ser;
public clientThread(Server ser,Socket clientSocket)
{
this.clientSocket=clientSocket;
this.ser=ser;
}
public void run()
{
try
{
is=new DataInputStream(clientSocket.getInputStream());
os=new PrintStream(clientSocket.getOutputStream());
os.println("Enter ur name");
name=is.readLine();
clientIdentity=name;
os.println("Welcome" +name +"to this 2 Phase Appliaction U Will receive a vote
now.........");
os.println("VOTE_REQUEST Please enter COMMIT or ABORT o proceed");
for(int i=0;i<(ser.t).size();i++)
{
if((ser.t).get(i)!=this)
{
((ser.t).get(i)).os.println("--------A new user " +name + "entered the Applicaation----------");
}
}
while(true)
{
line=is.readLine();
if(line.equalsIgnoreCase("ABORT"))
{

38
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

System.out.println("\nFrom" +clientIdentity+ ":ABORT\n since aborted we will never for

inputs from other clients.");
System.out.println("\nAborted");
for(int i=0;i<(ser.t).size();i++)
{
((ser.t).get(i)).os.println("GLOBAL _ABORT");
((ser.t).get(i)).os.close();
((ser.t).get(i)).is.close();
}
break;
}
if(line.equalsIgnoreCase("COMMIT"))
{
System.out.println("\n From "+clientIdentity+ " :COMMIT");
if((ser.t).contains(this))
{
(ser.data).set((ser.t).indexOf(this),"COMMIT");
for(int j=0;j<(ser.data).size();j++)
{
if(!(((ser.data).get(j)).equalsIgnoreCase("NOT_SENT")))
{
ser.inputFromAll=true;
continue;
}
else
{
ser.inputFromAll=false;
System.out.println("\nWaiting for inputs from other clients:");
break;
}
}
if(ser.inputFromAll)
{
System.out.println("\n\n Commited........");
for(int i=0;i<(ser.t).size();i++)
{
((ser.t).get(i)).os.println("GLOBAL _COMMIT");
((ser.t).get(i)).os.close();
((ser.t).get(i)).is.close();
}
break;
}
}
}
ser.closed=true;
clientSocket.close();
}
}
catch(IOException e)

39
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

{
;
}
}
}

2.twopcommitclient.java
import java.io.*;
import java.net.*;
public class twopcommitclient implements Runnable
{
static Socket clientSocket =null;
static PrintStream os=null;
static DataInputStream is=null;
static BufferedReader InputLine=null;
static boolean closed=false;
public static void main(String args[])
{
int port_number=1111;
String host="localhost";
try
{
clientSocket=new Socket(host,port_number);
InputLine=new BufferedReader(new InputStreamReader(System.in));

os=new PrintStream(clientSocket.getOutputStream());
is=new DataInputStream(clientSocket.getInputStream());
}
catch(Exception e)
{
System.out.println("Exception occured: "+e.getMessage());
}
if(clientSocket!=null && os!=null && is!=null)
{
try
{
new Thread(new twopcommitclient()).start();
while(!closed)
{
os.println(InputLine.readLine());
}
os.close();
is.close();
clientSocket.close();
}
catch(Exception e)
{
System.err.println("IO Exception:"+e);
}

40
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

}
}
public void run()
{
String responseLine;
try
{
while((responseLine=is.readLine())!=null)
{
System.out.println("\n"+responseLine);
if(responseLine.equalsIgnoreCase("GLOBAL COMMIT")==true ||
responseLine.equalsIgnoreCase("GLOBAL_ABORT")==true)
{
break;
}
}
closed=true;
}
catch(IOException e)
{
System.out.println("IOException :"+e);
}
}
}

41
IDOL_MSC(CS) PART-II DISTRIBUTED COMPUTING
YEARS 2018-19

Output:

42