passing socket to stdin working, to first order

Author: Michael Lauer

dialer.go

@@ -0,0 +1,97 @@
+package gofcgisrv
+
+import (
+	"crypto/rand"
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"os/exec"
+	"path"
+)
+
+type Dialer interface {
+	Dial() (net.Conn, error)
+}
+
+type TCPDialer struct {
+	addr string
+}
+
+func (d TCPDialer) Dial() (net.Conn, error) {
+	return net.Dial("tcp", d.addr)
+}
+
+// StdinDialer managers an app as a child process, creating a socket and passing it through stdin.
+type StdinDialer struct {
+	app      string
+	args     []string
+	cmd      *exec.Cmd
+	stdin    *os.File
+	listener net.Listener
+	filename string
+}
+
+func (sd *StdinDialer) Dial() (net.Conn, error) {
+	if sd.stdin == nil {
+		return nil, errors.New("No file")
+	}
+	return net.Dial("unix", sd.filename)
+}
+
+func (sd *StdinDialer) Start() error {
+	// Create a socket. 
+	// We'll use the high-level net API, creating a listener that does all sorts
+	// of socket stuff, getting its file, and passing that (really just for its FD)
+	// to the child process.
+	// We'll rely on crypt/rand to get a unique filename for the socket.
+	tmpdir := os.TempDir()
+	rnd := make([]byte, 8)
+	n, err := rand.Read(rnd)
+	if err != nil {
+		return err
+	}
+	basename := fmt.Sprintf("fcgi%x", rnd[:n])
+	filename := path.Join(tmpdir, basename)
+
+	listener, err := net.Listen("unix", filename)
+	if err != nil {
+		return err
+	}
+	socket, err := listener.(*net.UnixListener).File()
+	if err != nil {
+		listener.Close()
+		return err
+	}
+	cmd := exec.Command(sd.app, sd.args...)
+	cmd.Stdin = socket
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	err = cmd.Start()
+	if err != nil {
+		socket.Close()
+		listener.Close()
+		return err
+	}
+	sd.stdin = socket
+	sd.listener = listener
+	sd.cmd = cmd
+	sd.filename = filename
+	return nil
+}
+
+func (sd *StdinDialer) Close() {
+	if sd.stdin != nil {
+		sd.stdin.Close()
+		sd.stdin = nil
+	}
+	if sd.listener != nil {
+		sd.listener.Close()
+		sd.listener = nil
+	}
+	if sd.cmd != nil {
+		sd.cmd.Process.Kill()
+		sd.cmd = nil
+	}
+	sd.filename = ""
+}

gofcgisrv.go

@@ -37,11 +37,11 @@ func (f RequesterFunc) Request(env []string, stdin io.Reader, stdout io.Writer,
 // Server is the external interface. It manages connections to a single FastCGI application.
 // A server may maintain many connections, each of which may multiplex many requests.
 type Server struct {
-	applicationAddr string
-	connections     []*conn
-	reqLock         sync.Mutex
-	reqCond         *sync.Cond
-	initialized     bool
+	dialer      Dialer
+	connections []*conn
+	reqLock     sync.Mutex
+	reqCond     *sync.Cond
+	initialized bool
 
 	// Parameters of the application
 	CanMultiplex bool
@@ -51,7 +51,18 @@ type Server struct {
 
 // NewServer creates a server that will attempt to connect to the application at the given address over TCP.
 func NewServer(applicationAddr string) *Server {
-	s := &Server{applicationAddr: applicationAddr}
+	s := &Server{}
+	s.dialer = TCPDialer{addr: applicationAddr}
+	s.MaxConns = 1
+	s.MaxRequests = 1
+	s.reqCond = sync.NewCond(&s.reqLock)
+	return s
+}
+
+// NewFCGIStdin creates a server that runs the app and connects over stdin.
+func NewFCGIStdin(app string, args ...string) *Server {
+	s := &Server{}
+	s.dialer = &StdinDialer{app: app, args: args}
 	s.MaxConns = 1
 	s.MaxRequests = 1
 	s.reqCond = sync.NewCond(&s.reqLock)
@@ -89,7 +100,7 @@ func (s *Server) processGetValuesResult(rec record) (int, error) {
 // PHP barfs on FCGI_GET_VALUES. I don't know why. Maybe it expects a different connection.
 // For now don't do it unless asked.
 func (s *Server) GetValues() error {
-	c, err := net.Dial("tcp", s.applicationAddr)
+	c, err := s.dialer.Dial()
 	time.AfterFunc(time.Second, func() { c.Close() })
 	if err != nil {
 		return err
@@ -147,7 +158,7 @@ func (s *Server) Request(env []string, stdin io.Reader, stdout io.Writer, stderr
 func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	env := HTTPEnv(nil, r)
 	buffer := bytes.NewBuffer(nil)
-	s.Request(env, r.Body, buffer, buffer)
+	s.Request(env, r.Body, buffer, os.Stderr)
 
 	// Add any headers produced by the application, and skip to the response.
 	ProcessResponse(buffer, w, r)
@@ -170,7 +181,7 @@ func (s *Server) newRequest() (*request, error) {
 		s.reqCond.Wait()
 	}
 	// We will always need to create a new connection, for now.
-	netconn, err := net.Dial("tcp", s.applicationAddr)
+	netconn, err := s.dialer.Dial()
 	if err != nil {
 		return nil, err
 	}

py_test.go

@@ -33,7 +33,7 @@ func waitForConn(addr string, timeout time.Duration) error {
 }
 
 func TestPyServer(t *testing.T) {
-	cmd := exec.Command("python", "./testdata/cgi_test.py", "--port=9001")
+	cmd := exec.Command("python", "./testdata/cgi_test.py", "--host=127.0.0.1", "--port=9001")
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 	err := cmd.Start()
@@ -65,7 +65,7 @@ func TestPyCGI(t *testing.T) {
 }
 
 func TestPySCGI(t *testing.T) {
-	cmd := exec.Command("python", "./testdata/cgi_test.py", "--scgi", "--port=9002")
+	cmd := exec.Command("python", "./testdata/cgi_test.py", "--scgi", "--host=127.0.0.1", "--port=9002")
 	// flup barfs some output. Why?? Seems wrong to me.
 	err := cmd.Start()
 	if err != nil {
@@ -82,3 +82,16 @@ func TestPySCGI(t *testing.T) {
 		expected: "This is a test",
 	})
 }
+
+func TestPyFcgiStdin(t *testing.T) {
+	s := NewFCGIStdin("python", "./testdata/cgi_test.py", "--fcgi")
+	s.dialer.(*StdinDialer).Start()
+	defer s.dialer.(*StdinDialer).Close()
+	testRequester(t, httpTestData{
+		name:     "py fastcgi stdin",
+		f:        s,
+		body:     strings.NewReader("This is a test"),
+		status:   200,
+		expected: "This is a test",
+	})
+}

testdata/cgi_test.py

@@ -13,15 +13,18 @@ def resp():
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description="FastCGI test client application")
-    parser.add_argument('--host', type=str, default='127.0.0.1', help='Hostname to listen on')
-    parser.add_argument('--port', type=int, default='9000', help='Port to listen on')
+    parser.add_argument('--host', type=str, help='Hostname to listen on')
+    parser.add_argument('--port', type=int, help='Port to listen on')
     group = parser.add_mutually_exclusive_group()
     group.add_argument('--fcgi', action="store_true", help='Run as a FastCGI server')
     group.add_argument('--cgi', action="store_true", help='Run as a CGI server')
     group.add_argument('--scgi', action="store_true", help='Run as an SCGI server')
     args = parser.parse_args()
 
-    kwargs = {'bindAddress' : (args.host, args.port) }
+    if args.host and args.port:
+	kwargs = {'bindAddress' : (args.host, args.port) }
+    else:
+        kwargs = {}
     if args.cgi:
         import flup.server.cgi as cgimod
         kwargs = {}
@@ -32,5 +35,5 @@ def resp():
 
     WSGIServer = cgimod.WSGIServer
 
-    WSGIServer(echo, **kwargs).run()
+    result = WSGIServer(echo, **kwargs).run()