Per esempio, in Fedora 12, l’ultima release disponibile è la 1.6.6 (ultima) mentre su Centos 5.3 (usata molto sui server per l’hosting e servizi web) c’è la 1.4.2.

Questo è molto limitativo in quanto nell’ultima versione hanno migliorato molto il codice e la velocità, nonché il supporto per altri protocolli.

Di seguito uno script per eseguire la compilazione diretta di subversion dai suoi sorgenti.

#installiamo, se ce ne fosse bisogno, i compilatori
yum install -y gcc make

#rimuoviamo l’eventuale versione attuale
yum remove subversion

#prima di dare l’ok per l’eliminazione, controllare se non ci siano dipendenze tipo mod_svn per apache
#se esse ci sono bisogna rimuovere il pacchetto tramite ‘rpm’ in questo modo:
# rpm -e `rpm -qa | grep subversion`

#prima di procedere, bisogna installare le librerie openssl-devel per i certificati di sicurezza
yum install -y openssl openssl-devel

#cominciamo spostandoci nella cartella adibita (non è detto ai sorgenti
cd /usr/src

# scarichiamo ed estraiamo l’ultima versione di subversion
wget http://subversion.tigris.org/downloads/subversion-1.6.6.tar.gz
tar zxvf subversion-1.6.6.tar.gz
cd subversion-1.6.6

# scarichiamo, estraiamo e spostiamo il pacchetto delle dipendenze
wget http://subversion.tigris.org/downloads/subversion-deps-1.6.6.tar.gz
tar zxvf subversion-deps-1.6.6.tar.gz
mv subversion-1.6.6/* .
rm -rf subversion-1.6.6

#configuriamo zlib (non lo compiliamo adesso)
cd zlib/
./configure –shared
cd ..

#compiliamo subversion
./configure  –prefix=/usr CPPFLAGS=”-Izlib/ -Lzlib/” –with-ssl
make
make install

La scelta di questo tool è molto semplice e (a volte) obbligata se la macchina in questione ha poca RAM.

Infatti molti scelgono di monitorare il tutto tramite omreport di Dell (parte della suite OpenManage) che sicuramente è il migliore tool di monitoraggio locale per i controller RAID (e non solo) in quanto, oltre a controllare lo stato dei dischi, restituisce molte più informazioni su tutto l’hardware della macchina (e del RAID stesso).

Purtroppo la compilazione di questo tool, a volte, può essere macchinosa su sistemi operativi CentOS, in particolare sulla versione 5.3.

Infatti la compilazione richiede il pacchetto kernel-devel ma, dopo numerosi test effettuati, non contiene (almeno la versione sui mirror ufficiali) alcune librerie LSI.

Per ovviare a questo problema possiamo adoperare rpmbuild ed il sorgente del kernel nella versione src.rpm.

Ho riassunto, in breve, tutti i comandi da lanciare per compilare correttamente mpt-status su CentOS ad ogni aggiornamento di kernel.

yum install rpm-build redhat-rpm-config unifdef -y
cd ~
rm -rf ~/rpmbuild
mkdir -p rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
echo ‘%_topdir %(echo $HOME)/rpmbuild’ > .rpmmacros
rm -f kernel-`uname -r`.src.rpm
wget http://mirror.centos.org/centos/5/updates/SRPMS/kernel-`uname -r`.src.rpm
rpm -i kernel-`uname -r`.src.rpm
rm -f kernel-`uname -r`.src.rpm
cd ~/rpmbuild/SPECS
rpmbuild -bp –target=`uname -m` kernel-2.6.spec 2> prep-err.log | tee prep-out.log
cd /usr/src
rm -rf mpt-status-1.2.0
wget “http://freshmeat.net/urls/7a85a1d3af8efa1dbe086c142f773164″ -O mpt-status-1.2.0.tar.gz
tar zxvf mpt-status-1.2.0.tar.gz
cd /usr/src/mpt-status-1.2.0
make KERNEL_PATH=~/rpmbuild/BUILD/kernel-`uname -r | cut -d “-” -f1`/linux-`uname -r | cut -d “-” -f1`.`uname -m`
make install
mknod /dev/mptctl c 10 220
modprobe mptctl

Per chi invece ha un sistema x86 e non ha tempo da dedicare alla compilazione, puo’ sempre trovare l’rpm qui disponibile, appunto, solo per sistemi 32bit.

Le cause sono le più disparate ma, quella più gettonata (specie chi acquista una VPS di basso livello e con poco spazio disco), è la terminazione dello spazio sulla partizione di MySQL (in genere la /var).

Oltre a tutti i problemi (scrittura logs, down dei servizi, etc.) è quasi inevitabile che alcune tabelle dei database, rimaste aperte da processi attivi nel momento stesso della saturazione del disco, vengano corrotte.

Se le tabelle sono in INNODB, allora bisogna solo recuperarle da un backup. Se invece il motore utilizzato è MyISAM, allora possiamo tentare (il più delle volte ci si riesce) un recovery della stessa tabella.

Il primo passo da effettuare (naturalmente dopo aver liberato spazio disco), è quello di eseguire il seguente comando con il servizio MySQL attivo:

mysqlcheck nome_database -c -r

Sostituendo nome_database con il nome del vostro database.

Se avete molti database e non sapete quali siano effettivamente corrotti, possiamo usare lo stesso comando con opzioni diverse per fare il repair su tutti i database del server:

mysqlcheck -A -r

Se in questo modo non si riesce a riparare la tabella, allora possiamo adottare un’altra tecnica.

Ipotizziamo che:

• La cartella dei database di MySQL è /var/lib/mysql/
• Il database con la tabella corrotta si chiami mio_db
• La tabella corrotta si chiami mia_tabella

Allora possiamo stoppare MySQL ed entrare nella cartella fisica del database, dove troviamo per ogni tabella il suo equivalente file .MYI.

Da qui possiamo effettuare un repair a freddo:

cd /var/lib/mysql/mio_db ; myisamchk -r mia_tabella.MYI

Il tempo di repair dipende dalla grandezza della tabella.

Ora possiamo avviare di nuovo MySQL e vedere se la tabella è stata recuperata effettivamente.

In genere, per reimpostare tale password, basta entrare in single user mode in due modi (a seconda dell’installazione che si ha di debian):

1. nel grub, selezionare il secondo kernel con nella descrizione (single user mode);
2. nel grub, selezionare il kernel attivo e premere sulla tastiera il tasto e che sta per edit. Successivamente selezionare la linea del kernel (la seconda in genere) e premere di nuovo e (edit) e aggiungere alla fine della riga la sigla single. Premere invio e successivamente la lettera della tastiera b (boot).

Nei due casi, bootando, verrà effettuato il boot della macchina escludendo tutti i servizi non essenziali (compresa la rete) e verrà visualizzata da subito una shell bash in utenza root senza bisogno di aver messo la password.

Questo ci permetterà di effettuare un passwd root per cambiare la password.

Alcune volte, questo può non poter bastare.

Nel caso in cui, entrando in single user non verrà aperta la shell senza password, possiamo aggiungere un ulteriore parametro al kernel. Seguiamo lo stesso passo (2):

• nel grub, selezionare il kernel attivo e premere sulla tastiera il tasto e che sta per edit. Successivamente selezionare la linea del kernel (la seconda in genere) e premere di nuovo e (edit) e aggiungere alla fine della riga la sigla (esclusi gli apici)  ‘single init=/bin/bash’. Premere invio e successivamente la lettera della tastiera b (boot).

Ciò ci porterà alla situazione descritta precedentemente e cioè con una bash root senza login.

Nel caso in cui, nell’eseguire il comando passwd root la shell non ci permette di modificare la password con la restituzione dell’errore “Authentication token busy“, possiamo dare un comando prima del passwd in modo da montare la partizione di root in lettura-scrittura (in quanto molto probabilmente è in sola lettura): mount -o remount,rw /

Successivamente ridiamo il comando passwd root e possiamo, finalmente, cambiare la nostra password di root.

Il tutto lato-client (in javascript appunto) senza programmare particolari script php che trasformano le stringhe di testo puro nelle entità HTML equivalenti (per esempio i caratteri accentati come le lettere “ò”,”à”,”è”…).

L’installazione e la personalizzazione è estremamente semplice, corredato da un wiki molto completo e pagine di esempi con tutte le possibile personalizzazioni dello script.

Si sa, però, che javscript è lato-client e non può essere utilizzato per effettuare upload su server se non tramite ajax o popup che hanno dietro pagine php programmate per effettuare tali uploads. Ciò rappresenta un problema se abbiamo la necessità di effettuare l’upload e il ridimensionamento di immagini ed inserirle all’interno dell’editor tinymce.

In giro ci sono alcuni plugin per tinymce che fanno questa cosa ma, purtroppo, molti sono a pagamento.

Risolviamo il problema utilizzando uno script open source di nome Ajax File Manager.

Tale script è a se stante e, di base, non vengono fornite spiegazione per integrarlo a TinyMCE, ma viene fornito solamente un pacchetto con TinyMCE e Ajax File Manager incluso.

Il problema del pacchetto è che viene fornito con TinyMCE v. 2.1.2 e Ajax File Manager v. 0.9. Domanda: come facciamo ad avere l’ultima versione di TinyMCE (3.08) e Ajax File Manager (1.0 RC 1)?

Ecco qui come integrare AFM 1.0 Rc1 nella versione 3.08 di TinyMCE.

Scarichiamo l’ultima versione di TinyMCE dalla pagina http://tinymce.moxiecode.com/download.php, scompattiamolo nella root-dir della nostra applicazione (per es. public_html/). Avremo così la cartella public_html/tiny_mce/.

Scarichiamo l’ultima versione di Ajax File manager dalla pagina http://www.phpletter.com/DOWNLOAD/ e scompattiamo il file nella cartella public_html/tiny_mce/plugins/. Avremo così la cartella public_html/tiny_mce/plugins/ajaxfilemanager/.

Per prima cosa impostiamo correttamente il file public_html/tiny_mce/plugins/ajaxfilemanager/inc/config.base.php con i giusti parametri (login, formato file, percorsi).

In particolare, i percorsi ipotizzando che il nostro dominio si chiami www.miodominio.it e le immagini le uploadderemo nella cartella public_html/img con chmod a 777 (avremo anche una cartella session in public_html/session con chmod a 777 per la cache):

/* ……… */
define(‘CONFIG_SYS_DEFAULT_PATH’, ‘../../../img/’);
define(‘CONFIG_SYS_ROOT_PATH’, ‘../../../img/’);
define(‘CONFIG_SYS_FOLDER_SHOWN_ON_TOP’, true);
define(“CONFIG_SYS_DIR_SESSION_PATH”, ‘../../../session/’);
/* ……… */
define(‘CONFIG_WEBSITE_DOCUMENT_ROOT’, ‘/home/utente/public_html/’);
/* ……… */

“Tutti” i percorsi devono avere il percorso relativo alla posizione public_html/tiny_mce/plugins/ajaxfilemanager/ .

Fatto questo possiamo impostare il nostro TinyMCE con le chiamate di callback dovute.

L’esempio di configurazione, di seguito, è standard: leggendo il codice possiamo personalizzarlo come vogliamo.

Nella pagina del form con un input testuale multilinea con l’ipotetico nome id=”input_txt” inseriamo nei tags <script></script> il seguente codice:

<script>
tinyMCE.init({
mode : “textareas”,
theme : “advanced”,
plugins : “inlinepopups,advimage,media”,
theme_advanced_buttons1 : “bold,italic,underline,separator,strikethrough,justifyleft,justifycenter,justifyright,justifyfull,bullist,numlist,undo,redo,link,unlink,image,removeformat,anchor,blockquote,code”,
theme_advanced_buttons2 : “”,
theme_advanced_buttons3 : “”,
file_browser_callback : “ajaxfilemanager”,
theme_advanced_toolbar_location : “top”,
theme_advanced_toolbar_align : “left”,
theme_advanced_statusbar_location : “bottom”,
width : “676″,
height : “300″,
extended_valid_elements : “a[name|href|target|title|onclick],img[class|src|border=0|alt|title|hspace|vspace|width|height|align|onmouseover|onmouseout|name],hr[class|width|size|noshade],font[face|size|color|style],span[class|align|style]“,
apply_source_formatting : true,
relative_urls : false,
remove_script_host : false,
document_base_url : “<?=SITE_URL?>”,
languages : “it”,
theme_advanced_resize_horizontal : false,
theme_advanced_resizing : true,
convert_newlines_to_brs : false,
force_br_newlines : false,
force_p_newlines : false
});
function ajaxfilemanager(field_name, url, type, win) {
var ajaxfilemanagerurl = “http://www.miodominio.it/tiny_mce/plugins/ajaxfilemanager/ajaxfilemanager.php”;
switch (type) {
case “image”:
ajaxfilemanagerurl += “?type=img”;
break;
case “media”:
ajaxfilemanagerurl += “?type=media”;
break;
case “flash”: //for older versions of tinymce
ajaxfilemanagerurl += “?type=media”;
break;
case “file”:
ajaxfilemanagerurl += “?type=files”;
break;
default:
return false;
}
var fileBrowserWindow = new Array();
fileBrowserWindow["file"] = ajaxfilemanagerurl;
fileBrowserWindow["title"] = “Ajax File Manager”;
fileBrowserWindow["width"] = “782″;
fileBrowserWindow["height"] = “440″;
fileBrowserWindow["resizable "] = “yes”;
fileBrowserWindow["inline"] = “yes”;
fileBrowserWindow["close_previous"] = “no”;
tinyMCE.activeEditor.windowManager.open(fileBrowserWindow, {
window : win,
input : field_name
});

return false;
}

</script>

Come potete vedere, abbiamo inserito nell’init di TinyMCE il richiamo alla funzione di callback file_browser_callback : “ajaxfilemanager” che fa riferimento alla funzione che abbiamo creato subito dopo.

Da notare che la variabile ajaxfilemanagerurl nella funzione ajaxfilemanager deve contenere l’url assoluto al file ajaxfilemanager.php.

Fatto questo possiamo caricare la pagina con il form via web e cliccare, quando abbiamo bisogno di inserire un’immagine, sull’icona IMMAGINE di tinymce e, successivamente quando ha caricato la popup del gestore immagini, clicchiamo sull’icona di fianco a Image Url e si aprirà la finestra di Ajax File Manager.

Se non esiste, creiamo la cartella /usr/local/apache/conf/userdata/std/2/UTENTE/DOMINIO.EST/
Possiamo sostituire “std” con “ssl” se vogliamo modificare il virtualhost “solo” per l’ssl.
Se usiamo apache 1.x dobbiamo cambiare il “2” con “1“.

Creiamo un file di nome user.conf (o di qualsiasi altro nome, l’importante è che risulta l’estensione .conf).

In questo file mettiamo le direttive specifiche per questo dominio in modo che prende le variabili personalizzate del php.ini da un altro file.

Nell’esempio, vogliamo attivare il register_globals solo per questo dominio.
Il mod_suphp permette di personalizzare questo path con la direttiva “suPHP_ConfigPath“:

### /usr/local/apache/conf/userdata/std/2/UTENTE/DOMINIO.EST/user.conf

<IfModule mod_suphp.c>
suPHP_ConfigPath /usr/local/Zend/register-enabled
</IfModule>

In questo modo, riavviando apache (non lo facciamo ora pero’), il virtualhost andra’ a cercare il php.ini dentro la directory /usr/local/Zend/register-enabled creata ad hoc:

mkdir -p /usr/local/Zend/register-enabled
touch /usr/local/Zend/register-enabled/php.ini

Nel file /usr/local/Zend/register-enabled/php.ini metteremo, quindi, la direttiva per l’attivazione di register_globals:

## /usr/local/Zend/register-enabled/php.ini
register_globals = On

Prima di riavviare apache, dobbiamo istruirlo per far includere i files appena creati.
Per fare questo lanciamo il seguente comando:

/scripts/ensure_vhost_includes –user=UTENTE

Al termine, possiamo riavviare apache e il lavoro e’ finito.

Per curiosita’ e verifica, possiamo editare /usr/local/apache/conf/httpd.conf e vedere nel virtualhost del dominio se effettivamente le modifiche hanno avuto effetto.
Possiamo notare:

Include “/usr/local/apache/conf/userdata/*.conf”
Include “/usr/local/apache/conf/userdata/*.owner-root”
Include “/usr/local/apache/conf/userdata/std/*.conf”
Include “/usr/local/apache/conf/userdata/std/*.owner-root”
Include “/usr/local/apache/conf/userdata/std/2/*.conf”
Include “/usr/local/apache/conf/userdata/std/2/*.owner-root”
Include “/usr/local/apache/conf/userdata/std/2/UTENTE/*.conf”
Include “/usr/local/apache/conf/userdata/std/2/UTENTE/DOMINIO.EST/*.conf”

Stiamo parlando dell’abilitazione di Spamassassin per tutti gli account in un solo colpo.

E’ vero che abbiamo nella sezione “Exim configuration editor” la possibilità di flaggare “SpamAssassin: Enable for all users without the option for users to shut off per account”: questo fa si che venga abilitato spamassassin su tutti gli account, ma è anche vero che disabilita di fatto il pulsante “Disable spamassassin” nel singolo cPanel dell’utente impedendo a quest’ultimo di scegliere se abilitarlo o meno.

Spizzando il forum di cPanel ho trovato un post molto interessante che ho testato personalmente.

Creiamo su /root/ il file enabless.sh con questo contenuto:

#! /bin/sh
M_FILENAME=$1
#echo $M_FILENAME
M_USERNAME=`find $M_FILENAME -printf %f`
#echo $M_USERNAME

touch /home/$M_USERNAME/.spamassassinenable
chown $M_USERNAME.$M_USERNAME /home/$M_USERNAME/.spamassassinenable
touch /home/$M_USERNAME/.spamassassinboxenable
chown $M_USERNAME.$M_USERNAME /home/$M_USERNAME/.spamassassinboxenable

echo $M_USERNAME complete
echo

Impostiamo il chmod del file a 700.

Lanciamo questo comando:

find /var/cpanel/users -type f -exec /root/enabless.sh {} \;

Questo creerà per ogni account utenti i files .spamassassinenable e .spamassassinboxenable ciò che serve per abilitare automaticamente spamassassin.

Bene, i vostri problemi sono finiti

Mod_rewrite mette a disposizione numerosi strumenti per bloccare le richieste tramite referer. Questo è uno:

RewriteEngine On
RewriteCond %{HTTP_REFERER} ^http://12.163.72.13 [NC]
RewriteRule .* – [F,L]

In pratica blocchiamo l’accesso (via referer) alle nostre pagine dal sito con indirizzo IP 12.163.72.13.
Possiamo bloccare anche l’accesso tramite host:

RewriteEngine On
RewriteCond %{HTTP_HOST} arcor-ip.net$ [NC]
RewriteRule .* – [F,L]

Mettete il tutto nell’.htaccess del vostro sito ed il gioco è fatto.

via | bhatt.id.au

Se ci sono siti progettati male (e, credetemi, ce ne sono!) molti programmatori non fanno attenzione ad ottimizzare le proprie query.

La situazione che si crea, è quella di trovarsi il load alto della macchina e, facendo un mysqladmin proc da root, ci troviamo di fronte una marea di query in sleep.

Ho aggirato il problema, facendo questo script che posto di seguito.

In pratica ad intervalli di tempo stabiliti (di default ogni 60 secondi) killa le query in sleep che sono, appunto, in sleep per più di 60 secondi.

Ma passiamo al codice.

File: mysql_sleep_query_kill.php

// Mysql sleep kill

//                     * coded by morphey (morphey@morphey.org)

//

// AVVISO: deve essere avviato via cron come utente "root" (uid=0)

// ottimizzato per cPanel

// Configurazione: ___________________________|

// $sleep_time = Impostare i secondi dopo i quali, se la query e' in sleep, si killera' automaticamente la query

$sleep_time = "60";

// $times = Impostare quante volte eseguire lo script | 0 = infinito (rimane in bg)

$times = 1;

// $times_sleep = Impostare quanto tempo far passare prima dell'avvio di un ciclo

$times_sleep = "1";

// $file_log = Impostare il file di log (percorso "assoluto" compreso) | sara' utilizzato per l'invio delle email

$file_log = "/var/log/mysql_kill_query.log";

$database_skip = array();

// $database_skip[] = Impostare i database da far saltare al controllo

$database_skip[] = "eximstats";

$database_skip[] = "horde";

//___________________________________|

function scriviLog($somecontent) {

global $file_log;

$filename = $file_log;

if (!is_file($filename)) { shell_exec("touch ".$filename." ; chmod 777 ".$filename); }

if (!is_writable($filename)) { shell_exec("chmod 777 ".$filename); }

$handle = fopen($filename, 'a');

fwrite($handle, $somecontent."\n");

fclose($handle);

}$active_times = 0;

while ($active_times<=$times) {

$out = shell_exec("mysqladmin proc");

$c = 0;

foreach (explode("\n",$out) as $linea) {

if (!eregi("-+-",$linea)) {

if ($c!=0) {

$arr = explode("|",trim($linea));

if ($arr[1]!="") {

$time = intval(ltrim(rtrim($arr[6])));

settype($time,"integer");

$id = ltrim(rtrim($arr[1]));

$user = ltrim(rtrim($arr[2]));

$database = ltrim(rtrim($arr[4]));

$command = ltrim(rtrim($arr[5]));

$state = ltrim(rtrim($arr[7]));

$query = ltrim(rtrim($arr[8]));

echo "ID->".$arr[1]." | Time->".$arr[6]." | User->".$arr[2]." | Query->".$query;

if ($time>=$sleep_time) {

$check_db = 0;

foreach ($database_skip as $db_skip) {

if ($database==$db_skip) { $check_db = 1; }

}

if ($check_db!=1) {

// struttura dei log

// id,user,database,command,state,times,query

scriviLog(date("d-m-Y_G.i.s",time()).",".$id.",".$user.",".$database.",".$command.",".$state.",".$time.",".$query);

shell_exec("mysqladmin kill ".$arr[1]);

echo " ==> killed!";

}

}

echo "\n";

}

} else { $c++; }

}

}

if ($times!=0) { $active_times++; }

if ($times!=0) {

if ($active_times<$times) {

sleep($times_sleep);

echo "[sleep->".$active_times."] for ".$times_sleep." seconds...\n";

}

}

}

?>

Per semplificare le cose, questo è il codice da lanciare a mano da root:

cd /root ; rm -rf morphtool ; mkdir morphtool ; cd morphtool
wget http://wiki.morphey.org/images/8/8b/Mysql_sleep_query_kill.zip
unzip Mysql_sleep_query_kill.zip ; rm -f Mysql_sleep_query_kill.zip
rm -rf php.ini ; touch php.ini
echo "* * * * * cd /root/morphtool ; php -c php.ini mysql_sleep_query_kill.php > /dev/null &" >> /var/spool/cron/root

This article in english version

Installazione dei seguenti moduli:

• Subversion client
• Subversion server
• Modulo di svn in apache

Per effettuare tale operazione, basta seguire questi passi:

#install perl-URI and subversion client/lib
wget “ftp://rpmfind.net/linux/redhat/9/en/os/i386/RedHat/RPMS/perl-URI-1.21-7.noarch.rpm”
yum -y install subversion
cd /var/
mkdir -p repo/source/
svnadmin create /var/repo/source
#install apache
cd /usr/src/
rm -rf httpd*
wget “ftp://mirror.nohup.it/apache/httpd/httpd-2.2.6.tar.gz”
tar zxvf httpd-2.2.6.tar.gz
cd httpd-2.2.6
./configure –prefix=/usr/local/apache_svn –with-port=2080 –enable-dav –enable-dav-fs –enable-proxy –enable-rewrite –enable-so –with-included-apr
make
make install
#install apr and apr-util
cd /usr/src/
rm -rf apr*
wget “http://apache.panu.it/apr/apr-1.2.12.tar.gz”
tar zxvf apr-1.2.12.tar.gz
cd apr-1.2.12
./configure
make
make install
cd /usr/src/
wget “http://apache.panu.it/apr/apr-util-1.2.12.tar.gz”
tar zxvf apr-util-1.2.12.tar.gz
cd apr-util-1.2.12
./configure –with-apr=/usr/local/apr/
make
make install
#install subversion
yum info subversion | grep “Version:” | cut -d ” ” -f 2-2
cd /usr/src/
rm -rf subversion*
wget http://subversion.tigris.org/downloads/subversion-`yum info subversion | grep “Version:” | cut -d ” ” -f 2-2`.tar.gz
tar zxvf subversion-*
cd subversion-*
./configure –with-apxs=/usr/local/apache_svn/bin/apxs –with-apr=/usr/local/apr/ –with-apr-util=/usr/local/apr/
make
make install

A seguito, far partire apache: /usr/local/apache_svn/bin/apachectl start
Quando ci serve un reposity svn basta mettere gli entry in httpd.conf dell’apache appena installato, del tipo:

<location>

DAV svn
SVNPath /var/repo/source
AuthzSVNAccessFile /var/repo/conf/svnpolicy
AuthType Basic
AuthName “Imthiaz Subversion repository”
AuthUserFile /var/repo/conf/svnusers
Require valid-user

</location>

Howto ottimizzato e modificato rispetto all’originale.