@unomichisiada:

Tutto in Java!

@magnus:

Non penso proprio: del resto un server deve essere in grado di gestire letture e scritture "simultanee", concorrenti e frequenti (se penso, ad esempio, alla realtà lavorativa in cui mi trovo, dove ogni giorno una trentina di utenti utilizzano lo stesso server pesantemente con operazioni di ogni genere + qualche altro migliaio di clienti sparsi in tutta italia accedono "indirettamente" allo stesso server per il sito...)

Non ho nessuna difficoltà a postare il codice del demone (la sua struttura, perlomeno):
codice:
import java.io.*;
import java.util.Vector;
import java.util.GregorianCalendar;

public class DemoneFatture extends Thread {

   private boolean attivo;                // Flag: indica se il demone è attivo o no
   private int tempo;                     // Millisecondi di attesa tra un controllo e l'altro
   private long intervallo;               // Millisecondi di attesa per rispetto orario di funzionamento
   private String monitor;                // Directory da monitorare
   private File tmpDir;                   // Directory temporanea
   private String [] contenuto;           // Contenuto della directory monitor al momento del controllo
   private boolean[] lock;                // Flags di lock per il file in 'contenuto'
   private Buffer buffer;                 // Buffer per lo Spazzino
   private GregorianCalendar oraInizio;   // Ora di inizio del monitoraggio
   private GregorianCalendar oraFine;     // Ora di fine del monitoraggio

   private PrintStream oldOut;
   private PrintStream newOut;

   private Fatture fat;

   public DemoneFatture(Fatture fat, String monitor, String oraInizio, String oraFine, Buffer buffer) {
      tempo = 1000;   // 1 secondo di attesa
      attivo = true;
      monitor = monitor.replaceAll("\\\\", "/");
      if (monitor.charAt(monitor.length()-1) != '/')
         monitor += "/";
      this.fat = fat;
      this.monitor = monitor;
      this.oraInizio = genera( oraInizio );
      this.oraFine = genera( oraFine );
      this.buffer = buffer;
      try {
         oldOut = System.out;
         newOut = new PrintStream( new java.io.FileOutputStream("logFileFatture.log") );
         System.setOut( newOut );
         System.setErr( newOut );
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   public void run() {
      try {
         tmpDir = new File("./tempFat/");
         if (!tmpDir.exists()) {
            if (!tmpDir.mkdir()) {
               System.out.println("Impossibile creare la directory temporanea!");
               attivo = false;
            }
         }
         while( attivo ) {
            if ( controllaOrario() ) {
               controllaDirectory();
               sleep(tempo);
            } else {
               System.out.println("-- Ora termine monitoraggio: " + stampaOra(new GregorianCalendar()));
               System.out.println("-- Ora prevista ripresa monitoraggio: " + stampaOra(oraInizio));
               sleep(intervallo);
            }
         }
      } catch (Exception e) {
         System.out.println("-- DEMONE FERMO --");
         e.printStackTrace();
      }
   }

   private String normalizza(int num) {
      return (num > 9) ? "" + num : "0" + num;
   }

   private String stampaOra(GregorianCalendar gc) {
      int ampm = gc.get(gc.AM_PM);
      int aggiunta = (ampm == gc.PM) ? 12 : 0;
      return "" + normalizza(gc.get(gc.HOUR) + aggiunta) + ":" + normalizza(gc.get(gc.MINUTE)) + ":" + normalizza(gc.get(gc.SECOND));
   }

   private GregorianCalendar genera(String ora) {
      int ore = Integer.parseInt( ora.substring(0, 2) );
      int minuti = Integer.parseInt( ora.substring(3, 5) );
      GregorianCalendar tmp = new GregorianCalendar();
      return new GregorianCalendar(tmp.get(tmp.YEAR), tmp.get(tmp.MONTH), tmp.get(tmp.DATE), ore, minuti);
   }

   private boolean controllaOrario() {
      boolean ret = false;
      GregorianCalendar gc = new GregorianCalendar();
      int ampm;
      long aggiunta = 0;
      ret = gc.before(oraFine) && gc.after(oraInizio);
      if ( !ret ) {
         ampm = gc.get(gc.AM_PM);
         if (ampm == gc.PM) aggiunta = (long) 12;
         long oreAttuali = gc.get(gc.HOUR) + aggiunta;
         long minutiAttuali = gc.get(gc.MINUTE);
         long secondiAttuali = gc.get(gc.SECOND);
         ampm = oraInizio.get(oraInizio.AM_PM);
         aggiunta = 0;
         if (ampm == oraInizio.PM) aggiunta = (long) 12;
         long oreInizio = oraInizio.get(gc.HOUR) + aggiunta;
         long minutiInizio = oraInizio.get(gc.MINUTE);
         long minutiDiff = 0;
         if ( gc.after(oraInizio) ) {
            minutiDiff = 1440 - (((oreAttuali * 60) + minutiAttuali) - ((oreInizio * 60) + minutiInizio));
         } else {
            minutiDiff = ((oreInizio * 60) + minutiInizio) - ((oreAttuali * 60) + minutiAttuali);
         }
         long secondiDiff = - secondiAttuali + 10;
         intervallo = ((minutiDiff * 60) + secondiDiff) * 1000;
      }
      fat.setStatoDemone( ret );
      return ret;
   }

   private void controllaDirectory() {
      String suffix = "";
      try {
         File dir = new File(monitor);
         if ( dir.exists() ) {
            contenuto = dir.list();
            lock = new boolean[contenuto.length];
            for (int j=0; j<lock.length; j++) lock[j] = !contenuto[j].endsWith(".lock");
            String fileOut = "";
            for (int i=0; i<contenuto.length; i++) {
               if ( !contenuto[i].endsWith(".lock") ) {
                  if ( !sposta(monitor+contenuto[i], tmpDir.toString()+File.separator+contenuto[i]) ) {
                     System.out.println("Impossibile creare il file temporaneo: "+(new File(tmpDir.toString()+File.separator+contenuto[i])).toString());
                     lock[i] = false;
                  } else {
                     suffix = contenuto[i].substring(contenuto[i].length()-6, contenuto[i].length()-4);
                     contenuto[i] = tmpDir.toString()+File.separator+contenuto[i];
                     if (suffix.toUpperCase().equals("_M")) FatturePDF.generaPDF(contenuto[i], "COPIA MITTENTE");
                     if (suffix.toUpperCase().equals("_D")) FatturePDF.generaPDF(contenuto[i], "COPIA DESTINATARIO");
                     if (suffix.toUpperCase().equals("_V")) FatturePDF.generaPDF(contenuto[i], "COPIA VETTORE");
                     if (suffix.toUpperCase().equals("_C")) FatturePDF.generaPDF(contenuto[i], "COPIA CONFORME");
                  }
               }
            }
            if (contenuto.length > 0) {
               Vector v = new Vector();
               for (int j=0; j<contenuto.length; j++) {
                  if (lock[j]) v.add( contenuto[j] );
               }
               String[] listaPassata = new String[v.size()];
               for (int j=0; j<listaPassata.length; j++) listaPassata[j] = (String) v.elementAt(j);
               buffer.aggiungi(listaPassata);
            }
         } else {
            System.out.println(stampaOra( new GregorianCalendar() ) + ": Directory inesistente.");
         }
      } catch (Exception e) {
         System.out.println("Errore individuato, ma ignorato:");
         e.printStackTrace();
      }
   }

   private boolean sposta(String src, String dst) throws Exception {
      boolean result = false;
      try {
         FileInputStream fis = new FileInputStream( src );
         FileOutputStream fos = new FileOutputStream( dst );
         byte [] buf = new byte[fis.available()];
         int letti = fis.read( buf );
         if (letti > 0) {
            fos.write( buf );
            fos.flush();
            fos.close();
            fis.close();
         }
         if ( (new File(src)).delete() ) {
            result = true;
         } else {
            (new File(dst)).delete();
         }
      } catch (IOException ioe) {
         result = false;
      }
      return result;
   }

   public void ferma() { attivo = false; fat.setStatoDemone( false ); }
}
Non posto la classe FatturePDF: prende un file e genera un PDF (oltre a fare altre cose)

Non posto nemmeno la classe Spazzino (poco interessante): è un thread che si occupa di cancellare i temporanei quando il programma di generazione PDF ha finito di utilizzarli.


Cosa fa: monitora una ditrectory (remota). Quando trova un file lo copia in locale e lo cancella dalla remota. Quindi lo elabora.
Il tutto viene temporizzato: la sua creazione richiede il passaggio di un orario di inizio e un orario di fine funzionamento + un puntatore ad una finestra che riceve dei messaggi.


Ciao.