1. Copiate il pkg dell’installazione sul Desktop (o nel percorso che preferite)
2. Fate tasto destro sul pkg->mostra contenuto pacchetto
3. Entrate nella directory Contents -> Resources
4. Editate con Textedit o quello che preferite (MA NON FATE doppio click) il file postinstall
5. modificate la riga 2:
   • da: chown -R $USER:$USER “$2/SSHKeychain.app”
   • a: chown -R $USER:`id -gn` “$2/SSHKeychain.app”
6. salvate il file ed uscite
7. cliccate due volte sul file pkg e fate ripartire l’installazione

voilà! fatto.

Gio

Sicuramente una condizione ottimale per ottenere prestazioni migliori della propria web app o del proprio sito web è impostare il cosidetto Far Future Expire Header degli elementi prensenti nelle pagine e delle pagine stesse.

In questo post cercherò di descrivere alcune tecniche per impostare tale condizione.

Cito dal sito di YSlow:

Web page designs are getting richer and richer, which means more scripts, stylesheets, images, and Flash in the page. A first-time visitor to your page may have to make several HTTP requests, but by using the Expires header you make those components cacheable. This avoids unnecessary HTTP requests on subsequent page views. Expires headers are most often used with images, but they should be used on all components including scripts, stylesheets, and Flash components.

Quindi in pratica che fa?:-)

L’Expire Header definisce la scadenza dell’oggetto che il browser preleva dal server e deposita nella cache del client. Impostando la “data di scadenza” ad un periodo molto lontano (Far Future per l’appunto) diciamo al browser di non richiamare più tale componente durante le succesive visite alla pagina che lo conteneva, rendendo di fatto la navigazione più veloce. Inoltre, applicando questa tecnica ad elementi comuni a tutte le pagine (es: background o file javascript o file css) l’utente usufruirà dei benefici di questa tecnica fin dalla seconda pagina che andrà a visualizzare sul nostro sito.

Vediamo come fare.

Tramite l’uso di .htaccess (Apache)

1
2
3

<FilesMatch "\.(ico|pdf|flv|jpg|jpeg|png|gif|js|css|swf|php|html|htm|php4|php5)$">
Header set Expires "Thu, 2 Feb 2010 20:00:00 GMT"
</FilesMatch>

con l’istruzione FileMatch indichiamo a quale tipo di file applicare le regole all’interno del blocco di codice e con “Header set Expires” andremo a dire ad Apache di servire il contenuto indicato con una data di scadenza molto lontana. Nell’esempio ho usato il 2 Febbraio 2010, alle 8 di sera.

Tramite le impostazioni di IIS 6.0

1. Aprite il pannello di controllo di Internet Information Services (IIS).
2. Espandete “LocalMachine” sul pannelo di sinistra e succesivamente cliccate su Web Sites
3. Click con il tasto destro sul sito interessato e selezionate Properties.
4. Nel tab HTTP Headers, attivate la checkbox “Enable Content Expiration” e succesivamente selezionate l’opzione “Expire On”. e impostare il 2 Febbraio 2010 alle 8 di sera
5. Riavviate tutti i servizi IIS.

Con PHP
File far_future_loader.php

1
2
3
4
5
6

<?php
header("Content-type: text/javascript; charset: UTF-8");
header("Cache-Control: must-revalidate");
header("Expires: " . gmdate("D, d M Y H:i:s",time() + (60 * 60 * 24 * 3)) . " GMT");
include(dirname(__FILE__).'/scripts.js');
?>

con il codice sopra potete, ad esempio, raggruppare tutti i vostri file javascript in un unico grande file .php, modificare l’header Content-type in modo che venga interpretato correttamente dal browser come text/javascript e poi modificarne a piaciemento la deata di scandenza.
Successivamente nell’header delle vostre pagine, anzichè includere i singoli file javascript con l’istruzione:

1

<script type="text/javascript" src="js/scripts.js"></script>

userete

1

<script type="text/javascript" src="js/far_future_loader.php"></script>

Potete usare il file far_future_loader.php per ogni tipo di file, semplicemente cambiano il Content-type dei file che andrete ad includere, ad esempio, se volete averne uno anche per i file .css dovrete scrivere:

1
2
3
4
5
6

<?php
header("Content-type: text/css; charset: UTF-8");
header("Cache-Control: must-revalidate");
header("Expires: " . gmdate("D, d M Y H:i:s",time() + (60 * 60 * 24 * 3)) . " GMT");
include(dirname(__FILE__).'/style.css');
?>

e successivamente nell’header delle vostre pagine, esattamente come avete fatto per il file javascript, sostituirete l’istruzione:

1

<link rel="stylesheet" href="css/style.css" type="text/css" />

con

1

<link rel="stylesheet" href="css/far_future_loader.php" type="text/css" />

Con ASP
la procedura è identica a quella per PHP con la sola differenza che in ASP gli header si setttano con i seguenti comandi:

1
2

<% Response.CacheControl = "must-revalidate" %>
<% Response.Expires = -1 %>

Con JSP (Tomcat)
Grazie a Byron Tymvios su jGuru
E’ possibile ottenere l’identico risultato avuto con PHP o ASP tramite i filtri. Ad esempio:

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

package com.xyz
 
import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletResponse;
 
public class CacheFilter implements javax.servlet.Filter {
  FilterConfig filterConfig = null;
 
  public void init(FilterConfig filterConfig){
    this.filterConfig = filterConfig;
  }
 
  public void doFilter(ServletRequest req,
     ServletResponse res,
     FilterChain chain)
     throws IOException, ServletException {
    String sCache = filterConfig.getInitParameter("cache");
 
    if(sCache != null){       ((HttpServletResponse)res).setHeader("Cache-Control", sCache);
 
    }
 
    chain.doFilter(req, res);
  }
 
  public void destroy(){
    this.filterConfig = null;
  }
}

e poi impostare nel file web.xml il filtro per ogni contenuto desiderato. Ecco l’esempio per i file .jpg:

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

<filter>
  <filter-name>Cache</filter-name>
  <filter-class>com.xyz.CacheFilter</filter-class>
  <init-param>
    <param-name>cache</param-name>
    <param-value>public, max-age=2592000</param-value>
  </init-param>
</filter>
<filter-mapping>
  <filter-name>Cache</filter-name>
  <url-pattern>*.jpg</url-pattern>
</filter-mapping>

è tutto
nella prossimo post parleremo degli ETag.
Giovanni

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

abstract class ActiveRecordBase {
  # qui ci va la dichiarazione degli attributi della classe che tralasciamo
  # .....
  #
  public function __construct($data=array()){
     $this->__db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!is_array($data) && is_numeric($data)){
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table).
                  " WHERE ".$this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($data);
         $data = $this->__db->queryRow($sql);
     }
     if (!empty($data)) foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
  }
# Qui prosegue il resto del codice della classe
# ....
}

Con questa modifica la nostra classe continua a funzionare accettando 0 o 1 parametro di tipo numerico o array/hash.
Vediamo ora l’implementazione di un metodo find() che permetta di passare come parametro l’ID del record che vogliamo ottenere. Per semplicità d’ora in avanti verranno omesse le dichiarazioni di classe quando non strettamente necessarie.

1
2
3
4
5
6
7
8
9
10
11

    public function find($id){
         if (!is_numeric($id)) return false;
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table)." WHERE ".
                  $this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($id);
         $data = $this->__db->queryRow($data);
         if (!empty($data)){
             foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
             return true;
         }
         return false;
    }

Come potete vedere, l’implementazione di find() è molto simile a quella del costruttore. Ricordiamoci il principio DRY (= Don’t Repeat Yourself). Modifichiamo il costruttore e aggiungiamo un metodo privato che assegni a partire da un array i valori corrispondenti agli attributi della classe.
__assignData sarà un metodo privato che assegna i valori agli attributi:

1
2
3
4
5
6
7

    private function __assignData($data=array()){
        if (!empty($data)){
             foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
             return true;
         }
         return false;
    }

Possiamo semplificare il metodo find():

1
2
3
4
5
6
7

    public function find($id){
         if (!is_numeric($id)) return false;
         $sql = "SELECT * FROM ".$this->__db->quoteIdentifier($this->__table)." WHERE ".
                  $this->__db->quoteIdentifier($this->__primary_key)." = ".$this->__db->quote($id);
         $data = $this->__db->queryRow($data);
         return $this->__assignData($data);
    }

E ora rivediamo il costruttore:

1
2
3
4
5
6
7
8

  public function __construct($data=array()){
     $this->__db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!is_array($data) && is_numeric($data)){
         $this->find($data);
     }
     $this->__assignData($data);
  }

L’implementazione di ActiveRecord in Rails è molto complessa, permette di effettuare validazioni e avere riferimenti a chiavi esterne. Vediamo un’implementazione più semplice in PHP, ma comunque efficace.
Cercheremo di arrivare ad un’implementazione molto potente in qualche puntata.

Il concetto che sta alla base di active record è di trasformare l’accesso al database in accesso a una classe.
Cominciamo a definire una classe base che abbia l’accesso al database. Per semplificare utilizzeremo la classe PEAR::MDB2.

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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

require 'MDB2.php';
abstract class ActiveRecordBase {
  protected $__db; // Dichiariamo un oggetto "protected" per l'accesso al DB
  protected $__primary_key = "id"; // Definiamo una chiave primaria per la tabella. Può essere poi
                                           // modificata per ogni singola classe che estende questa.
  protected $__fields; // In questo attributo di tipo array andremo a salvare i campi della nostra tabella (escluso il campo primary key)
  protected $__table; // In questo attributo salviamo il nome della tabella
  /**
   * Il costruttore istanzia una connessione con il db e se sono presenti dei dati
   * li salva nell'oggetto (non nel database!)
   */
  public function __construct($data=array()){
     $this->db = &MDB2::connect(DB_DSN);  // DB_DSN è una stringa che contiene di dati accesso al DB
     $this->__table = strtolower(get_class($this));
     if (!empty($data)) foreach ($data as $key => $value){ $this->$key = $value; $this->fields[] = $key;}
  }
 
  /**
   * Definiamo un metodo per create un nuovo Record.
   * Esso è privato perché verrà utilizzato dal metodo save()
   */
  private function create(){
     // Creaimo l'istruzione SQL a partire dai campi disponibili
     $sql = "INSERT INTO ".$this->__db->quoteIdentifier($this->table)." (";
     $first = true;
     $data = array();
     foreach ($this->__fields as $field){
       if (!$first) $sql.=",";
       $sql.= $this->__db->quoteIdentifier($field);
       $data[] = $this->$field;
       $first = false;
     }
     $sql.= ") VALUES (";
     for ($i = 0; $i < count($fields); $i++) if ($i=0) $sql.="?" else $sql.=",?";
     $sql:=");";
     $prep = $this->__db->prepare($sql);
     $res =  $prep->execute($data);
     $pkey_field = $this->__primary_key;
     if ($res) $this->$pkey_field = $this->__db->lastInsertID($this->__table);
     return $res;
  }
 
  private function update(){
    $sql = "UPDATE ".$this->__db->quoteIdentifier($this->__table)." SET ";
    $first = true;
    $data = array();
    foreach ($this->__fields as $field){
      if (!$first) $sql.=",";
      $sql = "$field = ?";
      $data[] = $this->$field;
      $first = false;
    }
    $pkey_field = $this->__primary_key;
    $sql = "WHERE ".$this->db->quoteIdentifier($pkey_field)." = ".$this->db->quote($this->$pkey_field);
    $prep = $this->__db->prepare($sql);
    return $prep->execute($data);
  }
 
  private function delete(){
    $pkey_field = $this->__primary_key;
    $sql = "DELETE FROM ".$this->__db->quoteIdentifier($this->__table).
             " WHERE ".$this->db->quoteIdentifier($pkey_field)." = ".$this->db->quote($this->$pkey_field);
    return $this->__db->query($sql);
  }
 
  public function save(){
     $pkey_field = $this->__primary_key;
     if (!isset($this->$pkey_field)) return $this->create();
     else return $this->update();
  }
 
  public function destroy(){
     $pkey_field = $this->__primary_key;
     if (isset($this->$pkey_field)) return $this->delete();
     else return false;
  }
 
}

In questa implementazione, ancora in stato “embrionale”, è possibile creare un nuovo record.
Un uso molto semplice potrebbe essere creare una classe che estenda la base e istanziarne un oggetto:

1
2
3
4

require 'ActiveRecordBase.class.php'
class Dog extends ActiveRecordBase {}
$dog = new Dog(array('name' => 'Pluto', 'age' => '7'));
$dog->save();

Il precedente script inserisce un nuovo record in una tabella ‘dog’ (stessa nome della classe che estende ActiveRecordBase) assegnando gli attributi ‘name’ e ‘age’.
La primary key viene implicitamente impostata come “id” (ovviamente se il campo ha l’attributo auto_increment) e il valore inserito automaticamente.
Il tutto in 3 righe di codice, molto molto semplici…non è una bella comodità?
Più avanti vedremo come effettuare ricerche, e quindi come implementare il metodo “find” e migliorare ulteriormente la classe base in modo da gestire meglio errori, validazioni e chiavi esterne.

Purtoppo a volte è necessario modificare i path di default.
Vediamo come

Innanzitutto loggatevi sulla vostra macchina con privilegi di root

1

# su -

controlliamo i parametri del nostro suexec:

1
2
3
4
5
6
7
8

# /usr/lib/apache2/suexec -V
     -D AP_DOC_ROOT="/var/www"
     -D AP_GID_MIN=100
     -D AP_HTTPD_USER="www-data"
     -D AP_LOG_EXEC="/var/log/apache2/suexec.log"
     -D AP_SAFE_PATH="/usr/local/bin:/usr/bin:/bin"
     -D AP_UID_MIN=100
     -D AP_USERDIR_SUFFIX="public_html"

come potete vedere dal risultato, i parametri cablati al momento della compilazione sono molti.
spostiamoci in /usr/src e scarichiamo i sorgenti necessari al nostro scopo

1
2
3
4

# cd /usr/src
# apt-get update
# apt-get build-dep apache2
# apt-get source apache2

ok, adesso spostiamoci nella directory con i sorgenti e configuriamo apache con i parametri che ci interessano:

1
2

# cd apache2-2.2.3
# nano debian/rules

all’interno del file rules troverete un sacco di parametri. quelli ci interessano in questo momento sono quelli sotto la voce AP2_COMMON_CONFARGS.
quindi modifichiamo quanto ci serve andando a cambiare quanto presente alla riga

1

      --with-suexec-docroot=/home/hosting \

e salviamo.
ora, semplicemente, dovremmo ricompilare il file. prima di farlo però, è necessario modificare la versione di apache in modo tale che il nostro cambiamento non venga sovrascritto ad ogni upgrade.
quindi

1

# dch -i

e ci troviamo all’interno del changelog di apache.
UN CONSIGLIO: se non volete dover reinstallare tutti i pacchetti di apache, eliminate la versione che dch vi aggiunge in automatico e andate a lavorare sull’ultima. aggiungete un bel * e inserite il vostro commento, tipo: “fixed suexec docroot to: /home” e salvate.
in questo modo la versione rimarrà inalterata e apache installerà solo la “patch” da voi applicata

a questo punto dobbiamo solo compilare e pacchettizzare

1

# dpkg-buildpackage

aspettate la fine delle operazioni di compilazione, tornate in /usr/src e installate i pacchetti modificati (nel nostro caso apache2.2-common e apache2.2-utils)

1
2
3

# cd /usr/src //o se volete cd ../
# dpkg -i apache2.2-common_2.2.3-4+etch6_amd64.deb 
# dpkg -i apache2-utils_2.2.3-4+etch6_amd64.deb

fatto questo restartate apache, verificate che tutto sia andato a posto ed eventualmente controllate i conflitti con apt

1
2
3
4
5
6
7
8
9
10

# /etc/init.d/apache2 restart
# /usr/lib/apache2/suexec -V
     -D AP_DOC_ROOT="/home"
     -D AP_GID_MIN=100
     -D AP_HTTPD_USER="www-data"
     -D AP_LOG_EXEC="/var/log/apache2/suexec.log"
     -D AP_SAFE_PATH="/usr/local/bin:/usr/bin:/bin"
     -D AP_UID_MIN=100
     -D AP_USERDIR_SUFFIX="public_html" 
# apt-get install -f

alla prossima!

Se volessimo ottenere la lista degli impiegati il cui dipartimento ha, per esempio, sede a Roma, potremmo scrivere diverse query SQL che ci fanno ottenere lo stesso risultato:

1
2
3
4
5
6
7
8
9
10

SELECT i.* FROM impiegati i,dipartimenti d 
WHERE i.dipartimento_id = d.id AND d.sede = 'Roma';
 
SELECT * FROM impiegati 
WHERE dipartimento_id IN 
(SELECT id FROM dipartimenti WHERE sede = 'Roma');
 
SELECT i.* FROM impiegati i 
INNER JOIN dipartimenti d ON i.dipartimento_id = d.id 
WHERE d.sede = 'Roma';

Tra le precedenti query l’ultima ha prestazioni decisamente migliori anche se è la più lunga da scrivere:
nel primo caso il DBMS deve prima effettuare un prodotto cartesiano tra le due tabelle ed estrarre i record dove corrispondono gli ID dei dipartimenti e la sede è Roma;
nel secondo caso il DBMS prima leggere tutti i dipartimenti con sede = ‘Roma’ e per ogni impiegato verificare che dipartimento_id sia in questa lista.
Nel terzo caso invece il DBMS automaticamente associa ogni impiegato con il dipartimento relativo e la ricerca sarà effettuata solo sul campo “sede”.
L’uso di INNER JOIN velocizza le vostre applicazioni, ma usatelo con cautela: i valori nulli sui campi su cui si effettua il JOIN non sono ammessi.
Se ve n’é la necessità si possono utilizzare LEFT e RIGHT JOIN.
Se per esempio vogliamo sapere i cognomi degli impiegati che lavorano a Roma o che non lavorano (= dipartimento_id IS NULL) dovremmo scrivere:

1
2
3

SELECT i.cognome FROM impiegati i 
LEFT JOIN dipartimenti d ON i.dipartimento_id = d.id 
WHERE sede = 'Roma' OR i.dipartimento_id IS NULL;

La scrittura delle INNER JOIN può diventare molto ripetitiva, soprattutto se vengono usate spesso. L’uso per di convenzioni però ci può dare una mano. Ridefiniamo le tabelle di prima in questo modo:

1
2

impiegati (impiegato_id, cognome, nome, eta, dipartimento_id)
dipartimenti (dipartimento_id, sede)

Con le tabelle definite in questa guisa possiamo sfoderare un ulteriore tipo di JOIN: il NATURAL JOIN.
Il natural join utilizza campi con lo stesso nome per effettuare la combinazione dei record delle tabelle. Quindi se volessimo sapere quali impiegati lavorano a Roma, la nostra query SQL diventa:

1

SELECT i.* FROM impiegati i NATURAL JOIN dipartimenti d WHERE d.sede = 'Roma';

Praticamente il NATURAL JOIN funziona esattamente come l’INNER JOIN, solo che ci fa risparmiare la scrittura di ON i.dipartimento_id = d.dipartimento_id, mantenendo inalterate le prestazioni.
Quindi scegliendo bene i nomi dei campi possiamo scrivere query più veloci e più velocemente.

Ovviamente le prestazione delle JOIN aumentano in presenza di INDICI. Il miglior tipo di indice per effettuare un join è HASH, non implementato purtroppo da MySQL (almeno per quanto riguarda InnoDB e MyISAM).
Infatti un indice implementato tramite HASH ha prestazioni migliori rispetto a BTREE se la ricerca viene effettuata in base a delle uguaglianze.

Gli indici BTREE invece hanno migliori prestazione in ricerche basate su range, come ad esempio nella query:

1

SELECT * FROM impiegati WHERE eta > 30

Un indice BTREE sul campo “eta” migliorerebbe le prestazione della vostra query.

Vediamo come farlo in javascript, grazie a Mootools.

Immaginiamo di avere un form di ricerca di questo tipo:

1
2
3
4

<form action="/?action=cerca" name="ricerca" id="ricerca" method="get">
       <input name="q" id="q" size="20" type="text" />
       <input type="submit" value="Cerca" />
</form>

1
2
3

if($('q')){
       $('q').focus();
}

1
2
3
4
5

window.addEvent('domready',function(){
       if($('q')){
              $('q').focus();
       }
});

1
2
3
4
5
6

document.addEvent('keydown', function(event){
       var event = new Event(event);
       if(event.key == 'backspace' && !q.value){
              history.back();
       }
});

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

window.onload = function () {
       if(document.getElementById('q')){
              var campo = document.getElementById('q');
              campo.focus();
       }
       document.onkeydown = function (event) {
              if(!event){
                      var event = window.event;
              }
              if (event.keyCode === 8 && !q.value) {
                      history.back();
              }
       }
}