mercoledì 30 giugno 2010

SWT Virtual Table, libpango e lo strano crash dell'applicazione...

Dopo un sacco di tempo speso nel debugging di una applicazione RCP, sono riuscito a scoprire la causa, abbastanza subdola, di uno strano crash che sembrava essere dovuto da libpango.
La mia applicazione utilizza una serie di tabelle SWT in modalità virtual, quindi con un rendering delle righe fatta su richiesta a seconda della visualizzazione del componente grafico. E qui entra in gioco libpango che si occupa della visualizzazione del testo in Gnome (e quindi su sistemi *nix). Ogni tanto ahimé capitava che l'applicazione andasse in crash con il blocco totale della JVM e uno stack libpango seguito da un dump completo della memoria.
Ebbene ecco la causa:
  1. essendo la tabella in modalità virtual, ogni volta che doveva disegnare una nuova riga si entra in uno stack nativo (SWT si appoggia ai componenti nativi grafici)
  2. la tabella richiama un handler Java per ottenere i dati da visualizzare
  3. nel mio caso l'handler utilizza JDBC/Spring per recuperare un dato da un database
  4. la connettività genera un'eccezione
  5. l'eccezione produce un errore nello stack nativo, che a sua volta produce un crash nella libreria libpango e quindi il blocco della JVM
Rimuovendo l'eccezione nell'handler Java (ovvero gestendo opportunamente gli errori) sono giunto alla eliminazione del crash. 
Ovviamente, come si evince dalla trattazione, scoprire questo problema non è stato per niente banale a causa dello stack nativo e del suo wrapping attorno al vero problema lato Java che si veniva a generare.

martedì 29 giugno 2010

Eclipse Product: interactive splash screen non visibile nel prodotto esportato

Dopo diverse prove e controprove sono finalmente riuscito a capire come mai un mio prodotto RCP non mostrava lo splash screen interattivo nella sua versione esportata mentre lo mostrava se lanciavo direttamente il prodotto dall'IDE. Il problema è dovuto all'assenza del nome del plugin che definisce lo splash screen, che nel mio caso coincideva con il plugin principale del prodotto stesso. In una simile condizione, l'avvio tramite IDE va a richiamare in automatico lo splash screen poiché trovato all'interno del plug-in stesso, mentre il prodotto finito non sa da quale plug-in prelevare lo splash screen e quindi non lo visualizza. Certo sarebbe molto piu' semplice uniformare il meccanismo di caricamento e risoluzione fra IDE e prodotto finito, o quantomeno inserire dei warning per simili sviste....

giovedì 24 giugno 2010

Pl/Java: patch per cancellare l'operazione in corso da un trigger

Lo scorso weekend ho lavorato un po' sul codice di Pl/Java per studiare se fosse possibile cancellare una operazione in atto (statement) tramite un oggetto di tipo TriggerData. Dai test che ho effettuato posso affermare di aver raggiunto lo scopo! La patch aggiunge un paio di metodi all'interfaccia TriggerData, in particolare cancelCurrentStatement e isCurrentStatementCancelled. Questi due metodi vanno ad impostare un flag che ordina poi all'oggetto TriggerData di resituire un valore che viene interpretato come NULL al backend PostgreSQL. Così facendo si ottiene che il backend annulla l'operazione corrente. 

La patch non si conclude qui: ho anche fatto in modo che eventuali ResultSet ottenuti dopo che l'operazione è stata impostata come "cacellata" siano sempre e solo in lettura. I ResultSet ottenuti prima saranno in lettura/scrittura (ovviamente si parla di quelli new) ma ciò non costituisce un problema visto che poi l'operazione verrà comunque cancellata dal backend. Avere però un ResultSet in sola lettura aiuta a mantenere coerente l'interfaccia verso l'utente.

La patch è inserita nella coda e la si può trovare qui, dove è anche disponibile un semplice trigger per testarne il funzionamento.

pfSense & Timezone: problemi al firewall

pfSense ha un problema di sincronizzazione dell'orologio di sistema quando si cambia TimeZone: in sostanza se viene cambiata l'ora di sistema si ha che quasi tutti i processi si allineano alla nuova ora, mentre il filtro/firewall no. Questo potrebbe produrre alcuni problemi quando si hanno delle regole di filtro basate sul tempo (ossia con uno scheduler). Come spiegato qui, è bene riavviare l'intero firewall per aggiustare il tempo.

martedì 22 giugno 2010

ITPug @ CONFSL: parte 4

E' disponibile on-line il resoconto della partecipazione di ITPug alla CONFSL 2010 a Cagliari; dalla pagina è inoltre possibile scaricare le slide presentate.



Ancora una volta ringrazio gli organizzatori per la loro disponibilità, precisione e competenza.

lunedì 21 giugno 2010

Etags & PostgreSQL

etags è la versione per Emacs del programma ctags, lo scopo di entrambi è quello di indicizzare una serie di file sorgenti (tipicamente C, ma anche di altri linguaggi) per consentirne la navigazione da un editor testuale come vi oppure emacs. Mediante etags è possibile indicizzare l'intero albero dei sorgenti PostgreSQL per potervi navigare comodamente da Emacs. Purtroppo però, visto il numero elevato di sorgenti del progetto, etags non può essere lanciato con find sulla riga di comando, ovvero il seguente porterà ad una indicizzazione scorretta e imparziale:

etags `find . -name "*.c" - o -name "*.h"`

Si deve quindi usare find come comando principale, passando per ogni file trovato il controllo ad etags avendo cura di specificare il flag di append per non distruggere l'indicizzazione dei file trovati in precedenza. Quindi, ipotizzando di essere già dentro alla directory dei sorgenti, si può eseguire:

find `pwd` -name "*.c" -o -name "*.h" -print | xargs etags --append

e nella directory di lavoro verrà creato il file TAGS che contiene (in formato binario) l'indice da usare come Emacs. A questo punto s può aprire un qualunque file sorgente, posizionarsi sopra ad un simbolo e premere la combinazione di tasti ALT + . per saltare alla definizione del simbolo. Ovviamente Emacs non sa quale file di tag deve usare, così la prima volta che si effettuerà la combinazione di cui sopra chiederà quale file di tag deve aprire, e ovviamente occorre specificare il file appena creato.

venerdì 18 giugno 2010

Pl/Java & Eclipse: importare il progetto in Eclipse e usarlo con Git

Pl/Java è un linguaggio procedurale che sfrutta Java all'interno del database PostgreSQL; l'idea è quella di poter usare/riutilizzare codice Java all'interno del backend PostgreSQL. Ho tenuto una dettagliata presentazione del linguaggio e del suo funzionamento interno alla CONFSL 2010.
Dare un'occhiata ai sorgenti di Pl/Java è un ottimo esercizio di programmazione, ma purtroppo come per altri progetti PostgreSQL-related, i sorgenti sono disponibili su un archivio CVS! Se come me non amate molto CVS e preferite sistemi piu' flessibili, come ad esempio Git, ecco i passi da fare per caricare il progetto in un vostro repository locale con tutta la storia (è necessario abbiate CVS, git-cvs e Eclipse con relativo plugin egit installati).
Per prima cosa creiamo il repository e scarichiamo i sorgenti e la storia dal repository CVS:
mkdir pljava-git

cvs -d :pserver:anonymous@cvs.pgfoundry.org:/cvsroot/pljava login

cd pljava-git && git cvsimport -v -d :pserver:anonymous@cvs.pgfoundry.org:/cvsroot/pljava org.postgresql.pljava

Il processo richiederà circa 10 minuti, a seconda anche della banda disponibile. Al termine avrete all'interno della directory pljava-git il repository locale sul quale lavorare.
Non resta quindi che importare il tutto in Eclipse: avviate la procedura di import di un nuovo progetto, scegliete Git come tipo di progetto e specificate la directory appena popolata. Ovviamente non dovete creare un progetto nuovo, ma un progetto esistente a partire dall'albero dei sorgenti.


A questo punto avete pieno accesso al repository anche da Eclipse e potete iniziare a navigare nel codice e a sviluppare!

WhiteCat @ CTS 2010

WhiteCat has been presented as a poster at CTS 2010, where people appeared really interested in this dynamic role framework. It is a small step for WhiteCat to grow and become more visibile, but it is an important one: as much as the framework gains in popularity, the much its adoption and improvement will happen!
Here there is an image of the poster that can be used to understand at a glance the WhiteCat architecture and idea.



lunedì 14 giugno 2010

Una storia di licenze...

Una cosa che noto sempre piu' spesso, ahimé, è come si tenda a confondere il software OpenSource con il Free Software e con Linux, quasi sempre chiamato Gnu/Linux per enfatizzarne la libertà (mah!). A volte anche io abuso del termine e mi riferisco a Gnu/Linux, anche se cerco di evitare, come cerco di essere tollerante nei confronti di chi mi riferisce aneddoti su Gnu/Linux, dopotutto ognuno ha il diritto ad avere le proprie idee.
Partiamo da un assunto fondamentale: il termine Gnu/Linux è per me sbagliato, come pure sembra sbagliato per l'inventore del kernel stesso, Linus Torvalds. Perché per me è sbagliato? Per una considerazione molto semplice, che è il significato della parola GNU, che rispettivamente potrebbe essere:
  • il nome di un'azienda, come nel caso di Microsoft Windows, ma tutti sanno che questo non è il caso, quindi in questo senso anteporre il termine GNU al termine Linux è sbagliato;
  • il nome di un ente o associazione che ha composto una specifica distribuzione Linux, come nel caso di Red Hat Linux. Questo è uno schema dei nomi per me lecito, quindi se GNU produce una sua distribuzione Linux allora ha (per me) tutto il diritto di chiamarla Gnu/Linux;
  • il nome della licenza con la quale è rilasciato il software, che è il caso concreto. E se è vero che la FSF voglia esplicitamente acquisire popolarità con il nome di Linux, è altrettanto vero che non trovo riscontri analoghi in altri progetti simili. Avete mai sentito parlare di "Gnu MySQL" o di "Gnu KDE" o di "BSD PostgreSQL" o "CDDL OpenSolaris", per non parlare del quasi palindromo "BSD FreeBSD"? Io non li ho mai sentiti, quindi mettere il nome della licenza davanti al nome del prodotto non appare la priorità della FSF, che invece nel caso di Linux ci tiene ad aprire la sua coda di pavone in tutto il suo splendore.
  • l'ente o la fondazione che ha dettato le linee guida per la definizione del progetto stesso. Questo è il caso per esempio di Apache Tomcat (Apache è il nome della fondazione che guida il progetto, e per certi versi anche il nome della licenza), ma non è sicuramente il caso di Linux. Sicuramente Linux non sarebbe il sistema completo che è oggi senza l'aiuto di Gnu e dei suoi prodotti, ma da qui a dire che tutto il sistema è Gnu si esagera. Anche perché se così fosse, dovremmo citare ogni singolo partner che ha contribuito alla creazione di Linux così come è oggi, quindi probabilmente avremmo nomi di distribuzioni che suonano piu' o meno come Canonical-IBM-Apache-Gnu-Linux e chi piu' ne ha piu' ne metta.
Perché è importante comprendere il posto (assente) e il peso (importante) della parola Gnu associata alla parola Linux? Perché troppo spesso si considera che Free Software e Open Source siano la stessa cosa, e troppo spesso si uniscono le due sotto al cappello di Gnu, considerando tutto il resto come "maligno" e non degno di nota, anche se di fatto possa essere sviluppato come prodotto Open Source. Il FreeSoftware è software scritto secondo le linee guida della Free Software Foundation, mentre l'OpenSource è semplicemente una cultura piu' semplice che richiede solo di poter fornire i sorgenti a chi ne faccia richiesta, e che ovviamente chi disponga dei sorgenti possa produrre versioni modificate del prodotto.
Di fatto nel tempo mi sono convinto che la licenza GNU, che comunque continuo ad utilizzare per alcuni miei piccoli progetti, non sia nemmeo quella corretta da usare per promuovere l'OpenSource. Oggi penso che BSD sia la licenza migliore, invecchiando potrei anche cambiare idea e riconsiderare la GPL (o passare addirittura alla MIT). Perché la BSD è così buona? Dopotutto un prodotto OpenSource rilasciato con licenza BSD può essere fatto proprio da una azienda che poi lo rivende come prodotto proprietario, e magari non piu' OpenSource. E quindi? Che problema c'è? Supponiamo di avere un buon prodotto OpenSource con licenza BSD, ed essendo io del "partito", consideriamo PostgreSQL. Diciamo anche che un'azienda si appropria dei sorgenti di PostgreSQL per creare un prodotto proprietario e non OpenSource chiamato GodDB. Cosa potrebbe succedere? Penso a solo tre casi possibili:
  • GodDB è realmente innovativo, aggiunge funzionalità e performance che la versione community PostgreSQL non puo' neanche lontanamente immaginare e che non sa come fare a implementare. In questo caso è giusto che gli sforzi e gli investimenti dell'azienda siano ripagati, e quindi pagati tramite la licenza dell'azienda stessa.
  • GodDB non ha nulla di innovativo rispetto a PostgreSQL, e quindi non ha senso pagare delle licenze quando si può avere lo stesso motore database gratuitamente. In questo caso l'azienda che ha sviluppato il database faticherà a non fallire.
  • GodDB viene rilasciato OpenSource, e quindi tutte le funzionalità eventualmente innovative possono essere migrate dalla versione a pagamento a quella community. Ne consegue che l'azienda deve differenziarsi ad esempio sui servizi accessori o le consulenze.
Al di là di come finisca l'ipotetica storia di GodDB, la vera essenza della storia è che l'uso di una licenza BSD-like spinge verso una forte competitività: la comunità dovrà dimostrare di tenere il passo delle aziende, e queste ultime di tenere il passo (o andare piu' veloci) di volontari ed esperti di tutto il mondo. E in tutto questo la BSD ha anche favorito la nascita dell'azienda dietro a GodDB senza vincolarla o forzarla a rilasciare i propri progetti come di pubblico dominio, quindi permettendogli di entrare nel business piu' agevolmente. Ne consegue che io personalmente non sono spaventato da prodotti con licenza BSD o simile, anzi li vedo come progetti molto coraggiosi e sicuri delle proprie capacità di riuscita anche contro aziende con poteri economici sicuramente superiori. GNU invece tende ad imporre modelli e schemi di condotta, rilascio e business; ma questa è una scelta forzata e come tutte le cose forzate non va bene.
E ne consegue anche che ritengo piu' importante l'OpenSource del Free Software: se si sviluppa OpenSource la libertà è solo una conseguenza, non una imposizione!

Infine una considerazione doverosa dopo aver letto un'articolo di Nuccio Cantelmi su come "Linux puo' uccidere Gnu Linux". L'articolo si potrebbe riassumere così: Linux è una piattaforma libera, ma il cloud-computing spinto in particolare da Google trasforma Linux in una piattaforma che usa solo applicazioni che scambiano dati con applicazioni non libere (es. GMail). 
E quindi? Trovo questo ragionamento abbastanza contorto e tendenzioso. Nel Web 2.0 l'importante non sono le applicazioni, ma i dati. Se anche le applicazioni di Google fossero tutte Free Software (visto che l'articolo cita la GPL), chi avrebbe la potenza di calcolo di eseguire tali applicazioni (run the software è una delle quattro libertà della GPL)? E soprattutto a me interessa il fatto che sul tuo computer/mainframe/rack/cluster girino applicazioni non Free Software? Eticamente mi potrebbe dispiacere, ma fino a quando mi eroghi il servizio che ti richiedo e io posso accedere al servizio con protocolli e software liberi io sono in pace con me stesso. L'importante è che io possa accedere ai dati secondo le modalità pattuite. Altrimenti cosa facciamo, non accettiamo le e-mail che non sono spedite da Sendmail o Postfix perché non sono inviate tramite software libero? Le applicazioni sono e resteranno sempre importanti, ma quello che conta oggi sono i dati, e se i cultori del Free Software non cominceranno a concentrarsi anche su quelli rimaranno sempre una generazione indietro rispetto al mondo IT.

domenica 13 giugno 2010

La differenza fra la realtà e la finzione

All'aeroporta di Roma sono stato colpito da un cartellone pubblicitario particolare, non fosse altro per via di quel nome scritto in rosso...




La pubblicità è piuttosto chiara: uomo + macchina = eroe; software + hardware = completezza. Il messaggio non è nemmeno tanto criptico: con l'acquisizione di Sun Oracle si ritrova ad avere il parco hardware (sicuramente di tutto rispetto) e una dotazione software ottima per poter costruire il resto dello stack web che a Oracle mancava. Sono state spese un sacco di parole su questo argomento, ma il risultato finale è che mentre Sun vendeva hardware con a bordo una dotazione software (ad esempio PostgreSQL, MySQL) anche libero (l'importante era vendere l'hardware), Oracle ha messo le mani su ciò che gli mancava per diventare hero (sarà stato l'uomo o la macchina?). E adesso, a mio avviso, non vede l'ora di chiudere il cerchio producendo uno stack iron blindato e inattaccabile.

ITPUG @ CONFSL: parte 3

Torno a casa soddisfatto dalla CONFSL: ho conosciuto persone molto intelligenti e preparate su praticamente ogni argomento riguardasse il FLOSS, nonché penso che sia io che ITPug in generale ci siamo apprezzare e abbiamo mostrato la nostra competenza e la nostra passione.
Complimenti a tutti gli organizzatori della conferenza, che oltre ad essere stati molto disponibili, si sono rivelati anche molto simpatici.

Infine, devo sottolineare come gli organizzatori stessi ci abbiano riportati i complimenti per la "maratona" fatta e il buon livello tecnico raggiunto.

sabato 12 giugno 2010

ITPUG @ CONFSL: parte 2

Seconda parte del resoconto della partecipazione di ITPug alla conferenza CONFSL. Come era possibile aspettarsi, nel pomeriggio l'affluenza è diminuita, ma le sessioni tenute da me e Gabriele sono comunque state interessanti e ben seguite. Io ho fatto prima il merge di tre concetti Java & PostgresSQL: JDBC, il driver di PostgreSQL e per la prima volta Pl/Java. Successivamente Gabriele ha presentato l'High Availability di PostgreSQL in modo molto chiaro e dettagliato.
Considerando che le sessioni ITPug sono state messe in parallelo al JUG Meeting, l'affluenza delle sessioni PostgreSQL è stata piu' che buona. Certo la concomitanza delle sessioni ha penalizzato l'affluenza, ma mi ha fatto molto piacere notare come tutti i partecipanti siano usciti dalla sessione con la chiara concezione della potenza e versatilità di PostgreSQL.

GitCast

Ho scoperto quasi per caso, anche se è ben visibile nella sezione di documentazione del sito ufficiale di Git, un sito che contiene una serie di mini cast sull'utilizzo delle varie componenti di Git: gitcast.

Partizioni in FreeBSD: il concetto di slice

FreeBSD non partiziona i dischi seguendo lo schema "classico" di Linux o MS-DOS, ma utilizza un concetto differente: le slice.
Una slice è da intendersi come una normale partizione, ossia su un disco formattato ci possono essere al massimo 4 slice. All'interno delle slice ci possono essere quante partizioni si vuole, seguendo il concetto di disklabel. L'idea è questa: una slice rappresenta una delle quattro partizioni primarie di un disco, all'interno della slice posso avere differenti partizioni (logiche a questo punto). Le slice sono sempre numerate (ad esempio s1) mentre le partizioni sono sempre identificate da lettere (ad esempio a). Quindi la prima partizione (in senso FreeBSD) potrebbe essere la s1a, ovvero la prima partizione logica che si trova nella prima partizione primaria. Il disklabel è l'informazione sulle partizioni interne di FreeBSD, visto che le slice sono memorizzate nella normale tavola delle partizioni del disco. Il disklabel è un file che si trova all'inizio della partizione primaria (slice) e che contiene un array di partizioni (logiche) FreeBSD. E' facile rendersi conto di questo analizzando i sorgenti del comando bsdlabel (che consente di visualizzare/modificare la tabella delle partizioni estese di FreeBSD). In particolare si ha che il file che viene letto è all'inizio del disco stesso:

static int
readlabel(int flag)
{
 uint32_t lba;
 int f, i;
 int error;

 f = open(specname, O_RDONLY);
 if (f < 0)
  err(1, specname);
 if (is_file)
  get_file_parms(f);
 else {
  mediasize = g_mediasize(f);
  secsize = g_sectorsize(f);
  if (secsize < 0 || mediasize < 0)
   err(4, "cannot get disk geometry");
 }
 if (mediasize > (off_t)0xffffffff * secsize)
  errx(1,
      "disks with more than 2^32-1 sectors are not supported");
 (void)lseek(f, (off_t)0, SEEK_SET);
 if (read(f, bootarea, BBSIZE) != BBSIZE)
  err(4, "%s read", specname);
 close (f);
 error = bsd_disklabel_le_dec(
     bootarea + (labeloffset + labelsoffset * secsize),
     &lab, MAXPARTITIONS);
 if (flag && error)
  errx(1, "%s: no valid label found", specname);

 if (is_file)
  return(0);

 /*
  * Compensate for absolute block addressing by finding the
  * smallest partition offset and if the offset of the 'c'
  * partition is equal to that, subtract it from all offsets.
  */
 lba = ~0;
 for (i = 0; i < lab.d_npartitions; i++) {
  if (lab.d_partitions[i].p_size)
   lba = MIN(lba, lab.d_partitions[i].p_offset);
 }
 if (lba != 0 && lab.d_partitions[RAW_PART].p_offset == lba) {
  for (i = 0; i < lab.d_npartitions; i++) {
   if (lab.d_partitions[i].p_size)
    lab.d_partitions[i].p_offset -= lba;
  }
  /*
   * Save the offset so that we can write the label
   * back with absolute block addresses.
   */
  lba_offset = lba;
 }
 return (error);
}
Come si vede la lseek posiziona il prossimo punto di lettura all'inizio della partizione primaria corrente. Da qui poi si legge una certa mole di dati equivalenti ad una struct C che si trova nel file header:

struct disklabel {
 u_int32_t d_magic;  /* the magic number */
 u_int16_t d_type;  /* drive type */
 u_int16_t d_subtype;  /* controller/d_type specific */
 char   d_typename[16]; /* type name, e.g. "eagle" */

 char      d_packname[16]; /* pack identifier */

   /* disk geometry: */
 u_int32_t d_secsize;  /* # of bytes per sector */
 u_int32_t d_nsectors;  /* # of data sectors per track */
 u_int32_t d_ntracks;  /* # of tracks per cylinder */
 u_int32_t d_ncylinders;  /* # of data cylinders per unit */
 u_int32_t d_secpercyl;  /* # of data sectors per cylinder */
 u_int32_t d_secperunit;  /* # of data sectors per unit */

   /* filesystem and partition information: */
 u_int16_t d_npartitions; /* number of partitions in following */
 u_int32_t d_bbsize;  /* size of boot area at sn0, bytes */
 u_int32_t d_sbsize;  /* max size of fs superblock, bytes */
 struct partition {  /* the partition table */
  u_int32_t p_size; /* number of sectors in partition */
  u_int32_t p_offset; /* starting sector */
  u_int32_t p_fsize; /* filesystem basic fragment size */
  u_int8_t p_fstype; /* filesystem type, see below */
  u_int8_t p_frag; /* filesystem fragments per block */
  u_int16_t p_cpg; /* filesystem cylinders per group */
 } d_partitions[MAXPARTITIONS]; /* actually may be more */};


Come si nota la struttura, oltre a contenere i dati di base del disco (geometria, ecc.) contiene un array di partizioni, che altro non sono che le partizioni logiche di FreeBSD. Da notare che ogni partizione contiene l'offset, la dimensione e il filesystem, che sono le stesse informazioni, presentate in modo testuale, da bsdlabel.


ITPUG @ CONFSL: parte 1

L'Italian PostgreSQL Users Group (ITPug) ha partecipato alla CONFSL (CONFerenza nazionale sul Software Libero) di Cagliari presentando diversi workshop e tutorial su PostgreSQL.
Durante la mattina io ho tenuto un talk introduttivo/storico su PostgreSQL, che ha presentato la storia del progetto, le informazioni per il primo utilizzo e configurazione di base per poi passare al funzionamento di dettagli interni (WAL, c_log, pagine dati, CTE, window functions).
Gabriele Bartolini, a fine mattina, ha presentato un talk sull'utilizzo di PostgreSQL combinato a strumenti di Business Intelligence (BI).
La partecipazione durante la mattina è stata buona, anche se l'affluenza poteva sicuramente essere maggiore, e qui forse è complice il bel tempo che ha spinto molte persone a recarsi al vicinissimo mare. Ad ogni modo il pubblico ha partecipato attivamente con domande interessanti e non banali.
Nella seconda parte della giornata terrò un ulteriore talk su Java & PostgreSQL, coprendo lo standard JDBC e i dettagli del driver PostgreSQL, nonché l'estensione del database con il linguaggio Pl/Java.

venerdì 11 giugno 2010

Upgrade Ubuntu: sistema nuovamente "rotto"

Basta!
Sono stufo di questi upgrade di Ubuntu gestiti male. Sia chiaro, Ubuntu  una grande distribuzione, ma sta esagerando. Non c'è upgrade che non corrompa la configurazione di X; certo i tool automatici riescono a riconfigurare bene X e l'accelerazione hardware, ma è una rottura dover reboottare a causa di questo.
E inoltre nel passaggio da 9.4 a 10.04 mi sono trovato il mio Eclipse 3.5 (64 bit) con rcp non piu' funzionante, ed ho perfino aperto un bug ufficiale come suggeritomi. Risultato? Comincio seriamente ad odiare la politica delle distribuzioni Linux...

pfSense e migrazione DHCP

pfSense è un'ottima distribuzione firewall, ma che anziché basarsi sui file di configurazione classici dei demoni e dei servizi, salva la propria configurazione in un file XML che viene letto e interpretato dalla interfaccia PHP/Web e che viene poi tradotta nei file di configurazione di ogni servizio. 
Se da un lato questo è utile, dall'altro la migrazione da una piattaforma diversa da pfSense ad una pfSense richiede un editing manuale della configurazione o la conversione dei file di configurazione in un formato XML-compatibile. Io ho creato un piccolo e semplice script Perl che consente di migrare le porzioni di mapping statico ARP-IP di un file dhcpd.conf nel formato XML. Lo script è pubblico e disponibile direttamente nel forum di pfSense.