@@ -147,16 +147,18 @@ func (rk rawKey) PreimageKey() [32]byte {
147147}
148148
149149type ProcessPreimageOracle struct {
150- pCl * preimage.OracleClient
151- hCl * preimage.HintWriter
152- cmd * exec.Cmd
153- waitErr chan error
154- cancelIO context.CancelCauseFunc
150+ log log.Logger
151+ pCl * preimage.OracleClient
152+ hCl * preimage.HintWriter
153+ cmd * exec.Cmd
154+ waitErr chan error
155+ cancelIO context.CancelCauseFunc
156+ ioClosers ioutil.MultiCloser
155157}
156158
157159const clientPollTimeout = time .Second * 15
158160
159- func NewProcessPreimageOracle (name string , args []string , stdout log.Logger , stderr log.Logger ) (* ProcessPreimageOracle , error ) {
161+ func NewProcessPreimageOracle (logger log. Logger , name string , args []string , stdout log.Logger , stderr log.Logger ) (* ProcessPreimageOracle , error ) {
160162 if name == "" {
161163 return & ProcessPreimageOracle {}, nil
162164 }
@@ -179,18 +181,23 @@ func NewProcessPreimageOracle(name string, args []string, stdout log.Logger, std
179181 pOracleRW .Reader (),
180182 pOracleRW .Writer (),
181183 }
184+ // Discourage rust programs from using color in logs.
185+ cmd .Env = append ([]string {"NO_COLOR=1" }, os .Environ ()... )
182186
183187 // Note that the client file descriptors are not closed when the pre-image server exits.
184188 // So we use the FilePoller to ensure that we don't get stuck in a blocking read/write.
185189 ctx , cancelIO := context .WithCancelCause (context .Background ())
186190 preimageClientIO := preimage .NewFilePoller (ctx , pClientRW , clientPollTimeout )
187191 hostClientIO := preimage .NewFilePoller (ctx , hClientRW , clientPollTimeout )
188192 out := & ProcessPreimageOracle {
193+ log : logger ,
189194 pCl : preimage .NewOracleClient (preimageClientIO ),
190195 hCl : preimage .NewHintWriter (hostClientIO ),
191196 cmd : cmd ,
192197 waitErr : make (chan error ),
193198 cancelIO : cancelIO ,
199+ // We only close our side of the channels, the client program owns the side we pass through as extra files
200+ ioClosers : ioutil.MultiCloser {preimageClientIO , hostClientIO },
194201 }
195202 return out , nil
196203}
@@ -237,14 +244,29 @@ func (p *ProcessPreimageOracle) Close() error {
237244 if exited , err := tryWait (1 * time .Second ); exited {
238245 return err
239246 }
240- // Politely ask the process to exit and give it some more time
241- _ = p .cmd .Process .Signal (os .Interrupt )
247+
248+ // Close the IO streams to the preimage server to encourage it to exit
249+ if err := p .ioClosers .Close (); err != nil {
250+ p .log .Warn ("Failed to close preimage oracle IO streams" , "err" , err )
251+ }
252+ if exited , err := tryWait (30 * time .Second ); exited {
253+ return err
254+ }
255+
256+ // Politely ask the process to exit
257+ p .log .Info ("Preimage server process did not exit when streams closed, sending interrupt signal" )
258+ if err := p .cmd .Process .Signal (os .Interrupt ); err != nil {
259+ p .log .Warn ("Failed to send interrupt signal to preimage server process" , "err" , err )
260+ }
242261 if exited , err := tryWait (30 * time .Second ); exited {
243262 return err
244263 }
245264
246- // Force the process to exit
247- _ = p .cmd .Process .Signal (os .Kill )
265+ // Just terminate the process
266+ p .log .Warn ("Preimage server process would not exit cleanly, terminating" )
267+ if err := p .cmd .Process .Kill (); err != nil {
268+ p .log .Warn ("Failed to kill preimage server process" , "err" , err )
269+ }
248270 return <- p .waitErr
249271}
250272
@@ -365,7 +387,7 @@ func Run(ctx *cli.Context) error {
365387
366388 poOut := Logger (os .Stdout , log .LevelInfo ).With ("module" , "host" )
367389 poErr := Logger (os .Stderr , log .LevelInfo ).With ("module" , "host" )
368- po , err := NewProcessPreimageOracle (args [0 ], args [1 :], poOut , poErr )
390+ po , err := NewProcessPreimageOracle (l , args [0 ], args [1 :], poOut , poErr )
369391 if err != nil {
370392 return fmt .Errorf ("failed to create pre-image oracle process: %w" , err )
371393 }
0 commit comments