Documentation de la solution web de gestion OpenFlyers - User contributions [en]

Installation armoire à clés

2024-12-10T10:52:05Z

Jtremblet: /* Navigateur */

=Présentation=
L'objet de cette page est de décrire la procédure d'installation d'une [[Contrôle des accès#Armoires_à_clés_Deister_commercialiées_par_OpenFlyers|armoire à clés Deister ProxSafe Smart vendue par OpenFlyers]] et équipée du mini-serveur OpenFlyers.

=Préparation du réseau avant réception de l'armoire=
''La procédure décrite dans ce paragraphe peut être effectuée avant la réception de l'armoire. A défaut, de préparation anticipée, elle doit être effectuée '''avant''' tout branchement de l'armoire à clés sauf dans le cas d'une Livebox d'orange où il est nécessaire d'effectuer d'abord le branchement du matériel pour pouvoir ensuite effectuer la configuration du routeur. Dans ce cas, il faut d'abord suivre la procédure [[#Connexion_de_l'armoire|connexion de l'armoire et ensuite revenir sur ce paragraphe]]''

L'utilisation de l'armoire à clés Deister, nécessite 1 raccordement électrique 220v avec les 3 câbles (phase, neutre et terre) ainsi que 2 connexions RJ45 au réseau local via un routeur, en général une "box" :
*une pour le mini-serveur OpenFlyers
*une pour l'armoire à clés.

Le réseau doit être configuré en DHCP ce qui signifie que toute connexion au réseau est automatiquement reconnue et qu'une adresse IP est automatiquement affectée à cette connexion. Par défaut, les "box" des fournisseurs d'accès sont configurées selon ce mode là.

Cependant pour que le serveur OpenKey et l'armoire à clé puissent communiquer entre-eux et avec le logiciel OpenFlyers, les adresses IP attribuées par le routeur doivent être fixes. Pour forcer le routeur à attribuer toujours la même adresse IP à un équipement il faut le configurer en créant l'association d'une [[Wikipedia-fr:Adresse_IP|adresse IP]] à l'[[Wikipedia-fr:Adresse_MAC|adresse MAC]] du matériel.

Les adresses IP et MAC à configurer vous sont communiquées dans un e-mail qu'OpenFlyers envoie après la commande de l'armoire à clés et qui sont également indiquées le bordereau de livraison.

Ce paramétrage se fait soit directement dans l'interface de gestion du routeur ou par l'intermédiaire de l'interface de gestion de la "box" de votre fournisseur d'accès et dépend du matériel que vous disposez.
==Configuration du routeur==
Le routeur d'un fournisseur d'accès internet correspond à la "box".

===Configuration d'un Routeur NETGEAR Numericable===
''Cette documentation a été rédigée à partir d'un routeur NETGEAR CBVG834G''
*Aller sur la page d'administration du routeur. Elle est par défaut sous la forme http://192.168.0.1
*Saisir l'identifiant et le mot de passe
''Rédiger la redirection des ports''
*Aller '''Paramètres avancés > IP LAN'''
*Dans le 2ème formulaire, saisir dans les lignes '''Adresse MAC''' et '''Adresse IP''' les couples (adresse IP, adresse MAC) communiqués dans le bordereau de livraison et cliquer à après la saisie de chaque couple sur le bouton '''Ajouter''' de sorte à obtenir le tableau suivant :
''Copie d'écran à insérer''
*Débrancher 5 secondes le routeur puis le rebrancher.

===Configuration d'une Box BBox===
Il faut au préalable connecter l'armoire afin que la BBox lui affecte par défaut une adresse IP.
*Connecter vous sur votre BBox en tapant son IP 192.168.1.254 et mettre le mot de passe
* Déployer le menu '''Service de la box''' et sélectionner DHCP

[[File:BBox_acces_DHCP.jpg]]
* Allez dans la rubrique '''Attribution adresse IP Statique'''
* Cliquer sur ajouter un équipement
Sélectionner l'adresse MAC de l'équipement et le nommer pour plus de clarté

[[File:BBox_config_adresse_IP_fixe.jpg]]
* Refaire l'opération pour le Raspberry Pi

[[File:BBox_adresse_IP_fixe.jpg]]

===Configuration d'une Box SFR===
Il faut au préalable connecter l'armoire et le module Raspberry Pi par câbles RJ45 et l'alimenter afin que la Box SFR lui affecte par défaut une adresse IP.
*Connecter vous sur votre Box SFR en tapant son IP 192.168.1.1
*Cliquer sur Réseau V4/Général
*Mettre l'identifiant et mot de passe
*Vous visualiser les Postes connectés, il doit y en avoir deux supplémentaires à votre configuration habituelle
*Notez les adresses MAC des deux équipements (celles ci vous ont été communiquées dans le bon de livraison)
*Aller dans Réseau V4/DHCP
*Dans la section Adresses statiques
**Associez l'adresse 192.168.1.200 à l'adresse MAC du Raspberry Pi et cliquez sur le bouton + à droite
**Associez l'adresse 192.168.1.201 à l'adresse MAC de l'armoire Deister et cliquez sur le bouton + à droite

[[File:Keypanel2012-redirection-de-ports-SFR.PNG|center]]

*Déconnecter l'alimentation de l'armoire et la réalimenter après 10 secondes d'attente pour visualiser les nouvelles affectations d'IP statiques

===Configuration d'une Freebox v4===
*Aller sur [https://subscribe.free.fr/login/ l'espace client]
*Saisir l'identifiant et le mot de passe
*Aller '''Ma Freebox > Configurer mon routeur Freebox'''
*Dans '''Configuration > Configuration du routeur''', vérifier que l''''Adresse IP Freebox''' est 192.168.0.254
*Cliquer sur '''Redirections / Baux DHCP''' pour faire dérouler le contenu
*Dans le paragraphe '''Redirections de ports''', à côté de l’icône symbolisant un "plus" :
**Dans le champ de la colonne '''PORT EXTERNE''' saisir ''8000''
**Dans les champs de la colonne '''IP DE DESTINATION''' saisir ''192.168.0.200''
**Dans le champ de la colonne '''PORT INTERNE''' saisir ''8000''
**Cliquer sur l'icône symbolisant un "plus" de sorte à ce que la ligne vienne s'ajouter en-dessous
*Répéter cette opération de sorte à obtenir le tableau suivant :

[[File:Keypanel2012-redirection-de-ports-freebox.png|center]]

*Dans le paragraphe '''Baux DHCP permanents''', saisir sur la ligne avec l'icône symbolisant un "plus" les couples (adresse IP, adresse MAC) communiqués dans le bordereau de livraison de sorte à obtenir le tableau suivant :

[[File:Keypanel2012-Baux-DHCP-permanents-freebox.png|center]]

*En bas du formulaire, cliquer sur le bouton '''Sauvegarder les paramètres'''
*Débrancher 5 secondes la freebox puis la rebrancher.
*Une fois l'armoire à clés livrée, passer à l'étape de [[Installation armoire à clés#Connexion_de_l'armoire|connexion de l'armoire]].

===Configuration d'une Freebox v6===
A effectuer avec l'armoire connectée au réseau local de la Freebox
*Dans un navigateur d'un appareil connecté au réseau local de la Freebox concernée : http://mafreebox.freebox.fr
*Saisir le mot de passe de connexion à la Freebox
*Double-cliquer sur le bouton '''Paramètres de la Freebox'''
*Cliquer sur l'onglet en haut '''Mode avancé'''
*Double-cliquer le bouton '''DHCP'''
*Cliquer sur l'onglet '''Baux actifs'''
*Identifier dans la liste l'armoire à clés
*Faire un clic droit et cliquer sur le bouton contextuel '''Ajouter un bail statique'''
*Compléter l'adresse IP statique avec l'adresse IP communiqué dans le bordereau de livraison
*Indiquer éventuellement un commentaire pour permettre de repérer plus facilement l'élément dans la liste
*Cliquer le bouton '''Valider'''
*Vérifier dans '''Baux statiques''' qu'apparait bien le nouvel élément

===Configuration d'une Livebox Orange===
Pour se connecter à l'interface d'une Livebox Orange, il faut :
*[[Trucs-et-astuces#Trouver-l'adresse-IP-du-routeur|Trouver l'adresse IP du routeur]].
*Taper cette adresse dans la barre d'adresse du navigateur.
*Saisir le couple identifiant mot de passe du routeur. C'est par défaut (admin, admin). ''Il est recommandé de modifier ce mot passe.''
Ensuite, la procédure dépend du [http://assistance.orange.fr/livebox-tous-les-modeles-524.php modèle de Livebox]. Nous mettons ci-dessous les procédures en fonction des demandes et des difficultés rencontrées par les administrateurs.

''Attention, pour configurer correctement le routeur, il faut mettre les couples (adresses IP, adresses MAC) au niveau de la configuration des adresses IP statiques et non pas au niveau du filtrage du réseau Wifi (WAN).''

====Livebox 2 de Sagem====
La procédure ci-dessous permet d'associer les couples (adresse IP, adresse MAC) uniquement lorsque l'armoire à clé est connectée.
* '''Configuration'''
* Menu de gauche '''Réseaux & Services > Équipements > Visualiser'''
* Deux nouvelles icônes doivent apparaitre
* Cliquer dessus chaque icône, vérifier à quel matériel l'adresse MAC correspond (inscrit sur le bordereau de livraison de l'armoire à clés) et renommer chaque icône en "Armoire à clés" et "Daemon RPi" pour une identification plus aisée.
Attention : orange rajoute ses propres noms qui ne simplifient pas la reconnaissance du matériel.
*Retourner dans l'onglet '''Configuration'''
*Menu de gauche '''Réseaux & Services > Livebox > Paramètres avancés'''
*Onglet '''DHCP'''
*Section '''Adresse IP statique'''
*Cliquer sur '''Ajouter'''
[[File:LiveBox.JPG]]
*Sélectionner dans le menu déroulant '''Armoire à clés'''
*Saisir l'adresse "192.168.1.201"
*Cliquer sur '''Ajouter'''
*Sélectionner dans le menu déroulant '''Daemon RPi'''
*Saisir l'adresse "192.168.1.200"
*Cliquer sur le bouton '''Sauver'''
*Réinitialiser la Livebox
Il ne faut pas se fier à l'interface livebox pour la reconnaissance de l'armoire à clés car il semblerait qu'il existe un défaut d'affichage de l'état de connexion de l'armoire à clés dans cette interface. A la place il faut [[Gestion armoire à clés#Vérifier_les_connexions_réseaux_de_l'armoire_et_du_mini-serveur|vérifier la bonne attribution des couples (adresse IP, adresse MAC) en ligne de commande]].

=Fixation de l'armoire DEISTER ProxSafe Smart II=
L'armoire a un encombrement murale de 630 mm x 300 mm et une profondeur de 200 mm

L'arrière du coffret comporte un capteur de détection d'arrachement, veillez à ce que la zone d'appui soit affleurante aux fixations du coffret

La face arrière du coffret est espacé de 20 mm des fixations murales. Ceci permet le cheminement des câbles (alimentation + 2 Ethernet)

Pour accéder aux fixations de l'armoire il faut ouvrir la porte de service. Prendre la clé dans la pochette rouge fournie avec l'armoire, ouvrir la porte de façade en tournant la clé dans le sens horaire. Ouvrir la porte de service en tournant la clé dans le sens anti-horaire

Sa fixation murale dépend du type de mur sur lequel vous l'installez

==Fixation de l'armoire sur un mur robuste==
Elle peut dans ce cas être fixée que par les 2 orifices traversants avec 2 vis

[[File:DEISTER_ _Support_fixation_ _dos_armoire.jpg]]

[[Media:DEISTER_fixation_SMART U II.pdf]]

*Entraxe 406 mm,
*Diamètre 10 mm,
*Profondeur 20 mm
Les fixations dépendent de la nature du support, nous conseillons :
* Dans du bois : 2 tire-fonds de 8 x 70
* Dans du béton : 2 chevilles à expansion M8 x 55 + 2 vis M8 x 60
* Dans de la brique alvéolaire : 2 chevilles à scellement chimique M8 + rondelles et écrous (ou bien voir ci dessous)

Ces fixations sont aussi suffisantes si l'armoire est supportée sur un meuble ou une étagère

==Fixation de l'armoire sur un mur de résistance modérée==
Le support de fixation fournit permet de répartir les efforts. Il est vivement recommandé pour une pose similaire à celle d'une fixation d'une télévision à écran plat murale

[[File:DEISTER_ _Support_fixation.jpg]]

Il présente les avantages suivants :
*Il permet de faire l'installation seul (pas besoin d'être à deux)
*Il permet un réglage de horizontalité pour une mise niveaux plus aisée
*Il réduit le risque de chute (l'armoire pèse 20kg) et de l'endommager en la faisant tomber lors de son installation.
Ce support ne reprend que les efforts verticaux, il ne dispense pas des 2 fixations centrales qui pourront alors être de résistance moindre. Le support comporte 8 orifices de fixations de diamètre 8 mm, le nombre de fixations sera adaptée au type de support
*Placo, chevilles à grande expansion (type "Molly") M6 x 65 ou DuoPower de Fisher + vis 7 x 60
*Brique plâtrière, carreau de plâtre, parpaing, béton cellulaire : cheville plastique de 10 x 50 + vis 6 ou 8 de longueur 60 mm

Ne pas négliger les fixations, les sollicitations dans un club peuvent être sévères

=Connexions de l'armoire DEISTER ProxSafe Smart II=

Ne brancher la batterie qu'au moment de la [[#Finalisation|finalisation]], c'est à dire une fois que l'armoire est correctement installée et configurée à la plateforme OpenFlyers. En effet, il peut être nécessaire de faire plusieurs reboots de l'armoire en débranchant/rebranchant l'armoire du secteur. De ce fait, si la batterie est branchée, le reboot ne pourrait se faire en débranchant l'alimentation.

Les câbles suivants doivent être passés avant la fixation définitive au mur :
*Câble d'alimentation 220v
*Câble Ethernet entre le routeur et l'armoire
*Câble Ethernet entre le routeur et le mini-serveur OpenFlyers
Fixer l'armoire au mur par 4 chevilles et vis en ayant au préalable retiré l’adhésif de maintien de l’interrupteur qui sert à détecter une tentative de vandalisme
*Identifier le serveur OpenKey situé derrière le verrou de porte
*Vérifier que la carte microSDHC est correctement enfichée dans le logement du serveur OpenKey situé derrière la carte électronique.
*Brancher un câble Ethernet sur le serveur OpenKey
*Identifier la prise RJ45 de l'armoire et y brancher un câble Ethernet :
*Brancher le câble d'alimentation 220V en y joignant le câble de l'armoire correspondant à la "terre" (câble jaune et vert) :
*Bien vérifier que la terre soit raccorder sur le connecteur et que votre installation dispose d'un disjoncteur différentielle approprié
[[File:Connexion_Alim_SmartII.jpg]]
*Brancher l'alimentation sur le secteur.
**1 voyant vert, sur l'alimentation signal que l'alimentation est correctement connectée
**1 voyant rouge, sur le module serveur Openkey signal que la carte est fonctionnelle, un voyant vert cligne lorsque des signaux sont échangé sur le réseaux
**5 voyants leds, situés sur la carte mère de l'armoire doivent s'éclairer
**2 leds sur chaque connecteur RJ45, indique que la connexion au réseau est fonctionnelle : orange fixe et clignement vert
*Refermer la porte de service puis la porte de façade
*A l'initialisation de l'armoire les voyants en haut de la face avant signale les phases de démarrage
** Jaune clignotant durant l'initialisation de la carte mère de l'armoire
** Jaune fixe en fin d'initialisation
** Si la configuration du programme est faite le voyant Jaune s'eteint, le voyant rouge s'allumera pour test puis le voyant vert fixe signale la fin de l'initialisation du serveur OpenKey

=Configuration OpenFlyers=

==Navigateur==

*Dialogue avec l'armoire en HTTPS : nous privilégions le navigateur Chrome de Google pour la connexion avec l'armoire à clés. Ce navigateur est compatible avec le certificat de sécurité autosigné installé sur le daemon PyOpenKey et sur le(s) PC permettant l'accès à l'armoire.
*Le ou les PC de la structure doivent être paramétrés pour que ce soit ce navigateur qui soit utilisé.

=== Installation du certificat de sécurité sur PC Windows ===
En cas de changement de PC le certificat de sécurité doit être installé

Avant le changement du PC récupérer la clé public sur une clé USB. Par défaut elle est situé dans le répertoire :
'''C:\Users\OpenFlyers\PyOpenKey\SSL\opkServer.crt'''

Ce certificat est au format texte codé en base 64

En tant qu'administrateur créer les répertoires devant recevoir le certificat
*Ouvrir l'explorateur et le répertoire Utilisateur
*Clic droit puis dans le menu popup sélectionné '''Nouveau > Dossier'''
*Nommer le '''OpenFlyers'''
*Ce déplacer dans ce nouveau répertoire
*Clic droit puis dans le menu popup sélectionné '''Nouveau > Dossier'''
*Nommer le '''PyOpenKey'''
*Ce déplacer dans ce nouveau répertoire
*Clic droit puis dans le menu popup sélectionné '''Nouveau > Dossier'''
*Nommer le '''SSL'''
*Copier le certificat '''opkServer.crt''' situé sur votre clé USB dans ce répertoire

L'activation du certificat doit être faite dans chaque environnement utilisant OpenFlyers

L'installation sur le nouveau PC s'effectue en ligne de commande

Ouvrir l'interface de ligne de commande de Windows
* Exécuté la commande '''cmd''' dans la zone de recherche de la barre de tache de Windows
* Cliquer sur '''Invite de commande''', ceci affiche la fenêtre noir Windows de ligne de commande
* Exécuter la commande '''certutil -addstore -f -user root "C:\Users\OpenFlyers\PyOpenKey\SSL\opkServer.crt"'''

==Paramétrage OpenFlyers==

*Aller dans '''Admin > Structure > Paramétrage > Contrôle d'accès'''
*Activer les interrupteurs '''Contrôle d'accès''' et '''Gestion armoire à clés'''
*Cliquer sur le bouton '''Enregistrer'''
[[File:Config_parametres_OF_controle_acces 1.jpg|1200px]]

*De nouveaux champs sont alors visibles :
**Activer l'interrupteur '''Gestion des clés'''
** sélectionner le Logiciel de contrôle de l'armoire à clés. Pour OpenFlyers version 4.2 en https : PyOpenKey4
*De nouveaux champs sont alors visibles :
**Champ '''Nombre de clés''' : indiquer le nombre de clés que l'armoire peut accueillir (8, 16 ou 32)
*Dans la rubrique '''IP du PC contenant le logiciel de contrôle''' indiquer l'adresse IP du mini-serveur OpenFlyers, par défaut '''192.168.0.200''' ou '''192.168.1.200'''
*Dans la rubrique '''Port du PC contenant le logiciel de contrôle''' indiquer le port '''4080''' (ou autre si spécifié sur le bordereau de livraison)
**L'interrupteur '''Vérifier la présence de la clé lors de la fermeture d'activité'''. Il est recommandé de l'activer.
**Choisissez la durée de '''Temporisation''' pour prendre la clé. Cette durée est uniquement valide pour la prise de clé en mode locale, elle dépend de la distance entre votre PC et l'armoire. 10 à 20 secondes sont des valeurs usuelles. Pour la durée de déclenchement par le logiciel celle ci est paramétrable dans le programme du mini serveur. Demander au support OF pour modification
**L'interrupteur '''Fermeture automatique des activités au retour de la clé'''. Il est recommandé de le désactiver.
**Champ '''Phrase mot de passe''', saisir la même phrase que celle paramétrée lors de la configuration de l'armoire
[[File:Config_parametres_OF_controle_acces 3.jpg|1200px]]
*Cliquer sur le bouton '''Enregistrer'''
*Aller dans '''Admin > Utilisateurs > Profils''' et vérifier que le profil sous lequel vous êtes connecté possède le droit '''Gestion des clés''' dans l'onglet '''Généralité admin'''

=Première connexion=
==Brancher l'alimentation de l'armoire à clés==
*Le voyant vert de l'armoire doit s'allumer après quelques minutes
*Le voyant orange reste allumé durant la phase de connexion au serveur OpenFlyers et la vérification de la concordande de la position des clés dans l'armoire
*A la fin de l'initialisation, si toutes les clés sont bien positionnées, le voyant orange s’éteint

Si le voyant orange ne s'éteint pas, [[Gestion armoire à clés#Remettre_les_clés_à_leur_bonne_position|vérifier si le problème ne vient pas de la position d'une ou plusieurs clés]].

== Vérifier la communication avec le serveur PyOpenKey ==
Ce chapitre concerne les utilisateurs d'OpenFlyers 4.2 et au delà qui demande une connexion au serveur PyOpenKey en https

Vérifier si le certificat est correctement reconnu sur votre PC

*Ouvrer le Navigateur Google Chrome
*Dans le champ url indiquer l'adresse du WevServer de PyOpenKey, port 8000 '''https;//192.168.1.200:8000''' (cette adresse est a adapter en fonction de votre configuration réseau)
*Si c'est une première connexion, une fenêtre Windows s'ouvre vous demandant la confirmation de l'utilisation du certificat
*Si la fenêtre Windows indique que la connexion n'est pas sécurisé c'est que le certificat n'est pas correctement installé. Ne pas valider une exception de sécurité
*Si le certificat est reconnu alors la page du [[Gestion-armoire-à-clés#Connexion-à-l'interface-Web-de-secours|Webserver]] doit s'ouvrir

=Appariement des clés aux ressources=
*Pour attribuer les clés aux ressources dans OpenFlyers il faut aller dans la page '''Gestion > Ressources > Actives'''
*Sélectionner un numéro de clé pour chaque ressource.
[[File:Page_Ressource.jpg|center]]

Sur les versions au-delà d'OpenFlyers 4.2, si aucune action ne s'exécute ceci être dû à la non reconnaissance du certificat

Voir [[Installation-armoire-à-clés#Vérifier-la-communication-avec-le-serveur-PyOpenKey |Vérifier la communication avec le serveur PyOpenKey]].

Sur les versions antérieures d'OpenFlyers 4.2, si l'action ne s'exécute pas ceci peut être dû au blocage par le navigateur des scripts javascript car l'appel est en http sur une page https.

Sous Google Chrome apparait un icône en haut à droite
[[File:Page_Allow_mixed_content_Chrome.png|center]]
Avec le message
<bash>This page is trying to load scripts from unauthenticated sources</bash>
Avec un lien pour autoriser la page
<bash>Load unsafe script</bash>

=Enregistrer la position souhaitée des clés=
*Aller dans '''Gestion > Ressources > Actives'''
*Cliquer sur l'un des icônes symbolisant une clé dans la colonne '''Armoire à clé > Statut''' afin de pouvoir déverrouiller la porte.
*Mettre '''toutes les clés''' au tableau dans l'ordre souhaité y compris les clés qui avaient été retirées lors de la [[#Première_connexion|première connexion]]. Il ne faut pas tenir compte des lumières rouges autour des clés.
*Cliquer sur l'icône '''Activer les tags des clés'''
Les identifiants de chaque clé doivent apparaître après rafraîchissement de la page :

[[File:Ressources_activees.jpg|center]]

Si ce n'est pas le cas, rafraichir manuellement la page en allant dans '''Gestion > Ressources > Actives'''.

Débranchez de nouveau l'armoire pour refaire l'initialisation

=Prise de clé à l'ouverture d'un vol=
Pour un contrôle de la prise de clé par un utilisateur il faut que le logiciel soit paramétré avec l'option '''Ouverture et fermeture des activités.''' Aller dans '''Admin > Structure > Structure > Paramétrage''' et dans la rubrique '''Gestion des activités''' activer l'option '''Ouverture et fermeture des activités'''
.
[[File:Gestion_des_vols.JPG]]

Pour une prise de clé il faut cliquer droit sur une réservation et choisir l'option Saisir un vol
La page de saisie d'un vol s'ouvre avec l'option Départ en vol
Renseigner les champs et cliquer sur Valider
Une page de prise de clé s'ouvrira

[[File:Prise_de_cle.JPG]]

Cliquer sur le bouton Libérer la clé pour l'aéronef F-XXXX
La porte doit se déverrouiller (voyant orange) et la clé être libérer durant la temporisation prévue (clé entourée d'un halo lumineux rouge)
Refermer la porte sinon un buzzer intermittent retenti

Déconnectez-vous de OpenFlyers pour l'utilisateur suivant

=Retour de vol=

Pour remettre la clé, se connecter sur OpenFlyers
Cliquer sur l'icône Ouvrir la porte en haut à gauche de la page du cahier de réservation

[[File:Ouvrir_porte.JPG]]

La porte sera déverrouillé durant la durée de la temporisation
*Remettre la clé à son emplacement
*Si la clé est incorrectement placée, l'armoire déverrouille la clé (halo rouge de la clé reposée) et signale l'emplacement correct en allumant le halo rouge de l'emplacement prévu.
*Sur le planning l'avion en vol est indiquer par une couleur bleu. Survoler ce vol avec la souris
*Un menu apparait avec l'option '''Fermer le vol'''
*Cliquer et enregistré le vol

'''Note:''' Ne pas aller directement sur le menu '''Planning > Activités > Saisir une activité''' pour fermer le vol. Dans ce cas il ne pourra être établi de corrélation entre l'affichage du planning et le vol que vous fermez. Le vol restera ouvert (en bleu sur le planning) et l'avion sera bloqué pour repartir en vol. Néanmoins si un pilote faire l'erreur alors il faut, dans le menu surgissant, cliquer sur '''Annuler'''

=Finalisation=
*Ouvrir la porte de service
*Brancher le connecteur de la batterie de sauvegarde (Déconnecté pour le transport)

[[File:Connexion_Batterie_SmartII.jpg]]
*Refermer la porte de service

L'ouverture de la porte de service enclenche une alarme qui est mise en mémoire dans OpenFlyers. Pour supprimer l'alarme il faut aller sur l'interface [[Gestion armoire à clés#Connexion_interface_Web_de_secours|Web admin]] et cliquer sur '''RESET'''

Interfaçage OpenFlyers et armoire à clés

2024-12-10T10:24:24Z

Jtremblet: /* Modification de l'état d'une clé */

__TOC__

=Présentation=
L'objet de cette page est de décrire le protocole d'interfaçage avec toute solution d'armoire à clés tiers. Pour les armoires à clés commercialisées par OpenFlyers, il faut se référer à la [[Contrôle des accès|documentation sur le contrôle d'accès]].

Le protocole repose sur le principe que l'interfaçage est réalisé par un logiciel de contrôle de l'armoire à clé sur un PC ou une solution embarquée et qui dispose d'un accès à internet lui permettant de communiquer avec OpenFlyers. La communication est synchrone.

=Interface utilisateur OpenFlyers=
L'utilisateur ouvre un vol dans OpenFlyers :

[[File:Menu-contextuel-ouverture-de-vol.png]]

Il se retrouve sur le formulaire de saisie du vol en mode Départ en vol:

[[File:Formulaire-ouverture-de-vol.png]]

Lorsqu'il clique sur le bouton de validation, 3 cas peuvent se présenter :
*Une alerte ou plusieurs alertes rouges (bloquantes), s'affichent : l'utilisateur n'a pas la possibilité de surpasser ses alertes, il ne peut alors récupérer la clé :

[[File:Alertes-bloquantes-en-ouverture-vol.png]]

*Une alerte ou plusieurs alertes oranges (non-bloquantes), s'affichent : l'utilisateur a la possibilité de surpasser ses alertes, et ainsi de récupérer la clé :

[[File:Alertes-non-bloquantes-en-ouverture-vol.png]]

*Aucune alerte ne s'affiche, l'utilisateur se retrouve alors directement sur la page lui indiquant :

[[File:Message_autorisation_libération_clé.png]]

Une fois qu'il a cliqué sur '''LIBÉRER LA CLÉ''', il dispose de X secondes. Cette durée est paramétrable par OpenFlyers.

*Lorsqu'il rentre de vol, l'utilisateur n'a plus qu'a retourner sur le formulaire de saisie de vol et à fermer son vol. La clé doit etre remise en place sur l'armoire pour fermer le vol.

=Interface administrateur OpenFlyers=
==Activation et configuration de la gestion des armoires à clé==
Les protocoles OpenKey et PyOpenKey sont propriétaires d'OF, pour les configurer voir
[[Installation-armoire-à-clés#Configuration-OpenFlyers]]

==Attribution des clés aux ressources/aéronefs==
''Dans le cas où c'est le logiciel OpenFlyers qui gère les clés.''
*'''Admin > Types de ressources > Actives'''
[[File:Liste_des_aéronefs.png]]

Pour chaque aéronef concerné, il suffit d'attribuer un numéro et un nom de clé dans les champs correspondants. La validation de la saisie se fait automatiquement en cliquant hors du champ de saisie.

=Protocole de dialogue XML-RPC entre OpenFlyers et le logiciel de gestion de l'armoire à clé=
Le dialogue avec le serveur XML-RPC d'OpenFlyers doit s'effectuer en '''HTTPS'''. Les commandes accessibles sont listées par un appel à ActionOnDemand.php
https://openflyers.com/yourURL/actionOnDemand.php

==Demande de libération d'une clé==

===Cas avec gestion des clés par OpenFlyers===

*Lorsque qu'une clé doit être libérée, le navigateur envoie un message au logiciel de contrôle de l'armoire à clé par le protocole HTTPS sous la forme suivante :
https://127.0.0.1:4080/?sessid=e5f01p2oqh2vb36arisr8k5j87&timeOut=10000&key=1&resource=2&person=12;action='releaseKey'

:*L'adresse IP (ici 127.0.0.1) et le port (ici 4080) sont fonction de la [[#Activation_et_configuration_de_la_gestion_des_armoires_à_clé|configuration de l'armoire à clé dans OpenFlyers]].
:*sessid contient le numéro de session en cours
:*timeout correspond au temps d'attente pour la prise d'une clé en millisecondes
:*key contient le numéro de la clé concernée
:*resource contient le numéro de la ressource concernée
:*person contient le numéro de l'utilisateur qui fait la demande
:*action est un mot clé désignant l'objet de la commande
:**release_key: ordre de libérer la clé
:**open_door: ordre d'ouvrir la porte
:**init_tags: ordre de lire les tags des clés
*Le logiciel de contrôle de l'armoire à clé doit alors envoyer une demande d'ordre au serveur OpenFlyers à l'adresse suivante https://openflyers.com/structure/ où il faut remplacer openflyers.com/structure par l'adresse de la plateforme OpenFlyers concernée, avec comme commande XML_RPC '''checkCommand ("e5f01p2oqh2vb36arisr8k5j87",int(key))'''.

*Le serveur OpenFlyers vérifie alors l'action demandée :
Pour release_key, il est vérifié :
#Que la clé est au bon format et existe. Lorsque la clé est validée, on passe à l'étape suivante sinon on retourne 0
#Que l'utilisateur faisant la demande est bien celui qui est connecté. Lorsque c'est le cas, on passe à l'étape suivante sinon on retourne 0
#Ensuite si l'utilisateur qui a passé la demande :
#*A le droit '''Gestion des clés''' (administrateur) alors on libère la clé sans condition (cela permet de libérer la clé sans contrôle) et on retourne 1
#*N'a pas le droit '''Gestion des clés''' (pilote) alors on vérifie s'il existe un vol ouvert qui remplit la double condition :
#**Vol attribué à l'utilisateur
#**Aéronef du vol associé à la demande de libération de la clé
#**Lorsque la double condition est remplie, on retourne 1 sinon 0

*Le serveur retourne ensuite la réponse :
**1 dans le cas d'autorisation de libération de clé
**0 dans le cas contraire

====Exemple de script en Python d'utilisation de la commande checkCommand avec gestion des clés====
<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init array to send
sessid = ""
key_num = 1

# send to the XML-RPC server
proxy.callRemote('checkCommand', sessid, key_num).addCallbacks(printValue, printError)
reactor.run()</python>

Ce test peut être complété (pour obtenir une réponse "1") en simulant une armoire à clé à l'aide d'un script PHP de la façon suivante :
*Installer un serveur local (par exemple [https://www.wampserver.com/ wampserver] sous Windows) de façon à avoir le port 127.0.0.1 qui lui est attribué
*Configurer la plateforme OpenFlyers de manière à gérer l'armoire à clé avec les éléments suivants :
**'''IP du PC contenant le logiciel de contrôle''' : 127.0.0.1
**'''Port du PC contenant le logiciel de contrôle''' : 80
*Configurer la plateforme OpenFlyers de manière à gérer les clés
*A la racine du répertoire www, mettre le script index.php suivant (on suppose que ce script est appelé par défaut lorsqu'on utilise l'URL https://127.0.0.1 ) :
<php><?php
file_put_contents('test.txt', 'TEST', FILE_APPEND );
file_put_contents('test.txt', print_r($_REQUEST, true), FILE_APPEND );
?></php>
*Toujours à la racine du répertoire www, créer un fichier test.txt
Le script PHP écrira dans le fichier test.txt les variables transmises lors de la demande d'ouverture de l'armoire à clé :
<pre>TESTArray
(
[sessid] => j2eo92215nbef09borb74jftm1
[key] => 1
[resource] => 1
[person] => 1
)</pre>
*Il suffit alors de recopier la valeur de '''sessid''' et de '''key''' dans le script python de ce début de paragraphe et de le tester : il devrait renvoyer 1.

===Cas sans gestion des clés par OpenFlyers===

*Lorsque qu'une demande de vérification doit être réalisée, le navigateur envoie un message au logiciel de contrôle de l'armoire à clé par le protocole HTTPS sous la forme suivante :
https://127.0.0.1:4080/?sessid=e5f01p2oqh2vb36arisr8k5j87&resource=2&person=12

:*L'adresse IP (ici 127.0.0.1) et le port (ici 4080) sont fonction de la [[#Activation_et_configuration_de_la_gestion_des_armoires_à_clé|configuration de l'armoire à clé dans OpenFlyers]].
:*sessid contient le numéro de session en cours
:*resource contient le numéro de la ressource concernée
:*person contient le numéro de l'utilisateur qui fait la demande
*Le logiciel de contrôle de l'armoire à clé doit alors envoyer une demande d'ordre au serveur OpenFlyers à l'adresse suivante https://openflyers.com/structure/actionOnDemand.php où il faut remplacer openflyers.com/structure par l'adresse de la plateforme OpenFlyers concernée, avec comme commande XML_RPC '''checkCommand ("e5f01p2oqh2vb36arisr8k5j87")'''.

*Le serveur OpenFlyers vérifie alors :
#Que l'utilisateur faisant la demande est bien celui qui est connecté. Lorsque c'est le cas, on passe à l'étape suivante sinon on retourne 0
#On vérifie s'il existe un vol ouvert qui remplit la double condition :
#*Vol attribué à l'utilisateur
#*Aéronef du vol associé à la demande de libération de la clé
#*Lorsque la double condition est remplie, on retourne 1 sinon 0

*Le serveur retourne ensuite la réponse :
**1 dans le cas d'autorisation
**0 dans le cas contraire

====Exemple de script en Python d'utilisation de la commande checkCommand sans gestion des clés====

<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init array to send
sessid = ""

# send to the XML-RPC server
proxy.callRemote('checkCommand', sessid).addCallbacks(printValue, printError)
reactor.run()</python>

Ce test peut être complété (pour obtenir une réponse "1") en simulant une armoire à clé à l'aide d'un script PHP de la façon suivante :
*Installer un serveur local (par exemple [https://www.wampserver.com/ wampserver] sous Windows) de façon à avoir le port 127.0.0.1 qui lui est attribué
*Configurer la plateforme OpenFlyers de manière à gérer l'armoire à clé avec les éléments suivants :
**'''IP du PC contenant le logiciel de contrôle''' : 127.0.0.1
**'''Port du PC contenant le logiciel de contrôle''' : 80
*Configurer la plateforme OpenFlyers de manière à ne pas gérer les clés
*A la racine du répertoire www, mettre le script index.php suivant (on suppose que ce script est appelé par défaut lorsqu'on utilise l'URL https://127.0.0.1 ) :
<php><?php
file_put_contents('test.txt', 'TEST', FILE_APPEND );
file_put_contents('test.txt', print_r($_REQUEST, true), FILE_APPEND );
?></php>
*Toujours à la racine du répertoire www, créer un fichier test.txt
Le script PHP écrira dans le fichier test.txt les variables transmises lors de la demande d'ouverture de l'armoire à clé :
<pre>TESTArray
(
[sessid] => j2eo92215nbef09borb74jftm1
[resource] => 1
[person] => 1
)</pre>
*Il suffit alors de recopier la valeur de '''sessid''' dans le script python de ce début de paragraphe et de le tester : il devrait renvoyer 1.

==Modification de l'état d'une clé==
''Applicable dans le cas où le protocole PyOpenKeys2 gère les clés.''
*Le logiciel de contrôle de l'armoire à clés doit envoyer un ordre '''notify([1,0,1,1,1,1,0,0], "passphrase")''' avec comme paramètre un tableau chronologique des clés ayant pour valeur leur état
''Applicable dans le cas où le protocole PyOpenKeys4 gère les clés.''
*Le logiciel de contrôle de l'armoire à clés doit envoyer un ordre '''notify2([[1,1],[2,0],[3,1],[4,1],[5,1],[6,1],[7,0],[8,0]], "passphrase")''' avec comme paramètre un tableau de tableau avec le numéro de la clé suivi de son état
**1 = interrupteur de présence de clé fermé = clé absente de l'armoire
**0 = interrupteur de présence de clé ouvert = clé présente dans l'armoire

===Exemple de script en Python pour la commande notify===
Nécessite les librairies Twisted et OpenSSL

<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl
import random

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

# Initiate number of key
KEY_NUMBER = 16

# init array to send
state = random.randint(0,1)

if KEY_NUMBER > 8:
# Test notify2
status = [[d+1,0] for d in range(KEY_NUMBER)]
for i in range(KEY_NUMBER):
status[i] = [i+1,state]
# Alternate 0 and 1 for test
state = 0 if state == 1 else 1
else:
# Test notify
for i in range(KEY_NUMBER):
status.append(state)
# Alternate 0 and 1 for test
state = 0 if state == 1 else 1

# send to the XML-RPC server
print "Status sequence : %s" % status
if KEY_NUMBER<9:
proxy.callRemote('notify', status, passphrase).addCallbacks(printValue, printError)
else:
proxy.callRemote('notify2', status, passphrase).addCallbacks(printValue, printError)
reactor.run()
</python>
''Nota : to test change the number of key : up to 8 the software use '''notify()''', beyond it uses '''notify2()'''

Cela retournera 0 en cas d'anomalie ou si la passphase transmise n'est pas correcte, 1 si la table des clés a été correctement mise à jour.

==Fermeture automatique d'un vol==

Le logiciel de contrôle de l'armoire à clé doit envoyer un ordre '''closeFlight("passphrase", "id de ressource")''' avec comme paramètre un passphrase et l'id qui va entraîner la fermeture du vol effectué sur cette ressource si un vol avait été ouvert et que la "Fermeture automatique des
vols au retour de la clé" soit activée. La commande retournera comme réponse une structure JSON pour déterminer si la fermeture du vol s'est bien réalisée ou non et qu'il n'y a pas eu d'erreur.

Réponse quand la vérification du passphrase est incorrecte, ce qui a entraîné la non-fermeture du vol :
<javascript>{[
ack : 0
]}</javascript>

Réponse quand la vérification du passphrase est correcte et que la demande de fermeture du vol s'est bien réalisée :
<javascript>{[
ack : 1
]}</javascript>

Réponse quand la vérification du passphrase est correcte et que la demande de fermeture du vol ne s'est pas bien réalisée suite à une erreur :
<javascript>{[
ack : 1,
error : 'Message d\'erreur ...'
]}</javascript>

===Script d'exemple pour closeFlight===
<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl
import random

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# Id of resource which needs a flight closing
resource_id = 1

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

# send to the XML-RPC server
proxy.callRemote('closeFlight', resource_id, passphrase).addCallbacks(printValue, printError)
reactor.run()</python>

==Exemple de script en Python de logiciel de contrôle d'une armoire==
<python>#!/usr/bin/python
import xmlrpclib, time, dummy_proto, hashlib
from twisted.internet import reactor, task, threads, ssl
from twisted.application import internet, service
from twisted.internet.protocol import Protocol, ClientCreator, ReconnectingClientFactory
from twisted.web import resource, server

# Port from which the OF client contact OpenKeys service
SERVICE_PORT=4080
# IP address of the OpenKeys service
SERVICE_HOST="192.168.0.200"

# IP address of the key cabinet
KEYS_ADDR='192.168.0.201'
# Port from which OpenKeys service contacts the key cabinet
KEYS_PORT=6002
#Time to release the key
KEY_RELEASE_DURATION=15

# sha224 passwords
PASSWORDS=('847bed9bc354e7e47bc5350a3b3aaf6124f5748224a3c7ad79586c3c')

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

OF_XMLRPC_URL="https://openflyers.com/structure/actionOnDemand.php"

DEBUG=False

class dummyProtocol(Protocol):
def __init__(self, rpc_server):
self.rpc_server=rpc_server
self.lc = None

def connectionMade(self):
if not self.lc:
# update status every 10 minutes
self.lc = task.LoopingCall(self.updateStatus)
self.lc.start(600)

def dataReceived(self, data):
msg=dummy_proto.dummy_message.newFromData(data)
if DEBUG: msg.display()
try:
if type(msg)==dummyproto.dummy_ONOFF_Control_Response:
response = self.rpc_server.notify(msg.getKeysStatus(),passphrase)
except Exception, err:
if DEBUG: print "error: ", err
pass # ignore

def updateStatus(self):
msg = dummy_proto.dummy_State_Request()
self.transport.write(msg.build_message())

def send(self, dummy_data):
self.transport.write(dummy_data.build_message())

class dummyClientFactory(ReconnectingClientFactory):
def __init__(self, rpc_server):
self.rpc_server = rpc_server

def buildProtocol(self, addr):
self.resetDelay()
self.protocol = dummyProtocol(self.rpc_server)
return self.protocol

def clientConnectionLost(self, connector, reason):
ReconnectingClientFactory.clientConnectionLost(self, connector, reason)
connector.connect()

def clientConnectionFailed(self, connector, reason):
if DEBUG: print 'Connection failed. Reason:', reason
ReconnectingClientFactory.clientConnectionFailed(self, connector, reason)

# blocking method ! must be run in a new thread
def release_key(self, key_num, timeOur):
m = dummy_proto.dummy_ONOFF_Control()
m.setON(key_num)
self.protocol.send(m)
time.sleep(timeOut)
m.setOFF(key_num)
self.protocol.send(m)
return key_num

class WebResource(resource.Resource):
def __init__(self, rpc_server, dummy_client_factory):
self.rpc_server = rpc_server
self.dummy_client_factory = dummy_client_factory
resource.Resource.__init__(self)
self.keys_webcontrol_state = [0,0,0,0,0,0,0,0,0,0]

def getChild(self, name, request):
return self

def render(self, request):
reponse = 0 # NOK par defaut
key_num = 0
try:
sessid = request.args.get('sessid', [""])[0]
password = request.args.get('password', [""])[0]
key_num = int(request.args.get('key', ["0"])[0])
response = 0
if password:
if hashlib.sha224(password).hexdigest() in PASSWORDS:
timeOut = KEY_RELEASE_DURATION
response_XMLRPC = 1
else:
timeOut = int(request.args.get('timeout', ["0"])[0])
response = self.rpc_server.checkCommand(sessid, key_num)
except Exception, err:
if DEBUG: print "error: ", err
return "NOK:bad request"

if response == 1:
# Don't try to release a key that is being released
if self.keys_webcontrol_state[key_num-1]: return "OK:already released"
self.keys_webcontrol_state[key_num-1] = 1
d = threads.deferToThread(self.dummy_client_factory.release_key, key_num, timeOut)
d.addCallback(self.unset_webcontrol_state)
return "OK:releasing key..."
else:
return "NOK:permission refused"

def unset_webcontrol_state(self, key_num):
self.keys_webcontrol_state[key_num-1] = 0

class OpenKeysService(service.Service):
def __init__(self):
rpc_server=xmlrpclib.Server(OF_XMLRPC_URL);
self.dummy_client_factory = dummyClientFactory(rpc_server)
self.web_resource = WebResource(rpc_server, self.dummy_client_factory)

def getdummyClientFactory(self):
return self.dummy_client_factory

def getWebResource(self):
return self.web_resource

application = service.Application('openkeys')
f = OpenKeysService()
serviceCollection = service.IServiceCollection(application)
internet.TCPClient(KEYS_ADDR, KEYS_PORT, f.getdummyClientFactory()
).setServiceParent(serviceCollection)
internet.TCPServer(SERVICE_PORT, server.Site(f.getWebResource())
).setServiceParent(serviceCollection)</python>

==Maquette de script actionOnDemand.php côté serveur recevant les appels du logiciel de contrôle de l'armoire==
Ce script nécessite la bibliothèque PEAR [http://pear.php.net/package/XML_RPC2 XML_RPC2].

Pour les tests, il suffit de modifier la valeur de la variable $weDontWant.

<php><?php
include 'XML/RPC2/Server.php';

class OpenKeysGateway {
/**
* Update the status of the keys
*
* @param array $status Status of keys
* @return integer 1 if ok, 0 else
*/
public static function notify($status) {
$logmsg = "";
foreach ($status as $key_num_from_zero => $key_pres) {
if (!is_numeric($key_pres) || intval($key_pres)!=$key_pres || $key_pres < 0 || $key_pres > 1) continue;
if (!is_numeric($key_num_from_zero) || intval($key_num_from_zero)!=$key_num_from_zero
|| $key_num_from_zero < 0 || $key_num_from_zero > 9) continue;
$logmsg .= "".($key_num_from_zero+1).":".$key_pres.",";
}
file_put_contents('test.txt', "key notify :".$logmsg, FILE_APPEND );
return 1;
}

/**
* Check if user is able to release the key 'key_num'
*
* @param string $sessid PHPSESSID of a connected user
* @param integer $key_num number of the key to release
* @return integer 0:NOK, 1:OK
*/
public static function checkCommand($sessid, $key_num) {
/* sanitize input */
if (!is_numeric($key_num) || intval($key_num)!=$key_num || $key_num < 1 || $key_num > 10) {
return 0;
}

$weDontWant = 1;

if ($weDontWant) {
file_put_contents('test.txt', "$key_num has no associated airborne aircraft", FILE_APPEND );
return 0;
}
else {
file_put_contents('test.txt', "granted key: ".$key_num.":permission granted", FILE_APPEND );
return 1;
}
}
}

$options = array(
'autoDocument' => true,
);

// dirty hack to get things work !
$GLOBALS['HTTP_RAW_POST_DATA'] = file_get_contents('php://input');

$server = XML_RPC2_Server::create('OpenKeysGateway', $options);
$server->handleCall();

?></php>

Interfaçage OpenFlyers et armoire à clés

2024-12-10T10:04:23Z

Jtremblet: /* Activation et configuration de la gestion des armoires à clé */

__TOC__

=Présentation=
L'objet de cette page est de décrire le protocole d'interfaçage avec toute solution d'armoire à clés tiers. Pour les armoires à clés commercialisées par OpenFlyers, il faut se référer à la [[Contrôle des accès|documentation sur le contrôle d'accès]].

Le protocole repose sur le principe que l'interfaçage est réalisé par un logiciel de contrôle de l'armoire à clé sur un PC ou une solution embarquée et qui dispose d'un accès à internet lui permettant de communiquer avec OpenFlyers. La communication est synchrone.

=Interface utilisateur OpenFlyers=
L'utilisateur ouvre un vol dans OpenFlyers :

[[File:Menu-contextuel-ouverture-de-vol.png]]

Il se retrouve sur le formulaire de saisie du vol en mode Départ en vol:

[[File:Formulaire-ouverture-de-vol.png]]

Lorsqu'il clique sur le bouton de validation, 3 cas peuvent se présenter :
*Une alerte ou plusieurs alertes rouges (bloquantes), s'affichent : l'utilisateur n'a pas la possibilité de surpasser ses alertes, il ne peut alors récupérer la clé :

[[File:Alertes-bloquantes-en-ouverture-vol.png]]

*Une alerte ou plusieurs alertes oranges (non-bloquantes), s'affichent : l'utilisateur a la possibilité de surpasser ses alertes, et ainsi de récupérer la clé :

[[File:Alertes-non-bloquantes-en-ouverture-vol.png]]

*Aucune alerte ne s'affiche, l'utilisateur se retrouve alors directement sur la page lui indiquant :

[[File:Message_autorisation_libération_clé.png]]

Une fois qu'il a cliqué sur '''LIBÉRER LA CLÉ''', il dispose de X secondes. Cette durée est paramétrable par OpenFlyers.

*Lorsqu'il rentre de vol, l'utilisateur n'a plus qu'a retourner sur le formulaire de saisie de vol et à fermer son vol. La clé doit etre remise en place sur l'armoire pour fermer le vol.

=Interface administrateur OpenFlyers=
==Activation et configuration de la gestion des armoires à clé==
Les protocoles OpenKey et PyOpenKey sont propriétaires d'OF, pour les configurer voir
[[Installation-armoire-à-clés#Configuration-OpenFlyers]]

==Attribution des clés aux ressources/aéronefs==
''Dans le cas où c'est le logiciel OpenFlyers qui gère les clés.''
*'''Admin > Types de ressources > Actives'''
[[File:Liste_des_aéronefs.png]]

Pour chaque aéronef concerné, il suffit d'attribuer un numéro et un nom de clé dans les champs correspondants. La validation de la saisie se fait automatiquement en cliquant hors du champ de saisie.

=Protocole de dialogue XML-RPC entre OpenFlyers et le logiciel de gestion de l'armoire à clé=
Le dialogue avec le serveur XML-RPC d'OpenFlyers doit s'effectuer en '''HTTPS'''. Les commandes accessibles sont listées par un appel à ActionOnDemand.php
https://openflyers.com/yourURL/actionOnDemand.php

==Demande de libération d'une clé==

===Cas avec gestion des clés par OpenFlyers===

*Lorsque qu'une clé doit être libérée, le navigateur envoie un message au logiciel de contrôle de l'armoire à clé par le protocole HTTPS sous la forme suivante :
https://127.0.0.1:4080/?sessid=e5f01p2oqh2vb36arisr8k5j87&timeOut=10000&key=1&resource=2&person=12;action='releaseKey'

:*L'adresse IP (ici 127.0.0.1) et le port (ici 4080) sont fonction de la [[#Activation_et_configuration_de_la_gestion_des_armoires_à_clé|configuration de l'armoire à clé dans OpenFlyers]].
:*sessid contient le numéro de session en cours
:*timeout correspond au temps d'attente pour la prise d'une clé en millisecondes
:*key contient le numéro de la clé concernée
:*resource contient le numéro de la ressource concernée
:*person contient le numéro de l'utilisateur qui fait la demande
:*action est un mot clé désignant l'objet de la commande
:**release_key: ordre de libérer la clé
:**open_door: ordre d'ouvrir la porte
:**init_tags: ordre de lire les tags des clés
*Le logiciel de contrôle de l'armoire à clé doit alors envoyer une demande d'ordre au serveur OpenFlyers à l'adresse suivante https://openflyers.com/structure/ où il faut remplacer openflyers.com/structure par l'adresse de la plateforme OpenFlyers concernée, avec comme commande XML_RPC '''checkCommand ("e5f01p2oqh2vb36arisr8k5j87",int(key))'''.

*Le serveur OpenFlyers vérifie alors l'action demandée :
Pour release_key, il est vérifié :
#Que la clé est au bon format et existe. Lorsque la clé est validée, on passe à l'étape suivante sinon on retourne 0
#Que l'utilisateur faisant la demande est bien celui qui est connecté. Lorsque c'est le cas, on passe à l'étape suivante sinon on retourne 0
#Ensuite si l'utilisateur qui a passé la demande :
#*A le droit '''Gestion des clés''' (administrateur) alors on libère la clé sans condition (cela permet de libérer la clé sans contrôle) et on retourne 1
#*N'a pas le droit '''Gestion des clés''' (pilote) alors on vérifie s'il existe un vol ouvert qui remplit la double condition :
#**Vol attribué à l'utilisateur
#**Aéronef du vol associé à la demande de libération de la clé
#**Lorsque la double condition est remplie, on retourne 1 sinon 0

*Le serveur retourne ensuite la réponse :
**1 dans le cas d'autorisation de libération de clé
**0 dans le cas contraire

====Exemple de script en Python d'utilisation de la commande checkCommand avec gestion des clés====
<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init array to send
sessid = ""
key_num = 1

# send to the XML-RPC server
proxy.callRemote('checkCommand', sessid, key_num).addCallbacks(printValue, printError)
reactor.run()</python>

Ce test peut être complété (pour obtenir une réponse "1") en simulant une armoire à clé à l'aide d'un script PHP de la façon suivante :
*Installer un serveur local (par exemple [https://www.wampserver.com/ wampserver] sous Windows) de façon à avoir le port 127.0.0.1 qui lui est attribué
*Configurer la plateforme OpenFlyers de manière à gérer l'armoire à clé avec les éléments suivants :
**'''IP du PC contenant le logiciel de contrôle''' : 127.0.0.1
**'''Port du PC contenant le logiciel de contrôle''' : 80
*Configurer la plateforme OpenFlyers de manière à gérer les clés
*A la racine du répertoire www, mettre le script index.php suivant (on suppose que ce script est appelé par défaut lorsqu'on utilise l'URL https://127.0.0.1 ) :
<php><?php
file_put_contents('test.txt', 'TEST', FILE_APPEND );
file_put_contents('test.txt', print_r($_REQUEST, true), FILE_APPEND );
?></php>
*Toujours à la racine du répertoire www, créer un fichier test.txt
Le script PHP écrira dans le fichier test.txt les variables transmises lors de la demande d'ouverture de l'armoire à clé :
<pre>TESTArray
(
[sessid] => j2eo92215nbef09borb74jftm1
[key] => 1
[resource] => 1
[person] => 1
)</pre>
*Il suffit alors de recopier la valeur de '''sessid''' et de '''key''' dans le script python de ce début de paragraphe et de le tester : il devrait renvoyer 1.

===Cas sans gestion des clés par OpenFlyers===

*Lorsque qu'une demande de vérification doit être réalisée, le navigateur envoie un message au logiciel de contrôle de l'armoire à clé par le protocole HTTPS sous la forme suivante :
https://127.0.0.1:4080/?sessid=e5f01p2oqh2vb36arisr8k5j87&resource=2&person=12

:*L'adresse IP (ici 127.0.0.1) et le port (ici 4080) sont fonction de la [[#Activation_et_configuration_de_la_gestion_des_armoires_à_clé|configuration de l'armoire à clé dans OpenFlyers]].
:*sessid contient le numéro de session en cours
:*resource contient le numéro de la ressource concernée
:*person contient le numéro de l'utilisateur qui fait la demande
*Le logiciel de contrôle de l'armoire à clé doit alors envoyer une demande d'ordre au serveur OpenFlyers à l'adresse suivante https://openflyers.com/structure/actionOnDemand.php où il faut remplacer openflyers.com/structure par l'adresse de la plateforme OpenFlyers concernée, avec comme commande XML_RPC '''checkCommand ("e5f01p2oqh2vb36arisr8k5j87")'''.

*Le serveur OpenFlyers vérifie alors :
#Que l'utilisateur faisant la demande est bien celui qui est connecté. Lorsque c'est le cas, on passe à l'étape suivante sinon on retourne 0
#On vérifie s'il existe un vol ouvert qui remplit la double condition :
#*Vol attribué à l'utilisateur
#*Aéronef du vol associé à la demande de libération de la clé
#*Lorsque la double condition est remplie, on retourne 1 sinon 0

*Le serveur retourne ensuite la réponse :
**1 dans le cas d'autorisation
**0 dans le cas contraire

====Exemple de script en Python d'utilisation de la commande checkCommand sans gestion des clés====

<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init array to send
sessid = ""

# send to the XML-RPC server
proxy.callRemote('checkCommand', sessid).addCallbacks(printValue, printError)
reactor.run()</python>

Ce test peut être complété (pour obtenir une réponse "1") en simulant une armoire à clé à l'aide d'un script PHP de la façon suivante :
*Installer un serveur local (par exemple [https://www.wampserver.com/ wampserver] sous Windows) de façon à avoir le port 127.0.0.1 qui lui est attribué
*Configurer la plateforme OpenFlyers de manière à gérer l'armoire à clé avec les éléments suivants :
**'''IP du PC contenant le logiciel de contrôle''' : 127.0.0.1
**'''Port du PC contenant le logiciel de contrôle''' : 80
*Configurer la plateforme OpenFlyers de manière à ne pas gérer les clés
*A la racine du répertoire www, mettre le script index.php suivant (on suppose que ce script est appelé par défaut lorsqu'on utilise l'URL https://127.0.0.1 ) :
<php><?php
file_put_contents('test.txt', 'TEST', FILE_APPEND );
file_put_contents('test.txt', print_r($_REQUEST, true), FILE_APPEND );
?></php>
*Toujours à la racine du répertoire www, créer un fichier test.txt
Le script PHP écrira dans le fichier test.txt les variables transmises lors de la demande d'ouverture de l'armoire à clé :
<pre>TESTArray
(
[sessid] => j2eo92215nbef09borb74jftm1
[resource] => 1
[person] => 1
)</pre>
*Il suffit alors de recopier la valeur de '''sessid''' dans le script python de ce début de paragraphe et de le tester : il devrait renvoyer 1.

==Modification de l'état d'une clé==
''Applicable dans le cas où le protocole PyOpenKeys2 gère les clés.''
*Le logiciel de contrôle de l'armoire à clés doit envoyer un ordre '''notify([1,0,1,1,1,1,0,0], "passphrase")''' avec comme paramètre un tableau chronologique des clés ayant pour valeur leur état
''Applicable dans le cas où le protocole PyOpenKeys3 gère les clés.''
*Le logiciel de contrôle de l'armoire à clés doit envoyer un ordre '''notify2([[1,1],[2,0],[3,1],[4,1],[5,1],[6,1],[7,0],[8,0]], "passphrase")''' avec comme paramètre un tableau de tableau avec le numéro de la clé suivi de son état
**1 = interrupteur de présence de clé fermé = clé absente de l'armoire
**0 = interrupteur de présence de clé ouvert = clé présente dans l'armoire

===Exemple de script en Python pour la commande notify===
Nécessite les librairies Twisted et OpenSSL

<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl
import random

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

# Initiate number of key
KEY_NUMBER = 16

# init array to send
state = random.randint(0,1)

if KEY_NUMBER > 8:
# Test notify2
status = [[d+1,0] for d in range(KEY_NUMBER)]
for i in range(KEY_NUMBER):
status[i] = [i+1,state]
# Alternate 0 and 1 for test
state = 0 if state == 1 else 1
else:
# Test notify
for i in range(KEY_NUMBER):
status.append(state)
# Alternate 0 and 1 for test
state = 0 if state == 1 else 1

# send to the XML-RPC server
print "Status sequence : %s" % status
if KEY_NUMBER<9:
proxy.callRemote('notify', status, passphrase).addCallbacks(printValue, printError)
else:
proxy.callRemote('notify2', status, passphrase).addCallbacks(printValue, printError)
reactor.run()
</python>
''Nota : to test change the number of key : up to 8 the software use '''notify()''', beyond it uses '''notify2()'''

Cela retournera 0 en cas d'anomalie ou si la passphase transmise n'est pas correcte, 1 si la table des clés a été correctement mise à jour.

==Fermeture automatique d'un vol==

Le logiciel de contrôle de l'armoire à clé doit envoyer un ordre '''closeFlight("passphrase", "id de ressource")''' avec comme paramètre un passphrase et l'id qui va entraîner la fermeture du vol effectué sur cette ressource si un vol avait été ouvert et que la "Fermeture automatique des
vols au retour de la clé" soit activée. La commande retournera comme réponse une structure JSON pour déterminer si la fermeture du vol s'est bien réalisée ou non et qu'il n'y a pas eu d'erreur.

Réponse quand la vérification du passphrase est incorrecte, ce qui a entraîné la non-fermeture du vol :
<javascript>{[
ack : 0
]}</javascript>

Réponse quand la vérification du passphrase est correcte et que la demande de fermeture du vol s'est bien réalisée :
<javascript>{[
ack : 1
]}</javascript>

Réponse quand la vérification du passphrase est correcte et que la demande de fermeture du vol ne s'est pas bien réalisée suite à une erreur :
<javascript>{[
ack : 1,
error : 'Message d\'erreur ...'
]}</javascript>

===Script d'exemple pour closeFlight===
<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl
import random

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# Id of resource which needs a flight closing
resource_id = 1

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

# send to the XML-RPC server
proxy.callRemote('closeFlight', resource_id, passphrase).addCallbacks(printValue, printError)
reactor.run()</python>

==Exemple de script en Python de logiciel de contrôle d'une armoire==
<python>#!/usr/bin/python
import xmlrpclib, time, dummy_proto, hashlib
from twisted.internet import reactor, task, threads, ssl
from twisted.application import internet, service
from twisted.internet.protocol import Protocol, ClientCreator, ReconnectingClientFactory
from twisted.web import resource, server

# Port from which the OF client contact OpenKeys service
SERVICE_PORT=4080
# IP address of the OpenKeys service
SERVICE_HOST="192.168.0.200"

# IP address of the key cabinet
KEYS_ADDR='192.168.0.201'
# Port from which OpenKeys service contacts the key cabinet
KEYS_PORT=6002
#Time to release the key
KEY_RELEASE_DURATION=15

# sha224 passwords
PASSWORDS=('847bed9bc354e7e47bc5350a3b3aaf6124f5748224a3c7ad79586c3c')

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

OF_XMLRPC_URL="https://openflyers.com/structure/actionOnDemand.php"

DEBUG=False

class dummyProtocol(Protocol):
def __init__(self, rpc_server):
self.rpc_server=rpc_server
self.lc = None

def connectionMade(self):
if not self.lc:
# update status every 10 minutes
self.lc = task.LoopingCall(self.updateStatus)
self.lc.start(600)

def dataReceived(self, data):
msg=dummy_proto.dummy_message.newFromData(data)
if DEBUG: msg.display()
try:
if type(msg)==dummyproto.dummy_ONOFF_Control_Response:
response = self.rpc_server.notify(msg.getKeysStatus(),passphrase)
except Exception, err:
if DEBUG: print "error: ", err
pass # ignore

def updateStatus(self):
msg = dummy_proto.dummy_State_Request()
self.transport.write(msg.build_message())

def send(self, dummy_data):
self.transport.write(dummy_data.build_message())

class dummyClientFactory(ReconnectingClientFactory):
def __init__(self, rpc_server):
self.rpc_server = rpc_server

def buildProtocol(self, addr):
self.resetDelay()
self.protocol = dummyProtocol(self.rpc_server)
return self.protocol

def clientConnectionLost(self, connector, reason):
ReconnectingClientFactory.clientConnectionLost(self, connector, reason)
connector.connect()

def clientConnectionFailed(self, connector, reason):
if DEBUG: print 'Connection failed. Reason:', reason
ReconnectingClientFactory.clientConnectionFailed(self, connector, reason)

# blocking method ! must be run in a new thread
def release_key(self, key_num, timeOur):
m = dummy_proto.dummy_ONOFF_Control()
m.setON(key_num)
self.protocol.send(m)
time.sleep(timeOut)
m.setOFF(key_num)
self.protocol.send(m)
return key_num

class WebResource(resource.Resource):
def __init__(self, rpc_server, dummy_client_factory):
self.rpc_server = rpc_server
self.dummy_client_factory = dummy_client_factory
resource.Resource.__init__(self)
self.keys_webcontrol_state = [0,0,0,0,0,0,0,0,0,0]

def getChild(self, name, request):
return self

def render(self, request):
reponse = 0 # NOK par defaut
key_num = 0
try:
sessid = request.args.get('sessid', [""])[0]
password = request.args.get('password', [""])[0]
key_num = int(request.args.get('key', ["0"])[0])
response = 0
if password:
if hashlib.sha224(password).hexdigest() in PASSWORDS:
timeOut = KEY_RELEASE_DURATION
response_XMLRPC = 1
else:
timeOut = int(request.args.get('timeout', ["0"])[0])
response = self.rpc_server.checkCommand(sessid, key_num)
except Exception, err:
if DEBUG: print "error: ", err
return "NOK:bad request"

if response == 1:
# Don't try to release a key that is being released
if self.keys_webcontrol_state[key_num-1]: return "OK:already released"
self.keys_webcontrol_state[key_num-1] = 1
d = threads.deferToThread(self.dummy_client_factory.release_key, key_num, timeOut)
d.addCallback(self.unset_webcontrol_state)
return "OK:releasing key..."
else:
return "NOK:permission refused"

def unset_webcontrol_state(self, key_num):
self.keys_webcontrol_state[key_num-1] = 0

class OpenKeysService(service.Service):
def __init__(self):
rpc_server=xmlrpclib.Server(OF_XMLRPC_URL);
self.dummy_client_factory = dummyClientFactory(rpc_server)
self.web_resource = WebResource(rpc_server, self.dummy_client_factory)

def getdummyClientFactory(self):
return self.dummy_client_factory

def getWebResource(self):
return self.web_resource

application = service.Application('openkeys')
f = OpenKeysService()
serviceCollection = service.IServiceCollection(application)
internet.TCPClient(KEYS_ADDR, KEYS_PORT, f.getdummyClientFactory()
).setServiceParent(serviceCollection)
internet.TCPServer(SERVICE_PORT, server.Site(f.getWebResource())
).setServiceParent(serviceCollection)</python>

==Maquette de script actionOnDemand.php côté serveur recevant les appels du logiciel de contrôle de l'armoire==
Ce script nécessite la bibliothèque PEAR [http://pear.php.net/package/XML_RPC2 XML_RPC2].

Pour les tests, il suffit de modifier la valeur de la variable $weDontWant.

<php><?php
include 'XML/RPC2/Server.php';

class OpenKeysGateway {
/**
* Update the status of the keys
*
* @param array $status Status of keys
* @return integer 1 if ok, 0 else
*/
public static function notify($status) {
$logmsg = "";
foreach ($status as $key_num_from_zero => $key_pres) {
if (!is_numeric($key_pres) || intval($key_pres)!=$key_pres || $key_pres < 0 || $key_pres > 1) continue;
if (!is_numeric($key_num_from_zero) || intval($key_num_from_zero)!=$key_num_from_zero
|| $key_num_from_zero < 0 || $key_num_from_zero > 9) continue;
$logmsg .= "".($key_num_from_zero+1).":".$key_pres.",";
}
file_put_contents('test.txt', "key notify :".$logmsg, FILE_APPEND );
return 1;
}

/**
* Check if user is able to release the key 'key_num'
*
* @param string $sessid PHPSESSID of a connected user
* @param integer $key_num number of the key to release
* @return integer 0:NOK, 1:OK
*/
public static function checkCommand($sessid, $key_num) {
/* sanitize input */
if (!is_numeric($key_num) || intval($key_num)!=$key_num || $key_num < 1 || $key_num > 10) {
return 0;
}

$weDontWant = 1;

if ($weDontWant) {
file_put_contents('test.txt', "$key_num has no associated airborne aircraft", FILE_APPEND );
return 0;
}
else {
file_put_contents('test.txt', "granted key: ".$key_num.":permission granted", FILE_APPEND );
return 1;
}
}
}

$options = array(
'autoDocument' => true,
);

// dirty hack to get things work !
$GLOBALS['HTTP_RAW_POST_DATA'] = file_get_contents('php://input');

$server = XML_RPC2_Server::create('OpenKeysGateway', $options);
$server->handleCall();

?></php>

Interfaçage OpenFlyers et armoire à clés

2024-12-10T09:50:07Z

Jtremblet: /* Activation et configuration de la gestion des armoires à clé */

__TOC__

=Présentation=
L'objet de cette page est de décrire le protocole d'interfaçage avec toute solution d'armoire à clés tiers. Pour les armoires à clés commercialisées par OpenFlyers, il faut se référer à la [[Contrôle des accès|documentation sur le contrôle d'accès]].

Le protocole repose sur le principe que l'interfaçage est réalisé par un logiciel de contrôle de l'armoire à clé sur un PC ou une solution embarquée et qui dispose d'un accès à internet lui permettant de communiquer avec OpenFlyers. La communication est synchrone.

=Interface utilisateur OpenFlyers=
L'utilisateur ouvre un vol dans OpenFlyers :

[[File:Menu-contextuel-ouverture-de-vol.png]]

Il se retrouve sur le formulaire de saisie du vol en mode Départ en vol:

[[File:Formulaire-ouverture-de-vol.png]]

Lorsqu'il clique sur le bouton de validation, 3 cas peuvent se présenter :
*Une alerte ou plusieurs alertes rouges (bloquantes), s'affichent : l'utilisateur n'a pas la possibilité de surpasser ses alertes, il ne peut alors récupérer la clé :

[[File:Alertes-bloquantes-en-ouverture-vol.png]]

*Une alerte ou plusieurs alertes oranges (non-bloquantes), s'affichent : l'utilisateur a la possibilité de surpasser ses alertes, et ainsi de récupérer la clé :

[[File:Alertes-non-bloquantes-en-ouverture-vol.png]]

*Aucune alerte ne s'affiche, l'utilisateur se retrouve alors directement sur la page lui indiquant :

[[File:Message_autorisation_libération_clé.png]]

Une fois qu'il a cliqué sur '''LIBÉRER LA CLÉ''', il dispose de X secondes. Cette durée est paramétrable par OpenFlyers.

*Lorsqu'il rentre de vol, l'utilisateur n'a plus qu'a retourner sur le formulaire de saisie de vol et à fermer son vol. La clé doit etre remise en place sur l'armoire pour fermer le vol.

=Interface administrateur OpenFlyers=
==Activation et configuration de la gestion des armoires à clé==
*'''Admin > Structure > Structure > Paramétrage'''
*Dans la section du formulaire '''Contrôle d'accès''', sélectionner '''Activé(e)''' pour les champs '''Contrôle d'accès''' et '''Gestion armoire à clés'''.
[[File:Config_parametres_OF_controle_acces 1.jpg]]
*Cliquer sur le bouton '''Enregistrer'''
*Un nouveau champ s'affich
*Sélectionner le '''Logiciel de contrôle de l'armoire à clés''' selon votre armoire à clés
**Pour armoire FlogBox : [[File:Config_parametres_OF_controle_acces 4.jpg]]
**Pour armoire Deister : [[File:Config_parametres_OF_controle_acces 3.jpg]]

Les Logiciels OpenKey et PyOpenKey sont des protocoles propriétaires d'OF, pour les configurer voir [[Interfaçage-OpenFlyers-et-armoire-à-clés#Interface-administrateur-OpenFlyers | Interfaçage armoire à clés OF]]

==Attribution des clés aux ressources/aéronefs==
''Dans le cas où c'est le logiciel OpenFlyers qui gère les clés.''
*'''Admin > Types de ressources > Actives'''
[[File:Liste_des_aéronefs.png]]

Pour chaque aéronef concerné, il suffit d'attribuer un numéro et un nom de clé dans les champs correspondants. La validation de la saisie se fait automatiquement en cliquant hors du champ de saisie.

=Protocole de dialogue XML-RPC entre OpenFlyers et le logiciel de gestion de l'armoire à clé=
Le dialogue avec le serveur XML-RPC d'OpenFlyers doit s'effectuer en '''HTTPS'''. Les commandes accessibles sont listées par un appel à ActionOnDemand.php
https://openflyers.com/yourURL/actionOnDemand.php

==Demande de libération d'une clé==

===Cas avec gestion des clés par OpenFlyers===

*Lorsque qu'une clé doit être libérée, le navigateur envoie un message au logiciel de contrôle de l'armoire à clé par le protocole HTTPS sous la forme suivante :
https://127.0.0.1:4080/?sessid=e5f01p2oqh2vb36arisr8k5j87&timeOut=10000&key=1&resource=2&person=12;action='releaseKey'

:*L'adresse IP (ici 127.0.0.1) et le port (ici 4080) sont fonction de la [[#Activation_et_configuration_de_la_gestion_des_armoires_à_clé|configuration de l'armoire à clé dans OpenFlyers]].
:*sessid contient le numéro de session en cours
:*timeout correspond au temps d'attente pour la prise d'une clé en millisecondes
:*key contient le numéro de la clé concernée
:*resource contient le numéro de la ressource concernée
:*person contient le numéro de l'utilisateur qui fait la demande
:*action est un mot clé désignant l'objet de la commande
:**release_key: ordre de libérer la clé
:**open_door: ordre d'ouvrir la porte
:**init_tags: ordre de lire les tags des clés
*Le logiciel de contrôle de l'armoire à clé doit alors envoyer une demande d'ordre au serveur OpenFlyers à l'adresse suivante https://openflyers.com/structure/ où il faut remplacer openflyers.com/structure par l'adresse de la plateforme OpenFlyers concernée, avec comme commande XML_RPC '''checkCommand ("e5f01p2oqh2vb36arisr8k5j87",int(key))'''.

*Le serveur OpenFlyers vérifie alors l'action demandée :
Pour release_key, il est vérifié :
#Que la clé est au bon format et existe. Lorsque la clé est validée, on passe à l'étape suivante sinon on retourne 0
#Que l'utilisateur faisant la demande est bien celui qui est connecté. Lorsque c'est le cas, on passe à l'étape suivante sinon on retourne 0
#Ensuite si l'utilisateur qui a passé la demande :
#*A le droit '''Gestion des clés''' (administrateur) alors on libère la clé sans condition (cela permet de libérer la clé sans contrôle) et on retourne 1
#*N'a pas le droit '''Gestion des clés''' (pilote) alors on vérifie s'il existe un vol ouvert qui remplit la double condition :
#**Vol attribué à l'utilisateur
#**Aéronef du vol associé à la demande de libération de la clé
#**Lorsque la double condition est remplie, on retourne 1 sinon 0

*Le serveur retourne ensuite la réponse :
**1 dans le cas d'autorisation de libération de clé
**0 dans le cas contraire

====Exemple de script en Python d'utilisation de la commande checkCommand avec gestion des clés====
<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init array to send
sessid = ""
key_num = 1

# send to the XML-RPC server
proxy.callRemote('checkCommand', sessid, key_num).addCallbacks(printValue, printError)
reactor.run()</python>

Ce test peut être complété (pour obtenir une réponse "1") en simulant une armoire à clé à l'aide d'un script PHP de la façon suivante :
*Installer un serveur local (par exemple [https://www.wampserver.com/ wampserver] sous Windows) de façon à avoir le port 127.0.0.1 qui lui est attribué
*Configurer la plateforme OpenFlyers de manière à gérer l'armoire à clé avec les éléments suivants :
**'''IP du PC contenant le logiciel de contrôle''' : 127.0.0.1
**'''Port du PC contenant le logiciel de contrôle''' : 80
*Configurer la plateforme OpenFlyers de manière à gérer les clés
*A la racine du répertoire www, mettre le script index.php suivant (on suppose que ce script est appelé par défaut lorsqu'on utilise l'URL https://127.0.0.1 ) :
<php><?php
file_put_contents('test.txt', 'TEST', FILE_APPEND );
file_put_contents('test.txt', print_r($_REQUEST, true), FILE_APPEND );
?></php>
*Toujours à la racine du répertoire www, créer un fichier test.txt
Le script PHP écrira dans le fichier test.txt les variables transmises lors de la demande d'ouverture de l'armoire à clé :
<pre>TESTArray
(
[sessid] => j2eo92215nbef09borb74jftm1
[key] => 1
[resource] => 1
[person] => 1
)</pre>
*Il suffit alors de recopier la valeur de '''sessid''' et de '''key''' dans le script python de ce début de paragraphe et de le tester : il devrait renvoyer 1.

===Cas sans gestion des clés par OpenFlyers===

*Lorsque qu'une demande de vérification doit être réalisée, le navigateur envoie un message au logiciel de contrôle de l'armoire à clé par le protocole HTTPS sous la forme suivante :
https://127.0.0.1:4080/?sessid=e5f01p2oqh2vb36arisr8k5j87&resource=2&person=12

:*L'adresse IP (ici 127.0.0.1) et le port (ici 4080) sont fonction de la [[#Activation_et_configuration_de_la_gestion_des_armoires_à_clé|configuration de l'armoire à clé dans OpenFlyers]].
:*sessid contient le numéro de session en cours
:*resource contient le numéro de la ressource concernée
:*person contient le numéro de l'utilisateur qui fait la demande
*Le logiciel de contrôle de l'armoire à clé doit alors envoyer une demande d'ordre au serveur OpenFlyers à l'adresse suivante https://openflyers.com/structure/actionOnDemand.php où il faut remplacer openflyers.com/structure par l'adresse de la plateforme OpenFlyers concernée, avec comme commande XML_RPC '''checkCommand ("e5f01p2oqh2vb36arisr8k5j87")'''.

*Le serveur OpenFlyers vérifie alors :
#Que l'utilisateur faisant la demande est bien celui qui est connecté. Lorsque c'est le cas, on passe à l'étape suivante sinon on retourne 0
#On vérifie s'il existe un vol ouvert qui remplit la double condition :
#*Vol attribué à l'utilisateur
#*Aéronef du vol associé à la demande de libération de la clé
#*Lorsque la double condition est remplie, on retourne 1 sinon 0

*Le serveur retourne ensuite la réponse :
**1 dans le cas d'autorisation
**0 dans le cas contraire

====Exemple de script en Python d'utilisation de la commande checkCommand sans gestion des clés====

<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init array to send
sessid = ""

# send to the XML-RPC server
proxy.callRemote('checkCommand', sessid).addCallbacks(printValue, printError)
reactor.run()</python>

Ce test peut être complété (pour obtenir une réponse "1") en simulant une armoire à clé à l'aide d'un script PHP de la façon suivante :
*Installer un serveur local (par exemple [https://www.wampserver.com/ wampserver] sous Windows) de façon à avoir le port 127.0.0.1 qui lui est attribué
*Configurer la plateforme OpenFlyers de manière à gérer l'armoire à clé avec les éléments suivants :
**'''IP du PC contenant le logiciel de contrôle''' : 127.0.0.1
**'''Port du PC contenant le logiciel de contrôle''' : 80
*Configurer la plateforme OpenFlyers de manière à ne pas gérer les clés
*A la racine du répertoire www, mettre le script index.php suivant (on suppose que ce script est appelé par défaut lorsqu'on utilise l'URL https://127.0.0.1 ) :
<php><?php
file_put_contents('test.txt', 'TEST', FILE_APPEND );
file_put_contents('test.txt', print_r($_REQUEST, true), FILE_APPEND );
?></php>
*Toujours à la racine du répertoire www, créer un fichier test.txt
Le script PHP écrira dans le fichier test.txt les variables transmises lors de la demande d'ouverture de l'armoire à clé :
<pre>TESTArray
(
[sessid] => j2eo92215nbef09borb74jftm1
[resource] => 1
[person] => 1
)</pre>
*Il suffit alors de recopier la valeur de '''sessid''' dans le script python de ce début de paragraphe et de le tester : il devrait renvoyer 1.

==Modification de l'état d'une clé==
''Applicable dans le cas où le protocole PyOpenKeys2 gère les clés.''
*Le logiciel de contrôle de l'armoire à clés doit envoyer un ordre '''notify([1,0,1,1,1,1,0,0], "passphrase")''' avec comme paramètre un tableau chronologique des clés ayant pour valeur leur état
''Applicable dans le cas où le protocole PyOpenKeys3 gère les clés.''
*Le logiciel de contrôle de l'armoire à clés doit envoyer un ordre '''notify2([[1,1],[2,0],[3,1],[4,1],[5,1],[6,1],[7,0],[8,0]], "passphrase")''' avec comme paramètre un tableau de tableau avec le numéro de la clé suivi de son état
**1 = interrupteur de présence de clé fermé = clé absente de l'armoire
**0 = interrupteur de présence de clé ouvert = clé présente dans l'armoire

===Exemple de script en Python pour la commande notify===
Nécessite les librairies Twisted et OpenSSL

<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl
import random

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

# Initiate number of key
KEY_NUMBER = 16

# init array to send
state = random.randint(0,1)

if KEY_NUMBER > 8:
# Test notify2
status = [[d+1,0] for d in range(KEY_NUMBER)]
for i in range(KEY_NUMBER):
status[i] = [i+1,state]
# Alternate 0 and 1 for test
state = 0 if state == 1 else 1
else:
# Test notify
for i in range(KEY_NUMBER):
status.append(state)
# Alternate 0 and 1 for test
state = 0 if state == 1 else 1

# send to the XML-RPC server
print "Status sequence : %s" % status
if KEY_NUMBER<9:
proxy.callRemote('notify', status, passphrase).addCallbacks(printValue, printError)
else:
proxy.callRemote('notify2', status, passphrase).addCallbacks(printValue, printError)
reactor.run()
</python>
''Nota : to test change the number of key : up to 8 the software use '''notify()''', beyond it uses '''notify2()'''

Cela retournera 0 en cas d'anomalie ou si la passphase transmise n'est pas correcte, 1 si la table des clés a été correctement mise à jour.

==Fermeture automatique d'un vol==

Le logiciel de contrôle de l'armoire à clé doit envoyer un ordre '''closeFlight("passphrase", "id de ressource")''' avec comme paramètre un passphrase et l'id qui va entraîner la fermeture du vol effectué sur cette ressource si un vol avait été ouvert et que la "Fermeture automatique des
vols au retour de la clé" soit activée. La commande retournera comme réponse une structure JSON pour déterminer si la fermeture du vol s'est bien réalisée ou non et qu'il n'y a pas eu d'erreur.

Réponse quand la vérification du passphrase est incorrecte, ce qui a entraîné la non-fermeture du vol :
<javascript>{[
ack : 0
]}</javascript>

Réponse quand la vérification du passphrase est correcte et que la demande de fermeture du vol s'est bien réalisée :
<javascript>{[
ack : 1
]}</javascript>

Réponse quand la vérification du passphrase est correcte et que la demande de fermeture du vol ne s'est pas bien réalisée suite à une erreur :
<javascript>{[
ack : 1,
error : 'Message d\'erreur ...'
]}</javascript>

===Script d'exemple pour closeFlight===
<python># load library
from twisted.web.xmlrpc import Proxy
from twisted.internet import reactor, ssl
import random

def printValue(value):
print repr(value)
reactor.stop()

def printError(error):
print 'error', error
reactor.stop()

# URL of the XML-RPC server
proxy = Proxy('https://yourURL.xx/actionOnDemand.php')

# Id of resource which needs a flight closing
resource_id = 1

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

# send to the XML-RPC server
proxy.callRemote('closeFlight', resource_id, passphrase).addCallbacks(printValue, printError)
reactor.run()</python>

==Exemple de script en Python de logiciel de contrôle d'une armoire==
<python>#!/usr/bin/python
import xmlrpclib, time, dummy_proto, hashlib
from twisted.internet import reactor, task, threads, ssl
from twisted.application import internet, service
from twisted.internet.protocol import Protocol, ClientCreator, ReconnectingClientFactory
from twisted.web import resource, server

# Port from which the OF client contact OpenKeys service
SERVICE_PORT=4080
# IP address of the OpenKeys service
SERVICE_HOST="192.168.0.200"

# IP address of the key cabinet
KEYS_ADDR='192.168.0.201'
# Port from which OpenKeys service contacts the key cabinet
KEYS_PORT=6002
#Time to release the key
KEY_RELEASE_DURATION=15

# sha224 passwords
PASSWORDS=('847bed9bc354e7e47bc5350a3b3aaf6124f5748224a3c7ad79586c3c')

# init passphrase
passphrase = 'SDjklsdiuQSIPO23879ZERK2098ZL2908DFZLK'

OF_XMLRPC_URL="https://openflyers.com/structure/actionOnDemand.php"

DEBUG=False

class dummyProtocol(Protocol):
def __init__(self, rpc_server):
self.rpc_server=rpc_server
self.lc = None

def connectionMade(self):
if not self.lc:
# update status every 10 minutes
self.lc = task.LoopingCall(self.updateStatus)
self.lc.start(600)

def dataReceived(self, data):
msg=dummy_proto.dummy_message.newFromData(data)
if DEBUG: msg.display()
try:
if type(msg)==dummyproto.dummy_ONOFF_Control_Response:
response = self.rpc_server.notify(msg.getKeysStatus(),passphrase)
except Exception, err:
if DEBUG: print "error: ", err
pass # ignore

def updateStatus(self):
msg = dummy_proto.dummy_State_Request()
self.transport.write(msg.build_message())

def send(self, dummy_data):
self.transport.write(dummy_data.build_message())

class dummyClientFactory(ReconnectingClientFactory):
def __init__(self, rpc_server):
self.rpc_server = rpc_server

def buildProtocol(self, addr):
self.resetDelay()
self.protocol = dummyProtocol(self.rpc_server)
return self.protocol

def clientConnectionLost(self, connector, reason):
ReconnectingClientFactory.clientConnectionLost(self, connector, reason)
connector.connect()

def clientConnectionFailed(self, connector, reason):
if DEBUG: print 'Connection failed. Reason:', reason
ReconnectingClientFactory.clientConnectionFailed(self, connector, reason)

# blocking method ! must be run in a new thread
def release_key(self, key_num, timeOur):
m = dummy_proto.dummy_ONOFF_Control()
m.setON(key_num)
self.protocol.send(m)
time.sleep(timeOut)
m.setOFF(key_num)
self.protocol.send(m)
return key_num

class WebResource(resource.Resource):
def __init__(self, rpc_server, dummy_client_factory):
self.rpc_server = rpc_server
self.dummy_client_factory = dummy_client_factory
resource.Resource.__init__(self)
self.keys_webcontrol_state = [0,0,0,0,0,0,0,0,0,0]

def getChild(self, name, request):
return self

def render(self, request):
reponse = 0 # NOK par defaut
key_num = 0
try:
sessid = request.args.get('sessid', [""])[0]
password = request.args.get('password', [""])[0]
key_num = int(request.args.get('key', ["0"])[0])
response = 0
if password:
if hashlib.sha224(password).hexdigest() in PASSWORDS:
timeOut = KEY_RELEASE_DURATION
response_XMLRPC = 1
else:
timeOut = int(request.args.get('timeout', ["0"])[0])
response = self.rpc_server.checkCommand(sessid, key_num)
except Exception, err:
if DEBUG: print "error: ", err
return "NOK:bad request"

if response == 1:
# Don't try to release a key that is being released
if self.keys_webcontrol_state[key_num-1]: return "OK:already released"
self.keys_webcontrol_state[key_num-1] = 1
d = threads.deferToThread(self.dummy_client_factory.release_key, key_num, timeOut)
d.addCallback(self.unset_webcontrol_state)
return "OK:releasing key..."
else:
return "NOK:permission refused"

def unset_webcontrol_state(self, key_num):
self.keys_webcontrol_state[key_num-1] = 0

class OpenKeysService(service.Service):
def __init__(self):
rpc_server=xmlrpclib.Server(OF_XMLRPC_URL);
self.dummy_client_factory = dummyClientFactory(rpc_server)
self.web_resource = WebResource(rpc_server, self.dummy_client_factory)

def getdummyClientFactory(self):
return self.dummy_client_factory

def getWebResource(self):
return self.web_resource

application = service.Application('openkeys')
f = OpenKeysService()
serviceCollection = service.IServiceCollection(application)
internet.TCPClient(KEYS_ADDR, KEYS_PORT, f.getdummyClientFactory()
).setServiceParent(serviceCollection)
internet.TCPServer(SERVICE_PORT, server.Site(f.getWebResource())
).setServiceParent(serviceCollection)</python>

==Maquette de script actionOnDemand.php côté serveur recevant les appels du logiciel de contrôle de l'armoire==
Ce script nécessite la bibliothèque PEAR [http://pear.php.net/package/XML_RPC2 XML_RPC2].

Pour les tests, il suffit de modifier la valeur de la variable $weDontWant.

<php><?php
include 'XML/RPC2/Server.php';

class OpenKeysGateway {
/**
* Update the status of the keys
*
* @param array $status Status of keys
* @return integer 1 if ok, 0 else
*/
public static function notify($status) {
$logmsg = "";
foreach ($status as $key_num_from_zero => $key_pres) {
if (!is_numeric($key_pres) || intval($key_pres)!=$key_pres || $key_pres < 0 || $key_pres > 1) continue;
if (!is_numeric($key_num_from_zero) || intval($key_num_from_zero)!=$key_num_from_zero
|| $key_num_from_zero < 0 || $key_num_from_zero > 9) continue;
$logmsg .= "".($key_num_from_zero+1).":".$key_pres.",";
}
file_put_contents('test.txt', "key notify :".$logmsg, FILE_APPEND );
return 1;
}

/**
* Check if user is able to release the key 'key_num'
*
* @param string $sessid PHPSESSID of a connected user
* @param integer $key_num number of the key to release
* @return integer 0:NOK, 1:OK
*/
public static function checkCommand($sessid, $key_num) {
/* sanitize input */
if (!is_numeric($key_num) || intval($key_num)!=$key_num || $key_num < 1 || $key_num > 10) {
return 0;
}

$weDontWant = 1;

if ($weDontWant) {
file_put_contents('test.txt', "$key_num has no associated airborne aircraft", FILE_APPEND );
return 0;
}
else {
file_put_contents('test.txt', "granted key: ".$key_num.":permission granted", FILE_APPEND );
return 1;
}
}
}

$options = array(
'autoDocument' => true,
);

// dirty hack to get things work !
$GLOBALS['HTTP_RAW_POST_DATA'] = file_get_contents('php://input');

$server = XML_RPC2_Server::create('OpenKeysGateway', $options);
$server->handleCall();

?></php>