Les bases de la construction d'un tableau de bord WordPress Server

Ce que vous allez créer

Les gens se plaignent souvent que WordPress est lent. Que cela soit vrai ou non dépend de nombreux facteurs, mais si nous pouvons voir les ressources du serveur dans le tableau de bord WordPress, cela peut donner un aperçu du fonctionnement de notre installation WordPress..

Dans ce tutoriel, nous allons créer un plug-in pour afficher l'état du serveur, y compris l'espace disque, les consommations de mémoire, l'utilisation du processeur et des processus..

Nous allons également en apprendre davantage sur le cache WordPress pour éviter d'interroger ces métriques à répétition et nous couvrirons également les travaux cron de WordPress pour générer ces données automatiquement..

Le tableau de bord de l'administrateur, par défaut, nous présente deux blocs appelés widgets. Ceux-ci inclus:

En un coup d'oeil
Activité
Brouillon rapide
WordPress Nouvelles
Bienvenue

Les widgets peuvent être réorganisés par préférence, et peuvent être affichés ou masqués - de manière générale, le tableau de bord est personnalisable..

Étant donné que les widgets sont très flexibles et disponibles directement sur le premier écran de l'écran de l'administrateur, nous pouvons les utiliser pour afficher les ressources du serveur: état du disque, utilisation de la mémoire vive, utilisation du processeur et informations sur le système d'exploitation. Nous appellerons ces ressources "métriques" pour faire court.

Tout au long de ce débat sérieux, nous allons apprendre à utiliser l'API et les rôles et fonctionnalités de Dashboard Widgets pour rendre ces widgets accessibles à certains utilisateurs, car les données peuvent être sensibles..

Pour ce faire, nous allons également apprendre quelques commandes de base de Linux pour extraire des informations sur le serveur et des semences pour notre tableau de bord de widgets. Nous allons utiliser l'API transitoire pour mettre en cache ces données. Cronjobs sera utilisé pour extraire automatiquement ces données au lieu de les obtenir à la demande à chaque demande..

Le travail de notre plugin est inspiré de Linux Dash.

Notre plugin prend en charge neuf types de métriques. En conséquence, nous aurons neuf widgets de tableau de bord.

Informations sur le serveur: le système d'exploitation, le noyau Linux, le temps d'activation, etc..
Charge du processeur: charge moyenne du processeur en 1, 5 et 15 minutes
Utilisation de la RAM physique et du fichier d'échange par la RAM
Utilisation du disque
Logiciel installé
Les processus
Ethernet
La performance du réseau
IO stat

Exigences

Un environnement Linux. Mac OS X est toujours une option mais certaines des commandes permettant de vérifier les métriques ci-dessus ne sont pas disponibles. Si vous recevez une erreur commande introuvable, vous savez qu'il n'y a pas de support Mac pour cette commande..
Compréhension de base de la coque
Compréhension de base du plugin WordPress.

La structure du squelette du plugin

Créons un plugin simple et appelons-le Tableau de bord du serveur. Nous allons commencer par quelques éléments de base. Une traditionnelle Bonjour le monde vous aidera à avoir un avant-goût de l'ajout d'un widget au tableau de bord.

C'est facile, en fait.

Créer un appel de dossier Tableau de bord du serveur à l'intérieur wp-content / plugins, et un dossier serverdashboard.php. La disposition des dossiers ressemble à ceci. Concentrez-vous simplement sur le fichier principal et ignorez la corbeille, les tests, les widgets, etc..

Utilisez ce code pour serverdashboard.php

courir(); ?>

J'ai utilisé un espace de noms AX \ StatBoard pour éviter les conflits de noms avec différentes classes de plugins, nom de fonction des thèmes et autres plugins.
J'ai également utilisé le modèle Singleton pour obtenir une instance unique de la classe de plug-in. J'ai créé une méthode courir enregistrer hook ou filtrer avec WordPress.
Pour ajouter un widget, il faut passer à l'action wp_dashboard_setup. Ces points d'accès nous donnent accès à l'option de personnalisation associée à Dashboard. Il nous permet d’ajouter ou de supprimer le widget de tableau de bord de WordPress..
Dans la fonction crochet, nous utilisons wp_add_dashboard_widget enregistrer un widget. Cela nécessite des arguments dans cet ordre:

ID de widget est utilisé pour identifier le slug de votre widget. Ce slug est utilisé lors du rendu de l'identifiant, de la classe et des clés CSS dans un tableau de widgets..
Titre du Widget affiche sur le titre de la boîte de widget
Rappeler rendre le contenu du widget. Il devrait sortir le contenu directement, n'a pas besoin de retourner.

La plupart du temps, nous allons rencontrer des rappels sous forme d'une fonction unique, d'une fonction anonyme, d'un tableau d'objets et de méthodes ou d'un tableau de classes et de méthodes statiques..

Actualisez votre tableau de bord. Notre plugin montre son widget. Remarquez le identifiant de l'élément div widget.

Notre plugin est un widget qui s'affiche avec son identifiant et son contenu

Avançons cela. Nous allons montrer un graphique à secteurs avec des données factices. Pour rester simple, j'utiliserai l'API Google Chart. Nous l'utiliserons beaucoup plus tard pour les statistiques du serveur car il est préférable de visualiser ce type de données..

Si vous n'aimez pas Google Chart, vous pouvez vous en débarrasser et y placer votre bibliothèque de graphiques préférée. N'oubliez pas qu'il s'agit d'un didacticiel, alors ne vous limitez pas vous-même. Utilisez ce que vous êtes à l'aise d'utiliser.!

Nous devons charger le script Google Chart. Change ton courir() méthode pour enregistrer un crochet de plus.

 fonction publique run () add_action ('wp_dashboard_setup', array ($ this, 'add_dashboard_widgets')); add_action ('admin_enqueue_scripts', array ($ this, 'add_asset'));

admin_enqueue_scripts est l'action à laquelle vous devez vous connecter pour ajouter votre propre script dans le tableau de bord de l'administrateur. Nous allons ajouter un autre appel de méthode add_asset dans notre classe pour gérer le chargement de script. La mise en œuvre de add_asset.

 / ** * Ajout de javascript * / function add_asset () wp_enqueue_script ('google-chart', 'https://www.google.com/jsapi');

Nous avons la bibliothèque de cartes. Nous devons maintenant le rendre dans notre tableau de bord. Vous pouvez jouer avec Google Chart. Nous allons simplement réutiliser leur exemple maintenant.

fonction add_dashboard_widgets () syslog (LOG_DEBUG, "Run"); wp_add_dashboard_widget ('hello_world_dashboard_widget', // Un slug pour identifier ce widget 'Hello World', // fonction du titre du widget () echo <<<'EOD' Hey, I'm the body of widget. Thanks for bring me to the life.  
  EOD;  // fonction pour rendre le contenu du widget, j'utilise une fermeture ici);

Nous ajoutons simplement un autre élément div avec id hello_piechart et rendre graphique dans cet élément. Voyons ce que nous avons maintenant:

Remarquez l'ID de l'élément de widget.

Maintenant que nous savons comment ajouter notre propre bloc de widgets au tableau de bord, et maintenant que nous savons comment rendre Google Chart pour le rendu des informations, nous pouvons combiner les deux afin d'afficher plus d'informations..

Dans la section suivante, nous allons apprendre à récupérer les métriques de serveur et à restituer le contenu de chaque type de métrique de serveur que nous avons déjà décrit..

Tirer des statistiques de serveur

Lors de l'extraction des métriques du serveur, nous utiliserons la commande de Linux pour obtenir ces informations. En PHP, nous pouvons utiliser backtick "ou shell_exec pour appeler une commande shell, et récupérer le résultat.

Nous pouvons analyser la sortie pour obtenir les données du serveur. Par exemple, pour obtenir le statut d'utilisation du disque, nous pouvons utiliser la commande df -h. Nous connaissons le format de la sortie, nous pouvons donc l'analyser pour obtenir ce que nous voulons.

 $ df = 'df -h'; $ df = exploser ("\ n", $ df); if (is_array ($ df) && compte ($ df)> = 2) array_shift ($ df); // élimine la première ligne $ df = array_map (function ($ line) if (vide ($ line)) return NULL; $ segment = preg_split ('/ \ s + /', $ line); return array ( 'système de fichiers' => $ segment [0], 'taille' => $ segment [1], 'utilisé' => $ segment [2], 'disponible' => $ segment [3], 'use_percent' => $ segment [4],);, $ df); var_dump ($ df);

Nettoyer avec AWK

Pour aider à nettoyer la sortie directement à partir de la commande shell, nous pouvons combiner avec awk. Ce lien a l'air effrayant avec de nombreuses informations, mais nous allons simplement en utiliser une très petite quantité dans ce tutoriel. Expliquer awk est hors de portée de ce tutoriel.
Si vous voulez en savoir plus sur awk, utilisez cette aide-mémoire. Fondamentalement, nous utilisons awk pour traiter chaque ligne de sortie, et sur chaque ligne, la chaîne sera divisée par une tabulation ou un espace, et l'élément peut être accédé en tant que variable avec $ 1 pour le premier élément, $ 2 pour le deuxième élément, etc. La syntaxe est la suivante: [commande_we_run] | awk 'print $ 1, 3 $,…'.
Regardons l'exemple suivant:

D Serveur Dashboard [maître] ls -lh total 32 -rw-r - r-- 1 employé kureikain 2.6K 11 avr. 00:46 Serveur Dashboard.php drwxr-xr-x 3 employé kureikain 102B mars 29 01:27 bin - rw-r - r-- 1 personnel kureikain 98B 5 avril 18:53 loader.js -rw-r - r-- 1 personnel kureikain 321B 29 mars 01:27 phpunit.xml drwxr-xr-x 4 personnel kureikain 136B 29 mars 01:27 tests drwxr-xr-x 12 employés de kureikain 408B 13 avril 17:37 widget -rw-r - r-- 1 employé de kureikain 1.1K 6 avril 01:04 widget.php ☁ Serveur Dashboard [maître] ls -lh | awk 'print $ 3, 4 $, 5 $, 9 $' 'personnel kureikain 2,6K personnel serveur kureikain 102B personnel kangeikain 98B loader.js personnel kureikain 321B phpunit.xml personnel kureikain 136B teste personnel Kureikain 408B personnel kureikain 1.1K widget.php

Comme vous pouvez le voir chaque ligne de ls -la contient neuf champs:

drwxr-xr-x 4 employés kureikain 136B 29 mars 01:27 tests

Séparés par des espaces, ces 9 champs sont:

drwxr-xr-x
4
kureikain
Personnel
136B
Mar
29
01h27
tests

Je peux utiliser awk pour simplement saisir le nom, le groupe, la taille et le nom du fichier / dossier dans les champs correspondants 3, 4, 5, 9 awk 'print 3 $, 4 $, 5 $, 9 $' et je verrai:

personnel kureikain 136B tests

Par conséquent, en utilisant awk, nous pouvons nettoyer un peu plus la sortie avant d’intégrer notre fonction de traitement PHP..

Nettoyer avec GREP

Certaines commandes génèrent des données supplémentaires dont nous n’avons pas besoin; par conséquent, il faut un peu d'effort supplémentaire avec PHP pour le nettoyer.

Par exemple:

[vagrant @ vagrant-centos64 ~] $ free -m total total utilisé tampons partagés gratuits mis en cache Mem: 589 537 51 0 8 271 - / + tampons / cache: 258 330 Permutation: 255 0 255

gratuit -m nous montre l'utilisation de la RAM avec la mémoire et le fichier d'échange; cependant, il comprend deux autres lignes avec total / used / free et - / + buffers / cache dont nous n'avons peut-être pas besoin.
Nous voulons uniquement extraire des informations sur Mem et Swap - lignes 3 et 5, notamment. Utilisez grep avec -E commutateur. Ce commutateur permet d’utiliser des services d’expresseurs réguliers pour la recherche. Parce que nous voulons trouver la ligne avec les mots Mem et Swap, combinons avec grep -E "Mem | Swap".
Voici le résultat.

[vagrant @ vagrant-centos64 ~] $ free -m | grep -E "Mem | Swap" Mem: 589 536 52 0 8 271 Swap: 255 0 255

Donc c'est beaucoup plus propre. Combinez les deux grep et awk nous pouvons nettoyer les données et obtenir uniquement ce dont nous avons besoin.

[vagrant @ vagrant-centos64 ~] $ free -m | grep -E "Mem | Swap" | awk 'print $ 1, 2 $, 3 $, 4' Mem: 589 537 52 Swap: 255 0 255

Commandes Linux pour obtenir des informations sur le serveur

Nous devons apprendre quelques commandes pour extraire les métriques du serveur, alors ouvrons notre shell de serveur et essayons de taper la commande ci-dessous pour avoir un aperçu rapide.

Vérifier le trafic réseau

$ netstat -in Table d'interface noyau Iface MTU Met RX-OK RX-ERR RX-DRP RX-OVR TX-OK TX-ERR TX-DRP TX-OVR Flg eth0 1500 0 5538339494 0 0 0 6216082004 0 0 0 BMRU eth0: 1 1500 0 - aucune statistique disponible - BMRU eth1 1500 0 96707328840 0 0 0 102776317608 0 0 0 BMRU eth2 1500 0 33 0 0 0 0 BMRU lo 16436 0 29461422 0 0 0 29461422 0 0 0 0 LRU

Vérifier l'utilisation du disque

df -h Taille du système de fichiers utilisée Utilisée Utilisation% Monté sur / dev / sda7 2.0G 660M 1.3G 35% / / dev / sda8 1.0T 632G 340G 66% / home / dev / sda6 2.0G 68M 1.9G 4% / tmp / dev / sda5 20G 1.5G 18G 8% / var / dev / sda2 20G 2.1G 17G 12% / usr / dev / sda1 194M 25M 160M 14% / boot / dev / hdb1 459G 277G 159G 64% / sauvegarde des fichiers 16G 0 16G 0% / dev / shm

Vérifier l'utilisation de la RAM

free -m total total utilisé buffers partagés libres mis en cache Mem: 32189 32129 59 0 419 9052 - / + buffers / cache: 22656 9532 Permutation: 32767 4 3276

Nous utiliserons plus de commandes plus tard, mais les commandes précédentes vous donnent une commande fondamentale pour voir ce que nous pouvons obtenir du serveur directement sur la ligne de commande..

Construire le widget

Nous allons reformuler un peu notre classe d'origine dans la section précédente. Notez que, sauf indication contraire, nous allons créer tous les fichiers et dossiers. dans notre répertoire de plugins.

Premièrement, nous ne voulons pas inclure manuellement les fichiers. Nous allons écrire un chargeur de classe automatique à cette fin. Quand une classe manquante est initialisée, nous allons vérifier le nom de la classe et essayer d’inclure le fichier source contenant la définition de la classe..

Nous utiliserons les espaces de noms comme chemin et le nom de classe comme nom de fichier. Par exemple, une classe foo dans l'espace de noms AX \ StatBoard devrait être à la racine du dossier du plugin. Une classe bourdonner dans l'espace de noms AX \ StatBoard \ Bar devrait être dans Bar \ buzz.php

Structure de présentation de dossier avec espace de noms, nom de classe et nom de fichier pour chargement automatique.

Gardant cela à l’esprit, allons de l’avant et commençons à élaborer notre méthode de chargement automatique:

_plugin_dir. strtolower (str_replace ('\\', '/', $ classname). '.php'); if (! file_exists ($ filepath)) return false;  include $ filepath;  

 / **
 * Variable d'installation et fournisseur de widgets intialize
 * /
 fonction __construct () 
 $ this -> _ plugin_dir = plugin_dir_path (__FILE__);
 spl_autoload_register (array ($ this, 'load_class'));
 

 //…

Alors, que se passe-t-il ici? Notre plugin utilise l'espace de noms AX \ StatBoard. Nous nous assurons donc que la classe demandée sous cet espace de noms soit gérée par notre plugin, sinon notre chargeur automatique ne serait pas capable de les charger. On dépouille ensuite le AX \ StatBoard dans le nom de la classe et remplacez-le par le chemin du dossier du plugin. La barre oblique inverse \ dans l'espace de noms est remplacé par / séparateur de chemin, et ajoutez php extension. Cela signifie que l'espace de noms sera utilisé comme chemin du dossier contenant le fichier de classe et que le nom de la classe est le nom du fichier. L'inclusion ne se produit que si le fichier existe. Maintenant, nous avons le chargeur automatique, nous devons encore informer PHP que nous avons un chargeur automatique et que nous voulons l’utiliser. PHP inclut spl_autoload_register à cette fin. Nous le mettons dans notre constructeur de classe.
Deuxièmement, concevons notre classe de widgets. Nous avons plusieurs types de métrique de serveur à afficher. Il est préférable d'afficher chaque métrique dans un bloc de widgets distinct afin de pouvoir trier ou organiser ces widgets, ou de les personnaliser pour les masquer ou les afficher. Mettre toutes les informations dans le même widget mettra le coût du contrôle montrant / cachant chaque métrique à notre plugin.
En supposant que vous connaissiez la fonction wp_add_dashboard_widget, nous devons lui donner le titre et le contenu. Correspondant à chaque widget, nous aurons une classe pour rendre le titre et le contenu correspondant. Nous appelons ces classes sont des widgets Fournisseur. Tous les fournisseurs de widgets doivent définir get_title () et Obtenir du contenu() rendre le contenu.
À cette fin, nous créerons un Fournisseur interface et que notre classe de fournisseur de widgets implémente cette interface. Nous devons également créer un autre appel de méthode get_metric () extraire les données du serveur.
Créer un fichier widget / provider.php avec ce contenu:

Ceci est une interface. Nous avons demandé à chaque fournisseur de widgets d'implémenter cette interface et nous nous assurons donc que la classe de fournisseur de widgets a toujours ces trois méthodes..
Nous allons créer une classe supplémentaire Widget pour gérer ces fournisseurs. Nous créons des classes de fournisseurs, puis les distribuons à Widget classe et vue Widget classe comme un point unique pour nous de demander un fournisseur lorsque nous avons besoin. Nous pouvons simplement tout mettre dans notre fichier de plugin principal et créer une instance de classe avec Nouveau opérateur lorsque nous avons besoin, mais il est difficile de maintenir plus tard. 
Lorsque nous décomposons les éléments en plusieurs couches, il est plus facile de les tester et de les étendre. Une fois que tous les fournisseurs sont gérés par une seule classe, nous pouvons utiliser cette classe pour faire la même chose sur l’ensemble des fournisseurs. Nous pouvons facilement ajouter plus de fournisseur à tout moment, en créant simplement un objet qui implémente la classe de fournisseur Widget classe
Composer un fichier widget.php dans le répertoire racine du dossier du plugin.

espace de noms AXE \ StatBoard;
utilisez AXE \ StatBoard \ Widget \ Provider;

classe Widget 
 const WIDGET_SLUG_PREFIX = 'AXE';

 protected $ _providers = array ();
 static $ _instance protégé;

 fonction statique instance () 
 return self :: $ _ instance = self :: $ _ instance?: new self ();
 

 fonction __construct () 
 

 / **
 * Ajouter un fournisseur de widgets
 * Nom du widget chaîne @param
 * Objet fournisseur @param pour gérer le rendu du contenu du widget
 * / 
 fonction publique add_provider ($ name, fournisseur $ gestionnaire) 
 $ this -> _ providers [$ name] = $ handler;
 return $ this;
 

 / **
 * Obtenez tous les fournisseurs ou un fournisseur particulier
 * /
 fonction publique get_provider ($ name = NULL) 
 si (! $ name) 
 renvoyer $ ceci -> _ fournisseurs;
 
 retourne $ this -> _ providers [$ name];
 

 / **
 * Enregistrer un widget pour le rendre.
 * /
 registre de fonction publique ($ name) 
 $ slugid = self :: WIDGET_SLUG_PREFIX. $ name;
 $ widget_provider = $ this-> get_provider ($ name);
 if (vide ($ widget_provider)) 
 retourne faux;
 

 wp_add_dashboard_widget (
 $ slugid,
 $ widget_provider-> get_title (),
 array ($ widget_provider, 'get_content'));
 retourne vrai;
 


Encore une fois, nous utilisons le modèle Singleton pour notre classe Widget. Un bref résumé de notre méthode ici.
 le add_provider La méthode ajoutera un objet fournisseur de widgets à la liste de fournisseurs de widgets. Nous utilisons également les indications de type pour nous assurer que la transmission d’objet à add_provider doit être une Fournisseur en mettant en œuvre notre Fournisseur interface.
 le get_provider méthode peut renvoyer une liste de tous les fournisseurs, ou d'un fournisseur particulier.
 le registre La méthode enregistrera effectivement notre objet fournisseur avec WordPress pour rendre un widget de tableau de bord avec wp_add_dashboard_widget. L'ID du widget est généré en fonction du préfixe, d'une constante prédéfinie et du nom de classe du widget. Le titre et le contenu seront tirés via get_title et get_content du fournisseur. Nous nous sommes assurés qu'ils mettent en œuvre notre interface de fournisseur. Avec cette méthode de registre, nous résumons l’implémentation de l’ajout du widget au tableau de bord. Il ne nous reste plus qu'à appeler registre avec le nom du fournisseur que nous ajoutons avant avec add_provider. Dans cet esprit, lorsque l’API de WordPress change, il n’est pas nécessaire d’aller à chaque endroit wp_add_dashboard_widget, nous venons de mettre à jour au même endroit.
 

Revenir notre fichier de plugin principal d'origine serverdashboard.php, nous allons initialiser tous les fournisseurs et les ajouter à la liste des fournisseurs d'objet Widget.
 _plugin_dir = plugin_dir_path (__FILE__); spl_autoload_register (array ($ this, 'load_class')); $ this -> _ dashboard_widget = array ('serveur', 'cpu_load', 'ram', 'disque', 'diskio', 'logiciel', 'ethernet', 'internetspeed', 'networkio', 'process',;; foreach ($ this -> _ dashboard_widget as $ item) if (! file_exists ($ this -> _ plugin_dir. '/ widget /'. $ item. '.php')) continuer;  $ classname = 'AX \\ StatBoard \\ Widget \\'. ucwords ($ item); Widget :: instance () -> add_provider ($ item, new $ classname ()); 

Nous mettrons toutes les classes de fournisseur de widgets sous l'espace de noms AXE \ StatBoard \ Widget et donc ils vont s'asseoir à l'intérieur du dossier widget. Nous supportons neuf types de métrique et nous nommons la classe correspondant au tableau _dashboard_widgets au dessus de. 
Pour chaque widget, nous créons une nouvelle instance de son fournisseur, et ajoutons dans Widget classe. Voici ce que nous obtiendrons plus tard avec cette structure:
Rappelez-vous que nous avons accroché dans wp_dashboard_setup, et à l'intérieur nous appelons la fonction wp_add_dashboard_widget ajouter un nouveau widget au tableau de bord. Ensuite, nous avons notre registre méthode à cette fin. Nous allons parcourir tous les fournisseurs ajoutés et les enregistrer. Mettre à jour le contenu de add_dashboard_widgets de serverdashboard.php devenir:
 
 / ** * Enregistrez le proider du widget de tableau de bord pour qu'il apparaisse sur le tableau de bord * / function add_dashboard_widgets () $ widget = Widget :: instance (); foreach ($ widget-> get_provider () as $ name => $ fournisseur) $ widget-> register ($ name); 


Ensuite, nous allons nous connecter à admin_footer pour générer du code JavaScript intégré au bas de la page d’administration pour initialiser le package de classe Google Chart. Notre courir() la méthode est également mise à jour pour le nouveau crochet.
 / ** * Commencer à installer hook * / public function run () add_action ('wp_dashboard_setup', array ($ this, 'add_dashboard_widgets')); add_action ('admin_enqueue_scripts', array ($ this, 'add_asset')); add_action ('admin_footer', array ($ this, 'footer'));  / ** * JavaScript intégré au graphique * / function footer () echo '  '; 

A ce moment, nous avons terminé la base, et le fichier de plugin principal devrait ressembler à ceci.
_plugin_dir. strtolower (str_replace ('\\', '/', $ classname). '.php'); if (! file_exists ($ filepath)) return false;  include $ filepath;  / ** * Variable d'installation et fournisseur de widgets d'initialisation * / function __construct () $ this -> _ plugin_dir = plugin_dir_path (__FILE__); spl_autoload_register (array ($ this, 'load_class')); $ this -> _ dashboard_widget = array ('serveur', 'cpuload', 'ram', 'disque', 'logiciel', 'processus', 'ethernet', 'networkio', 'iostat',); foreach ($ this -> _ dashboard_widget as $ item) if (! file_exists ($ this -> _ plugin_dir. '/ widget /'. $ item. '.php')) continuer;  $ classname = 'AX \\ StatBoard \\ Widget \\'. ucwords ($ item); Widget :: instance () -> add_provider ($ item, new $ classname ());  / ** * Créer une instance unique via l'instance de fonction statique app * / public () return self :: $ _ instance = self :: $ _ instance?: New self ();  / ** * Commence à installer hook * / public function run () add_action ('wp_dashboard_setup', array ($ this, 'add_dashboard_widgets')); add_action ('admin_enqueue_scripts', array ($ this, 'add_asset')); add_action ('admin_footer', array ($ this, 'footer'));  / ** * Enregistrez le fournisseur de widgets de tableau de bord pour qu'il apparaisse sur le tableau de bord * / function add_dashboard_widgets () $ widget = Widget :: instance (); foreach ($ widget-> get_provider () as $ name => $ fournisseur) $ widget-> register ($ name);  / ** * Chargement des actifs: feuille de style, JS. * / function add_asset () syslog (LOG_DEBUG, "Loaded"); wp_enqueue_script ('google-chart', 'https://www.google.com/jsapi'); // wp_enqueue_script ('plugin_dir_url', plugin_dir_url (__ FILE__). '/loader.js');  / ** * JavaScript intégré au graphique * / function footer () echo '  ';  Dashboard :: instance () -> run (); 
En gros, nous créons une instance de la classe du plugin principal et appelons la méthode run. Ce qui à son tour vient d'établir une liste de hook. Chaque hook est une autre méthode de la classe. Nous créons également et enregistrons notre objet fournisseur avec Widget objet.
Et après?
À ce stade, nous n’avons toujours rien affiché; Cependant, nous avons élaboré une structure pour notre annonce de plug-in qui a commencé à s’accrocher à Google Charts..
Vous pouvez télécharger le script complet à partir des liens de téléchargement en haut de cet article. Nous allons entrer dans les détails d'implémentation de chaque fournisseur de widget dans l'article suivant, alors assurez-vous de suivre la partie suivante. 
J'espère que vous avez apprécié cet article. Laissez des commentaires avec vos pensées et je m'assurerai d'y répondre.




		
			
	   
	




Code