Constructeur __construct
Description:
Worker::__construct([string $listen , array $context])
Initialise une instance du conteneur Worker, permettant de configurer certaines propriétés et interfaces de rappel du conteneur, afin de réaliser des fonctionnalités spécifiques.
Paramètres
$listen （paramètre optionnel, le laisser vide signifie ne pas écouter de port）
Si le paramètre d'écoute $listen est défini, le socket sera à l'écoute.
Le format de $listen est ://<adresse d'écoute>
peut être l'un des formats suivants :
tcp : par exemple tcp://0.0.0.0:8686
udp : par exemple udp://0.0.0.0:8686
unix : par exemple unix:///tmp/my_file (nécessite Workerman>=3.2.7)
http : par exemple http://0.0.0.0:80
websocket : par exemple websocket://0.0.0.0:8686
text : par exemple text://0.0.0.0:8686 (text est le protocole texte intégré de Workerman, compatible avec telnet, voir l'annexe sur le protocole Text pour plus de détails)
et d'autres protocoles personnalisés, voir la section sur les protocoles de communication personnalisés de ce manuel.
<adresse d'écoute> peut être l'un des formats suivants :
Si c'est un socket unix, l'adresse est un chemin de disque local.
Pour les sockets qui ne sont pas unix, le format de l'adresse est :<numéro de port>.
peut être ```0.0.0.0``` pour écouter toutes les interfaces réseau locales, y compris les adresses IP internes, externes et la boucle locale 127.0.0.1.
si c'est ```127.0.0.1``` signifie écouter la boucle locale, accessible uniquement depuis la machine locale, l'accès externe est impossible.
si c'est une adresse IP interne, comme ```192.168.xx.xx```, signifie écouter uniquement les adresses IP internes, donc les utilisateurs externes n'accéderont pas.
La valeur définie pour qui ne fait pas partie des adresses IP de la machine ne peut pas exécuter d'écoute et générera une erreur ```Cannot assign requested address```.
**Attention :** ne peut pas dépasser 65535. Si est inférieur à 1024, l'autorisation root est requise pour écouter. Le port écouté doit être un port inoccupé sur la machine, sinon l'écoute échouera et générera une erreur ```Address already in use```.
#### **``` $context ```**
Un tableau. Utilisé pour passer les options de contexte du socket, voir [Options de contexte des sockets](https://php.net/manual/fr/context.socket.php)
## Exemples
Worker agissant comme conteneur http pour écouter et traiter les requêtes http
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
use Workerman\Protocols\Http\Request;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('http://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, Request $request)
{
$connection->send("hello");
};
// Exécuter le worker
Worker::runAll();
```
Worker agissant comme conteneur websocket pour écouter et traiter les requêtes websocket
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('websocket://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Exécuter le worker
Worker::runAll();
```
Worker agissant comme conteneur tcp pour écouter et traiter les requêtes tcp
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('tcp://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Exécuter le worker
Worker::runAll();
```
Worker agissant comme conteneur udp pour écouter et traiter les requêtes udp
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('udp://0.0.0.0:8686');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Exécuter le worker
Worker::runAll();
```
Worker écoutant un socket de domaine unix ```(nécessite Workerman version>=3.2.7)```
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
$worker = new Worker('unix:///tmp/my.sock');
$worker->onMessage = function(TcpConnection $connection, $data)
{
$connection->send("hello");
};
// Exécuter le worker
Worker::runAll();
```
Worker ne réalisant aucune écoute, utilisé pour traiter certaines tâches planifiées
```php
use \Workerman\Worker;
use \Workerman\Timer;
require_once __DIR__ . '/vendor/autoload.php';
$task = new Worker();
$task->onWorkerStart = function($task)
{
// S'exécute toutes les 2,5 secondes
$time_interval = 2.5;
Timer::add($time_interval, function()
{
echo "task run\n";
});
};
// Exécuter le worker
Worker::runAll();
```
**Worker écoutant les ports de protocoles personnalisés**
Structure finale des répertoires
```
├── Protocols // Répertoire Protocols à créer
│ └── MyTextProtocol.php // Fichier de protocole personnalisé à créer
├── test.php // Script test à créer
└── Workerman // Répertoire du code source de Workerman, ne pas modifier le code à l'intérieur
```
1. Créer le répertoire Protocols et un fichier de protocole
Protocols/MyTextProtocol.php (se référer à la structure de répertoire ci-dessus)
```php
// L'espace de noms des protocoles personnalisés est uniformément défini comme Protocols
namespace Protocols;
// Protocole texte simple, format du protocole : texte + nouvelle ligne
class MyTextProtocol
{
// Fonction de fragmentation, retourne la longueur du paquet actuel
public static function input($recv_buffer)
{
// Trouve le caractère de nouvelle ligne
$pos = strpos($recv_buffer, "\n");
// Si le caractère de nouvelle ligne n'est pas trouvé, cela signifie qu'il ne s'agit pas d'un paquet complet, retourne 0 et continue d'attendre les données
if($pos === false)
{
return 0;
}
// Si le caractère de nouvelle ligne est trouvé, retourne la longueur actuelle du paquet, y compris le caractère de nouvelle ligne
return $pos+1;
}
// Après avoir reçu un paquet complet, il est automatiquement décodé par decode, ici nous supprimons simplement le caractère de nouvelle ligne
public static function decode($recv_buffer)
{
return trim($recv_buffer);
}
// Avant d'envoyer des données au client, celles-ci seront automatiquement encodées par encode, puis envoyées au client, ici nous ajoutons une nouvelle ligne
public static function encode($data)
{
return $data."\n";
}
}
```
2. Utiliser le protocole MyTextProtocol pour écouter et traiter les requêtes
Créer le fichier test.php en se référant à la structure finale des répertoires
```php
use Workerman\Worker;
use Workerman\Connection\TcpConnection;
require_once __DIR__ . '/vendor/autoload.php';
// #### Worker MyTextProtocol ####
$text_worker = new Worker("MyTextProtocol://0.0.0.0:5678");
/*
* Après avoir reçu des données complètes (se terminant par une nouvelle ligne), MyTextProtocol::decode('les données reçues') sera automatiquement exécuté.
* Le résultat est passé à la fonction de rappel onMessage via $data
*/
$text_worker->onMessage = function(TcpConnection $connection, $data)
{
var_dump($data);
/*
* L'envoi de données au client appellera automatiquement MyTextProtocol::encode('hello world') pour encoder le protocole,
* puis les enverra au client
*/
$connection->send("hello world");
};
// Exécuter tous les workers
Worker::runAll();
```
3. Tester
Ouvrez un terminal, allez dans le répertoire où se trouve test.php et exécutez ```php test.php start```
```
php test.php start
Workerman[test.php] démarré en mode DEBUG
----------------------- WORKERMAN -----------------------------
Version Workerman :3.2.7 Version PHP :5.4.37
------------------------ WORKERS -------------------------------
utilisateur worker écoute processus état
root none myTextProtocol://0.0.0.0:5678 1 [OK]
----------------------------------------------------------------
Appuyez sur Ctrl-C pour quitter. Démarrage réussi.
```
Ouvrez un terminal et utilisez telnet pour tester (il est conseillé d'utiliser telnet sur un système linux)
Supposons que ce soit un test local,
dans le terminal exécutez telnet 127.0.0.1 5678
puis entrez hi et appuyez sur Entrée
vous recevrez les données hello world\n
```
telnet 127.0.0.1 5678
Trying 127.0.0.1...
Connected to 127.0.0.1.
Escape character is '^]'.
hi
hello world
```