Support websocket

.github/workflows/check.yml

@@ -6,44 +6,25 @@ on:
       - main
 
 jobs:
-  check-stable:
+  test:
     runs-on: ubuntu-latest
 
     strategy:
       matrix:
-        rt: [tokio, async-std]
+        rt:        ["tokio", "async-std"]
+        x:         [",websocket", ""]
+        toolchain: ["stable", "nightly"]
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: ${{ matrix.toolchain }}
           profile:   minimal
           override:  true
 
       - uses: actions-rs/cargo@v1
         with:
           command: check
-          args: --features rt_${{ matrix.rt }}
-
-  check-nighlt:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        rt: [tokio, async-std]
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          profile:   minimal
-          override:  true
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: check
-          args: --features nightly,rt_${{ matrix.rt }}
+          args: --features rt_${{ matrix.rt }}${{ matrix.x }}${{ matrix.toolchain == "nightly" && ",nightly" || "" }},DEBUG

.github/workflows/test.yml

@@ -6,44 +6,25 @@ on:
       - main
 
 jobs:
-  test-stable:
+  test:
     runs-on: ubuntu-latest
 
     strategy:
       matrix:
-        rt: [tokio, async-std]
+        rt:        ["tokio", "async-std"]
+        x:         [",websocket", ""]
+        toolchain: ["stable", "nightly"]
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - uses: actions-rs/toolchain@v1
         with:
-          toolchain: stable
+          toolchain: ${{ matrix.toolchain }}
           profile:   minimal
           override:  true
 
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --features rt_${{ matrix.rt }},DEBUG
-
-  test-nightly:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        rt: [tokio, async-std]
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - uses: actions-rs/toolchain@v1
-        with:
-          toolchain: nightly
-          profile:   minimal
-          override:  true
-
-      - uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --features nightly,rt_${{ matrix.rt }},DEBUG
+          args: --features rt_${{ matrix.rt }}${{ matrix.x }}${{ matrix.toolchain == "nightly" && ",nightly" || "" }},DEBUG

README.md

@@ -184,6 +184,42 @@ async fn main() {
 
 <br/>
 
+### web socket
+Activate `websocket` feature.
+
+```rust
+use ohkami::prelude::*;
+use ohkami::websocket::{WebSocketContext, Message};
+
+fn handle_websocket(c: WebSocketContext) -> Response {
+    c.on_upgrade(|ws| async move {
+        while let Some(Ok(message)) = ws.recv().await {
+            match message {
+                Message::Text(text) => {
+                    let response = Message::from(text);
+                    if let Err(e) = ws.send(response).await {
+                        tracing::error!("{e}");
+                        break
+                    }
+                }
+                Message::Close(_) => break,
+                other => tracing::warning!("Unsupported message type: {other}"),
+            }
+        }
+    }).await
+}
+
+#[tokio::main]
+async fn main() {
+    Ohkami::new((
+        "/websocket"
+            .GET(handle_websocket)
+    )).howl(8080).await
+}
+```
+
+<br/>
+
 ### testing
 ```rust
 use ohkami::prelude::*;

ohkami/Cargo.toml

@@ -28,8 +28,17 @@ byte_reader      = "1.1.2"
 [features]
 rt_tokio         = ["dep:tokio"]
 rt_async-std     = ["dep:async-std"]
+websocket        = []
 nightly          = []
 
 ##### DEBUG #####
-DEBUG   = ["serde/derive", "tokio?/macros", "async-std?/attributes"]
-# default = ["rt_tokio", "DEBUG"]
+DEBUG   = [
+    "websocket",
+    "serde/derive", "tokio?/macros", "async-std?/attributes"
+]
+default = [
+    "rt_tokio",
+    #"rt_async-std",
+    "DEBUG",
+    # "nightly"
+]

ohkami/src/layer0_lib/status.rs

@@ -1,19 +1,26 @@
 #[derive(PartialEq)]
 pub enum Status {
+    SwitchingProtocols,
+
     OK,
     Created,
     NoContent,
+
     MovedPermanently,
     Found,
+
     BadRequest,
     Unauthorized,
     Forbidden,
     NotFound,
+
     InternalServerError,
     NotImplemented,
 } impl Status {
     #[inline(always)] pub(crate) const fn as_str(&self) -> &'static str {
         match self {
+            Self::SwitchingProtocols  => "101 Switching Protocols",
+
             Self::OK                  => "200 OK",
             Self::Created             => "201 Created",
             Self::NoContent           => "204 No Content",

ohkami/src/layer0_lib/string.rs

@@ -14,3 +14,4 @@ pub trait IntoCows<'l> {
 }
 impl IntoCows<'static> for &'static str {fn into_cow(self) -> Cow<'static, str> {Cow::Borrowed(self)}}
 impl IntoCows<'static> for String {fn into_cow(self) -> Cow<'static, str> {Cow::Owned(self)}}
+impl IntoCows<'static> for Cow<'static, str> {fn into_cow(self) -> Cow<'static, str> {self}}

ohkami/src/layer1_req_res/mod.rs

@@ -1,4 +1,4 @@
-mod request; pub use request::*;
+mod request;  pub use request::*;
 mod response; pub use response::*;
 
 

ohkami/src/layer1_req_res/response/headers.rs

@@ -2,18 +2,26 @@
 #![allow(non_snake_case)]
 #![allow(unused)] // until ....
 
-use std::{collections::BTreeMap, sync::OnceLock};
-use crate::{layer0_lib::now};
+use std::{collections::BTreeMap, sync::OnceLock, borrow::Cow};
+use crate::{layer0_lib::{now, IntoCows}};
 
 
-struct Header(Option<&'static str>);
+struct Header(Option<Cow<'static, str>>);
 
 pub trait HeaderValue {
-    fn into_header_value(self) -> Option<&'static str>;
-}
-impl HeaderValue for &'static str {fn into_header_value(self) -> Option<&'static str> {Some(self)}}
-impl HeaderValue for Option<&'static str> {fn into_header_value(self) -> Option<&'static str> {self}}
-
+    fn into_header_value(self) -> Option<Cow<'static, str>>;
+} const _: () = {
+    impl<S: IntoCows<'static>> HeaderValue for S {
+        fn into_header_value(self) -> Option<Cow<'static, str>> {
+            Some(self.into_cow())
+        }
+    }
+    impl HeaderValue for Option<()> {
+        fn into_header_value(self) -> Option<Cow<'static, str>> {
+            None
+        }
+    }
+};
 
 macro_rules! ResponseHeaders {
     ($(
@@ -23,22 +31,23 @@ macro_rules! ResponseHeaders {
     )*) => {
         /// Headers in a response.
         /// 
-        /// In current version, this expects values are `&'static str` or `None`.
+        /// Expected values: &'static str, String, Cow<'static, str>, or `None`
         /// 
-        /// - `&'static str` sets the header value to it
-        /// - `None` removes the header value
+        /// - `None` clears value of the header
+        /// - others set the header to thet value
         /// 
         /// <br/>
         /// 
         /// - Content-Type
         /// - Content-Length
         /// - Access-Control-*
+        /// - headers related to WebSocket handshake
         /// 
-        /// are managed by ohkami and MUST NOT be set by `.custom` ( `.custom` has to be used **ONLY** to set custom HTTP headers )
+        /// are managed by ohkami and MUST NOT be set by `.custom` ( `.custom` has to be used **ONLY** to set custom HTTP headers like `X-MyApp-Data: amazing` )
         pub struct ResponseHeaders {
             $( $group: bool, )*
             $($( $name: Header, )*)*
-            custom: BTreeMap<&'static str, &'static str>,
+            custom: BTreeMap<&'static str, Cow<'static, str>>,
             cors_str: &'static str,
         }
 
@@ -76,8 +85,8 @@ macro_rules! ResponseHeaders {
                 $(
                     if self.$group {
                         $(
-                            if let Some(value) = self.$name.0 {
-                                h.push_str($key);h.push_str(value);h.push('\r');h.push('\n');
+                            if let Some(value) = &self.$name.0 {
+                                h.push_str($key);h.push_str(&value);h.push('\r');h.push('\n');
                             }
                         )*
                     }
@@ -141,9 +150,7 @@ impl ResponseHeaders {
     pub fn custom(&mut self, key: &'static str, value: impl HeaderValue) -> &mut Self {
         match value.into_header_value() {
             Some(value) => {
-                self.custom.entry(key)
-                    .and_modify(|v| *v = value)
-                    .or_insert(value);
+                self.custom.insert(key, value);
                 self
             }
             None => {

ohkami/src/layer2_context/mod.rs

@@ -73,61 +73,53 @@ use crate::{
 /// }
 /// ```
 pub struct Context {
+    #[cfg(feature="websocket")]
+    pub(crate) upgrade_id: Option<crate::x_websocket::UpgradeID>,
+
     pub headers: ResponseHeaders,
 }
 
 impl Context {
     #[inline(always)] pub(crate) fn new() -> Self {
-        Self { headers: ResponseHeaders::new() }
-    }
-}
+        Self {
+            #[cfg(feature="websocket")]
+            upgrade_id: None,
 
-impl Context {
-    #[inline] pub fn OK(&self) -> Response {
-        Response {
-            status:  Status::OK,
-            headers: self.headers.to_string(),
-            content: None,
-        }
-    }
-    #[inline] pub fn Created(&self) -> Response {
-        Response {
-            status:  Status::Created,
-            headers: self.headers.to_string(),
-            content: None,
-        }
-    }
-    #[inline] pub fn NoContent(&self) -> Response {
-        Response {
-            status:  Status::NoContent,
-            headers: self.headers.to_string(),
-            content: None,
+            headers: ResponseHeaders::new(),
         }
     }
 }
 
-macro_rules! impl_error_response {
-    ($( $name:ident ),*) => {
+macro_rules! generate_response {
+    ($( $status:ident ),* $(,)?) => {$(
         impl Context {
-            $(
-                #[inline] pub fn $name(&self) -> Response {
-                    Response {
-                        status:  Status::$name,
-                        headers: self.headers.to_string(),
-                        content: None,
-                    }
+            #[inline] pub fn $status(&self) -> Response {
+                Response {
+                    status:  Status::$status,
+                    headers: self.headers.to_string(),
+                    content: None,
                 }
-            )*
+            }
         }
-    };
-} impl_error_response!(
+    )*};
+} generate_response! {
+    SwitchingProtocols,
+
+    OK,
+    Created,
+    NoContent,
+
+    // MovedPermanently,
+    // Found,
+
     BadRequest,
     Unauthorized,
     Forbidden,
     NotFound,
+
     InternalServerError,
-    NotImplemented
-);
+    NotImplemented,
+}
 
 impl Context {
     #[inline] pub fn redirect_to(&self, location: impl AsStr) -> Response {