code review 5493047: exp/ssh: simplify Stdin/out/errPipe methods

src/pkg/exp/ssh/session.go

 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package ssh
 
 // Session implements an interactive session described in
 // "RFC 4254, section 6".
 
 import (
@@ skipping 55 matching lines @@
         Stdout io.Writer
         Stderr io.Writer
 
         *clientChan // the channel backing this session
 
         started   bool // true once Start, Run or Shell is invoked.
         copyFuncs []func() error
         errch     chan error // one send per copyFunc
 
         // true if pipe method is active
         stdinpipe, stdoutpipe, stderrpipe bool

[agl1, 2011/12/15 15:48:45]

stdinPipe and so on?

 }
 
 // RFC 4254 Section 6.4.
 type setenvRequest struct {
         PeersId   uint32
         Request   string
         WantReply bool
         Name      string
         Value     string
 }
@@ skipping 145 matching lines @@
                 return nil
         case *channelRequestFailureMsg:
                 return errors.New("request failed")
         }
         return fmt.Errorf("unknown packet %T received: %v", msg, msg)
 }
 
 func (s *Session) start() error {
         s.started = true
 
-        type F func(*Session) error
+        type F func(*Session)
         for _, setupFd := range []F{(*Session).stdin, (*Session).stdout, (*Session).stderr} {
-                if err := setupFd(s); err != nil {
-                        return err
-                }
+                setupFd(s)
         }
 
         s.errch = make(chan error, len(s.copyFuncs))
         for _, fn := range s.copyFuncs {
                 go func(fn func() error) {
                         s.errch <- fn()
                 }(fn)
         }
         return nil
 }
@@ skipping 76 matching lines @@
                         return errors.New("wait: remote command exited without exit status or exit signal")
                 }
                 wm.status = 128
                 if _, ok := signals[Signal(wm.signal)]; ok {
                         wm.status += signals[Signal(wm.signal)]
                 }
         }
         return &ExitError{wm}
 }
 
-func (s *Session) stdin() error {
+func (s *Session) stdin() {
         if s.stdinpipe {
-                return nil
+                return
         }
         if s.Stdin == nil {
                 s.Stdin = new(bytes.Buffer)
         }
         s.copyFuncs = append(s.copyFuncs, func() error {
                 _, err := io.Copy(s.clientChan.stdin, s.Stdin)
                 if err1 := s.clientChan.stdin.Close(); err == nil {
                         err = err1
                 }
                 return err
         })
-        return nil
-}
-
-func (s *Session) stdout() error {
+}
+
+func (s *Session) stdout() {
         if s.stdoutpipe {
-                return nil
+                return
         }
         if s.Stdout == nil {
                 s.Stdout = ioutil.Discard
         }
         s.copyFuncs = append(s.copyFuncs, func() error {
                 _, err := io.Copy(s.Stdout, s.clientChan.stdout)
                 return err
         })
-        return nil
-}
-
-func (s *Session) stderr() error {
+}
+
+func (s *Session) stderr() {
         if s.stderrpipe {
-                return nil
+                return
         }
         if s.Stderr == nil {
                 s.Stderr = ioutil.Discard
         }
         s.copyFuncs = append(s.copyFuncs, func() error {
                 _, err := io.Copy(s.Stderr, s.clientChan.stderr)
                 return err
         })
-        return nil
 }
 
 // StdinPipe returns a pipe that will be connected to the
 // remote command's standard input when the command starts.
 func (s *Session) StdinPipe() (io.WriteCloser, error) {
         if s.Stdin != nil {
                 return nil, errors.New("ssh: Stdin already set")
         }
         if s.started {
                 return nil, errors.New("ssh: StdinPipe after process started")
@@ skipping 94 matching lines @@
 }
 
 // Lang returns the language tag. See RFC 3066
 func (w Waitmsg) Lang() string {
         return w.lang
 }
 
 func (w Waitmsg) String() string {
         return fmt.Sprintf("Process exited with: %v. Reason was: %v (%v)", w.status, w.msg, w.signal)
 }