image: updates to webp clientv0.8.2

- Support a logger
- Support readiness checks for the server
- Support converting raw image bytes instead of tiff

1 files changed, 74 insertions, 8 deletions

diff --git a/image/webp/client.go b/image/webp/client.go
index 6b08b72..aabf240 100644
--- a/image/webp/client.go
+++ b/image/webp/client.go
@@ -13,7 +13,9 @@ import (
         "path"
         "strconv"
         "syscall"
+        "time"
 
+        "code.crute.us/mcrute/golib/log"
         "golang.org/x/image/tiff"
 )
 
@@ -22,8 +24,9 @@ import (
 // bytestream. This struct is only threadsafe after Start has been
 // called.
 type WebPConvertClient struct {
-        p *exec.Cmd
-        c *http.Client
+        p      *exec.Cmd
+        c      *http.Client
+        Logger log.LeveledLogger
 }
 
 // Start starts the server, cancelling the passed context will stop
@@ -31,12 +34,17 @@ type WebPConvertClient struct {
 // process and not just context.Background. This function will return an
 // error if setup fails but does not block.
 func (c *WebPConvertClient) Start(ctx context.Context) error {
+        if c.Logger == nil {
+                c.Logger = &log.NoopLeveledLogger{}
+        }
+
         sockDir, err := os.MkdirTemp("", "webp-*")
         if err != nil {
                 return err
         }
 
         sockPath := path.Join(sockDir, "webp.sock")
+        c.Logger.Debugf("Webp conversion server socket: %s", sockPath)
 
         c.c = &http.Client{
                 Transport: &http.Transport{
@@ -53,6 +61,7 @@ func (c *WebPConvertClient) Start(ctx context.Context) error {
         }
 
         c.p.Cancel = func() error {
+                c.Logger.Debugf("Shutting down webp conversion server")
                 if err := c.p.Process.Signal(syscall.SIGTERM); err != nil {
                         return err
                 }
@@ -65,6 +74,11 @@ func (c *WebPConvertClient) Start(ctx context.Context) error {
                 os.RemoveAll(sockDir)
         }()
 
+        if err := c.awaitServerReadiness(ctx, 10); err != nil {
+                c.p.Cancel()
+                return err
+        }
+
         select {
         case err = <-ec:
                 return err
@@ -73,6 +87,47 @@ func (c *WebPConvertClient) Start(ctx context.Context) error {
         }
 }
 
+// awaitServerReadiness waits for the server to become ready by pinging
+// its endpoint. This should happen rather quickly, but without this
+// check it can be a race to see if the server starts before the first
+// call is made in some programs.
+func (c *WebPConvertClient) awaitServerReadiness(ctx context.Context, maxTries int) error {
+        for {
+                c.Logger.Debugf("Waiting for webp conversion server to be ready")
+
+                maxTries--
+                if maxTries == 0 {
+                        break
+                }
+
+                if err := c.ping(ctx); err == nil {
+                        return nil
+                }
+
+                time.Sleep(time.Second)
+        }
+        return fmt.Errorf("Webp server failed to become ready")
+}
+
+func (c *WebPConvertClient) ping(ctx context.Context) error {
+        req, err := http.NewRequestWithContext(ctx, http.MethodGet, "http://unix/ping", nil)
+        if err != nil {
+                return err
+        }
+
+        res, err := c.c.Do(req)
+        if err != nil {
+                return err
+        }
+        defer res.Body.Close()
+
+        if res.StatusCode != http.StatusOK {
+                return fmt.Errorf("server not ready")
+        }
+
+        return nil
+}
+
 // Convert encodes an image as TIFF and sends it to the conversion
 // server. It returns either an error or the webp encoded bytes from the
 // input image.
@@ -86,7 +141,18 @@ func (c *WebPConvertClient) Convert(ctx context.Context, img image.Image, qualit
                 return nil, err
         }
 
-        req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://unix/", bb)
+        return c.ConvertBytes(ctx, bb.Bytes(), quality, lossless, exact)
+}
+
+// ConvertBytes takes an image in any format and sends it to the
+// conversion server. It returns either an error or the webp encoded
+// bytes from the input image.
+func (c *WebPConvertClient) ConvertBytes(ctx context.Context, img []byte, quality int, lossless, exact bool) ([]byte, error) {
+        if c.c == nil {
+                return nil, fmt.Errorf("WebPConvertClient has not been started")
+        }
+
+        req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://unix/", bytes.NewReader(img))
         if err != nil {
                 return nil, err
         }
@@ -100,7 +166,7 @@ func (c *WebPConvertClient) Convert(ctx context.Context, img image.Image, qualit
         }
         defer res.Body.Close()
 
-        if res.StatusCode != 200 {
+        if res.StatusCode != http.StatusOK {
                 e, err := io.ReadAll(res.Body)
                 if err != nil {
                         return nil, err
@@ -108,10 +174,10 @@ func (c *WebPConvertClient) Convert(ctx context.Context, img image.Image, qualit
                 return nil, fmt.Errorf("WebPConvertClient server error: %s", e)
         }
 
-        bb.Reset()
-        if _, err := io.Copy(bb, res.Body); err != nil {
-                return nil, err
+        webp, err := io.ReadAll(res.Body)
+        if err != nil {
+                return nil, fmt.Errorf("WebPConvertClient error reading response: %w", err)
         }
 
-        return bb.Bytes(), nil
+        return webp, nil
 }