Visualizzazione dei risultati da 1 a 5 su 5
  1. #1

    [JAVA] Creazione di due classi per l'esercizio in questione

    Si vuole realizzare un'applicazione Director capace di gestire una serie di attività eseguibili parallelamente.
    Il sistema è composto da un coordinatore centrale, detto MASTER, e da un numero N di macchine, dette SLAVE, che eseguono tutte lo stesso tipo di attività.
    Ogni slave può eseguire una sola attività. Il master attende la richiesta di un client e, una volta ricevuta, individua se possibile, uno slave libero e lo contatta per dare inizio all'attività. Se tutte le macchine slave sono occupate, il master risponde immediatamente al clientinviando la stringa "SYSTEM BUSY".
    Per attivare l'attività di una macchina slave, il master deve semplicemente inviargli la stringa "START ACTIVITY". Il master attende la fine dell'attività della macchina slave e poi avvisa il client inviando la stringa "ACTIVITY OVER".

    Si richiededi implementare in Java:
    - una classe per la gestione del modulo MASTER (IP: 150.100.100.100, TCP Port: 1111),
    - una classe per la gestione del modulo SLAVE (IP: 150.100.100.10x, TCP Port: 2222, con x = 1...N).
    --------------------------------------------------------------------------------------------------

    Dato il testo dell'esercizio (vedi sopra), vorrei sapere come impostare il tutto a livello teorico: cioè come scomporre in sotto-problemi l'esercizio e come, sempre teoricamente, procedere passo-passo.

    Grazie a chiunque possa aiutarmi...
    Filippo.

  2. #2

    Re: [JAVA] Creazione di due classi per l'esercizio in questione

    Originariamente inviato da badboyme
    Dato il testo dell'esercizio (vedi sopra), vorrei sapere come impostare il tutto a livello teorico: cioè come scomporre in sotto-problemi l'esercizio e come, sempre teoricamente, procedere passo-passo.
    Dalla specifica emerge che i vari Slave sono server delocalizzati che può vedere solo il Master (ogni client per raggiungere uno Slave deve passare per il Master).

    Quindi, nel momento in cui un client si connette al Master, si verifica questa situazione:
    se ci sono Slave liberi, il Master invia al primo Slave libero la stringa e questo svolge la sua attività (non so in cosa consiste in questo caso).

    Il Master dovrebbe essere costituito da due Thread. Uno si occupa delle connessioni con i vari client, il secondo si occupa di comunicare con gli n Slave.

  3. #3
    Ok...allora la mia interpretazione è correta (in base a quanto hai detto tu (VincenzoTheBest).

    Io sto iniziando a buttare giù un po di codice...

    La mia idea è la seguente:
    Creo una classe Master che non fa altro che aspettare delle connessioni in ingresso
    tramite il solito ServerSocket, all'interno di un ciclo while() infinito, dopodichè,
    da in pasto ad un thread (chiamato da me MasterThread) la connessione col client appena collegato e torna in attesa di connessioni nel suo cicletto while infinito.
    Il MasterThread è quello che sto attualmente sviluppando...
    l'idea sarebbe quella di avere una lista (hashtable), come variabile di classe,
    nella classe Master e, ogni slave aggiorna questa lista comunicando il proprio IP e stato ("free" o "busy"). a questo punto, tornando al MasterThread, questo controlla la lista e, se arriva a scorrerla tutta senza trovare alcun slave libero, invia direttamente il messaggio al client "SYSTEM BUSY", altrimenti, al primo slave libero, apre una nuova connessione con questìultimo e invia la stringa "START ACTIVITY". Intanto, una volta ricevuta tale stringa da parte del MasterThread, lo slave in questione dovrà aggiornare il suo stato in "BUSY" nella lista (hashtable) della classe Master. A tal proposito si potrebbe anche fare, credo, che lo stato di tale slave, venga aggiornato direttamente dal thread MasterThread, col codice del tipo Master.listaSlaves.put("IP slave", "stato slave"). Forse quest'ultima variante è più semplice da implementare? Considerando, come giustamente dicevi tu, che le due classi Master e MasterThread girano sulla stessa macchina fisica (in teoria) mentre la classe Slave gira su macchine diverse in un range di indirizzi ip compreso tra 150.100.100.101 e 150.100.100.109. Corretto?


    Intanto proseguo...vediamo che combino... ;-)

    Ti aggiornerò via via...

    Grazie come sempre!

  4. #4
    Eccomi!!
    Allora, mi sto incartando nello scrivere un metodo di classe, nella classe Master,
    che provveda a interrogare lo stato degli slaves, con un ciclo for da i=0 a i<10.
    Quello che vorrei fare è: mettere dentro un ciclo for la creazione di un nuovo socket, ad ogni ciclata del for, e aperto lo stream di input di quel socket, leggere l'output dello slave e sapere il suo stato. Una volta acquisito questo dato, inserirlo insieme all'ip dello slave che ha risposto nella hashtable "listaSlaves" nella classe Master.

    Come si può fare in modo che, all'interno del for, possa evitare che si blocchi l'applicazione con qualche eccezione nel caso in cui il socket temporaneo, che voglio creare all'interno del ciclo for, non possa essere creato perchè, ad esempio,
    il socket che si vuole creare non si può agganciare all'ip generato in quel momento?
    (Per esempio, una causa potrebbe essere che non esiste una macchina slave con un certo ip...quindi la creazione o binding del socket fallisce).

    Il punto fondamentale è che, in caso di non esistenza di una macchina slave con un certo ip, il ciclo for continui...invece di generare un'eccezzione che termina tutto il programma in esecuzione.


    Posto questa funzione (Scusate, METODO), il cui codice è da prendere con le pinze!! :-S

    codice:
    public static void refreshListaSlaves() {
            listaSlaves = new Hashtable();
            try {
                //Inizializzo le variabili tempSocket, IP e PORTA;
                //IP = 150.100.100.10x (con x = 1...9);
                Socket tempSocket = null;
                String IP = null; //IP = "150.100.100.";
                int PORTA = 5555;
                            
                for(int i=0; i<10; i++) {
                    int lastOctet = 100 + (i + 1);
                    IP = ("150.100.100." + lastOctet + "");
                    try {
                        tempSocket = new Socket(IP, PORTA);
                        if(tempSocket != null) {
                            //Apro lo Stream di input per ricevere lo stato dello Slave corrente;
                            ObjectInputStream in = new ObjectInputStream(tempSocket.getInputStream());
                            //Leggo lo stato dello Slave corrente;
                            String status = (String) in.readObject();
                            //Aggiungo alla Lista degli SLaves lo Slaves corrente (IP, Stato);
                            listaSlaves.put(IP, status);
                        }                       
                    } catch (ClassNotFoundException e) {
                        System.out.println("Si è verificato un errore!");
                    }
                }
            } catch (IOException e) {
                System.out.println("Si è verificato un errore di IOException!");
                e.printStackTrace();
            }            
        }

  5. #5
    Originariamente inviato da badboyme
    Eccomi!!
    Allora, mi sto incartando nello scrivere un metodo di classe, nella classe Master,
    che provveda a interrogare lo stato degli slaves, con un ciclo for da i=0 a i<10.
    Quello che vorrei fare è: mettere dentro un ciclo for la creazione di un nuovo socket, ad ogni ciclata del for, e aperto lo stream di input di quel socket, leggere l'output dello slave e sapere il suo stato. Una volta acquisito questo dato, inserirlo insieme all'ip dello slave che ha risposto nella hashtable "listaSlaves" nella classe Master.
    La tua soluzione non è tanto efficace, nè tanto meno efficiente.

    Il Master nel momento in cui viene inizializzato, stabilisce una connessione con gli n Slave e imposta il loro stato iniziale su disponibile.
    Poi potrebbe avvalersi di n Thread, dove ogni processo resta in ascolto del rispettivo Slave in modo tale da rendere più automatico ed efficiente l'aggiornamento del suo stato.

    In pratica, il Master scrive al primo Slave libero (settando il suo stato su Occupato), poi nel momento in cui lo Slave ha finito, invia il messaggio al Thread che è in ascolto e quest'ultimo si occupa di inviare il messaggio al client e setta su disponibile lo stato dello Slave.

Permessi di invio

  • Non puoi inserire discussioni
  • Non puoi inserire repliche
  • Non puoi inserire allegati
  • Non puoi modificare i tuoi messaggi
  •  
Powered by vBulletin® Version 4.2.1
Copyright © 2025 vBulletin Solutions, Inc. All rights reserved.