diff --git a/README.md b/README.md index a050c18..757dc1b 100644 --- a/README.md +++ b/README.md @@ -23,3 +23,14 @@ Un assistant en CLI vous posera quelques questions, (l'id du plugin, la catégor Voila, votre plugin est basiquement prêt pour coder votre travail. + +--- +Démon +--- +Le démon d'exemple (`resources/demond/demond.py`) fonctionne avec Jeedom 4.6 et Jeedom 5 : + +* Jeedom parle au démon par un socket Unix que seul Jeedom peut ouvrir (`--socket`), sans clé API ni port réseau. Côté PHP, `template::sendToDaemon()` remplace l'ancien `socket_create(AF_INET…)` par `socket_create(AF_UNIX…)`. +* Le démon envoie ses valeurs avec `jeedom_com.add_changes()`. Avec Jeedom 5, il passe par l'API REST avec un jeton qu'il renouvelle lui-même (`--rest-credentials`). Avec Jeedom 4, il appelle `core/php/jeetemplate.php` avec la clé API du plugin. +* Dans les deux cas, le plugin reçoit les messages dans `template::handleDaemonMessages()`. +* `deamon_info()` ne déclare le démon en service que si son pid est vivant **et** s'il répond sur son socket (ligne `health` → `ok` pour `demond.py`, `GET /health` → `204` pour `jeedom.js`). Un démon figé, ou tué en laissant son socket, est ainsi relancé par Jeedom. +* Pour un démon Node.js, `resources/demond/jeedom/jeedom.js` offre les mêmes possibilités avec `Jeedom.com.config(apikey, callback, cycle, credentials)` et `Jeedom.http.config(socket)`. diff --git a/core/class/template.class.php b/core/class/template.class.php index 962496d..b7206d5 100644 --- a/core/class/template.class.php +++ b/core/class/template.class.php @@ -97,6 +97,126 @@ public static function getConfigForCommunity() { } */ + /* * ***************************Démon******************************* */ + /* À supprimer si le plugin n'a pas de démon (hasOwnDeamon à false dans info.json). */ + + public static function deamon_info() { + $return = array(); + $return['log'] = __CLASS__; + $return['state'] = 'nok'; + $pid_file = jeedom::getTmpFolder(__CLASS__) . '/deamon.pid'; + if (file_exists($pid_file) && @posix_getsid(trim(file_get_contents($pid_file)))) { + // Le démon doit aussi répondre sur son socket : un processus figé ou un pid réutilisé ne suffit pas. + // Avec un démon Node.js (jeedom.js), envoyer GET /health avec com_http et attendre le code 204. + $socket = socket_create(AF_UNIX, SOCK_STREAM, 0); + socket_set_option($socket, SOL_SOCKET, SO_RCVTIMEO, array('sec' => 1, 'usec' => 0)); + if (@socket_connect($socket, self::daemonSocketPath()) && socket_write($socket, "health\n") && trim((string) @socket_read($socket, 16)) == 'ok') { + $return['state'] = 'ok'; + } + socket_close($socket); + } + $return['launchable'] = 'ok'; + return $return; + } + + public static function deamon_start() { + self::deamon_stop(); + $deamon_info = self::deamon_info(); + if ($deamon_info['launchable'] != 'ok') { + throw new Exception(__('Veuillez vérifier la configuration', __FILE__)); + } + // Python de l'environnement du plugin, créé par l'installation des dépendances (section pip3 de packages.json). + $python = is_dir(__DIR__ . '/../../resources/python_venv') ? system::getCmdPython3(__CLASS__) : 'python3 '; + $cmd = $python . escapeshellarg(realpath(__DIR__ . '/../../resources/demond') . '/demond.py'); + $cmd .= ' --loglevel ' . log::convertLogLevel(log::getLogLevel(__CLASS__)); + $cmd .= ' --socket ' . escapeshellarg(self::daemonSocketPath()); + $cmd .= ' --cycle ' . escapeshellarg(config::byKey('cycle', __CLASS__, 0.3)); + $cmd .= ' --pid ' . escapeshellarg(jeedom::getTmpFolder(__CLASS__) . '/deamon.pid'); + $cmd .= self::daemonJeedomArguments(); + log::add(__CLASS__, 'info', 'Lancement du démon'); + exec($cmd . ' >> ' . log::getPathToLog(__CLASS__ . '_daemon') . ' 2>&1 &'); + for ($i = 0; $i < 20; $i++) { + if (self::deamon_info()['state'] == 'ok') { + message::removeAll(__CLASS__, 'unableStartDeamon'); + return true; + } + sleep(1); + } + log::add(__CLASS__, 'error', __('Impossible de lancer le démon, vérifiez le log', __FILE__), 'unableStartDeamon'); + return false; + } + + public static function deamon_stop() { + $pid_file = jeedom::getTmpFolder(__CLASS__) . '/deamon.pid'; + if (file_exists($pid_file)) { + system::kill(intval(trim(file_get_contents($pid_file)))); + } + system::kill('demond.py'); + if (file_exists(self::daemonSocketPath())) { + unlink(self::daemonSocketPath()); + } + } + + /* + * Socket Unix du démon. Seul Jeedom peut l'ouvrir : le PHP n'a pas besoin de clé API pour parler au démon. + */ + public static function daemonSocketPath() { + return jeedom::getTmpFolder(__CLASS__) . '/daemon.sock'; + } + + /* + * Arguments qui permettent au démon d'envoyer ses messages à Jeedom : + * - Jeedom 5 : API REST, avec un jeton propre au démon qu'il renouvelle lui-même ; + * - Jeedom 4 : core/php/jeetemplate.php, avec la clé API du plugin. + */ + private static function daemonJeedomArguments() { + $url = network::getNetworkAccess('internal', 'http:127.0.0.1:port:comp'); + if (method_exists('plugin', 'daemonCredentialFile')) { + try { + $credentials = plugin::daemonCredentialFile(__CLASS__); + } catch (DomainException $e) { + // Session du démon supprimée par Jeedom (expirée ou révoquée) : on lui en ouvre une nouvelle. + $credentials = plugin::daemonCredentialFile(__CLASS__, true); + } + config::save('daemon::transport', 'rest', __CLASS__); + return ' --callback ' . escapeshellarg($url . '/api/v1/plugins/' . __CLASS__ . '/daemon/messages') + . ' --rest-credentials ' . escapeshellarg($credentials); + } + config::save('daemon::transport', 'callback', __CLASS__); + return ' --callback ' . escapeshellarg($url . '/plugins/' . __CLASS__ . '/core/php/jee' . __CLASS__ . '.php') + . ' --apikey ' . escapeshellarg(jeedom::getApiKey(__CLASS__)); + } + + /* + * Envoie un message au démon (reçu dans read_socket() de demond.py). + * Exemple : template::sendToDaemon(array('action' => 'test')); + * + * Avec un démon Node.js (jeedom.js, Jeedom.http.config(socket)), le PHP envoie une requête HTTP sur le socket : + * $request = new com_http('http://localhost/action'); + * $request->setCURLOPT(array(CURLOPT_UNIX_SOCKET_PATH => self::daemonSocketPath())); + * $request->setHeader(array('Content-Type: application/json')); + * $request->setPost(json_encode($params)); + * $request->exec(); + */ + public static function sendToDaemon($params) { + $socket = socket_create(AF_UNIX, SOCK_STREAM, 0); + if ($socket === false || !@socket_connect($socket, self::daemonSocketPath())) { + throw new Exception(__('Le démon ne répond pas', __FILE__)); + } + $payload = json_encode($params) . "\n"; + socket_write($socket, $payload, strlen($payload)); + socket_close($socket); + } + + /* + * Messages envoyés par le démon avec jeedom_com, regroupés par clé : + * add_changes('equipement::temperature', 21.5) donne array('equipement' => array('temperature' => 21.5)). + * Appelée par Jeedom 5 et, avec Jeedom 4, par core/php/jeetemplate.php. + */ + public static function handleDaemonMessages(array $messages) { + log::add(__CLASS__, 'debug', 'Messages du démon : ' . json_encode($messages)); + } + /* * *********************Méthodes d'instance************************* */ // Fonction exécutée automatiquement avant la création de l'équipement diff --git a/core/php/jeetemplate.php b/core/php/jeetemplate.php new file mode 100644 index 0000000..f80d618 --- /dev/null +++ b/core/php/jeetemplate.php @@ -0,0 +1,36 @@ +. + */ + + +/* + * Point d'entrée du démon avec Jeedom 4, appelé avec la clé API du plugin. + * Avec Jeedom 5, le démon envoie ses messages par l'API REST : ce fichier refuse alors tout. + */ +require_once __DIR__ . '/../../../../core/php/core.inc.php'; + +if (config::byKey('daemon::transport', 'template') == 'rest' || !jeedom::apiAccess(init('apikey'), 'template')) { + http_response_code(403); + die(); +} +if ($_SERVER['REQUEST_METHOD'] != 'POST') { + echo 'OK'; // test de connexion du démon au démarrage + die(); +} +$messages = json_decode(file_get_contents('php://input'), true); +if (is_array($messages)) { + template::handleDaemonMessages($messages); +} diff --git a/resources/demond/demond.py b/resources/demond/demond.py index b031edf..554f0e4 100644 --- a/resources/demond/demond.py +++ b/resources/demond/demond.py @@ -28,10 +28,8 @@ def read_socket(): if not JEEDOM_SOCKET_MESSAGE.empty(): logging.debug("Message received in socket JEEDOM_SOCKET_MESSAGE") + # Message envoyé par template::sendToDaemon() : seul Jeedom peut écrire sur le socket Unix. message = json.loads(jeedom_utils.stripped(JEEDOM_SOCKET_MESSAGE.get())) - if message['apikey'] != _apikey: - logging.error("Invalid apikey from socket: %s", message) - return try: print('read') except Exception as e: @@ -74,8 +72,8 @@ def shutdown(): _log_level = "error" -_socket_port = 55009 -_socket_host = 'localhost' +_socket = '' +_rest_credentials = '' _device = 'auto' _pidfile = '/tmp/demond.pid' _apikey = '' @@ -89,7 +87,8 @@ def shutdown(): parser.add_argument("--apikey", help="Apikey", type=str) parser.add_argument("--cycle", help="Cycle to send event", type=float) parser.add_argument("--pid", help="Pid file", type=str) -parser.add_argument("--socketport", help="Port for socket server", type=int) +parser.add_argument("--socket", help="Unix socket for messages from Jeedom", type=str) +parser.add_argument("--rest-credentials", help="Daemon access file for the REST API (Jeedom 5)", type=str) args = parser.parse_args() if args.device: @@ -104,19 +103,21 @@ def shutdown(): _pidfile = args.pid if args.cycle: _cycle = float(args.cycle) -if args.socketport: - _socket_port = args.socketport - -_socket_port = int(_socket_port) +if args.socket: + _socket = args.socket +else: + # Sans socket Unix, le démon écouterait sur un port TCP sans contrôle de la clé API : on refuse. + print('Missing --socket argument: the daemon only listens on a Unix socket') + sys.exit(1) +if args.rest_credentials: + _rest_credentials = args.rest_credentials jeedom_utils.set_log_level(_log_level) logging.info('Start demond') logging.info('Log level: %s', _log_level) -logging.info('Socket port: %s', _socket_port) -logging.info('Socket host: %s', _socket_host) +logging.info('Socket: %s', _socket) logging.info('PID file: %s', _pidfile) -logging.info('Apikey: %s', _apikey) logging.info('Device: %s', _device) signal.signal(signal.SIGINT, handler) @@ -124,12 +125,12 @@ def shutdown(): try: jeedom_utils.write_pid(str(_pidfile)) - my_jeedom_com = jeedom_com(apikey=_apikey, url=_callback, cycle=_cycle) + my_jeedom_com = jeedom_com(apikey=_apikey, url=_callback, cycle=_cycle, credentials=_rest_credentials) if not my_jeedom_com.test(): logging.error('Network communication issues. Please fixe your Jeedom network configuration.') shutdown() # my_jeedom_serial = jeedom_serial(device=_device) # if you need jeedom_serial - my_jeedom_socket = jeedom_socket(port=_socket_port, address=_socket_host) + my_jeedom_socket = jeedom_socket(path=_socket) listen() except Exception as e: logging.error('Fatal error: %s', e) diff --git a/resources/demond/jeedom/jeedom.js b/resources/demond/jeedom/jeedom.js index bce1761..563635e 100644 --- a/resources/demond/jeedom/jeedom.js +++ b/resources/demond/jeedom/jeedom.js @@ -17,6 +17,8 @@ const axios = require('axios'); var express = require('express'); const http = require('http'); +const fs = require('fs'); +const crypto = require('crypto'); axios.defaults.httpAgent = new http.Agent({ keepAlive: false }); @@ -84,26 +86,38 @@ Jeedom.isObject = function(item) { return (item && typeof item === 'object' && !Array.isArray(item)); } +// Les clés viennent de l'extérieur (topics, équipements) : elles sont écrites comme de simples données, +// pour qu'une clé __proto__ ou constructor ne modifie jamais les objets du démon. +Jeedom.setKey = function(target, key, value) { + Object.defineProperty(target, key, { value: value, writable: true, enumerable: true, configurable: true }); +} + Jeedom.mergeDeep = function(target, ...sources) { if (!sources.length) return target; const source = sources.shift(); if (Jeedom.isObject(target) && Jeedom.isObject(source)) { - for (const key in source) { + for (const key of Object.keys(source)) { if (Jeedom.isObject(source[key])) { - if (!target[key]) Object.assign(target, { [key]: {} }); + if (!Object.prototype.hasOwnProperty.call(target, key) || !Jeedom.isObject(target[key])) Jeedom.setKey(target, key, {}); Jeedom.mergeDeep(target[key], source[key]); } else { - Object.assign(target, { [key]: source[key] }); + Jeedom.setKey(target, key, source[key]); } } } return Jeedom.mergeDeep(target, ...sources); } -Jeedom.com.config = function(_apikey,_callback,_cycle){ +/* + * Jeedom 4 : _callback est core/php/jee.php et _apikey la clé API du plugin. + * Jeedom 5 : _callback est /api/v1/plugins//daemon/messages et _credentials le fichier --rest-credentials. + * Les messages arrivent dans la méthode handleDaemonMessages() du plugin. + */ +Jeedom.com.config = function(_apikey,_callback,_cycle,_credentials){ Jeedom.com.apikey = _apikey; Jeedom.com.callback = _callback; Jeedom.com.cycle = _cycle; + Jeedom.com.credentials = _credentials; Jeedom.com.changes = {}; if(Jeedom.com.cycle > 0){ setInterval(function() { @@ -116,57 +130,125 @@ Jeedom.com.config = function(_apikey,_callback,_cycle){ } Jeedom.com.add_changes = function(_key,_value){ - if (_key.indexOf('::') != -1){ - tmp_changes = {} - var changes = _value - var keys = _key.split('::').reverse(); - for (var k in keys){ - if (typeof tmp_changes[keys[k]] == 'undefined'){ - tmp_changes[keys[k]] = {} - } - tmp_changes[keys[k]] = changes - changes = tmp_changes - tmp_changes = {} - } - if (Jeedom.com.cycle <= 0){ - Jeedom.com.send_change_immediate(changes) - }else{ - Jeedom.com.changes = Jeedom.mergeDeep(Jeedom.com.changes,changes) - } - } else{ - if (Jeedom.com.cycle <= 0){ - Jeedom.com.send_change_immediate({_key:_value}) - }else{ - Jeedom.com.changes[_key] = _value - } + // 'a::b' devient { a: { b: valeur } } + var changes = _value + for (const key of _key.split('::').reverse()) { + var parent = {} + Jeedom.setKey(parent, key, changes) + changes = parent + } + if (Jeedom.com.cycle <= 0){ + Jeedom.com.send_change_immediate(changes) + }else{ + Jeedom.com.changes = Jeedom.mergeDeep(Jeedom.com.changes,changes) } } Jeedom.com.send_change_immediate = function(_changes){ Jeedom.log.debug('Send data to jeedom : '+JSON.stringify(_changes)); - axios({ - method : 'POST', - url:Jeedom.com.callback+'?apikey='+Jeedom.com.apikey, - data: JSON.stringify(_changes) - }).catch(function (error) { - Jeedom.log.error('Error on send to jeedom : '+JSON.stringify(error)); + Jeedom.com.post(_changes).catch(function (error) { + Jeedom.log.error('Error on send to jeedom : '+error.message); }) } +Jeedom.com.post = async function(_changes){ + if (!Jeedom.com.credentials) { + return axios({ + method : 'POST', + url:Jeedom.com.callback+'?apikey='+Jeedom.com.apikey, + data: JSON.stringify(_changes) + }) + } + const send = async function() { + return axios.post(Jeedom.com.callback, JSON.stringify({ messages: _changes }), { + headers: { Authorization: 'Bearer ' + await Jeedom.rest.token(), 'Content-Type': 'application/json' }, + validateStatus: () => true, + }) + } + let response = await send() + if (response.status === 401) { + Jeedom.rest.forget() // jeton expiré : on en demande un nouveau + response = await send() + } + if (response.status === 401 || response.status === 403) { + Jeedom.log.error('Accès REST du démon refusé : arrêt, Jeedom lui redonnera un accès au redémarrage') + process.exit(1) + } + if (response.status !== 204) throw new Error('HTTP ' + response.status) +} + Jeedom.com.test = function(){ - axios({ + const check = Jeedom.com.credentials ? Jeedom.com.post({}) : axios({ method:'GET', url:Jeedom.com.callback+'?apikey='+Jeedom.com.apikey - }).catch(function (error) { - Jeedom.log.error('Callback error.Please check your network configuration page : '+JSON.stringify(error)); + }) + check.catch(function (error) { + Jeedom.log.error('Callback error.Please check your network configuration page : '+error.message); process.exit(); }) } +/***************************REST (Jeedom 5)*******************************/ + +/* + * Le fichier transmis par le PHP (--rest-credentials) contient un jeton de renouvellement. Il est échangé + * contre un jeton d'accès valable 24 h et un nouveau jeton de renouvellement, enregistré à sa place. + */ +Jeedom.rest = {} + +Jeedom.rest.token = async function(){ + if (Jeedom.rest.accessToken && Jeedom.rest.expiresAt > Date.now() + 5000) { + return Jeedom.rest.accessToken + } + if (!Jeedom.rest.pending) { + Jeedom.rest.pending = Jeedom.rest.refresh().finally(function() { Jeedom.rest.pending = null }) + } + return Jeedom.rest.pending +} + +Jeedom.rest.forget = function(){ + Jeedom.rest.accessToken = null +} + +Jeedom.rest.refresh = async function(){ + const file = Jeedom.com.credentials + const credentials = JSON.parse(fs.readFileSync(file, 'utf8')) + // La clé est enregistrée avant l'appel : si la réponse se perd, le prochain essai la réutilise + // et Jeedom renvoie la même paire au lieu de croire à un vol du jeton. + const attempt = credentials.refreshAttempt || crypto.randomBytes(16).toString('hex') + Jeedom.rest.store({ refreshToken: credentials.refreshToken, refreshAttempt: attempt }) + const url = Jeedom.com.callback.split('/api/v1/')[0] + '/api/v1/session/refresh' + const response = await axios.post(url, { refreshToken: credentials.refreshToken }, { + headers: { 'Idempotency-Key': attempt }, + validateStatus: () => true, + }) + if (response.status === 401 || response.status === 403) { + Jeedom.log.error('Accès REST du démon refusé : arrêt, Jeedom lui redonnera un accès au redémarrage') + process.exit(1) + } + if (response.status !== 200) throw new Error('Renouvellement du jeton : HTTP ' + response.status) + Jeedom.rest.store({ refreshToken: response.data.refreshToken }) + Jeedom.rest.accessToken = response.data.accessToken + Jeedom.rest.expiresAt = Date.parse(response.data.accessExpiresAt) + return Jeedom.rest.accessToken +} + +Jeedom.rest.store = function(credentials){ + const temp = Jeedom.com.credentials + '.tmp' + fs.writeFileSync(temp, JSON.stringify(credentials), { mode: 0o600 }) + fs.renameSync(temp, Jeedom.com.credentials) +} + /***************************HTTP SERVER*******************************/ +/* + * Serveur HTTP qui reçoit les demandes du PHP. + * Avec un chemin (--socket), il écoute sur un socket Unix que seul Jeedom peut ouvrir : plus besoin de clé API. + * Avec un numéro de port, ancien fonctionnement sur 127.0.0.1 avec la clé API. + */ Jeedom.http.config = function(_port,_apikey){ Jeedom.http.apikey = _apikey; + Jeedom.http.socket = typeof _port === 'string' && _port.startsWith('/'); Jeedom.http.app = express(); Jeedom.http.app.use(express.urlencoded({limit: '5mb', extended: true })); Jeedom.http.app.use(express.json({limit: '5mb'})); @@ -174,13 +256,25 @@ Jeedom.http.config = function(_port,_apikey){ res.setHeader('Content-Type', 'text/plain'); res.status(404).send('Not found'); }); + // Contrôle de deamon_info() : le démon répond 204 tant qu'il traite les requêtes. + Jeedom.http.app.get('/health', function(req, res) { + res.status(204).end(); + }); + if (Jeedom.http.socket) { + if (fs.existsSync(_port)) fs.unlinkSync(_port); + process.umask(0o077); // socket accessible au seul compte de Jeedom + Jeedom.http.app.listen(_port, function() { + Jeedom.log.debug('HTTP listen on socket ' + _port + ' started'); + }); + return; + } Jeedom.http.app.listen(_port,'127.0.0.1', function() { Jeedom.log.debug('HTTP listen on 127.0.0.1 port : '+_port+' started'); }); } Jeedom.http.checkApikey = function(_req){ - return (_req.query.apikey === Jeedom.http.apikey) + return Jeedom.http.socket || (_req.query.apikey === Jeedom.http.apikey) } /***************************EXPORTS*******************************/ diff --git a/resources/demond/jeedom/jeedom.py b/resources/demond/jeedom/jeedom.py index 0717b1e..6af7a7d 100644 --- a/resources/demond/jeedom/jeedom.py +++ b/resources/demond/jeedom/jeedom.py @@ -16,7 +16,11 @@ import time import logging -from threading import Thread +import fcntl +import json +import secrets +from datetime import datetime +from threading import Thread, Lock import requests from collections.abc import Mapping import serial @@ -28,13 +32,74 @@ import pyudev +class jeedom_rest_access(): + """Jeton du démon pour l'API REST de Jeedom 5. + + Le fichier transmis par le PHP (--rest-credentials) contient un jeton de renouvellement. Il est échangé + contre un jeton d'accès valable 24 h et un nouveau jeton de renouvellement, enregistré à sa place. + """ + + def __init__(self, path, messages_url): + self._path = path + self._refresh_url = messages_url.split('/api/v1/')[0] + '/api/v1/session/refresh' + self._token = None + self._expires = 0 + self._lock = Lock() + + def token(self): + with self._lock: + if self._token is None or self._expires < time.time() + 5: + self._refresh() + return self._token + + def forget(self): + self._token = None + + def _refresh(self): + # Même verrou que plugin::daemonCredentialFile() côté PHP. + with open(self._path + '.lock', 'a') as lock: + fcntl.flock(lock, fcntl.LOCK_EX) + with open(self._path) as file: + credentials = json.load(file) + # La clé est enregistrée avant l'appel : si la réponse se perd, le prochain essai la réutilise + # et Jeedom renvoie la même paire au lieu de croire à un vol du jeton. + attempt = credentials.get('refreshAttempt') or secrets.token_hex(16) + self._store({'refreshToken': credentials['refreshToken'], 'refreshAttempt': attempt}) + response = requests.post(self._refresh_url, json={'refreshToken': credentials['refreshToken']}, + headers={'Idempotency-Key': attempt}, timeout=10, verify=False) + if response.status_code in (401, 403): + raise jeedom_access_lost('Accès REST du démon refusé par Jeedom (HTTP %s)' % response.status_code) + response.raise_for_status() + data = response.json() + self._store({'refreshToken': data['refreshToken']}) + self._token = data['accessToken'] + self._expires = datetime.fromisoformat(data['accessExpiresAt'].replace('Z', '+00:00')).timestamp() + + def _store(self, credentials): + temp = self._path + '.tmp' + with open(os.open(temp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), 'w') as file: + json.dump(credentials, file) + os.replace(temp, self._path) + + +class jeedom_access_lost(Exception): + """Jeedom a supprimé l'accès du démon : seul un redémarrage par Jeedom lui en redonne un.""" + + class jeedom_com(): - def __init__(self, apikey='', url='', cycle=0.5, retry=3): + """Envoi des messages du démon au plugin, reçus par sa méthode handleDaemonMessages(). + + Jeedom 4 : url est core/php/jee.php et apikey la clé API du plugin. + Jeedom 5 : url est /api/v1/plugins//daemon/messages et credentials le fichier --rest-credentials. + """ + + def __init__(self, apikey='', url='', cycle=0.5, retry=3, credentials=''): self._apikey = apikey self._url = url self._cycle = cycle self._retry = retry self._changes = {} + self._rest = jeedom_rest_access(credentials, url) if credentials else None if self._cycle > 0: Thread(target=self.__thread_changes_async, daemon=True).start() logging.info('Init request module v%s', requests.__version__) @@ -81,16 +146,30 @@ def __post_change(self, change): logging.debug('Send to jeedom: %s', change) for i in range(self._retry): try: - r = requests.post(self._url + '?apikey=' + self._apikey, json=change, timeout=(0.5, 120), verify=False) - if r.status_code == requests.codes.ok: + if self.__post(change): return True - else: - logging.warning('Error on send request to jeedom, return code %s', r.status_code) + except jeedom_access_lost as error: + logging.error('%s : arrêt du démon, Jeedom lui redonnera un accès au redémarrage', error) + os._exit(1) except Exception as error: logging.error('Error on send request to jeedom "%s" retry: %i/%i', error, i, self._retry) time.sleep(0.5) return False + def __post(self, change): + if self._rest is None: + r = requests.post(self._url + '?apikey=' + self._apikey, json=change, timeout=(0.5, 120), verify=False) + expected = requests.codes.ok + else: + r = requests.post(self._url, json={'messages': change}, timeout=(0.5, 120), verify=False, + headers={'Authorization': 'Bearer ' + self._rest.token()}) + if r.status_code == 401: + self._rest.forget() # jeton expiré : le prochain essai en demande un nouveau + expected = 204 + if r.status_code != expected: + logging.warning('Error on send request to jeedom, return code %s', r.status_code) + return r.status_code == expected + def set_change(self, changes): self._changes = changes @@ -106,6 +185,12 @@ def merge_dict(self, d1, d2): d1[k] = v2 def test(self): + if self._rest is not None: + try: + return self.__post({}) + except Exception as e: + logging.error('Jeedom REST API error: %s', e) + return False try: response = requests.get(self._url + '?apikey=' + self._apikey, verify=False) if response.status_code != requests.codes.ok: @@ -155,7 +240,10 @@ def find_tty_usb(idVendor, idProduct, product=None): @staticmethod def stripped(str): - return "".join([i for i in str if i in range(32, 127)]) + # Le socket fournit des octets : ils sont décodés, puis les caractères de contrôle sont retirés. + if isinstance(str, bytes): + str = str.decode('utf-8', errors='ignore') + return "".join([i for i in str if ord(i) >= 32]) @staticmethod def ByteToHex(byteStr: bytes): @@ -284,23 +372,36 @@ def readbytes(self, number): class jeedom_socket_handler(StreamRequestHandler): def handle(self): global JEEDOM_SOCKET_MESSAGE - logging.info("Client connected to [%s:%d]", self.client_address[0], self.client_address[1]) lg = self.rfile.readline() + if lg.strip() == b'health': + # Contrôle de deamon_info() : le démon répond sans passer par la file des messages. + self.wfile.write(b'ok\n') + return JEEDOM_SOCKET_MESSAGE.put(lg) - logging.info("Message read from socket: %s", str(lg.strip())) + logging.debug("Message read from socket: %s", str(lg.strip())) self.netAdapterClientConnected = False - logging.info("Client disconnected from [%s:%d]", self.client_address[0], self.client_address[1]) class jeedom_socket(): + """Réception des messages du PHP. Avec path, le démon écoute sur un socket Unix que seul Jeedom peut + ouvrir : plus besoin de clé API ni de port. Sans path, ancien fonctionnement sur un port TCP local : + le démon doit alors vérifier la clé API de chaque message.""" - def __init__(self, address='localhost', port=55000): + def __init__(self, address='localhost', port=55000, path=None): self.address = address self.port = port + self.path = path socketserver.TCPServer.allow_reuse_address = True def open(self): - self.netAdapter = TCPServer((self.address, self.port), jeedom_socket_handler) + if self.path: + if os.path.exists(self.path): + os.remove(self.path) + os.umask(0o077) # socket accessible au seul compte de Jeedom + self.netAdapter = socketserver.ThreadingUnixStreamServer(self.path, jeedom_socket_handler) + self.address, self.port = self.path, 0 + else: + self.netAdapter = TCPServer((self.address, self.port), jeedom_socket_handler) if self.netAdapter: logging.info("Socket interface started") Thread(target=self.loopNetServer).start() @@ -309,7 +410,7 @@ def open(self): def loopNetServer(self): logging.info("LoopNetServer Thread started") - logging.info("Listening on: [%s:%d]", self.address, self.port) + logging.info("Listening on: %s", self.path or '%s:%d' % (self.address, self.port)) self.netAdapter.serve_forever() logging.info("LoopNetServer Thread stopped")