Ce fichier se nomme “Constellation.Server.exe.config” et se trouve dans le répertoire d’installation du serveur (par défaut dans “Program Files\Constellation Plateform\Server« ).

Vous pouvez le modifier de différente manière :

• En éditant ce fichier directement sur le serveur (avec un éditeur de texte type Notepad)
• Via la Console Constellation (sur la page Configuration Editor)
• Via Visual Studio
• Via l’API de Management Constellation

Le fichier contient une balise globale “configuration” dans laquelle vous trouverez 4 sections :

• configSections : réservé au moteur .NET
• constellation : la section de configuration Constellation (anciennement nommée ‘constellationSection’)
• startup : réservé au moteur .NET
• runtime : réservé au moteur .NET

Vous ne devez en aucun cas modifier les sections réservées au moteur .NET sans savoir exactement ce que vous faites.

La section de “constellation” se décompose de la façon suivante :

• listenUris : définit la configuration des URI d’écoute du serveur Constellation
• fileServer : définit la configuration du serveur Web statique utilisé pour l’hébergement de la Console Constellation
• recoveryOptions : définit les options de récupération des packages
• sentinels : définit la configuration des sentinelles (et des packages) de votre Constellation
• settingsGroups : définit la configuration des groupes de “settings”
• credentials : définit la configuration des credentials pour l’accès à votre Constellation

A chaque modification vous devez recharger la configuration soit via le hub de contrôle ou la Console Constellation (bouton “Reload Configuration”) ou soit en redémarrant le service Constellation Server.

Section “listenUris”

Cette section permet de définir les URI sur lesquels le serveur Constellation doit écouter.

<listenUris>
  <uri listenUri="http://+:8088/" />
</listenUris>

Ici le serveur répondra sur le port HTTP 8088 quelque soit le host (nom DNS ou adresse IP) car nous utilisons le wildcard “+” (pour plus d’information, lisez ceci).

Vous pouvez configurer autant de “listenUri” que vous souhaitez. Par exemple :

<listenUris>
  <uri listenUri="http://+:8088/" />
  <uri listenUri="http://constellation.mydomain.net:8888/" />
  <uri listenUri="http://+:8080/constellation/" />
  <uri listenUri="https://+:8089/" />
</listenUris>

Ici, le serveur Constellation répondra :

• Aux requêtes sur le port HTTP 8088
• Aux requêtes sur le port HTTP 8888 où le host est “constellation.mydomain.net” (en clair une requête http://<ip>:8888  ne fonctionnera pas)
• Aux requêtes sur le port HTTP 8080 quelque soit le host mais dont le path doit forcement démarrer par “/constellation/”
• Aux requêtes sur le port HTTPS 8089 en utilisant un cryptage SSL (plus d’information)

Pour prendre en compte les modifications de cette section vous devez redémarrer le service Constellation.

Section “fileServer”

Cette section permet d’activer et configurer le “fileServer” de Constellation pour héberger des fichiers statiques (pages HTML, fichiers CSS, JS, images, etc..).

Cela sert principalement pour “auto-héberger”  la Console Constellation par le serveur Constellation lui-même.

En effet, la Console Constellation n’est ni plus ni moins qu’une application Web client-side, c’est à dire une série de pages HTML avec scripts JS et fichiers CSS/Image. Libre à vous de l’héberger sur vos serveurs Web mais afin de limiter les prérequis, le serveur Constellation peut lui-même héberger la console grâce au “fileServer” intégré.

La section “fileServer” ne contient que quatre attributs :

<fileServer enable="true" path="/WebConsole" localhostOnly="true" physicalPath="D:\App\Constellation\Console" />

• “enable” : indique si le serveur de fichier statique sur le serveur Constellation doit être activé (true ou false).
• “path” : le répertoire d’écoute (préfixé par la listenUri).
• “localhostOnly” : indique si le fileServer répond seulement aux requêtes “locales” ou à toutes les requêtes (true ou false).
• “physicalPath” : le répertoire physique

Dans l’exemple ci-dessus, le serveur de fichier est activé mais ne répondra qu’aux requêtes locales. Le serveur délivra les fichiers dans “D:\App\Constellation\Console” sur l’URL “<listen_URI_du_serveur_Constellation>/WebConsole” par exemple http://localhost:8088/WebConsole ou http://127.0.0.1:8088/WebConsole en partant du principe qu’il existe une listenUri “http://+:8088”.

Comme pour la section précédente (listenUris), il faut obligatoirement redémarrer le service Constellation Server pour prendre en compte ces modifications.

Section “recoveryOptions”

Les options de récupération (recoveryOptions) permettent de définir le comportement de la sentinelle en cas d’arrêt brutale de l’exécution d’un package (crash du package).

Chaque package peut avoir ses propres options de récupération mais cette section permet de définir les options “globales”, c’est à dire appliqué par défaut pour chaque package de la Constellation.

Les options de récupérations se résume en quatre propriétés :

• “restartAfterFailure” (true par défaut) : définit si la sentinelle doit redémarrer un package en cas de crash de ce dernier
• “numberOfRetry” (3 par défaut) : définit le nombre maximal de tentative de redémarrage d’un package
• “restCounterAfterMinutes” (15 par défaut) : définit la période (en minute) au delà de laquelle le compteur d’erreur est réinitialisé
• “restartPackageAfterSeconds” (30 par défaut) : définit le délai d’attente avant de redémarrer un package suite à un crash

Dans la configuration par défaut, si un package “crash” il est automatiquement redémarré 30 secondes après son crash dans la limite de 3 tentatives sachant qu’au bout de 15 minutes, le compteur de tentative est réinitialisé à 0.

Section “sentinels”

Dans cette section vous allez déclarer vos sentinelles (virtuelles ou non) dans lesquelles vous déclarerez les packages (virtuels ou non) qui eux même déclarons leurs settings et leurs groupes.

En clair, c’est cette section qui décrit votre “Constellation”.

Prenez l’exemple de la Constellation suivante :

<sentinels>
  <sentinel name="SENTINEL-NAME-DEMO" credential="Standard">
    <packages>    
      <package name="HWMonitor" enable="true"></package>          
      <package name="DemoPackage" credential="ControlHubAccess" enable="true">
        <settings>
        <import>
          <settingGroup groupName="GroupSettingsDemo" />
        </import>
        <setting key="IntSetting" value="42" />
        <setting key="StringSetting" value="sample config value 2" />
        <setting key="SettingXml">
          <content>
            <demo type="test">
              <list count="42">
              <a>123</a>
              <b>test</b>
              </list>
            </demo>
          </content>
        </setting>
        <setting key="SettingJson">
          <content>
          <![CDATA[
          {
            ListenPorts: [ 80, 443 ],
            EnableCaching : true,
            ServerProgramName: "Hypothetical WebServer 1.0",
            Websites: [
              {
                Path: "/srv/www/example/",
                Domain: "example.com",
                Contact: "admin@example.com"    
              },
              {
                Path: "/srv/www/somedomain/",
                Domain: "somedomain.com",
                Contact: "admin@somedomain.com"
              }
            ]
          }
          ]]>
          </content>
        </setting>
        </settings>
      </package>
    </packages>
  </sentinel>
  <sentinel name="ANOTHER-SENTINEL" credential="Standard">
    <!-- ..... -->
  </sentinel>
</sentinels>

Voici ce qu’elle décrit :

• Nous avons deux sentinelles “SENTINEL-NAME-DEMO” et “ANOTHER-SENTINEL »
• Les deux sentinelles utilisent le même credential “Standard” (déclaré dans la section credentials).
• Sur la première sentinelle est déployée deux packages :
  • “HWMonitor” : le package utilise le même credential que sa sentinelle (car non défini explicitement donc hérite du credential de sa sentinelle)
  • “DemoPackage” : ce package utilise le credential nommé “ControlHubAccess” et déclare les settings suivants :
    • IntSetting et StringSetting associés à des valeurs (numérique et string)
    • SettingXml et SettingJson associés à des contenus (XML et JSON)
    • Importe le groupes de settings nommé “GroupSettingsDemo” défini dans la section “settingsGroups”

Les sentinelles

Pour entrer dans le détail, vous allez déclarer dans la section “sentinels”, les sentinelles de votre Constellation que ce soit des sentinelles réelles ou virtuelles.

Pour cela, vous utiliser la balise “<sentinel>” qui comporte les attributs suivants :

• “name” : le nom de la sentinelle (obligatoire et unique)
• “credential” : le nom du credential (déclaré dans la section credentials) à utiliser pour l’authentification (obligatoire)

La section “<sentinel>” contient une collection de “<package>” rangée dans la balise “<packages>”. Chaque package peut-être réel ou virtuel.

Les packages

L’élément “<package>” contient les attributs suivants :

• “name”: le nom de l’instance du package (obligatoire et unique)
• “filename” (facultatif) : le nom du fichier du package à utiliser dans le repository (plus d’info)
• “enable” (facultatif, par defaut true) : indique si le package est activé ou désactivé
• “credential” (facultatif, utilise par défaut du credential de sa sentinelle) : spécifie le credential que le package va utiliser pour s’authentifier sur le serveur Constellation
• “autostart” (facultatif, par defaut true) : indique si le package doit automatiquement démarrer sur sa sentinelle ou juste être déployé (et donc démarré manuellement)

Un package peut contenir ensuite trois sous sections :

• “recoveryOptions” : définit les options de récupération du package (par défaut, la sentinelle utilise les options globales)
• “settings” : définit les paramètres/variables de configuration d’un package
• “groups” : définit les groupes dans lesquels le package sera abonné

Les options de récupérations

La balise est la même que la section globale.

Par exemple si on ne souhaite pas que le package redémarre en cas de crash, on peut écrire :

<package name="MonPackage" enable="true">
  <recoveryOptions restartAfterFailure="false" />
</package>

Les paramètres de configuration

Chaque package peut définir des paramètres de configuration au niveau du serveur Constellation. Cela vous permet de changer ces paramètres directement depuis la Constellation qui se chargera de redescendre ces paramètres sur vos packages.

Il y a deux types de settings :

• Les “Setting Value” : il s’agit d’un couple clé/value
• Les “Setting Content”  : il s’agit d’un setting dont la valeur peut être un XML ou JSON

Dans l’exemple plus haut, le package “DemoPackage” contient à la fois des settings de type “value” et de type “content”.

Vous pouvez également regrouper des settings dans les groupes afin de les partager entre plusieurs package grâce aux settingsGroups. Toujours dans l’exemple précédent, le package “DemoPackage” inclut le groupe “GroupSettingsDemo”, un groupe de settings décrit dans la section ”settingsGroups”.

Pour plus d’information sur les settings, consultez l’article sur l’exploitation des settings avec l’API .NET.

Les groupes

Comme vous le savez, un message peut être envoyé à un groupe dans lequel des packages réels ou virtuels peuvent s’abonner.

Il y a deux manières d’abonner un package à un groupe :

• Soit par le package lui même en invoquant la méthode “SubscribeToMessage” via les différentes API Constellation misent à disposition
• Soit dans la configuration du package au niveau du serveur Constellation

Cela vous permet d’avoir la main sur l’appartenance des packages aux groupes que vous pouvez administrer sans devoir modifier vos packages (virtuels ou non).

La section “groups” sur un package permet de définir ces liens. Par exemple :

<package name="MonPackage" enable="true">
  <groups>
    <group name="MonGroupeA" />
    <group name="MonGroupeB" />
  </groups>
</package>

Ici le package “MonPackage” est abonné aux groupes “MonGroupeA” et “MonGroupeB”. En cas de modification des affectations aux groupes, il faudra redémarrer le package soit via vos applications en utilisant les API du hub de contrôle soit depuis la Console Constellation.

Section “settingsGroups”

Vous pouvez grouper des settings (Content ou Value) dans des groupes au niveau du serveur et importer ces groupes dans les settings de vos packages ou dans d’autres groupes.

Par exemple, créons un groupe pour “HWMonitorSettings” qui contient le setting “Interval” :

<settingsGroups>
  <group name="HWMonitorSettings">
    <settings>
      <setting key="Interval" value="500" />
    </settings>
  </group>
</settingsGroups>

Ainsi pour chaque instance du package “HWMonitor”, vous pouvez importer le groupe “HWMonitorSettings” afin de centraliser la configuration de ce package :

<package name="HWMonitor">
  <settings>
    <import>
      <settingGroup groupName="HWMonitorSettings" />
    </import>
  </settings>
</package>

Vous pouvez importer des groupes dans des groupes sans limite.

C’est toujours la valeur du setting la plus proche du package qui gagne (surcharge).

Bien entendu, vous pouvez créer autant de groupe que vous voulez et chaque groupe peut contenir des SettingValue ou des SettingContent :

<settingsGroups>
  <group name="test">
    <settings>
      <setting key="Demo1" value="Seb" />
      <setting key="Demo2" value="123" />
    </settings>
  </group>
  <group name="test2">
    <settings>
      <import>
        <settingGroup groupName="common" />
      </import>
      <setting key="Demo1" value="Sebastien" />
      <setting key="Demo2" value="2015" />
    </settings>
  </group>
  <group name="common">
    <settings>
      <setting key="MyStringSetting" value="This is a string" />
      <setting key="MyBoolSetting" value="true" />
      <setting key="MyXmlDocument">
        <content>
          <note date="09-02-2016">
            <to>Tove</to>
            <from>Jani</from>
            <heading>Reminder</heading>
            <body>Don't forget me this weekend!</body>
          </note>
        </content>
      </setting>
      <setting key="MyJsonObject">
        <content>
          <![CDATA[
        {
          "Number": 123,
          "String" : "This is a test (local)",
          "Boolean": true
        }
        ]]>
        </content>
      </setting>
    </settings>
  </group>
</settingsGroups>

Pour bien comprendre, imaginez le package suivant :

<package name="DemoPackage">
  <settings>
    <import>
      <settingGroup groupName="test" />
      <settingGroup groupName="test2" />
    </import>
    <setting key="numberTest" value="42" />
    <setting key="Demo1" value="It’me" />
  </settings>
</package>

Ici cette instance du package “DemoPackage” définie au niveau du serveur (= sans prendre en compte les settings déclarés dans le fichier local et le manifeste) 7 settings :

• numberTest = 42 (définit dans les settings du package)
• Demo1 = “It’s me” (définit dans les settings du package, cette valeur écrase celle des groupes importés)
• Demo2 = 2015 (définit par le groupe “test2”. Cette valeur écrase la valeur du groupe “test”, car le groupe “test2” est importé APRES le groupe “test”)
• MyStringSetting, MyBoolSetting, MyXmlDocument et MyJsonObject définies par le groupe “common” (groupe importé dans le groupe “test2” lui même importé sur le package “DemoPackage”).

Section “credentials”

Comme évoqué dans l’article lié à la sécurité, tous les appels (http) au serveur Constellation doivent être authentifiés en utilisant une clé d’accès que l’on nomme “AccessKey”.

Ces clé d’accès sont liés à des credentials.

Dans la section “credentials” nous allons donc définir les différents credentials ainsi que les différentes autorisations et droits sur ces credentials.

Chaque credential comporte obligatoirement deux propriétés :

• Le nom (unique) du credential
• L’AccessKey

Ainsi que les propriétés suivantes :

• “enable” (true par défaut) : indique si le credential est activé ou désactivé
• “enableControlHub” (false par défaut) : indique si le credential peut se connecter sur le hub de contrôle (pour l’administration de la Constellation)
• “enableManagementAPI” (false par défaut) : indique si le credential peut se connecter à l’API de Management (pour l’édition de la configuration)
• “enableDeveloperAccess” (false par défaut) : indique si le credential peut utiliser la sentinelle virtuelle “Developer” pour debugger des packages (utilisé par le SDK Visual Studio)

Par exemple :

<credentials>
  <credential name="Standard" accessKey="fb1af70a46057dbf4f2ff3f43b6ec0c544b22749" />
  <credential name="Administrator" accessKey="b363d6ccb86ef1418a72f9fea4b96975d8a1f2c7" enableControlHub="true" enableDeveloperAccess="true" enableManagementAPI="true" />
</credentials>

Vous pouvez ensuite définir des autorisations particulières sur un credential pour l’envoi de message, l’abonnement aux groupes de message ou encore l’interrogation de StateObject.

Pour cela il existe trois sous-sections :

• “stateObjects” : autorisations spécifiques pour l’interrogation (Request ou Subscribe) des StateObjects
• “messages” : autorisations spécifiques pour l’envoi de messages
• “groups” : autorisations spécifiques pour l’abonnement aux groupes

Les autorisations sur l’interrogation des StateObjects

Par défaut un credential actif (enable=true) peut interroger (Request ou Subscribe) tous les StateObjects de votre Constellation sans restriction.

Pour modifier ce comportement vous pouvez utiliser les autorisation sur les StateObjects.

Par exemple :

<credential name="Standard" accessKey="fb1af70a46057dbf4f2ff3f43b6ec0c544b22749">
  <authorizations>
    <stateObjects defaultAuthorization="Deny">
      <authorization id="Paradox" authorization="Allow" packageName="Paradox" />
      <authorization id="MonPC" authorization="Allow" sentinelName="PC-SEB" />
      <authorization id="LesCPU" authorization="Allow" packageName="HWMonitor" name="/intelcpu/load/0" />
      <authorization id="ServerRAM" authorization="Allow" sentinelName="SERVER" packageName="HWMonitor" name="/ram/load" />
    </stateObjects>
  </authorizations>
</credential>

Ici le credential “Standard” ne pourra pas interroger les StateObjects de la Constellation (defaultAuthorization = Deny) sauf pour les exceptions suivantes :

• Les StateObjects produits par le(s) instance(s) du package “Paradox”
• Les StateObjects produits par les packages (quel qu’il soit) de la sentinelle “PC-SEB”
• Les StateObjects nommés “/intelcpu/load/0” et produits par le package “HWMonitor” peu importe la sentinelle
• Le StateObject nommé “/ram/load” produit par le package “HWMonitor” sur la sentinelle “SERVER”

Vous devez donc définir l’autorisation par défaut (defaultAuthorization) et optionnellement ajouter une ou plusieurs exceptions avec l’élément <authorization> dont les attributs sont les suivants :

• “id” (obligatoire) : identifiant unique de l’autorisation
• “authorization” (facultatif – Allow par défaut) : type de l’exception (Allow ou Deny)
• “sentinelName” (facultatif – * par défaut) : sentinelle producteur du StateObject
• “packageName” (facultatif – * par défaut) : package producteur du StateObject
• “name” (facultatif – * par défaut) :  nom du StateObject

Les autorisations sur l’envoi de messages

Par défaut un credential actif (enable=true) peut envoyer un message à n’importe quel scope dans votre Constellation sans restriction.

Par exemple :

<credential name="Standard" accessKey="fb1af70a46057dbf4f2ff3f43b6ec0c544b22749">
  <authorizations>
    <messages defaultAuthorization="Deny">
      <authorization id="GroupA" authorization="Allow" scope="Group" args="A" />
      <authorization id="DemoSeb" authorization="Allow" scope="Package" args="DemoPackage" />
      <authorization id="TemperatureNest" authorization="Allow" scope="Package" args="Nest" messageKey="SetTargetTemperature"  />
    </messages>
  </authorizations>
</credential>

Ici le credential “Standard” ne pourra pas envoyer de message dans la Constellation (defaultAuthorization = Deny) sauf pour les exceptions suivantes :

• Messages envoyés au groupe “A”
• Messages envoyés au package “DemoPackage”
• Message “SetTargetTemperature” envoyé au package “Nest”

Vous devez donc définir l’autorisation par défaut (defaultAuthorization) et optionnellement ajouter une ou plusieurs exceptions avec l’élément <authorization> dont les attributs sont les suivants :

• “id” (obligatoire) : identifiant unique de l’autorisation
• “scope” (obligatoire) : type de scope pour le message (All, Group, Package ou Sentinel)
• “authorization” (facultatif – Allow par défaut) : type de l’exception (Allow ou Deny)
• “args” (facultatif) : les arguments du scope
• “messageKey” (facultatif) :  la clé du message

Les autorisation sur l’abonnement aux groupes

Par défaut un credential actif (enable=true) peut s’abonner à n’importe quel groupe sans restriction.

Par exemple :

<credential name="Standard" accessKey="fb1af70a46057dbf4f2ff3f43b6ec0c544b22749">
  <authorizations>
    <groups defaultAuthorization="Deny">
      <authorization groupName="A" />
    </groups>
  </authorizations>
</credential>

Ici le credential “Standard” ne pourra pas s’abonner à des groupes (defaultAuthorization = Deny) à l’exception du groupe “A”. Les attributs sont les suivants :

• “groupName” (obligatoire) : le nom du groupe
• “authorization” (facultatif – Allow par défaut) : type de l’exception (Allow ou Deny)

The post Le fichier de configuration appeared first on Constellation.

Découvrons dans cet article comment créer et déployer votre premier package Constellation en Python.

Prérequis

Tout d’abord, que vous soyez sur Windows ou Linux, il vous faudra un interpréteur Python 2 ou Python 3 et une ou deux libraires indispensables pour Constellation.

Notez que ces prérequis sont automatiquement installés sur Linux avec le Web Platform Installer.

Installer Python sur Windows

Téléchargez Python pour Windows (en version 2.x ou 3.x) puis lancez l’installation en choisissant une installation pour tous les utilisateurs :

Sélectionnez le composant “PIP” ( le gestionnaire de package Python) et ajoutez “Python.exe” dans les “Paths” Windows :

Une fois l’installation terminée, lancez une invite de commande (cmd.exe) et assurez-vous que la commande “python” fonctionne :

Toujours dans une invite de commande Windows, installez via PIP les librairies “pyzmq” (et “enum34” si vous êtes en Python 2.x) grâce aux commandes suivantes :

pip install pyzmq
pip install enum34

Si vous êtes sur Python 3.x, vous n’avez pas besoin du module “enum34”, seulement “pyzmq”.

Et voilà, votre environnement Windows est prêt !

Installer Python sur Linux

Sur un système Debian ou similaire (Raspbian, Ubuntu, etc …), vous n’avez qu’à installer (et enregistrer dans votre Constellation) une sentinelle Constellation.

Le Web Platform Installer vous proposera d’installer tous les prérequis nécessaires à savoir Python et les librairies “pyZmq” et “enum34” (si Python 2.x) via PIP.

Autrement, pour installer manuellement ces prérequis, vous pouvez utiliser les mêmes commandes que sur Windows :

sudo easy_install pip
sudo pip install pyzmq
sudo pip install enum34

Encore une fois, la libraire “enum34” est seulement requise sur Python 2.x.

Enfin si vous utilisez un Raspberry Pi, vous pouvez également consulter cet article en particulier.

Et voilà, votre environnement Linux est prêt !

Développer un package Python en ligne de commande

Vous pouvez soit utiliser le SDK Constellation basé sur Visual Studio pour créer, tester et déployer des packages Constellation (.NET ou Python) ou bien, utiliser l’outil en ligne de commande nommé « Constellation Package Tools CLI ».

Le développement sous Visual Studio est abordé ci-dessous. Pour l’outil en ligne de commande, rendez-vous sur la page : Créer, tester et déployer des packages Python en ligne de commande

Développer un package Python avec Visual Studio

Après avoir installé les prérequis et le SDK Constellation, lancez Visual Studio et créez un nouveau package Constellation de type “Python” :

Une fois créé le projet Visual Studio a la structure suivante :

Vous retrouverez une structure classique pour un package Constellation :

• App.config : le fichier de configuration local pour définir les valeurs locales de vos settings (lire ici) ainsi que les scripts Python à démarrer
• PackageInfo.xml : le manifeste de votre package
• packages.config : le fichier des packages Nuget de votre projet (réservé à Nuget)
• Program.cs : le point d’entrée (C#) de votre package qui se chargera de lancer le “Python Proxy” (le pont entre vos scripts Python et Constellation)
• Le répertoire “Scripts” (qui contient vos scripts Python)
  • Constellation.py : le proxy Python Constellation (la librairie Python) : ne pas modifier !
  • Demo.py : un script Python d’exemple

Configurer les scripts à démarrer

Vous pouvez ajouter autant de scripts Python dans le dossier “Scripts” comme vous le souhaitez. Pour cela, cliquez-droit sur ce répertoire et sélectionnez « Ajouter un nouvel élément ».

Dans la catégorie « Constellation » sélectionnez « Constellation Python Script » :

Chaque script sera démarré dans un processus dédié et connecté à Constellation.

Attention : si vous rajoutez des scripts Python dans ce dossier, il faut obligatoirement les inclure dans le package en sélectionnant “Copy if newer” pour la propriété “Copy to Output directory”. Cette propriété est automatiquement définie à cette valeur si vous avez créé votre fichier Python en sélectionnant l’élément « Constellation Python Script » comme expliqué ci-dessus.

Dans le fichier « App.config » vous devez déclarer les fichiers Python à démarrer. Les scripts Python créé en sélectionnant l’élément « Constellation Python Script » sont automatiquement ajoutés dans ce fichier lors de la création. Si vous renommez ou supprimer vos scripts, n’oubliez pas de mettre à jour ce fichier.

<pythonProxy xmlns="urn:Constellation.PythonProxy">
  <scripts>
    <script filename="Scripts\Demo.py" />
    <script filename="Scripts\LightSensor.py" />
    <script filename="Scripts\Camera.py" />
  </scripts>
</pythonProxy>

Le script “Demo.py” est créé à titre d’exemple. Vous pouvez le supprimer, renommer ou modifier à votre convenance.

Grâce à Visual Studio et au SDK Constellation, vous bénéficiez d’un environnement de développement agréable pour créer vos packages Python avec la coloration syntaxique et l’IntelliSense :

Les bases

Chaque script Python doit impérativement importer la librairie Constellation et démarrer la “connexion” avec le proxy Python en invoquant la méthode “Start” :

import Constellation
# Votre code !
Constellation.Start()

Vous avez trois façon de démarrer cette connexion :

1 – La plus simple est d’invoquer la méthode “Start” :

Constellation.Start()

La méthode “Start” démarre la connexion et maintient le script en “vie” grâce à une boucle qui tourne tant que le package Constellation est lancé.

Autrement dit le code après la méthode “Start” ne sera jamais appelé !

2 – Invoquer la méthode “Start” en passant une fonction de démarrage :

Vous pouvez passer le nom d’une fonction en paramètre de la méthode “Start” qui sera invoquée dès que le script Python est connecté à Constellation.

Cela vous permet de définir du code au démarrage du package :

def OnStart():
    # Mon code de démarrage ici
    pass

Constellation.Start(OnStart);

3 – Troisième méthode : invoquer la méthode “StartAsync” (non bloquante)

Mais attention vous devrez vous même créer une boucle pour maintenant votre script “en vie” autrement il s’arrêtera automatiquement !

Constellation.StartAsync()
while Constellation.IsRunning:
    pass
    time.sleep(1)

Interpréteurs Python et environnements virtuels

Par défaut chaque script est lancé avec la commande “python”. C’est pour cela qu’il est recommandé d’ajouter Python dans le PATH de votre système afin de pouvoir “résoudre” la commande “python”.

Vous pouvez aussi définir dans le fichier App.config de votre package Python, l’attribut “pythonCmd” pour spécifier la commande à lancer. Ci-dessous un exemple avec l’interpréteur Python 2.7 :

<pythonProxy xmlns="urn:Constellation.PythonProxy" pythonCmd="C:\Python27\python.exe">
  <scripts>
    <script filename="Scripts\Demo.py" />
    <script filename="Scripts\Demo2.py" />
  </scripts>
</pythonProxy>

L’attribut “pythonCmd” peut-être également défini de manière individuelle pour chaque script. Prenez par exemple la configuration suivante :

<pythonProxy xmlns="urn:Constellation.PythonProxy" pythonCmd="python3">
  <scripts>
    <script filename="Scripts\Demo.py" />
    <script filename="Scripts\Demo2.py" pythonCmd="C:\Users\Sebastien\venv\Scripts\python.exe" />
    <script filename="Scripts\Demo3.py" pythonCmd="C:\Python27\python.exe" />
  </scripts>
</pythonProxy>

Ci-dessus le package Python démarre trois scripts Demo.py, Demo2.py et Demo3.py de la façon suivante :

• Demo.py sera lancé par l’interpréteur Python 3 (via la commande “python3” défini au niveau global)
• Demo2.py sera lancé par un environnement virtuel ici nommé “venv” (défini pour le script)
• Demo3.py sera lancé par l’interpréteur Python 2.7 installé dans “C:\Python27”

Vous pouvez donc utiliser cet attribut pour spécifier l’interpréteur Python à utiliser (Python 2 vs 3 ou même des interpréteurs dans des environnements virtuels). Quelque soit l’interpréteur utilisé n’oubliez d’installer les librairies “pyzmq” (et “enum34” si Python 2.x).

Note : vous pouvez aussi les Settings Constellation dans l’attribut « pythonCmd » vous permettant ainsi de définir/changer d’interpréteur sans modifier le code de votre package, simplement en manipulant les settings de votre package depuis la Console Constellation. Plus d’information sur ce billet.

Produire des logs

Pour écrire des logs dans le hub Constellation, tout comme en C#, vous disposez des méthodes suivantes :

• WriteInfo
• WriteWarn
• WriteError

Exemple :

Constellation.WriteInfo("Hello world from Python !")
Constellation.WriteWarn("This is a warning !")
Constellation.WriteError("This is an error !")

En Python vous pouvez formater vos messages avec des variables grâce à l’opérateur “%”.

Par exemple, affichons dans les logs Constellation l’état de notre package :

Constellation.WriteInfo("Hi I'm '%s' and I run on %s" % (Constellation.PackageName, Constellation.SentinelName))
Constellation.WriteInfo("IsConnected = %s | IsStandAlone = %s " % (Constellation.IsConnected, Constellation.IsStandAlone))

Vous remarquez par la même occasion quelques propriétés accessibles dans vos scripts Python (IsConnected, IsStandAlone, SentinelName, PackageName, etc…).

Accès aux settings

Le fonctionnement des settings est strictement identique à l’API .NET décrite ici.

Les settings sont définis sur le serveur au niveau du package ou via des groupes, et par héritage peuvent être définis dans le fichier local App.config et/ou dans le manifeste. Je vous invite vivement à lire cet article pour bien comprendre le fonctionnement des settings.

Avec l’API Python de Constellation vous disposez de la méthode “GetSetting” pour récupérer la valeur de vos settings.

Par exemple pour afficher la valeur du setting “Demo1” :

Constellation.WriteInfo("Demo1 = " + str(Constellation.GetSetting("Demo1")))

Si la valeur du setting n’existe pas, la méthode vous retourne un “Null” :

if Constellation.GetSetting("Demo1") <> Null:
     Constellation.WriteInfo("Demo1 = " + str(Constellation.GetSetting("Demo1")))

Vous avez également la possibilité d’attacher une méthode callback pour être notifier dans votre code Python lorsque les settings de votre packages sont mises à jour dans Constellation :

import Constellation

def OnSettingsUpdated():
    print("Mise à jour de mes settings depuis Constellation !!")

def Start():
    Constellation.OnSettingsUpdated = OnSettingsUpdated

Constellation.Start(Start);

Publier des StateObjects

Comme pour l’API .NET, vous disposez de la méthode PushStateObject pour publier un StateObject.

Chaque StateObject a obligatoirement un nom et une valeur de n’importe quel type :

Constellation.PushStateObject("MyString", "OK")
Constellation.PushStateObject("MyNumber", 123)
Constellation.PushStateObject("MyDecimal", 123.12)
Constellation.PushStateObject("MyBoolean", True)

Vous pouvez publier des StateObjects dont la valeur est un objet complexe :

Constellation.PushStateObject("Demo", { "UneString": "DemoPython", "UnNombre": 123 })

Dans l’exemple ce-dessus, le StateObject « Demo » est un objet contenant deux propriétés : « UneString » et « UnNombre ».

Lorsqu’il s’agit de type complexe, il est vivement conseiller de décrire le type du StateObject à Constellation.

Pour cela au démarrage de votre package (méthode Start), enregistrez vos différents types de StateObjects avec la méthode « DescribeStateObjectType ».

Par exemple :

Constellation.DescribeStateObjectType("MyStateObject", "StateObject à deux propriétés de démonstration", [
    { 'Name':'UneString', 'Type':'string', 'Description': 'Une chaine de caractère tout simplement' },        
    { 'Name':'UnNombre', 'Type':'int', 'Description': 'Un nombre entier' }
])

Pour chaque type on spécifiera un nom, une description du type et la liste ses propriétés. Sachant que pour chaque propriété nous avons un nom, un type et une description.

Le type d’une propriété peut faire elle-même référence à un autre type complexe que vous avez enregistré.

Pour finir il faudra déclarer le package descriptor après avoir décrit tous vos types :

Constellation.DeclarePackageDescriptor()

Enfin, pour chaque publication de StateObject, vous pouvez spécifier le type (simple ou complexe que vous aurez enregistré ci-dessus), un dictionnaire de méta-données ou encore une durée de vie (en seconde)  :

Constellation.PushStateObject("Demo", { "UneString": "DemoPython", "UnNombre": 123 }, type = "MyStateObject", metadatas = { "DeviceId": "RPi", "SerialNumber":"123" }, lifetime = 300)

Tester son package dans Visual Studio

Laissons le code de démo du script “Demo.py” créé par le Template du projet tel quel :

Notons simplement qu’au démarrage du package on enregistre la méthode “OnStart” pour :

• Produire différents logs via des “WriteInfo” (Warning & Error) contenant notamment différentes propriétés comme le IsConnected & IsStandalone.
• Publier le StateObject “Demo”

Debug local (hors Constellation)

Commençons par tester notre package hors Constellation en lançant simplement le package avec le bouton “Start” de Visual Studio (F5) :

Votre package démarre et vous pouvez suivre dans la console les différents logs produits par votre package.

Vous observerez que votre package n’est pas connecté à Constellation (IsConnected = false).

Debug dans Constellation

Maintenant lançons toujours le debugging de votre package Constellation depuis Visual Studio mais en connectant votre package à Constellation. (Assurez-vous d’avoir défini dans Visual Studio la Constellation à utiliser pour le debug comme nous l’avons vu dans ce guide).

Cette fois ci, votre package démarre dans Visual Studio mais en étant connecté à Constellation (IsConnected = true).

Vous pouvez donc suivre en temps réel les logs depuis la Console Constellation :

Vous retrouverez également dans le StateObject Explorer de la Console, le StateObject “Demo” publié par notre package :

Publiez votre package

Lorsque votre package est testé et validé, nous pouvons le publier dans Constellation.

Pour cela cliquez sur le bouton de publication :

Sélectionnez votre serveur Constellation cible et cliquez sur “Publish” :

Une fois publié, vous retrouverez votre package dans le “Package Repository” de la Console.

N’oubliez pas que vous pouvez personnaliser les différentes informations (nom du package, auteur, URL, version, description, etc…) en éditant le manifeste de votre package.

Déployez votre package sur une sentinelle

Maintenant que votre package est dans le catalogue de votre Constellation, vous pouvez le déployer sur autant de sentinelle que vous le souhaitez!

Par l’édition du fichier de configuration

Pour cela, vous pouvez éditer manuellement la configuration (via le Configuration Editor) pour ajouter une instance de package sur la sentinelle de votre choix par la ligne :

<package name="MonPackagePython" />

On peut également déclarer le setting “Demo1” pour cette instance de package :

<package name="MonPackagePython">
  <settings>
    <setting key="Demo1" value="Hello Python !!!!" />
  </settings>
</package>

Cliquez sur le bouton “Save & Deploy” et votre package sera automatiquement démarré sur la sentinelle ici nommée “PO-SWARIN” !

Par l’interface graphique de la Console Constellation

Autre moyen, plus intuitif et rapide pour déployer un package, cliquez sur le bouton “Deploy” dans menu contextuel de votre package Python :

Vous pouvez également cliquer sur le bouton “Deploy new package” sur la page “Packages”.

Un assistant vous proposera de sélectionner la sentinelle sur laquelle déployer votre package Python :

Si les settings de votre package sont déclarés dans le manifeste (voir ici), la Console vous affichera une fenêtre de paramétrage :

Une fois votre package déployé, vous pourrez suivre dans la Console Log votre package :

Et voilà votre premier package Python créé et déployé dans votre Constellation !

Next steps

• MessageCallback : exposer des méthodes Python dans la Constellation
• Envoyer des messages et invoquer des MessageCallbacks de la Constellation
• StateObjectLink : consommer des StateObjects de votre Constellation

The post Créez votre premier package Constellation en Python appeared first on Constellation.

Introduction

Par exemple si vous disposez d’un Arduino il vous faudra un shield Ethernet ou Wifi bien que ces derniers ont été retirés du support Arduino.

Arduino propose en alternative des modèles déjà équipés d’une connectivité Ethernet et/ou Wifi comme le MKR1000, le Yun Shield ou le Wifi Shield 101.

En alternative vous avez les ESP8266 que j’ai pu vous présenter sur mon blog personnel.

Ce microcontrôleur est cadencé à 80Mhz par un processeur 32bits RISC avec 96K de RAM et une mémoire flash de 512Ko à 4Mo selon les modèles.

Il dispose d’une connectivité Wifi 802.11 b/g/n supportant le WEP, WPA/2/WPS et réseau ouvert et 16 GPIO dont le support du SPI, I²C, UART et un port ADC (pour les I/O analogiques).

Vous trouverez différents modèles sur internet, comme ceux produit par AI-Thinker mais il faudra réaliser vous même la carte de programmation comme je l’explique sur mon blog ou bien des modules “tout en un” comme ceux d’Adafruit ou Sparkfun disposant d’un port USB intégré pour une programmation facile :

Si vous débutez je vous recommande la Wemos D1 Mini qui intègre un ESP8266 avec 4M de mémoire Flash, 11 I/O digitales et 1 analogique (ADC) ainsi qu’une interface USB le tout pour moins de 5€ :

Pour bien comprendre les ESP8266, je vous recommande une nouvelle fois mon article Découverte des ESP8266 : le microcontrôleur connecté par Wifi pour 2€ au potentiel phénoménal avec Constellation

Le plus important étant que les ESP8266 peuvent être programmés comme les Arduino avec l’IDE Arduino.

Arduino/ESP8266 = package virtuel

Ce concept a déjà été abordé ici. En clair le micro-programme d’un Arduino ou d’un ESP est stocké dans la puce elle même et il n’y a pas de concept de “processus” sur ce genre de device. Il n’est donc pas possible d’avoir une véritable sentinelle qui tourne ce genre d’objet pour déployer et superviser des packages Constellation à la volée comme sur un système Windows ou Linux.

C’est pour cela qu’on parle de sentinelle et de package “virtuel” : on déclare bien dans la configuration de notre Constellation une sentinelle (par exemple nommée “Arduino” et associée à un credential) et contenant un package (par exemple nommé  “TemperatureSensor”). Ce package peut être joint à des groupes et avoir des settings qui lui sont propres.

Dans le microprogramme téléversé sur votre Arduino/ESP vous allez vous connecter en spécifiant le nom de la sentinelle et du package virtuel (ici Arduino/TemperatureSensor) et la clé d’accès associée. Votre device sera alors connecté à Constellation comme étant le package “TemperatureSensor” sur la sentinelle “Arduino”. Comme n’importe quel package il pourra produire des logs, publier des StateObjects, récupérer ses settings, envoyer ou recevoir des messages ou encore consommer les StateObjects d’autres packages.

Techniquement parlant l’Arduino/ESP utilise l’API REST “Constellation”.

Installer la librairie Constellation dans l’IDE Arduino

Ouvrez le « Gestionnaire de bibliothèque » dans le menu « Croquis > Inclure une bibliothèque > Gérer les bibliothèques » :

Avec le moteur de recherche, recherchez le terme « ArduinoJson » :

Vous trouverez lors la bibliothèque « ArduinoJson » de Benoit Blanchon (dépendance de la librairie Constellation) ainsi que la librairie Constellation.

Pour ces deux bibliothèques, cliquez sur le bouton « Installer » (ou « Mise à jour » si la librairie est déjà installée).

Hello World, Hello Constellation

Commencez par créer un nouveau sketch et ajoutez la librairie Constellation :

#include <Constellation.h>

Vous pouvez maintenant déclarer le client “Constellation” en l’initialisant avec l’adresse (IP ou DNS) de votre serveur Constellation, le port et les informations de connexion de Constellation, c’est à dire le nom de votre sentinelle et package ainsi que la clé d’accès que vous aurez déclarés sur votre serveur :

Constellation<WiFiClient> constellation("IP or DNS du serveur constellation", 8088, "MyVirtualSentinel", "MyVirtualPackage", "123456789");

Pour ajouter une sentinelle virtuelle cliquez sur le bouton “Add sentinel” sur la page “Sentinels” de la Console Constellation :

Puis ajoutons un package virtuel en cliquant sur le bouton contextuel de notre sentinelle “Deploy package” ou directement depuis la package “Packages” :

Déclarez ensuite le nom de votre package, ici “MyVirtualPackage” utilisant la même clé que celle définie au niveau de la sentinelle :

Vous remarquerez que dans la déclaration du client Constellation nous avons spécifié dans le template de la classe Constellation le type de notre client réseau, qui dans le cas d’un ESP8266 ou d’un Arduino MKR1000 est “WifiClient”.

N’oubliez pas d’ajouter les librairies de votre client réseau, quelques exemples :

/* Arduino Wifi (ex: Wifi Shield) */
#include <SPI.h>
#include <WiFi.h>

/* Arduino Wifi101 (for WiFi Shield 101 and MKR1000 board) */
#include <SPI.h>
#include <WiFi101.h>

/* Arduino Ethernet */
#include <SPI.h>
#include <Ethernet.h>

/* ESP8266 Wifi */
#include <ESP8266WiFi.h>

Au démarrage du programme, nous allons d’abord connecter votre client réseau sur le réseau. Dans le cas d’un ESP8266, on se connecte au réseau Wifi de cette façon :

void setup(void) {
  Serial.begin(115200);

  // Connect to Wifi  
  WiFi.begin("MY-SSID", "MY-WIFI_KEY");  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // For WiFi101, wait 10 seconds for connection!
  // delay(10000);

  Serial.println("WiFi connected. IP: ");
  Serial.println(WiFi.localIP());
}

Une fois connecté au réseau, on peut utiliser les méthodes de la librairie Constellation.

Par exemple, produisons un log avec la méthode “WriteInfo” :

constellation.writeInfo("Hello Constellation");

Cette méthode gère nativement le formatage “à la printf”, par exemple :

constellation.writeInfo("Hello Constellation, I'm '%s !", constellation.getSentinelName());

Notez que vous pouvez produire de la même façon des messages de type “Info”, “Warning” ou “Error” :

constellation.writeInfo("This is an information"); 
constellation.writeWarn("This is a warning"); 
constellation.writeError("This is an error");

Bien entendu, comme n’importe quel package, les logs sont remontés en temps réel dans la Constellation ce qui permet à n’importe quel “contrôleur” de voir les logs de votre Arduino/ESP en temps réel.

Par exemple, en ouvrant la Console Constellation on pourra suivre votre Arduino/ESP en temps réel :

Accès aux settings

Tous les settings des packages de votre Constellation sont déclarés depuis le fichier de configuration de votre Constellation. Vous pouvez aussi utiliser la Console Constellation pour les administrer.

Dans votre code Arduino, vous devez utiliser la méthode “getSettings” pour récupérer un objet JSON contenant les settings (clé/valeur).

JsonObject& settings = constellation.getSettings();

Par exemple pour récupérer la valeur du setting “MonChiffre” déclarée sur le serveur à 42 :

JsonObject& settings = constellation.getSettings();
static int monChiffre= settings["MonChiffre"].as<int>()

La variable “monChiffre” sera donc affectée à la valeur “42”. Dans l’exemple ci-dessus, la variable est statique pour pouvoir être utilisée n’importe où dans votre code.

Pour les chaines de caractères vous pouvez utiliser la classe “String” :

JsonObject& settings = constellation.getSettings();
static String strMaChaine = String(settings["MaChaine"].as<char *>());

Encore une fois la variable est statique pour pouvoir l’utiliser n’importe où dans votre code.

Si vous devez convertir votre chaîne de caractères en const char *, vous pouvez utiliser la fonction c_str() :

const char* maChaine = strMaChaine.c_str();

Vous pouvez également tester la présence d’un setting avec la méthode « containsKey » :

if(settings.containsKey("MySetting")) {  
  // Do something with settings["MySetting"]  
}

Par exemple vous pouvez gérer les valeurs par défaut. Imaginez un code où la valeur d’un timeout est de 5 secondes par défaut mais vous vous laissez la possibilité de surcharger cette variable depuis les settings Constellation :

// Default value
int timeout = 5; // sec

setup() {
  // .....
  JsonObject& settings = constellation.getSettings();
  if(settings.containsKey("Timeout")) {  
    timeout = settings["Timeout"].as<int>();
  }
}

void loop() {
   // DO something with 'timeout'
}

Si le setting « Timeout » est défini dans les settings de votre package sur Constellation, la variable « timeout » sera affectée à votre valeur, autrement, si le setting n’existe pas, la valeur de cette variable sera de 5.

Publier des StateObjects

Pour produire et publier un StateObject dans votre Constellation vous devez invoquer la méthode “pushStateObject” :

constellation.pushStateObject(name, value);

Vous pouvez aussi passer le “type” de votre StateObject :

constellation.pushStateObject(name, value, type);

Notez que pour les types simples (int,bool, long, float et double) le type est spécifié implicitement.

Par exemple, pour publier un StateObject dont la valeur est un chiffre :

constellation.pushStateObject("Temperature", 21);

Vous pouvez aussi publier des StateObject avec un objet complexe en utilisant la fonction “stringFormat” pour formater votre valeur en JSON.

Par exemple pour publier un StateObject nommé “Lux” étant un objet contenant 3 propriétés :

constellation.pushStateObject("Lux", stringFormat("{ 'Lux':%d, 'Broadband':%d, 'IR':%d }", lux, full, ir));

Vous pouvez également faire la même chose en construisant un “JsonObject” :

StaticJsonBuffer<200> jsonBuffer;
JsonObject& root = jsonBuffer.createObject();

root["Lux"] = lux;
root["Broadband"] = full;
root["IR"] = ir;
constellation.pushStateObject("Lux", &root);

Une fois vos StateObjects publiés, ils sont accessibles en temps réel aux autres packages et consommateurs de votre Constellation. Vous pouvez également utiliser le “StateObject Explorer” de la Console Constellation pour explorer tous les StateObjects de votre Constellation :

Next steps

• Publier des StateObjects
• Envoyer des messages
• Recevoir des messages
• Consommer des StateObjects
• Connectez vos ESP8266 à Constellation en Lua avec NodeMCU

The post Connecter un Arduino ou un ESP8266 à Constellation appeared first on Constellation.

Pour chaque package (réel) vous avez en temps réel :

• Le statut :
  • Starting : package en cours de démarrage
  • Started : package démarré et en cours de fonctionnement
  • Stopping : package en cours d’arrêt
  • Stopped : package arrêté
• L’état de connexion qui indique si le package est bien connecté au serveur
• La date de la dernière activité (il s’agit de la date de la dernière modification du statut)
• La consommation en CPU et RAM sur la sentinelle sur lequel le package est démarré
• Des informations quant à la version du package et de la librairie Constellation utilisée par le package

En fonction de l’état du package le bouton d’action permettra de démarrer le package (Start) et de l’arrêter (Stop).

Comme sur les autres pages de la Console, vous avez un menu contextuel pour chaque package vous permettant de contrôler le package, d’éditer sa configuration ou ses settings, etc.

La fenêtre d’information permet de retrouver toutes les informations sur le statut du package :

Notez également que vous avez la possibilité de filtrer dans la liste des packages soit avec la zone de texte ou soit en cliquant sur le bouton “Show filters” afin de filtrer le type de package (réel ou virtuel), l’état de connexion (connecté ou non) et l’état activé/désactivé. Par défaut tous les packages sont affichés à l’exception des packages marqués “Désactivé” (Enable=false).

Contrôler un package

Pour pouvez pour chaque package le démarrer ou l’arrêter avec le bouton d’action sur la droite ou depuis le menu contextuel.

Vous pouvez également redémarrer le package (restart) c’est à dire demander à la sentinelle de stopper le package (si il est “Started”)  puis de le démarrer.

Vous pouvez aussi faire un rechargement du package : “reload”. Cette action fonctionne comme un “restart” mais force la sentinelle à (re)télécharger le package du “Package Repository” du serveur. Cela permet de déployer les mises à jours de vos packages : vous envoyez la nouvelle version de votre package sur votre serveur Constellation puis vous faites un “reload” afin de reforcer les sentinelles à redémarrer le package avec sa nouvelle version.

Pour finir vous pouvez également “pousser” les settings vers un package en cas de modification (sans avoir à redémarrer le package).

Editer la configuration d’un package

Pour chaque package (réel ou virtuel) vous pouvez saisir le nom de l’instance (seulement lors de la création) et le credential utilisé pour la connexion du package. Vous pouvez également définir si le package est activé ou non.

S’il s’agit d’un package réel, vous pouvez définir si le package doit démarré automatiquement lorsque la sentinelle se démarre et vous pouvez également redéfinir les options de récupération :

Editer les settings d’un package

Il s’agit des paramètres propre au package (voir ici).

Pour chaque package vous définir autant de variable de configuration (= une clé et une valeur) que vous désirez en cliquant sur le bouton “Add new setting” :

Dans le cas d’un package dit “réel” il est grandement recommandé de déclarer les settings utilisés par le package dans son manifeste : voir ici.

Cette déclaration permet à la Console Constellation de connaitre les settings obligatoires ou non, le type de chaque setting, la description et valeur par défaut.

Editer les groupes d’un package

Pour rappel, un message peut être envoyé à un (ou plusieurs) groupe qui regroupe des packages ou des consommateurs. Chaque package ou consommateur peut joindre un groupe depuis les API mais vous pouvez également définir ces liens d’appartenance au niveau de la configuration du serveur.

Pour cela, cliquez sur “Group membership” dans le menu contextuel d’un page et définissez les groupes dont fait partie votre package :

Déployer un package

Pour déployer un package, vous avez plusieurs solutions :

• Cliquez sur le bouton “Deploy new package” depuis la page “Packages”
• Cliquez sur le bouton “Deploy new package” dans le menu contextuel d’une sentinelle sur la page « Sentinels »
• Utiliser la page “Package Repository”

Depuis la page des Packages, cliquez sur le bouton “Deploy new package” en haut à gauche  :

Vous obtiendrez alors une pop-in vous permettant de sélectionner la sentinelle sur laquelle déployer et le package à déployer :

S’il s’agit d’un page virtuel, sélectionnez “Virtual package” (voir ci-dessous) sinon sélectionner un package présent dans votre “Package repository”.

Vous serez alors guidé dans les étapes de configuration du package.

Note : par défaut le champ “Package file” est nul, c’est à dire que le fichier à utiliser pour votre instance sera déterminé dynamiquement (lire ici).

Dans le cas où une instance est déjà présente sur la sentinelle vous serez obligé de définir un autre nom et donc de spécifier le “Package file”.

Par exemple, ici je pourrais nommer cette nouvelle instance “HWMonitor2” en utilisant le fichier “HWMonitor”.

Veuillez lire ceci pour bien comprendre le mécanisme de résolution.

Les packages virtuels

Comme expliqué ici, un package virtuel n’est pas réel dans le sens où ce n’est pas un processus lancé et supervisé par une sentinelle.

De ce fait, dans la Console, vous n’aurez aucun information remontée à son sujet.

Vous pouvez seulement les déclarer ou supprimer, les associer à des credenitals, gérer l’appartenance aux groupes ou bien sûr gérer les settings.

The post Gérer les packages avec la Console Constellation appeared first on Constellation.

Nous allons dans cet article créer, tester et déployer sur votre Constellation un package Python avec cet outil.

Prérequis

Le « Constellation Package Tools CLI » est un outil en ligne de commande compatible Windows et Linux. Il est écrit en Python et s’installe via PIP avec la commande :

pip install constellation-pkgtools-cli

Sur Windows vous devriez au préalable avoir installé Python 2.7 ainsi que l’outil « pip » et les libraires « pyzmq » et « enum34 ». La procédure complète d’installation est décrite sur cette page.

Via une invite de commande, tapez la commande ci-dessus :

Sur Linux, vous devez également avoir installé Python 2.7 (généralement installé par défaut),  l’outil « pip » et les libraires « pyzmq » et « enum34 » sans oublier le moteur Mono. Pour cela, utilisez le WPI (Web Platform Installer) pour installer une sentinelle Constellation. Celui-ci se chargera de déployer l’ensemble des prérequis nécessaire.

La commande « ctln »

Une fois le package Python « constellation-pkgtools-cli » installé via PIP, vous aurez accès à une commande nommée « ctln » (abréviation de Constellation)

Cette commande vous permettra de créer de nouveau package, les tester et déployer en local ou directement sur un serveur Constellation.

Créer son premier package Python

Pour créer un nouveau package utilisez simplement la commande “create” en spécifiant le nom de votre package. Par exemple :

ctln create <mon projet>

Et voilà, votre package “MyFirstPackage” est créé dans le répertoire du même nom !

Template de package

Chaque package est créé à partir d’un template. Vous pouvez lister les templates avec la commande :

ctln template list

A l’heure où est écrit cet article il y a deux templates de type “projet” :

• Python Base Template : le template de base (créé par défaut)
• Python Demo template : package Python avec du code de “demo”

Lorsque vous créez un package avec la commande “ctln create”, le template “python-base” est sélectionné par défaut.

Vous pouvez cependant préciser l’Id du template à utiliser dans la commande “ctln create”. Par exemple pour créer un package sur base du template de demo :

ctln create <mon projet> python-demo

Il y a aussi des templates de type “item”, c’est à dire des templates pour les scripts que vous allez rajouter par la suite à votre package.

Mise à jour du template

Comme vous le constatez dans le listing des templates ci-dessus, chaque template comporte un numéro de version car ils sont amenés à évoluer notamment en cas de mise à jour des librairies Constellation.

Avec le SDK Constellation Visual Studio, les nouvelles versions des librairies sont diffusées avec NuGet. Ici avec cet outil en ligne de commande, les nouvelles librairies sont embarquées dans des mises à jour des templates.

Ainsi pour mettre à jour vos packages, vous pouvez tout simplement mettre à jour le template de votre package par la commande :

ctln update

Cette commande doit être lancé depuis le répertorie racine de votre package.

Notez également que la mise à jour est “intelligente” dans la mesure où elle n’écrase pas vos fichiers de configuration, le manifeste du package ou encore vos scripts Python.

Développer son package

Le développement de package Python est expliqué dans cet article. Bien que l’article se base sur Visual Studio, l’API Python est strictement identique.

Ainsi, pour rappel, vous avez à la racine de votre projet le fichier « PackageInfo.xml » qui contient l’ensemble des informations de votre package (plus de détail ici) mais aussi le fichier de configuration nommé « PythonPackageHost.exe.config » qui contient la liste des scripts Python à lancer.

Les bases du développement d’un script Constellation Python sont expliquées ici.

Pour faciliter le développement, vous n’êtes pas obligé de modifier manuellement le fichier de configuration pour gérer les scripts Python. Pour cela vous avez à disposition différentes commandes pour lister, ajouter, renommer ou supprimer des scripts.

Lister les scripts du package

Les scripts Constellation Python lancés par votre package peuvent être listés par la commande :

ctln pyscript list

Ici votre package « MyFirstPackage » ne contient qu’un seul script nommé « Main.py » dans le répertoire Scripts du package.

Ajouter des scripts Python

Pour ajouter un script Constellation Python, vous pouvez soit ajouter un script existant sur votre système de fichier dans votre package ou soit créer un nouveau script à partir d’un modèle (template).

Ajouter un script existant

Pour un script existant, il suffit d’utiliser l’option « add » :

ctln pyscript add <filepath> [--filename=<name>]

Vous devez spécifier le chemin complet vers votre fichier à ajouter (filepath) et optionnellement le nom du fichier une fois ajouté dans votre package.

Par exemple la commande ci-dessous ajoutera dans votre package le fichier « ~/demo/MyDemo.py » sous le nom « DemoSeb.py »

ctln pyscript add ~/demo/MyDemo.py --filename=DemoSeb.py

Ajouter de nouveau script

L’action la plus courante sera de créer un nouveau script Python dans votre package avec l’action « new » via la commande suivante :

ctln pyscript new <filename> [<item_template_name>]

Vous devez obligatoirement spécifier le nom du fichier (filename) avec ou sans l’extension .py (rajoutée automatiquement). Le script sera créé dans le répertoire Scripts de votre package et automatiquement déclaré dans la configuration.

Vous pouvez également spécifier l’identifiant du template à utiliser. Les templates peuvent être listés avec la commande « ctln template list » comme vu ci-dessus.  A l’heure où cet article est écrit il y a trois templates de type « item » :

• « python-base » : le template de base
• « python-demo »  : un template avec du code de demonstration
• « python-empty »  : un squelette vide

Si vous ne précisez pas l’identifiant, c’est le template « python-base » qui sera utilisé.

Par exemple ajoutons à notre package un deuxième script (avec le template de base) :

ctln pyscript new Main2

Rajoutons également un troisieme scriupt de démonstation en utilisant le template de demo (python-demo) :

ctln pyscript new DemoConstellation python-demo

Notre package a maintenant trois scripts : Main.py (créé avec le template du package), Main2.py (créé ci-dessus avec le template de base), DemoConstellation.py (créé avec le template de demo) :

Renommer ou supprimer des scripts

Vous pouvez renommer les scripts du package avec l’option “rename”. Par exemple renommons “DemoConstellation” par “Demo” (les extensions “.py” sont optionnelles) :

ctln pyscript rename DemoConstellation Demo

Pour supprimer des scripts il suffit d’utiliser l’option “remove” en spécifiant le nom du script (avec ou sans son extension .py).

Par exemple supprimons les deux fichiers “Main2.py” et “Demo.py” que nous avons ajoutés (et renommés) ci-dessus :

ctln pyscript remove Main2
ctln pyscript remove Demo

Editer les scripts Python du package

Une fois vos scripts ajoutés, renommés ou supprimés avec la commande “ctln”, libre à vous d’utiliser votre éditeur de texte préféré pour éditer votre code !

Par exemple de le cas ici présent d’un accès SSH Linux, je pourrais utiliser “nano” ou “vim” (ou encore Notepad++ sur ma station WIndows via un tranfert SCP avec WInSCP par exemple).

nano Scripts/Main.py

Ici le script “Main” défini une fonction de démarrage (OnStart) et une fonction de fermeture (OnExit). Pour rappel, les bases de l’API Constellation Python sont expliquées ici.

Notez simplement que dans cet exemple, le WriteInfo déclenché au démarrage (OnStart) écrit un log dasn Constellation de type “Information” en concaténant dans un message textuel les propriétés suivantes :

• “PackageName” : le nom du package
• “SentinelName” : le nom de la sentinelle sur laquelle est déployée ce package
• “IsStandAlone” : un booléen indiquant si le package tourne de façon indépendante ou hébergée au sein d’une sentinelle
• “IsConnected” : un booléen indiquant si le package est connecté ou non à une Constellation

Tester son package

Pour tester notre package en local, il suffit de lancer la commande suivante :

ctln run

Comme vous pouvez le lire sur la console, le nom de la sentinelle affichée est “local sandbox” étant donné que la propriété IsStandalone est true (la propriété SentinelName est None). En effet votre package n’est pas déployé/démarré par Constellation sur une véritable sentinelle. Il est juste démarré en “standalone” par la commande “run”.

De plus la propriété “IsConnected” est false car votre package n’est pas connecté à une Constellation.

Vous pouvez donc tester des éléments de base de votre package mais de façon déconnecté, il manquera donc plusieurs fonctionnalités (les logs produits resterons local dans votre console, pas d’accès aux settings hormis ceux déclarés en local, la publication ou consommation de StateObjects sera impossible tout comme l’invocation ou l’exposition de MessageCallbacks).

Pour tester votre package complètement, il est possible de le lancer en local tout en le connectant à une Constellation.

Tout d’abord, il faudra déclarer des serveurs Constellation dans l’outil ctln.

Ajouter et gérer des serveurs Constellation

Les commandes sont les suivantes :

ctln server list
ctln server (add | set) <name> --url=<url> --accesskey=<key>
ctln server (add | set) <name> --url=<url> --username=<user>
ctln server check <name>
ctln server remove <name>

Vous pouvez lister les serveurs, ajouter ou mettre à jour des serveurs avec la clé d’accès ou un couple login/password, tester la connectivité ou supprimer des serveurs.

Par exemple je dispose d’une Constellation installée à l’adresse : http://pc-seb.ajsinfo.loc:8088. Un credential basé sur le couple login/password “admin/seb” a été configuré. Je peux donc ajouter ce serveur que je nommerai ici “pc-seb” via la commande :

ctln server add pc-seb --url=http://pc-seb.ajsinfo.loc:8088 --username=admin

Le serveur ajouté est testé au moment de l’ajout mais vous pouvez à tout moment tester la connectivité vers cette Constellation avec la commande “ctln server check”. Par exemple pour tester la Constellation nommée “pc-seb” :

ctln server check pc-seb

Tester son package dans Constellation

Maintenant que nous avons ajouté un serveur Constellation dans l’outil, nous pouvons relancé notre package en le connectant à notre Constellation nommée “pc-seb” via la commande :

ctln run --server=pc-seb

Le package démarre toujours dans la « sandbox locale » (IsStandalone = true) mais cette fois ci il est connecté à ma Constellation nommée « pc-seb » (IsConnected = true).

D’ailleurs en lançant la Console Constellation je peux maintenant suivre en temps réel les logs de ce package, les StatesObjects qu’il produit ou encore les MessageCallbacks qu’il expose.

Publier son package

Une fois le package développé et testé, il ne reste plus qu’à le packager pour pouvoir le déployer dans Constellation.

Vous pouvez soit le packager dans un fichier en local (que vous pourrez uploader sur une Constellation ou échanger avec d’autre) ou soit le déployer directement dans une Constellation référencée dans l’outil.

Par exemple pour publier ce package dans un fichier local dans le répertoire “/home/pi” :

ctln publish --output=/home/pi

Maintenant, pour déployer ce même package directement sur une Constellation, il suffit simplement de spécifier le nom du serveur Constellation enregistré sur la commande “publish”.

Par exemple pour publier ce package sur la Constellation nommée ici “pc-seb” :

ctln publish pc-seb

En vous rendant sur le Package Repository de votre Console Constellation, votre package fraîchement publié sera prêt à être déployé sur vos sentinelles Windows ou Linux de votre Constellation.

Next steps

Pour en savoir plus sur le développement de package en Python :

• Retour sur les bases de l’API Python  (produire des logs, accéder aux settings, publier des StateObjects)
• Exposer vos fonctions Python dans Constellation (les MessageCallbacks)
• Invoquer des MessageCallbacks des autres packages de votre Constellation en Python
• Consommer les StateObjects de votre Constellation

The post Créer, tester et déployer des packages Python en ligne de commande appeared first on Constellation.

Développer des applications natives sur ESP peut être assez compliqué pour celui qui ne connait pas le développement bas niveau !

NodeMCU a eu l’idée de créer un firmware ESP8266 embarquant eLua, un interpréteur Lua très minimaliste pour système embarqué. Grace à ce firmware vous pouvez développer des programmes pour votre ESP très facilement en Lua.

Concrètement il faut commencer par flasher votre ESP avec le firmware NodeMCU en utilisant un outil comme ESP Flash Download (voir ici). Vous pouvez télécharger le firmware directement sur le GitHub de NodeMCU ou bien sur http://nodemcu-build.com/  pour compiler son firmware à la demande en personnalisant différentes options (branche à compiler, modules à inclure, support ou non du SSL, activation du mode debug, etc..).

Une fois installé utilisez l’outil Esplorer, une application Java (compatible Linux/Windows et Mac OS) pour éditer les scripts Lua directement depuis le système de fichier de votre ESP.

A gauche vous retrouverez l’éditeur, à droite la sortie de votre ESP. Chaque fichier est enregistré dans le système de fichier de votre ESP avant d’être exécuté.

Par exemple pour se connecter au Wifi :

print("Démarrage")
wifi.setmode(wifi.STATION)
print("set mode=STATION (mode="..wifi.getmode()..")")
wifi.sta.config{ssid="MON RESEAU WIFI", pwd="Ma clé Wifi"}

tmr.alarm(0, 1000, 1, function()
   if wifi.sta.getip() == nil then
      print("Connecting to AP...")
   else
      print("Connected! IP: ",wifi.sta.getip())
      tmr.stop(0)
   end
end)

On commence par définir le mode Wifi à Station (client) puis on se connecte en spécifiant le SSID et la clé Wifi. Ensuite on lance une tache qu’on exécute sur le timer « 0 » (vous pouvez aller de 0 à 6), à une seconde d’intervalle (1000ms) de façon répétitive afin de récupérer l’IP. Si la connexion n’est pas encore effective on affiche le message « Connecting » sinon on coupe le timer « 0 » et on affiche l’adresse IP de votre ESP.

Pour plus d’information je vous invite à lire ou relire cet article : http://sebastien.warin.fr/2016/07/12/4138-decouverte-des-esp8266-le-microcontroleur-connecte-par-wifi-pour-2-au-potentiel-phenomenal-avec-constellation/

Connexion à Constellation

Commencez tout d’abord par télécharger la librairie “Constellation pour NodeMCU” et transférez les fichiers du fichier ZIP sur votre ESP avec Esplorer.

Créez ensuite un script Lua en incluant cette librairie afin d’initialiser le client Constellation avec l’adresse du serveur, votre Sentinelle & package virtuel ainsi que la clé d’accès :

local constellation = require("constellation")
constellation.init("constellation.monserveur.com", 8088, "MyVirtualSentinel", "MyVirtualPackage", "123456789")

Fonctionnalités de base

Vous pouvez écrire dans les logs Constellation grâce à la méthode “writeLog”. Par exemple :

constellation.writeLog("Je suis pret avec " .. node.heap())

Par défaut les logs sont envoyés comme “Information”, mais vous pouvez spécifier “Warn” ou “Error” dans le 2ème arguments de cette méthode :

constellation.writeLog("Ceci est un warning", "Warn")
constellation.writeLog("Ceci est une erreur", "Error")

Vous pouvez également récupérer les settings de votre package virtuel du serveur Constellation avec la méthode “getSettings” :

constellation.getSettings(function(messages)
      print("Settings received :")
      for k,v in pairs(messages) do
          print(" -> " .. k .. " = " .. v)
      end        
  end)

Publier des StateObjects

Pour publier un StateObject, vous disposez de la méthode “push” prenant en paramètre le nom et la valeur. Dans la version 1.0 le “lifetime”, “type” ou les “métadatas” ne sont pas supportés.

Vous pouvez publier soit des types simples, par exemple :

constellation.push("Lux", math.floor(lux))

Soit des types complexes, c’est à dire des objets formatés en JSON. Vous pouvez formater vous même vos objets par concaténation :

constellation.push("Lux", "{ Broadband:" .. broadband .. ", IR:" .. ir .. ", Lux:" .. math.floor(lux) .. "}")

Ou bien via le module Lua “cjson” :

constellation.push("Lux", cjson.encode({ Broadband=broadband, IR=ir, Lux= math.floor(lux) }))

Recevoir des messages

Vous pouvez également recevoir des messages sur votre ESP8266 en enregistrant une fonction “callback” qui sera invoquée à chaque message reçu.

Par exemple :

constellation.subscribeToMessage(function(message)
    print(message["Sender"]["FriendlyName"], message["Key"], message["Data"][2])  
    if message["Key"] == "Restart" then
        node.restart()
    end        
end)

Dans cette première version de la librairie la description des messages callback (Package Descriptor) n’est pas supportée.

The post Utiliser Lua sur NodeMCU pour connecter des ESP8266 à Constellation appeared first on Constellation.

Avec cette interface vous pourrez via des requêtes HTTP :

• Publier, consommer ou purger des StateObjects
• Envoyer et recevoir des messages
• Récupérer les settings du package « virtuel »
• Produire des logs
• Déclarer le “Package Descriptor” (MessageCallbacks exposés ou les types utilisés par les MC ou SO)

De ce fait un script Bash ou Powershell, une page PHP, un Arduino, ESP ou NetDuino, bref n’importe quel système, objet ou langage pouvant effectuer des appels HTTP peut être considéré comme un package (dit virtuel) de votre Constellation et produire ou consommer des StateObjects, envoyer ou recevoir des messages, écrire des logs, etc…

Généralités

Construction de l’URL

L’URL est :  <Root URI>/rest/constellation/<action>?<paramètres>

Partons du principe que votre Constellation est exposée en HTTP sur le port 8088 (sans path). On retrouvera dans le fichier de configuration la section suivante :

<listenUris>
  <uri listenUri="http://+:8088/" />
</listenUris>

La “Root URI “ est donc “http://<ip ou dns>:8088/”.

Par exemple si nous sommes en local, nous pourrions écrire :

http://localhost:8088/rest/constellation/xxxxx

Authentification

Comme pour toutes les requêtes vers Constellation vous devez impérativement spécifier dans les headers HTTP ou dans les paramètres de l’URL (querystring), les paramètres “SentinelName”, “PackageName” et “AccessKey” pour l’authentification.

Ici votre “package virtuel” doit être déclaré dans la configuration de votre Constellation comme un véritable package, c’est à dire avec une sentinelle (dite virtuelle) et un package qui peut contenir des settings, etc…

Par exemple :

<sentinels>
  <sentinel name="MyVirtualSentinel" credential="Standard">
    <packages>        
      <package name="MyVirtualPackage" enable="true">
        <settings>
          <setting key="IntSetting" value="42" />
          <setting key="StringSetting" value="sample config value" />
        </settings>
      </package>
    </packages>
  </sentinel>
</sentinels>

On a ici déclaré une sentinelle virtuelle “MyVirtualSentinel” qui contient le package virtuelle “MonPackageVirtuel”. Ce package utilise implicitement l’AccessKey du credential “Standard” déclaré au niveau de la sentinelle.

De ce fait, pour chaque appel on passera les paramètres suivants (dans l’URL ou dans les headers) :

• SentinelName = MyVirtualSentinel
• PackageName = MyVirtualPackage
• AccessKey = MyAccessKey (en partant du principe que l’AccessKey déclaré pour le credential “Standard” est “MyAccessKey”)

Pour la suite de cet article nous passerons tous les paramètres dans l’URL, ainsi chaque appel sera sous la forme :

http://localhost:8088/rest/constellation/<action>?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey&<paramètres>

Check Access

Toutes les API REST de Constellation exposent une méthode en GET “CheckAccess” qui retourne un code HTTP 200 (OK). Cela permet de tester la connexion et l’authentification au serveur Constellation.

• Action : “CheckAccess” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/constellation/CheckAccess?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey

Publier des StateObjects

• Action : “PushStateObject” (GET ou POST)
• En GET, voici les paramètres de l’URL :
  • name : le nom du StateObject
  • value : la valeur du StateObject
  • type (optionnel) : le type du StateObject
  • lifetime (optionnel – par défaut 0) : la durée de vie (en seconde) du StateObject avant d’être marqué “expiré”. (0 = durée de vie infinie)

Pour publier un StateObject vous devez obligatoirement spécifier son nom (name) et sa valeur (value). La valeur peut être un type simple (un Int, String, bool, etc..) ou un objet complexe formaté en JSON. Optionnellement vous pouvez spécifier le type et la durée de vie de votre SO (en seconde).

Par exemple publions un StateObject nommé “Temperature” dont la valeur est le nombre “21” :

http://localhost:8088/rest/constellation/PushStateObject?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey&name=Temperature&value=21

Autre exemple avec un objet complexe contenant deux propriété (Temperature et Humidity) dont la durée de vie est de 60 secondes et le type nommé “TemperatureHumidity” :

http://localhost:8088/rest/constellation/PushStateObject?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey&name=Temperature&value={ Temperature: 21, Humidity: 72 }&type=TemperatureHumidity&lifetime=60

Si la valeur du StateObject est trop grande pour être passée dans l’URL ou si vous souhaitez ajouter des métadonnées (metadatas) à votre StateObject vous pouvez “poster” le StateObject dans le corps de la requête HTTP en utilisant le verbe “POST” (sans oublier de définir le Content-Type à “application/json”).

Pour publier par un POST le même StateObject en lui ajoutant deux métadonnées :

POST http://localhost:8088/rest/constellation/PushStateObject?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey
Host: localhost:8088
Content-Length: 189
Content-Type: application/json

{
  "Name" : "Temperature",
  "Value" : { Temperature: 21, Humidity: 72 },
  "Type" : "TemperatureHumidity",
  "Lifetime" : 60,
  "Metadatas": { "ChipId":"ABC123", "Room":"Garden" }
}

Purger ses StateObjects

Un package peut supprimer ses StateObjects qu’il produit avec la méthode “PurgeStateObjects”.

• Action : “PurgeStateObjects” (GET)
• Paramètres:
  • name (optionnel – par défaut “*”) : le nom du StateObject
  • type (optionnel – par défaut “*”) : le type du StateObject

Vous pouvez spécifier le nom du StateObject à supprimer et/ou son type. Par défaut ces deux paramètres sont définis à “*”. C’est à dire que si vous ne précisez rien, tous les StateObjects du package seront purgés.

Par exemple pour purger tous les StateObjects de notre package virtuel (instance MyVirtualSentinel/MyVirtualPackage):

http://localhost:8088/rest/constellation/PurgeStateObjects?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey

Pour purger tous les StateObjects de type “Temperature” de cette même instance :

http://localhost:8088/rest/constellation/PurgeStateObjects?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey&type=Temperature

Ou pour supprimer le StateObject nommé “Demo” :

http://localhost:8088/rest/constellation/PurgeStateObjects?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey&name=Demo

Ecrire des logs

Les packages peuvent écrire des logs qui seront remontés dans le hub Constellation.

• Action : “WriteLog” (GET)
• Paramètres:
  • message : texte du log
  • level (optionnel – par défaut “Info”) : le niveau du log (Info, Warn ou Error)

Exemple d’un message “Info” :

http://localhost:8088/rest/constellation/WriteLog?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey&message=Hello World

Exemple pour produire un message d’erreur (Error) :

http://localhost:8088/rest/constellation/WriteLog?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey&message=Il y  a une erreur ici&level=Error

Récupérer ses settings

Les settings sont récupérés en invoquant la méthode “GetSettings”.

• Action : “GetSettings” (GET)
• Paramètres:  aucun

Par exemple pour récupérer les settings (dictionnaire de clé / valeur) définis pour notre package virtuel :

http://localhost:8088/rest/constellation/GetSettings?SentinelName=MyVirtualSentinel&PackageName=MyVirtualPackage&AccessKey=MyAccessKey

Envoyer des messages

• Action : “SendMessage” (GET ou POST)
• En GET, voici les paramètres de l’URL :
  • scope : le type de scope (All, Other, Group, Sentinel ou Package)
  • args : les arguments du scope (par exemple le nom du groupe, de la sentinelle, du package ou de l’instance du package – plusieurs valeurs possibles séparées par des virgules)
  • key : la clé du message (= la méthode à invoquer)
  • data : le contenu du message (= les arguments de la méthode)
  • sagaId (optionnel) : l’identification de la saga si le message est envoyé dans une saga

Vous pouvez également invoquer cette action en POST. Le corps de votre requête contiendra l’objet JSON suivant :

{
  "Scope" : { "Type" : "<type>", Args: [ "<arg1>", "<args2>", .... ], "SagaId":"Identifiant de la Saga" },
  "Key" : "<Key>",
  "Data" : "<Data>"
}

La propriété “SagaId” dans le JSON ci-dessus est optionnelle.

Par exemple pour envoyer un message au package Nest en invoquant la méthode (key) “SetTargetTemperature” avec en paramètre le nombre “21” :

http://localhost:8088/rest/constellation/SendMessage?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&scope=Package&args=Nest&key=SetTargetTemperature&data=21

Ce même MessageCallback “SetTargetTemperature” du package Nest peut être invoqué dans une saga afin de recevoir un accusé de réception :

http://localhost:8088/rest/constellation/SendMessage?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&scope=Package&args=Nest&key=SetTargetTemperature&data=21&sagaId=123456789

Il faudra ensuite “récupérer” les messages reçus (voir dessous) pour lire la réponse à votre saga que nous avons ici identifié par la clé “123456789”.

Recevoir des messages

Créer un abonnement de réception

Tout d’abord pour recevoir des messages il faut s’abonner aux messages.

• Action : “SubscribeToMessage” (GET)
• Paramètres :
  • subscriptionId (optionnel) : identifiant de l’abonnement si déjà connu

http://localhost:8088/rest/constellation/SubscribeToMessage?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123

Vous obtiendrez en réponse l’ID de votre abonnement, le “Subscription Id”.

Relever les messages

• Action : “GetMessages” (GET)
• Paramètres :
  • subscriptionId : identifiant de l’abonnement
  • timeout (optionnel – par défaut 60000) : temps maximal en milliseconde de la mise en attente de la requête (entre 1000ms et 120000ms)
  • limit (optionnel – par défaut 0) : nombre maximum de message à retourner pour l’appel

Il s’agit d’une requête en “long-polling” c’est à dire que la requête sera “bloquée” sur le serveur tant qu’il n’y a pas de message reçu évitant ainsi de “flooder” en continue le serveur pour savoir si de nouveaux messages sont disponibles ou non. Par défaut la requête est bloquée 60 secondes maximum mais vous pouvez personnaliser cette valeur avec le paramètre “timeout”. Si il y a des messages disponibles, le serveur vous renvoi un tableau JSON avec les messages reçus. Si il n’y a pas de réponse dans le délai spécifié par le paramètre “timeout” (60 secondes par défaut), le tableau retourné sera vide.

A chaque réponse vous devez donc relancer une requête “GetMessages” pour “écouter” les prochains messages qui vont sont destinés.

Il est également possible de limiter le nombre de message dans la réponse avec le paramètre “limit” ce qui peut être utile sur de petits “devices” ne disposant pas de beaucoup de mémoire RAM pour désérialiser de gros tableaux JSON.

Exemple simple :

http://localhost:8088/rest/constellation/GetMessages?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&subscriptionId=xxxxx

Autre exemple en limitant le nombre de message à 2 par appel et en bloquant la requête pendant 10 secondes au maximum :

http://localhost:8088/rest/constellation/GetMessages?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&subscriptionId=xxxxx&timeout=10000&limit=2

S’abonner à un groupe

Vous pouvez vous abonner à des groupes pour recevoir les messages envoyés dans ces groupes par l’action “SubscribeToMessageGroup” en précisant le nom du groupe et votre ID d’abonnement.

• Action : “SubscribeToMessageGroup” (GET)
• Paramètres :
  • group : le nom du groupe à joindre
  • subscriptionId (optionnel) : identifiant de l’abonnement si déjà connu

http://localhost:8088/rest/constellation/SubscribeToMessageGroup?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&subscriptionId=xxxxx&group=A

Comme l’action “SubscribeToMessage”, cette action vous retourne l’ID d’abonnement à utiliser pour l’action “GetMessages”.

Consommation de StateObjects

Request

Cette méthode permet de récupérer la valeur actuelle d’un ou de plusieurs StateObjects.

• Action : “RequestStateObjects” (GET)
• Paramètres :
  • sentinel (optionnel – par défaut “*”): nom de la sentinelle
  • package (optionnel – par défaut “*”) : nom du package
  • name (optionnel – par défaut “*”) : nom du StateObject
  • type (optionnel – par défaut “*”) : type du StateObject

Par exemple pour récupérer tous les StateObject de votre Constellation :

http://localhost:8088/rest/constellation/RequestStateObjects?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123

Ou seulement ceux produits par le package “HWMonitor” (quelque soit la sentinelle) :

http://localhost:8088/rest/constellation/RequestStateObjects?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&package=HWMonitor

Ou encore tous les StateObjects nommés “/intelcpu/load/0” et produits le package “HWMonitor” (quelque soit la sentinelle) :

http://localhost:8088/rest/constellation/RequestStateObjects?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&package=HWMonitor&name=/intelcpu/load/0

Subscribe

Vous pouvez également vous abonner aux mises à jour des StateObjects.

Le principe est le même qu’avec les messages : il faut récupérer un ID d’abonnement et invoquer une méthode en long-polling pour recevoir les mises à jour.

S’abonner à des StateObjects

• Action : “SubscribeToStateObjects” (GET)
• Paramètres :
  • subscriptionId (optionnel) : identifiant de l’abonnement si déjà connu
  • sentinel (optionnel – par défaut “*”): nom de la sentinelle
  • package (optionnel – par défaut “*”) : nom du package
  • name (optionnel – par défaut “*”) : nom du StateObject
  • type (optionnel – par défaut “*”) : type du StateObject

En retour vous obtiendrez l’ID d’abonnement (un GUID).

Par exemple pour s’abonner au SO “/intelcpu/load/0”, produit le package “HWMonitor” sur la sentinelle “MON-PC” :

http://localhost:8088/rest/constellation/SubscribeToStateObjects?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&sentinel=MON-PC&package=HWMonitor&name=/intelcpu/load/0

ATTENTION : si vous souhaitez “ajouter” des SO à votre abonnement vous devez impérativement préciser votre ID d’abonnement récupéré lors du 1er appel autrement vous allez créer un nouvel abonnement.

Par exemple pour “ajouter” le SO correspondant à la consommation RAM :

http://localhost:8088/rest/constellation/SubscribeToStateObjects?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&sentinel=MON-PC&package=HWMonitor&name=/ram/load&subscriptionId=<subId>

Relever les StateObjects mis à jour

Pour récupérer les SO de votre abonnement qui ont changés entre deux appels vous devez invoquer l’action “GetStateObjects” en spécifiant l’ID de votre abonnement :

• Action : “GetStateObjects” (GET)
• Paramètres :
  • subscriptionId : identifiant de l’abonnement
  • timeout (optionnel – par défaut 60000) : temps maximal en milliseconde de la mise en attente de la requête (entre 1000ms et 120000ms)
  • limit (optionnel – par défaut 0) : nombre maximum de message à retourner pour l’appel

Comme pour les messages, vous pouvez limiter le nombre de SO (limit) et le timeout de la requête (timeout).

http://localhost:8088/rest/constellation/GetStateObjects?SentinelName=Consumer&PackageName=Demo&AccessKey=MaCleDeTest123&subscriptionId=<subId>

Notez que si un StateObject pour lequel vous êtes abonné change plusieurs fois entre deux appels “GetStateObjects”, vous obtiendrez la dernière valeur et non l’historique de tous les changements.

Déclarer le “Package Descriptor”

Action : “DeclarePackageDescriptor” (POST)

Le “Package Descriptor” permet décrire les MessagesCallbacks d’un package ainsi que les types utilisés par ses MC ou StateObjects.

Ainsi en publiant le PackageDescriptor, la Constellation aura connaissance des MessageCallbacks qu’expose un package ainsi que le type des StateObject qu’il publie. C’est grâce au Package Descriiptor que fonctionne le “MessageCallback Explorer” de la Console Constellation.

Le Package Descriptor est un objet JSON contenant :

• Le nom du package
• La liste des MessageCallbacks du package
• La liste des types utilisés par les MessageCallbacks du package
• La liste des types utilisés par les StateObjects publiés par le package

La structure de base est donc :

{
  "PackageName": "MyVirtualPackage",
  "MessageCallbacks": [],
  "MessageCallbackTypes": [],
  "StateObjectTypes": [],
}

Chaque “MessageCallback” est un objet contenant :

• MessageKey : la clé du message (le nom/clé du MessageCallback)
• Description (optionnel) : description du MessageCallback
• ResponseType (optionnel) : le type du message de retour dans le cas où le MC répond au Saga
• Parameters (optionnel) : la liste des paramètres du MC

Un paramètre est décrit par un objet contenant :

• Name : le nom du paramètre
• TypeName : le type du paramètre
• Description (optionnel) : la description du paramètre
• Type : le type de paramètre (doit être obligatoirement défini à 2 pour un paramètre d’un MC)
• IsOptional (optionnel) : booléen (true ou false) qui indique si le paramètre est optionnel ou non
• DefaultValue (optionnel) : la valeur par défaut du paramètre si optionnel

Le type d’un paramètre peut être un type simple décrit par les types .NET (System.Int16, System.Int32, System.Int64, System.Double, System.Decimal, System.Float, System.Boolean, System.String) ou un type personnalisé.

Les types personnalisés utilisés dans les paramètres des MC seront décrits dans la propriété “MessageCallbackTypes” du Package Descriptor et les types personnalisés utilisés pour les StateObjects seront décrits dans la propriété “StateObjectTypes” du Package Descriptor.

Dans les deux cas il s’agit de la même structure de donnée.

La description d’un type est un objet contenant :

• TypeName : le nom du type (l’identifiant)
• TypeFullname : le nom complet du type (utilisé pour identifier le nom complet d’un type .NET par exemple)
• Description (optionnel) : la description du type
• IsGeneric (optionnel) : booléen (true ou false) qui indique si le type est un type générique
• IsArray (optionnel) : booléen (true ou false) qui indique si le type est un tableau
• GenericParameters (optionnel) : la liste des types génériques si il s’agit d’un type générique ou d’un tableau
• IsEnum (optionnel) : booléen (true ou false) qui indique si le type est une énumération
• EnumValues (optionnel) : la liste des valeurs de l’énumérations si le type est une énumération
• Properties (optionnel) : la liste des propriétés du type

Les propriétés d’un type tout comme les valeurs d’une énumération sont décrits de la même manière qu’un paramètre d’un MessageCallback déjà détaillé ci-dessus.

Seule la propriété “Type” change :

• Type = 0 : pour décrire une propriété
• Type = 1 : pour décrire une valeur d’une énumération
• Type = 2 : pour décrire une paramètre d’un MessageCallback comme expliqué précédemment

Exemple 1 – Package “NetworkTools”

Voici le Package Descriptor du package “NetworkTools” :

{
   "PackageName":"NetworkTools",
   "MessageCallbacks":[  
      {  
         "MessageKey":"Ping",
         "Description":"Pings the specified host and return the response time.",
         "ResponseType":"System.Int64",
         "Parameters":[  
            {  
               "Name":"host",
               "TypeName":"System.String",
               "Description":"The host.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"timeout",
               "TypeName":"System.Int32",
               "Description":"The timeout (5000ms by defaut).",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"CheckPort",
         "Description":"Check a port's status by entering an address and port number above and return the response time.",
         "ResponseType":"System.Int64",
         "Parameters":[  
            {  
               "Name":"host",
               "TypeName":"System.String",
               "Description":"The host.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"port",
               "TypeName":"System.Int32",
               "Description":"The port.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"timeout",
               "TypeName":"System.Int32",
               "Description":"The timeout (5000ms by defaut).",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"CheckHttp",
         "Description":"Checks the HTTP address and return the response time.",
         "ResponseType":"System.Int64",
         "Parameters":[  
            {  
               "Name":"address",
               "TypeName":"System.String",
               "Description":"The address.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"ScanPort",
         "Description":"Scans TCP port range to discover which TCP ports are open on your target host.",
         "ResponseType":"System.Collections.Generic.Dictionary`2[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]",
         "Parameters":[  
            {  
               "Name":"host",
               "TypeName":"System.String",
               "Description":"The host.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"startPort",
               "TypeName":"System.Int32",
               "Description":"The start port.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"endPort",
               "TypeName":"System.Int32",
               "Description":"The end port.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"timeout",
               "TypeName":"System.Int32",
               "Description":"The timeout (5000ms by defaut).",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"WakeUp",
         "Description":"Wakes up the specified host.",
         "ResponseType":"System.Boolean",
         "Parameters":[  
            {  
               "Name":"host",
               "TypeName":"System.String",
               "Description":"The host.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"macAddress",
               "TypeName":"System.String",
               "Description":"The mac address.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"DnsLookup",
         "Description":"Resolves a host name or IP address.",
         "ResponseType":"System.String[]",
         "Parameters":[  
            {  
               "Name":"host",
               "TypeName":"System.String",
               "Description":"The host.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      }
   ],
   "MessageCallbackTypes":[  
      {  
         "Description":null,
         "IsGeneric":true,
         "IsArray":false,
         "GenericParameters":[  
            "System.Int32",
            "System.Boolean"
         ],
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"Dictionary`2",
         "TypeFullname":"System.Collections.Generic.Dictionary`2[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.Boolean, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]",
         "Properties":null
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":true,
         "GenericParameters":[  
            "System.String"
         ],
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"String[]",
         "TypeFullname":"System.String[]",
         "Properties":null
      }
   ],
   "StateObjectTypes":[  
      {  
         "Description":"Monitoring type",
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"MonitoringResult",
         "TypeFullname":"NetworkTools.MonitoringResult",
         "Properties":[  
            {  
               "Name":"ResponseTime",
               "TypeName":"System.Int64",
               "Description":"Gets or sets the response time in millisecond.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"State",
               "TypeName":"System.Boolean",
               "Description":"Gets or sets the state.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      }
   ]
}

Exemple 2 – Package “Paradox”

Autre exemple plus complet, le Package Descriptor du package “Paradox” :

{  
   "PackageName":"Paradox",
   "MessageCallbacks":[  
      {  
         "MessageKey":"AreaArm",
         "Description":"Arm the area.",
         "ResponseType":"System.Boolean",
         "Parameters":[  
            {  
               "Name":"request",
               "TypeName":"ParadoxOnConstellation.ArmingRequestData",
               "Description":"The request.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"AreaDisarm",
         "Description":"Disarm the area.",
         "ResponseType":"System.Boolean",
         "Parameters":[  
            {  
               "Name":"request",
               "TypeName":"ParadoxOnConstellation.ArmingRequestData",
               "Description":"The request.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"RefreshArea",
         "Description":"Refreshes the area.",
         "ResponseType":null,
         "Parameters":[  
            {  
               "Name":"area",
               "TypeName":"Paradox.Core.Area",
               "Description":"The area.",
               "Type":2,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "MessageKey":"RefreshAll",
         "Description":"Refreshes all.",
         "ResponseType":null,
         "Parameters":[  

         ]
      }
   ],
   "MessageCallbackTypes":[  
      {  
         "Description":"Arming or disarming request",
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"ArmingRequestData",
         "TypeFullname":"ParadoxOnConstellation.ArmingRequestData",
         "Properties":[  
            {  
               "Name":"Area",
               "TypeName":"Paradox.Core.Area",
               "Description":"The number of area.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Mode",
               "TypeName":"Paradox.Core.ArmingMode",
               "Description":"The mode number.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"PinCode",
               "TypeName":"System.String",
               "Description":"The pin code.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":true,
         "EnumValues":[  
            {  
               "Name":"All",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area1",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area2",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area3",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area4",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area5",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area6",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area7",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Area8",
               "TypeName":"Paradox.Core.Area",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            }
         ],
         "TypeName":"Area",
         "TypeFullname":"Paradox.Core.Area",
         "Properties":null
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":true,
         "EnumValues":[  
            {  
               "Name":"RegularArm",
               "TypeName":"Paradox.Core.ArmingMode",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"ForceArm",
               "TypeName":"Paradox.Core.ArmingMode",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"StayArm",
               "TypeName":"Paradox.Core.ArmingMode",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"InstantArm",
               "TypeName":"Paradox.Core.ArmingMode",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            }
         ],
         "TypeName":"ArmingMode",
         "TypeFullname":"Paradox.Core.ArmingMode",
         "Properties":null
      }
   ],
   "StateObjectTypes":[  
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"UserInfo",
         "TypeFullname":"ParadoxOnConstellation.UserInfo",
         "Properties":[  
            {  
               "Name":"Id",
               "TypeName":"System.Int32",
               "Description":"The identifier.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Type",
               "TypeName":"System.String",
               "Description":"The object type.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Name",
               "TypeName":"System.String",
               "Description":"The name.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"LastActivity",
               "TypeName":"System.DateTime",
               "Description":"The last activity.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"DateTime",
         "TypeFullname":"System.DateTime",
         "Properties":[  
            {  
               "Name":"Date",
               "TypeName":"System.DateTime",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Day",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"DayOfWeek",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"DayOfYear",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Hour",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Kind",
               "TypeName":"System.DateTimeKind",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Millisecond",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Minute",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Month",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Now",
               "TypeName":"System.DateTime",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"UtcNow",
               "TypeName":"System.DateTime",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Second",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Ticks",
               "TypeName":"System.Int64",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"TimeOfDay",
               "TypeName":"System.TimeSpan",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Today",
               "TypeName":"System.DateTime",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Year",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":true,
         "EnumValues":[  
            {  
               "Name":"Sunday",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Monday",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Tuesday",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Wednesday",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Thursday",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Friday",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Saturday",
               "TypeName":"System.DayOfWeek",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            }
         ],
         "TypeName":"DayOfWeek",
         "TypeFullname":"System.DayOfWeek",
         "Properties":null
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":true,
         "EnumValues":[  
            {  
               "Name":"Unspecified",
               "TypeName":"System.DateTimeKind",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Utc",
               "TypeName":"System.DateTimeKind",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Local",
               "TypeName":"System.DateTimeKind",
               "Description":null,
               "Type":0,
               "IsOptional":false,
               "DefaultValue":null
            }
         ],
         "TypeName":"DateTimeKind",
         "TypeFullname":"System.DateTimeKind",
         "Properties":null
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"TimeSpan",
         "TypeFullname":"System.TimeSpan",
         "Properties":[  
            {  
               "Name":"Ticks",
               "TypeName":"System.Int64",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Days",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Hours",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Milliseconds",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Minutes",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Seconds",
               "TypeName":"System.Int32",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"TotalDays",
               "TypeName":"System.Double",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"TotalHours",
               "TypeName":"System.Double",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"TotalMilliseconds",
               "TypeName":"System.Double",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"TotalMinutes",
               "TypeName":"System.Double",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"TotalSeconds",
               "TypeName":"System.Double",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "Description":"Represent Zone information",
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"ZoneInfo",
         "TypeFullname":"ParadoxOnConstellation.ZoneInfo",
         "Properties":[  
            {  
               "Name":"IsOpen",
               "TypeName":"System.Boolean",
               "Description":"A value indicating whether this zone is open.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"IsTamper",
               "TypeName":"System.Boolean",
               "Description":"A value indicating whether this zone is tamper.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"InAlarm",
               "TypeName":"System.Boolean",
               "Description":"A value indicating whether this zone is in alarm.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"InFireAlarm",
               "TypeName":"System.Boolean",
               "Description":"A value indicating whether this zone is in fire alarm].",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"SupervisionLost",
               "TypeName":"System.Boolean",
               "Description":"A value indicating whether this zone has supervision lost.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"LowBattery",
               "TypeName":"System.Boolean",
               "Description":"A value indicating whether this zone has low battery.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Id",
               "TypeName":"System.Int32",
               "Description":"The identifier.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Type",
               "TypeName":"System.String",
               "Description":"The object type.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Name",
               "TypeName":"System.String",
               "Description":"The name.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"LastActivity",
               "TypeName":"System.DateTime",
               "Description":"The last activity.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      },
      {  
         "Description":null,
         "IsGeneric":false,
         "IsArray":false,
         "GenericParameters":null,
         "IsEnum":false,
         "EnumValues":null,
         "TypeName":"AreaInfo",
         "TypeFullname":"ParadoxOnConstellation.AreaInfo",
         "Properties":[  
            {  
               "Name":"IsFullArmed",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"IsStayArmed",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"ZoneInMemory",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"HasTrouble",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"IsReady",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"IsInProgramming",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"InAlarm",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Strobe",
               "TypeName":"System.Boolean",
               "Description":null,
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Id",
               "TypeName":"System.Int32",
               "Description":"The identifier.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Type",
               "TypeName":"System.String",
               "Description":"The object type.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"Name",
               "TypeName":"System.String",
               "Description":"The name.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            },
            {  
               "Name":"LastActivity",
               "TypeName":"System.DateTime",
               "Description":"The last activity.",
               "Type":1,
               "IsOptional":false,
               "DefaultValue":null
            }
         ]
      }
   ]
}

The post L’interface REST « Constellation » appeared first on Constellation.

• Gestion des sentinelles
• Gestion des packages
• Gestion des groupes
• Gestion des settings
• Gestion des RecoveryOptions
• Gestion des credentials et autorisations
• Gestion du Package Repository et upload de package
• Gestion de la licence
• Lire / Ecriture du fichier de configuration
• Récupération du numéro de version du serveur
• Rechargement et déploiement de la configuration

Généralités

Construction de l’URL

L’URL est :  <Root URI>/rest/management/<action>?<paramètres>

Partons du principe que votre Constellation est exposée en HTTP sur le port 8088 (sans path). On retrouvera dans le fichier de configuration la section suivante :

<listenUris>
  <uri listenUri="http://+:8088/" />
</listenUris>

La “Root URI “ est donc “http://<ip ou dns>:8088/”.

Par exemple si nous sommes en local, nous pourrions écrire :

http://localhost:8088/rest/management/xxxxx

Authentification

Comme pour toutes les requêtes vers Constellation vous devez impérativement spécifier dans les headers HTTP ou dans les paramètres de l’URL (querystring), les paramètres “SentinelName”, “PackageName” et “AccessKey” pour l’authentification.

Dans le cas de l’API “Management”, la “SentinelName” est “Management” et le “PackageName” est le nom de votre choix que l’on considère comme un “FriendlyName”. Typiquement le “FriendlyName” est par exemple le nom de l’application/page qui se connecte.

L’AccessKey doit bien sûr être déclaré et activé sur le serveur. De plus elle doit avoir le droit  d’utiliser l’API de Management, soit depuis la Console Constellation ou soit directement dans le fichier de configuration en ajoutant l’attribut “enableManagementAPI”.

Ainsi chaque appel aura le format suivant :

http://localhost:8088/rest/management/<action>?SentinelName=Management&PackageName=<Friendly name>&AccessKey=<access key>&<paramètres>

Check Access

Toutes les API REST de Constellation exposent une méthode en GET “CheckAccess” qui retourne un code HTTP 200 (OK). Cela permet de tester la connexion et l’authentification au serveur Constellation.

• Action : “CheckAccess” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/CheckAccess?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Récupérer la version du serveur

Pour connaitre la version du serveur Constellation, vous pouvez invoquer l’action “/server/version”.

• Action : “/server/version” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/server/version?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Edition du fichier de configuration

Lire le fichier de configuration

Vous pouvez récupérer le contenu entier du fichier de configuration de votre Constellation en invoquant l’action ”/configuration”

• Action : “/configuration” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/configuration?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Ecrire le fichier de configuration

Vous pouvez également réécrire le fichier de configuration en postant le nouveau contenu sur la même URL.

• Action : “/configuration” (POST)
• Paramètres : aucun
• Corps de la requête : le fichier de configuration XML

Le serveur vérifiera le bon format du fichier XML avant d’écraser le fichier de configuration existant par votre nouvelle version. Vous devrez ensuite recharger la configuration pour appliquer les modifications.

Recharger et déployer la configuration

Pour recharger le fichier de configuration vous devez invoquer l’action “/configuration/reload” :

• Action : “/configuration/reload ” (GET)
• Paramètres :
  • deployConfiguration (optionnel – par défaut “false”) : indique si l’ordre de mise à jour doit être envoyé aux sentinelles et packages de la Constellation

Exemple :

http://localhost:8088/rest/management/configuration/reload?deployConfiguration=true&SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

La License Constellation

Vous pouvez récupérer les caractéristiques de la licence affectée à votre serveur en invoquant l’action  “/license”.

• Action : “/license” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/license?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Vous pouvez également charger une nouvelle licence en utilisant le verbe “POST” sur cette action et en plaçant le contenu de la nouvelle licence dans le corps de la requête.

Gestion du Package Repository

Lister le Package Repository

Pour récupérer la liste des packages de le Package Repository :

• Action : “/packages” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/packages?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Récupérer un package

Pour récupérer un package en particulier de votre Package Repository :

• Action : “/packages/{packageName}” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/packages/{packageName}?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Renommer un package

Pour renommer un package de votre Package Repository vous devez poster un objet JSON contenant son nouveau nom :

• Action : “/packages/{packageName}” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : { « newName »: newName }

Supprimer un package

Pour supprimer package de votre Package Repository :

• Action : “/packages/{packageName}” (DELETE)
• Paramètres : aucun

Récupérer l’icone d’un package

Pour récupérer l’icone d’un package de votre Package Repository :

• Action : “/packages/{packageName}/icon” (GET)
• Paramètres : aucun

Vous obtiendrez l’icone au format “PNG”.

Exemple :

http://localhost:8088/rest/management/packages/{packageName}/icon?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Récupérer le schéma XSD d’un paramètre de configuration d’un package

Chaque package peut avoir des settings. Ces settings peuvent être de plusieurs types (types simples, objet JSON ou XML). Chaque package doit (ou devrait) déclarer la liste des settings qu’il utilise dans son “Package Manifest”.

Si le setting est de type XML (“ConfigurationSection” ou “XmlDocument”) il peut être lié à un schéma XSD pour décrire le format XML du setting en question.

L’action ci-dessous permet de récupérer ce schema XSD pour un setting d’un package de votre Package Repository.

• Action : ”/packages/{package}/settings/{settingName}/xsd ” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/packages/{packageName}}/settings/{settingName}/xsd?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Télécharger un package vers votre Package Repository

Vous pouvez ordonner à votre serveur Constellation de télécharger un fichier vers le Package Repository.

Pour cela vous utiliserez l’action “/download-package” en spécifiant l’URL du fichier à télécharger.

• • Action : ”/download-package” (POST)
  • Paramètres : aucun
  • Corps de la requête (application/json) : { « url »: url}

Téléverser un package vers votre Package Repository

Vous pouvez également envoyer un fichier vers votre Package Repository en utilisant l’action “/upload-package”.

• Action : ”/upload-package” (POST)
• Paramètres : aucun
• Corps de la requête (multipart/form-data) : les fichiers à enregistrer dans votre Package Repository.

Les RecoveryOptions

Les Recovery Options spécifient les options de récupération en cas de crash d’un package sur vos sentinelles.

Chaque package peut avoir ses propres options mais par défaut il hérite des options “globales”.

Pour récupérer ces options “globales” :

• Action : ”/configuration/recoveryoptions” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/configuration/recoveryoptions?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Vous pouvez également redéfinir ces options en postant sur cette même URI votre nouvel objet JSON :

• Action : ”/configuration/recoveryoptions” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : l’objet “RecoveryOptions” avec les nouvelles valeurs

Gestion des sentinelles

Lister les sentinelles

Pour récupérer la liste des sentinelles de votre Constellation :

• Action : “/sentinels” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/sentinels?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Ajouter ou modifier une sentinelle

Pour ajouter ou modifier une sentinelle de votre Constellation :

• Action : “/sentinels” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : un objet JSON contenant deux propriétés :
  • “Name”  : le nom de la sentinelle
  • “Credential” : le nom du credential associé à cette sentinelle

Supprimer une sentinelle

Pour supprimer une sentinelle de votre Constellation :

• Action : “/sentinels/{sentinelName}” (DELETE)
• Paramètres : aucun

Gestion des packages et des settings

Lister les packages d’une sentinelles

Pour récupérer la liste des packages (virtuels ou non) d’une sentinelle (virtuelle ou non) de votre Constellation :

• Action : “/sentinels/{sentinelName}/packages” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/sentinels/{sentinelName}/packages?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Récupérer une instance d’un package

Pour récupérer le détail d’une instance de package sur une sentinelle donnée :

• Action : “/sentinels/{sentinelName}/packages/{packageName}” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/sentinels/{sentinelName}/packages/{packageName}?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Ajouter ou modifier une instance d’un package

Pour ajouter ou modifier un package sur une sentinelle de votre Constellation :

• Action : “/sentinels/{sentinel}/packages” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : un objet JSON contenant cinq propriétés :
  • “Name”: le nom de l’instance du package (obligatoire et unique)
  • “PackageFile” (facultatif) : le nom du fichier du package à utiliser dans le repository (plus d’info)
  • “Enable” (facultatif, par defaut true) : indique si le package est activé ou désactivé
  • “Credential” (facultatif, utilise par défaut du credential de sa sentinelle) : spécifie le credential que le package va utiliser pour s’authentifier sur le serveur Constellation
  • “AutoStart” (facultatif, par defaut true) : indique si le package doit automatiquement démarrer lorsque sa sentinelle démarre

Supprimer une instance d’un package

Pour supprimer un package sur une sentinelle de votre Constellation :

• Action : “/sentinels/{sentinel}/packages/{packageName}” (DELETE)
• Paramètres : aucun

Options de récupération d’une instance d’un package

Pour récupérer les options de récupération d’une instance d’un package :

• Action : “/sentinels/{sentinelName}/packages/{packageName}/recoveryoptions” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/sentinels/{sentinelName}/packages/{packageName}/recoveryoptions?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Pour les redéfinir vous devez poster la nouvelle valeur de votre objet “RecoveryOptions” sur cette même URI.

• Action : “/sentinels/{sentinelName}/packages/{packageName}/recoveryoptions” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : l’objet “RecoveryOptions” avec les nouvelles valeurs

Groupes d’une instance d’un package

Pour récupérer les groupes d’une instance d’un package :

• Action : “/sentinels/{sentinelName}/packages/{packageName}/groups” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/sentinels/{sentinelName}/packages/{packageName}/groups?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Utilisez cette même URI pour poster la nouvelle liste des groupes de votre instance :

• Action : “/sentinels/{sentinelName}/packages/{packageName}/groups” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : la liste des groupes de votre instance

Settings d’une instance d’un package

Pour récupérer les settings d’une instance d’un package :

• Action : “/sentinels/{sentinelName}/packages/{packageName}/settings” (GET)
• Paramètres : aucun

Exemple :

http://localhost:8088/rest/management/sentinels/{sentinelName}/packages/{packageName}/settings?SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Utilisez cette même URI pour poster le nouveau dictionnaire (clé/valeur) des settings :

• Action : “/sentinels/{sentinelName}/packages/{packageName}/settings” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : le dictionnaire (clé/valeur) des settings de votre instance

Gestion des credentials et autorisations

Lister les credentials

Pour récupérer la liste des credentials de votre Constellation :

• Action : “/credentials” (GET)
• Paramètres :
  • includeAccessKeys (optionnel – par défaut “false”) : indique si vous souhaitez inclure les AccessKeys de chaque credentials

Exemple :

http://localhost:8088/rest/management/credentials?includeAccessKeys=true&SentinelName=Management&PackageName=Demo&AccessKey=MaCleDeTest123

Ajouter ou modifier un credential

Pour ajouter ou modifier un credential de votre Constellation :

• Action : “/credentials” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : un objet JSON contenant six propriétés :
  • “Name” : le nom du credential
  • “AccessKey” : la clé d’accès du credential
  • “Enable” (true par défaut) : indique si le credential est activé ou désactivé
  • “EnableControlHub” (false par défaut) : indique si le credential peut se connecter sur le hub de contrôle (pour l’administration de la Constellation)
  • “EnableManagementAPI” (false par défaut) : indique si le credential peut se connecter à l’API de Management (pour l’édition de la configuration)
  • “EnableDeveloperAccess” (false par défaut) : indique si le credential peut utiliser la sentinelle virtuelle “Developer” pour debugger des packages (utilisé par le SDK Visual Studio)

Supprimer un credential

Pour supprimer un credential de votre Constellation :

• Action : “/credentials/{credentialName}” (DELETE)
• Paramètres : aucun

Récupérer les autorisations d’un credential

• Action : “/credentials/{credentialName}/authorizations” (GET)
• Paramètres : aucun

Vous récupérerez un objet de type “CredentialAuthorizations“ sérialisé en JSON

Définir les autorisations d’un credential

• Action : “/credentials/{credentialName}/authorizations” (POST)
• Paramètres : aucun
• Corps de la requête (application/json) : l’objet CredentialAuthorizations sérialisé en JSON

The post L’interface REST « Management » appeared first on Constellation.