Cette mise à jour de version accompagne désormais le SDK Visual Studio ainsi que les templates du Constellation Package Tools CLI depuis la semaine dernière.

Au programme de cette nouvelle version : la description des arguments des MessageCallbacks et des types de StateObjects.

En effet, comme vous le savez déjà, pour déclarer un MessageCallback en Python il suffit d’ajouter le décorateur Constellation.MessageCallback() :

@Constellation.MessageCallback()
def MultipleParameterCallback(a, b, c):
    '''
    MessageCallback with 3 parameters
    '''
    Constellation.WriteInfo("a = %s - type: %s" % (a, type(a)))
    Constellation.WriteInfo("b = %s - type: %s" % (b, type(b)))
    Constellation.WriteInfo("c = %s - type: %s" % (c, type(c)))

Dans l’exemple ci-dessus, une méthode Python avec 3 paramètres, le simple fait d’ajouter le décorateur Constellation.MessageCallback() permet d’invoquer cette méthode depuis n’importe quel client (package ou consommateur) connecté dans notre Constellation.

D’ailleurs, ce MC est également référencé dans Constellation. Nous pouvons le découvrir sur le ControlHub ou via le MessageCallbacks Explorer de la Console Constellation :

Seulement à l’inverse de l’API .NET, les parametres d’une méthode Python (et les variables de manière globale) ne sont pas fortement typés comme en .NET. Autrement dit, il n’y a rien qui indique le type des arguments de notre MessageCallback. Côté MessageCallbacks Explorer les arguments sont alors reconnus comme « Objects ».

Cette mise à jour 1.8.4 permet la description des arguments en utilisant une syntaxe empruntée à Sphinx dans les commentaires.

Pour cela utilisez la syntaxe suivante dans la description du MC :

:param <type> <name> : <description>

Par exemple pour décrire les 3 arguments de notre exemple :

@Constellation.MessageCallback()
def Demo(a, b, c):
    '''
    Ceci est un exemple de MC avec 3 parametres

    :param int a: My int value
    :param bool b: My boolean value
    :param string c: My string value
    '''
    Constellation.WriteInfo("a = %s - type: %s" % (a, type(a)))
    Constellation.WriteInfo("b = %s - type: %s" % (b, type(b)))
    Constellation.WriteInfo("c = %s - type: %s" % (c, type(c)))

Ainsi en retournant sur le MC Explorer, chaque argument est correctement typé dans Constellation :

Notez que vous pouvez également décrire des types complexes utilisés comme type de paramètre d’entrée, définir les paramètres qui sont optionnels, ou encore décrire les types de retour.

Egalement compris dans cette mise à jour la description des types complexe utilisés comme modèle de données de vos StateObjects.

Pour en profiter il suffit de mettre à jour le package Nuget depuis Visual Studio ou de taper la commande « ctln update » si vous utilisez la CLI.

The post Décrire les MessagesCallbacks en Python avec la mise à jour du PythonProxy 1.8.4 appeared first on Constellation.

https://cdn.myconstellation.io/js/

Veuillez noter que le CDN est accessible en HTTP ou HTTPS et expose toutes les versions des librairies JavaScript et AngularJS pour Constellation au format classique ou minifié.

Ainsi dans vos pages HTML, vous pouvez facilement, sans aucun autre prérequis qu’une connectivité internet, ajouter les librairies Constellation et leurs dépendances :

<script type="text/javascript" src="//code.jquery.com/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="//ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="//cdn.myconstellation.io/js/Constellation-1.8.1.min.js"></script>

Pour AngularJS :

<script type="text/javascript" src="//code.jquery.com/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="//ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="//cdn.myconstellation.io/js/Constellation-1.8.1.min.js"></script>
<script type="text/javascript" src="//ajax.googleapis.com/ajax/libs/angularjs/1.5.7/angular.min.js"></script>
<script type="text/javascript" src="//cdn.myconstellation.io/js/ngConstellation-1.8.1.min.js"></script>

Au passage vous remarquerez la mise à jour des libraires JS en version 1.8.1.

Changelog :

• Revu de la gestion des sagas (sendMessageWithSaga)
• Ajout de la méthode registerMessageCallback
• Ajout de la méthode registerStateObjectLink

Les packages NuGet correspondants ont également été mis à jour sur le repository Constellation accessible depuis votre Visual Studio.

The post Nouvelles versions des librairies JavaScript et mise en place d’un CDN appeared first on Constellation.

Cette nouvelle version amène beaucoup de nouveautés que je vous propose de découvrir dans cet article. La librairie a été testé avec succès sur différentes cartes animées par un ESP8266 (ESP-01, 05, 07 et D1 Mini) ainsi qu’un Arduino/Genuino MKR1000.

Pour la mise à jour, téléchargez la libraire ci-dessous et dézippez les fichiers dans le dossier “Constellation” dans votre répertoire de libraire Arduino.

Attention : cette version 2.x de la librairie Constellation pour Arduino/ESP nécessite la version 1.8.1.16249 ou plus récente du serveur Constellation pour fonctionner correctement. Pour mettre à jour votre plateforme Constellation, lancez le Web Platform Installer.

Réception de message et StateObject “asynchrone”

Il s’agit d’une grosse évolution par rapport à la version 1.x. Pour “récupérer” du serveur Constellation les messages à destination de votre package virtuel ou les StateObjects pour lequel votre package (virtuel) s’est abonné, il faut invoquer les actions “GetMessages” et “GetStateObjects” sur l’interface REST.

Ces méthodes supportent le “long-polling” c’est à dire qu’elles mettent en attente la requête tant qu’il n’y a pas de messages ou StateObjects à retourner avec la notion de timeout (par défaut 60 secondes).

Le problème sur les versions 1.x de la libraire Arduino est que le client HTTP est “synchrone”, c’est à dire qu’il envoi la requête HTTP et attend la réponse du serveur pour traitement ce qui est incompatible avec du long-polling car cela bloquerait le code de l’Arduino. De ce fait, les anciennes versions spécifiées le “timeout” de ces requêtes à 1 seconde.

Ainsi jusqu’à maintenant, l’interrogation des messages et SO pouvaient bloquer jusqu’à 2 secondes votre Arduino (1 seconde pour le GetMessage et 1 seconde pour le GetStateObject) et engendrait donc 1 requêtes HTTP toutes les secondes entre votre ESP/Arduino et le serveur Constellation.

Dans cette nouvelle version, la librairie utilisent 3 clients HTTP différents : un pour toutes les requêtes synchrones, un pour la réception de message (GetMessage) et un pour la réception des StateObjects (GetStateObjects).

Le client synchrone est donc toujours disponible et il n’y a aucun blocage, aucune attente pour la réception de message et de SO. De plus il n’y a plus besoin de “poller” ou “flooder” le serveur d’une requête toute les secondes, en réactivant le long-polling le 2ème et 3ème client HTTP, on lance une requête toutes les minutes (60 sec par défaut) dans l’attente de message et SO.

De ce fait, il y a quelques modifications à apporter dans votre code !

Premièrement, vous ne devez plus passer la référence de votre client réseau mais plutôt spécifier le type de votre client dans le template de la classe Constellation. Par exemple, si vous utilisez un ESP8266 ou un Arduino MKR1000, vous utiliserez la classe “WifiClient “” :

/* Create the Constellation client */
Constellation<WiFiClient> constellation("constellation.monserveur.com", 8088, "MyVirtualSentine", "MyPackage", "MyAccessKey123!");

Ensuite, il n’y a plus besoin d’invoquer la méthode “poll” dans votre boucle principale avec un timer, vous devez tout simplement appeler la méthode “loop” autant de fois que vous voulez :

void loop(void) {
  // Process incoming message & StateObject updates
  constellation.loop();
}

Cette méthode vérifie en fait si il y a eu une réponse sur le client utilisé pour la réception de message et sur le client pour la réception de SO afin de les dispatcher dans votre code.

Support du PackageDescriptor

Autre nouveauté majeure pour cette version 2, le support du “Package Descriptor”.

Pour rappel le “Package Descriptor” est un objet envoyé par un package au serveur pour décrire ses StateObjects et ses MessageCallbacks exposés par le package.

Le MessageCallback Explorer de la Console Constellation s’appuie sur le “Package Descriptor” de chaque package pour lister chaque MessageCallback avec un formulaire de test. Sans cette description cela serait impossible !

Les versions 1.x ne supportaient pas “Package Descriptor”, de ce fait il n’était pas possible d’explorer/découvrir les MessageCallbacks d’un package Arduino/ESP. Vous devez nécessairement connaitre par vous même les MC exposés par le package et le type des StateObjects qu’il pouvait publier.

Avec la version 2.0, l’Arduino/ESP envoie au serveur la description des MC exposés et des types utilisés par les SO et arguments des MC.

Dans la suite de cet article, vous découvrirez comment ajouter des types dans la description de votre package, mais n’oubliez jamais d’envoyer votre “Package Descriptor” en invoquant la méthode “declarePackageDescriptor”, typiquement une fois votre code Arduino initialisé (par exemple à la fin de la méthode setup()) :

// Declare the package descriptor
constellation.declarePackageDescriptor();

Amélioration du PushStateObject

La méthode “PushStateObject” permet de publier un StateObject sur le serveur Constellation.

Tout d’abord la méthode expose des surcharges vous permettant de spécifier comme “value” de votre SO des int, uint, double, float, long et bool et supporte en paramètre optionnel le “lifetime”, c’st à dire la durée en seconde de “vie” de votre StateObject avant d’être considéré comme expiré.

// Dummy data
uint16_t lux = 123;

// Push a simple type on Constellation 
constellation.pushStateObject("DemoLux", lux);  

// Push a simple type on Constellation with lifetime of 20 seconds
constellation.pushStateObject("DemoLux", lux, 20);

Vous pouvez toujours publier des StateObjects dont la valeur (value) est un objet complexe (formaté en JSON).

Le JSON peut être formaté sous forme d’une chaine de caractère avec la méthode “stringFormat” :

// Push a complex object on Constellation with stringFormat
constellation.pushStateObject("DemoLux", stringFormat("{ 'Lux':%d, 'Broadband':%d, 'IR':%d }", lux, full, ir));

Vous pouvez également définir votre propre type pour ce StateObject, par exemple nommons cet objet “MyLuxData” :

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

Sans oublier d’ajouter ce type “personnalisé” dans le “package descriptor”. Par exemple, dans le “setup()” et avant de faire un “declarePackageDescriptor”, on aurait décrit “MyLuxData” de la façon suivante :

constellation.addStateObjectType("MyLuxData", TypeDescriptor().setDescription("MyLuxData demo").addProperty("Broadband", "System.Int32").addProperty("IR", "System.Int32").addProperty("Lux", "System.Int32"));

Pour finir, vous pouvez toujours publier un StateObject en construisant la valeur dans un objet JsonObject de façon suivante :

// Push a complex object on Constellation with JsonObject
const int BUFFER_SIZE = JSON_OBJECT_SIZE(5);
StaticJsonBuffer<BUFFER_SIZE> jsonBuffer;
JsonObject& myStateObject = jsonBuffer.createObject();
myStateObject["Lux"] = lux;
myStateObject["Broadband"] = full;
myStateObject["IR"] = ir;
constellation.pushStateObject("DemoLux", myStateObject);

Dans les surcharges de cette méthode, vous pouvez également spécifier le type de votre StateObject et/ou sa durée de vie :

constellation.pushStateObject("DemoLux", myStateObject, "MyLuxData", 20);

Pour finir, nouveauté de la librairie 2.0, vous pouvez également spécifier des “meta-données” à vos StateObjects. Par exemple :

// Ajout de metadatas au StateObject
JsonObject& metadatas = jsonBuffer.createObject();
metadatas["ChipId"] = ESP.getChipId();
metadatas["Timestamp"] = millis();
constellation.pushStateObject("DemoLux", myStateObject, "MyStateObject", 20, &metadatas);

Les StateObjectLinks

En version 1.x de la librairie Arduino, vous pouvez :

• interroger des StateObjects de la Constellation en invoquant la méthode “requestStateObjects” qui vous retourne les StateObjects à l’instant T correspondant à votre requête :

// Example : print the all SO's value named "/intelcpu/0/load/0" and produced by the "HWMonitor" package (on all sentinels)
JsonArray& cpus = constellation.requestStateObjects("*", "HWMonitor", "/intelcpu/0/load/0");
for(int i=0; i < cpus.size(); i++) { 
  constellation.writeInfo("CPU on %s is currently %d %", cpus[i]["SentinelName"].asString(), cpus[i]["Value"]["Value"].as<float>());
}

• vous abonnez aux mises à jour des StateObjects pour être notifié en temps réel des que les SO changent :

// set a StateObject update callback and subscribe to SO
constellation.setStateObjectUpdateCallback([] (JsonObject& so) {
constellation.writeInfo("StateObject updated ! StateObject name = %s", so["Name"].asString()); 
});
// Subscribe to SO named "/intelcpu/0/load/0" and produced by the "HWMonitor" package (on all sentinels)
constellation.subscribeToStateObjects("*", "HWMonitor", "/intelcpu/0/load/0");

Vous pouvez invoquer plusieurs fois la méthode “subscribeToStateObjects” pour ajouter des abonnements à d’autre StateObjects mais il n’y a qu’un seul callback de réception des SO (défini par la méthode setStateObjectUpdateCallback). C’est à vous de “dispatcher” les SO reçus.

La nouveauté en 2.0 vient de l’ajout de la méthode “registerStateObjectLink” qui vous permet d’associer un callback à un abonnement laissant ainsi à la librairie la charge du “dispatch”.

Par exemple, on peut désormais écrire :

constellation.registerStateObjectLink("*", "HWMonitor", "/intelcpu/0/load/0", [](JsonObject& so) {
  constellation.writeInfo("CPU on %s is currently %d %", so["SentinelName"].asString(), so["Value"]["Value"].as<float>());
});

Ici on enregistre un “StateObject Link” sur tous les SO nommés « /intelcpu/0/load/0 » produits par le package “HWMonitor” de toutes les sentinelles de votre Constellation. Dès qu’un de ces StateObjects changent on exécutera le callback associé, qui ici écrit dans le log un message indiquant la nouvelle valeur du CPU.

Vous bien entendu enregistrer autant de StateObjectLink que vous souhaitez.

Enregistrement des MessageCallbacks

Le principe est le même que celui décrit ci-dessus pour les abonnements aux StateObjects.

En version 1.x, on devait définir un callback pour réception de message et invoquer la méthode “subscribeToMessage” :

// Set callback for all incoming messages
 constellation.setMessageReceiveCallback([](JsonObject& json) { 
   constellation.writeInfo("Message receive ! Message key = %s", json["Key"].asString());     
 }); 
 // Subscribe to message
 constellation.subscribeToMessage();

C’était donc à votre charge de “dispatcher” les messages reçus en fonction du “MessageKey”.

Désormais avec la version 2.0, vous pouvez enregistrer un callback pour un “MessageKey” donné. Par exemple :

constellation.registerMessageCallback("HelloWorld",
  [](JsonObject& json) {
    constellation.writeInfo("Hello Constellation !");
 });

Dans l’exemple ci-dessous, on ajoute/expose un MessageCallback “HelloWorld” qui écrit dans les logs !

Il n’y donc plus besoin de “dispatcher”, un MessageCallback est donc associé à un “MessageKey” unique et un callback. Il n’y a plus besoin non plus de faire un “subscribeToMessage” (cette méthode est invoquée implicitement par le registerMessageCallback).

De plus cette méthode ajoute implicitement les MessageCallbacks dans le Package Descriptor de sorte que chaque MC soit ainsi référencé dans la Constellation

(console)

Vous pouvez également passer un “MessageCallbackDescriptor” dans l’enregistrement de vos MC pour ajouter une description par exemple :

constellation.registerMessageCallback("HelloWorld",
  MessageCallbackDescriptor().setDescription("Say Hello to Constellation"),
  [](JsonObject& json) {
    constellation.writeInfo("Hello Constellation !");
 });

Et même définir les paramètres de vos MC :

constellation.registerMessageCallback("SayHello",
  MessageCallbackDescriptor().setDescription("Say hello !").addParameter("FirstName", "System.String").addParameter("LastName", "System.String"),
  [](JsonObject& json) {
    constellation.writeInfo("Hello %s %s", json["Data"][0].asString(), json["Data"][1].asString()); 
 });

Ici on déclare un MC nommé “SayHello” prenant deux paramètres de type String avec un texte de description. Dans la code nous verrons :

(console)

Tout comme les StateObjects, les types des arguments des MC peuvent être des types complexes.

Par exemple enregistrons un MC prenant un seul argument de type “SampleUserData” que nous allons décrire avec la méthode “addMessageCallbackType” comme un objet composé de deux propriétés de type String :

// Expose a MessageCallback with complex parameter :
constellation.registerMessageCallback("SayHello2",
  MessageCallbackDescriptor().setDescription("Say hello with complex object!").addParameter("User", "SampleUserData"),
  [](JsonObject& json) {
    constellation.writeInfo("Hello %s %s", json["Data"][0]["FirstName"].asString(), json["Data"][0]["LastName"].asString()); 
});  
// and describe the complex parameter "SampleUserData"  
constellation.addMessageCallbackType("SampleUserData", TypeDescriptor().setDescription("This is a smaple user data").addProperty("FirstName", "System.String").addProperty("LastName", "System.String"));

Enfin la méthode “registerMessageCallback” accepte également des callbacks prenant en paramètre le “MessageContext” :

constellation.registerMessageCallback("HelloWorld",
  MessageCallbackDescriptor().setDescription("Say Hello to Constellation"),
  [](JsonObject& json, MessageContext ctx) {
    constellation.writeInfo("Message received from %s", ctx.sender.friendlyName);
 });

L’objet “MessageContext” est défini de la façon suivante :

typedef struct {
    const char* sagaId;
    bool isSaga;
    const char* messageKey;
    MessageSender sender;
    ScopeType scope;
} MessageContext;

typedef struct {
    SenderType type;
    const char* friendlyName;
    const char* connectionId;
} MessageSender;

Vous pouvez donc récupérer les informations sur l’émetteur (Sender) du message, le scope et l’identifiant de Saga si c’est une saga (isSaga = true).

Support des Saga (messages avec réponse)

Une saga est un identifiant unique qu’on affecte à des messages pour les lier entre eux. Cela permet de faire des couples de message “Requête / Réponse”. Une “réponse” étant un message renvoyé à l’émetteur de la requête avec le même identifiant de saga pour que ce dernier puisse l’identifier comme la “réponse” à son message d’origine.

Vous pouvez exposer des MessageCallbacks qui “répondent”, c’est à dire des  MessageCallbacks qui retournent un message de réponse.

Par exemple, exposons un MC pour réaliser des Additions sur un Arduino. Vous enregistrerez un MC “Addition” prenant en parametre deux entiers et qui en retourne un (le résultat) :

constellation.registerMessageCallback("Addition",
  MessageCallbackDescriptor().setDescription("Do addition on this tiny device").addParameter("a", "System.Int32").addParameter("b", "System.Int32").setReturnType("System.Int32"),
  [](JsonObject& json, MessageContext ctx) {        
    int a = json["Data"][0].as<int>();      
    int b = json["Data"][1].as<int>();
    int result = a + b;
    constellation.writeInfo("Addition %d + %d = %d", a, b, result);      
    if(ctx.isSaga) {
      constellation.writeInfo("Doing additoon for %s (sagaId: %s)", ctx.sender.friendlyName, ctx.sagaId);   
    // Return the result :
      constellation.sendResponse<int>(ctx, result);
    }
    else {
      constellation.writeInfo("No saga, no response !");
    }
 });

Vous remarquerez dans le “MessageCallbackDescriptor” l’appel de la méthode “setReturnType” pour spécifier le type de retour (et que le fait qu’il s’agit d’un MC acceptant les sagas).

L’envoi de la réponse étant réalisé par la méthode sendReponse. Cette méthode a plusieurs surcharges :

template<typename T> bool sendResponse(MessageContext context, T data);
bool sendResponse(MessageContext context, const char* data, ...);
bool sendResponse(MessageContext context, JsonObject& data);

Notez aussi que vous devriez faire un “sendResponse” si et seulement le message reçu est associé à une saga, c’est à dire que le champs “isSaga” du contexte (MessageContext) est “vrai”. Sinon ca ne sert à rien de répondre

Pour finir, cette nouvelle version supporte également l’envoi de message dans une saga. C’est à dire que vous pouvez envoyer un message qui attend une réponse et donc enregistrer un callback de traitement de la réponse.

Par exemple le package “NetworkTools” expose un MC “Ping” permettant de faire un ping. Le package retourne dans la saga un message contenant le temps en milliseconde du ping. On pourrait alors invoquer cette méthode depuis notre Arduino de la façon suivante :

const char* ip = "192.168.0.10";
// Send message in a saga and attach a callback for response :
constellation.sendMessageWithSaga([](JsonObject& json) {
  constellation.writeInfo("Ping response in %s ms", json["Data"].asString()); 
}, Package, "NetworkTools", "Ping", "[ '%s' ]", ip);

Ici on envoi un message au scope “Package” pour atteindre le(x) package(s) “NetworkTools” afin d’invoquer le MessageCallback “Ping” en passant en argument l’IP à pinger. Vous remarquerez qu’on utilise le formatage implicite des arguments.

La méthode n’est pas la traditionnelle “sendMessage” mais “sendMessageWithSaga” qui prend un argument supplémentaire : le callback de traitement de la réponse.

Ainsi quand le package “NetworkTools” répondra, on executera le callback associé qui ici affichera le temps de réponse de notre ping (Data) dans les logs Constellation (writeInfo).

De ce fait, avec cette nouvelle libraire vos Arduino/ESP peuvent invoquer des MC dans sagas pour exploiter la réponse mais également exposer des MC qui retournent des résultats.

Autres nouveautés

En vrac, vous disposez maintenant une méthode “purgeStateObjects” permettant de supprimer des StateObjects de votre package.

De plus la méthode “setDebugMode” accepte en argument l’énumération “DebugMode” composée des valeurs suivantes :

• “Quiet” (mode silencieux, la libraire ne produit aucune trace dans l’interface Serial)
• “Normal” (mode par défaut, écrit quelques informations dans l’interface Serial)
• “Verbose” (écrit beaucoup d’information dans l’interface Serial comme par exemple les requêtes et réponse HTTP v ers Constellation)

Enfin les exemples fournis dans la libraire ont été complètement revus.

The post Nouvelle librairie Constellation pour Arduino / ESP8266 en version 2.0 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.

Il héberge des hubs et des interfaces HTTP/REST. De plus il peut également héberger des fichiers statiques en configurant le “fileServer” ce qui permet par exemple l’auto-hébergement de la console Constellation (plus d’info ici).

Les hubs Constellation sont basés sur la technologie SignalR permettant d’exposer des canaux de communication bi-directionnels et temps réel en HTTP long-polling, server-event ou WebSocket en fonction des capacités du client.

Les interfaces HTTP/REST sont en fait des contrôleurs WebAPI exposant des méthodes en HTTP/REST. Les interfaces HTTP/REST permettent d’exposer des fonctionnalités de Constellation de manière très simple pour les devices ou frameworks ne pouvant supporter SignalR.

Il existe 4 hubs :

• Constellation
• Consumer
• Controller
• Sentinel

Ainsi que 3 interfaces HTTP/REST :

• Constellation
• Consumer
• Management

Le hub et l’interface HTTP “Constellation” sont utilisés par les packages Constellation (réels ou virtuels). Ils exposent des méthodes pour écrire des logs, pour récupérer les settings, pour publier ou interroger des StateObjects, envoyer ou recevoir des messages, etc…

Le hub et l’interface HTTP “Consumer” sont utilisés par les “consommateurs”. Par exemple une page Web est un consommateur, c’est à dire qu’elle se connecte à Constellation pour interroger des StateObjects ou envoyer/recevoir des messages mais elle n’est pas un package (son cycle de vie est lié au navigateur du client). Un “consommateur” ne peut pas produire des logs, avoir de settings ou encore publier des StateObjects.

Le hub “Controller” expose des méthodes pour contrôler la Constellation comme arrêter/démarrer des packages, s’abonner et récupérer en temps réel les logs des packages de la Constellation, propager les changements de configuration dans la Constellation, suivre les états et consommation des ressources des packages, etc… Ce hub est notamment utilisé par la Console Constellation pour vous fournir une interface de pilotage de votre Constellation. Pour pouvez également vous connecter et exploiter les fonctionnalités de contrôle de vos pages Web ou packages .NET.

Le hub “Sentinel” est un hub privé réservé aux sentinelles de la Constellation. C’est sur ce hub que les sentinelles s’enregistrent, remontent les états des packages qu’elles supervisent, etc…

Enfin l’interface HTTP “Management” aussi nommée “Management API” est une API HTTP/REST de management du serveur permettant la gestion des sentinelles, des packages, des settings, des credentials, etc… Cette API est notamment utilisée par la Console Constellation pour vous fournir une interface d’administration de votre Constellation.

The post Les différents hubs et interfaces REST du serveur Constellation appeared first on Constellation.

Vous pouvez soit utiliser le gestionnaire de package Nuget depuis Visual Studio pour installer la dernière version du package “Constellation.Javascript” et ses dépendances :

Ou bien utiliser (ou copier en local) les scripts des CDN en ajoutant dans votre code HTML les balises suivantes :

<script type="text/javascript" src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.2.min.js"></script>
<script type="text/javascript" src="https://cdn.myconstellation.io/js/Constellation-1.8.2.min.js"></script>

Une fois les scripts ajoutés dans votre page vous devez initialiser le client Constellation en spécifiant l’URL de votre serveur Constellation, la clé d’accès et le “Friendly name” de votre page :

var constellation = $.signalR.createConstellationConsumer("http://localhost:8088", "123456789", "Test API JS");

Vous pouvez créer une clé d’accès depuis la Console Constellation ou en éditant le fichier de configuration du serveur.

Enfin ajoutons un handler sur le changement d’état de la connexion pour afficher le message “Je suis connecté” dans la console de votre navigateur par exemple lorsque la connexion à Constellation est établie :

constellation.connection.stateChanged(function (change) {
    if (change.newState === $.signalR.connectionState.connected) {
        console.log("Je suis connecté");
    }
});

Il ne reste plus qu’à lancer la connexion en invoquant la méthode Start :

constellation.connection.start();

Et voilà, votre page est connectée à votre Constellation.

Envoyer des messages et invoquer des MessageCallbacks

Envoyer des messages

Pour envoyer des messages et donc invoquer des MessageCallbacks vous devez utiliser la méthode “constellation.server.sendMessage” en spécifiant :

• Le scope
• La clé du message
• Le contenu du message (= les paramètres du MessageCallback)

Par exemple, avec le package Nest déployé dans votre Constellation, on retrouvera un MessageCallback  “SetTargetTemperature” pour piloter la température de consigne d’un thermostat Nest.

N’hésitez pas à utiliser le MessageCallback Explorer pour découvrir l’ensemble des MessageCallbacks exposés par les packages de votre Constellation.

Pour invoquer le MessageCallback  “SetTargetTemperature” depuis votre page Web en passant en paramètre l’ID du thermostat et la température de consigne :

constellation.server.sendMessage({ Scope: 'Package', Args: ['Nest'] }, 'SetTargetTemperature', 'thermostatId', 19);

Vous pouvez également passer plusieurs arguments à votre MC combinant type simple et type complexe.

Par exemple le MC “ShowNotification” du package Xbmc permettant d’afficher une notification sur une interface Kodi/XBMC prend deux paramètres : le nom d l’hôte XBMC (un type string) et le détail de la notification à afficher (un type complexe) :

constellation.server.sendMessage({ Scope: 'Package', Args: ['Xbmc'] }, 'ShowNotification', xbmcName, { "Title":"Hello", "Message":"Hello from JS" });

Bien entendu vous pouvez invoquer des MessageCallbacks de n’importe quel package, réel (programme Linux/Windows) ou virtuel (Arduino/ESP) ou même sur d’autres consommateurs (pages Web par exemple).

Ainsi vos pages Web peuvent, en envoyant des messages, invoquer des méthodes sur n’importe quel système connecté dans votre Constellation.

Par exemple dans l’article sur les ESP/Arduinos, notre ESP8266 exposait un MC “Reboot” pour redémarrer la puce. Si l’on souhaite redémarrer notre Arduino/ESP depuis une page Web, il suffit d’envoyer un message sans paramètre au bon scope. Par exemple :

constellation.server.sendMessage({ Scope: 'Sentinel', Args: ['MyArduino'] }, 'Reboot');

Ici le scope est “Sentinel” avec l’argument “MyArduino”, c’est à dire que le message “Reboot” sera envoyé à tous les packages de la sentinelle “MyArduino”.

Les scopes peuvent être :

• Sentinel
• Package
• Group
• Others
• All

La propriété “Args” de l’objet scope est un tableau contenant le nom des groupes, des sentinelles ou packages en fonction du type de scope sélectionné. Seuls les scopes “All” et “Others” n’ont pas besoin d’argument.

Envoyer des messages avec réponse : les sagas

Les Sagas permettent de lier des messages et donc de créer des couples de “requêtes / réponses”.

Avec la libraire JavaScript, il est possible d’envoyer des messages dans une saga et d’enregistrer un callback pour traiter la réponse.

Par exemple, le package “NetworkTools” expose un MC “Ping” permettant de réaliser un ping réseau. Le résultat du ping est retourné dans un message de réponse (un Int64 représentant le temps du réponse du ping) :

De ce fait pour réaliser un ping vers « www.google.fr » depuis une page Web :

constellation.server.sendMessageWithSaga(function(response) {
        console.log("Ping %s ms", response.Data);
    }, { Scope: 'Package', Args: ['NetworkTools'] }, 'Ping', "www.google.fr");

Souvenez-vous de notre package virtuel de notre ESP8266 / Arduino, on exposait un MessageCallback “Addition” capable de réaliser une addition locale (sur le CPU de l’Arduino ou ESP) en prenant en paramètre deux entiers. Le résultat était retourné dans la saga.

constellation.server.sendMessageWithSaga(function(response) {
        console.log("Le resultat de 40+2 par l'Arduino est %s", response.Data);
    }, { Scope: 'Sentinel', Args: ['MyArduino'] }, 'Addition', 40, 2);

Ainsi vos pages Web peuvent invoquer des méthodes et exploiter la réponse de tous les systèmes connectés sur Constellation exposant des MessageCallbacks.

Recevoir des messages

Une page Web connectée sur Constellation peut elle même recevoir des messages et donc exposer des MessageCallbacks que d’autres consommateurs (autres pages Web) ou packages (réels et virtuels) pourront invoquer.

Ceci dit un consommateur tel qu’une page Web n’a pas réellement d’existence. Autrement dit elle n’a pas d’identité et donc ne peut recevoir que des messages adressés à un groupe qu’elle devra joindre.

Pour joindre un groupe vous devez utiliser la méthode “subscribeMessages“ (et “unSubscribeMessages” pour en sortir). Vous pouvez joindre autant de groupe que vous souhaitez.

Par exemple, pour ajouter votre page au groupe “Demo” :

constellation.server.subscribeMessages("Demo");

Vous pourrez ensuite recevoir les messages envoyés dans ce groupe en ajoutant un handler sur le “onReceiveMessage” :

constellation.client.onReceiveMessage(function (message) {
    console.log("Message recu !", message);
});

Dans ce handler vous recevrez TOUS les messages (quelque soit la clé du message).

Vous avez aussi un moyen plus simple consistant à définir un handler pour une clé de message spécifiquement via la méthode “registerMessageCallback”.

Par exemple :

constellation.client.registerMessageCallback("ChangeTitle", function (msg) {
    document.title = msg.Data;
});
constellation.client.registerMessageCallback("HelloWorld", function (msg) {
    alert("Hello World");
});

Ici on enregistre deux MessageCallbacks.

Si votre page reçoit un MessageCallback “HelloWorld”, une alerte sera ouverte, si elle reçoit un MessageCallback “ChangeTitle”, le titre de votre page sera modifié avec l’argument passé dans le MC.

Imaginez par exemple que vous ouvrez une page Web en plein écran sur différents devices dont vous n’avez pas de contrôle (par exemple des écrans Dashboard). Sur cette page vous affichez différentes données en temps réel, par exemple basées sur les StateObjects Constellation.

Vous modifiez votre page et vous souhaitez donc la rafraîchir sur tous les navigateurs qui ont ouvert votre page pour recharger la nouvelle version.

Pour ce faire, vous pouvez facilement exposer un MessageCallback “ReloadMe” qui recharge la page avec le code :

constellation.client.registerMessageCallback("ReloadMe", function (msg) {
    location.reload();
});

Puis vous ajoutez votre page dans le groupe “ControlPage” :

constellation.server.subscribeMessages("ControlPage");

Dans ce fait, vous pouvez maintenant créer une page “cachée” avec un bouton pour invoquer le MessageCallback “ReloadMe” sur le groupe “ControlPage” afin de recharger toutes les navigateurs qui ont ouvert votre page par la ligne :

constellation.server.sendMessage({ Scope:'Group', Args:['ControlPage'] }, "ReloadMe", {});

Bien entendu, comme vos pages HTML peuvent enregistrer autant de MessageCallbacks qu’elles souhaitent et que ces MessageCallbacks sont invocables depuis n’importe quel système connecté à Constellation, d’autres pages Web, des objets à base d’Arduino, ESP ou autre, des programmes Python, .NET, etc… vous pouvez imaginer tout type d’usage.

Consommer des StateObjects

Pour consommer des StateObjects produits par des packages (virtuels ou réels) de votre Constellation, vous avez deux méthodes : l’évènement “onUpdateStateObject” ou les StateObjectLinks.

La première méthode consiste à enregistre un ou plusieurs handlers sur l’évènement “onUpdateStateObject” :

constellation.client.onUpdateStateObject(function (stateobject) {
    console.log(stateobject);
});

Les handlers seront déclenchés à chaque mise à jour ou interrogation des StateObjects de votre page quelque soit le StateObject.

Pour interroger un ou plusieurs StateObjects à un instant T vous disposez de la méthode “requestStateObjects”.

Pour vous abonner aux mises à jour d’un ou plusieurs StateObjects, vous disposez de la méthode “subscribeStateObjects” (et “unSubscribeStateObjects” pour vous désabonner).

Enfin la méthode “requestSubscribeStateObjects” réalise un “requestStateObjects” et un “subscribeStateObjects” c’est à dire que la méthode demande la valeur actuelle du ou des StateObjects et s’abonne auprès du serveur Constellation pour être notifiée des mises à jour.

Toutes ces méthodes prennent en paramètre : le nom de la sentinelle, le nom du package, le nom du StateObject et le type du StateObject. Vous pouvez utiliser le wildcard “*” pour ne pas appliquer de filtre (plus d’information ici).

Par exemple, pour récupérer tous les StateObjects du package “Demo” quelque soit la sentinelle et pour s’abonner aux mises à jour de ces StateObjects :

constellation.server.requestSubscribeStateObjects("*", "Demo", "*", "*");

L’autre méthode consiste à enregistrer un (ou plusieurs) StateObjectLink. Cela permet de lier une fonction à un abonnement.

Par exemple :

constellation.client.registerStateObjectLink("*", "HWMonitor", "/intelcpu/0/load/0", "*", function (so) {
    // Code A
});

constellation.client.registerStateObjectLink("*", "Demo", "*", "*", function (so) {
    // Code B
});

Ci-dessus le code A sera invoqué dès qu’un SO nommé « /intelcpu/0/load/0” et produit par le package “HWMonitor” est modifié alors que le code B sera déclenché dès qu’un StateObject du package “Demo” est modifié.

The post Consommer Constellation avec l’API Javascript appeared first on Constellation.

Couplée à la libraire JavaScript Constellation, il devient très facile de créer une application mobile pour votre smartphone ou tablette connectée à Constellation.

Installer Cordova

Cordova utilise nodejs, l’installation est donc très simple et rapide :

1. Installer NodeJS si vous ne l’avez pas déjà
2. Depuis le terminal (ou cmd pour windows) lancez la commande :

npm install -g cordova

Et voila Cordova est installé, mais il vous faut maintenant installer les SDK spécifiques aux plateformes que vous comptez utiliser.

Pour plus d’information, quelques ressources :

• Installer et configurer Cordova
• Guide de démarrage Cordova
• Guide pour la plate-forme Android

Créer un projet Cordova

Lancez une invite de commande Windows et tapez la ligne suivante pour créer votre projet :

cordova create Demo

Ensuite ajoutez le ou les plateformes cibles de votre application. Par exemple, développons une application pour Android :

cd Demo
cordova platform add android

Pour démarrer votre application sur l’émulateur Android ou sur votre terminal Android (connecté en USB) :

cordova run android

Tester votre application sur l’émulateur

En utilisant le “Android Virtual Device (AVD) Manager” créez un device que l’on nommera ici “SmartphoneDemo” sous Android 5.1.1 :

Vous pouvez ensuite cliquer sur le bouton “Start” pour lancer le device virtuel :

Enfin lancez la commande suivante pour déployer et démarrer votre application dans l’émulateur :

cordova run android

Debugger votre application avec l’inspecteur Chrome

Dans un nouvel onglet Chrome, rendez-vous sur chrome://inspect/#devices. Vous pourrez alors inspecter votre application Cordova :

Ainsi vous profiterez de tous les outils de debugging Web pour votre application mobile.

Déployer votre application sur votre téléphone

En connectant votre téléphone Android en USB ( sans oublier d’activer le debugging USB dans les paramètres de votre téléphone) vous pouvez, toujours avec la commande :

cordova run android

… lancer votre application sur votre téléphone et utiliser l’inspecteur Chrome pour la debugger à distance.

Autrement vous pouvez aussi utiliser la commande :

cordova build android

… pour générer le fichier APK, l’équivalent de l’installeur de votre application, qu’il faudra copier et lancer sur votre téléphone ou tablette Android.

Connecter votre application Cordova à Constellation

La structure d’une application Cordova est la suivante :

• Une page “index.html”, la page de démarrage de votre application
• Des dossiers css, img et js pour ranger respectivement les feuilles de style CSS, les images et les scripts JS

En clair votre application mobile se développe comme une véritable application Web. Vous pouvez ensuite ajouter des plugins pour accéder fonctionnalités du téléphone depuis votre code JavaScript (téléphonie, SMS, contacts, GPS, Bluetooth, Wifi, appareil photo, etc..).

Ajouter les librairies Constellation

Comme il s’agit d’une application Web, connecter une application Cordova à Constellation revient à connecter une page Web à Constellation.

Vous pouvez donc inclure les libraires en utilisant les CDN (en prenant soin de spécifier le schème explicitement, par exemple ‘https’) :

<script type="text/javascript" src="https://code.jquery.com/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="https://cdn.myconstellation.io/js/Constellation-1.8.1.min.js"></script>

Par contre afin d’améliorer les performances de votre application mobile, il est recommandé d’embarquer ces libraires dans votre application.

Pour cela téléchargez (clique-droit > Enregistrer sous …) dans le dossier “js” les librairies JavaScript suivantes :

• https://code.jquery.com/jquery-2.2.4.min.js
• https://ajax.aspnetcdn.com/ajax/signalr/jquery.signalr-2.2.1.min.js
• https://cdn.myconstellation.io/js/Constellation-1.8.1.min.js

Puis ajoutez-les dans votre page “index.html” de cette façon:

<script type="text/javascript" src="js/jquery-2.2.4.min.js"></script>
<script type="text/javascript" src="js/jquery.signalr-2.2.1.min.js"></script>
<script type="text/javascript" src="js/Constellation-1.8.1.min.js"></script>

Connecter votre application

Tout d’abord dans le ficher “config.xml” à la racine de votre projet Cordova, ajoutez ces quelques lignes :

<allow-intent href="ws://"/>
<allow-intent href="*" />
<access origin="*" subdomains="true" />

Cela permet d’autoriser le container Cordova à accéder à des ressources externes comme le serveur Constellation !

Aussi dans votre page principale, index.html, modifiez le “Content-Security-Policy” par :

<meta http-equiv="Content-Security-Policy" content="default-src *; style-src 'self' 'unsafe-inline'; script-src * 'unsafe-inline' 'unsafe-eval';">

On autorise ainsi notre page à exploiter des services et scripts externes.

Dans le fichier de script principal (app.js), créez un client “Consumer” en spécifiant l’adresse de votre serveur Constellation, une clé d’accès et un friendly name :

constellation: $.signalR.createConstellationConsumer("http://constellation.monServer.com:8088", "MaCle123!", "Demo Cordova"),

Dans la fonction “onDeviceReady” lancez la connexion au serveur Constellation par la ligne :

app.constellation.connection.start();

Pour finir dans la fonction “initialize” attachez un handler sur le changement d’état de la connexion Constellation. L’idée étant d’afficher le texte “Connected to Constellation” à la place du message “Device is Ready” du sample Cordova.

app.constellation.connection.stateChanged(function (change) {
  if (change.newState === $.signalR.connectionState.connected) {
    $('.received').text('connected to constellation');
  }
});

En démarrant l’application dans l’émulateur, votre application se connectera au hub “Consumer” de votre Constellation :

Vous pouvez maintenant envoyer des messages et invoquer des MessageCallbacks de vos différents packages, recevoir des messages pour que les autres clients de la Constellation puissent invoquer des méthodes de votre application mobile par exemple, interroger ou suivre en temps réel des StateObjects publiés par les packages de votre Constellation.

Quelques exemples ci-après …

Afficher en temps réel des StateObjects

Reprenons l’exemple du StateObject “/intelcpu/0/load/0” produit par le package “HWMonitor” et correspondant à la consommation de votre CPU.

Pour cela nous allons enregistrer StateObjectLink sur ce StateObject en ciblant une sentinelle en particulier. Ici la sentinelle UI de mon ordinateur se nomme “PC-SEB_UI”.

Vous pouvons écrire :

app.constellation.connection.stateChanged(function (change) {
  if (change.newState === $.signalR.connectionState.connected) {
    $('.received').text('connected to constellation');
    app.constellation.client.registerStateObjectLink("PC-SEB_UI", "HWMonitor", "/intelcpu/0/load/0", "*", function (so) {
      $("#cpu").text(Math.round(so.Value.Value * 100) / 100);
    });
  }
});

Sans oublier d’ajouter le “span” dans lequel afficher notre consommation :

<h2>PC-SEB CPU: <span id="cpu">0</span> %</h2>

Et voilà comment en quelques lignes afficher des StateObjects en temps réel dans une application mobile multi-plateforme.

Dans cet exemple nous affichons la consommation CPU capturée par le package HWMonitor mais nous pouvons bien sûr afficher n’importe quel StateObject : des capteurs de température, état d’une zone de l’alarme, position de votre voiture, volume de l’ampli, consommation électrique, état d’une lampe, etc.…

Invoquer des MessageCallbacks

Tout comme n’importe quel “consommateur”, votre application mobile multi-plateforme peut envoyer des messages et donc invoquer des MessageCallbacks.

Pour découvrir les MessageCallbacks de votre Constellation, vous pouvez utiliser le MessageCallback Explorer de la Console Constellation.

Par exemple, après avoir déployé le package “WindowsControl” sur une sentinelle Windows, vous pouvez invoquer des MC pour arrêter votre Windows, verrouiller la session, se déconnecter, redémarrer ou encore mettre en veille la machine.

Ajoutons à notre application Android la capacité de verrouiller notre PC Windows. Pour cela vous pouvez cliquer sur l’icone pour générer le code d’invocation de ce MC en sélectionnant le langage de votre choix, dans notre cas, “Javascript” :

Dans notre page “index.html”, ajoutons un simple bouton (ou lien) HTML :

<a id="lockPC" href="#" class="btn">LOCK MY PC</a>

Et dans notre fichier Javascript, invoquons le MessageCallback “’LockWorkStation” lorsque l’utilisateur clique sur notre bouton :

$("#lockPC").click(function () 
  constellation.server.sendMessage({ Scope: 'Package', Args: ['PC-SEB_UI/WindowsControl'] }, 'LockWorkStation', {});
});

Notez que dans le code ci-dessus, à l’inverse de l’exemple donné par le générateur de code de la Console Constellation, nous avons défini le nom de l’instance du package et non le nom du package seul. En effet, en envoyant un message au scope de type Package ”WindowsControl”, votre message sera reçu par toutes les instances du package “WindowsControl” quelque soit la sentinelle. Autrement dit, toutes les sentinelles Windows qui exécutent le package “WindowsControl” seront verrouillées. Pour cibler votre sentinelle en particulier, nous avons indiqué ici le nom de l’instance, c’est à dire le couple “Sentinelle + Package”, ici “PC-SEB_UI/WindowsControl”.

Aussi, d’un point de vue visuel, Cordova n’inclut pas de framework CSS à l’inverse d’Ionic par exemple. De ce fait tout est à votre charge. Ici nous avons créer un lien (<a>) sur lequel nous avons appliqué la classe CSS “btn”. Vous pouvez, pour l’exemple, utiliser des générateurs tel que celui-ci ou encore celui-la pour générer la classe “btn”.

Et voilà, notre application Android est maintenant capable de verrouiller notre poste Windows et d’afficher la consommation CPU en temps réel :

(screen here)

Pour aller plus loin …

Donc vous avez pu le découvrir dans cet article, réaliser des applications mobiles (ou tablettes) pour Android, iOS, Windows ou autre est relativement facile avec des plateformes comme Cordova. En utilisant la libraire JavaScript Constellation, vous pouvez donc développer des applications mobile connectées à Constellation en quelques minutes.

Une fois que votre application mobile est connectée à votre Constellation, elle peut suivre en temps réel tous les StateObjects produits par les packages de votre Constellation et invoquer des méthodes de ces packages en envoyant des messages.

De ce fait vous êtes libre de créer vos propres applications de supervision ou de contrôle de vos systèmes, services, réalisations, de votre domotique, etc…

Par exemple, vous créer un objet connecté avec un Raspberry et du Python ou bien un Arduino ou ESP8266, et vous pouvez créer facilement l’enrichir avec une application mobile. Ou bien vous ajoutez des lampes Hue et un media-center Kodi et vous décidez de créer une applications mobile unique pour tout contrôler en utilisant Constellation comme centralisateur.

Pour ma part je vous recommande vivement d’utiliser Ionic plutôt que Cordova. En effet, Ionic n’est ni plus ni moins qu’une surcouche à Cordova qui intègre le framework AngularJS et un framework CSS. Grace à Ionic vous pouvez développer des applications plus riche et beaucoup plus rapidement.

The post Créer une application mobile multi-plateforme connectée à Constellation avec Cordova 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.