Dump e backup di un database con ASP

ASP E-Commerce con ASP Menu Javascript Ricette Cocktail Registrazione domini Area Aziende

Home + Articoli + Database e SQL + Articolo # 160

Concesso in esclusiva a Mr.Webmaster. Vietata la riproduzione.

Introduzione

Un'esigenza comune a chiunque gestisca un sito Web, o una qualsiasi applicazione in generale, è quella di salvaguardare i dati del proprio database. Allo scopo esistono sistemi di dump e di backup che, attraverso script ASP ed SQL, creano una copia dei dati e li mettono al sicuro. Lo scopo di questo articolo è quello di insegnare al lettore come creare da se un sistema di backup dei dati in ASP.

I database dell'applicazione

La soluzione migliore quando si vuole effettuare un backup di dati è quella di salvarli in un database esterno, diverso da quello di produzione. E' tuttavia possibile salvare i dati all'interno del database stesso, ma è una scelta sconsigliabile, dato che se a corrompersi o ad essere danneggiato fosse il database stesso e non una singola tabella, si finirebbe per perdere anche i backup fatti fino a quel momento. Altro motivo per cui è consigliabile avvalersi di due database è l'ordine, che in programmazione è indispensabile per vivere sereni.

I database di esempio sono MS Access.

Ipotizziamo dunque di avere il database di produzione di nome database.mdb (che fantasia...) in cui troviamo la tabella utenti, composta dai seguenti campi:

id - Contatore;
matricola - Numerico;
nome - Testo;
cognome - Testo.

Mentre il campo "id" è il contatore autoincrementale della tabella, il campo "matricola" serve ad assegnare univocamente all'utente un identificativo, su cui si baseranno tutti i calcoli dell'applicazione, a prescindere dalle operazioni di dump e backup dei dati.

Il database di backup si chiamerà backup.mdb (tanto per essere coerenti con la mancanza di fantasia) e sarà corredato, ovviamente, dalla stessa tabella con gli stessi campi del database di produzione.

Struttura dell'applicazione

Trattandosi di un sistema di salvataggio dei dati, ovvero di un qualcosa di tanto utile quanto riservato, è bene essere precisi in fase di analisi, al fine di creare un software sicuro e robusto nella sua semplicità. Il sistema presentato in questo articolo, infatti, è già pronto per l'uso!

Si crei la cartella dump sul proprio server Web e le si assegni i permessi in lettura ed in scrittura.

Segue l'elenco dei file ASP che compongono il front-end ed il back-end dell'applicazione:

config.asp - file di configurazione dell'applicazione, contenente le stringhe di connessione ai due database, nonchè le relative le funzioni di gestione delle connessioni;

default.asp - pagina di accoglienza del sistema di backup che presenta il modulo di login;

login.asp - file senza interfaccia che effettua l'autenticazione dell'utente amministratore, attraverso l'inserimento delle credenziali d'accesso: username e password;

dump.asp - pagina che, su specifica richiesta dell'amministratore attraverso un apposito bottone di comando, esegue quanto in oggetto in questo articolo.

Il file di configurazione dell'applicazione

Iniziamo dal file di configurazione della nostra applicazione di dump e backup dei dati, ovvero il file di back-end config.asp.

Segue il codice completo, in attesa di commentarlo a dovere:

<%
    Option Explicit
    On Error Resume Next
    Response.Buffer = True
    Response.Expires = 0
    ' ----- ----- ----- ----- -----
    Dim sc, cn, rs, cn_bk, rs_bk
    ' ----- ----- ----- ----- -----
    Function ConnOpen()
        sc = "driver={Microsoft Access Driver (*.mdb)};dbq="
        sc = sc & Server.MapPath("database.mdb")
        Set cn = Server.CreateObject("ADODB.Connection")
        Set rs = Server.CreateObject("ADODB.Recordset")
        cn.Open sc
    End Function
    ' ----- ----- ----- ----- -----
    Function ConnClose()
        Set rs = Nothing
        cn.Close
        Set cn = Nothing
    End Function
    ' ----- ----- ----- ----- -----
    Function BackupOpen()
        sc = "driver={Microsoft Access Driver (*.mdb)};dbq="
        sc = sc & Server.MapPath("backup.mdb")
        Set cn_bk = Server.CreateObject("ADODB.Connection")
        Set rs_bk = Server.CreateObject("ADODB.Recordset")
        cn_bk.Open sc
    End Function
    ' ----- ----- ----- ----- -----
    Function BackupClose()
        Set rs_bk = Nothing
        cn_bk.Close
        Set cn_bk = Nothing
    End Function
%>

Per semplificare la vita al lettore ho utilizzato dei commenti di separazione tra un'operazione e l'altra, operazioni che, per chiarezza, chiameremo "fasi".

La prima fase vede la specifica delle intestazioni della pagina: la dichiarazione obbligatoria delle variabili, la gestione degli errori e la gestione della cache.

La seconda fase vede la dichiarazione di tutte le variabili relative alle connessioni al database: "sc" racchiuderà le due stringhe di connessione; "cn" ed "rs" sono la Connection ed il Recordset di lavoro sul database di produzione; "cn_bk" ed "rs_bk" sono la Connection ed il Recordset di lavoro sul database di backup.

La terza e la quarta fase vedono, rispettivamente, la gestione dell'apertura della connessione e degli oggetti ADO utili relativi al database di produzione.

La quinta e la sesta fase vedono, come suppongo sarà intuibile, rispettivamente la gestione dell'apertura della connessione e degli oggetti ADO utili relativi al database di backup.

Nota

Anche se già pronto all'uso, quello di questo articolo rimane comunque un esempio puramente didattico. E' possibile notare che i due database, date le stringhe di connessione, si trovano all'interno della cartella "dump" che contiene i file ASP. Quando metterete in produzione quanto appreso in questa sede ricordate di spostare entrambi i database in una directory sicura del server Web che utilizzate. Sarà dunque opportuno modificare, di conseguenza, entrambe le stringhe di connessione.

Il modulo di login

Passiamo alla pagina di login, il file degault.asp che, oltre a contenere il suddetto modulo, rappresenta in qualche modo anche la Homepage dell'applicazione.

Vediamo il codice:

<%@LANGUAGE = VBScript%>
<html>
<head>
<title>Dump e backup di un database con ASP</title>
</head>
<body>

<h1>Login</h1>

<form method="post" action="login.asp">
    Username<br>
    <input type="text" name="username"><br><br>
    Password<br>
    <input type="password" name="password"><br><br>
    <input type="submit" value="Login">
</form>

</body>
</html>

Nulla più e nulla meno di un normale file HTML con un modulo che punta al file di login, che esamineremo a breve.

Esecuzione della fase di autenticazione

Passiamo al file di back-end login.asp che esegue l'autenticazione dell'utente amministratore di backup.

Segue il codice:

<%@LANGUAGE = VBScript%>
<%
    Dim username, password
    username = Server.HTMLEncode(Request.Form("username"))
    password = Server.HTMLEncode(Request.Form("password"))
    Dim u, p
    u = "demo"
    p = "demo"
    If username = u And password = p Then
        Session("admin")= "OK"
        Response.Redirect "dump.asp"
    Else
        Response.Redirect "default.asp"
    End If
%>

Il codice è semplice: recuperiamo le credenziali di accessi filtrandole per evitare il Cross Site Scripting (XSS); impostiamo le credenziali di accesso in due variabili (si è scelto di non usare un database per l'autenticazione) e confrontiamo i valori. Se c'è corrispondenza creiamo una sessione di controllo ed indirizziamo il richiedente presso la pagina di dump, altrimenti lo rimandiamo alla Homepage dell'applicazione.

Ecco come cambiare le proprie credenziali d'accesso:

u = "demo"
p = "demo"

Valorizzare con i dati che si preferisce le variabili "u" (username) e "p" (password).

Chiusura della sessione di lavoro

Per completezza creiamo anche il file di back-end logout.asp per chiudere la sessione di lavoro corrente.

Segue il codice:

<%@LANGUAGE = VBScript%>
<%
    Session.Abandon
    Response.Redirect "default.asp"
%>

Il suo compito è quello di distruggere tutte le variabili di sessione attive e di rimandare l'utente amministratore alla pagina di accoglienza dell'applicazione.

La pagina di dump e backup del database

Veniamo al cuore dell'applicazione, il file di front-end dump.asp.

Segue il codice completo, in attesa di commentarlo a dovere:

<%@LANGUAGE = VBScript%>
<!--#include file="config.asp"-->
<%
    If Session("ADMIN") <> "OK" Then
        Response.Redirect "default.asp"
    End If
    Dim backup
    backup = Request.QueryString("backup")
%>
<html>
<head>
<title>Dump e backup di un database con ASP</title>
</head>
<body>

<h1>Effettua il dump del database</h1>

<form method="post" action="dump.asp?backup=OK">
    <input type="submit" value="DUMP">
</form>

<a href="logout.asp">Logout</a><br><br>

<%
    If backup = "OK" Then
        Call ConnOpen()
        rs.Open "SELECT * FROM utenti ORDER BY id ASC", cn, 1
        If rs.EOF = False Then
            Call BackupOpen()
            cn_bk.Execute("DELETE * FROM utenti")
            rs_bk.Open "utenti", cn_bk, 3, 3
                While rs.EOF = False
                        rs_bk.AddNew
                            rs_bk("matricola") = rs("matricola")
                            rs_bk("nome") = rs("nome")
                            rs_bk("cognome") = rs("cognome")
                        rs_bk.Update
                    rs.MoveNext
                Wend
            rs_bk.Close
            Call BackupClose()
        End If
        rs.Close
        Call ConnClose()
        Response.Write "Operazione eseguita con successo!"
    End If
%>

</body>
</html>

Includiamo il file di configurazione per avere a disposizione le funzioni di apertura e chiusura ai due database.

Nel corpo della pagina creiamo un bottone di tipo "submit" in un modulo che, col metodo "post", invia i dati al file stesso, passando come parametro in querystring la variabile di controllo backup.

Torniamo all'intestazione della pagina. Oltre al doveroso controllo sulla sessione (che, se non attiva, rimanda l'utente alla pagina di accoglienza), recupera la querystring attraverso cui verrà effettuato il controllo.

Torniamo al corpo della pagina. Dopo il bottone piazziamo un semplice link che esegue il logout, come visto in precedenza.

Veniamo alla fase centrale dell'applicazione: lo script ASP.

Una volta verificato che il modulo è stato effettivamente inviato, procediamo con l'apertura della connessione al database di produzione e lanciamo una query che estrae tutti i campi dalla tabella interessata.

Verifichiamo che ci siano effettivamente dati e, in caso affermativo, apriamo la connessione al database di backup e come prima operazione svuotiamo la tabella di backup per poi ripopolarla.

L'operazione di popolazione della tabella di backup avviene attraverso il Recordset che accede in scrittura alla tabella utenti del database di backup ed inserisce (attraverso un ciclo) tutti i dati estratti dalla query sul database di produzione.

Non resta che chiudere le due connessioni e mostrare un messaggio di successo.