Ein Pluginsystem mit Paketserver in PHP – Teil 1
Ein PHP Plugin- und Paketsystem – Teil 1
Welcher PHP Programmierer möchte das nicht, ein Pluginsystem für seine Anwendung, welches in der Lage ist, Pakete von einem Server nachzuladen und schick zu installieren.
Ich wollte so etwas auch für meine Anwendung gFramework. Zwar hatte ich bereits vor 3 Jahren ein mal einen ähnlichen Code bereits geschrieben, doch toll und performant war dieser gar nicht.
In den folgenden Teilen dieses Tutorials möchte ich euch zeigen, wie Ihr euch so ein Pluginsystem baut und anschließend, wie Ihr ein Paketserver aufsetzt und eine automatische Installationsroutine in eure Anwendung einbaut.
Dafür werde ich das Know-How nutzen, welches ich mir im letzten halben Jahr für gFramework angegeignet habe. Die Gesamtentwicklungszeit des Systemes liegt “nur” bei 6 bis 7 Stunden (für mich als Laie auf diesem Gebiet bis Dato.).
Ihr findet am Ende jedes Teiles den ganzen Code der im Teil behandelten Dateien. Wenn Ihr nicht alle Dateien kopieren wollt, so ladet euch das gFramework herunter. (Zusatz: Erscheinungstermin und weitere Details: s. http://bug.gvisions.de)
Der hier veröffentliche Quellcode kann unter den folgenden Bedingungen genutzt und veröffentlicht werden.
Was soll das System können?
Bevor wir uns um die Erstellung der Klasse kümmern, klären wir erst einmal, was die Klasse am Ende alles können soll:
- generalle Pluginfunktionalität: d.h. Plugin durch URL Parameter aufrufen, auf Rechte prüfen und sichern, das ganze modular
- Plugins in Datenbank verwalten
- Plugin(de)installation
- Plugin von Paketserver installieren
Fangen wir an mit der Plugindatenbank
Um die Plugins später in der Datenbank zu verwalten, müssen wir eine Tabelle anlegen, nennen wir diese ‘plugins’.
Was für Felder brauchen wir in der Datenbank?
- id int (99) auto_increment key – Hieran wird das Plugin erkannt
- name varchar(200) – Dies ist der Name des Plugins
- activate bool – Hier steht jeweils nur true oder false, jenachdem, ob das Plugin aktiv ist oder nicht
- desc text – Hier soll der Entwickler eine kurze Beschreibung mitliefern, ggf. mit HilfeURL oder Screenshot
- com_id varchar(200) – Diese ID setzt sich aus einem Präfix, den Herstellernamen und dem Pluginnamen zusammen (ähnlich wie bei Android), zB com.gvisions.framework oder com.mustermann.faq
- version varchar(200) – Die aktuell installierte Version
- path varchar(999) – Dies stellt den relativen Pfad zum Plugin auf dem Server dar
- updateServer int(10) – Hier steht die ID des UpdateServer drinn, dazu kommen wir später noch.
Hier nun der SQL Code zur Datenbank:
CREATE TABLE IF NOT EXISTS `gframework_plugins` (
`id` int(99) NOT NULL AUTO_INCREMENT,
`name` varchar(200) NOT NULL DEFAULT ”,
`activate` varchar(200) NOT NULL DEFAULT ‘true’,
`desc` text NOT NULL,
`com_id` varchar(200) NOT NULL,
`version` varchar(20) NOT NULL,
`path` varchar(200) NOT NULL COMMENT ‘von root an zB root./apps/…/’,
`updateServer` int(10) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=37 ;
Damit wir einheitlich arbeiten, gebe ich euch nun eine Ordnerstruktur vor, mit welcher ich arbeite.
Ihr könnt die gesamte Klasse dann auf eure Struktur anpassen, wenn dies erforderlich ist.
/ – Dies ist der Root des Projektes
/apps – Hier liegen alle Plugins
/apps/com.gvisions.framework – Die Pluginordner sind nach dessen comid benannt, hierdurch wird die Wahrscheinlichkeit = 0, dass ein Pluginordner sich doppelt, denn bei der Installation wird geprüft, ob die comid schon registriert ist.
/core – Hier liegen die Systemdateien
/core/classes – Und hier die Klasse, indem Fall auch die Klasse gPlugin und die Klasse gInstall, welche wir brauchen
Kommen wir zum Aufruf des Plugins…
…bevor wir zum Anfang der Klasse kommen.
Um ein Plugin aufzurufen, übergeben wir den Parameter $_GET['app'] mit der PluginID oder den Parameter $_GET['app_comid'] mit der comID.
Wir schauen dann, mithilfe SQL, ob diese AppID bzw. die comID existent ist und aktiv ist.
Falls beide Abfragen true ergeben binden wir das Plugin ein, ansonten schalten wir eine 404 Seite:
Datei: /index.php
<?php
/**
* gFramework is a little framework for Scripts by gVisions.
*
*
* PHP 5
*
* LICENSE: Creative Commong NC-BY-SA 3.0 with additional legalcode (link above)
*
* @package com.gvisions.framework
* @author Alexander Grüßung <me at gvisions dot de>
* @copyright 2011 Alexander Grüßung
* @license http://gvisions.de/rechte.html CC NC-BY-SA 3.0 with additional legalcode
* @version 0.5
* @link http://gvisions.de
*/
/*
eine AppID wird immer bevorzugt, falls parralel eine app_comid angeben ist!
*/
$appid = "";
$app_comid = "";
if (isset($_GET['app']) ){
$appid = $_GET['app'];
}
if (isset($_GET['app_comid'])) {
$app_comid = $_GET['app_comid'];
}
if (empty($appid) AND empty($app_comid)) {
/*
Baue DB Verb. auf und schaue, welche App als aller erstes in der DB steht, laden wir dann einfach diese. Der Nutzer wird darauf per trigger_error(); hingewisen!
*/
$db = new db();
$db->query("SELECT * FROM ".pfw."_".plugins." WHERE `id` != '1' ORDER BY id ASC LIMIT 0,1");
$app = $db->fetch();
if ($app->activate != "true" AND $app->activate != "1") {
require_once("apps/com.gvisions.framework/pluginnotfound.php");
die();
}
require_once($app->path."/index.php");
/*
So, dann hoffen wir mal, es war richtig.
*/
die();
}
/*
Gibt es diese Applikation denn in unserer Datenbank ?
Baue DB Verb. dafür auf:
*/
$db = new db();
/*
Suche nun in der DB nach der Applikation.
Eigentlich sollte ja nur eine Übereinstimmung vorhanden sein.
*/
if (!empty($appid)) {
$db->query("SELECT * FROM ".pfw."_".plugins." WHERE id = ".$appid."");
}
elseif (!empty($app_comid)) {
$db->query("SELECT * FROM ".pfw."_".plugins." WHERE `com_id` = '".$app_comid."'");
}
else
{
trigger_error("Interner Fehler bei appid und app_comid.",E_USER_ERROR);
}
/*
So, dann mal alles in einem array speichern
*/
$row = $db->fetch();
/*
Es gibt eine Übereinstimmung, gut, dann binden wir das Teil mal ein.
Und überlassen wir der Applikation den Rest.
*/
if ($row->activate != "true" AND $row->activate != "1")
{
require_once("apps/com.gvisions.framework/pluginnotfound.php"); //404 Seite im Hauptplugin, Pfad kann natürlich angepasst werden
die();
}
if ($num==1){
require_once($row->path."/index.php");
}
(Ein kurzer Hinweis: Ich arbeite mit einer Datenbankklasse, ihr könnt natürlich die normalen Befehle, wie mysql_connect(); mysql_query(); und andere, nutzen.)
Wie Ihr seht ist das einbinden relativ einfach, sieht mehr aus, als es ist, durch die vielen Kommentare für euch 
Auch seht Ihr, dass beim Aufruf keine gPlugin-Klasse aufgerufen wird, wieso? Weil die notwendigen Daten _alle_ In der Datenbank stehen, wieso dann extra Laufzeit erzeugen und über eine Klasse gehen.
Soweit wäre das Tutorial ja eigentlich zu Ende, schließlich können wir nun Plugins laden…nur ist das natürlich nicht alles, was wir wollen.
Wir wir nun die Plugins intern verwalten, das sehen wir im nächsten Teil des Tutorials!
Zur Hauptseite
Über Feedback würde ich mich natürlich freuen.
