"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 2018 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

Object subclass:#OSProcess

	instanceVariableNames:'pid command environment directory inStream outStream errorStream

		auxInStream auxOutStream showWindow lineWise newPgrp exitStatus

		finishSema inputShufflerProcesses outputShufflerProcesses

		streamsToClose terminateActionBlock'

	classVariableNames:'Instances'

	poolDictionaries:''

	category:'System-Support'

!

Object subclass:#ProcessListEntry

	instanceVariableNames:'executableName processID sessionName userName'

	classVariableNames:''

	poolDictionaries:''

	privateIn:OSProcess

!

OSProcess subclass:#RemoteOSProcess

	instanceVariableNames:'host'

	classVariableNames:'MethodPerHost'

	poolDictionaries:''

	privateIn:OSProcess

!

!OSProcess class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 2018 by eXept Software AG

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    Instances of OSProcess represent operating system processes that can be executed.

    (as opposed to Smalltalk processes).

    Both local and remote processes are supported.

    commandString:

     If command is a String, the commandString is passed to a shell for execution

     - see the description of 'sh -c' in your UNIX manual ('cmd.exe' in your Windows manual).

     Regular input/output redirection and pipes etc. are supported as supported by

     the underlying OS's command interpreter (i.e. some limits apply to MSDOS)

     With an empty command, the shell will read commands from the passed input stream.

     If command is an Array, the first element is the command to be executed,

     and the other elements are the arguments to the command. 

     No shell is invoked in this case. Any redirection or piping can then be done

     by Smalltalk code (including piping through smalltalk streams & filters).

    [author:]

        Stefan Vogel (stefan@zwerg)

    [instance variables:]

        pid         SmallInteger    the process id

        command     String          the command line of the running command.

    [class variables:]

    [see also:]

        Process

"

!

examples

"

  send command's output to the Transcript:

                                                            [exBegin]

    OSProcess new 

        terminateActionBlock:[:status | Transcript showCR:status. Transcript showCR:status isError];

        command:'lsxxxx -l';

        outStream:Transcript;

        lineWise:true;

        startProcess.

                                                            [exEnd]

  send command's output to my stdout (see console):

                                                            [exBegin]

    OSProcess new 

        command:'ls -l';

        outStream:Stdout;

        execute.

                                                            [exEnd]

  send command's output to a Smalltalk stream:

                                                            [exBegin]

    |outStream|

    outStream := '' writeStream.

    OSProcess new 

        command:'ls -l';

        outStream:outStream;

        execute.

    outStream contents inspect.

                                                            [exEnd]

  feed it from a smalltalk stream, get command's output into a Smalltalk stream:

                                                            [exBegin]

    |inStream outStream|

    inStream := 'hello world' readStream.

    outStream := '' writeStream.

    OSProcess new 

        command:'tr ''a-z'' ''A-Z''';

        inStream:inStream;

        outStream:outStream;

        execute.

    outStream contents inspect.

                                                            [exEnd]

  again, send output to a Smalltalk stream;

  watch the stream getting filled after 10 seconds:

                                                            [exBegin]

    |outStream|

    outStream := '' writeStream.

    OSProcess new 

        command:'ls -l; sleep 10; echo =================================; echo hallo after 10s; echo >&2 +++++++++++++++++++++; cat >&2';

        outStream:outStream;

        errorStream:outStream;

        startProcess.

    outStream inspect

                                                            [exEnd]

  separate stdout and stderr:

                                                            [exBegin]

    |outStream errStream|

    outStream := '' writeStream.

    errStream := '' writeStream.

    OSProcess new 

        command:'ls -l && ls >&2';

        outStream:outStream;

        errorStream:errStream;

        startProcess.

    outStream inspect.

    errStream inspect.

                                                            [exEnd]

  Execute commands in shell/cmd.exe and read them from stdin:

                                                            [exBegin]

    |outStream|

    outStream := '' writeStream.

    OSProcess new 

        command:'';

        inStream:'ls -l' readStream;

        outStream:outStream;

        lineWise:true;

        execute.

    outStream contents inspect

                                                            [exEnd]

  Execute on a remote host (you must have the appropriate ssh setup):

                                                            [exBegin]

    |outStream|

    outStream := '' writeStream.

    (OSProcess onHost:'exeptn') 

        command:'ls -l';

        outStream:outStream;

        lineWise:true;

        execute.

    outStream contents inspect

                                                            [exEnd]

"

! !

!OSProcess class methodsFor:'instance creation'!

allInstancesDo:aBlock

    "return an initialized instance for a local process.

     Keep track of the new instance (so we can quickly enumerate all of them)"

    Instances notNil ifTrue:[ 

        Instances do:aBlock

    ].

    "

     super allInstances

     self allInstances

    "

    "Created: / 02-03-2019 / 19:19:41 / Claus Gittinger"

!

command:aCommandString

    "return an initialized instance to execute aCommandString

     in the current directory (for a local process)"

    ^ self new command:aCommandString.

!

command:aCommandString directory:aStringOrFilename

    "return an initialized instance to execute aCommandString 

     in a given directory (for a local process)"

    ^ self new command:aCommandString directory:aStringOrFilename.

!

commandStringForProgramName:executableFile arguments:arrayOfStrings

    "generate a command line string from appending args (possibley quoted) to the exe-name (with spaces)"

    ^ String streamContents:[:s |

        s nextPutAll:(self possiblyQuoted:executableFile asFilename pathName).

        arrayOfStrings notNil ifTrue:[

            arrayOfStrings do:[:eachArg |

                s space.

                s nextPutAll:(self possiblyQuoted:eachArg).

            ].

        ]

    ]

    "Modified (comment): / 02-07-2018 / 20:50:29 / cg"

!

new

    "return an initialized instance for a local process.

     Keep track of the new instance (so we can quickly enumerate all of them)"

    |newInst|

    Instances isNil ifTrue:[

        Instances := WeakIdentitySet new

    ].    

    newInst := self basicNew initialize.

    Instances add:newInst.

    ^ newInst

    "Modified (comment): / 02-03-2019 / 19:15:25 / Claus Gittinger"

!

onHost:aHost

    "return an initialized instance for a remote process running on another host"

    (SocketAddress hostName:aHost) isLocal ifTrue:[

        ^ self basicNew initialize.

    ].

    ^ RemoteOSProcess basicNew host:aHost; initialize.

    "

     OSProcess onHost:'localhost'

     OSProcess onHost:'exeptn'

     (OSProcess new) command:'ls'

     (OSProcess onHost:'exeptn') command:'ls'

    "

!

possiblyQuoted:aString

    "should we quote or escape?"

    "/ better quote - qorks on Windows AND Unix

    ^ Filename possiblyQuotedPathname:aString.

"/    ^ String streamContents:[:s |

"/        aString do:[:ch |

"/            (ch isSeparator or:[ch = $\]) ifTrue:[

"/                s nextPut:$\

"/            ].

"/            s nextPut:ch

"/        ]

"/    ]

    "

     self possiblyQuoted:'foo bar' 

     self possiblyQuoted:'foo\bar'

    "

    "Modified: / 28-03-2019 / 16:19:41 / Claus Gittinger"

!

programName:executableFile arguments:arrayOfStrings initialEnvironment:stringDictionary

    "similar to command:, but with separate command and arguments"

    ^ self new

        command:(self commandStringForProgramName:executableFile arguments:arrayOfStrings);

        environment:stringDictionary;

        yourself

    "

     (self programName:'notepad.exe' arguments:#() initialEnvironment:nil)

        showWindow:true;

        startProcess

    "

    "Modified (comment): / 02-07-2018 / 20:33:02 / cg"

! !

!OSProcess class methodsFor:'class initialization'!

initialize

    "Backward compatibility: Win32Process is an alias for OSProcess"

    Win32Process := self.

! !

!OSProcess class methodsFor:'queries'!

defaultShellPath

    OperatingSystem isUNIXlike ifTrue:[

        ^ OperatingSystem getEnvironment:'SHELL' 

    ].

    ^ 'cmd'

! !

!OSProcess class methodsFor:'utilities'!

getTaskList

    "get a tasklist (Windows OS only)"

    |lines sepIdx entries|

    OperatingSystem isMSWINDOWSlike ifTrue:[

        lines := (PipeStream outputFromCommand:'tasklist') asStringCollection.

        sepIdx := lines findFirst:[:line | line startsWith:'=='].

        sepIdx == 0 ifTrue:[ ^ #() ].

        entries := (lines from:(sepIdx + 1)) 

                        collect:[:line |

                            |s idx executableName processID userName|

                            s := line readStream.

                            executableName := (s upToMatching:[:ch | ch isDigit]) withoutSeparators.

                            processID := Integer readFrom:s.

                            s skipSeparators.

                            userName := s nextAlphaNumericWord.

                            ProcessListEntry executableName:executableName processID:processID sessionName:userName

                        ]

                        as:OrderedCollection.

    ] ifFalse:[

        lines := (PipeStream outputFromCommand:'ps') asStringCollection.

        sepIdx := lines findFirst:[:line | line withoutSeparators first isDigit].

        sepIdx == 0 ifTrue:[ ^ #() ].

        entries := (lines from:(sepIdx + 1)) 

                        collect:[:line |

                            |s idx executableName processID tty time|

                            s := line readStream.

                            processID := Integer readFrom:s.

                            s skipSeparators.

                            tty := s upToSeparator.

                            s skipSeparators.

                            time := s upToSeparator.

                            s skipSeparators.

                            executableName := s upToEnd.

                            (executableName startsWith:'-') ifTrue:[

                                executableName := executableName copyFrom:2.

                            ].    

                            ProcessListEntry executableName:executableName processID:processID sessionName:nil

                        ]

                        as:OrderedCollection.

    ].

    ^ entries

    "

     self getTaskList

    "

    "Modified: / 16-07-2018 / 23:11:05 / Claus Gittinger"

! !

!OSProcess methodsFor:'accessing'!

auxInStream

    ^ auxInStream

!

auxInStream:aStream

    "set an auxiliary input stream that will be available to the command as

     file descriptor 3"

    auxInStream := aStream.

    "Modified (comment): / 23-02-2017 / 10:56:57 / Maren"

!

auxOutStream

    ^ auxOutStream

!

auxOutStream:aStream

    "set an auxiliary output stream that will be available to the command as

     file descriptor 4"

    auxOutStream := aStream.

    "Modified (comment): / 23-02-2017 / 10:56:57 / Maren"

!

auxStream

    <resource: #obsolete>

    ^ self auxInStream

!

auxStream:aStream

    <resource: #obsolete>

    "set an auxiliary input stream that will be available to the command as

     file descriptor 3"

    self auxInStream:aStream.

    "Modified (comment): / 23-02-2017 / 10:56:57 / Maren"

!

command

    "the OS (shell-) command, as string or string-array"

    ^ command

    "Created: / 10.11.1998 / 21:27:07 / cg"

!

command:aStringOrArray 

    "set the command to be executed.

     If aStringOrArray is a String, the commandString is passed to a shell for execution

     - see the description of 'sh -c' in your UNIX manual ('cmd.exe' in your Windows manual).

     With an empty command, the shell will read commands from the passed input stream.

     If aCommandString is an Array, the first element is the command to be executed,

     and the other elements are the arguments to the command. 

     No shell is invoked in this case."

    command := aStringOrArray.

!

command:commandStringArg directory:stringOrFilenameArg

    "set the command to be executed and directory, where to execute.

     If aStringOrArray is a String, the commandString is passed to a shell for execution

     - see the description of 'sh -c' in your UNIX manual ('cmd.exe' in your Windows manual).

     If aCommandString is an Array, the first element is the command to be executed,

     and the other elements are the arguments to the command. No shell is invoked in this case."

    command := commandStringArg.

    directory := stringOrFilenameArg.

!

command:commandArg directory:directoryArg outStream:outStreamArg errorStream:errorStreamArg 

    "set the command to be executed & directory, where to execute.

     and output/error streams.

     See comments in individual setters for more info"

    command := commandArg.

    directory := directoryArg.

    outStream := outStreamArg.

    errorStream := errorStreamArg.