Change [proto]-server to [proto]-listen (#9)

* add [proto]-listen versions

* update docs

* rename methods/errors

Author: wybiral

README.md

@@ -22,24 +22,24 @@ Any data that's fed into the input will be piped to the output.
 
 ## Examples
 
-Pipe from stdin to a new TCP server on port 8080:
+Pipe from stdin to a new TCP listener on port 8080:
 ```
-hookah -o tcp-server://localhost:8080
+hookah -o tcp-listen://localhost:8080
 ```
 
-Pipe from an existing TCP server on port 8080 to a new HTTP server on port 8081:
+Pipe from an existing TCP listener on port 8080 to a new HTTP listener on port 8081:
 ```
-hookah -i tcp://localhost:8080 -o http-server://localhost:8081
+hookah -i tcp://localhost:8080 -o http-listen://localhost:8081
 ```
 
 Pipe from a new Unix domain socket listener to stdout:
 ```
-hookah -i unix-server://path/to/sock
+hookah -i unix-listen://path/to/sock
 ```
 
-Pipe from a new HTTP server on port 8080 to an existing Unix domain socket:
+Pipe from a new HTTP listener on port 8080 to an existing Unix domain socket:
 ```
-hookah -i http-server://localhost:8080 -o unix://path/to/sock
+hookah -i http-listen://localhost:8080 -o unix://path/to/sock
 ```
 
 # Usage instructions (Go package)

examples_test.go

@@ -32,39 +32,39 @@ func ExampleNewInput_httpClient() {
 	r, err = hookah.NewInput("http://localhost:8080")
 }
 
-// Create HTTP server input.
-func ExampleNewInput_httpServer() {
-	r, err = hookah.NewInput("http-server://localhost:8080")
+// Create HTTP listen input.
+func ExampleNewInput_httpListen() {
+	r, err = hookah.NewInput("http-listen://localhost:8080")
 }
 
 // Create TCP client input.
 func ExampleNewInput_tcpClient() {
 	r, err = hookah.NewInput("tcp://localhost:8080")
 }
 
-// Create TCP server input.
-func ExampleNewInput_tcpServer() {
-	r, err = hookah.NewInput("tcp-server://localhost:8080")
+// Create TCP listen input.
+func ExampleNewInput_tcpListen() {
+	r, err = hookah.NewInput("tcp-listen://localhost:8080")
 }
 
 // Create Unix client input.
 func ExampleNewInput_unixClient() {
 	r, err = hookah.NewInput("unix://path/to/sock")
 }
 
-// Create Unix server input.
-func ExampleNewInput_unixServer() {
-	r, err = hookah.NewInput("unix-server://path/to/sock")
+// Create Unix listen input.
+func ExampleNewInput_unixListen() {
+	r, err = hookah.NewInput("unix-listen://path/to/sock")
 }
 
 // Create WebSocket client input.
 func ExampleNewInput_wsClient() {
 	r, err = hookah.NewInput("ws://localhost:8080")
 }
 
-// Create WebSocket server input.
-func ExampleNewInput_wsServer() {
-	r, err = hookah.NewInput("ws-server://localhost:8080")
+// Create WebSocket listen input.
+func ExampleNewInput_wsListen() {
+	r, err = hookah.NewInput("ws-listen://localhost:8080")
 }
 
 // NewOutput examples
@@ -94,37 +94,37 @@ func ExampleNewOutput_httpClient() {
 	w, err = hookah.NewOutput("http://localhost:8080")
 }
 
-// Create HTTP server output.
-func ExampleNewOutput_httpServer() {
-	w, err = hookah.NewOutput("http-server://localhost:8080")
+// Create HTTP listen output.
+func ExampleNewOutput_httpListen() {
+	w, err = hookah.NewOutput("http-listen://localhost:8080")
 }
 
 // Create TCP client output.
 func ExampleNewOutput_tcpClient() {
 	w, err = hookah.NewOutput("tcp://localhost:8080")
 }
 
-// Create TCP server output.
-func ExampleNewOutput_tcpServer() {
-	w, err = hookah.NewOutput("tcp-server://localhost:8080")
+// Create TCP listen output.
+func ExampleNewOutput_tcpListen() {
+	w, err = hookah.NewOutput("tcp-listen://localhost:8080")
 }
 
 // Create Unix client output.
 func ExampleNewOutput_unixClient() {
 	w, err = hookah.NewOutput("unix://path/to/sock")
 }
 
-// Create Unix server output.
-func ExampleNewOutput_unixServer() {
-	w, err = hookah.NewOutput("unix-server://path/to/sock")
+// Create Unix listen output.
+func ExampleNewOutput_unixListen() {
+	w, err = hookah.NewOutput("unix-listen://path/to/sock")
 }
 
 // Create WebSocket client output.
 func ExampleNewOutput_wsClient() {
 	w, err = hookah.NewOutput("ws://localhost:8080")
 }
 
-// Create WebSocket server output.
-func ExampleNewOutput_wsServer() {
-	w, err = hookah.NewOutput("ws-server://localhost:8080")
+// Create WebSocket listen output.
+func ExampleNewOutput_wsListen() {
+	w, err = hookah.NewOutput("ws-listen://localhost:8080")
 }

pkg/input/httpserver.go pkg/input/httplisten.gopkg/input/httpserver.go renamed to pkg/input/httplisten.go

@@ -6,7 +6,7 @@ import (
 	"sync"
 )
 
-type httpServerApp struct {
+type httpListenApp struct {
 	server *http.Server
 	// Channel of messages
 	ch chan []byte
@@ -16,9 +16,9 @@ type httpServerApp struct {
 	top []byte
 }
 
-// Create an HTTP server and return as ReadCloser
-func httpServer(addr string) (io.ReadCloser, error) {
-	app := &httpServerApp{}
+// Create an HTTP listener and return as ReadCloser
+func httpListen(addr string) (io.ReadCloser, error) {
+	app := &httpListenApp{}
 	app.server = &http.Server{
 		Addr:    addr,
 		Handler: http.HandlerFunc(app.handle),
@@ -30,7 +30,7 @@ func httpServer(addr string) (io.ReadCloser, error) {
 	return app, nil
 }
 
-func (app *httpServerApp) Read(b []byte) (int, error) {
+func (app *httpListenApp) Read(b []byte) (int, error) {
 	app.mu.Lock()
 	defer app.mu.Unlock()
 	if len(app.top) == 0 {
@@ -45,12 +45,12 @@ func (app *httpServerApp) Read(b []byte) (int, error) {
 	return n, nil
 }
 
-func (app *httpServerApp) Close() error {
+func (app *httpListenApp) Close() error {
 	close(app.ch)
 	return app.server.Close()
 }
 
-func (app *httpServerApp) handle(w http.ResponseWriter, r *http.Request) {
+func (app *httpListenApp) handle(w http.ResponseWriter, r *http.Request) {
 	defer r.Body.Close()
 	buffer := make([]byte, bufferSize)
 	for {

pkg/input/input.go

@@ -40,56 +40,56 @@ func New(opts string) (io.ReadCloser, error) {
 		return file(arg)
 	case "http":
 		if arg == "" {
-			return nil, errors.New("http client: no address supplied")
+			return nil, errors.New("http: no address supplied")
 		}
 		return httpClient("http://" + arg)
 	case "https":
 		if arg == "" {
-			return nil, errors.New("https client: no address supplied")
+			return nil, errors.New("https: no address supplied")
 		}
 		return httpClient("https://" + arg)
-	case "http-server":
+	case "http-listen", "http-server":
 		if arg == "" {
-			return nil, errors.New("http server: no address supplied")
+			return nil, errors.New("http-listen: no address supplied")
 		}
-		return httpServer(arg)
+		return httpListen(arg)
 	case "tcp":
 		if arg == "" {
-			return nil, errors.New("tcp client: no address supplied")
+			return nil, errors.New("tcp: no address supplied")
 		}
 		return tcpClient(arg)
-	case "tcp-server":
+	case "tcp-listen", "tcp-server":
 		if arg == "" {
-			return nil, errors.New("tcp server: no address supplied")
+			return nil, errors.New("tcp-listen: no address supplied")
 		}
-		return tcpServer(arg)
+		return tcpListen(arg)
 	case "unix":
 		if arg == "" {
-			return nil, errors.New("unix client: no address supplied")
+			return nil, errors.New("unix: no address supplied")
 		}
 		return unixClient(arg)
-	case "unix-server":
+	case "unix-listen", "unix-server":
 		if arg == "" {
-			return nil, errors.New("unix server: no address supplied")
+			return nil, errors.New("unix-listen: no address supplied")
 		}
-		return unixServer(arg)
+		return unixListen(arg)
 	case "ws":
 		if arg == "" {
-			return nil, errors.New("ws client: no address supplied")
+			return nil, errors.New("ws: no address supplied")
 		}
 		return wsClient("ws://" + arg)
 	case "wss":
 		if arg == "" {
-			return nil, errors.New("wss client: no address supplied")
+			return nil, errors.New("wss: no address supplied")
 		}
 		return wsClient("wss://" + arg)
-	case "ws-server":
+	case "ws-listen", "ws-server":
 		if arg == "" {
-			return nil, errors.New("ws server: no address supplied")
+			return nil, errors.New("ws-listen: no address supplied")
 		}
-		return wsServer(arg)
+		return wsListen(arg)
 	default:
-		return nil, errors.New("unknown in protocol: " + proto)
+		return nil, errors.New("unknown input protocol: " + proto)
 	}
 }
 

pkg/input/listenserver.go pkg/input/listen.gopkg/input/listenserver.go renamed to pkg/input/listen.go

@@ -6,7 +6,7 @@ import (
 	"sync"
 )
 
-type listenServerApp struct {
+type listenApp struct {
 	ln net.Listener
 	// Channel of messages
 	ch chan []byte
@@ -16,9 +16,9 @@ type listenServerApp struct {
 	top []byte
 }
 
-// Create a listen server and return as ReadCloser
-func listenServer(network, addr string) (io.ReadCloser, error) {
-	app := &listenServerApp{}
+// Create a listener and return as ReadCloser
+func listen(network, addr string) (io.ReadCloser, error) {
+	app := &listenApp{}
 	ln, err := net.Listen(network, addr)
 	if err != nil {
 		return nil, err
@@ -31,7 +31,7 @@ func listenServer(network, addr string) (io.ReadCloser, error) {
 	return app, nil
 }
 
-func (app *listenServerApp) Read(b []byte) (int, error) {
+func (app *listenApp) Read(b []byte) (int, error) {
 	app.mu.Lock()
 	defer app.mu.Unlock()
 	if len(app.top) == 0 {
@@ -46,12 +46,12 @@ func (app *listenServerApp) Read(b []byte) (int, error) {
 	return n, nil
 }
 
-func (app *listenServerApp) Close() error {
+func (app *listenApp) Close() error {
 	close(app.ch)
 	return app.ln.Close()
 }
 
-func (app *listenServerApp) serve() {
+func (app *listenApp) serve() {
 	defer app.ln.Close()
 	for {
 		conn, err := app.ln.Accept()
@@ -62,7 +62,7 @@ func (app *listenServerApp) serve() {
 	}
 }
 
-func (app *listenServerApp) handle(conn net.Conn) {
+func (app *listenApp) handle(conn net.Conn) {
 	defer conn.Close()
 	buffer := make([]byte, bufferSize)
 	for {

pkg/input/tcplisten.go

@@ -0,0 +1,10 @@
+package input
+
+import (
+	"io"
+)
+
+// Create a TCP listener and return as ReadCloser
+func tcpListen(addr string) (io.ReadCloser, error) {
+	return listen("tcp", addr)
+}

pkg/input/tcpserver.go

@@ -0,0 +1,10 @@
+package input
+
+import (
+	"io"
+)
+
+// Create a Unix listener and return as ReadCloser
+func unixListen(addr string) (io.ReadCloser, error) {
+	return listen("unix", addr)
+}