Advertisement
Guest User

Untitled

a guest
Jan 22nd, 2019
73
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 5.81 KB | None | 0 0
  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.io.PrintWriter;
  5. import java.lang.reflect.Array;
  6. import java.net.ServerSocket;
  7. import java.net.Socket;
  8. import java.util.ArrayList;
  9.  
  10. public class DispatcherApp extends Thread {
  11.  
  12.     private ServerSocket dispatcherServerSocket;
  13.     private Socket dispatcherSocket;
  14.     private PrintWriter outToRemoteSocket;
  15.     private BufferedReader inFromRemoteSocket;
  16.  
  17.     private ArrayList<Courier> couriers;
  18. //    private ArrayList<Client> clients;
  19.  
  20.     private String messageToProcess;
  21.  
  22.     public DispatcherApp(int port) throws IOException{
  23.         dispatcherServerSocket = new ServerSocket(port);
  24.         couriers = new ArrayList<>();
  25.     }
  26.  
  27.     public static void main(String[] args) {
  28.         int port = 50001;
  29.  
  30.         try {
  31.             Thread t = new DispatcherApp(port);
  32.             t.start();
  33.         } catch (IOException e) {
  34.             e.printStackTrace();
  35.         }
  36.  
  37.     }
  38.  
  39.     @Override
  40.     public void run() {
  41.         while(true) {
  42.             try{
  43.                 System.out.println("Waiting for client on port " + dispatcherServerSocket.getLocalPort() + "...");
  44.                 dispatcherSocket = dispatcherServerSocket.accept();
  45.  
  46.                 System.out.println("Just connected to " + dispatcherSocket.getRemoteSocketAddress());
  47.                 inFromRemoteSocket = new BufferedReader(new InputStreamReader(dispatcherSocket.getInputStream()));
  48.  
  49.                 messageToProcess = inFromRemoteSocket.readLine();
  50.  
  51.                 if(wasTheMessageFromCourier(messageToProcess)) {
  52.                     processCourierInfo(messageToProcess);
  53.                 } else {
  54.  
  55.                 }
  56.  
  57.  
  58.                 dispatcherSocket.close();
  59.  
  60.             } catch (IOException e) {
  61.                 e.printStackTrace();
  62.             }
  63.         }
  64.     }
  65.  
  66.     private processMessage(String message) {
  67.         String []tempString = message.split(":");
  68.  
  69.         if(wasTheMessageFromCourier(message)) {
  70.  
  71.             switch(tempString[1]) {
  72.                 case "add":
  73.                     processCourierInfo(message);
  74.                     break;
  75.                 case "ready":
  76.                     setReadyCourier(message);
  77.                     break;
  78.                     case ""
  79.  
  80.             }
  81.  
  82.         } else {
  83.  
  84.         }
  85.  
  86.     }
  87.  
  88.     public boolean setReadyCourier(String message) {
  89.         String []tempString = message.split(":");
  90.  
  91.         int id = Integer.parseInt(tempString[2]);
  92.  
  93.         for(Courier courier : couriers) {
  94.             if(courier.getId() == id) {
  95.                 courier.setReady(true);
  96.                 return true;
  97.             }
  98.         }
  99.  
  100.         return false;
  101.     }
  102.  
  103.     public boolean wasTheMessageFromCourier(String message) {
  104.         String []tempString = message.split(":");
  105.  
  106.         if(tempString[0].toLowerCase().equals("courier"))
  107.             return true;
  108.         else
  109.             return false;
  110.  
  111.     }
  112.  
  113.     public boolean processCourierInfo(String message) {
  114.         String []tempString = message.split(":");
  115.         String address;
  116.         String category;
  117.         int id;
  118.  
  119.         try {
  120.             address = tempString[2];
  121.             category = tempString[3];
  122.             id = Integer.parseInt(tempString[4]);
  123.         } catch (IndexOutOfBoundsException e) {
  124.             e.printStackTrace();
  125.             return false;
  126.         }
  127.  
  128.         Courier tempCourier = new Courier(address, category, id);
  129.  
  130.         couriers.add(tempCourier);
  131.         return true;
  132.  
  133.     }
  134.  
  135.     public
  136.  
  137.  
  138.  
  139.     //
  140. //    private ServerSocket dispatcherServerSocket;
  141. //    private Socket courierSocket;
  142. //    private PrintWriter outToRemoteSocket;
  143. //    private BufferedReader inFromRemoteSocket;
  144. //
  145. //    private ArrayList<Courier> couriers;
  146. //
  147. //    private String messageFromCourier;
  148. //
  149. //
  150. //    public DispatcherApp(int port) throws IOException {
  151. //        dispatcherServerSocket = new ServerSocket(port);
  152. //        couriers = new ArrayList<>();
  153. //    }
  154. //
  155. //    @Override
  156. //    public void run() {
  157. //        while (true) {
  158. //            try {
  159. //                System.out.println("Waiting for client on port " + dispatcherServerSocket.getLocalPort() + " ...");
  160. //                courierSocket = dispatcherServerSocket.accept();
  161. //
  162. //                System.out.println("Just connected to " + courierSocket.getRemoteSocketAddress());
  163. //                inFromRemoteSocket = new BufferedReader(new InputStreamReader(courierSocket.getInputStream()));
  164. //
  165. //
  166. //                messageFromCourier = inFromRemoteSocket.readLine();
  167. //                couriers.add(new Courier(courierSocket.getRemoteSocketAddress().toString(), messageFromCourier.split(" ")[0], Integer.parseInt(messageFromCourier.split(" ")[1])));
  168. //
  169. //
  170. //                outToRemoteSocket = new PrintWriter(courierSocket.getOutputStream(), true);
  171. //                outToRemoteSocket.println("Thank you for connecting to " + courierSocket.getLocalAddress() + "\nGoodbye!");
  172. //                System.out.println(couriers.get(0).getId() + couriers.get(0).getAddress() + couriers.get(0).getCategory());
  173. //                courierSocket.close();
  174. //
  175. //            } catch (IOException e) {
  176. //                e.printStackTrace();
  177. //            }
  178. //        }
  179. //    }
  180. //
  181. //    private void initializeConnectedCourier(String message) {
  182. //        String[] splitMessage = message.split(" ");
  183. //        String category = splitMessage[1];
  184. //        int id = Integer.parseInt(splitMessage[2]);
  185. //
  186. //    }
  187. //
  188. //    public static void main(String[] args) {
  189. //        int port = 50001;
  190. //        try {
  191. //            Thread t = new DispatcherApp(port);
  192. //            t.start();
  193. //        } catch (IOException e) {
  194. //            e.printStackTrace();
  195. //        }
  196. //
  197. //        DispatcherView view = new DispatcherView();
  198. //    }
  199. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement