zstd suppoer in Hunchentoot

Author: fsmunoz

clack.lisp

@@ -32,6 +32,8 @@
   (let ((headers '(:content-type "text/event-stream; charset=utf-8"
                    :cache-control "no-cache"
                    :connection "keep-alive")))
+    ;; FIXME
+    (setf (compressed-stream generator) nil)
     (setf (response generator)
           (lack/util/writer-stream:make-writer-stream
            (funcall responder `(200 ,headers))))))

datastar-cl.asd

@@ -14,7 +14,10 @@
                #:flexi-streams
                #:hunchentoot
                #:clack
-               #:lack-util-writer-stream)
+               #:lack-util-writer-stream
+               #:zstd
+               #:gzip-stream
+               #:salza2)
   :components ((:file "package")
                (:file "datastar-cl")
                (:file "conditions")

datastar-cl.lisp

@@ -102,6 +102,9 @@
    (response :initarg :response
              :accessor response
              :documentation "The response stream.")
+   (compressed-stream :initarg :compressed-stream
+                      :accessor compressed-stream
+                      :documentation "The compressed stream (depending on the algorithm)")
    (lock :initform (bt:make-lock)
          :reader lock
          :documentation "Thread safety lock for stream operations."))
@@ -154,14 +157,35 @@
   (declare (ignore event-type data-lines event-id retry-duration))
   (ensure-connection-open generator))
 
+;; (defmethod send-event ((generator sse-generator) event-type data-lines
+;;                        &key event-id retry-duration)
+;;   "Send an SSE event with thread safety.
+
+;;    Signals: STREAM-ERROR if the response stream is closed or writing fails.
+;;             This is standard CL behavior - no wrapping is performed."
+;;   (bt:with-lock-held ((lock generator))
+;;     (let ((stream (response generator)))
+;;       (format stream "event: ~a~%" (string-downcase (string event-type)))
+;;       (when event-id
+;;         (format stream "id: ~a~%" event-id))
+;;       (when retry-duration
+;;         (format stream "retry: ~a~%" retry-duration))
+;;       (dolist (line data-lines)
+;;         (format stream "data: ~a~%" line))
+;;       (format stream "~%")
+;;       ;; flush immediately
+;;       (force-output stream))))
+
+
 (defmethod send-event ((generator sse-generator) event-type data-lines
                        &key event-id retry-duration)
   "Send an SSE event with thread safety.
 
    Signals: STREAM-ERROR if the response stream is closed or writing fails.
             This is standard CL behavior - no wrapping is performed."
   (bt:with-lock-held ((lock generator))
-    (let ((stream (response generator)))
+    (let ((stream (response generator))
+          (compressed-stream (compressed-stream generator)))
       (format stream "event: ~a~%" (string-downcase (string event-type)))
       (when event-id
         (format stream "id: ~a~%" event-id))
@@ -171,6 +195,8 @@
         (format stream "data: ~a~%" line))
       (format stream "~%")
       ;; flush immediately
+      (when compressed-stream
+        (finish-output (compressed-stream generator)))
       (force-output stream))))
 
 (defmethod patch-elements ((generator sse-generator) (elements string)

hunchentoot.lisp

@@ -11,18 +11,46 @@
   (:documentation "Hunchentoot-specific SSE generator implementation."))
 
 
-(defmethod initialize-instance :after ((generator hunchentoot-sse-generator) &key request &allow-other-keys)
-  "Set up SSE headers and response stream for Hunchentoot."
+;; (defmethod initialize-instance :after ((generator hunchentoot-sse-generator) &key request &allow-other-keys)
+;;   "Set up SSE headers and response stream for Hunchentoot."
+;;   ;; Set headers using Hunchentoot API
+;;   (setf (hunchentoot:content-type*) "text/event-stream; charset=utf-8"
+;;         (hunchentoot:header-out "Cache-Control") "no-cache")
+;;   ;; HTTP/1.1 specific headers
+;;   (when (string= (hunchentoot:server-protocol request) "HTTP/1.1")
+;;     (setf (hunchentoot:header-out "Connection") "keep-alive"))
+;;   ;; Initialize response stream
+;;   (let ((raw-stream (hunchentoot:send-headers)))
+;;     (setf (response generator)
+;;           (flex:make-flexi-stream raw-stream :external-format :utf-8))))
+
+
+(defmethod initialize-instance :after ((generator hunchentoot-sse-generator) &key request  &allow-other-keys)
+  "Set up SSE headers and response stream for Hunchentoot. Use compression if available"
   ;; Set headers using Hunchentoot API
-  (setf (hunchentoot:content-type*) "text/event-stream; charset=utf-8"
-        (hunchentoot:header-out "Cache-Control") "no-cache")
-  ;; HTTP/1.1 specific headers
-  (when (string= (hunchentoot:server-protocol request) "HTTP/1.1")
-    (setf (hunchentoot:header-out "Connection") "keep-alive"))
-  ;; Initialize response stream
-  (let ((raw-stream (hunchentoot:send-headers)))
-    (setf (response generator)
-          (flex:make-flexi-stream raw-stream :external-format :utf-8))))
+  (let ((accepts-zstd (search "zstd" (hunchentoot:header-in* :accept-encoding request)
+                               :test #'string-equal)))
+    (setf (hunchentoot:content-type*) "text/event-stream; charset=utf-8"
+          (hunchentoot:header-out "Cache-Control") "no-cache")
+    ;; HTTP/1.1 specific headers
+    
+    (when (string= (hunchentoot:server-protocol request) "HTTP/1.1")
+      (setf (hunchentoot:header-out "Connection") "keep-alive"))
+    (when accepts-zstd
+      (setf (hunchentoot:header-out "Content-Encoding") "zstd"
+            (hunchentoot:header-out "Vary") "Accept-Encoding"))
+    (let* ((raw-stream (hunchentoot:send-headers))
+           (compressed-stream (when accepts-zstd
+                                (zstd:make-compressing-stream raw-stream :level 3)))
+           (utf8-stream (if compressed-stream
+                            (flex:make-flexi-stream compressed-stream :external-format :utf-8)
+                            (flex:make-flexi-stream raw-stream :external-format :utf-8)
+                            )))
+    
+      (setf (response generator) utf8-stream)
+      (setf (compressed-stream generator) compressed-stream))))
+    
+
 
 (defmethod read-signals ((request hunchentoot:request) 
                          &key (catch-errors *catch-errors-p*))