sdis1819-t7g06

package Peers;

import java.io.*;

import java.rmi.RemoteException;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.rmi.server.UnicastRemoteObject;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ScheduledThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.nio.file.Paths;

import java.nio.file.Paths;

import Channel.Channel;

import Protocols.BackUpProtocol;

import Protocols.DeleteProtocol;

import Protocols.RestoreProtocol;

import RMI.Service;

import Storage.FileSystem;

import static Global.Globals.MAX_SIZE_STORAGE;

public class Peer implements Service, Serializable {

    private int id;

    private String versionProtocol;

    private String remoteObjName;

    private Channel mc_channel;

    private Channel mdb_channel;

    private Channel mdr_channel;

    ScheduledThreadPoolExecutor threadPool = new ScheduledThreadPoolExecutor(200);

    FileSystem storage;

    Control control;

    public Peer(String version, String peerId, String remoteName, String mcAddr, int mcPort, String mdbAddr, int mdbPort, String mdrAddr, int mdrPort) {

        this.versionProtocol = version;

        this.remoteObjName = remoteName;

        this.id = Integer.parseInt(peerId);

        this.storage = new FileSystem(MAX_SIZE_STORAGE, Paths.get(System.getProperty("user.dir")).toString() + "/sdis/", this.id, this);

        try {

            mc_channel = new Channel(mcAddr, mcPort, this);

            mdb_channel = new Channel(mdbAddr, mdbPort, this);

            mdr_channel = new Channel(mdrAddr, mdrPort, this);

            if(!loadStatus())

                this.control = new Control(this);

            // save data every 2 seconds

            threadPool.scheduleAtFixedRate(() -> {

                this.saveState();

            }, 0, 2, TimeUnit.SECONDS);

        } catch (IOException e) {

           // e.printStackTrace();

        }

        /*new Thread(mdb_channel).start();

        new Thread(mdr_channel).start();

        new Thread(mc_channel).start();

        */

        threadPool.execute(mc_channel);

        threadPool.execute(mdb_channel);

        threadPool.execute(mdr_channel);

    }

    @Override

    public void backup(String filepath, int replicationDegree) throws IOException {

        BackUpProtocol backup = new BackUpProtocol(this, replicationDegree, filepath);

        threadPool.execute(backup);

    }

    @Override

    public void restore(String filepath) throws RemoteException {

        RestoreProtocol restore = new RestoreProtocol(this, filepath);

        threadPool.execute(restore);

    }

    @Override

    public void delete(String filepath) throws RemoteException {

        DeleteProtocol delete = new DeleteProtocol(this, filepath);

        threadPool.execute(delete);

    }

    @Override

    public void manage(int space) throws RemoteException {

    }

    @Override

    public void state() throws RemoteException {

    }

    public static void main(String args[]) throws RemoteException {

        if (args.length != 9) {

            System.out.println("Usage: java Peers.Peer <version> <peer id> <access_point> <MC_IP_address>" +

                    " <MC_port> <MDB_IP_address> <MDB_port> <MDR_IP_address> <MDR_port>");

            return;

        }

        Peer peer = null;

        try {

            peer = new Peer(args[0], args[1], args[2], args[3], Integer.parseInt(args[4]), args[5], Integer.parseInt(args[6]), args[7], Integer.parseInt(args[8]));

            Service serv = (Service) UnicastRemoteObject.exportObject(peer, 0);

            Registry registry = LocateRegistry.getRegistry();

            registry.bind(args[2], serv);

        } catch (Exception e) {

            System.out.println("Server Exception: " + e.getMessage());

            e.printStackTrace();

        }

        try {

            peer.threadPool.awaitTermination(1, TimeUnit.DAYS);

        } catch (Exception e) {

          //  e.printStackTrace();

        }

    }

    public FileSystem getStorage() {

        return storage;

    }

    public String getVersionProtocol() {

        return versionProtocol;

    }

    public Channel getMc_channel() {

        return mc_channel;

    }

    public Channel getMdb_channel() {

        return mdb_channel;

    }

    public Channel getMdr_channel() {

        return mdr_channel;

    }

    public int getId() {

        return id;

    }

    public ScheduledThreadPoolExecutor getThreadPool() {

        return threadPool;

    }

    public Control getControl() {

        return control;

    }

    private void saveState() {

        try {

            FileOutputStream fileCtrl = new FileOutputStream(Paths.get(System.getProperty("user.dir")).toString() + "/objs/" + id + "Ctrl.ser");

            ObjectOutputStream out2 = new ObjectOutputStream(fileCtrl);

            out2.writeObject(this.control);

            out2.close();

            fileCtrl.close();

        } catch (IOException e) {

            new File(Paths.get(System.getProperty("user.dir")).toString() + "/objs").mkdir();

            try {

                new File(Paths.get(System.getProperty("user.dir")).toString() + "/objs/" + id + "Ctrl.ser").createNewFile();

            } catch (IOException e1) {

               // e1.printStackTrace();

            }

            //e.printStackTrace();

        }

    }

    private boolean loadStatus() {

        try {

            FileInputStream fileCtrl = new FileInputStream(Paths.get(System.getProperty("user.dir")).toString() + "/objs/" + id + "Ctrl.ser");

            ObjectInputStream obj2 = new ObjectInputStream(fileCtrl);

            this.control = (Control) obj2.readObject();

            obj2.close();

            fileCtrl.close();

            return true;

        } catch (Exception e) {

            System.out.println("no files found");

        }

        return false;

    }

}