19.4. Utiliser LMIShell

PDF

LMIShell est un client interactif et un interprète non-interactif pouvant être utilisé pour accéder aux objets CIM fournis par le CIMOM OpenPegasus. Il est basé sur l'interprète Python, mais implémente également des fonctions et des classes supplémentaires pour interagir avec les objets CIM.

19.4.1. Lancer, utiliser, et quitter LMIShell

De même qu'avec l'interprète Python, il est possible d'utiliser LMIShell soit en tant que client interactif, ou en tant qu'inteprète non-interactif pour les scripts LMIShell.

Lancer le LMIShell en mode interactif

Pour lancer l'interprète LMIShell en mode interactif, veuillez exécuter la commande lmishell sans argument supplémentaire :

lmishell

Par défaut, lorsque LMIShell tente d'établie une connexion avec un CIMOM, il valide un certificat côté serveur avec le magasin des confiances des autorités de certification (CA). Pour désactiver cette validation, exécutez la commande lmishell avec l'option de ligne de commande --noverify ou -n :

lmishell --noverify

Utiliser la saisie semi-automatique avec la touche « Tab »

Lors de l'exécution en mode interactif, l'interprète LMIShell vous permet d'appuyer sur la touche Tab pour compléter des structures de programmation et d'objets CIM de base, y compris les espaces de noms, les classes, les méthodes, et les propriétés d'objets.

Historique de navigation

Par défaut, LMIShell stocke toutes les commandes saisies sur l'invite interactive dans le fichier ~/.lmishell_history. Cela vous permet de parcourir l'historique des commandes et de réutiliser les lignes déjà saisies en mode interactif sans avoir à les réécrire dans l'invite. Pour reculer dans l'historique, veuillez appuyer sur la Flèche vers le haut ou sur la combinaison de touches Ctrl+p. Pour avancer dans l'historique des commandes, veuillez appuyer sur la touche Flèche vers le bas ou sur la combinaison de touches Ctrl+n.

LMIShell prend également en charge les recherches inversées incrémentielles. Pour rechercher une ligne en particulier dans l'historique des commandes, veuillez appuyer sur Ctrl+r,puis commencez à saisir n'importe quelle partie de la commande. Exemple :

> (reverse-i-search)`connect': c = connect("server.example.com", "pegasus")

Pour supprimer l'historique des commandes, veuillez utiliser la fonction clear_history() comme suit :

clear_history()

Vous pouvez configurer le nombre de lignes stockées dans l'historique des commandes en modifiant la valeur de l'option history_length dans le fichier de configuration ~/.lmishellrc. En outre, vous pouvez modifier l'emplacement du fichier de l'historique en changeant la valeur de l'option history_file dans ce fichier de configuration. Par exemple, pour paramétrer l'emplacement du fichier de l'historique sur ~/.lmishell_history et pour configurer LMIShell pour qu'un maximum de 1000 lignes y soient stockées, veuillez ajouter les lignes suivantes au fichier ~/.lmishellrc :

history_file = "~/.lmishell_history"
history_length = 1000

Gestion des exceptions

Par défaut, l'interprète LMIShell gère toutes les exceptions et utilise de valeurs de retour. Pour désactiver ce comportement de manière à gérer toutes les exceptions dans le code, veuillez utiliser la fonction use_exceptions() comme suit :

use_exceptions()

Pour réactiver la gestion d'exceptions automatique, veuillez utiliser :

use_exception(False)

Vous pouvez désactiver la gestion des exceptions de manière permanente en modifiant la valeur de l'option use_exceptions dans le fichier de configuration ~/.lmishellrc sur True :

use_exceptions = True

Configurer un cache temporaire

Avec la configuration par défaut, les objets de connexion LMIShell utilisent un cache temporaire pour stocker les noms de classe CIM et les classes CIM afin de réduire les communications réseaux. Pour supprimer ce cache temporaire, veuillez utiliser la méthode clear_cache() comme suit :

object_name.clear_cache()

Veuillez remplacer object_name par le nom d'un objet de connexion.

Pour désactiver le cache temporaire d'un objet de connexion en particulier, veuillez utiliser la méthode use_cache() comme suit :

object_name.use_cache(False)

Pour le réactiver à nouveau, veuillez utiliser :

object_name.use_cache(True)

Il est possible de désactiver de manière permanente le cache temporaire pour les objets de connexion en modifiant la valeur de l'option use_cache dans le fichier de configuration ~/.lmishellrc sur False :

use_cache = False

Quitter LMIShell

Pour quitter l'interprète LMIShell et retourner à l'invite de shell, veuillez appuyer sur la combinaison de touches Ctrl+d ou passez la fonction quit() comme suit :

> quit()
~]$

Exécuter un script LMIShell

Pour exécuter un script LMIShell, veuillez exécuter la commande lmishell comme suit :

lmishell file_name

Veuillez remplacer file_name par le nom du script. Pour inspecter un script LMIShell après son exécution, veuillez également spécifier l'option de ligne de commande --interact ou -i :

lmishell --interact file_name

L'extension de fichier préférée des scripts LMIShell est .lmi.

19.4.2. Connexion à un CIMOM

LMIShell vous permet de vous connecter à un CIMOM en cours d'exécution sur le même système local, ou sur une machine distante accessible à travers le réseau.

Connexion à un CIMOM distant

Pour accéder à des objets CIM fournis par un CIMOM distant, veuillez créer un objet de connexion en utilisant la fonction connect() comme suit :

connect(host_name, user_name[, password])

Veuillez remplacer host_name par le nom d'hôte du système géré, user_name par le nom d'un utilisateur autorisé à se connecter au CIMOM OpenPegasus exécuté sur ce système, et password par le mot de passe de l'utilisateur. Si le mot de passe est oublié, LMIShell demandera à l'utilisateur de le saisir. La fonction retourne un objet LMIConnection.

Exemple 19.1. Connexion à un CIMOM distant

Pour se connecter au CIMOM OpenPegasus en cours d'exécution sur server.example.com en tant qu'utilisateur pegasus, veuillez saisir ce qui suit dans l'invite interactive :

> c = connect("server.example.com", "pegasus")
password:
>

Connexion à un CIMOM local

LMIShell vous permet de vous connecter à un CIMOM local en utilisant un socket UNIX. Pour ce type de connexion, vous devrez exécuter l'interprète LMIShell en tant qu'utilisateur root et le socket /var/run/tog-pegasus/cimxml.socket doit exister.

Pour accéder à des objets CIM fournis par un CIMOM local, veuillez créer un objet de connexion en utilisant la fonction connect() comme suit :

connect(host_name)

Veuillez remplacer host_name par localhost, 127.0.0.1, ou ::1. la fonction retourne un objet LMIConnection ou None.

Exemple 19.2. Connexion à un CIMOM local

Pour se connecter au CIMOM OpenPegasus en cours d'exécution sur localhost en tant qu'utilisateur root, veuillez saisir ce qui suit dans l'invite interactive :

> c = connect("localhost")
>

Vérifier une connexion sur un CIMOM

La fonction connect() retourne soit un objet LMIConnection, ou None si la connexion n'a pas pu être établie. En outre, lorsque la fonction connect() ne parvient pas à établir une connexion, un message d'erreur est imprimé sur la sortie d'erreur standard.

Pour vérifier qu'une connexion à un CIMOM a bien été établie, veuillez utiliser la fonction isinstance() comme suit :

isinstance(object_name, LMIConnection)

Veuillez remplacer object_name par le nom de l'objet de connexion. Cette fonction retourne True si object_name est un objet LMIConnection, sinon elle retournera False.

Exemple 19.3. Vérifier une connexion sur un CIMOM

Pour vérifier si la variable c, créée dans l'Exemple 19.1, « Connexion à un CIMOM distant », contient un objet LMIConnection, veuillez saisir ce qui suit dans l'invite interactive :

> isinstance(c, LMIConnection)
True
>

De manière alternative, vous pouvez vérifier si c n'est pas égal à None :

> c is None
False
>

19.4.3. Utiliser des espaces de noms

Les espaces de noms LMIShell offre une manière naturelle d'organiser les classes disponibles et servent de point d'accès hiérarchique à d'autres espaces de noms et classes. L'espace de noms root est le premier point d'entrée d'un objet de connexion.

Répertorier les espaces de noms disponibles

Pour répertorier tous les espaces de noms disponibles, veuillez utiliser la méthode print_namespaces(), comme suit :

object_name.print_namespaces()

Veuillez remplacer object_name par le nom de l'objet à inspecter. Cette méthode imprime les espaces de noms disponibles sur la sortie standard.

Pour obtenir une liste des espaces de noms disponibles, veuillez accéder à l'attribut d'objet namespaces :

object_name.namespaces

Une liste de chaînes est retournée.

Exemple 19.4. Répertorier les espaces de noms disponibles

Pour inspecter l'objet de l'espace de noms root de l'objet de connexion c créé dans l'Exemple 19.1, « Connexion à un CIMOM distant » et pour répertorier les espaces de noms disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> c.root.print_namespaces()
cimv2
interop
PG_InterOp
PG_Internal
>

Pour assigner une liste de ces espaces de noms à une variable nommée root_namespaces, veuillez saisir :

> root_namespaces = c.root.namespaces
>

Accéder aux objets d'espaces de noms

Pour accéder à un objet d'espace de noms particulier, veuillez utiliser la syntaxe suivante :

object_name.namespace_name

Veuillez remplacer object_name par le nom de l'objet à inspecter et namespace_name par le nom de l'espace de noms à accéder. Un objet LMINamespace sera retourné.

Exemple 19.5. Accéder aux objets d'espaces de noms

Pour accéder à l'espace de noms cimv2 de l'objet de connexion c créé dans l'Exemple 19.1, « Connexion à un CIMOM distant » et l'assigner à une variable nommée ns, veuillez saisir ce qui suit dans l'invite interactive :

> ns = c.root.cimv2
>

19.4.4. Utiliser des classes

Les classes LMIShell représentent des classes fournies par un CIMOM. Vous pouvez accéder et répertorier leurs propriétés, méthodes, instances, noms d'instances, et propriétés ValueMap, imprimer les chaînes de leur documentation et créer de nouvelles instances et de nouveaux noms d'instances.

Répertorier les classes disponibles

Pour répertorier toutes les classes disponibles, veuillez utiliser la méthode print_classes() comme suit :

namespace_object.print_classes()

Veuillez remplacer namespace_object par le nom de l'objet d'espace de noms à inspecter. Cette méthode imprime les classes disponibles sur la sortie standard.

Pour obtenir une liste des classes disponibles, veuillez utiliser la méthode classes() :

namespace_object.classes()

Cette méthode retourne une liste de chaînes.

Exemple 19.6. Répertorier les classes disponibles

Pour inspecter l'objet de l'espace de noms ns de l'objet de connexion créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms » et pour répertorier les classes disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> ns.print_classes()
CIM_CollectionInSystem
CIM_ConcreteIdentity
CIM_ControlledBy
CIM_DeviceSAPImplementation
CIM_MemberOfStatusCollection
...
>

Pour assigner une liste de ces classes à une variable nommée cimv2_classes, veuillez saisir :

> cimv2_classes = ns.classes()
>

Accéder aux objets de classe

Pour accéder à un objet de classe particulier qui est fourni par le CIMOM, veuillez utiliser la syntaxe suivante :

namespace_object.class_name

Veuillez remplacer namespace_object par le nom de l'objet d'espace de noms à inspecter et class_name par le nom de la classe à laquelle accéder.

Exemple 19.7. Accéder aux objets de classe

Pour accéder à la classe LMI_IPNetworkConnection de l'objet de l'espace de noms ns créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms » et l'assigner à une variable nommée cls, veuillez saisir ce qui suit dans l'invite interactive :

> cls = ns.LMI_IPNetworkConnection
>

Examiner les objets de classe

Tous les objets de classe stockent des informations sur leurs noms et sur l'espace de noms auquel ils appartiennent, ainsi qu'une documentation de classe détaillée. Pour obtenir le nom d'un objet de classe particulier, veuillez utiliser la syntaxe suivante :

class_object.classname

Veuillez remplacer class_object par le nom de l'objet de classe à inspecter. Une représentation par chaîne du nom de l'objet sera retournée.

Pour obtenir des informations sur l'espace de noms auquel un objet de classe appartient, veuillez utiliser :

class_object.namespace

Une représentation par chaîne de l'espace de noms sera retournée.

Pour afficher la documentation détaillée d'une classe, veuillez utiliser la méthode doc() comme suit :

class_object.doc()

Exemple 19.8. Examiner les objets de classe

Pour inspecter l'objet de classe cls créé dans l'Exemple 19.7, « Accéder aux objets de classe » et pour afficher son nom et son espace de noms correspondant, veuillez saisir ce qui suit dans l'invite interactive :

> cls.classname
'LMI_IPNetworkConnection'
> cls.namespace
'root/cimv2'
>

Pour accéder à la documentation des classes, veuillez saisir :

> cls.doc()
Class: LMI_IPNetworkConnection
    SuperClass: CIM_IPNetworkConnection
    [qualifier] string UMLPackagePath: 'CIM::Network::IP'

    [qualifier] string Version: '0.1.0'
...

Répertorier les méthodes disponibles

Pour répertorier toutes les méthodes disponibles pour un objet de classe particulier, veuillez utiliser la méthode print_methods(), comme suit :

class_object.print_methods()

Veuillez remplacer class_object par le nom de l'objet de classe à inspecter. Cette méthode imprime les méthodes disponibles sur la sortie standard.

Pour obtenir une liste des méthodes disponibles, veuillez utiliser la méthode methods() :

class_object.methods()

Cette méthode retourne une liste de chaînes.

Exemple 19.9. Répertorier les méthodes disponibles

Pour inspecter l'objet de classe cls créé dans l'Exemple 19.7, « Accéder aux objets de classe » et pour répertorier toutes les méthodes disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> cls.print_methods()
RequestStateChange
>

Pour assigner une liste de ces méthodes à une variable nommée service_methods, veuillez saisir :

> service_methods = cls.methods()
>

Répertorier les propriétés disponibles

Pour répertorier toutes les propriétés disponibles pour un objet de classe particulier, veuillez utiliser la méthode print_properties() comme suit :

class_object.print_properties()

Veuillez remplacer class_object par le nom de l'objet de classe à inspecter. Cette méthode imprime les propriétés disponibles dans la sortie standard.

Pour obtenir une liste des propriétés disponibles, veuillez utiliser la méthode properties() :

class_object.properties()

Cette méthode retourne une liste de chaînes.

Exemple 19.10. Répertorier les propriétés disponibles

Pour inspecter l'objet de classe cls créé dans l'Exemple 19.7, « Accéder aux objets de classe » et pour répertorier toutes les propriétés disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> cls.print_properties()
RequestedState
HealthState
StatusDescriptions
TransitioningToState
Generation
...
>

Pour assigner une liste de ces classes à une variable nommée service_properties, veuillez saisir :

> service_properties = cls.properties()
>

Répertorier et afficher les propriétés ValueMap

Les classes CIM peuvent contenir des propriétés ValueMap dans leur définition MOF (« Managed Object Format »). Les propriétés ValueMap contiennent des valeurs constantes, qui peuvent être utiles lorsque des méthodes sont appelées ou pendant la vérification des valeurs retournées.

Pour répertorier toutes les propriétés ValueMap disponibles pour un objet de classe particulier, veuillez utiliser la méthode print_valuemap_properties(), comme suit :

class_object.print_valuemap_properties()

Veuillez remplacer class_object par le nom de l'objet de classe à inspecter. Cette méthode imprime les propriétés ValueMap disponibles dans la sortie standard.

Pour obtenir une liste des propriétés ValueMap disponibles, veuillez utiliser la méthode valuemap_properties() :

class_object.valuemap_properties()

Cette méthode retourne une liste de chaînes.

Exemple 19.11. Répertorier les propriétés ValueMap

Pour inspecter l'objet de classe cls créé dans l'Exemple 19.7, « Accéder aux objets de classe » et pour répertorier toutes les propriétés ValueMap disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> cls.print_valuemap_properties()
RequestedState
HealthState
TransitioningToState
DetailedStatus
OperationalStatus
...
>

Pour assigner une liste de ces propriétés ValueMap à une variable nommée service_valuemap_properties, veuillez saisir :

> service_valuemap_properties = cls.valuemap_properties()
>

Pour accéder à une propriété ValueMap particulière, veuillez utiliser la syntaxe suivante :

class_object.valuemap_propertyValues

Veuillez remplacer valuemap_property par le nom de la propriété ValueMap à accéder.

Pour répertorier toutes les valeurs constantes, veuillez utiliser la méthode print_values(), comme suit :

class_object.valuemap_propertyValues.print_values()

Cette méthode imprime sur la sortie standard les valeurs constantes nommées disponibles. Vous pouvez également obtenir une liste des valeurs constantes disponibles en utilisant la méthode values() :

class_object.valuemap_propertyValues.values()

Cette méthode retourne une liste de chaînes.

Exemple 19.12. Accéder aux propriétés ValueMap

Exemple 19.11, « Répertorier les propriétés ValueMap » mentione une propriété ValueMap nommée RequestedState. Pour inspecter cette propriété et répertorier les valeurs constantes disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> cls.RequestedStateValues.print_values()
Reset
NoChange
NotApplicable
Quiesce
Unknown
...
>

Pour assigner une liste de ces valeurs constantes à une variable nommée requested_state_values, veuillez saisir :

> requested_state_values = cls.RequestedStateValues.values()
>

Pour accéder à une valeur constante en particulier, veuillez utiliser la syntaxe suivante :

class_object.valuemap_propertyValues.constant_value_name

Veuillez remplacer constant_value_name par le nom de la valeur constante. Alternativement, vous pouvez utiliser la méthode value() comme suit :

class_object.valuemap_propertyValues.value("constant_value_name")

Pour déterminer le nom d'une valeur constante particulière, veuillez utiliser la méthode value_name() :

class_object.valuemap_propertyValues.value_name("constant_value")

Cette méthode retourne une chaîne.

Exemple 19.13. Accéder à des valeurs constantes

L'Exemple 19.12, « Accéder aux propriétés ValueMap » montre que la propriété RequestedState fournit une valeur constante nommée Reset. Pour accéder à cette valeur constante nommée, veuillez saisir ce qui suit dans l'invite interactive :

> cls.RequestedStateValues.Reset
11
> cls.RequestedStateValues.value("Reset")
11
>

Pour déterminer le nom de cette valeur constante, veuillez saisir :

> cls.RequestedStateValues.value_name(11)
u'Reset'
>

Rechercher un objet CIMClass

De nombreuses méthodes de classe ne requièrent pas d'accès à un objet CIMClass, ce qui explique pourquoi LMIShell recherche uniquement cet objet dans le CIMOM lorsqu'une méthode appelée en a besoin. Pour rechercher l'objet CIMClass manuellement, veuillez utiliser la méthode fetch(), comme suit :

class_object.fetch()

Veuillez remplacer class_object par le nom de l'objet de classe. Remarquez que les méthodes qui requièrent un accès à l'objet CIMClass le recherchent automatiquement.

19.4.5. Utiliser des instances

Les instances LMIShell représentent des instances fournies par un CIMOM. Vous pouvez obtenir et définir leurs propriétés, les répertorier et appeler leurs méthodes, imprimer les chaînes de leur documentation, obtenir une liste d'objets associés ou d'objets d'association, envoyer les objets modifiés sur le CIMOM, et supprimer des instances individuelles à partir du CIMOM.

Accéder à des instances

Pour obtenir toutes les instances disponibles d'un objet de classe particulier, veuillez utiliser la méthode instances() comme suit :

class_object.instances()

Veuillez remplacer class_object par le nom de l'objet de classe à inspecter. Cette méthode retourne une liste d'objets LMIInstance.

Pour accéder à la première instance d'un objet de classe, veuillez utiliser la méthode first_instance() :

class_object.first_instance()

Cette méthode retourne un objet LMIInstance.

En plus de répertorier toutes les instances ou de retourner la première, instances() et first_instance() prennent en charge un argument optionnel vous permettant de filtrer les résultats :

class_object.instances(criteria)

class_object.first_instance(criteria)

Veuillez remplacer criteria par un dictionnaire consistant de paires de clés-valeurs, où les clés représentent les propriétés de l'instance et les valeurs représentent les valeurs de ces propriétés.

Exemple 19.14. Accéder à des instances

Pour trouver la première instance de l'objet de classe cls créé dans l'Exemple 19.7, « Accéder aux objets de classe » dont la propriété ElementName est égale à eth0 et pour l'assigner à une variable nommée device, veuillez saisir ce qui suit dans l'invite interactive :

> device = cls.first_instance({"ElementName": "eth0"})
>

Examiner des instances

Tous les objets d'instance stockent des informations sur leur nom de classe et sur l'espace de nom auquel ils appartiennent, ainsi qu'une documentation détaillée sur leurs propriétés et valeurs. En outre, les objets d'instance vous permettent de récupérer un objet d'identification unique.

Pour obtenir le nom de classe d'un objet d'instance particulier, veuillez utiliser la syntaxe suivante :

instance_object.classname

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Une représentation par chaîne du nom de la classe sera retournée.

Pour obtenir des informations sur l'espace de nom auquel un objet d'instance appartient, veuillez utiliser :

instance_object.namespace

Une représentation par chaîne de l'espace de noms sera retournée.

Pour récupérer un objet d'identification unique pour une objet d'instance, veuillez utiliser :

instance_object.path

Ceci retourne un objet LMIInstanceName.

Finalement, pour afficher la documentation détaillée, veuillez utiliser la méthode doc() comme suit :

instance_object.doc()

Exemple 19.15. Examiner des instances

Pour inspecter l'objet d'instance device créé dans l'Exemple 19.14, « Accéder à des instances » et pour afficher son nom de classe et son espace de nom correspondant, veuillez saisir ce qui suit dans l'invite interactive :

> device.classname
u'LMI_IPNetworkConnection'
> device.namespace
'root/cimv2'
>

Pour accéder à la documentation d'un objet d'instance, veuillez saisir :

> device.doc()
Instance of LMI_IPNetworkConnection
    [property] uint16 RequestedState = '12'

    [property] uint16 HealthState

    [property array] string [] StatusDescriptions
...

Créer de nouvelles instances

Certains fournisseurs de CIM autorisent la création de nouvelles instances d'objets de classe spécifiques. Pour créer une nouvelle instance d'un objet de classe, veuillez utiliser la méthode create_instance() comme suit :

class_object.create_instance(properties)

Veuillez remplacer class_object par le nom de l'objet de classe et properties par un dictionnaire consistant de paires clés-valeurs, où les clés représentent les propriétés de l'instance et les valeurs représentent les valeurs de ces propriétés. Cette méthode retourne un objet LMIInstance.

Exemple 19.16. Créer de nouvelles instances

La classe LMI_Group représente les groupes de système et la classe LMI_Account représente les comptes utilisateurs sur le système géré. Pour utiliser l'objet d'espace de noms ns créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms », veuillez créer des instances de ces deux classes pour le groupe de systèmes nommé pegasus et l'utilisateur nommé lmishell-user, et assignez-les aux variables nommées group et user, puis saisissez ce qui suit dans l'invite interactive :

> group = ns.LMI_Group.first_instance({"Name" : "pegasus"})
> user = ns.LMI_Account.first_instance({"Name" : "lmishell-user"})
>

Pour obtenir une instance de la classe LMI_Identity pour l'utilisateur lmishell-user, veuillez utiliser :

> identity = user.first_associator(ResultClass="LMI_Identity")
>

La classe LMI_MemberOfGroup représente l'adhésion au groupe de systèmes. Pour utiliser la classe LMI_MemberOfGroup pour ajouter lmishell-user au groupe pegasus, veuillez créer une nouvelle instance de cette classe comme suit :

> ns.LMI_MemberOfGroup.create_instance({
...     "Member" : identity.path,
...     "Collection" : group.path})
LMIInstance(classname="LMI_MemberOfGroup", ...)
>

Supprimer des instances individuelles

Pour supprimer une instance particulière du CIMOM, veuillez utiliser la méthode delete(), comme suit :

instance_object.delete()

Veuillez remplacer instance_object par le nom de l'objet d'instance à supprimer. Cette méthode retourne un booléen. Remarquez qu'après la suppression d'une instance, ses propriétés et méthodes seront inaccessibles.

Exemple 19.17. Supprimer des instances individuelles

La classe LMI_Account représente les comptes utilisateurs sur le système géré. Pour utiliser l'objet d'espace de noms ns créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms », veuillez créer une instance de la classe LMI_Account pour l'utilisateur nommé lmishell-user, et assignez-la à une variable nommée user, puis saisissez ce qui suit dans l'invite interactive :

> user = ns.LMI_Account.first_instance({"Name" : "lmishell-user"})
>

Pour supprimer cette instance et pour supprimer lmishell-user du système, veuillez saisir :

> user.delete()
True
>

Répertorier et accéder aux propriétés disponibles

Pour répertorier toutes les propriétés disponibles pour un objet d'instance particulier, veuillez utiliser la méthode print_properties(), comme suit :

instance_object.print_properties()

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Cette méthode imprime les propriétés disponibles dans la sortie standard.

Pour obtenir une liste des propriétés disponibles, veuillez utiliser la méthode properties() :

instance_object.properties()

Cette méthode retourne une liste de chaînes.

Exemple 19.18. Répertorier les propriétés disponibles

Pour inspecter l'objet d'instance device créé dans l'Exemple 19.14, « Accéder à des instances » et pour répertorier toutes les propriétés disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> device.print_properties()
RequestedState
HealthState
StatusDescriptions
TransitioningToState
Generation
...
>

Pour assigner une liste de ces propriétés à une variable nommée device_properties, veuillez saisir :

> device_properties = device.properties()
>

Pour obtenir la valeur actuelle d'une propriété particulière, veuillez utiliser la syntaxe suivante :

instance_object.property_name

Veuillez remplacer property_name par le nom de la propriété à accéder.

Pour modifier la valeur d'une propriété en particulier, assignez-lui une valeur comme suit :

instance_object.property_name = value

Veuillez remplacer value par la nouvelle valeur de la propriété. Remarquez qu'afin de propager le changement sur le CIMOM, vous devrez également exécuter la méthode push() :

instance_object.push()

Cette méthode retourne un tuple de trois éléments consistant d'une valeur de retour, de paramètres de valeur de retour, et d'une chaîne d'erreur.

Exemple 19.19. Accéder aux propriétés individuelles

Pour inspecter l'objet d'instance device créé dans l'Exemple 19.14, « Accéder à des instances » et pour afficher la valeur de la propriété nommée SystemName, veuillez saisir ce qui suit dans l'invite interactive :

> device.SystemName
u'server.example.com'
>

Répertorier et utiliser les méthodes disponibles

Pour répertorier toutes les méthodes disponibles pour un objet d'instance particulier, veuillez utiliser la méthode print_methods(), comme suit :

instance_object.print_methods()

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Cette méthode imprime les méthodes disponibles sur la sortie standard.

Pour obtenir une liste des méthodes disponibles, veuillez utiliser la méthode methods() :

instance_object.methods()

Cette méthode retourne une liste de chaînes.

Exemple 19.20. Répertorier les méthodes disponibles

Pour inspecter l'objet d'instance device créé dans l'Exemple 19.14, « Accéder à des instances » et pour répertorier toutes les méthodes disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> device.print_methods()
RequestStateChange
>

Pour assigner une liste de ces méthodes à une variable nommée network_device_methods, veuillez saisir :

> network_device_methods = device.methods()
>

Pour appeler une méthode particulière, veuillez utiliser la syntaxe suivante :

instance_object.method_name(
    parameter=value,
    ...)

Veuillez remplacer instance_object par le nom de l'objet d'instance à utiliser, method_name par le nom de la méthode à appeler, parameter par le nom du paramètre à définir, et value par la valeur de ce paramètre. Les méthodes retournent un tuple à trois éléments consistant d'une valeur de retour, de paramètres de retour, et d'une chaîne d'erreur.

Important

Les objets LMIInstance ne réactualisent pas automatiquement leur contenu (propriétés, méthodes, qualificateurs, et ainsi de suite). Pour cela, veuillez utiliser la méthode refresh() comme décrit ci-dessous.

Exemple 19.21. Utiliser des méthodes

La classe PG_ComputerSystem représente le système. Pour créer une instance de cette classe en utilisant l'objet d'espace de noms ns créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms » et pour l'assigner à une variable nommée sys, veuillez saisir ce qui suit dans l'invite interactive :

> sys = ns.PG_ComputerSystem.first_instance()
>

La classe LMI_AccountManagementService implémente les méthodes qui vous permettent de gérer des utilisateurs et des groupes dans le système. Pour créer une instance de cette classe et l'assigner à une variable nommée acc, veuillez saisir :

> acc = ns.LMI_AccountManagementService.first_instance()
>

Pour créer un nouvel utilisateur nommé lmishell-user dans le système, veuillez utiliser la méthode CreateAccount(), comme suit :

> acc.CreateAccount(Name="lmishell-user", System=sys)
LMIReturnValue(rval=0, rparams=NocaseDict({u'Account': LMIInstanceName(classname="LMI_Account"...), u'Identities': [LMIInstanceName(classname="LMI_Identity"...), LMIInstanceName(classname="LMI_Identity"...)]}), errorstr='')

LMIShell prend en charge les appels de méthodes synchrones : lorsqu'une méthode synchrone est utilisée, LMIShell attend que l'objet de la tâche correspondante change son état sur « finished », puis qu'il retourne les paramètres de retour de cette tâche. LMIShell est capable d'effectuer un appel de méthode synchrone si la méthode donnée retourne un objet de l'une des classes suivantes :

LMI_StorageJob
LMI_SoftwareInstallationJob
LMI_NetworkJob

LMIShell tente avant tout d'utiliser des indications comme la méthode d'attente. Si cela échoue, une méthode d'interrogation est utilisée à la place.

Pour effectuer un appel de méthode synchrone, veuillez utiliser la syntaxe suivante :

instance_object.Syncmethod_name(
    parameter=value,
    ...)

Veuillez remplacer instance_object par le nom de l'objet d'instance à utiliser, method_name par le nom de la méthode à appeler, parameter par le nom du paramètre à définir, et value par la valeur de ce paramètre. Toutes les méthodes synchrones contiennent le préfixe Sync dans leur nom et retournent un tuple à trois éléments consistant de la valeur de retour de la tâche, des paramètres de retour de la tâche, et de la chaîne d'erreur de celle-ci.

Vous pouvez également forcer LMIShell à utiliser une méthode d'interrogation uniquement. Pour faire cela, veuillez spécifier le paramètre PreferPolling, comme suit :

instance_object.Syncmethod_name(
    PreferPolling=True
    parameter=value,
    ...)

Répertorier et afficher les paramètres ValueMap

Les méthodes CIM peuvent contenir des paramètres ValueMap dans leur définition MOF (« Managed Object Format »). Les paramètres ValueMap contiennent des valeurs constantes.

Pour répertorier tous les paramètres ValueMap disponibles d'une méthode particulière, veuillez utiliser la méthode print_valuemap_parameters(), comme suit :

instance_object.method_name.print_valuemap_parameters()

Veuillez remplacer instance_object par le nom de l'objet d'instance et method_name par le nom de la méthode à inspecter. Cette méthode imprime les paramètres ValueMap disponibles sur la sortie standard.

Pour obtenir une liste des paramètres ValueMap disponibles, veuillez utiliser la méthode valuemap_parameters() :

instance_object.method_name.valuemap_parameters()

Cette méthode retourne une liste de chaînes.

Exemple 19.22. Répertorier les paramètres ValueMap

Pour inspecter l'objet d'instance acc créé dans l'Exemple 19.21, « Utiliser des méthodes » et pour répertorier tous les paramètres ValueMap disponibles de la méthode CreateAccount(), veuillez saisir ce qui suit dans l'invite interactive :

> acc.CreateAccount.print_valuemap_parameters()
CreateAccount
>

Pour assigner une liste de ces paramètres ValueMap à une variable nommée create_account_parameters, veuillez saisir :

> create_account_parameters = acc.CreateAccount.valuemap_parameters()
>

Pour accéder à un paramètre ValueMap particulier, veuillez utiliser la syntaxe suivante :

instance_object.method_name.valuemap_parameterValues

Veuillez remplacer valuemap_parameter par le nom du paramètre ValueMap à accéder.

Pour répertorier toutes les valeurs constantes, veuillez utiliser la méthode print_values(), comme suit :

instance_object.method_name.valuemap_parameterValues.print_values()

instance_object.method_name.valuemap_parameterValues.values()

Cette méthode retourne une liste de chaînes.

Exemple 19.23. Accéder aux paramètres ValueMap

L'Exemple 19.22, « Répertorier les paramètres ValueMap » mentionne un paramètre ValueMap nommé CreateAccount. Pour inspecter ce paramètre et répertorier les valeurs constantes disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> acc.CreateAccount.CreateAccountValues.print_values()
Operationunsupported
Failed
Unabletosetpasswordusercreated
Unabletocreatehomedirectoryusercreatedandpasswordset
Operationcompletedsuccessfully
>

Pour assigner une liste de ces valeurs constantes à une variable nommée create_account_values, veuillez saisir :

> create_account_values = acc.CreateAccount.CreateAccountValues.values()
>

Pour accéder à une valeur constante en particulier, veuillez utiliser la syntaxe suivante :

instance_object.method_name.valuemap_parameterValues.constant_value_name

Veuillez remplacer constant_value_name par le nom de la valeur constante. Alternativement, vous pouvez utiliser la méthode value() comme suit :

instance_object.method_name.valuemap_parameterValues.value("constant_value_name")

Pour déterminer le nom d'une valeur constante particulière, veuillez utiliser la méthode value_name() :

instance_object.method_name.valuemap_parameterValues.value_name("constant_value")

Cette méthode retourne une chaîne.

Exemple 19.24. Accéder à des valeurs constantes

L'Exemple 19.23, « Accéder aux paramètres ValueMap » montre que le paramètre ValueMap CreateAccount fournit une valeur constante nommée Failed. Pour accéder à cette valeur constante nommée, veuillez saisir ce qui suit dans l'invite interactive :

> acc.CreateAccount.CreateAccountValues.Failed
2
> acc.CreateAccount.CreateAccountValues.value("Failed")
2
>

Pour déterminer le nom de cette valeur constante, veuillez saisir :

> acc.CreateAccount.CreateAccountValues.value_name(2)
u'Failed'
>

Actualiser les objets d'instances

Les objets locaux utilisés par LMIShell, qui représentent des objets CIM du côté CIMOM, peuvent devenir obsolètes, si ceux-ci changent pendant leur utilisation avec les objets de LMIShell. Pour mettre à jour les propriétés et les méthodes d'un objet d'instance en particulier, veuillez utiliser la méthode refresh(), comme suit :

instance_object.refresh()

Veuillez remplacer instance_object par le nom de l'objet à actualiser. Cette méthode retourne un tuple de trois éléments consistant d'une valeur de retour, d'un paramètre de valeur de retour, et d'une chaîne d'erreur.

Exemple 19.25. Actualiser les objets d'instances

Pour mettre à jour les propriétés et méthodes de l'objet d'instance device créé dans l'Exemple 19.14, « Accéder à des instances », veuillez saisir ce qui suit dans l'invite interactive :

> device.refresh()
LMIReturnValue(rval=True, rparams=NocaseDict({}), errorstr='')
>

Afficher la représentation MOF

Pour afficher la représentation MOF (Format d'objet géré, « Managed Object Format ») d'un objet d'instance, veuillez utiliser la méthode tomof() comme suit :

instance_object.tomof()

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Cette méthode imprime la représentation MOF de l'objet sur la sortie standard.

Exemple 19.26. Afficher la représentation MOF

Pour afficher la représentation MOF de l'objet d'instance device créé dans l'Exemple 19.14, « Accéder à des instances », veuillez saisir ce qui suit dans l'invite interactive :

> device.tomof()
instance of LMI_IPNetworkConnection {
        RequestedState = 12;
        HealthState = NULL;
        StatusDescriptions = NULL;
        TransitioningToState = 12;
...

19.4.6. Utiliser des noms d'instance

Les noms d'instance LMIShell sont des objets contenant un ensemble de clés principales et leurs valeurs. Ce type d'objet identifie une instance de manière exacte.

Accéder aux noms d'instances

Les objets CIMInstance sont identifiés par des objets CIMInstanceName. Pour obtenir une liste de tous les objets des noms d'instances disponibles, veuillez utiliser la méthode instance_names(), comme suit :

class_object.instance_names()

Veuillez remplacer class_object par le nom de l'objet de classe à inspecter. Cette méthode retourne une liste d'objets LMIInstanceName.

Pour accéder au premier objet du nom d'instance d'un objet de classe, veuillez utiliser la méthode first_instance_name() :

class_object.first_instance_name()

Cette méthode retourne un objet LMIInstanceName.

En plus de répertorier tous les objets de noms d'instances ou de retourner le premier, instances_names() et first_instance_name() prennent en charge un argument optionnel vous permettant de filtrer les résultats :

class_object.instance_names(criteria)

class_object.first_instance_name(criteria)

Veuillez remplacer criteria par un dictionnaire consistant de paires de clés-valeurs, où les clés représentent les propriétés clés et les valeurs représentent les valeurs de ces propriétés clés.

Exemple 19.27. Accéder aux noms d'instances

Pour trouver le premier nom d'instance de l'objet de classe cls créé dans l'Exemple 19.7, « Accéder aux objets de classe » dont la propriété clé Name est égale à eth0 et pour l'assigner à une variable nommée device_name, veuillez saisir ce qui suit dans l'invite interactive :

> device_name = cls.first_instance_name({"Name": "eth0"})
>

Examiner des noms d'instance

Tous les objets de noms d'instances stockent des informations sur leurs noms de classe et sur l'espace de nom auquel ils appartiennent.

Pour obtenir le nom de classe d'un objet de nom d'instance particulier, veuillez utiliser la syntaxe suivante :

instance_name_object.classname

Veuillez remplacer instance_name_object par l'objet du nom d'instance à inspecter. Une représentation par chaîne du nom de la classe sera retournée.

Pour obtenir des informations sur l'espace de noms auquel un objet de nom d'instance appartient, veuillez utiliser :

instance_name_object.namespace

Une représentation par chaîne de l'espace de noms sera retournée.

Exemple 19.28. Examiner des noms d'instance

Pour inspecter l'objet du nom d'instance device_name créé dans l'Exemple 19.27, « Accéder aux noms d'instances » et pour afficher son nom de classe et son espace de nom correspondant, veuillez saisir ce qui suit dans l'invite interactive :

> device_name.classname
u'LMI_IPNetworkConnection'
> device_name.namespace
'root/cimv2'
>

Créer de nouveaux noms d'instance

LMIShell permet de créer un nouvel objet CIMInstanceName encapsulé (« wrapped ») si vous connaissez toutes les clés principales d'un objet distant. Cet objet de nom d'instance peut ensuite être utilisé pour récupérer l'objet d'instance entier.

Pour créer un nouveau nom d'instance d'un objet de classe, veuillez utiliser la méthode new_instance_name(), comme suit :

class_object.new_instance_name(key_properties)

Veuillez remplacer class_object par le nom de l'objet de classe et key_properties par un dictionnaire consistant de paires clés-valeurs, où les clés représentent les propriétés clés et les valeurs représentent les valeurs de ces propriétés clés. Cette méthode retourne un objet LMIInstanceName.

Exemple 19.29. Créer de nouveaux noms d'instance

La classe LMI_Account représente les comptes utilisateurs sur le système géré. Pour utiliser l'objet d'espace de noms ns créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms », et pour créer une nouvelle instance de la classe LMI_Account représentant l'utilisateur lmishell-user sur le système géré, veuillez saisir ce qui suit dans l'invite interactive :

> instance_name = ns.LMI_Account.new_instance_name({
...     "CreationClassName" : "LMI_Account",
...     "Name" : "lmishell-user",
...     "SystemCreationClassName" : "PG_ComputerSystem",
...     "SystemName" : "server"})
>

Répertorier et accéder aux propriétés clés

Pour répertorier toutes les propriétés clés disponibles pour un objet de nom d'instance particulier, veuillez utiliser la méthode print_key_properties(), comme suit :

instance_name_object.print_key_properties()

Veuillez remplacer instance_name_object par le nom de l'objet du nom d'instance à inspecter. Cette méthode imprime les propriétés clés dans la sortie standard.

Pour obtenir une liste des propriétés clés disponibles, veuillez utiliser la méthode key_properties() :

instance_name_object.key_properties()

Cette méthode retourne une liste de chaînes.

Exemple 19.30. Répertorier les propriétés clés disponibles

Pour inspecter l'objet du nom d'instance device_name créé dans l'Exemple 19.27, « Accéder aux noms d'instances » et pour répertorier toutes les propriétés clés disponibles, veuillez saisir ce qui suit dans l'invite interactive :

> device_name.print_key_properties()
CreationClassName
SystemName
Name
SystemCreationClassName
>

Pour assigner une liste de ces propriétés clés à une variable nommée device_name_properties, veuillez saisir :

> device_name_properties = device_name.key_properties()
>

Pour obtenir la valeur actuelle d'une propriété clé particulière, veuillez utiliser la syntaxe suivante :

instance_name_object.key_property_name

Veuillez remplacer key_property_name par le nom de la propriété clé à accéder.

Exemple 19.31. Accéder aux propriétés clés individuelles

Pour inspecter l'objet du nom d'instance device_name créé dans l'Exemple 19.27, « Accéder aux noms d'instances » et pour afficher la valeur de la propriété clé nommée SystemName, veuillez saisir ce qui suit dans l'invite interactive :

> device_name.SystemName
u'server.example.com'
>

Convertir des noms d'instances en instances

Chaque nom d'instance peut être converti en instance. Pour faire cela, veuillez utiliser la méthode to_instance() comme suit :

instance_name_object.to_instance()

Remplacer instance_name_object par l'objet du nom d'instance à convertir. Cette méthode retourne un objet LMIInstance.

Exemple 19.32. Convertir des noms d'instances en instances

Pour convertir l'objet du nom d'instance device_name créé dans l'Exemple 19.27, « Accéder aux noms d'instances » en objet d'instance et pour l'assigner à une variable nommée device, veuillez saisir ce qui suit dans l'invite interactive :

> device = device_name.to_instance()
>

19.4.7. Utiliser des objets associés

Le CIM (« Common Information Model », ou modèle d'informations communes) définit une relation d'association entre objets gérés.

Accéder à des instances associées

Pour obtenir une liste de tous les objets associés avec un objet d'instance particulier, veuillez utiliser la méthode associators() comme suit :

instance_object.associators(
    AssocClass=class_name,
    ResultClass=class_name,
    ResultRole=role,
    IncludeQualifiers=include_qualifiers,
    IncludeClassOrigin=include_class_origin,
    PropertyList=property_list)

Pour accéder au premier objet associé à un objet d'instance particulier, veuillez utiliser la méthode first_associator() :

instance_object.first_associator(
    AssocClass=class_name,
    ResultClass=class_name,
    ResultRole=role,
    IncludeQualifiers=include_qualifiers,
    IncludeClassOrigin=include_class_origin,
    PropertyList=property_list)

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Il est possible de filtrer les résultats en spécifiant les paramètres suivants :

AssocClass — chaque objet retourné doit être associé à l'objet source à travers une instance de cette classe ou de l'une de ses sous-classes. La valeur par défaut est None.
ResultClass — chaque objet retourné doit être une instance de cette classe ou de l'une de ses sous-classes, ou doit être cette classe ou l'une de ses sous-classes. La valeur par défaut est None.
Role — chaque objet retourné doit être associé à l'objet source à travers une association dans laquelle l'objet source joue le rôle spécifié. Le nom de la propriété dans la classe d'association faisant référence à l'objet source doit correspondre à la valeur de ce paramètre. La valeur par défaut est None.
ResultRole — chaque objet retourné doit être associé à l'objet source à travers une association pour laquelle l'objet retourné joue le rôle spécifié. Le nom de la propriété dans la classe d'association faisant référence à l'objet retourné doit correspondre à la valeur de ce paramètre. La valeur par défaut est None.

Les paramètres restants font référence à :

IncludeQualifiers — un booléen indiquant si les qualificateurs de chaque objet (y compris les qualificateurs de l'objet et de toute propriété retournée) doivent être inclus en tant qu'éléments « QUALIFIER » dans la réponse. La valeur par défaut est False.
IncludeClassOrigin — un booléen indiquant si l'attribut CLASSORIGIN doit être présent sur tous les éléments correspondants de chaque objet retourné. La valeur par défaut est False.
PropertyList — les membres de cette liste définissent un ou plusieurs noms de propriétés. Les objets retournés n'inclueront pas d'éléments pour toute propriété manquante à cette liste. Si PropertyList est une liste vide, aucune propriété ne sera incluse dans les objets retournés. Si None, aucun filtre supplémentaire ne sera défini. La valeur par défaut est None.

Exemple 19.33. Accéder à des instances associées

La classe LMI_StorageExtent représente les périphériques blocs disponibles sur le système. Pour utiliser l'objet d'espace de nom ns créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms », veuillez créer une instance de la classe LMI_StorageExtent pour le périphérique bloc nommé /dev/vda, et assignez-la à une variable nommée vda, puis saisissez ce qui suit dans l'invite interactive :

> vda = ns.LMI_StorageExtent.first_instance({
...     "DeviceID" : "/dev/vda"})
>

Pour obtenir une liste de toutes les partitions de disque de ce périphérique bloc et l'assigner à une variable nommée vda_partitions, veuillez utiliser la méthode associators() comme suit :

> vda_partitions = vda.associators(ResultClass="LMI_DiskPartition")
>

Accéder aux noms d'instances associés

Pour obtenir une liste des tous les noms d'instances associés d'un objet d'instance particulier, veuillez utiliser la méthode associator_names() comme suit :

instance_object.associator_names(
    AssocClass=class_name,
    ResultClass=class_name,
    Role=role,
    ResultRole=role)

Pour accéder au premier nom d'instance associé d'un objet d'instance particulier, veuillez utiliser la méthode first_associator_name() :

instance_object.first_associator_name(
    AssocClass=class_object,
    ResultClass=class_object,
    Role=role,
    ResultRole=role)

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Il est possible de filtrer les résultats en spécifiant les paramètres suivants :

AssocClass — chaque nom retourné identifie un objet devant être associé à l'objet source à travers une instance de cette classe ou de l'une de ses sous-classes. La valeur par défaut est None.
ResultClass — chaque nom retourné identifie un objet qui est une instance de cette classe ou l'une de ses sous-classes, ou qui doit être cette classe ou l'une de ses sous-classes. La valeur par défaut est None.
Role — chaque nom retourné identifie un objet devant être associé à l'objet source à travers une association dans laquelle l'objet source joue le rôle spécifié. Le nom de la propriété dans la classe d'association faisant référence à l'objet source doit correspondre à la valeur de ce paramètre. La valeur par défaut est None.
ResultRole — chaque nom retourné identifie un objet devant être associé à l'objet source à travers une association dans laquelle l'objet nommé retourné joue le rôle spécifié. Le nom de la propriété dans la classe d'association faisant référence à l'objet retourné doit correspondre à la valeur de ce paramètre. La valeur par défaut est None.

Exemple 19.34. Accéder aux noms d'instances associés

Pour utiliser l'objet d'instance vda créé dans l'Exemple 19.33, « Accéder à des instances associées », veuillez obtenir une liste de ses noms d'instances associés, puis assignez-la à une variable nommée vda_partitions, saisissez :

> vda_partitions = vda.associator_names(ResultClass="LMI_DiskPartition")
>

19.4.8. Utiliser des objets d'association

Le CIM (« Common Information Model », ou modèle d'informations communes) définit une relation d'association entre objets gérés. Les objets d'association définissent la relation entre deux objets.

Accéder à des instances d'association

Pour obtenir une liste d'objets d'association faisant référence à un objet cible particulier, veuillez utiliser la méthode references(), comme suit :

instance_object.references(
    ResultClass=class_name,
    Role=role,
    IncludeQualifiers=include_qualifiers,
    IncludeClassOrigin=include_class_origin,
    PropertyList=property_list)

Pour accéder au premier objet d'association faisant référence à un objet cible particulier, veuillez utiliser la méthode first_reference() :

instance_object.first_reference(
...     ResultClass=class_name,
...     Role=role,
...     IncludeQualifiers=include_qualifiers,
...     IncludeClassOrigin=include_class_origin,
...     PropertyList=property_list)
>

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Il est possible de filtrer les résultats en spécifiant les paramètres suivants :

ResultClass — chaque objet retourné doit être une instance de cette classe ou de l'une de ses sous-classes, ou doit être cette classe ou l'une de ses sous-classes. La valeur par défaut est None.
Role — chaque objet retourné doit faire référence à l'objet cible à travers une propriété avec un nom correspondant à la valeur de ce paramètre. La valeur par défaut est None.

Les paramètres restants font référence à :

IncludeQualifiers — un booléen indiquant si chaque objet (y compris les qualificateurs de l'objet et de toute propriété retournée) doit être inclus en tant qu'élément « QUALIFIER » dans la réponse. La valeur par défaut est False.
IncludeClassOrigin — un booléen indiquant si l'attribut CLASSORIGIN doit être présent sur tous les éléments correspondants de chaque objet retourné. La valeur par défaut est False.
PropertyList — les membres de cette liste définissent un ou plusieurs noms de propriété. Les objets retournés n'inclueront pas d'éléments pour toute propriété manquante de cette liste. Si PropertyList est une liste vide, aucune propriété ne sera incluse dans les objets retournés. Si None, aucun filtre supplémentaire ne sera défini. La valeur par défaut est None.

Exemple 19.35. Accéder à des instances d'association

La classe LMI_LANEndpoint représente un point de terminaison de communication associé à un certain périphérique d'interface réseau. Pour utiliser l'objet d'espace de noms ns créé dans l'Exemple 19.5, « Accéder aux objets d'espaces de noms », veuillez créer une instance de la classe LMI_LANEndpoint pour le périphérique d'interface réseau nommé eth0, et assignez-la à une variable nommée lan_endpoint, puis saisissez ce qui suit dans l'invite interactive :

> lan_endpoint = ns.LMI_LANEndpoint.first_instance({
...     "Name" : "eth0"})
>

Pour accéder au premier objet d'association faisant référence à un objet LMI_BindsToLANEndpoint et pour l'assigner à une variable nommée bind, veuillez saisir :

> bind = lan_endpoint.first_reference(
...     ResultClass="LMI_BindsToLANEndpoint")
>

Vous pouvez désormais utiliser la propriété Dependent pour accéder à la classe dépendante LMI_IPProtocolEndpoint qui représente l'adresse IP du périphérique de l'interface réseau correspondant :

> ip = bind.Dependent.to_instance()
> print ip.IPv4Address
192.168.122.1
>

Accéder aux noms d'instances d'associations

Pour obtenir une liste des noms d'instances d'associations d'un objet particulier, utiliser la méthode reference_names() comme suit :

instance_object.reference_names(
    ResultClass=class_name,
    Role=role)

Pour accéder au premier nom d'instance associé d'un objet d'instance particulier, veuillez utiliser la méthode first_reference_name() :

instance_object.first_reference_name(
    ResultClass=class_name,
    Role=role)

Veuillez remplacer instance_object par le nom de l'objet d'instance à inspecter. Il est possible de filtrer les résultats en spécifiant les paramètres suivants :

ResultClass — chaque objet retourné doit identifier une instance de cette classe ou de l'une de ses sous-classes, ou cette classe ou l'une de ses sous-classes. La valeur par défaut est None.
Role — chaque objet retourné doit identifier un objet ui se réfère à une instance cible à travers une propriété avec un nom correspondant à la valeur de ce paramètre. La valeur par défaut est None.

Exemple 19.36. Accéder aux noms d'instances d'associations

Pour utiliser l'objet d'instance Ian_endpoint créé dans l'Exemple 19.35, « Accéder à des instances d'association », accéder au premier nom d'instance d'association faisant référence à un objet LMI_BindsToLANEndpoint, et l'assigner à une variable nommée bind, veuillez saisir :

> bind = lan_endpoint.first_reference_name(
...     ResultClass="LMI_BindsToLANEndpoint")

> ip = bind.Dependent.to_instance()
> print ip.IPv4Address
192.168.122.1
>

19.4.9. Travailler avec des indications

Une indication est une réaction à un événement particulier qui se produit en réponse à un changement précis parmi les données. LMIShell peut être abonné à une indication pour recevoir des réponses pour de tels événements.

S'abonner à des indications

Pour s'abonner à une indication, veuillez utiliser la méthode subscribe_indication(), comme suit :

connection_object.subscribe_indication(
    QueryLanguage="WQL",
    Query='SELECT * FROM CIM_InstModification',
    Name="cpu",
    CreationNamespace="root/interop",
    SubscriptionCreationClassName="CIM_IndicationSubscription",
    FilterCreationClassName="CIM_IndicationFilter",
    FilterSystemCreationClassName="CIM_ComputerSystem",
    FilterSourceNamespace="root/cimv2",
    HandlerCreationClassName="CIM_IndicationHandlerCIMXML",
    HandlerSystemCreationClassName="CIM_ComputerSystem",
    Destination="http://host_name:5988")

Alternativement, vous pouvez utiliser une version plus courte de l'appel de méthode, comme suit :

connection_object.subscribe_indication(
    Query='SELECT * FROM CIM_InstModification',
    Name="cpu",
    Destination="http://host_name:5988")

Veuillez remplacer connection_object par un objet de connexion et un host_name ayant le nom d'hôte du système auquel vous souhaitez fournir les indications.

Par défaut, tous les abonnements créés par l'interprète LMIShell sont automatiquement supprimés lorsque l'interprète se ferme. Pour modifier ce comportement, transmettez le paramètre permanente = True à l'appel de méthode subscribe_indication(). Cela empêchera LMIShell de supprimer l'abonnement.

Exemple 19.37. S'abonner à des indications

Pour utiliser l'objet de connection c créé dans Exemple 19.1, « Connexion à un CIMOM distant » et pour vous abonner à une indication nommée cpu, veuillez saisir ce qui suit dans l'invite interactive :

> c.subscribe_indication(
...     QueryLanguage="WQL",
...     Query='SELECT * FROM CIM_InstModification',
...     Name="cpu",
...     CreationNamespace="root/interop",
...     SubscriptionCreationClassName="CIM_IndicationSubscription",
...     FilterCreationClassName="CIM_IndicationFilter",
...     FilterSystemCreationClassName="CIM_ComputerSystem",
...     FilterSourceNamespace="root/cimv2",
...     HandlerCreationClassName="CIM_IndicationHandlerCIMXML",
...     HandlerSystemCreationClassName="CIM_ComputerSystem",
...     Destination="http://server.example.com:5988")
LMIReturnValue(rval=True, rparams=NocaseDict({}), errorstr='')
>

Répertorier les indications abonnées

Pour répertorier toutes les indications auxquelles vous êtes abonnées, utiliser la méthode print_subscribed_indications(), comme suit :

connection_object.print_subscribed_indications()

Veuillez remplacer connection_object par le nom de l'objet de connexion à inspecter. Cette méthode affichera les indications auquelles vous êtes abonnées sur la sortie standard.

Pour obtenir une liste de toutes les indications auxquelles vous êtes abonnées, veuillez utiliser la méthode subscribed_indications() comme suit :

connection_object.subscribed_indications()

Cette méthode retourne une liste de chaînes.

Exemple 19.38. Répertorier les indications abonnées

Pour inspecter l'objet de connexion c créé dans l'Exemple 19.1, « Connexion à un CIMOM distant » et pour répertorier les indications abonnées, veuillez saisir ce qui suit dans l'invite interactive :

> c.print_subscribed_indications()
>

Pour assigner une liste de ces indications à une variable nommée indications, veuillez saisir :

> indications = c.subscribed_indications()
>

Se désabonner des indications

Par défaut, tous les abonnements créés par l'interprète LMIShell sont automatiquement supprimés lorsque l'interprète se ferme. Pour supprimer un abonnement individuel plus tôt, utilisez la méthode unsubscribe_indication() comme suit :

connection_object.unsubscribe_indication(indication_name)

Veuillez remplace connection_object par le nom de l'objet de connexion et indication_name par le nom de l'indication à supprimer.

Pour supprimer tous les abonnements, veuillez utiliser la méthode unsubscribe_all_indications() :

connection_object.unsubscribe_all_indications()

Exemple 19.39. Se désabonner des indications

Pour utiliser l'objet de connection c créé dans Exemple 19.1, « Connexion à un CIMOM distant » et pour vous désabonner de l'indication créée dans l' Exemple 19.37, « S'abonner à des indications », veuillez saisir ce qui suit dans l'invite interactive :

> c.unsubscribe_indication('cpu')
LMIReturnValue(rval=True, rparams=NocaseDict({}), errorstr='')
>

Implémenter un gestionnaire d'indications (« Indication Handler »)

La méthode subscribe_indication() vous permet de spécifier le nom d'hôte du système sur lequel vous souhaitez remettre les indications. L'exemple ci-dessous montre comment implémenter un gestionnaire d'indications :

> def handler(ind, arg1, arg2, **kwargs):
...     exported_objects = ind.exported_objects()
...     do_something_with(exported_objects)
> listener = LmiIndicationListener("0.0.0.0", listening_port)
> listener.add_handler("indication-name-XXXXXXXX", handler, arg1, arg2, **kwargs)
> listener.start()
>

Le premier argument du gestionnaire est un objet LmiIndication, qui contient une liste de méthodes et d'objets exportés par l'indication. D'autres paramètres sont spécifiques à l'utilisateur : ces arguments devront être spécifiés lors de l'ajout d'un gestionnaire au listener.

Dans l'exemple ci-dessus, l'appel de la méthode add_handler() utilise une chaîne spéciale avec huit caractères « X ». Ces caractères sont remplacés par une chaîne aléatoire générée par des listeners afin d'éviter une collision possible de noms de gestionnaire. Pour utiliser la chaîne aléatoire, commencez par lancer le listener d'indications, puis abonnez-vous à une indication afin que la propriété Destination de l'objet du gestionnaire contienne la valeur suivante : schema://host_name/random_string.

Exemple 19.40. Implémenter un gestionnaire d'indications (« Indication Handler »)

Le script suivant illustre comment écrire un gestionnaire qui surveille un système géré se trouvant sur 192.168.122.1 et qui appelle la fonction indication_callback() lorsqu'un nouveau compte utilisateur est créé :

#!/usr/bin/lmishell

import sys
from time import sleep
from lmi.shell.LMIUtil import LMIPassByRef
from lmi.shell.LMIIndicationListener import LMIIndicationListener

# These are passed by reference to indication_callback
var1 = LMIPassByRef("some_value")
var2 = LMIPassByRef("some_other_value")

def indication_callback(ind, var1, var2):
    # Do something with ind, var1 and var2
    print ind.exported_objects()
    print var1.value
    print var2.value

c = connect("hostname", "username", "password")

listener = LMIIndicationListener("0.0.0.0", 65500)
unique_name = listener.add_handler(
    "demo-XXXXXXXX",     # Creates a unique name for me
    indication_callback, # Callback to be called
    var1,                # Variable passed by ref
    var2                 # Variable passed by ref
)

listener.start()

print c.subscribe_indication(
    Name=unique_name,
    Query="SELECT * FROM LMI_AccountInstanceCreationIndication WHERE SOURCEINSTANCE ISA LMI_Account",
    Destination="192.168.122.1:65500"
)

try:
    while True:
        sleep(60)
except KeyboardInterrupt:
    sys.exit(0)

19.4.10. Exemple d'utilisation

Cette section fournit un certain nombre d'exemples de divers fournisseurs CIM distribués avec les paquets OpenLMI. Tous les exemples de cette section utilisent les deux définitions de variables suivantes :

c = connect("host_name", "user_name", "password")
ns = c.root.cimv2

Utiliser le fournisseur du service OpenLMI

Le paquet openlmi-service installe un fournisseur CIM pour gérer les services système. Les exemples ci-dessous illustrent comment utiliser ce fournisseur CIM pour répertorier les services système disponibles et comment les lancer, les arrêter, les activer, et les désactiver.

Exemple 19.41. Répertorier les services disponibles

Pour répertorier tous les services disponibles sur la machine gérée, ainsi que pour des informations indiquant si le service a été lancé (TRUE) ou est arrêté (FALSE), et la chaîne de statut, veuillez utiliser l'extrait de code suivant :

for service in ns.LMI_Service.instances():
    print "%s:\t%s" % (service.Name, service.Status)

Pour uniquement répertorier les services activés par défaut, veuillez utiliser l'extrait de code suivant :

cls = ns.LMI_Service
for service in cls.instances():
    if service.EnabledDefault == cls.EnabledDefaultValues.Enabled:
        print service.Name

Remarquez que la valeur de la propriété EnabledDefault est égale à 2 pour les services activés et à 3 pour les services désactivés.

Pour afficher les informations concernant le service cups, veuillez utiliser :

cups = ns.LMI_Service.first_instance({"Name": "cups.service"})
cups.doc()

Exemple 19.42. Lancer et arrêter des services

Pour lancer et arrêter le service cups et pour afficher son statut actuel, veuillez utiliser l'extrait de code suivant :

cups = ns.LMI_Service.first_instance({"Name": "cups.service"})
cups.StartService()
print cups.Status
cups.StopService()
print cups.Status

Exemple 19.43. Activer et désactiver des services

Pour activer et désactiver le service cups et pour afficher sa propriété EnabledDefault, veuillez utiliser l'extrait de code suivant :

cups = ns.LMI_Service.first_instance({"Name": "cups.service"})
cups.TurnServiceOff()
print cups.EnabledDefault
cups.TurnServiceOn()
print cups.EnabledDefault

Utiliser le fournisseur réseau OpenLMI

Le paquet openlmi-networking installe un fournisseur CIM pour la mise en réseau. Les exemples ci-dessous illustrent comment utiliser ce fournisseur CIM pour répertorier les adresses IP associées à un certain numéro de port, créer une nouvelle connexion, configurer une adresse IP statique, et activer une connexion.

Exemple 19.44. Répertorier les adresses IP associées à un numéro de port donné

Pour répertorier toutes les adresses associées à l'interface réseau eth0, veuillez utiliser l'extrait de code suivant :

device = ns.LMI_IPNetworkConnection.first_instance({'ElementName': 'eth0'})
for endpoint in device.associators(AssocClass="LMI_NetworkSAPSAPDependency", ResultClass="LMI_IPProtocolEndpoint"):
    if endpoint.ProtocolIFType == ns.LMI_IPProtocolEndpoint.ProtocolIFTypeValues.IPv4:
        print "IPv4: %s/%s" % (endpoint.IPv4Address, endpoint.SubnetMask)
    elif endpoint.ProtocolIFType == ns.LMI_IPProtocolEndpoint.ProtocolIFTypeValues.IPv6:
        print "IPv6: %s/%d" % (endpoint.IPv6Address, endpoint.IPv6SubnetPrefixLength)

Cet extrait de code utilise la classe LMI_IPProtocolEndpoint associée à une classe LMI_IPNetworkConnection donnée.

Pour afficher la passerelle par défaut, veuillez utiliser l'extrait de code suivant :

for rsap in device.associators(AssocClass="LMI_NetworkRemoteAccessAvailableToElement", ResultClass="LMI_NetworkRemoteServiceAccessPoint"):
    if rsap.AccessContext == ns.LMI_NetworkRemoteServiceAccessPoint.AccessContextValues.DefaultGateway:
        print "Default Gateway: %s" % rsap.AccessInfo

La passerelle par défaut est représentée par une instance LMI_NetworkRemoteServiceAccessPoint dont la propriété AccessContext est égale à DefaultGateway.

Pour obtenir une liste de serveurs DNS, le modèle de l'objet doit être traversé comme suit :

Obtenez les instances LMI_IPProtocolEndpoint associées avec LMI_IPNetworkConnection en utilisant LMI_NetworkSAPSAPDependency.
Utilisez la même association pour les instances LMI_DNSProtocolEndpoint.

Les instances LMI_NetworkRemoteServiceAccessPoint dont la propriété AccessContext est égale au serveur DNS associé à travers LMI_NetworkRemoteAccessAvailableToElement possèdent l'adresse du serveur DNS dans la propriété AccessInfo.

Il peut y avoir davantage de chemins possibles vers RemoteServiceAccessPath et les entrées peuvent être dupliquées. L'extrait de code suivant utilise la fonction set() pour supprimer les entrées dupliquées de la liste des serveurs DNS :

dnsservers = set()
for ipendpoint in device.associators(AssocClass="LMI_NetworkSAPSAPDependency", ResultClass="LMI_IPProtocolEndpoint"):
    for dnsedpoint in ipendpoint.associators(AssocClass="LMI_NetworkSAPSAPDependency", ResultClass="LMI_DNSProtocolEndpoint"):
        for rsap in dnsedpoint.associators(AssocClass="LMI_NetworkRemoteAccessAvailableToElement", ResultClass="LMI_NetworkRemoteServiceAccessPoint"):
            if rsap.AccessContext == ns.LMI_NetworkRemoteServiceAccessPoint.AccessContextValues.DNSServer:
                dnsservers.add(rsap.AccessInfo)
print "DNS:", ", ".join(dnsservers)

Exemple 19.45. Créer une nouvelle connexion et configurer une adresse IP statique

Pour créer un nouveau paramètre avec une configuration IPv4 statique et IPv6 stateless pour l'interface réseau eth0, veuillez utiliser l'extrait de code suivant :

capability = ns.LMI_IPNetworkConnectionCapabilities.first_instance({ 'ElementName': 'eth0' })
result = capability.LMI_CreateIPSetting(Caption='eth0 Static',
        IPv4Type=capability.LMI_CreateIPSetting.IPv4TypeValues.Static,
        IPv6Type=capability.LMI_CreateIPSetting.IPv6TypeValues.Stateless)
setting = result.rparams["SettingData"].to_instance()
for settingData in setting.associators(AssocClass="LMI_OrderedIPAssignmentComponent"):
    if setting.ProtocolIFType == ns.LMI_IPAssignmentSettingData.ProtocolIFTypeValues.IPv4:
        # Set static IPv4 address
        settingData.IPAddresses = ["192.168.1.100"]
        settingData.SubnetMasks = ["255.255.0.0"]
        settingData.GatewayAddresses = ["192.168.1.1"]
        settingData.push()

Cet extrait de code crée un nouveau paramètre en appelant la méthode LMI_CreateIPSetting() sur l'instance de LMI_IPNetworkConnectionCapabilities, qui est associée avec LMI_IPNetworkConnection à travers LMI_IPNetworkConnectionElementCapabilities. Il utilise également la méthode push() pour modifier le paramètre.

Exemple 19.46. Activer une connexion

Pour appliquer un paramètre à l'interface réseau, veuillez appeler la méthode ApplySettingToIPNetworkConnection() de la classe LMI_IPConfigurationService. Cette méthode est asynchrone et retourne une tâche. Les extraits de code suivants illustrent comment appeler cette méthode de manière synchrone :

setting = ns.LMI_IPAssignmentSettingData.first_instance({ "Caption": "eth0 Static" })
port = ns.LMI_IPNetworkConnection.first_instance({ 'ElementName': 'ens8' })
service = ns.LMI_IPConfigurationService.first_instance()
service.SyncApplySettingToIPNetworkConnection(SettingData=setting, IPNetworkConnection=port, Mode=32768)

Le paramètre Mode affecte la manière dont le paramètre est appliqué. Les valeurs les plus couramment utilisées de ce paramètre sont comme suit :

1 — applique le paramètre immédiatement et le rend automatiquement actif.
2 — rend le paramètre automatiquement actif mais ne l'applique pas immédiatement.
4 — déconnecte et désactive l'activation automatique.
5 — ne modifie pas l'état du paramètre, désactive uniquement l'activation automatique.
32768 — applique le paramètre.
32769 — déconnexion.

Utiliser le fournisseur de stockage OpenLMI

Le paquet openlmi-storage installe un fournisseur CIM pour la gestion du stockage. Les exemples ci-dessous illustrent comment utiliser ce fournisseur CIM pour créer un groupe de volumes, un volume logique, un système de fichiers, pour monter un système de fichiers, et pour répertorier les périphériques blocs connus par le système.

En plus des variables c et ns, ces exemples utilisent les définitions de variables suivantes :

MEGABYTE = 1024*1024
storage_service = ns.LMI_StorageConfigurationService.first_instance()
filesystem_service = ns.LMI_FileSystemConfigurationService.first_instance()

Exemple 19.47. Créer un groupe de volumes

Pour créer un nouveau groupe de volumes se trouvant dans /dev/myGroup/ qui possède trois membres et une taille d'extension par défaut de 4 Mo, veuillez utiliser l'extrait de code suivant :

# Find the devices to add to the volume group
# (filtering the CIM_StorageExtent.instances()
# call would be faster, but this is easier to read):
sda1 = ns.CIM_StorageExtent.first_instance({"Name": "/dev/sda1"})
sdb1 = ns.CIM_StorageExtent.first_instance({"Name": "/dev/sdb1"})
sdc1 = ns.CIM_StorageExtent.first_instance({"Name": "/dev/sdc1"})

# Create a new volume group:
(ret, outparams, err) = storage_service.SyncCreateOrModifyVG(
        ElementName="myGroup",
        InExtents=[sda1, sdb1, sdc1])
vg = outparams['Pool'].to_instance()
print "VG", vg.PoolID, \
        "with extent size", vg.ExtentSize, \
        "and",  vg.RemainingExtents, "free extents created."

Exemple 19.48. Créer un volume logique

Pour créer deux volumes logiques avec une taille de 100 Mo, veuillez utiliser cet extrait de code :

# Find the volume group:
vg = ns.LMI_VGStoragePool.first_instance({"Name": "/dev/mapper/myGroup"})

# Create the first logical volume:
(ret, outparams, err) = storage_service.SyncCreateOrModifyLV(
        ElementName="Vol1",
        InPool=vg,
        Size=100 * MEGABYTE)
lv = outparams['TheElement'].to_instance()
print "LV", lv.DeviceID, \
        "with", lv.BlockSize * lv.NumberOfBlocks,\
        "bytes created."

# Create the second logical volume:
(ret, outparams, err) = storage_service.SyncCreateOrModifyLV(
        ElementName="Vol2",
        InPool=vg,
        Size=100 * MEGABYTE)
lv = outparams['TheElement'].to_instance()
print "LV", lv.DeviceID, \
        "with", lv.BlockSize * lv.NumberOfBlocks, \
        "bytes created."

Exemple 19.49. Créer un système de fichiers

Pour créer un système de fichiers ext3 sur un volume logique lv selon l'Exemple 19.48, « Créer un volume logique », veuillez utiliser l'extrait de code suivant :

(ret, outparams, err) = filesystem_service.SyncLMI_CreateFileSystem(
        FileSystemType=filesystem_service.LMI_CreateFileSystem.FileSystemTypeValues.EXT3,
        InExtents=[lv])

Exemple 19.50. Monter un système de fichiers

Pour monter le système de fichier créé dans l'Exemple 19.49, « Créer un système de fichiers », veuillez utiliser l'extrait de code suivant :

# Find the file system on the logical volume:
fs = lv.first_associator(ResultClass="LMI_LocalFileSystem")

mount_service = ns.LMI_MountConfigurationService.first_instance()
(rc, out, err) = mount_service.SyncCreateMount(
     FileSystemType='ext3',
     Mode=32768, # just mount
     FileSystem=fs,
     MountPoint='/mnt/test',
     FileSystemSpec=lv.Name)

Exemple 19.51. Répertorier les périphériques blocs

Pour répertorier tous les périphériques blocs connus par le système, veuillez utiliser l'extrait de code suivant :

devices = ns.CIM_StorageExtent.instances()
for device in devices:
    if lmi_isinstance(device, ns.CIM_Memory):
        # Memory and CPU caches are StorageExtents too, do not print them
        continue
    print device.classname,
    print device.DeviceID,
    print device.Name,
    print device.BlockSize*device.NumberOfBlocks

Utiliser le fournisseur de matériel OpenLMI

Le paquet openlmi-hardware installe un fournisseur CIM pour surveiller le matériel. Les exemples ci-dessous illustrent comment utiliser ce fournisseur CIM pour récupérer des informations sur le CPU, les modules de mémoire, les périphériques PCI, et sur le constructeur et le modèle de la machine.

Exemple 19.52. Afficher les informations du CPU

Pour afficher les informations de base du CPU, comme le nom du CPU, le nombre de cœurs du processeur, et le nombre de threads de matériel, veuillez utiliser l'extrait de code suivant :

cpu = ns.LMI_Processor.first_instance()
cpu_cap = cpu.associators(ResultClass="LMI_ProcessorCapabilities")[0]
print cpu.Name
print cpu_cap.NumberOfProcessorCores
print cpu_cap.NumberOfHardwareThreads

Exemple 19.53. Afficher les informations de mémoire

Pour afficher des informations de base sur les modules de mémoire, comme leur taille individuelle, veuillez utiliser l'extrait de code suivant :

mem = ns.LMI_Memory.first_instance()
for i in mem.associators(ResultClass="LMI_PhysicalMemory"):
    print i.Name

Exemple 19.54. Afficher les informations du châssis

Pour afficher des informations de base sur la machine, comme son fabricant ou son modèle, veuillez utiliser l'extrait de code suivant :

chassis = ns.LMI_Chassis.first_instance()
print chassis.Manufacturer
print chassis.Model

Exemple 19.55. Répertorier les périphériques PCI

Pour répertorier tous les périphériques PCI connus par le système, veuillez utiliser l'extrait de code suivant :

for pci in ns.LMI_PCIDevice.instances():
    print pci.Name

19.4. Utiliser LMIShell

19.4.1. Lancer, utiliser, et quitter LMIShell

Lancer le LMIShell en mode interactif

Utiliser la saisie semi-automatique avec la touche « Tab »

Historique de navigation

Gestion des exceptions

Configurer un cache temporaire

Quitter LMIShell

Exécuter un script LMIShell

19.4.2. Connexion à un CIMOM

Connexion à un CIMOM distant

Connexion à un CIMOM local

Vérifier une connexion sur un CIMOM

19.4.3. Utiliser des espaces de noms

Répertorier les espaces de noms disponibles

Accéder aux objets d'espaces de noms

19.4.4. Utiliser des classes

Répertorier les classes disponibles

Accéder aux objets de classe

Examiner les objets de classe

Répertorier les méthodes disponibles

Répertorier les propriétés disponibles

Répertorier et afficher les propriétés ValueMap

Rechercher un objet CIMClass

19.4.5. Utiliser des instances

Accéder à des instances

Examiner des instances

Créer de nouvelles instances

Supprimer des instances individuelles

Répertorier et accéder aux propriétés disponibles

Répertorier et utiliser les méthodes disponibles

Répertorier et afficher les paramètres ValueMap

Actualiser les objets d'instances

Afficher la représentation MOF

19.4.6. Utiliser des noms d'instance

Accéder aux noms d'instances

Examiner des noms d'instance

Créer de nouveaux noms d'instance

Répertorier et accéder aux propriétés clés

Convertir des noms d'instances en instances

19.4.7. Utiliser des objets associés

Accéder à des instances associées

Accéder aux noms d'instances associés

19.4.8. Utiliser des objets d'association

Accéder à des instances d'association

Accéder aux noms d'instances d'associations

19.4.9. Travailler avec des indications

S'abonner à des indications

Répertorier les indications abonnées

Se désabonner des indications

Implémenter un gestionnaire d'indications (« Indication Handler »)

19.4.10. Exemple d'utilisation

Utiliser le fournisseur du service OpenLMI

Utiliser le fournisseur réseau OpenLMI

Utiliser le fournisseur de stockage OpenLMI

Utiliser le fournisseur de matériel OpenLMI

Apprendre

Essayez, achetez et vendez

Communautés

À propos de la documentation Red Hat

Rendre l’open source plus inclusif

À propos de Red Hat

Red Hat legal and privacy links

Red Hat legal and privacy links