Aggiunto esercizio su stab-skeleton. Creato esercizio quindi con dns resolver, client -> stub -> skeleton -> server

stub_skeleton/Client_Launch.java

@@ -0,0 +1,81 @@
+package stub_skeleton;
+
+import socket_test.test.Record;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+import static java.lang.System.exit;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 26/10/14
+ * Time: 15:25
+ */
+public class Client_Launch {
+
+    private static final Logger log = Logger.getLogger(Client_Launch.class.getName());
+    private static  Socket client_dns_socket = null;
+
+    public static void main (String[] args){
+
+
+
+        try {
+            Socket sock = new Socket("localhost", 60000);
+            log.info("Connessione a server dns");
+            client_dns_socket = sock;
+
+            // GETTING IP OF HOST xserver CONTACTING THE DNS SERVER
+            DNS_Record dns_record = new DNS_Record("xserver",null,0);
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            log.info("inviando richiesta al server dns per host xserver");
+            out.writeObject(dns_record);
+            ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
+            DNS_Record in_dns = (DNS_Record) in.readObject();
+            sock.close();
+            ///////////////////////////////////////////////////////
+
+            if (in_dns.getHost() == null){
+                log.info("No record found in dns server");
+                exit(-1);
+            } else {
+
+               Impiegato i = new Stub(in_dns.getIp(),in_dns.getPorta());
+               log.info(i.getCognome());
+               log.info(i.getNome());
+               log.info(i.getStipendio() + "");
+               log.info(i.aumentaStipendio(400) + "");
+               log.info(i.getStipendio() + "");
+
+
+            }
+
+
+
+
+        } catch (IOException e) {
+            log.info("Server DNS Irragiungibile");
+            //e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (client_dns_socket!= null)
+                try {
+                    client_dns_socket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+        }
+
+    }
+
+
+
+}

stub_skeleton/DNS_Record.java

@@ -0,0 +1,51 @@
+package stub_skeleton;
+
+import java.io.Serializable;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 21/10/14
+ * Time: 13:20
+ */
+public class DNS_Record implements Serializable {
+
+    private static final long serialVersionUID = 9091L;
+
+    public DNS_Record(String in_nome_server, String in_ip_server, int in_porta){
+
+    host=in_nome_server;
+        ip=in_ip_server;
+        porta=in_porta;
+
+
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public void setHost(String host) {
+        this.host = host;
+    }
+
+    public String getIp() {
+        return ip;
+    }
+
+    public void setIp(String ip) {
+        this.ip = ip;
+    }
+
+    public int getPorta() {
+        return porta;
+    }
+
+    public void setPorta(int porta) {
+        this.porta = porta;
+    }
+
+    private String host = null;
+    private String ip = null;
+    private int porta = 0;
+}

stub_skeleton/DNS_Server_Launch.java

@@ -0,0 +1,57 @@
+package stub_skeleton;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 21/10/14
+ * Time: 12:31
+ */
+public class DNS_Server_Launch {
+
+    private static final int dns_server_port = 60000;
+    private static ServerSocket saved_socket = null;
+
+    private static final Logger log = Logger.getLogger(DNS_Server_Launch.class.getName());
+
+    public static void main (String[] arg){
+
+
+        try {
+            ServerSocket open = new ServerSocket(dns_server_port);
+            saved_socket = open;
+             log.info("Aperto socket di ascolto su porta " + dns_server_port);
+             final HashMap<String,DNS_Record> database = new HashMap<String, DNS_Record>();
+
+            for(;true;){
+                Socket accept = open.accept();
+                log.info("Accettata richiesta");
+                Thread request_management_thread = new Thread(new DNS_Server_Request_Management(accept,database));
+                log.info("Richiesta inoltrata a thread");
+                request_management_thread.start();
+                log.info("Waiting on port " + dns_server_port);
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        finally{
+            if (saved_socket!=null)
+                try {
+                    saved_socket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+        }
+
+
+
+    }
+
+
+}

stub_skeleton/DNS_Server_Request_Management.java

@@ -0,0 +1,87 @@
+package stub_skeleton;
+
+import socket_test.test.Record;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 21/10/14
+ * Time: 13:00
+ */
+public class DNS_Server_Request_Management implements Runnable{
+
+
+    private static final Logger log = Logger.getLogger(DNS_Server_Request_Management.class.getName());
+    public DNS_Server_Request_Management(Socket in, HashMap<String, DNS_Record> in_h){
+               sock = in;
+               hash = in_h;
+    }
+
+
+    @Override
+    public void run() {
+         log.info("Gestendo richiesta");
+        try {
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
+            DNS_Record r = (DNS_Record) in.readObject();
+            if (r.getHost()!= null && r.getIp()!= null && r.getPorta()!=0){
+                synchronized (hash) {
+                    hash.put(r.getHost(), r);
+                }
+                log.info("Aggiungendo " + r.getHost() + " " + r.getIp() + " " + r.getPorta() + " al database dns");
+            } else {
+
+                if (r.getHost() != null && r.getIp()== null){
+                         DNS_Record r_out = hash.get(r.getHost());
+                         if (r_out == null)
+                             r_out = new DNS_Record(null,null,0);
+                         out.writeObject(r_out);
+                    log.info("Inviando " + r_out.getHost() + " " + r_out.getIp() + " " + r_out.getPorta() + " al client");
+
+
+                }  else {
+
+                    DNS_Record r_out = new DNS_Record(null,null,0);
+                    out.writeObject(r_out);
+                    log.info("Inviando " + r_out.getHost() + " " + r_out.getIp() + " " + r_out.getPorta() + " al client");
+
+                }
+
+
+            }
+
+            //operations on socket
+            sock.close();
+            log.info("Terminata gestione");
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        finally {
+            try {
+                sock.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+
+    final private Socket sock;
+    final private HashMap<String,DNS_Record> hash;
+
+
+
+
+}

stub_skeleton/Impiegato.java

@@ -0,0 +1,16 @@
+package stub_skeleton;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 26/10/14
+ * Time: 15:15
+ */
+public interface Impiegato {
+
+    String getNome();
+    String getCognome();
+    double getStipendio();
+    double aumentaStipendio(double in_aumento);
+
+}

stub_skeleton/Impiegato_Server_Object.java

@@ -0,0 +1,43 @@
+package stub_skeleton;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 26/10/14
+ * Time: 15:14
+ */
+public class Impiegato_Server_Object implements Impiegato{
+
+    public Impiegato_Server_Object(String in_nome, String in_cognome, double in_aumento){
+        nome = in_nome;
+        cognome = in_cognome;
+        stipendio = in_aumento;
+
+    }
+
+    @Override
+    public String getNome() {
+        return nome;
+    }
+
+    @Override
+    public String getCognome() {
+        return cognome;
+    }
+
+    @Override
+    public double getStipendio() {
+        return stipendio;
+    }
+
+    @Override
+    public double aumentaStipendio(double in_aumento) {
+        stipendio+=in_aumento;
+        return stipendio;
+    }
+
+    private String nome;
+    private String cognome;
+    private double stipendio;
+
+}

stub_skeleton/Server_Launch.java

@@ -0,0 +1,27 @@
+package stub_skeleton;
+
+import socket_test.test.Record;
+
+import java.util.HashMap;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 26/10/14
+ * Time: 15:25
+ */
+public class Server_Launch {
+
+    public static void main (String[] args){
+
+        Impiegato i = new Impiegato_Server_Object("Mario","Rossi",2000);
+        final HashMap<String,Impiegato_Server_Object> database = new HashMap<String, Impiegato_Server_Object>();
+        Skeleton s = new Skeleton(i,database);
+        Thread skeleton_thread = new Thread(s);
+        skeleton_thread.start();
+
+    }
+
+
+
+}

stub_skeleton/Skeleton.java

@@ -0,0 +1,111 @@
+package stub_skeleton;
+
+import socket_test.test.Record;
+import socket_test.test.server_request_management;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 26/10/14
+ * Time: 15:21
+ */
+public class Skeleton implements Runnable{
+
+    private final int skeleton_server_port = 61000;
+    private final int dns_server_port = 60000;  // change this value if dns server port change
+
+    private static final Logger log = Logger.getLogger(socket_test.test.server.class.getName());
+
+     public Skeleton (Impiegato in_server_object , HashMap<String,Impiegato_Server_Object> in_database){
+
+                server_object = in_server_object;
+                database  = in_database;
+
+     }
+
+
+    @Override
+    public void run() {
+
+          contact_DNS();
+          wait_connections();
+
+    }
+
+    void contact_DNS (){
+
+
+
+        try {
+            Socket sock = new Socket("localhost", dns_server_port);   // connessione al server dns
+            savednssocket = sock;
+            log.info("Connessione a DNS");
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            DNS_Record dns_record =  new DNS_Record("xserver", InetAddress.getLocalHost().getHostAddress(),skeleton_server_port);
+            out.writeObject(dns_record);
+            log.info("inviando dati al server dns");
+            sock.close();
+
+
+        } catch (IOException e) {
+            log.info("Impossibile contattare il server DNS");
+            //e.printStackTrace();
+        }
+        finally {
+            try { if (savednssocket != null)
+                    savednssocket.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+
+    }
+    void wait_connections(){
+
+        try {
+            ServerSocket open = new ServerSocket(skeleton_server_port);
+            serversocketsaved = open;
+            log.info("Aperto socket di ascolto su porta " + skeleton_server_port);
+
+            for(;true;){
+                Socket accept = open.accept();
+                log.info("Accettata richiesta");
+                Thread request_management_thread = new Thread(new Skeleton_Server_Request_Management(accept,database, (Impiegato_Server_Object) server_object));
+                log.info("Richiesta inoltrata a thread");
+                request_management_thread.start();
+                log.info("Waiting on port " + skeleton_server_port);
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        finally {
+            try {
+                if(serversocketsaved != null)
+                serversocketsaved.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+
+
+    }
+
+
+        private  Impiegato server_object = null;
+        final private  HashMap<String,Impiegato_Server_Object> database;
+        private Socket savednssocket = null;
+        private ServerSocket serversocketsaved= null;
+
+
+}

stub_skeleton/Skeleton_Server_Request_Management.java

@@ -0,0 +1,87 @@
+package stub_skeleton;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.logging.Logger;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 21/10/14
+ * Time: 13:00
+ */
+public class Skeleton_Server_Request_Management implements Runnable{
+
+
+    private static final Logger log = Logger.getLogger(Skeleton_Server_Request_Management.class.getName());
+    public Skeleton_Server_Request_Management(Socket in, HashMap<String, Impiegato_Server_Object> in_h, Impiegato_Server_Object in_s){
+               sock = in;
+               hash = in_h;
+               server_object = in_s;
+    }
+
+
+    @Override
+    public void run() {
+         log.info("Gestendo richiesta");
+        try {
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
+
+            String request = (String) in.readObject();
+
+            if (request.equals("getNome")){
+                      out.writeObject(server_object.getNome());
+                      out.flush();
+
+            }else if (request.equals("getCognome")) {
+                      out.writeObject(server_object.getCognome());
+                out.flush();
+
+            }else if (request.equals("getStipendio")){
+                      out.writeDouble(server_object.getStipendio());
+                out.flush();
+
+
+            } else /* aumenta stipendio  */{
+                log.info("Aumentando lo stipendio");
+                double aumento = in.readDouble();
+                double aumentato = server_object.aumentaStipendio(aumento);
+                out.writeDouble(aumentato);
+                out.flush();
+                log.info("Aumentato");
+
+            }
+
+
+            //operations on socket
+            sock.close();
+            log.info("Terminata gestione");
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        finally {
+            try {
+                sock.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+
+    final private Socket sock;
+    final private HashMap<String,Impiegato_Server_Object> hash;
+    private Impiegato_Server_Object server_object = null;
+
+
+
+
+}

stub_skeleton/Stub.java

@@ -0,0 +1,146 @@
+package stub_skeleton;
+
+import socket_test.test.Record;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.util.logging.Logger;
+
+/**
+ * Created with xgiovio.macbookair.
+ * User: xgiovio
+ * Date: 21/10/14
+ * Time: 12:31
+ */
+public class Stub  implements Impiegato{
+
+    private static final Logger log = Logger.getLogger(Stub.class.getName());
+
+    public Stub (String in_ip, int in_port){
+        server_ip = in_ip;
+        port = in_port;
+    }
+
+    @Override
+    public String getNome() {
+        try {
+            Socket sock = new Socket(server_ip, port);
+            saved_socket = sock;
+            log.info("Connessione a " + server_ip + " " + port);
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            log.info("inviando getNome al server");
+            out.writeObject(new String("getNome"));
+            ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
+            String to_return = (String) in.readObject();
+            sock.close();
+            return to_return;
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (saved_socket!=null)
+                try {
+                    saved_socket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+        }
+        return "";
+    }
+
+
+    @Override
+    public String getCognome() {
+        try {
+            Socket sock = new Socket(server_ip, port);
+            saved_socket = sock;
+            log.info("Connessione a " + server_ip + " " + port);
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            log.info("inviando getCognome al server");
+            out.writeObject(new String("getCognome"));
+            ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
+            String to_return = (String) in.readObject();
+            sock.close();
+            return to_return;
+        } catch (IOException e) {
+            e.printStackTrace();
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (saved_socket!=null)
+                try {
+                    saved_socket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+        }
+        return "";
+    }
+
+    @Override
+    public double getStipendio() {
+        try {
+            Socket sock = new Socket(server_ip, port);
+            saved_socket = sock;
+            log.info("Connessione a " + server_ip + " " + port);
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            log.info("inviando getStipendio al server");
+            out.writeObject(new String("getStipendio"));
+            ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
+            double to_return = in.readDouble();
+            sock.close();
+            return to_return;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (saved_socket!=null)
+                try {
+                    saved_socket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+        }
+        return -1;
+    }
+
+    @Override
+    public double aumentaStipendio(double in_aumento) {
+        try {
+            Socket sock = new Socket(server_ip, port);
+            saved_socket = sock;
+            log.info("Connessione a " + server_ip + " " + port);
+            ObjectOutputStream out = new ObjectOutputStream(sock.getOutputStream());
+            log.info("inviando aumentaStipendio al server");
+            out.writeObject(new String("aumentaStipendio"));
+            out.flush();
+            out.writeDouble(in_aumento);
+            out.flush();
+            ObjectInputStream in = new ObjectInputStream(sock.getInputStream());
+            double to_return = in.readDouble();
+            sock.close();
+            return to_return;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        finally {
+            if (saved_socket!=null)
+                try {
+                    saved_socket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+        }
+        return -1;
+
+    }
+
+    private String server_ip;
+    private int port;
+    private Socket saved_socket= null;
+}