Improve http/reader/writer; add net package; procs support vars

exec/proc.go

@@ -315,3 +315,8 @@ func (p *Proc) GetErrorPipe() io.Reader {
 func (p *Proc) hasStarted() bool {
 	return (p.cmd.Process != nil && p.cmd.Process.Pid != 0)
 }
+
+// Parse parses the command string and returns its tokens
+func Parse(cmd string) ([]string, error) {
+	return parse(cmd)
+}

fs/file_writer.go

@@ -59,6 +59,11 @@ func (fw *FileWriter) SetVars(variables *vars.Variables) *FileWriter {
 	return fw
 }
 
+func (fw *FileWriter) WithMode(mode os.FileMode) *FileWriter {
+	fw.mode = mode
+	return fw
+}
+
 // Err returns FileWriter error during execution
 func (fw *FileWriter) Err() error {
 	return fw.err

http/http_reader.go

@@ -1,10 +1,9 @@
 package http
 
 import (
-	"io"
 	"net/http"
+	"time"
 
-	"github.com/vladimirvivien/gexe/fs"
 	"github.com/vladimirvivien/gexe/vars"
 )
 
@@ -13,7 +12,6 @@ type ResourceReader struct {
 	client *http.Client
 	err    error
 	url    string
-	res    *Response
 	vars   *vars.Variables
 }
 
@@ -40,73 +38,71 @@ func (r *ResourceReader) Err() error {
 	return r.err
 }
 
-// Response returns the server's response info
-func (r *ResourceReader) Response() *Response {
-	return r.res
+// WithTimeout sets the HTTP reader's timeout
+func (r *ResourceReader) WithTimeout(to time.Duration) *ResourceReader {
+	r.client.Timeout = to
+	return r
 }
 
-// Bytes returns the server response as a []byte
-func (r *ResourceReader) Bytes() []byte {
-	if err := r.Do().Err(); err != nil {
-		r.err = err
-		return nil
-	}
-	return r.read()
-}
+// // Bytes returns the server response as a []byte
+// func (r *ResourceReader) Bytes() []byte {
+// 	if err := r.Do().Err(); err != nil {
+// 		r.err = err
+// 		return nil
+// 	}
+// 	return r.read()
+// }
 
-// String returns the server response as a string
-func (r *ResourceReader) String() string {
-	if err := r.Do().Err(); err != nil {
-		r.err = err
-		return ""
-	}
-	return string(r.read())
-}
+// // String returns the server response as a string
+// func (r *ResourceReader) String() string {
+// 	if err := r.Do().Err(); err != nil {
+// 		r.err = err
+// 		return ""
+// 	}
+// 	return string(r.read())
+// }
 
-// Body returns an io.ReadCloser to stream the server response.
-// NOTE: ensure to close the stream when finished.
-func (r *ResourceReader) Body() io.ReadCloser {
-	if err := r.Do().Err(); err != nil {
-		r.err = err
-		return nil
-	}
-	return r.res.body
-}
+// // Body returns an io.ReadCloser to stream the server response.
+// // NOTE: ensure to close the stream when finished.
+// func (r *ResourceReader) Body() io.ReadCloser {
+// 	if err := r.Do().Err(); err != nil {
+// 		r.err = err
+// 		return nil
+// 	}
+// 	return r.res.body
+// }
 
 // Do invokes the client.Get to "GET" the content from server
-func (r *ResourceReader) Do() *ResourceReader {
+func (r *ResourceReader) Do() *Response {
 	res, err := r.client.Get(r.url)
 	if err != nil {
-		r.err = err
-		r.res = &Response{}
-		return r
+		return &Response{err: err}
 	}
-	r.res = &Response{stat: res.Status, statCode: res.StatusCode, body: res.Body}
-	return r
+	return &Response{stat: res.Status, statCode: res.StatusCode, body: res.Body}
 }
 
-func (r *ResourceReader) WriteFile(fileName string) error {
-	fileName = r.vars.Eval(fileName)
-	if err := r.Do().Err(); err != nil {
-		return err
-	}
-	if err := fs.Write(fileName).From(r.Body()).Err(); err != nil {
-		return err
-	}
-	return nil
-}
+// func (r *ResourceReader) WriteFile(fileName string) error {
+// 	fileName = r.vars.Eval(fileName)
+// 	if err := r.Do().Err(); err != nil {
+// 		return err
+// 	}
+// 	if err := fs.Write(fileName).WithMode(0766).From(r.Body()).Err(); err != nil {
+// 		return err
+// 	}
+// 	return nil
+// }
 
-// read reads the content of the response body and returns a []byte
-func (r *ResourceReader) read() []byte {
-	if r.res.body == nil {
-		return nil
-	}
+// // read reads the content of the response body and returns a []byte
+// func (r *ResourceReader) read() []byte {
+// 	if r.res.body == nil {
+// 		return nil
+// 	}
 
-	data, err := io.ReadAll(r.res.body)
-	defer r.res.body.Close()
-	if err != nil {
-		r.err = err
-		return nil
-	}
-	return data
-}
+// 	data, err := io.ReadAll(r.res.body)
+// 	defer r.res.body.Close()
+// 	if err != nil {
+// 		r.err = err
+// 		return nil
+// 	}
+// 	return data
+// }

http/http_reader_test.go

@@ -141,9 +141,8 @@ func TestHttpReader_Do(t *testing.T) {
 				t.Fatal("unexpected server response length: ", dataLen)
 			}
 
-			res := r.Response()
-			if res.StatusCode() != test.status {
-				t.Fatal("got unexpected status code: ", res.StatusCode())
+			if r.StatusCode() != test.status {
+				t.Fatal("got unexpected status code: ", r.StatusCode())
 			}
 		})
 	}

http/http_response.go

@@ -7,6 +7,7 @@ type Response struct {
 	stat     string
 	statCode int
 	body     io.ReadCloser
+	err      error
 }
 
 // Status returns the standard lib http.Response.Status value from the server
@@ -24,3 +25,33 @@ func (res *Response) StatusCode() int {
 func (res *Response) Body() io.ReadCloser {
 	return res.body
 }
+
+// Err returns the response known error
+func (r *Response) Err() error {
+	return r.err
+}
+
+// Bytes returns the server response as a []byte
+func (r *Response) Bytes() []byte {
+	return r.read()
+}
+
+// String returns the server response as a string
+func (r *Response) String() string {
+	return string(r.read())
+}
+
+// read reads the content of the response body and returns as []byte
+func (r *Response) read() []byte {
+	if r.body == nil {
+		return nil
+	}
+
+	data, err := io.ReadAll(r.body)
+	defer r.body.Close()
+	if err != nil {
+		r.err = err
+		return nil
+	}
+	return data
+}

http/http_writer.go

@@ -6,6 +6,7 @@ import (
 	"net/http"
 	"net/url"
 	"strings"
+	"time"
 
 	"github.com/vladimirvivien/gexe/vars"
 )
@@ -39,6 +40,12 @@ func (w *ResourceWriter) SetVars(variables *vars.Variables) *ResourceWriter {
 	return w
 }
 
+// WithTimeout sets the HTTP client's timeout
+func (w *ResourceWriter) WithTimeout(to time.Duration) *ResourceWriter {
+	w.client.Timeout = to
+	return w
+}
+
 // Err returns the last known error for the post operation
 func (w *ResourceWriter) Err() error {
 	return w.err

net.go

@@ -0,0 +1,9 @@
+package gexe
+
+import (
+	"github.com/vladimirvivien/gexe/net"
+)
+
+func (e *Echo) AddressUsable(addr string) error {
+	return net.AddrUsable(e.Eval(addr))
+}

net/listener.go

@@ -0,0 +1,29 @@
+package net
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"os"
+	"syscall"
+)
+
+func AddrUsable(address string) error {
+	addr, err := net.ResolveTCPAddr("tcp", address)
+	if err != nil {
+		return fmt.Errorf("net: address parsing: %s", err)
+	}
+
+	lsnr, err := net.Listen(addr.Network(), addr.String())
+
+	if err != nil {
+		sysErr, ok := err.(*os.SyscallError)
+		if ok && errors.Is(sysErr.Err, syscall.EADDRINUSE) {
+			return fmt.Errorf("net: addr in use: %s", sysErr.Err)
+		}
+		return fmt.Errorf("net: %s", err)
+	}
+
+	defer lsnr.Close()
+	return nil
+}

procs.go

@@ -69,3 +69,14 @@ func (e *Echo) RunConcur(cmdStrs ...string) *exec.CommandResult {
 func (e *Echo) Pipe(cmdStrs ...string) *exec.PipedCommandResult {
 	return exec.CommandsWithVars(e.vars, cmdStrs...).Pipe()
 }
+
+// ParseCommand parses the string into individual command tokens
+func (e *Echo) ParseCommand(cmdStr string) (cmdName string, args []string) {
+	result, err := exec.Parse(e.vars.Eval(cmdStr))
+	if err != nil {
+		e.err = err
+	}
+	cmdName = result[0]
+	args = result[1:]
+	return
+}