[ДС] Лабораториска 3(UDP) - Дистрибуирани задачи

package lab3udp;

import java.io.*;
import java.net.*;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

enum Status {
    Uspeh,
    NepoznatOperator,
    DelenjeSoNula,
    NemaRabotnik
}

class Zadaca implements Serializable {
    double operand1;
    double operand2;
    char operator;

    public Zadaca(double operand1, double operand2, char operator) {
        this.operand1 = operand1;
        this.operand2 = operand2;
        this.operator = operator;
    }
}

class Rezultat implements Serializable {
    double rezz;
    Status status;

    public Rezultat(double rezz, Status status) {
        this.rezz = rezz;
        this.status = status;
    }

    @Override
    public String toString() {
        return "Rezultat{" +
                "rezz=" + rezz +
                ", status=" + status +
                '}';
    }
}

class ClientThread extends Thread {
    DatagramPacket packet;

    public ClientThread(DatagramPacket packet) {
        this.packet = packet;
    }

    @Override
    public void run() {
        try {
            byte[] bytes = packet.getData();
            ObjectInputStream ois = new ObjectInputStream (new ByteArrayInputStream(bytes));
            Zadaca zadaca = (Zadaca) ois.readObject();

            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            RabotnikThread rabotnik = Server.najdiRabotnik(zadaca);
            if(rabotnik == null)
                oos.writeObject(new Rezultat(Double.NaN, Status.NemaRabotnik));
            else
                oos.writeObject(rabotnik.zadadiRabota(zadaca));
            oos.flush();
            byte[] bytesOut = bos.toByteArray();

            DatagramPacket dp = new DatagramPacket(bytesOut, bytesOut.length);
            dp.setPort(packet.getPort());
            dp.setAddress(packet.getAddress());
            Server.socket.send(dp);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Server extends Thread{
    static DatagramSocket socket;
    static List<RabotnikThread> rabotnici;

    public Server() throws SocketException {
        this.socket = new DatagramSocket(5445);
        rabotnici = new LinkedList<>();
    }

    public static RabotnikThread najdiRabotnik(Zadaca zadaca) {
        for (RabotnikThread rabotnik: rabotnici) {
            if(rabotnik.sloboden)
                return rabotnik;
        }
        return null;
    }

    class RabotaSoKlienti extends Thread {
        DatagramSocket socket;

        public RabotaSoKlienti(DatagramSocket socket) {
            this.socket = socket;
        }

        @Override
        public void run() {
            try {
                while (true) {
                    byte[] buffer = new byte[250];
                    DatagramPacket tmp = new DatagramPacket(buffer, 250);
                    socket.receive(tmp);
                    ClientThread ct = new ClientThread(tmp);
                    ct.start();
                }
            }catch (IOException e) {
                System.err.println(e.getLocalizedMessage());
            }
        }
    }

    @Override
    public void run() {
        RabotaSoKlienti rabotaSoKlienti = null;
        try {
            rabotaSoKlienti = new RabotaSoKlienti(new DatagramSocket(5444));
            rabotaSoKlienti.start();
        } catch (SocketException e) {
            e.printStackTrace();
        }
        try {
            while (true) {
                byte[] buffer = new byte[250];
                DatagramPacket tmp = new DatagramPacket(buffer, 250);
                socket.receive(tmp);
                RabotnikThread rt = new RabotnikThread(tmp.getAddress(), tmp.getPort());
                rt.start();
                rabotnici.add(rt);
            }
        }catch (IOException e) {
            System.err.println(e.getLocalizedMessage());
        }
    }
}

class Client extends Thread {
    String input;
    DatagramSocket socket;

    public Client(String input) throws IOException {
        this.input = input;
        Random random = new Random();
        socket = new DatagramSocket();
    }

    @Override
    public void run() {
        try {
            String line = input;
            String[] lineSegments = line.split(" ");
            double operand1 = Double.parseDouble(lineSegments[0]);
            char operator = lineSegments[1].charAt(0);
            double operand2 =  Double.parseDouble(lineSegments[2]);
            Zadaca z = new Zadaca(operand1, operand2, operator);

            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(z);
            oos.flush();
            byte[] bytes = bos.toByteArray();
            DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, InetAddress.getByName("localhost"), 5444);

            socket.send(datagramPacket);

            DatagramPacket received = new DatagramPacket(new byte[250], 250);
            socket.receive(received);

            ByteArrayInputStream bis = new ByteArrayInputStream(received.getData());
            ObjectInputStream ois = new ObjectInputStream(bis);
            String s = new String(received.getData());
            Rezultat rezultat = (Rezultat) ois.readObject();
            System.out.println(rezultat);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}


class RabotnikThread extends Thread {
    DatagramSocket socket;
    InetAddress rabotnikAddress;
    int rabotnikPort;
    public boolean sloboden;

    public RabotnikThread(InetAddress rabotnikAddress, int rabotnikPort) throws IOException {
        this.socket = new DatagramSocket();
        sloboden = true;
        this.rabotnikAddress = rabotnikAddress;
        this.rabotnikPort = rabotnikPort;
    }

    @Override
    public void run() {
        while(true);
    }

    public Rezultat zadadiRabota(Zadaca z) throws Exception {
        if (!sloboden)
            throw new Exception("Povikan zafaten rabotnik!");

        sloboden = false;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(z);
        oos.flush();
        byte[] bytesToSend = bos.toByteArray();
        DatagramPacket packetOut = new DatagramPacket(bytesToSend, bytesToSend.length);
        packetOut.setAddress(rabotnikAddress);
        packetOut.setPort(rabotnikPort);
        socket.send(packetOut);

        byte[] buffer = new byte[2000];
        DatagramPacket packetIn = new DatagramPacket(buffer, 2000);
        socket.receive(packetIn);
        ObjectInputStream ois = new ObjectInputStream (new ByteArrayInputStream(buffer));
        Rezultat rezz = (Rezultat) ois.readObject();
        sloboden = true;
        return rezz;
    }
}


class Rabotnik extends Thread {
    DatagramSocket socket;
    @Override
    public void run() {
        try {
            socket = new DatagramSocket();

            // oznaci mu na serverot deka si zapocnat
            DatagramPacket najava = new DatagramPacket(new byte[] { 1 }, 1);
            try {
                najava.setAddress(InetAddress.getByName("localhost"));
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
            najava.setPort(5445);
            try {
                socket.send(najava);
            } catch (IOException e) {
                e.printStackTrace();
            }

            // celo vreme citaj zadaci i vrakjaj rezz DO SMRT
            byte[] buffer = new byte[2000];
            while(true){
                DatagramPacket packetIn = new DatagramPacket(buffer, 2000);
                socket.receive(packetIn);
                ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(buffer));
                Zadaca z = (Zadaca) ois.readObject();

                ByteArrayOutputStream bos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(bos);
                Rezultat rezz;
                switch (z.operator) {
                    case '+':
                        rezz = new Rezultat(z.operand1 + z.operand2, Status.Uspeh);
                        break;
                    case '-':
                        rezz = new Rezultat(z.operand1 - z.operand2, Status.Uspeh);
                        break;
                    case '*':
                        rezz = new Rezultat(z.operand1 * z.operand2, Status.Uspeh);
                        break;
                    case '/':
                        rezz = z.operand2 == 0 ? new Rezultat(Double.NaN, Status.DelenjeSoNula) : new Rezultat(z.operand1 / z.operand2, Status.Uspeh);
                        break;
                    default:
                        rezz = new Rezultat(Double.NaN, Status.NepoznatOperator);
                }
                oos.writeObject(rezz);
                oos.flush();
                byte[] bytes = bos.toByteArray();

                DatagramPacket packetOut = new DatagramPacket(bytes, bytes.length);
                packetOut.setPort(packetIn.getPort());
                packetOut.setAddress(packetIn.getAddress());
                socket.send(packetOut);
            }
        } catch (IOException | ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}

public class Lab3UDP {
    public static void main(String[] args) throws IOException, InterruptedException {
        Server server = new Server();
        server.start();

        Rabotnik rabotnik = new Rabotnik();
        rabotnik.start();

        Client clientThread = new Client("5.324 * 23.4");
        clientThread.start();
        clientThread.join();

        Client clientThread2 = new Client("65 + 4");
        clientThread2.start();
        clientThread2.join();

        Client clientThread3 = new Client("65 % 4");
        clientThread3.start();
        clientThread3.join();

        Client clientThread4 = new Client("65 / 0");
        clientThread4.start();
        clientThread4.join();

        server.join();
    }
}