"{ Encoding: utf8 }"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

Object subclass:#OSProcess

	instanceVariableNames:'pid command environment directory inStream outStream errorStream

		auxStream showWindow lineWise newPgrp exitStatus finishSema

		shufflerProcesses streamsToClose'

	classVariableNames:''

	poolDictionaries:''

	category:'System-Support'

!

!OSProcess class methodsFor:'documentation'!

documentation

"

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

    (as opposed to Smalltalk processes).

    [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

    "

        |outStream|

        outStream := '' writeStream.

        self new 

            command:'ls -l';

            inStream:'abc' readStream;

            outStream:outStream;

            lineWise:true;

            execute.

        outStream contents

    "

    "

        |outStream|

        outStream := '' writeStream.

        self new 

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

            inStream:'abc' readStream;

            outStream:outStream;

            errorStream:outStream;

            startProcess.

        outStream inspect

    "

    "

        |outStream|

        outStream := '' writeStream.

        self new 

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

            inStream:'abc' readStream;

            outStream:outStream;

            errorStream:outStream;

            startProcess.

        outStream inspect

    "

! !

!OSProcess class methodsFor:'instance creation'!

new

    "return an initialized instance"

    ^ self basicNew initialize.

! !

!OSProcess class methodsFor:'initialize'!

initialize

    "Backward compatibility"

    Win32Process := self.

! !

!OSProcess methodsFor:'accessing'!

accessor

    ^ self

!

auxStream

    ^ auxStream

!

auxStream:something

    auxStream := something.

!

command

    "return the value of the instance variable 'command' (automatically generated)"

    ^ command

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

!

command:something

    "set the value of the instance variable 'command' (automatically generated)"

    command := something.

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

!

directory

    "return the value of the instance variable 'directory' (automatically generated)"

    ^ directory

    "Created: / 10.11.1998 / 21:21:52 / cg"

!

directory:something

    "set the value of the instance variable 'directory' (automatically generated)"

    directory := something.

    "Created: / 10.11.1998 / 21:21:52 / cg"

!

environment

    "return the value of the instance variable 'environment' (automatically generated)"

    ^ environment

    "Created: / 10.11.1998 / 21:26:34 / cg"

!

environment:something

    "set the value of the instance variable 'environment' (automatically generated)"

    environment := something.

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

!

errorStream

    "return the value of the instance variable 'errorStream' (automatically generated)"

    ^ errorStream

    "Created: / 10.11.1998 / 21:26:34 / cg"

!

errorStream:something

    "set the value of the instance variable 'errorStream' (automatically generated)"

    errorStream := something.

    "Created: / 10.11.1998 / 21:26:34 / cg"

!

exitStatus

    "return the value of the instance variable 'exitStatus' (automatically generated)"

    ^ exitStatus

    "Created: / 10.11.1998 / 21:24:55 / cg"

!

exitStatus:something

    "set the value of the instance variable 'exitStatus' (automatically generated)"

    exitStatus := something.

    "Created: / 10.11.1998 / 21:24:55 / cg"

!

finishSema

    "wait on this semaphore if yo want to wait until the os process has finished.

     There may be multiple waiters, so it is a good idea to do a #waitUncounted"

    ^ finishSema

!

inStream

    "return the value of the instance variable 'inStream' (automatically generated)"

    ^ inStream

    "Created: / 10.11.1998 / 21:26:34 / cg"

!

inStream:something

    "set the value of the instance variable 'inStream' (automatically generated)"

    inStream := something.

    "Created: / 10.11.1998 / 21:26:34 / cg"

!

lineWise

    ^ lineWise

!

lineWise:something

    lineWise := something.

!

newPgrp

    ^ newPgrp

!

newPgrp:something

    newPgrp := something.

!

outStream

    "return the value of the instance variable 'outStream' (automatically generated)"

    ^ outStream

    "Created: / 10.11.1998 / 21:26:34 / cg"

!

outStream:something

    "set the value of the instance variable 'outStream' (automatically generated)"

    outStream := something.

    "Created: / 10.11.1998 / 21:26:34 / cg"

!

pid

    ^ pid

!

pid:something

    pid := something.

!

showWindow

    ^ showWindow

!

showWindow:something

    showWindow := something.

! !

!OSProcess methodsFor:'initialization'!

initialize

    "Invoked when a new instance is created."

    showWindow := false.    "/ for backward compatibility

    lineWise := false.

    newPgrp := true.

! !

!OSProcess methodsFor:'printing'!

printOn:aStream

    aStream 

        nextPutAll:self className;

        nextPut:$(.

    pid printOn:aStream.

    aStream space.

    command printOn:aStream.

    aStream nextPut:$)

! !

!OSProcess methodsFor:'private'!

setupShufflerForInput:aStream

    "if aStream is an internal Stream, set up a pipe for the command input.

     Start a process that shuffles tha data fron the internal stream into the pipe

     (and into the command's input)."

    |pipe externalStream shuffledStream shufflerProcess|

    (aStream isNil or:[aStream isExternalStream]) ifTrue:[

        ^ aStream.

    ].

    pipe := NonPositionableExternalStream makePipe.

    externalStream := pipe at:1.

    shuffledStream := pipe at:2.

    lineWise ifFalse:[

        shuffledStream blocking:false.

    ].

    aStream isBinary ifTrue:[

        shuffledStream binary.

    ].

    "/ start a reader process, shuffling data from the given

    "/ inStream to the pipe (which is connected to the commands input)

    shufflerProcess := [

            [

                WriteError handle:[:ex |"ignored" ] do:[

                    lineWise ifTrue:[

                        "shuffle until end-of-input"

                        [aStream atEnd] whileFalse:[

                            |data|

                            data := aStream nextLine.

                            data notNil ifTrue:[

                                shuffledStream nextPutLine:data.

                                shuffledStream flush.

                            ].

                        ].

                    ] ifFalse:[

                        aStream copyToEndInto:shuffledStream.

                    ].

                ].

            ] ensure:[

                shuffledStream close.

            ]

        ] newProcess

            name:'OSProcess input shuffler';

"/                beSystemProcess;

            resume.

    shufflerProcesses add:shufflerProcess.

    streamsToClose add:externalStream.

    ^ externalStream

!

setupShufflerForOutput:aStream

    "if aStream is an internal Stream, set up a pipe for the command output.

     Start a process that shuffles the data fron the pipe into the internal stream."

    |pipe externalStream shuffledStream shufflerProcess|

    (aStream isNil or:[aStream isExternalStream]) ifTrue:[

        ^ aStream.

    ].

    pipe := NonPositionableExternalStream makePipe.

    externalStream := pipe at:2.

    shuffledStream := pipe at:1.

    aStream isBinary ifTrue:[

        shuffledStream binary.

    ].

    shufflerProcess := [

            WriteError handle:[:ex |"ignored" ] do:[

                [

                    "shuffle until the pipe closes"

                    lineWise ifTrue:[

                        [shuffledStream atEnd] whileFalse:[

                            |data|

                            data := shuffledStream nextLine.

                            data notNil ifTrue:[

                                aStream nextPutLine:data

                            ] .

                        ].

                    ] ifFalse:[

                        shuffledStream copyToEndInto:aStream.

                    ].

                ] ensure:[

                    shuffledStream close.

                ].

            ].

        ] newProcess

            priority:(Processor userSchedulingPriority "+ 1");

            name:'OSProcess output shuffler';

"/                beSystemProcess;

            resume.

    streamsToClose add:externalStream.

    ^ externalStream

! !

!OSProcess methodsFor:'queries'!

isAlive

    "answer true, if the process is still alive"

    ^ pid notNil and:[exitStatus notNil]

!

isDead

    "answer true, if the process is no longer alive"

    ^ self isAlive not

! !

!OSProcess methodsFor:'starting'!

execute

    "execute the command. 

     Wait until is is finished.

     Abort the execution if I am interrupted.

     Answer true if the terminated succesfully, 

     false if it could not be started or terminated with error."

    |ok|

    [

        ok := self startProcess.

        ok ifTrue:[

            ok := self waitUntilFinished.

        ].

    ] ifCurtailed:[

        "/ we were interrupted -

        "/ terminate the os-command (and all of its forked commands)

        pid notNil ifTrue:[

            self terminateGroup.

        ].

    ].

    ^ ok.

!

startProcess

    "If there are non-external streams, setup transfer (shuffler) processes

     to transfer data from a pipe to the internal stream.

     Start the command.

     Answer true if the command could be started, false if not.

     Return immediately (do not wait until the command is finished)." 

    externalInStream := self setupShufflerForInput:inStream.

    externalAuxStream := self setupShufflerForInput:auxStream.

    errorStream == outStream ifTrue:[

        externalErrorStream := externalOutStream := self setupShufflerForOutput:errorStream.

    ] ifFalse:[

        externalErrorStream := self setupShufflerForOutput:errorStream.

        externalOutStream := self setupShufflerForOutput:outStream.

    ].

    "start the command"

    Processor 

        monitor:[

            pid := OperatingSystem

        ] 

        action:[:status |

            status stillAlive ifFalse:[

                exitStatus := status.

                pid notNil ifTrue:[

                    OperatingSystem closePid:pid.

                ].

                shufflerProcesses do:[:eachProcess|

                    "terminate the shuffler processes.

                     They close the local side of the pipe when being terminated"

                    eachProcess terminate.

                ].

                finishSema signal.

            ].

        ].

    "we can close the remote side of the pipes after the os process has been started (after the fork)"

    streamsToClose do:[:eachStream | eachStream close].

    streamsToClose := nil.

    pid isNil ifTrue:[

        "process could not be started - terminate shufflers"

        shufflerProcesses do:[:eachProcess|

            eachProcess terminate.

        ].

        shufflerProcesses := nil.