diff --git a/src/client/SisTerClient.java b/src/client/SisTerClient.java
index 51194a38f82ca0c13ee7bf1f517552c0580c9426..54deb228bc4fc036c674ff6804f130c31531dc7a 100644
--- a/src/client/SisTerClient.java
+++ b/src/client/SisTerClient.java
@@ -31,6 +31,12 @@ public class SisTerClient {
c.client2server();
//c.peerAsClient();
- }
+ public void vote(){
+
+ }
+
+ public void send_request(R){
+
+ }
}
diff --git a/src/json-20140107.jar b/src/json-20140107.jar
new file mode 100644
index 0000000000000000000000000000000000000000..40a325dbadf46a178fb60a8251c796dacf1f66be
Binary files /dev/null and b/src/json-20140107.jar differ
diff --git a/src/json-simple-1.1.1.jar b/src/json-simple-1.1.1.jar
new file mode 100644
index 0000000000000000000000000000000000000000..66347a6c86b7d6442358ca7643e4dc484fb01866
Binary files /dev/null and b/src/json-simple-1.1.1.jar differ
diff --git a/src/server/Channel.java b/src/server/Channel.java
new file mode 100644
index 0000000000000000000000000000000000000000..689182d941c2d43dad79bbcbb4c1c3594b50dd97
--- /dev/null
+++ b/src/server/Channel.java
@@ -0,0 +1,48 @@
+import java.util.LinkedList;
+
+public class Chanel {
+ Network network;
+ int index;
+
+ // Send a message
+ public void sendMessage(int destination, String message) {
+ synchronized(network,queues[destination]) {
+ network.queues[destination].push(message);
+ }
+ }
+
+ // Receive a message
+ public String receiveMessage() {
+ synchronized(network.queues[index]) {
+ if (!network.queues[index].isEmpty())
+ return network.queues[index].pop();
+ else
+ return null;
+ }
+ }
+
+ // distinguish?
+ public void decide(int decision) {
+ if (index<(network.getnumProposers() + network.getnumAcceptors()))
+ throw new Error("Tidak dapat menerima value!");
+
+ else if (decision>=network.getnumProposers())
+ throw new Error("Bukan initial value coy.");
+
+ synchronized(network) {
+ if (network.decision==-1)
+ network.decision=decision;
+ else {
+ if (network.decision!=decision)
+ System.out.println("Terdapat disagreement");
+ }
+ }
+ }
+
+ // initial value untuk proposer
+ public int getInitialValue() {
+ if (index >= network.numProposers())
+ throw new Error("Gak usah tanya non-proposer mah");
+ return index;
+ }
+}
\ No newline at end of file
diff --git a/src/server/Paxos.java b/src/server/Paxos.java
index 49dbffea8d471334f18af7ed7e2710b6e01cf2da..ebcc7c442005446581e9cad40aec38245af762ca 100644
--- a/src/server/Paxos.java
+++ b/src/server/Paxos.java
@@ -7,11 +7,24 @@ import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
+import java.util.HashMap;
+import java.uti.Date;
+
+import java.lang.Thread;
+
+enum MSG_TYPE {PREPARE, PROMISE, ACCEPT, ACCEPTED,LEARN,NACK_PROMISE,NACK_ACCEPTED};
+
public class Paxos
{
+ Server server;
DatagramSocket clientSocket;
+ int MAX_PROPNUM = Integer.MAX_VALUE;
private int n; // number of request
+ public Paxos(){
+ this.server = server;
+ }
+
public void sendRequest(String sentence, String host, int port)
{
clientSocket = new DatagramSocket();
@@ -23,6 +36,313 @@ public class Paxos
clientSocket.send(sendPacket);
}
+ public void runPaxos() {
+ int n_proses = server.getnumProposers() + server.getnumAcceptors() + server.getnumLearners();
+ for (int i=0; i<n_proses; i++){
+ Thread t = new Thread(this, ""+i);
+ t.start();
+ }
+ }
+
+ public int nextProposalNumber(int PID, int cur_Pnum){
+ int i = 0;
+ while (true) {
+ if (i<=cur_Pnum){
+ i++;
+ } else {
+ if (i%server.getnumProposers()==PID)
+ return i;
+ else
+ i++;
+ }
+ if (i==MAX_PROPNUM)
+ return -1;
+ }
+ }
+
+ public void run() {
+ try {
+ Thread t = Thread.currentThread();
+ int myindex = Integer.parseInt(t.getName());
+ Channel c = server.getChannel(myindex);
+ if(myindex<server.getnumProposers()){
+ int cur_Pnum = 0;
+ int CONSENSUS = 0;
+ Message promise_queue[] = new Message[server.numAcceptors()];
+ int Acceptor_decisions[] = new int[server.numAcceptors()];
+ String guaranteed_value = null;
+ int guaranteed_Pnum = -1;
+ int guaranteed_flag = 0;
+ int TIME_OUT = 5000;
+ Date start_time = new Date();
+ while (true) {
+ if(c.isDistinguished()){
+ while(c.receiveMessage()!=null){}
+
+ cur_Pnum = nextProposalNumber(myindex,cur_Pnum);
+ for(int a = server.getnumProposers(); a<(server.getnumProposers()+server.getnumAcceptors()))
+ Message m_prepare = new Message(MSG_TYPE.PREPARE,myindex,a,cur_Pnum,-1,null);
+ c.sendMessage(a,m_prepare.createMessage());
+ }
+ while(true){
+ if(!c.isDistinguished())
+ break;
+ String msg = c.receiveMessage();
+ Date cur_time = new Date();
+ long elapsed_time = cur_time.getTime() - start_time.getTime();
+ if(elapsed_time>TIME_OUT){
+ while(c.receiveMessage()!=null){}
+ cur_Pnum = nextProposalNumber(myindex,cur_Pnum);
+ for(int a=server.getnumProposers(); a<(server.getnumProposers() + server.getnumAcceptors());a++){
+ Message m_prepare = new Message(MSG_TYPE.PREPARE,myindex,a,cur_Pnum,-1,null);
+ c.sendMessage(a,m_prepare.createMessage());
+ }
+ start_time = new Date();
+ guaranteed_value = null;
+ guaranteed_Pnum=-1;
+ guaranteed_flag=0;
+ TIME_OUT*=2;
+ }
+ if(msg!=null){
+ start_time=new Date();
+ Message m=new Message(MSG_TYPE.PREPARE,-1,-1,-1,-1,null); //create a dummy Message object
+ m.parseMessage(msg);
+ //parse the received message to the Message object.
+ switch(m.msg_type){
+ case PROMISE: //if the proposer received promise, send a accept only if it contains Pnum=cur_Pnum.
+ if(guaranteed_flag==1 && m.Pnum==guaranteed_Pnum){ //We already got a guarantee from majority so just accept what we already agreed
+ Message m_accept=new Message(MSG_TYPE.ACCEPT,myindex,m.AID,m.Pnum,-1,guaranteed_value);
+ c.sendMessage(m.AID,m_accept.createMessage());
+ }
+ if(m.Pnum==cur_Pnum){
+ f(guaranteed_flag==0){
+ Message msg_promQ=promise_queue[m.AID-network.numProposers()];
+
+ //Add messages to local queue or discard those messages
+ if(msg_promQ==null){
+ promise_queue[m.AID-network.numProposers()]=m; //new PROMISE recvd
+ }
+ else{
+ if(m.Value==null && msg_promQ.Value==null && msg_promQ.Pnum<m.Pnum){
+ promise_queue[m.AID-network.numProposers()]=m; //new latest PROMISE recvd to replace existing unknown value.
+ }
+ if(m.Value!=null && msg_promQ.Value!=null && msg_promQ.Pnum<m.Pnum){
+ promise_queue[m.AID-network.numProposers()]=m; //new latest PROMISE recvd to replace existing known value.
+ }
+ if(m.Value!=null && msg_promQ.Value==null){
+ promise_queue[m.AID-network.numProposers()]=m; //new latest PROMISE recvd with value to replace existing unknown value.
+ }
+ }
+ //end of adding messages to local queue
+
+ //loop through all message in local queue and check for majority
+ int valid_msg=0;
+ for(int a=network.numProposers();a<(network.numProposers()+network.numAcceptors());a++){
+ if(promise_queue[a-network.numProposers()]!=null){
+ Message m_promise_queue=promise_queue[a-network.numProposers()];//create a dummy Message object
+ valid_msg++;
+ if(m_promise_queue.Value!=null) {
+ if(guaranteed_Pnum<m_promise_queue.Value_Pnum){
+ guaranteed_value=m_promise_queue.Value;
+ guaranteed_Pnum=m_promise_queue.Value_Pnum;
+ }
+ }
+ }
+
+ // end main phase
+ }
+
+ // setelah mendapatkan majority (voting) lalu accept
+ if(valid_msg>(network.numAcceptors()/2)){
+ if(guaranteed_value==null){
+ guaranteed_value=""+c.getInitialValue();
+ guaranteed_Pnum=cur_Pnum;
+ }
+ if(c.isDistinguished()){
+ for(int a=network.numProposers();a<(network.numProposers()+network.numAcceptors());a++){
+ if(promise_queue[a-network.numProposers()]!=null){
+ Message m_accept=new Message(MSG_TYPE.ACCEPT,myindex,a,m.Pnum,-1,guaranteed_value);
+ c.sendMessage(a,m_accept.createMessage());
+ }
+ } // end for
+ }
+ guaranteed_flag=1; // flag set
+ }
+ }
+ }
+ break;
+ case NACK_PROMISE:
+ if(c.isDistinguished() && guaranteed_Pnum <= m.Pnum){
+ cur_Pnum = nextProposalNumber(myindex,cur_Pnum>m.Pnum?cur_Pnum:m.Pnum);
+ // Acceptor should send the highest promised Pnum so far. so that Proposer can generate a even higher Pnum.
+ if(cur_Pnum==-1)
+ c.sleep();
+ while(c.receiveMessage()!=null){} //Clear all previous messages and start fresh prepare
+ for(int a=network.numProposers();a<(network.numProposers()+network.numAcceptors());a++){
+ Message m_newprepare=new Message(MSG_TYPE.PREPARE,myindex,a,cur_Pnum,-1,null);
+ c.sendMessage(a,m_newprepare.createMessage());
+ promise_queue[a-network.numProposers()]=null;
+ }
+ }
+ break;
+
+ case ACCEPTED: //value has been accepted. Keep quiet.
+ Acceptor_decisions[m.AID-network.numProposers()]=1;
+ int decision_made=0;
+ for(int i=0;i<network.numAcceptors();i++){
+ if(Acceptor_decisions[m.AID-network.numProposers()]==1)
+ decision_made++;
+ }
+ if(decision_made>network.numAcceptors()/2)
+ CONSENSUS=1;
+ break;
+
+
+ case NACK_ACCEPTED:
+ Acceptor_decisions[m.AID-network.numProposers()]=-1;
+ int rerun=0;
+ for(int i=0;i<network.numAcceptors();i++){
+ if(Acceptor_decisions[m.AID-network.numProposers()]==-1)
+ rerun++;
+ }
+ if(rerun>network.numAcceptors()/2){ //now start a new run reset all state variables
+ CONSENSUS=0; //1->after reaching
+ promise_queue=new Message[network.numAcceptors()];
+ Acceptor_decisions=new int[network.numAcceptors()]; //1->Accept , -1->NACK_Accept
+ guaranteed_value=null;
+ guaranteed_Pnum=-1;
+ guaranteed_flag=0;
+ cur_Pnum=nextProposalNumber(myindex,cur_Pnum);
+ if(cur_Pnum==-1)
+ System.out.println("Reached MAX_PROPNUM, bail out by throwing exception");
+ c.sleep();
+ while(c.receiveMessage()!=null){} //Clear all previous messages and start fresh prepare
+
+ for(int a=network.numProposers();a<(network.numProposers()+network.numAcceptors());a++){
+ Message m_prepare=new Message(MSG_TYPE.PREPARE,myindex,a,cur_Pnum,-1,null);
+ c.sendMessage(a,m_prepare.createMessage());
+ }
+ }
+ break;
+ }
+ }
+ else{
+ c.sleep(); //Message queue empty so sleeping.
+ }
+ }
+ }
+ else{
+ c.sleep();
+ }
+ }
+ }
+ // kode untuk acceptor
+ if(myindex>=network.numProposers() && myindex<(network.numProposers()+network.numAcceptors())) {
+ /* Initialize the highest proposal number received so far
+ * and the value if any proposal has been accepted */
+
+ int max_pnum = -1; // highest pnum for which acceptor has send a PROMISE
+ String val = null; // value it has accepted
+ int val_pnum = -1; // corresponding pnum for the accepted value above
+ boolean hasAccepted = false;
+ //Acceptor code goes here
+ while(true) {
+
+ Message m1 = new Message(MSG_TYPE.PROMISE, -1, -1, -1, -1, null);
+ String msg_st = c.receiveMessage();
+ Message m2;
+ if(msg_st != null) {
+ m1.parseMessage(msg_st);
+ // switch case to handle all msg_type
+ switch (m1.msg_type) {
+ case PREPARE:
+ /* This is when the message received is PREPARE.
+ * If the proposal number is greater than highest proposal number this acceptor has PROMISEd,
+ * it will send a PROMISE message.
+ *
+ * It will also handle the case when the acceptor has accepted a value but the proposal number
+ * is greater than it has PROMISEd, by sending a PROMISE with the val and corresponding val_pnum
+ * set to one it has accepted. */
+ if(m1.Pnum >= max_pnum) { // change max proposal number promised only when it is greater than current
+ max_pnum = m1.Pnum;
+ m2 = new Message(MSG_TYPE.PROMISE, m1.PID, m1.AID, max_pnum, val_pnum, val);
+ c.sendMessage(m1.PID, m2.createMessage());
+ }
+ else {
+ m2 = new Message(MSG_TYPE.NACK_PROMISE, m1.PID, m1.AID, max_pnum, -1, null); // sending a NACK_PROMISE when proposal's pnum < max_pnum
+ c.sendMessage(m1.PID, m2.createMessage());
+ }
+ break;
+
+ case ACCEPT:
+ if(m1.Pnum == max_pnum) {
+ val = m1.Value;
+ val_pnum = m1.Pnum;
+ hasAccepted = true;
+ /* Send the accepted value to learner only when it is accepted for the first time
+ * hasAccepted boolean takes care of this */
+ Message m3 = new Message(MSG_TYPE.LEARN, m1.PID, m1.AID, max_pnum, val_pnum, val);
+ /* send message to all learners */
+ int totalprocess=network.numProposers()+network.numAcceptors()+network.numLearners();
+
+ for(int i=network.numProposers()+network.numAcceptors(); i<totalprocess; i++) {
+ c.sendMessage(i, m3.createMessage());
+ }
+
+ m2 = new Message(MSG_TYPE.ACCEPTED, m1.PID, m1.AID, max_pnum, val_pnum, val);
+ }
+ else {
+ /* Send a NACK_ACCEPTED message with current max_pnum when received Pnum in ACCEPT message is less than max_pnum
+ * which was promised by the acceptor. */
+ m2 = new Message(MSG_TYPE.NACK_ACCEPTED, m1.PID, m1.AID, max_pnum, -1,null);
+ }
+ c.sendMessage(m1.PID, m2.createMessage());
+ break;
+
+ default:
+ break;
+ }
+ }
+ }
+ }
+ if(myindex>=(network.numProposers()+network.numAcceptors())){
+ //Learner code goes here
+ HashMap<String, Integer> learner_map = new HashMap<String, Integer>(); //format : <<AID.PropNum,Value>>
+ HashMap<Integer, Integer> DECIDED = new HashMap<Integer, Integer>(); //DECIDED for each Prop_Num null->not decided and 1->decided
+ while(true){
+ String Msg_Learn=c.receiveMessage();
+ if(Msg_Learn!=null){
+ Message msg_learn=new Message(MSG_TYPE.PREPARE,-1,-1,-1,-1,null); //create a dummy Message object
+ msg_learn.parseMessage(Msg_Learn);
+ //putting decided value in hashmap
+ learner_map.put(msg_learn.AID+"."+msg_learn.Pnum,Integer.parseInt(msg_learn.Value));
+ HashMap<Integer, Integer> learn_val = new HashMap<Integer, Integer>();
+ for(int i=network.numProposers();i<network.numProposers()+network.numAcceptors()&&DECIDED.get(msg_learn.Pnum)==null;i++){
+ if(learner_map.get(i+"."+msg_learn.Pnum)!=null){
+ int cur_learn_val=learner_map.get(i+"."+msg_learn.Pnum);
+ if(learn_val.get(cur_learn_val)==null){
+ learn_val.put(cur_learn_val,1);
+ }
+ else{
+ learn_val.put(cur_learn_val,learn_val.get(cur_learn_val)+1);
+ if(learn_val.get(cur_learn_val)>network.numAcceptors()/2){
+ c.decide(cur_learn_val);
+// System.out.println("Value Learnt for Prop_Num:"+msg_learn.Pnum+":"+ cur_learn_val + " by learner " + myindex);
+ DECIDED.put(msg_learn.Pnum,1);
+ }
+ }
+ }
+ } // end for
+ } // end if
+ c.sleep();
+ }
+ }
+ }
+ catch(Exception e){e.printStackTrace();}
+ }
+ }
+
+/*
public boolean IsUnique(){
// check the uniqueness of ID
}
@@ -53,6 +373,6 @@ public class Paxos
public boolean Fail(){
- }
+ } */
}
\ No newline at end of file
diff --git a/src/server/Server.java b/src/server/Server.java
index 10f8d18c53b81f7c278d9836acae0d9c223dc74a..485c4aa0ca468a2b0f38fd1ece5f6f821ae84c4e 100644
--- a/src/server/Server.java
+++ b/src/server/Server.java
@@ -14,8 +14,12 @@ import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
+import java.util.LinkedList;
+import java.util.Stack;
+
public class Server implements Runnable
{
+<<<<<<< HEAD
//private Paxos paxos;
private String host;
private int port;
@@ -31,13 +35,16 @@ public class Server implements Runnable
static int count = 0;
Thread thread;
+=======
+>>>>>>> 50cd7dce6ca5ad2a4fe6fb38066efe574e692b88
- public Server()
- {
- this.host = "localhost";
- this.port = 9999;
- this.socket = null;
+ private int totalProcesses;
+ private int numProposers;
+ private int numAcceptors;
+ private int numLearners;
+ private int decision=-1;
+<<<<<<< HEAD
try{
serverSocket = new ServerSocket(1001);
} catch (Exception e) {
@@ -69,57 +76,31 @@ public class Server implements Runnable
System.out.println("Game sudah dimulai... V^__^V");
}
+=======
+ LinkedList<String>[] queues;
+>>>>>>> 50cd7dce6ca5ad2a4fe6fb38066efe574e692b88
- public JSONObject receiveJSON() throws IOException
- {
- InputStream in = socket.getInputStream();
- ObjectInputStream i = new ObjectInputStream(in);
- JSONObject line = null;
- try {
- line = (JSONObject) i.readObject();
- } catch (ClassNotFoundException e){
- e.printStackTrace();
+ @SuppressWarnings("unchecked")
+ public Server(int numProposers, int numAcceptors, int numLearners){
+ totalProcesses = numProposers + numAcceptors + numLearners;
+ queues = new LinkedList[totalProcesses];
+ for (int i=0; i<totalProcesses; i++) {
+ queues[i] = new LinkedList<String>();
}
-
- return line;
-
+ this.numProposers = numProposers;
+ this.numAcceptors = numAcceptors;
+ this.numLearners = numLearners;
}
- public void sendJSON(JSONObject jsonObj) throws IOException
- {
- JSONObject jsonObject2 = new JSONObject();
-
- OutputStream out = socket.getOutputStream();
- ObjectOutputStream o = new ObjectOutputStream(out);
- o.writeObject(jsonObject2);
- out.flush();
+ public int getnumAcceptors(){
+ return numAcceptors;
}
- public void runServer()
- {
- try{
- while(true){
- fromClient = serverSocket.accept();
- count++;
- //streamFromClient = new BufferedReader(fromClient.getInputStream());
-
- InputStreamReader in = new InputStreamReader((fromClient.getInputStream()));
- //PrintStream streamToClient = new PrintStream(fromClient.getInputStream());
- String str = streamFromClient.readLine();
- System.out.println(str);
- //streamToClient.println("Halo, "+str);
- }
- } catch (Exception e){
- e.printStackTrace();
- } finally {
- try {
- fromClient.close();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
+ public int getnumProposers(){
+ return numProposers;
}
+<<<<<<< HEAD
public void server2client() throws IOException{
@@ -170,7 +151,22 @@ public class Server implements Runnable
public void run() {
throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
}
+=======
+ public int getnumLearners(){
+ return numLearners
+ }
+>>>>>>> 50cd7dce6ca5ad2a4fe6fb38066efe574e692b88
+ // untuk channel communication dari proses processID
+ public Channel getChannel(int processID){
+ if (processID <0 || processID >= totalProcesses) {
+ throw new Error ("Invalid process ID");
+ }
+ Channel c = new Channel();
+ c.index = processID;
+ c.network = this;
+ return c;
+ }
}
diff --git a/src/server/Server.java.orig b/src/server/Server.java.orig
new file mode 100644
index 0000000000000000000000000000000000000000..16523eeb004b0ab87d3a7a5133771ac862c53ba1
--- /dev/null
+++ b/src/server/Server.java.orig
@@ -0,0 +1,157 @@
+package sisterserver;
+
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import org.json.JSONObject;
+
+public class Server implements Runnable
+{
+<<<<<<< HEAD
+
+ private Paxos paxos;
+ private String host;
+
+ private String host;
+
+=======
+ private Paxos paxos;
+ private String host;
+>>>>>>> 69b6100463f19dcd49485fc68a92559c4d2bd04a
+ private int port;
+ private Socket socket;
+ private final String DEFAULT_HOST = "localhost";
+ private ServerSocket serverSocket;
+ private int numPlayer;
+ private boolean playing;
+ //PrintStream streamToClient;
+ BufferedReader streamFromClient;
+ Socket fromClient;
+ static int count = 0;
+ Thread thread;
+
+ public Server()
+ {
+ this.host = "localhost";
+ this.port = 9999;
+ this.socket = null;
+
+ try{
+ serverSocket = new ServerSocket(1001);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ }
+
+ public Server(String _host, int _port){
+ try{
+ host = _host;
+ port = _port;
+ serverSocket = new ServerSocket(_port);
+ socket = serverSocket.accept();
+ playing = false;
+ }catch(IOException e){
+
+ }
+
+ }
+ public boolean isWerewolf()
+ {
+ boolean yes = false;
+ // for werewolf
+ return yes;
+ }
+
+ public void connect(String host, int port) throws IOException
+ {
+ this.host = host;
+ this.port = port;
+ socket = new Socket(host, port);
+ System.out.println("Game sudah dimulai... V^__^V");
+
+ }
+
+ public JSONObject receiveJSON() throws IOException
+ {
+ InputStream in = socket.getInputStream();
+ ObjectInputStream i = new ObjectInputStream(in);
+ JSONObject line = null;
+ try {
+ line = (JSONObject) i.readObject();
+ } catch (ClassNotFoundException e){
+ e.printStackTrace();
+ }
+
+ return line;
+
+ }
+
+ public void sendJSON(JSONObject jsonObj) throws IOException
+ {
+ JSONObject jsonObject2 = new JSONObject();
+
+ OutputStream out = socket.getOutputStream();
+ ObjectOutputStream o = new ObjectOutputStream(out);
+ o.writeObject(jsonObject2);
+ out.flush();
+ }
+
+ public void runServer()
+ {
+ try{
+ while(true){
+ fromClient = serverSocket.accept();
+ count++;
+ //streamFromClient = new BufferedReader(fromClient.getInputStream());
+
+ InputStreamReader in = new InputStreamReader((fromClient.getInputStream()));
+ //PrintStream streamToClient = new PrintStream(fromClient.getInputStream());
+ String str = streamFromClient.readLine();
+ System.out.println(str);
+ //streamToClient.println("Halo, "+str);
+ }
+ } catch (Exception e){
+ e.printStackTrace();
+ } finally {
+ try {
+ fromClient.close();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+<<<<<<< HEAD
+=======
+
+>>>>>>> 69b6100463f19dcd49485fc68a92559c4d2bd04a
+
+ public String receiveMessage() throws IOException{
+ String temp = null;
+ BufferedReader inFromClient =new BufferedReader(new InputStreamReader(socket.getInputStream()));
+ temp = inFromClient.readLine();
+ return temp;
+ }
+ public void sendMessage(String out) throws IOException{
+ DataOutputStream outToClient = new DataOutputStream(socket.getOutputStream());
+ String response = out + '\n';
+ outToClient.writeBytes(response);
+ }
+ @Override
+ public void run() {
+ throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+ }
+<<<<<<< HEAD
+=======
+
+>>>>>>> 69b6100463f19dcd49485fc68a92559c4d2bd04a
+
+
+}
diff --git a/src/server/SisterServer.java b/src/server/SisterServer.java
index 558fc08e20a98fecf88411f0c8b6af668ecd4981..63cfddc5c79f3f426c53ab8526c92b473e87e758 100644
--- a/src/server/SisterServer.java
+++ b/src/server/SisterServer.java
@@ -10,6 +10,11 @@ import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.*;
import org.json.JSONObject;
+import org.json.JSONException;
+
+import javax.servlet.http.HttpServlet;
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
/**
*
@@ -33,6 +38,36 @@ public class SisterServer {
//Client c = new Client(0,9999);
//c.peerAsServer();
+<<<<<<< HEAD
+=======
+ while(true)
+ {
+ Socket connectionSocket = welcomeSocket.accept();
+ BufferedReasder inFromClient =new BufferedReader(new InputStreamReader(connectionSocket.getInputStream()));
+ DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());
+ clientSentence = inFromClient.readLine();
+ System.out.println("Received: " + clientSentence);
+ capitalizedSentence = clientSentence.toUpperCase() + '\n';
+ outToClient.writeBytes(capitalizedSentence);
+
+ }*/
+ /*Server s = new Server("localhost",9999);
+ String request = s.receiveMessage();
+ System.out.println(request);
+ JSONObject j = new JSONObject(request);
+ System.out.println(j.get("method"));*/
+ private int sequenceID;
+ private int processID;
+
+ Client c = new Client(1,9999);
+ c.receiveMessageFromClient("localhost", 8888);
+
+ // creating consensus
+ public void consensus(){
+
+ }
+
+>>>>>>> 50cd7dce6ca5ad2a4fe6fb38066efe574e692b88
}
}