CADSMCMD Befehlszeilenschnittstelle › Der Befehl "cadsmcmd" › Pipe

Pipe

Die Pipe-Schnittstelle bietet den Vorteil einer Batch-Verarbeitung und eines direkten Befehlsaufrufes, d. h. es ist möglich, mehr als einen Befehl während einer Sitzung zwischen der CLI und dem Manager auszuführen, wie dies bei der Batch-Option der Fall ist. Andererseits besteht bei einem Skript die Möglichkeit zur Verarbeitung der Befehlsausgabe vor dem Start des nächsten CLI-Befehls. Die Pipe-Schnittstelle wird durch das Pipe-Schlüsselwort aktiviert, gefolgt von den Namen der Pipe, auf die die CLI warten muss. Die angegebene Pipe ist eine Named Pipe unter Windows und eine FIFO-Datei unter Linux. Auf jeden Fall arbeitet die CLI als Pipe-Client, d. h., die Pipe muss von dem aufgerufenen Skript erstellt und verwaltet werden. Wenn sie für die Verarbeitung der Pipe-Schnittstelle aufgerufen wird, stellt die CLI die Verbindung zum angegebenen Manager mit den angegebenen Anmeldeinformationen her und zeichnet das Ergebnis in stdout auf. Wenn die Sitzung eingerichtet ist, wartet die CLI auf die Pipe und auf einen zu verarbeitenden Befehl. Wenn sie einen solchen Befehl erhält, wird dieser verarbeitet und seine Ergebnisse werden in stdout aufgezeichnet. Nach der Verarbeitung des Befehls wartet die CLI auf den nächsten Befehl. Im Gegensatz zum Batch-Modus kehrt die CLI im Pipe-Modus immer zur Pipe zurück, unabhängig davon, ob ein Befehl erfolgreich verarbeitet wurde oder nicht. Die Sitzung zwischen der CLI und dem Manager wird nicht beendet, wenn ein Befehl fehlschlägt. Dieses Verhalten entspricht dem Batch-Modus mit SDCMD_CONTINUE=ON.

Zur Erleichterung der Kommunikation und Synchronisation zwischen der CLI und dem gestarteten Skript bietet die CLI gewisse Eye Catcher, die ankündigen, dass eine CLI-Verarbeitung beendet wird und dass die CLI nun wieder auf die Pipe wartet.

Beim Starten der CLI im Pipe-Modus startet die CLI die Nachricht in stdout.

*** SDCMD: Line up ***

, wenn die Sitzung mit dem Manager erstellt wurde und die CLI beginnt, auf die Pipe zu warten. Ab diesem Zeitpunkt kann ein Skript damit beginnen, Befehle über die Pipe an die CLI zu senden. Auch das Ende einer Befehlsverarbeitung wird von einem speziellen Eye Catcher gemeldet. Jedes Mal, wenn ein Befehl beendet wird, ob erfolgreich oder nicht, startet die CLI folgende Nachricht in stdout:

### SDCMD: -eoc ###

Wenn ein Skript diese Zeichenfolge findet, weiß es, dass der von ihm gestartete Befehl beendet wurde und die gesamte Befehlsausgabe in stdout geschrieben wird.

Die von einer Anwendung über Pipe zu sendenden Befehle besitzen das gleiche Format wie in Batch-Dateien. Der von der Anwendung in die Pipe geschriebene Befehlspuffer muss den vollständigen auszuführenden Befehl enthalten. Ein Befehl kann nicht über mehrere Sendepuffer verteilt werden.

Andererseits ist es möglich, mehr als einen Befehl innerhalb des Puffers zu senden. In diesem Fall müssen die Befehle durch folgende Zeichenfolge getrennt werden:

-eoc

Die Sitzung zwischen einer CLI im Pipe-Modus und dem Manager wird beendet, sobald die CLI die Zeichenfolge

-quit

über die Pipe empfängt.

Die CLI wird für die Pipe-Schnittstelle aufgerufen, indem das Schlüsselwort "Pipe" angegeben wird, gefolgt vom Namen der Pipe (Pipe-Name), den die CLI für den Empfang ihrer zu verarbeitenden Befehle verwendet. Zwischen dem Schlüsselwort und dem Pipe-Namen muss mindestens ein Leerzeichen stehen.

Das folgende Beispiel zeigt die Nutzung der Pipe-Schnittstelle unter Linux. Das Skript listet alle bei der USD registrierten Zielcomputer und alle bei der USD-Softwarebibliothek registrierten Produkte auf.

#! /usr/bin/sh
proto ()
{
	aa=" "
	bb=`echo "$aa" | grep "SDCMD: Line up"`
	while [ -z "$bb" ]
	do
		read aa
		bb=`echo "$aa" | grep "SDCMD: Line up"`
		if [ -z "$bb" ]
		then
			echo "$aa"
		fi
	done
}
prot ()
{
	aa=" "
	bb=`echo "$aa" | grep "SDCMD: -eoc"`
	while [ -z "$bb" ]
	do
		read aa
		bb=`echo "$aa" | grep "SDCMD: -eoc"`
		if [ -z "$bb" ]
		then
			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
	#
	#  ausgegebene Liste speichern und verarbeiten
	#
	#     ...
	#
	#  nächster Befehl
	echo "swLibrary action=list -eoc" > /ca_dsmcmd_in
	prot
	#
	#  ausgegebene Liste speichern und verarbeiten
	#
	#      ...
	#
	#  Sitzung beenden
	echo "-quit" > /ca_dsmcmd_in
} < /ca_dsmcmd_out
rm /ca_dsmcmd_*

Das Beispiel besteht aus zwei Routinen und dem Mainline-Teil. Die Routine "proto ()" löst "###SDCMD": Line up ###" aus und gibt somit an, dass die Pipe-Schnittstelle aktiv ist und auf Befehle wartet, und die Routine "prot ()" löst "### SDCMD: -eoc ###" aus und gibt somit an, dass die Verarbeitung für einen Befehl abgeschlossen ist.

Der Mainline-Teil erstellt zunächst zwei Pipes. Die Pipe "/ca_dsmcmd_in" wird von der CLI als Eingabe-Pipe verwendet, d. h., die CLI empfängt die zu verarbeitenden Befehle über diese Pipe. Die andere Pipe "/ca_dsmcmd_out" wird zur Umleitung der stdout der CLI an das Skript verwendet, so dass das Skript möglicherweise in der Lage ist, die Ergebnisse zu verarbeiten. Nachdem diese Pipes erstellt wurden, wird ein Block gestartet, der die CLI im Pipe-Modus im Batch startet, zwei Listenbefehle für targetComputer und swLibrary startet und die Sitzung anschließend beendet. Dieser Block empfängt seine Eingabe von der Pipe "/ca_dsmcmd_out", die die Ausgabe der CLI aufzeichnet. Es wird dringend empfohlen, diese Pipe während der Lebensdauer der CLI für das Skript geöffnet zu lassen. Deshalb wird sie für diesen Block als Eingabe zugewiesen. Wenn diese Pipe beispielsweise den Prozeduren "proto" und "prot" nur als Eingabe zugewiesen wird, führt die möglicherweise zu Laufzeitproblemen beim Benutzer, die einen Datenverlust und möglicherweise den Absturz von Sitzungen verursachen können.

Nachdem die CLI im Pipe-Modus im Batch gestartet ist, wird die Routine "proto" als Auslöser dafür verwendet, dass die CLI handlungsbereit ist. Nach der Rückgabe startet das Skript die Aktion "list" für "targetComputer" und verwendet anschließend die Routine "prot", um das Ende der Befehlsverarbeitung festzulegen. Die Ausgabe dieser Routine "prot" könnte zur anschließenden Skriptverarbeitung in eine Datei umgeleitet werden. Daraufhin wird die Aktion "list" für "swLibrary" gestartet, und erneut wird die Routine "prot" verwendet, um das Ende der Befehlsverarbeitung festzulegen. Wieder könnte die Ausgabe der Prozedur "prot" zur anschließenden Skriptverarbeitung in eine Datei umgeleitet werden. Schließlich wird der Block durch Beenden der CLI mit "-quit" beendet.

Die letzte Zeile des Skripts dient der Wartung und der Bereinigung der Pipes.

Das folgende Beispiel arbeitet genauso wie das vorige Beispiel, verwendet jedoch DM Scripting und gilt für Windows.

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

' ************************************************************************
' clear screen
ClrScr()

' ************************************************************************
' Konstanten festlegen
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"

' ************************************************************************
' Eingabe-Pipe von CLI erstellen
hPipeIn = CreatePipe(pipeIn, O_WRITE)
If (hPipeIn = -1) Then
	MsgBox("Open pipe """ + pipeIn + """ failed.", "Pipe test", MB_OK + 					MB_ICONSTOP + MB_SETFOREGROUND)
	exit
EndIf

' ************************************************************************
' Ausgabe-Pipe von CLI erstellen
hPipeOut = CreatePipe(pipeOut, O_READ)
If (hPipeOut = -1) Then
	MsgBox("Open pipe """ + pipeOut + """ failed.", "Pipe test", MB_OK + MB_ICONSTOP + MB_SETFOREGROUND) 
	CloseFile(hPipeIn)
	exit
EndIf

' ************************************************************************
' cadsmcmd im Pipe-Modus mit Hilfe von "pipeIn" als Eingabe-Pipe starten und umleiten
‘ stdout an 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)
		exit
	EndIf
	If (InStr(buffer, lineUp) = 0) Then
		Print(buffer)
	Else
		ExitWhile
	EndIf
Wend

' ************************************************************************
' Anforderung starten für eine 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)
	exit
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)
		exit
	EndIf
	If (InStr(buffer, endOfCommand) = 0) Then
		' Ergebnisse können zur Weiterverarbeitung gespeichert oder direkt verarbeitet werden.
		Print(buffer)
	Else
		ExitWhile
	EndIf
Wend

' ************************************************************************
' Anforderung starten für eine 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)
	exit
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)
		exit
	EndIf
	If (InStr(buffer, endOfCommand) = 0) Then
		' Ergebnisse können zur Weiterverarbeitung gespeichert oder direkt verarbeitet werden.
		Print(buffer)
	Else
		ExitWhile
	EndIf
Wend

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

' ************************************************************************
' bereinigen
CloseFile(hPipeIn)
CloseFile(hPipeOut)

Alle gültigen Befehle der CLI sind an der Pipe-Schnittstelle verfügbar.