Il backup di linux

In questo ultimo periodo mi sto occupando di trovare un metodo di backup da implementare per il server che amministro. Ho dato un occhiata a diversi sistemi che consentono di effettuare l’operazione di backup dei dati, ma al momento non ho ancora scelto quello che fa per me. In più ho postato anche sul forum del sito debianizzati.org un’ottima risorsa per la comunità Debian con gente in gamba disponibile ad aiutare altri in difficoltà. Quindi essendo un’altro in difficoltà, ho deciso di scrivere sul forum chiedendo loro un parere, al fine di risolvere il problema e di creare un guida più o meno completa del problema del backup su linux.
Vi siete mai chiesti quale sia lo strumento di backup utilizzato da wikipedia ? Sinceramente sì, ma non so come possa essere implementato…mi vengono in mente cluster di server che fanno solo quello con tera e tera disponibili utilizzati per salvare i dati.
E riferiamoci proprio a Wikipedia per la definizione di backup: "Il backup, copia di sicurezza o copia di riserva in informatica indicano un’operazione atta a prevenire la perdita totale dei dati archiviati nella memoria di massa dei computer siano essi stazione di lavoro o server. L’attività di backup è un aspetto fondamentale della gestione di un computer: in caso di guasti, manomissioni, furti, ecc., ci si assicura che esista una copia dei dati, pertanto l’esecuzione del backup è quasi sempre automatica e svolta normalmente con una periodicità stabilita (per esempio una volta al giorno o alla settimana)."
Su Linux esistono diversi strumenti per effettuare il backup dei dati…uno di questi è dd, un tool che si usa da riga di comando mooolto potente. Nei prossimi articoli riguardanti questo argomento vedremo altri tool.

Il comando dd

Il comando dd permette di copiare i dati in blocchi, effettuando delle conversioni all’occorrenza. E’ molto facile da utilizzare, in sostanza è necessario indicare il valore di 2 parametri.

devme:~$ dd if=/dev/sda1 of=/media/backup.img

Nell’esempio di sopra è richiesto a dd di effettuare la copia della prima partizione dell’unità sda all’interno dell’immagine backup.img. Al termine, il file di immagine corrisponderà alla partizione sorgente e sarà possibile montarlo grazie al comando mount. Vedremo più avanti come.

devme:~$ dd if=/dev/sda of=/media/sdb

In questo caso invece viene effettuata il clone del disco sda all’interno del disco sdb. Si noti che la copia in questo caso prevede la copia eventuale anche del MBR , master boot record e dell’eventuale partizione di swap.
La sintassi base del comando dd è la seguente:

devme:~$ dd if=<source></source> of=<target> bs=<byte size=""> skip= seek= conv=<conversion> </conversion></byte></target>

Per effettuare l’operazione simmetrica, ovvero il ripristino dei dati da un backup, è sufficiente invertire il valore dei parametri if e of. Vediamo ora una serie di esempi di utilizzo del comando dd.

Effettua la duplicazione di una partizione in un’altra partizione, copiando i dati in blocchi da 4kb, effettuando le conversioni: notrunc=non troncare il file di output,noerror=non fermarti in caso di errore nella lettura di un blocco di dato.

devme:^$ dd if=/dev/sda2 of=/dev/sdb2 bs=4096 conv=notrunc,noerror

Crea un’immagine ISO di un cd, leggendo in blocchi da 2kb, effettuando le conversioni: sync fa padding dei blocchi letti con bye nulli, noerror non fermarti in caso di errore nella lettura di un blocco di dato.

devme:^$ dd if=/dev/hdb of=/home/devme/cdrom.iso bs=2048 conv=sync,notrunc

Crea un’immagine ISO di un cd, leggendo in blocchi da 2kb, effettuando le conversioni: sync fa padding dei blocchi letti con bye nulli, noerror non fermarti in caso di errore nella lettura di un blocco di dato. Successivamente sarà possibile montare l’immagine creata usando il comando mount.

devme:^$ dd if=/dev/hdb of=/home/devme/cdrom.iso bs=2048 conv=sync,notrunc
devme:^$ mount -o loop /home/devme/cdrom.iso /mnt/iso_images

Effettuare una cancellazione sicura a prova di bomba, ovvero senza la possibilità di poter risalire ai dati scritti (secure delete).

1
2

#!/bin/bash 
for n in `seq 7`; do dd if=/dev/urandom of=/dev/sda bs=8b conv=notrunc; done

Modo semplice e veloce per effettuare un backup del proprio portatile. Segue comando per effettuare il ripristino.

devme:^$ dd if=/dev/hda of=/dev/sda bs=64k conv=notrunc,noerror
devme:^$ dd if=/dev/sda of=/dev/hda bs=64k conv=notrunc,noerror

Crea il backup di un hard disk e memorizzalo all’interno di una serie di DVD. Seguono comandi per il ripristino.

devme:^$ if=/dev/sda3 of=/home/devme/dvd_set_1.img bs=1M count=4430
devme:^$ dd if=/dev/sda3 skip=4430 of=/home/devme/dvd_set_2.img bs=1M count=4430
devme:^$ dd if=/dev/sda3 skip=4430 of=/home/devme/dvd_set_3.img bs=1M count=4430
devme:^$
devme:^$ dd if=/media/devme/devme_set_1.img of=/dev/sda3 bs=1M conv=sync,noerror
devme:^$ dd if=/media/devme/devme_set_2.img of=/dev/sda3 seek=4430 bs=1M conv=sync,noerror
devme:^$ dd if=/media/devme/devme_set_3.img of=/dev/sda3 seek=4430 bs=1M conv=sync,noerror

Copia il master boot record, ma non la tabella delle partizioni.

devme:^$ dd if=/dev/sda of=/home/devme/devme_mbr.img bs=446 count=1

Vediamo ora un caso particolare, ovvero fare il backup completo di un disco, quindi con MBR, tabella delle partizioni e tutte le partizioni del disco, e vediamo come fare a selezionare solo la partizione da montare con il comando mount. Quindi supponiamo di avere:

devme:^$ dd if=/dev/sda of=my_disk_image.img

con il quale effettuiamo il backup creando il nostro file immagine my_disk_image.img che contiene al suo interno l’intero disco. Per montare solo una certa partizione dovremmo sapere l’offset in cui inizia la partizione e quindi montarla con il comando mount sul dispositivo di loop. Per determinare l’offset dei vari elementi costituenti il disco utilizziamo un’altro comando di linux che consente di far questo, parted. Lanciando parted sul file appena creato otteniamo:

devme:^$ parted my_disk_image.img
GNU Parted 1.7.1
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) unit
Unit?  [compact]? B
(parted) print
Sector size (logical/physical): 512B/512B
Partition Table: msdos
Number  Start        End           Size         Type     File system  Flags
1      32256B       106928639B    106896384B   primary  ext3         boot
2      106928640B   1184440319B   1077511680B  primary  linux-swap
3      1184440320B  10256924159B  9072483840B  primary  ext3
(parted) quit

a questo punto possiamo montare il file system che ci interessa indicando l’offset specifico, ovvero:

devme:^$ mount -o loop,ro,offset=32256 my_disk_image.img /mnt/devme

E qui mi fermo, anche perché potrei continuare per delle ore con degli esempi su dd, alcuni dei quali dimostrano quanto veramente potente è questo comando. Nei prossimi articoli vedremo altri strumenti per realizzare il backup.
Stay tuned !

Generative Programming: Domain Engineering

Secondo appuntamento con la programmazione generativa già discussa in precedenza in questo articolo sempre sulle pagine di DevMe. Ci eravamo lasciati parlando delle opportunità e delle comodità di cui gode la programmazione generativa, ovvero la creazione di programmi detti generatori capaci di creare, software specifici sulla base di una configurazione data in input. Il generatore è un programma in grado di generare una famiglia di altri programmi; la scelta del componente della famiglia è a carico della configurazione, ovvero del mezzo che discrimina un determinato componente da un altro. La configurazione può essere fornita in diversi modi: un file XML, un insieme di tabelle di un database, etc.
Quello di cui volevo parlare ora riguarda il Domain Engineering. Cos’è ? Partiamo dalla definizione: 
il Domain Engineering è l’attività di recuperare, organizzare e memorizzare l’esperienza maturata durante la costruzione di sistemi software o parti di sistemi di un particolare dominio, in modo tale che possa essere definita una forma di prodotto riutilizzabile, oltre a fornire un mezzo adeguato che descriva come fare a riutilizzare questi prodotti durante la costruzione di nuovi sistemi.
Ecco non spaventatevi….sebbene questa definizione possa sembrare incomprensibile, vedrete che analizzandola ci accorgeremo che è più semplice di quanto sembri.
I sistemi software che conosciamo possono essere classificati secondo la loro area di business, commercio elettronico, sistemi medicali, sistemi di prenotazione aerea, e così via. Chiamiamo queste aree Domini Verticali. Allo stesso modo possiamo classificare le parti di questi software sulla base della loro funzionalità, ad esempio i database, i sistemi di workflow, le librerie, etc. Chiamiamo queste parti di sistemi Domini Orizzontali.
Naturalmente questi sistemi o componenti all’interno di uno stesso dominio, condividono molte caratteristiche tra loro, e quando un’azienda che ha già lavorato ad applicazioni appartenenti ad uno stesso dominio, si trova a dover sviluppare di nuovo parti o sistemi dello stesso dominio, può trarre vantaggio da quanto già fatto riutilizzando il lavoro svolto. Qual è la parte difficile ? Ovviamente, cercare di trarre dalla conoscenza acquisita dal lavoro svolto, una forma che possa rendere quanto prodotto riutilizzabile, così da rimettere in campo componenti già sviluppati, e quindi già pronti. In questo modo l’azienda potrà produrre nuovi prodotti in minor tempo, a basso costo e di altà qualità.
Il Domain Engineering comprende:

• Domain Analysis
• Domain Design
• Domain Implementation

Il Domain Analysis consiste nel definire il focus del dominio, analizzarne le caratteristiche annotando quelle comuni, quelle variabili e le dipendenze all’interno della famiglia dei sistemi.
Il Domani Design consiste nel progettare il design di un’architettura comune costituita da un insieme di componenti elementari e altro, e del loro meccanismo automatico che permette di assemblarli.
Infine il Domain Implementation permette di implementare i componenti, definire la specifica e quindi il generatore.
Introduciamo ora quello che sarà l’esempio del prossimo articolo, ovvero un piccolo progettino che dimostra ancora una volta le potenzialità della programmazione generativa. Nell’ambito del mio lavoro, mi trovo spesso a sviluppare applicazione web in Java, tutti basata su Spring, ormai famoso framework di sviluppo, con il supporto di Spring Web Flow sottoprogetto di Spring utilizzato per lo sviluppo di Internet Rich Applications.
Prima osservazione: la struttura di un progetto Spring, almeno per quanto mi riguarda oramai è nota, o meglio detto in termini di Domain Engiinering, ha molte parti che accomunano i diversi progetti. Seconda osservazione: molti dei task implementati nell’ambito di applicazioni web, hanno in comune alcune funzionalità. Ad esempio, nell’ambito dello sviluppo di un RIA, classica di gestione clienti e fornitori, per ciascuna delle due entità dovremo fornire sempre le funzionaltià di inserimento, modifica e cancellazione. Bene, sulla base di queste osservazioni costruiremo una versione alpha del nostro generatore, che andremo via via migliorando. Al momento esiste già una versione alpha di questo generatore, non sono ancora riuscito a portarla a termine visto che il tempo che ho disposizione non è molto. Vedremo infine come la specifica di configurazione viene fornita mediante database, per la quale in futuro potrebbe essere sviluppata una piccola applicazione ad-hoc che permette di definirla in modo semplice.
Stay tuned !

Top 10 Wordpress tips 2009

Siamo alla fine del 2009 e come si fa in questi casi è tempo di bilanci. Volevo stilare una classifica dei migliori 7 tips (trucchi) per wordpress che ho usato e trovato in rete. Wordpress si sta affermando sempre più come piattaforma di blogging e CMS quindi spero risulti utile a chiunque visiti le pagine del mio sito.
 
 

1. Pubblicare un post su Wordpress dall’esterno di Wordpress

Questo tip è quello che mi è piaciuto più di tutti…non l’ho ancora mai provato ma sicuramente lo farò in futuro. Il codice che segue permette di pubblicare un post su wordpress dall’esterno di wordpress, utilizzando cURL ovvero delle librerie php che permettono di simulare un web browser…più precisamente permettono di utilizzare tra gli altri il protocollo HTTP facendo submit dei dati di un form ad esempio.
Per utilizzare questa funzionalità è necessario attivare XMLRPC all’interno del file php.ini presente nell’installazione di php. Se non la si attiva non sarà possibile inserire il contenuto dei post all’interno del database.
Vediamo il codice:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

function add_post_to_wordpress($title, $body, $rpcurl, $username, $password, $category, $keywords='', $encoding='UTF-8') {
    $title = htmlentities($title,ENT_NOQUOTES,$encoding);
    $keywords = htmlentities($keywords,ENT_NOQUOTES,$encoding);
 
    $content = array(
        'title'=>$title,
        'description'=>$body,
        'mt_allow_comments'=>0,  // 1 to allow comments
        'mt_allow_pings'=>0,  // 1 to allow trackbacks
        'post_type'=>'post',
        'mt_keywords'=>$keywords,
        'categories'=>array($category)
    );
    $params = array(0,$username,$password,$content,true);
    $request = xmlrpc_encode_request('metaWeblog.newPost',$params);
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_POSTFIELDS, $request);
    curl_setopt($ch, CURLOPT_URL, $rpcurl);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    curl_setopt($ch, CURLOPT_TIMEOUT, 1);
    $results = curl_exec($ch);
    curl_close($ch);
    return $results;
}

2. Visualizzare il numero di parole contenute in un post

E’ possibile contare il numero di parole che compongono un post per visualizzarlo, ad esempio, alla fine del post stesso. Basta aggiungere il seguente pezzo di codice all’interno del file function.php

1
2
3
4
5
6
7
8
9
10

function post_word_count(){
    /* Attiva l'output buffering */
    ob_start();
    /* Ottieni il contenuto del post */
    the_content();
    /* Preleva e ripulisci il contenuto del buffer */
    $content = ob_get_clean();
    /* Calcola il numero delle parole*/
    return sizeof(explode(" ", $content));
}

Al termine per richiamare la funzione è sufficiente effettuare la chiamata:

<?=post_word_count()?>

3. Ottenere la prima immagine di un post e visualizzarla

Questo tip è stato uno dei più quotati del 2009 dal sito WpRecipes. Dall’intero del contenuto di un post è possibile prelevare l’immagine contenuta al suo interno e visualizzarla.

1
2
3
4
5
6
7
8
9
10
11
12
13

function get_first_post_image() {
  global $post, $posts;
  $first_img = '';
  ob_start();
  ob_end_clean();
  $output = preg_match_all(\'//i\', $post->post_content, $matches);
  $first_img = $matches [1] [0];
 
  if(empty($first_img)){ //Defines a default image
    $first_img = "/images/default.jpg";
  }
  return $first_img;
}

Il codice di sopra va inserito all’interno del file function.php in modo che sia disponibile ai file del tema corrente. Al termine è possibile richiamarlo nel seguente modo:

1

<?=get_first_post_image()?>

4. Usare SSL per l’accesso al pannello di amministrazione

Per aumentare la sicurezza durante gli accessi al pannello di amministrazione di wordpress è possibile abilitare il protocollo SSL. SSL è un protocollo crittografico che permette una comunicazione sicura e integrità dei dati trasmessi su reti che utilizzano il protocollo TCP-IP, come internet. Per abilitarlo è sufficiente aggiungere la seguente riga di codice all’interno del file wp-admin.php:

1

define('FORCE_SSL_ADMIN', true);

5. Potenziare la funzionalità di ricerca

E’ possibile aumentare la potenzialità della ricerca integrata all’interno di wordpress evidenziando ad esempio i risultati trovati.

1
2
3
4
5
6

 $title = get_the_title();
 $keys= explode(" ",$s);
 $title = preg_replace('/('.implode('|', $keys) .')/iu',
	'<strong class="search-excerpt">\0</strong>',
	$title);
<br />

Il codice di sopra va inserito all’interno del file search.php del vostro tema corrente. Al termine aggiungete all’interno del vostro foglio di stile il codice per evidenziare i risultati della ricerca:

1

strong.search-excerpt { background: yellow; }

6. Override del nome dell’autore utilizzando un custom field

Se dal vostro blog permette la pubblicazione di post ad utenti guest, allora questo tip può esservi utile. In sostanza si tratta della creazione di un custom field che memorizza il nome dell’autore del post. Quindi in fase di visualizzazione del post se presente il custom field, si preleva il contenuto; altrimenti utilizzando la funziona predefinita di wordpress, si ottiene il nome dell’autore.
Vediamo come:

1
2
3
4
5
6

$author = get_post_meta($post->ID, "guest-author", true);
if ($author != "") {
    echo $author;
} else {
    the_author();
}

7. Riutilizzare i vecchi post

Questo tip permette di riutilizzare i vecchi post cercando di sfruttarli anche se sono stati pubblicare molto tempo fa. Per monetizzare i vecchi post è possibile ad esempio far comparire banner pubblicitari, ad esempio, solo se il post è più vecchio di 15 giorni.
Il codice che segue riconosce se il post è più vecchio di 15 giorni e in caso positivo aggiunge un banner pubblicitario.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

function is_old_post($post_id=null){
   $days = 15;
   global $wp_query;
   if(is_single() || is_page()) {
      if(!$post_id) {
         $post_id = $wp_query->post->ID;
      }
      $current_date = time();
      $offset = $days *60*60*24;
      $post_id = get_post($post_id);
      $post_date = mysql2date('U',$post_id->post_date);
      $cunning_math = $post_date + $offset;
      $test = $current_date - $cunning_math;
      if($test > 0){
         $return = true;
      }else{
         $return = false;
      }
   }else{
      $return = false;
   }
   return $return;
}

Il codice di sopra va inserito all’interno del file function.php in modo che sia disponibile ai file del tema corrente. Al termine è possibile richiamarlo nel seguente modo dall’interno del file singel.php:

1
2
3

<? if(is_old_post()){ ?>
INSERIRE IL CODICE QUI
<? } ?>

Stay tuned!

Generative Programming: yes !!

Oggi volevo parlare di un argomento che mi appassiona molto, ovvero della Generative Programming (Programmazione Generativa).
Mi piacerebbe molto dedicarmi a tempo pieno, ma ahimé il tempo è quello che è ! Cerchiamo di capire di cosa stiamo parlando, o meglio proviamoci.

La Programmazione Generativa è un paradigma di programmazione basato sulla modellazione di famiglie di sistemi software tali che, data una particolare specifica dei requisiti, è possibile generare su richiesta (on-demand) una versione definitiva del software personalizzata in modo automatico.
La programmazione generativa si concentra sulle famiglie di sistemi software piuttosto che su un tipo specifico di sistema. I singoli software appartenenti a famiglie di sistemi, possono essere generati a partire da un modello di dominio generativo (generative domain model), ovvero un modello di una famiglia di sistemi che ha 3 elementi:

1. un mezzo per la specifica dei singoli software
2. un insieme di implementations components capaci di costruire, assemblandoli, i singoli software
3. una specifica di configurazione, che mappa la specifica di un membro con la sua implementazione finale

Un’analogia la si ha quando si ordina un’automobile. C’è un sistema per ordinare l’automobile, ci sono i componenti con i quali si provvede ad assemblare (costruire) l’automobile ed infine c’è una specifica configurazione che indica come assemblare l’automobile secondo l’ordinazione richiesta.
Riepilogando, l’idea è generare in modo automatico singoli sistemi a partire da modelli di famiglie di sistemi. I componenti e la specifica di configurazione vengono riutilizzati per ogni membro generato, riducendo così il costo dello sviluppo per ogni singolo membro.
Esiste realmente un potenziale di riduzione dei costi di realizzazione di singoli software, perchè piuttosto che dover sviluppare da zero l’intero sistema, spesso basta aggiungere solo qualche funzionalità al modello generativo esistente. In sintesi è possibile praticare economie di scala utilizzando la programmazione generativa, riducendo sia i tempi che i costi dello sviluppo di un singolo software.
Non voglio annoiare con troppa teoria, quindi passiamo a vedere un esempio pratico che illustra le potenzialità della generazione automatica del codice, non prima di aver precisato che, prima di avventurarsi alla scrittura di un generatore è necessario effettuare una attenta analisi per determinare quali sono le caratteristiche comuni della famiglia dei software con cui si vuole operare. Questa analisi ha un nome preciso e si chiama: Domain Engineering.
Nell’ultimo post pubblicato su devme, abbiamo visto come rendere più chiara l’organizzazione dei custom fields di wordpress raggruppandoli semanticamente all’interno di un riquadro. L’articolo illustra il codice da scrivere per realizzare il raggruppamento, in particolare analizzando il codice generato si nota come alcune parti di esso sono statiche, o meglio non cambiano nelle varie implementazione; altre invece sono dinamiche, cioè cambiano sulla base di ciò che si sta creando. Vediamo più nel dettaglio. 
La prima parte di codice costituisce la definizione della struttura dati che mappa i custom fields che si vogliono raggruppare con il riquadro. Si definisce il nome del custom fields ed il titolo che comparirà in corrispondenza del campo all’interno del riquadro. La seconda parte consiste nella creazione di funzioni che riferiscono quanto dichiarato nella prima parte e creano il riquadro che verrà visualizzato, in termini di codice HTML, la logica che permette il salvataggio dei dati in fase di inserimento e modifica di un post. Infine si procede con la registrazione all’interno del framework del codice scritto.
Non mi soffermerò molto sul codice dal momento che l’articolo è esaustivo, piuttosto rendo disponibile il codice che realizza il generatore qui ampiamente commentato e la versione demo qui.
Nelle prossime puntate vedremo cosa vuol dire e come si realizza il Domain Engineering passaggio chiave per la realizzazione di software generatori.
Stay tuned.
 

Personalizzare il pannello di admin dei custom fields in Wordpress

Come avrei potuto non avere a che fare con Wordpress !? Provate un pò a dirmelo….il mitico CMS semplice da usare, gestire e facile da installare. Non ho mai parlato sul blog di wordpress, ne di quanto lo usi a lavoro..Tutti i giorni il caro inkiostro mi riempie sempre di nuovi e mirabolanti problemi da risolvere in wordpress, quindi mi sono fatto una discreta cultura.
Quello di cui volevo parlare è di come fare a rendere più chiara l’organizzazione dei custom field all’interno del pannello di amministrazione di wordpress, raggruppandoli semanticamente all’interno di un riquadro. Per intenderci dalla situazione in figura :

passare a questa:

 

Vediamo il codice php per realizzare quanto mostrato in figura:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

$box_dati_devme =
	array(
	    "titolo" => array(
	    "name" => "titolo",
	    "std" => "",
	    "title" => "Titolo",
	    "description" => ""),
 
	"url" => array(
	    "name" => "url",
	    "std" => "",
	    "title" => "URL",
	    "description" => ""),
 
	"argomento" => array(
	    "name" => "argomento",
	    "std" => "",
	    "title" => "Argomento",
	    "description" => ""));

Primo step: definire una variabile di tipo array in cui il primo elemento ha come chiave il nome del campo custom e come valore, un array che definisce il nome alcuni attributi del campo custom, nome, std, title e description.

1
2
3
4
5
6
7
8
9
10
11

function box_dati_devme_boxes() {
	global $post, $box_dati_devme;
	echo '';
	foreach($box_dati_devme as $meta_box) {
		echo '';
		echo '';
		echo '';
		echo '';
	}
	echo '<table style="width:99%"><tbody><tr><td class="left" style="width:25%;">'; 		$meta_box_value = get_post_meta($post->ID, $meta_box['name'], true); 		if($meta_box_value == "") 			$meta_box_value = $meta_box['std']; 		echo '<input type="hidden" name="'.$meta_box['name'].'_noncename" id="'.$meta_box['name'].'_noncename" value="'.wp_create_nonce( plugin_basename(__FILE__) ).'" />'; 		echo $meta_box['title']; 		echo '<br />'; 		echo '<label class="desc" style="font-size:10px;" for="'.$meta_box['name'].'_value">'.$meta_box['description'].'</label>'; 		echo '</td><td>'; 		echo '<textarea style="width:99%" rows="2" name="'.$meta_box['name'].'_value">'.$meta_box_value.'</textarea>'; 		echo '</td></tr></tbody></table>';
}

Secondo step: definire una funziona in cui l’unica cosa da fare è aggiungere come variabile globale dopo $post il nome della variabile definita allo step uno e la stessa variabile come iteratore del foreach.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

function create_meta_box() {
    global $theme_name;
 
    if ( function_exists('box_dati_devme_boxes') ) {
        add_meta_box('box_dati_devme', 'Boxe DevMe', 'box_dati_devme', 'post', 'normal', 'high');
    }
}
 
function save_postdata( $post_id ) {
	global $post, $box_dati_devme;
 
	foreach($box_dati_devme as $meta_box) {
		if ( !wp_verify_nonce( $_POST[$meta_box['name'].'_noncename'], plugin_basename(__FILE__) )) {
			return $post_id;
		}
		if ( 'page' == $_POST['post_type'] ) {
			if ( !current_user_can( 'edit_page', $post_id ))
				return $post_id;
		} else {
			if ( !current_user_can( 'edit_post', $post_id ))
				return $post_id;
		}
		$data = $_POST[$meta_box['name'].'_value'];
		if(get_post_meta($post_id, $meta_box['name']) == "")
			add_post_meta($post_id, $meta_box['name'], $data, true);
		elseif($data != get_post_meta($post_id, $meta_box['name'], true))
			update_post_meta($post_id, $meta_box['name'], $data);
		elseif($data == "")
			delete_post_meta($post_id, $meta_box['name'], get_post_meta($post_id, $meta_box['name'], true));
	}
}
 
add_action('admin_menu', 'create_meta_box');
add_action('save_post', 'save_postdata');

Terzo step: nell’ultimo step ho racchiuso un pò di cose tutte assieme. Si definiscono 2 funzioni : la create_meta_box e la save_postdata. La prima viene richiamata dal framework di wordpress per creare il riquadro, contestualmente si definiscono il nome del riquadro che comparirà poi in pagine e si aggiunge il riferimento alla variabile definita nello step uno. La funzione save_postdata viene usata da wordpress per effettuare il salvataggio dei custom field inseriti al momento dell’inserimento e della modifica di un post. Infine si registrano le 2 funzioni php con le add_action di wordpress.
E’ chiaro che in presenza di pochi custom field si può procedere anche senza personalizzare il pannello; al contrario, con un centinaio di campi il tutto diviene più chiaro. Consiglio nel caso usiate questa soluzione, di definire la personalizzare dei campi all’interno di un file .php che terrete all’interno del tema che state usando, quindi importarlo all’interno del file function.php.
Prova il generatore qui.
Stay tuned.