[PHP 5.3] Class de stockage de connexion BDD

[xetqL]

Salut à tous !
Voilà, j'ai développé une class permettant de stocker une multitude de connexion à l'intérieur pour simplifier l'utilisation des accès BDD dans PHP.
J'aimerai savoir ce que vous en pensez, avis, remarques, critiques constructives, tout est bon à prendre !

Voici le code

Code :

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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
<?php
 
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
 
/**
 * Description of DBConnect
 *
 * @author Anthony
 */
class DBConnect {
 
    //put your code here
 
    private static $DBInfo = array(
        array()
    ); //UUID=>[Informations]
    private static $DBConnection = array(); // UUID => PDO
    private static $unvalidateActions = array(
        array(
            array()
        )
    ); //UUID => [UnvalidateActions] => Action/Valeur
 
    /**
     *
     * Connecte une base de donnée MySQL à l'aide des informations de connexion / uuid d'une connexion non linkée
     * @param type $server
     * @param type $dbname
     * @param type $user
     * @param type $password
     * @param type $uuid
     * @return type 
     */
 
    public static function connect($server=null, $dbname=null, $user=null, $password=null, $uuid=null) {
        if ($server == null && $user == null && $password == null && $dbname == null && !empty($uuid)) {
            $informations = self::getInformations($uuid);
            try {
                if (!empty($informations['DBNAME'])) {
                    $connect = new PDO("mysql:host=" . $informations['SERVER'] . ";dbname=" . $informations['DBNAME'], $informations['USER'], $informations['PASSWORD']); //Crée un objet PDO (Connexion à la base de données)
                } else {
                    $connect = new PDO("mysql:host=" . $informations['SERVER'], $informations['USER'], $informations['PASSWORD']); //Crée un objet PDO (Connexion à la base de données) 
                }
                $connect->exec('SET CHARACTER SET utf8'); //Execute la requête de formatage   
            } catch (Exception $e) {
                return false;
            }
            self::$DBConnection[$uuid] = $connect;
        }
 
        if (!empty($server) && !empty($user) && !empty($password) && $uuid == null) {
            try {
                if (!empty($dbname)) {
                    $connect = new PDO("mysql:host=$server;dbname=$dbname", $user, $password); //Crée un objet PDO (Connexion à la base de données)
                } else {
                    $connect = new PDO("mysql:host=$server;", $user, $password); //Crée un objet PDO (Connexion à la base de données) 
                }
                $connect->exec('SET CHARACTER SET utf8'); //Execute la requête de formatage   
            } catch (Exception $e) {
                return false;
            }
            self::setServer($server, $uuid);
            self::setPassword($password, $uuid);
            self::setUser($user, $uuid);
            if (!empty($dbname))
                self::setDbname($dbname, $uuid);
            self::$DBConnection[$uuid] = $connect;
        }
 
        return self::getConnection($uuid);
    }
 
    /**
     * tente une connexion avec le serveur demandé
     * @param type $server
     * @param type $user
     * @param type $password
     * @param type $dbname
     * @return type 
     */
    private static function tryConnection($uuid, $server, $user, $password, $dbname = null) {
        try {
            if (!empty($dbname)) {
                $connect = new PDO("mysql:host=$server;dbname=$dbname", $user, $password); //Crée un objet PDO (Connexion à la base de données)
            } else {
                $connect = new PDO("mysql:host=$server;", $user, $password); //Crée un objet PDO (Connexion à la base de données) 
            }
            /* Ajout des informations sans passer par la fonction pour des raisons de performance */
            self::$DBInfo[$uuid]["SERVER"] = $server;
            self::$DBInfo[$uuid]["USER"] = $user;
            self::$DBInfo[$uuid]["DBNAME"] = $dbname;
            self::$DBInfo[$uuid]["PASSWORD"] = $password;
            self::$DBConnection[$uuid] = $connect;
 
            unset($connect);
            return true;
        } catch (Exception $e) {
            return false;
        }
    }
 
    /**
     * déconnecte un link
     * @param type $uuid 
     */
    public static function disconnect($uuid) {
        unset(self::$DBConnection[$uuid]);
    }
 
    /*
     * Ajoute une nouvelle connexion vide
     */
 
    private static function addNewEmptyConnection($uuid=null) {
        if (empty($uuid))
            self::$DBInfo[] = array();
        else
            self::$DBInfo[$uuid] = array();
    }
 
    /**
     * Ajoute une nouvelle connexion non linkée avec le serveur
     * @param type $server
     * @param type $user
     * @param type $password
     * @param type $dbname
     * @return type 
     */
    public static function addUnlinkedConnection($server, $user, $password, $dbname=null) {
 
        $uuid = self::generateUUID();
        self::addNewEmptyConnection($uuid);
        if (!self::setDbname($dbname, $uuid)) {
            return false;
        }
        if (!self::setPassword($password, $uuid)) {
            return false;
        }
        if (!self::setServer($server, $uuid)) {
            return false;
        }
        if (!self::setUser($user, $uuid)) {
            return false;
        }
        return $uuid;
    }
 
    /**
     * Génère un UUID
     * @return type 
     */
    private static function generateUUID() {
        return uniqid("DB_");
    }
 
    /**
     * Récupère la connexion à l'aide d'un UUID
     * @param type $uuid
     * @return type 
     */
    public static function getConnection($uuid) {
        return self::$DBConnection[$uuid];
    }
 
    /**
     * Définit une nouvelle connexion, ne peut pas en modifier une existante
     * @param type $uuid
     * @param PDO $connect
     * @return type 
     */
    private static function setConnection(PDO $connect, $uuid) {
        if (self::verifyData($uuid)) {
            if (!empty($connect) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                self::$DBConnection[$uuid] = $connect;
                return true;
            } else
                return false;
        }else
            return false;
    }
 
    /**
     * retourne l'UUID d'une connexion
     * @param PDO $connexion
     * @return type 
     */
    public static function getUUID(PDO $connexion) {
        foreach (self::$DBConnection as $UUID => $LINK) {
            if ($LINK === $connexion)
                return $UUID;
        }
        return false;
    }
 
    /**
     * définit le serveur d'une connexion
     * @param type $server
     * @param type $uuid
     * @return type 
     */
    public static function setServer($server, $uuid) {
        if (self::verifyData($uuid)) {
            if (!empty($server) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                if (array_key_exists("DBNAME", self::$DBInfo[$uuid])) {// test la validité de la modification
                    self::addUnvalidateAction($uuid, "setServer", self::getServer($uuid));
                    return self::tryConnection($uuid,$server, self::getUser($uuid), self::getPassword($uuid), self::getDbname($uuid));
                } else { // test la validité de la modification
                    self::addUnvalidateAction($uuid, "setServer", self::getServer($uuid));
                    return self::tryConnection($uuid,$server, self::getUser($uuid), self::getPassword($uuid));
                }
            }else
                return false;
        }else
            self::$DBInfo[$uuid]["SERVER"] = $server;
        return true;
    }
 
    /**
     * définit l'utilisateur d'une connexion
     * @param type $user
     * @param type $uuid
     * @return type 
     */
    public static function setUser($user, $uuid) {
        if (self::verifyData($uuid)) {
            if (!empty($user) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                if (array_key_exists("DBNAME", self::$DBInfo[$uuid])) {// test la validité de la modification
                    self::addUnvalidateAction($uuid, "setUser", self::getUser($uuid));
                    return self::tryConnection($uuid,self::getServer($uuid), $user, self::getPassword($uuid), self::getDbname($uuid));
                } else { // test la validité de la modification
                    self::addUnvalidateAction($uuid, "setUser", self::getUser($uuid));
                    return self::tryConnection($uuid,self::getServer($uuid), $user, self::getPassword($uuid));
                }
            }else
                return false;
        }else
            self::$DBInfo[$uuid]["USER"] = $user;
        return true;
    }
 
    /*
     * Définit le mot de passe d'une connexion
     */
 
    public static function setPassword($password, $uuid) {
        if (self::verifyData($uuid)) {
            if (!empty($password) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                if (array_key_exists("DBNAME", self::$DBInfo[$uuid])) {// test la validité de la modification
                    self::addUnvalidateAction($uuid, "setPassword", self::getPassword($uuid));
                    return self::tryConnection($uuid,self::getServer($uuid), self::getUser($uuid), $password, self::getDbname($uuid));
                } else { // test la validité de la modification
                    self::addUnvalidateAction($uuid, "setPassword", self::getPassword($uuid));
                    return self::tryConnection($uuid,self::getServer($uuid), self::getUser($uuid), $password);
                }
            }else
                return false;
        }else
            self::$DBInfo[$uuid]["PASSWORD"] = $password;
        return true;
    }
 
    /**
     * Définit la base de donnée sélectionnée pour la connexion
     * @param type $dbname
     * @param type $uuid
     * @return type 
     */
    public static function setDbname($dbname, $uuid) {
        if (self::verifyData($uuid)) {
            if (!empty($dbname) && !empty($uuid) && array_key_exists($uuid, self::$DBInfo)) {
                self::addUnvalidateAction($uuid, "setDbname", self::getDbname($uuid));
                return self::tryConnection($uuid,self::getServer($uuid), self::getUser($uuid), self::getPassword($uuid), $dbname);
            }else
                return false;
        }else {
            self::$DBInfo[$uuid]["DBNAME"] = $dbname;
        }
        return true;
    }
 
    private static function addUnvalidateAction($uuid, $actionName, $lastValue) {
        $tmp = self::generateUUID();
        self::$unvalidateActions[$uuid][$tmp]["ACTION"] = $actionName;
        self::$unvalidateActions[$uuid][$tmp]["LASTVALUE"] = $lastValue;
    }
 
    /**
     * Récupère le serveur de la connexion
     * @param type $uuid
     * @return type 
     * 
     */
    public static function getServer($uuid) {
        return self::$DBInfo[$uuid]["SERVER"];
    }
 
    /**
     * Récupère l'utilisateur d'une connexion
     * @param type $uuid
     * @return type 
     */
    public static function getUser($uuid) {
        return self::$DBInfo[$uuid]["USER"];
    }
 
    /**
     * Récupère le mot de passe d'une connexion
     * @param type $uuid
     * @return type 
     */
    public static function getPassword($uuid) {
        return self::$DBInfo[$uuid]["PASSWORD"];
    }
 
    /**
     * Récupère la base de donnée sélectionnée d'une connexion
     * @param type $uuid
     * @return type 
     */
    public static function getDbname($uuid) {
        return self::$DBInfo[$uuid]["DBNAME"];
    }
 
    /**
     * Récupère toutes les informations d'une connexion
     * @param type $uuid
     * @return type 
     */
    public static function getInformations($uuid) {
        return self::$DBInfo[$uuid];
    }
 
    /**
     * Annule les dernières actions non validées.
     */
    public static function rollback($uuid) {
 
        foreach (self::$unvalidateActions as $_uuid => $listActions) {
            if ($_uuid === $uuid) {
                foreach ($listActions as $action) {
                    self::$action['ACTION']($action['LASTVALUE'],$uuid);
                }
            }
        }
        self::valid($uuid); 
    }
 
    public static function valid($uuid) {
        unset(self::$unvalidateActions[$uuid]);
    }
 
    private static function verifyData($uuid) {
        foreach (self::$DBInfo as $Cuuid => $info) {
            if ($Cuuid === $uuid) {
                if (empty($info))
                    return false;
                if(array_key_exists("DBNAME", $info) && 
                   array_key_exists("SERVER", $info) && 
                   array_key_exists("USER", $info) && 
                   array_key_exists("PASSWORD", $info)){
                    foreach($info as $data){
                        if($data == null) return false;
                    }
                }else return false;
            }
        }
        return true;
    }
 
}
 
?>

Merci à vous.

Cordiallement, Anthony <xetqL> BOULMIER

[christele_r]

Bonjour,
Si tu veux un avis , il va me falloir étre franche

C' est une usine a gaz pour risquer de créer des failles de sécuritées la ou la recherche va dans le sens d'une minimilisation du code.

En premier tu t'attaques a une des premiére classe, la connection.

Tu es bien OK que tout serveur qui se respecte interdit toute connection externe, et même toute connection sur un même serveur, entre noms de domaines.

Tu vois déjas dans ce cas ta classe parait inutile. J'ajouterais que de plus en plus nous allons vers PDO donc tu vas te retrouver avec des classes de classes.

A ce sujet sur la connection PDO pas de mise en route de la gestion d'erreurs ! pas de vrais TRY etc ...

Je m'arrétes là, mais je reconnais que tu as du travailler sérieusement pour monter cela.

[Benjamin Delespierre]

Bonjour

Cette classe m'a l'air pas mal du tout mais son principal défaut selon moi est qu'elle ne contraste pas vraiment avec un simple tableau d'instances PDO...

Un défaut somme toute mineur est que la méthode "disconnect" ne provoque pas réellement de déconnexion.

Tu devrais également la rendre plus générique en permettant d'ouvrir des connections vers d'autres SGBD.

Une amélioration possible serait de permettre de passer des requêtes SQL directement dans cette classe qui se chargerait in-fine de trouver à quelle connexion cette requête correspond. Cela peut se faire par exemple en détectant un nom de table ou de base de données dans la chaine SQL.

Par curiosité, pourquoi avoir créé cette classe ?

[xetqL]

@Cristele_r :
Merci de votre commentaire !

Tu es bien OK que tout serveur qui se respecte interdit toute connection externe, et même toute connection sur un même serveur, entre noms de domaines.

De quel connexion externe parles-tu ? J'effectue simplement une connexion à l'aide de la classe PDO, rien de plus rien de moins.

J'ajouterais que de plus en plus nous allons vers PDO donc tu vas te retrouver avec des classes de classes.

Mon code utilise déjà PDO, le principe de ma classe est de simplifier la gestion et l'organisation des différents BDD/SGBD à utiliser (pour l'instant que MySQL, mais en cours de dev.)

A ce sujet sur la connection PDO pas de mise en route de la gestion d'erreurs ! pas de vrais TRY etc ...

Dans mon code, aucunes actions critiques ne sont effectuées. Libre à l'utilisateur de ma classe de faire des try/catch sur les actions qu'il entreprendra sur ses BDD. En l'occurence, cette classe est une classe de STOCKAGE et non de traitement, récupération et affichage (MVC)
Cependant, il est vrai que je ne me suis pas amuser à créer mes propres exceptions pour faire plus propre mais je ne vois pas ou cela peut apporter de l'insécurité, une petit explication ? .

@Benjamin : Merci de ton commentaire !

Tu devrais également la rendre plus générique en permettant d'ouvrir des connections vers d'autres SGBD.

C'est en cours de développement, mais merci de l'avoir souligné

Par curiosité, pourquoi avoir créé cette classe ?

J'ai eu plusieurs écho d'amis développeurs apprentis qui étaient emmerdés, par les multiples base de données à gérer pour générer un backup automatique sur une base de données distante.
J'ai décidé de créer cette classe pour moi-même être plus tranquille avec les actions à faire sur les différentes sgbd disponible, manque plus qu'à faire les quelques modifications restantes pour que ma class soit plus ou moins comme je l'espérais.
Cordiallement.

[Benjamin Delespierre]

Dans mon code, aucunes actions critiques ne sont effectuées. Libre à l'utilisateur de ma classe de faire des try/catch sur les actions qu'il entreprendra sur ses BDD. En l'occurence, cette classe est une classe de STOCKAGE et non de traitement, récupération et affichage (MVC)
Cependant, il est vrai que je ne me suis pas amuser à créer mes propres exceptions pour faire plus propre mais je ne vois pas ou cela peut apporter de l'insécurité, une petit explication ? .

Il n'est pas obligatoire de mettre un try/catch ici, on peut très bien vouloir laisser remonter l'exception. Mais je pense que ce serait pas mal de mettre un paramètre optionnel supplémentaire $silent = true qui, si vrai attrape l'exception et renvoie false et si faux, laisse remonter l'exception. Quand à créer des classes personnalisées d'exception, franchement je ne vois pas ce que ça apporte...

De quel connexion externe parles-tu ? J'effectue simplement une connexion à l'aide de la classe PDO, rien de plus rien de moins.

C'est vrai que les cas ou on est amené à utiliser plusieurs bdd distantes sont plutôt rares - surtout dans le web - mais dans le milieu industriel, ça peut se comprendre.

[xetqL]

Il est vrai que je fais pas de

Code :

throw new Exception

, c'est plus clair au niveau du message d'erreur pour l'utilisateur de la classe mais rien de plus n'est-ce pas ?
Personnellement, j'en ai eu l'utilité il n'y a pas une semaine entre un site Magento et une bdd interne à l'entreprise pour faire des sondages / calculs etc.

[Benjamin Delespierre]

Non c'est complêtement différent. Renvoyer un status true/false permet de déterminer une action à effectuer si la connection n'a pas été ouverte, c'est je pense le mieux à faire. Dans ce cas c'est à toi de mettre le try / catch.

Lever une exception, c'est normalement comme son nom l'indique exceptionnel, par exemple dans le cadre des constructeurs qui ne peuvent rien renvoyer: comment savoir alors que quelque chose s'est mal déroulé ? Lever une exception (ou la laisser remonter ce qui revient au même) provoque l'arrêt immédiat de la méthode / fonction en cours et remonte la pile des appels jusqu'au script racine. S'il n'est à aucun moment catché cela provoque une FATAL_ERROR et interrompt brutalement le script.

Une exception doit toujours être levée en dernier recours, s'il n'y a plus rien d'autre à faire, dans ton cas renvoyer false suffit amplement.

Note: quand une méthode / fonction lève une exception et qu'on veut la faire remonter, on a alors 2 possibilités: soit on re-throw l'exception:

Code :

1
2
3
4
5
6
 
try {
 throw new RuntimeException("une exception bidon");
} catch (RuntimeException $e) {
 throw $e;
}

soit on enveloppe cette exception dans une autre:

Code :

1
2
3
4
5
6
 
try {
 throw new LogicException("erreur de logique");
} catch (LogicException $e) {
 throw new RuntimeException("un autre message", 0, $e);
}

Note: on peut définir plusieurs blocs catch pour les différentes classes d'exception disponibles, sachant qu'un catch (Exception $e) les attrapera obligatoirement vu que les exception dérivent toutes de Exception.

En espérant avoir été clair.

[xetqL]

Je connaissais déjà le principe des exceptions, vu que j'en fais moult utilisation en Java, mais j'avais simplement mal compris ton affirmation ^^

[christele_r]

Bref comme je te l'ais dis, tu refait un PDO de PDO et pas de

Code :

1
2
 
$bdd->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

En disant si tu veux tu te le mets

[xetqL]

Ma classe n'est pas un PDO de PDO.
Cette classe permet de STOCKER (à nouveau) plusieurs BDD à la fois !
Non pas une seule connexion où l'on peut changer les attributs etc. mais plusieurs.
Ma classe s'utilise comme un tableau de PDO sauf que j'en simplifie l'utilisation.
Après, je vois pas comment être plus claire

[stealth35]

utilise un pattern type registry ça sera plus simple, pourquoi ne par garder le systeme de DNS, j'ai pas MySQL je fais comment ?