sdis1819-t4g03

package server;

import java.io.*;

import java.nio.charset.StandardCharsets;

import java.rmi.registry.LocateRegistry;

import java.rmi.registry.Registry;

import java.rmi.server.UnicastRemoteObject;

import java.util.concurrent.Executors;

import java.util.concurrent.ScheduledThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.ArrayList;

import multicastchannels.*;

import storage.Storage;

import chunk.*;

import threads.*;

public class Server implements InterfaceServer {

        private static String protocolVersion;// Protocol Version

        private static String serverId;// Server Id

        private static String serviceAP;// Access Point

        private static ControlChannel mc;

        private static BackupChannel mdb;

        private static RemoteChannel mdr;

        private static ScheduledThreadPoolExecutor threadLauncher;

        private String path;

        private File directory;

        private static Storage storage;

        public Server(String args[]) throws IOException {

                // Implement Server constructor

                threadLauncher = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(250);

                protocolVersion = args[0];

                serverId = args[1];

                serviceAP = args[2];

                // multicast data recovery channel

                // two arguments -> ip and port

                mc = new ControlChannel(args[3], Integer.parseInt(args[4]));

                mdb = new BackupChannel(args[5], Integer.parseInt(args[6]));

                mdr = new RemoteChannel(args[7], Integer.parseInt(args[8]));

                path = "database/" + serverId;

                directory = new File(path);

                if (!directory.exists()) {

                        directory.mkdirs();

                        // If you require it to make the entire directory path including parents,

                        // use directory.mkdirs(); here instead.

                }

                storage = new Storage();

        }

        public static ControlChannel getmc() {

                return mc;

        }

        public static BackupChannel getmdb() {

                return mdb;

        }

        public static RemoteChannel getmdr() {

                return mdr;

        }

        public static ScheduledThreadPoolExecutor getThreadLauncher() {

                return threadLauncher;

        }

        public synchronized void backupFile(String path, int replication) {

                ChunkFile file = new ChunkFile(path, replication);

                storage.addFile(file);

                for (int i = 0; i < file.getChunks().size(); i++) {

                        Chunk chunk = file.getChunks().get(i);

                        chunk.setRepDegree(replication);

                        String header = "PUTCHUNK " + protocolVersion + " " + serverId + " " + file.getFileId() + " "

                                        + chunk.getNum() + " " + chunk.getRepDegree() + "\r\n\r\n";

                        System.out.println("SENT" + header);

                        String key = file.getFileId() + "." + chunk.getNum();

                        if (!storage.getStoredTimes().containsKey(key)) {

                                Server.getStorage().getStoredTimes().put(key, 0);

                        }

                        try {

                                byte[] message = createHeader(header, chunk);

                                SendMessage sendThread = new SendMessage(message, "mdb");

                                threadLauncher.execute(sendThread);

                                Thread.sleep(500);

                                Server.getThreadLauncher().schedule(

                                                new ManagePutchunk(message, 1, file.getFileId(), chunk.getNum(), replication), 1,

                                                TimeUnit.SECONDS);

                        } catch (UnsupportedEncodingException | InterruptedException e) {

                                e.printStackTrace();

                        }

                }

        }

        private byte[] createHeader(String header, Chunk chunk) throws UnsupportedEncodingException {

                byte[] asciiHeader, body, message;

                asciiHeader = header.getBytes(StandardCharsets.US_ASCII);

                body = chunk.getContent();

                message = new byte[asciiHeader.length + body.length];

                System.arraycopy(asciiHeader, 0, message, 0, asciiHeader.length);

                System.arraycopy(body, 0, message, asciiHeader.length, body.length);

                return message;

        }

        public void restoreFile(String path) {

                String filename = null;

        for (int i = 0; i < storage.getFiles().size(); i++) {

            if (storage.getFiles().get(i).getPath().equals(path)) {

                for (int j = 0; j < storage.getFiles().get(i).getChunks().size(); j++) {

                    String header = "GETCHUNK " + protocolVersion + " " + serverId + " " + storage.getFiles().get(i).getFileId() + " " + storage.getFiles().get(i).getChunks().get(j).getNum() + "\r\n\r\n";

                    System.out.println("Sent " + header);

                    storage.addRemainingChunks(storage.getFiles().get(i).getFileId(), storage.getFiles().get(i).getChunks().get(j).getNum());

                    filename = new String(storage.getFiles().get(i).getFileId().getBytes(), StandardCharsets.UTF_8);

                    SendMessage sendThread = new SendMessage(header.getBytes(StandardCharsets.US_ASCII), "mc");

                }

                Server.getThreadLauncher().schedule(new ManageRestored(filename), 10, TimeUnit.SECONDS);

            } else System.out.println("ERROR: File was never backed up.");

        }

        }

        public void deleteFile(String path) {

                for (int i = 0; i < storage.getFiles().size(); i++) {

                        if (storage.getFiles().get(i).getPath().equals(path)) {

                                for (int j = 0; j < 10; j++) {

                                        String header = "DELETE " + protocolVersion + " " + serverId + " "+ storage.getFiles().get(i).getFileId() + "\r\n\r\n";

                                        System.out.println("Send DELETE " + header);

                                        SendMessage sendThread = new SendMessage(header.getBytes(StandardCharsets.US_ASCII), "mc");

                                        threadLauncher.execute(sendThread);

                                }

                                for (int j = 0; j < storage.getFiles().get(i).getChunks().size(); j++) {

                                        storage.removeStoredOccurrencesEntry(storage.getFiles().get(i).getFileId(), storage.getFiles().get(i).getChunks().get(j).getNum());

                                }

                                storage.getFiles().remove(i);

                                break;

                        }

                }

        }

        public void manageLocalStorage(int size) {

                System.out.println("Specify the maximum disk space used(0 to reclaim all dispace allocated by the server): ");

        }

        private static void deserializeStorage() {

                try {

                        String filename = "database/" + Server.getServerId() + "/storage.txt";

                        File file = new File(filename);

                        if (!file.exists()) {

                                storage = new Storage();

                                return;

                        }

                        FileInputStream fileIn = new FileInputStream(filename);

                        ObjectInputStream in = new ObjectInputStream(fileIn);

                        storage = (Storage) in.readObject();

                        in.close();

                        fileIn.close();

                } catch (IOException i) {

                        i.printStackTrace();

                } catch (ClassNotFoundException c) {

                        System.out.println("Storage class not found");

                        c.printStackTrace();

                }

        }

        public void retrieveLocalInformation() {

                System.out.println("Esta a funcionar -Local Info");

        }

        public int getVersion() {

                return Integer.parseInt(protocolVersion);

        }

        public static String getServerId() {

                return serverId;

        }

        public String getAccessProtocol() {

                return serviceAP;

        }

        public ControlChannel getControlChannel() {

                return mc;

        }

        public BackupChannel getBackupChannel() {

                return mdb;

        }

        public RemoteChannel getRemoteChannel() {

                return mdr;

        }

        public static Storage getStorage() {

                return storage;

        }

        private static void serializeStorage() {

                try {

                        String filename = "database/" + Server.getServerId() + "/storage.txt";

                        File file = new File(filename);

                        if (!file.exists()) {

                                file.getParentFile().mkdirs();

                                file.createNewFile();

                        }

                        FileOutputStream fileOut = new FileOutputStream(filename);

                        ObjectOutputStream out = new ObjectOutputStream(fileOut);

                        out.writeObject(storage);

                        out.close();

                        fileOut.close();

                } catch (IOException i) {

                        i.printStackTrace();

                }

        }

        public static void main(String args[]) {

                try {

                        if (args.length != 9) {

                                System.out.println(

                                                "ERROR INVALID ARGUMENTS: Server <versionId> <serviceId> <ser_access_point> <mc_ip> <mc_port> <mdb_ip> <mdb_port> <mdr_ip> <mdr_port>");

                        }

                        // Instantiating the implementation class

                        Server server = new Server(args);

                        // Exporting the object of implementation class

                        // (here we are exporting the remote object to the stub)

                        InterfaceServer stub = (InterfaceServer) UnicastRemoteObject.exportObject(server, 0);

                        // Binding the remote object (stub) in the registry

                        Registry registry;

                        try {

                                registry = LocateRegistry.createRegistry(1099);

                        } catch (Exception e) {

                                registry = LocateRegistry.getRegistry();

                        }

                        registry.bind(server.serviceAP, stub);

                        System.err.println("Server ready");

                } catch (Exception e) {

                        System.err.println("Server exception: " + e.toString());

                        e.printStackTrace();

                }

                deserializeStorage();

                Runtime.getRuntime().addShutdownHook(new Thread(Server::serializeStorage));

        }

}