@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. 
Permessi di invio
Rispondi quotando