Tag ControlHub - Constellation

Accéder au hub de contrôle avec le ControlManager

Sebastien Warin — Mon, 21 Mar 2016 10:24:49 +0000

Le hub de contrôle permet d’accéder à différentes fonctions de pilotage de votre Constellation.

Voyons en détail comment contrôler votre Constellation depuis un package C#/.NET.

Accéder au hub de contrôle

Tout d’abord il faut déclarer que votre package souhaite un accès au hub de contrôle. Pour cela vous devez ajouter l’attribut “EnableControlHub” à true dans le manifeste de votre package (fichier PackageInfo.xml).

Ensuite, il faut que votre package se connecte à votre Constellation avec une “Access Key” qui possède l’autorisation d’accès au hub de contrôle.

Il faut ajouter l’attribut “enableControlHub” à true sur un de vos credentials et affecter ce credential à votre package :

Ainsi votre package pourra accéder au hub de contrôle de contrôle. Vous devriez d’ailleurs toujours tester la propriété “HasControlManager” pour gérer les erreurs où l’accès au hub de contrôle n’est possible.

if (PackageHost.HasControlManager)
{
    PackageHost.WriteInfo("ControlHub OK");
}
else
{
    PackageHost.WriteError("ControlHub access denied !");
}

Suivre les sentinelles et leurs statuts

Il y a deux manières d’obtenir la liste des sentinelles enregistrées dans votre Constellation :

RequestSentinelsList : vous retourne la liste des sentinelles en une seule fois par l’événement “SentinelsListUpdated”
RequestSentinelUpdates : vous retourne l’état de chaque sentinelle dans l’événement “SentinelUpdated” (cet événement est levé pour chaque sentinelle)

En principe pour récupérer la liste des sentinelles de votre Constellation, vous utiliserez toujours la première méthode.

Par exemple :

PackageHost.ControlManager.SentinelsListUpdated += (s, e) =>
{
    PackageHost.WriteInfo("Il y a {0} sentinelle(s)", e.Sentinels.Count);
    foreach (SentinelInfo sentinel in e.Sentinels)
    {
        PackageHost.WriteInfo("Sentinelle '{0}' (Plateforme: {1}) => IsConnected = {2}",
            sentinel.Description.SentinelName,
            sentinel.Description.Platform,
            sentinel.IsConnected);
    }
};
PackageHost.ControlManager.RequestSentinelsList();

Vous pouvez également vous abonner en temps réel aux mises à jour des sentinelles de votre Constellation.

Pour cela il faut activer la réception des mises à jour :

PackageHost.ControlManager.ReceiveSentinelUpdates = true;

Puis attacher un handler sur l’événement “SentinelUpdated” qui se produit à chaque mise à jour d’une sentinelle :

PackageHost.ControlManager.SentinelUpdated += (s, e) =>
{
    PackageHost.WriteInfo("Sentinelle '{0}' (Plateforme: {1}) => IsConnected = {2}",
        e.Sentinel.Description.SentinelName,
        e.Sentinel.Description.Platform,
        e.Sentinel.IsConnected);
};

Superviser les packages

Récupérer les packages d’une sentinelle

Pour récupérer la liste des packages qui sont déployés sur une sentinelle vous devez attacher un handler sur l’événement “PackagesListUpdated” et appeler la méthode “RequestPackagesList” en spécifiant le nom de la sentinelle.

Pour exemple :

PackageHost.ControlManager.PackagesListUpdated += (s, e) =>
{
    PackageHost.WriteInfo("Il y a {0} package(s) sur la sentinelle {1}", e.Packages.Count, e.SentinelName);
};
PackageHost.ControlManager.RequestPackagesList("MA-SENTINELLE");

Chaque “PackageInfo” contient différentes informations sur l’instance du package (description du package, état du package, état de la connexion, version du package, etc…) :

foreach (PackageInfo package in e.Packages)
{
    PackageHost.WriteInfo("Package '{0}' - Etat = {1}", package.Package.Name, package.State);
}

Suivre l’état des packages

Vous pouvez aussi vous abonnez aux mises à jour des états des packages :

PackageHost.ControlManager.ReceivePackageState = true;

Vous pourrez ensuite être notifier de tout changement d’état de vos packages dans votre Constellation :

PackageHost.ControlManager.PackageStateUpdated += (s, e) =>
{
    PackageHost.WriteInfo("Le package '{0}' est maintenant dans l'état {1}", e.PackageName, e.State);
};

Suivre la consommation des packages

Vous pouvez aussi récupérer la consommation des ressources (CPU et RAM) de vos packages :

PackageHost.ControlManager.ReceivePackageUsage = true;

Par exemple, on pourrait écrire un warning si un package consomme plus de 50% du CPU :

PackageHost.ControlManager.PackageUsageUpdated += (s, e) =>
{
    if (e.CPU > 50) // Package consommant plus de 50% du CPU à un instant T
    {
        PackageHost.WriteWarn("Le package {0} consomme maintenant plus de 50% !!! CPU={1}% RAM={2}ko",
            e.PackageName, e.CPU, e.RAM / 1024);
    }
};

Contrôler les packages

Vous pouvez démarrer un package sur une sentinelle avec la méthode “StartPackage” :

// Démrrage du package "MonPremierPackage" sur la sentinelle "MON-PC"
PackageHost.ControlManager.StartPackage("MON-PC", "MonPremierPackage");

Ou encore l’arrêter avec la méthode “StopPackage” :

// Arret du package "MonPremierPackage" sur la sentinelle "MON-PC"
PackageHost.ControlManager.StopPackage("MON-PC", "MonPremierPackage");

Pour redémarrer (Stop puis Start) un package sur une sentinelle donnée, utilisez la méthode “RestartPackage” :

// Redémarrage du package "MonPremierPackage" sur la sentinelle "MON-PC"
PackageHost.ControlManager.RestartPackage("MON-PC", "MonPremierPackage");

Enfin pour mettre à jour un package, utilisez la méthode “ReloadPackage”.

Un “reload” stoppe le package, ordonne à la sentinelle de re-télécharger le package sur le serveur, le déploie en local avant de le démarrer.

// Mise à jour du package "MonPremierPackage" sur la sentinelle "MON-PC"
PackageHost.ControlManager.ReloadPackage("MON-PC", "MonPremierPackage");

Accéder aux logs en temps réel

Pour récupérer les logs produits par vos sentinelles et packages dans votre Constellation, activez la propriété suivante :

PackageHost.ControlManager.ReceivePackageLog = true;

Il suffit ensuite d’attacher handler sur l’événement “LogEntryReceived “.

Vous recevrez en paramètre un objet “LogEntry” qui contient toutes les informations sur un log (le message, la date, le couple Sentinelle/Package à l’origine du log et la sévérité du message).

Par exemple :

PackageHost.ControlManager.LogEntryReceived += (s, e) =>
{
    if (e.LogEntry.PackageName != PackageHost.PackageInstanceName) // Ne pas prendre les logs de ce package pour éviter la boucle ;)
    {
        // On log des logs, juste pour l'exemple ;)
        PackageHost.WriteInfo("Je reçois un log daté du {0} du package {1} sur la sentinelle {2} de type {3}." +
            "Message = {4}",
            e.LogEntry.Date.ToString(),
            e.LogEntry.SentinelName,
            e.LogEntry.PackageName,
            e.LogEntry.Level,
            e.LogEntry.Message);
    }
};

Notez qu’ici on logue dans Constellation (“WriteInfo”) les logs des autres packages (d’où le ). Ca n’a pas de sens, c’est juste pour l’exemple !

Récupérer la description des packages

Comme vous le savez, tous les MessageCallbacks ainsi que les types personnalisés utilisés en entrée ou en sortie sont décrits dans un PackageDescriptor tout comme les types personnalisés des StateObjects.

En vous connectant au hub de contrôle vous pouvez récupérer le PackageDescriptor de chaque package. Par exemple :

PackageHost.ControlManager.PackageDescriptorUpdated += (s, e) =>
{
    PackageHost.WriteInfo("Pour le package {0}, il y a {1} MessageCallback(s) associés à " +
                         "{2} type(s) ainsi que {3} type(s) de StateObject",
        e.PackageName,
        e.Descriptor.MessageCallbacks.Count,
        e.Descriptor.MessageCallbackTypes.Count,
        e.Descriptor.StateObjectTypes.Count);
};
PackageHost.ControlManager.RequestPackageDescriptor("MonPremierPackage");

Purger les StateObjects

Pour supprimer tous les StateObjects d’un package déployé une sentinelle :

PackageHost.ControlManager.PurgeStateObjects("MON-PC", "MonPremierPackage");

Vous pouvez aussi spécifier le nom du StateObject, pour supprimer un StateObject en particulier (identifié par son nom) :

PackageHost.ControlManager.PurgeStateObjects("MON-PC", "MonPremierPackage", "Demo");

Ou encore, tous les StateObjects d’un type particulier d’une instance de package :

PackageHost.ControlManager.PurgeStateObjects("MON-PC", "MonPremierPackage", type:"TypeDemo");

Recharger la configuration

Vous pouvez recharger et déployer la configuration Constellation en invoquant la méthode :

PackageHost.ControlManager.ReloadServerConfiguration();

Vous pouvez également passer un booléen pour indiquer si il faut déployer la configuration (c’est à dire pousser la configuration sur chaque sentinelle et package). Par défaut, la valeur est à “true” (la configuration est déployée).

Autrement :

PackageHost.ControlManager.ReloadServerConfiguration(false);

The post Accéder au hub de contrôle avec le ControlManager appeared first on Constellation.

Contrôler votre Constellation en Javascript

Sebastien Warin — Thu, 18 Aug 2016 14:48:37 +0000

Le hub de contrôle 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 la consommation de ressource des packages, etc…

Les deux librairies JavaScript Constellation intègrent un client permettant de se connecter sur ce hub afin de pouvoir piloter votre Constellation. La Console Constellation est d’ailleurs basée sur ce client.

Dans cet article découvrons les fonctionnalités de ce client avec l’API JavaScript et l’API AngularJS.

Connecter une page HTML au hub de contrôle

Etape 1 : Ajouter les librairies

En utilisant le CDN

Les librairies JavaScripts sont accessibles sur : http://cdn.myconstellation.io/js/ (en HTTP ou HTTPS).

Pour utiliser la librairie JavaScript :

Ou si vous souhaitez l’utiliser avec le framework AngularJS :

Par Nuget en utilisant Visual Studio

Dans Visual Studio et ouvrez le gestionnaire de package NuGet.

En sélectionnant la source “Constellation”, installez le package Nuget “Constellation.Javascript” pour l’API JavaScript ou “Constellation.AngularJS” pour l’API AngularJS :

Etape 2 : Connexion au hub de contrôle

Avec l’API JavaScript (JS) vous devez créer le client avec la méthode “createConstellationController” en spécifiant l’URL de votre Constellation, une clé d’accès et un friendly name :

var controller = $.signalR.createConstellationController("http://localhost:8088", "123456789", "TestAPI");
controller.connection.stateChanged(function (change) {
  if (change.newState === $.signalR.connectionState.connected) {
    console.log("Connected to the ControlHub");
  }
});
controller.connection.start();

Avec l’API AngularJS (NG), vous devez injecter le client “constellationController” dans votre contrôleur puis l’initialiser avec la méthode “initializeClient” en spécifiant l’URL de votre Constellation, une clé d’accès et un friendly name :

var demo = angular.module('demoApp', ['ngConstellation']);
demo.controller('MyController', ['$scope',  'constellationController', function ($scope, controller) {

  controller.initializeClient("http://localhost:8088", "123456789", "TestAPI");
    
  controller.onConnectionStateChanged(function (change) {
    if (change.newState === $.signalR.connectionState.connected) {
      console.log("Connected to the ControlHub");
    }
  });
    
  controller.connect();
}]);

La clé d’accès (AccessKey) utilisée pour se connecter au hub de contrôle doit avoir l’attribut “enableControlHub” à “true”. Vous pouvez gérer les credentials dans la Console Constellation ou dans le fichier de configuration.

Superviser les sentinelles

Vous disposez de deux méthodes :

requestSentinelsList() : pour recevoir la liste des sentinelles de votre Constellation
requestSentinelUpdates() : pour recevoir toutes les mises à jour des sentinelles de votre Constellation (ajout ou suppression de sentinelles, connexion ou déconnexion des sentinelles, mise à jour des informations, etc…).

Ces deux méthodes sont de type “void”. Les réponses sont réceptionnées par les handlers respectivement nommés ”onUpdateSentinelsList” et “onUpdateSentinel”.

Avec l’API JS :

controller.client.onUpdateSentinelsList(function (list) {
  console.log(list);
});

controller.client.onUpdateSentinel(function (sentinel) {
  console.log(sentinel);
});

controller.connection.onConnectionStateChanged(function (change) {
  if (change.newState === $.signalR.connectionState.connected) {
    controller.server.requestSentinelsList();
    controller.server.requestSentinelUpdates();
  }
}

Avec l’API NG :

controller.onUpdateSentinelsList (function (list) {
  console.log(list);
});

controller.onUpdateSentinel  (function (se) {
  console.log(se);
});

controller.onConnectionStateChanged(function (change) {
  if (change.newState === $.signalR.connectionState.connected) {
    controller.requestSentinelsList();
    controller.requestSentinelUpdates ();
  }
});

Par exemple utilisons l’API NG pour créer une page affichant l’ensemble des sentinelles avec leur statuts en temps dans une page :

Dans le code du contrôleur, ajoutons un handler sur la mise à jour sentinelle afin de stocker les objets “sentinelle” dans une variable de scope :

$scope.sentinels = {};
controller.onUpdateSentinel  (function (sentinel) {
  $scope.$apply(function() {
    $scope.sentinels[sentinel.Description.SentinelName.replace("-", "")] = sentinel;
  });
});

Nous sommes obligé de faire un “replace(« -« , « »)” car nous utilisons le nom de la sentinelle comme nom pour la propriété de notre variable de scope, or en JavaScript une propriété ou variable ne peut pas comporter de “-“.

Lors de la connexion, abonnons-nous aux mises à jour des sentinelles afin de maintenir notre page à jour :

controller.onConnectionStateChanged(function (change) {
  if (change.newState === $.signalR.connectionState.connected) {
    console.log("Connected to the ControlHub");
    controller.requestSentinelUpdates ();
  }
});

Enfin dans le template HTML affichons nos différentes sentinelles dans une simple liste à puce :


  {{s.Description.SentinelName}} [{{s.IsConnected ? "CONNECTED" : "DISCONNECTED"}}] ({{s.Description.OSVersion}})

Veuillez noter que seule les sentinelles “réelles” qui se sont connectées au moins une fois peuvent être récupérer car cette technique. Pour les sentinelles qui ne se sont jamais connectées comme pour les sentinelles virtuelles, vous devez lire le fichier de configuration en utilisant l’API REST de Management (Management API).

Voici la structure de l’objet ”sentinelle” :

Superviser les packages

Une fois la liste de vos sentinelles connue, vous pouvez récupérer la liste des packages pour chaque sentinelle en invoquant la méthode “requestPackagesList “ et en ajoutant un handler sur le “onUpdatePackageList”.

Avec l’API JS :

controller.client.onUpdatePackageList (function (list) {
  console.log(list);
});
controller.server.requestPackagesList("MySentinel");

Avec l’API NG :

controller.onUpdatePackageList (function (list) {
  console.log(list);
});
controller.requestPackagesList("MySentinel");

Reprenons notre page ci-dessus et ajoutons la liste des packages pour chaque sentinelle de notre Constellation.

Dans le handler “onUpdateSentinel” défini dans la section précédente, demandons au hub de contrôle la liste des packages pour chaque sentinelle :

controller.onUpdateSentinel  (function (sentinel) {
  $scope.$apply(function() {
    $scope.sentinels[sentinel.Description.SentinelName.replace("-", "")] = sentinel;
  });
  controller.requestPackagesList(sentinel.Description.SentinelName);
});

Et ajoutons dans notre scope le handler “onUpdatePackageList” de manière à ajouter la liste des packages dans une propriété “Packages” que nous ajouterons dans nos objets “sentinelles” :

controller.onUpdatePackageList (function (p) {
  $scope.$apply(function() {
    $scope.sentinels[p.SentinelName.replace("-", "")]["Packages"] = p.List;
  });
});

Nous pouvons maintenant enrichir notre template pour afficher les packages de chacune de nos sentinelles :


  {{s.Description.SentinelName}} [{{s.IsConnected ? "CONNECTED" : "DISCONNECTED"}}] ({{s.Description.OSVersion}})
    
      {{p.Package.Name}} version {{p.PackageVersion}} [{{p.State}}]

Surveiller l’état et la consommation des packages

La liste de package récupérée ci-dessus n’est pas maintenue à jour. Pour recevoir les mises à jour de vos packages afin d’être notifié de chaque changement d’état vous pouvez ajouter le handler “onReportPackageState”.

De plus vous pouvez aussi vous abonner aux informations de consommation des ressources de vos packages avec le handler “onReportPackageUsage”.

Avec l’API JS :

controller.client.onReportPackageUsage  (function (usage) {
  console.log(usage);
});

controller.client.onReportPackageState  (function (usage) {
  console.log(usage);
});

Avec l’API NG :

controller.onReportPackageUsage  (function (usage) {
  console.log(usage);
});

controller.onReportPackageState  (function (usage) {
  console.log(usage);
});

Par exemple ajoutons dans notre page la consommation de CPU et de RAM pour chaque package de notre Constellation :

controller.onReportPackageUsage(function (usage) {
  $scope.$apply(function() {
    var sentinelName = usage.SentinelName.replace("-", "");
    for(var idx in $scope.sentinels[sentinelName].Packages) {
      var p = $scope.sentinels[sentinelName].Packages[idx];
      if(p.Package.Name == usage.PackageName) {
        p["CPU"] = usage.CPU;
        p["RAM"] = usage.RAM;
      }
    }
  });
});

Dans le code ci-dessus, on ajoute dans chaque objet “Package” la valeur de la consommation du CPU et de RAM.

Ainsi on peut enrichir le template HTML avec le code :


  {{s.Description.SentinelName}} [{{s.IsConnected ? "CONNECTED" : "DISCONNECTED"}}] ({{s.Description.OSVersion}})
    
      {{p.Package.Name}} version {{p.PackageVersion}} [{{p.State}}]
        
          CPU: {{p.CPU | number : 0 }}% - RAM: {{p.RAM / 1024 / 1024 | number: 0}}Mo

Contrôler les packages

Pour contrôler les instances de package vous disposez des méthodes suivantes :

start(sentinelName, packageName) : démarre un package
stop(sentinelName, packageName) : arrête un package
restart(sentinelName, packageName) : redémarre un package
reload(sentinelName, packageName) : arrête un package, force la sentinelle à télécharger la dernière version du package sur le serveur et redémarre le package
updatePackageSettings(sentinelName, packageName) : pousse les settings d’un package au package en cours de fonctionnement (à charge au package à prendre en compte ses nouveaux paramètres).

Avec l’API JS :

controller.server.start(sentinelName, packageName);
controller.server.stop(sentinelName, packageName);
controller.server.restart(sentinelName, packageName);
controller.server.reload(sentinelName, packageName);
controller.server.updatePackageSettings(sentinelName, packageName);

Avec l’API NG :

controller.start(sentinelName, packageName);
controller.stop(sentinelName, packageName);
controller.restart(sentinelName, packageName);
controller.reload(sentinelName, packageName);
controller.updatePackageSettings(sentinelName, packageName);

Par exemple ajoutons dans notre page la possibilité de piloter les packages.

Pour ce faire exposons notre client “controller” dans le scope Angular de façon à pouvoir l’utiliser dans le template HTML :

$scope.controller = controller;

Dans notre template ajoutons ensuite des boutons en spécifiant l’action du clic grâce à l’attribut “ng-click” :

Pour aller plus loin on peut également afficher/cacher les boutons en fonction de l’état du package, par exemple ne pas afficher le bouton “Start” si le package est déjà démarré :

S’abonner aux logs de Constellation

Pour récupérer les logs produits par les packages (virtuels ou non) en temps réel dans votre page Web, vous devez ajouter un handler sur “onReceiveLogMessage”.

Avec l’API JS :

controller.client.onReceiveLogMessage(function (log) {
  console.log(log);
});

Avec l’API NG :

controller.onReceiveLogMessage(function (log) {
  console.log(log);
});

Par exemple ajoutons à notre page la capacité d’afficher les logs des packages de notre Constellation en temps réel.

Pour cela nous allons nous abonner aux logs et les stocker dans un tableau de notre scope Angular :

$scope.logs = [];
controller.onReceiveLogMessage(function (log) {
  $scope.$apply(function() {
    $scope.logs.push(log);
  });
});

Nous pouvons donc maintenant afficher proprement nos logs dans notre template HTML :


  {{log.Date | date: 'dd/MM/yyyy HH:mm:ss' }} on {{log.SentinelName}}/{{log.PackageName}} : [{{ log.Level.toUpperCase() }}] {{log.Message}}

Récupérer les PackageDescriptors

Le PackageDescriptor est un objet publié par les packages qui permet de décrire les MessagesCallbacks que les packages exposent ainsi que les types utilisés dans leurs MC et StateObjects.

Pour récupérer un PackageDescriptor vous devez invoquer la méthode ”requestPackageDescriptor” en spécifiant le nom du package et attacher un handler “onUpdatePackageDescriptor” pour récupérer le résultat.

Avec l’API JS :

controller.client.onUpdatePackageDescriptor(function (descriptor) {
  console.log(descriptor);
});

controller.server.requestPackageDescriptor(packageName);

Avec l’API NG :

controller.onUpdatePackageDescriptor(function (descriptor) {
  console.log(descriptor);
});

controller.requestPackageDescriptor(packageName);

Par exemple sur notre page ci-dessus, ajoutons un bouton permettant d’afficher dans une simple boite de dialogue la liste des MessageCallbacks d’un package :

Dans le template HTML :

Et dans le code de notre contrôleur, de manière grossière :

controller.onUpdatePackageDescriptor(function (descriptor) {
  var result = "Package "+ descriptor.PackageName + " :";
  for(var idx in descriptor.Descriptor.MessageCallbacks) {
    result += "\n - " + descriptor.Descriptor.MessageCallbacks[idx].MessageKey;
  }
  alert(result);          
});

Une description plus détaillée des PackageDesciptors se trouve ici.

Effacer des StateObjects

Vous pouvez effacer des StateObjects en invoquant la méthode “purgeStateObjects” :

Avec l’API JS :

controller.server.purgeStateObjects(sentinelName, packageName, name, type);

Avec l’API NG :

controller.purgeStateObjects(sentinelName, packageName, name, type);

Vous devez indiquer les filtres de sélection des StateObjects à supprimer avec la possibilité d’utiliser le wildcard ”*” seulement pour les paramètres “name” et “type”. Autrement dit vous êtes obliger de spécifier le “sentinelName” et “packageName”.

Rafraichir et déployer la configuration

Vous pouvez recharger la configuration Constellation avec la méthode “reloadServerConfiguration” :

Avec l’API JS :

controller.server.reloadServerConfiguration(deployConfiguration);

Avec l’API NG :

controller.reloadServerConfiguration(deployConfiguration);

Cette méthode attend un booléen (deployConfiguration) pour indiquer si oui ou non la configuration doit être déployée après son rechargement. Dans le cas d’un déploiement, la nouvelle configuration est envoyée à toutes les sentinelles et packages de votre Constellation.

The post Contrôler votre Constellation en Javascript appeared first on Constellation.