Interface de ligne de commande du CADSMCMD › La commande cadsmcmd › barre verticale

barre verticale

L'interface en mode canal offre l'avantage d'un traitement par lot et d'une invocation de commande directe, c'est à dire la possibilité d'exécuter plusieurs commandes au cours d'une session entre la CLI et le gestionnaire comme avec l'option lot mais d'un autre côté, un script a la possibilité de traiter la sortie de commande avant de lancer la commande de CLI suivante. L'interface de canal est activée par le mot-clé pipe suivi du nom du canal que la CLI doit écouter. Le canal spécifié est un canal nommé sous Windows alors que c'est un fichier fifo sous Linux. Dans tous les cas, la CLI fonctionne en tant que canal client, ce qui signifie que le canal doit être créé et administré par le script d'appel. Lorsqu'elle est appelée pour un traitement via l'interface en mode canal, la CLI établit la connexion au gestionnaire spécifié avec les informations d'identification spécifiées et enregistre le résultat dans stdout. Lorsque la session est établie, la CLI écoute le canal à la recherche de toute commande à traiter. Lorsqu'elle reçoit une commande, la CLI la traite et enregistre ses résultats dans stdout. Une fois la commande traitée, la CLI recommence à écouter à la recherche de la commande suivante. A la différence du mode de traitement par lot, la CLI revient toujours au canal en mode canal, que le traitement d'une commande ait réussi ou échoué. La session entre la CLI et le gestionnaire ne s'arrête pas en cas d'échec d'une commande. Ce comportement est le même qu'en mode de traitement par lot avec SDCMD_CONTINUE=ON.

Pour faciliter la communication et la synchronisation entre la CLI et le script de lancement, la CLI fournit certaines accroches visuelles qui indiquent la fin d'un traitement par la CLI et que cette dernière recommence à écouter le canal.

Au démarrage de la CLI en mode canal, celle-ci lance dans stdout le message

*** SDCMD: Line up ***

lorsque la session avec le gestionnaire est établie et que la CLI commence à écouter le canal. A partir de là, un script peut commencer à envoyer des commandes à la CLI via le canal. La fin du traitement d'une commande est elle aussi signalée par une accroche visuelle spécifique. Chaque fois qu'une commande se termine, réussie ou non, la CLI émet le message suivant dans stdout :

### SDCMD: -eoc ###

Lorsqu'un script détecte cette chaîne, il sait que la commande qu'il a lancée s'est terminée et toutes les sorties de toutes les commandes sont écrites dans stdout.

Les commandes qui doivent être envoyées par une application via le canal présentent le même format que les fichiers de commandes. Le tampon des commandes écrit et transmis au canal par l'application doit contenir la commande complète à exécuter. Il est impossible de répartir une commande entre plusieurs tampons d'envoi.

Par contre, il est possible d'envoyer plusieurs commandes dans un seul tampon. Dans ce cas, les commandes doivent être séparées par la chaîne suivante :

-eoc

La session entre la CLI en mode canal et le gestionnaire s'arrête dès que la CLI reçoit la chaîne

-quit

via le canal.

L'interface en mode canal est appelée dans la CLI en codant le mot-clé pipe suivi du nom du canal (nomcanal) que la CLI utilise pour recevoir les commandes qu'elle doit traiter. Il doit y avoir au moins un espace vide entre le mot clé et le nomcanal.

L'exemple suivant illustre l'utilisation de l'interface en mode canal sous Linux. Le script répertorie tous les ordinateurs cibles (targetComputers) enregistrés dans USD et tous les produits enregistrés dans la bibliothèque de logiciels USD.

#! /usr/bin/sh
proto ()
{
	aa=" "
	bb=`echo "$aa" | grep "SDCMD: Line up"`
	while [ -z "$bb" ]
	procédez
		read aa
		bb=`echo "$aa" | grep "SDCMD: Line up"`
		if [ -z "$bb" ]
		alors
			echo "$aa"
		fi
	done
}
prot ()
{
	aa=" "
	bb=`echo "$aa" | grep "SDCMD: -eoc"`
	while [ -z "$bb" ]
	procédez
		read aa
		bb=`echo "$aa" | grep "SDCMD: -eoc"`
		if [ -z "$bb" ]
		alors
			echo "$aa"
		fi
	done
}

mkfifo /ca_dsmcmd_in
mkfifo /ca_dsmcmd_out
{
	cadsmcmd pipe /ca_dsmcmd_in > /ca_dsmcmd_out &
	proto
	echo "targetComputer action=list -eoc" > /ca_dsmcmd_in
	prot
	N°
	#  stocker la liste renvoyée et la traiter
	N°
	#     ...
	N°
	#  commande suivante
	echo "swLibrary action=list -eoc" > /ca_dsmcmd_in
	prot
	N°
	#  stocker la liste renvoyée et la traiter
	N°
	#     ...
	N°
	# terminer la session
	echo "-quit" > /ca_dsmcmd_in
} < /ca_dsmcmd_out
rm /ca_dsmcmd_*

L'exemple fourni est constitué de deux routines et de la partie principale. La routine proto () déclenche ### SDCMD: Line up ###, signalant que l'interface en mode canal est en cours d'exécution et attend des commandes. La routine prot (), quant à elle, déclenche “### SDCMD: -eoc ###, signalant le traitement complet d'une commande.

La partie principale crée d'abord deux canaux. Le canal “/ca_dsmcmd_in” est utilisé par la CLI comme canal d'entrée, ce qui veut dire que la CLI reçoit les commandes à traiter via ce canal. Le second canal “/ca_dsmcmd_out” est utilisé pour rediriger la sortie standard stdout de la CLI vers le script afin que ce dernier puisse traiter les résultats. Une fois ces canaux créés, un bloc commence par lancer la CLI en mode canal depuis le mode de traitement par lot, lance ensuite deux commandes de liste pour targetComputer et swLibrary, puis termine la session. Ce bloc reçoit ses entrées depuis le canal “/ca_dsmcmd_out” qui enregistre les sorties de la CLI. Il est fortement recommandé de conserver ce canal ouvert pour le script pendant toute la durée de vie de la CLI. C'est la raison pour laquelle il est affecté en tant d'entrée pour ce bloc. Si, par exemple, ce canal est seulement affecté comme entrée des procédures proto et prot, l'utilisateur risque de rencontrer des problèmes d'exécution pouvant mener à la perte de données et à la suspension de ses sessions.

Après le démarrage de la CLI en mode canal depuis le mode de taitement par lot, la routine proto sert de déclencheur pour que la CLI soit prête à l'action. Lorsque cette routine revient, le script démarre l'action list pour targetComputer, puis utilise la routine prot pour déterminer la fin du traitement de la commande. Il est possible de rediriger la sortie de cette routine prot vers un fichier pour en permettre le traitement ultérieur par un autre script. Ensuite, l'action liste est de lancée pour swLibrary et la routine prot est de nouveau utilisée pour déterminer la fin du traitement de la commande. Là encore, il est possible de rediriger la sortie de la routine prot vers un fichier pour en permettre le traitement ultérieur par un autre script. Pour finir, le bloc est terminé en arrêtant la CLI à l'aide de -quit.

La dernière ligne du script est destinée à la maintenance et au nettoyage des canaux.

L'exemple suivant effectue la même opération que l'exemple précédent, mais utilise Script DM et s'applique à Windows.

Dim hPipeIn, hPipeOut As Integer
Dim pipeIn, pipeOut As String
Dim command_1, command_2, eoc, eop, lineUp, endOfCommand, buffer As String

' ************************************************************************
' Effacer l'écran
ClrScr()

' ************************************************************************
' définition des constantes
eoc = " -eoc"
eop = "-quit"
command_1 = "targetComputer action=list" + eoc
command_2 = "swLibrary action=list" + eoc
lineUp = "SDCMD: Line up"
endOfCommand = "SDCMD: -eoc"

pipeIn ="\\.\pipe\ca_dsmcmd_in"
pipeOut ="\\.\pipe\ca_dsmcmd_out"

' ************************************************************************
' Créer le canal d'entrée de la CLI
hPipeIn = CreatePipe(pipeIn, O_WRITE)
If (hPipeIn = -1) Then
	MsgBox("Open pipe """ + pipeIn + """ failed.", "Pipe test", MB_OK + 					MB_ICONSTOP + MB_SETFOREGROUND)
	quitter
EndIf

' ************************************************************************
' Créer le canal de sortie de la CLI
hPipeOut = CreatePipe(pipeOut, O_READ)
If (hPipeOut = -1) Then
	MsgBox("Ouverture de canal """ + pipeOut + """ en échec.", "test canal", MB_OK + MB_ICONSTOP + MB_SETFOREGROUND) 
	CloseFile(hPipeIn)
	quitter
EndIf

' ************************************************************************
' Lancer cadsmcmd en mode canal en utilisant pipeIn comme canal d'entrée et en redirigeant
‘ stdout vers pipeOut
Execute("cmd /c ""cadsmcmd pipe " + pipeIn + " > " + pipeOut + """", 					FALSE, 0)
While (TRUE)
	If (Not(ReadFile(hPipeOut, buffer))) Then
		MsgBox("Read from pipe """ + pipeOut + """ failed.", "Pipe test", 					MB_OK + MB_ICONSTOP + MB_SETFOREGROUND)
		CloseFile(hPipeIn)
		CloseFile(hPipeOut)
		quitter
	EndIf
	If (InStr(buffer, lineUp) = 0) Then
		Print(buffer)
	Else
		ExitWhile
	EndIf
Wend

' ************************************************************************
' lancer une requête pour un targetComputer action=list
If (Not(WriteFile(hPipeIn, command_1))) Then
	MsgBox("Write to pipe """ + pipeIn + """ failed.", "Pipe test", MB_OK + 				MB_ICONSTOP + MB_SETFOREGROUND)
	CloseFile(hPipeIn)
	CloseFile(hPipeOut)
	quitter
EndIf
While (TRUE)
	If (Not(ReadFile(hPipeOut, buffer))) Then
		MsgBox("Read from pipe """ + pipeOut + """ failed.", "Pipe test", 					MB_OK + MB_ICONSTOP + MB_SETFOREGROUND)
		CloseFile(hPipeIn)
		CloseFile(hPipeOut)
		quitter
	EndIf
	If (InStr(buffer, endOfCommand) = 0) Then
		' les résultats peuvent être stockés pour un traitement ultérieur ou être directement traités.
		Print(buffer)
	Else
		ExitWhile
	EndIf
Wend

' ************************************************************************
' lancer une requête pour une swLibrary action=list
If (Not(WriteFile(hPipeIn, command_2))) Then
	MsgBox("Write to pipe """ + pipeIn + """ failed.", "Pipe test", MB_OK + 				MB_ICONSTOP + MB_SETFOREGROUND)
	CloseFile(hPipeIn)
	CloseFile(hPipeOut)
	quitter
EndIf
While (TRUE)
	If (Not(ReadFile(hPipeOut, buffer))) Then
		MsgBox("Read from pipe """ + pipeOut + """ failed.", "Pipe test", 					MB_OK + MB_ICONSTOP + MB_SETFOREGROUND)
		CloseFile(hPipeIn)
		CloseFile(hPipeOut)
		quitter
	EndIf
	If (InStr(buffer, endOfCommand) = 0) Then
		' les résultats peuvent être stockés pour un traitement ultérieur ou être directement traités.
		Print(buffer)
	Else
		ExitWhile
	EndIf
Wend

' ************************************************************************
' arrêter la CLI
If (Not(WriteFile(hPipeIn, eop))) Then
	MsgBox("Write to pipe """ + pipeIn + """ failed.", "Pipe test", MB_OK + 				MB_ICONSTOP + MB_SETFOREGROUND)
	CloseFile(hPipeIn)
	CloseFile(hPipeOut)
	quitter
EndIf

' ************************************************************************
' nettoyage
CloseFile(hPipeIn)
CloseFile(hPipeOut)

Toutes les commandes valides de la CLI sont disponibles depuis l'interface en mode canal.