make max_pending_rows configurable and increase the default from 128 to 256

closes #441

Author: lovasoa

CHANGELOG.md

@@ -32,6 +32,7 @@
     - Add the ability to use local Woff2 fonts in the [shell](https://sql.ophir.dev/documentation.sql?component=shell#component) component. This is useful to use custom fonts in your website, without depending on google fonts (and disclosing your users' IP addresses to google).
     - Add a `fixed_top_menu` attribute to make the top menu sticky. This is useful to keep the menu visible even when the user scrolls down the page.
  - Add a `wrap` attribute to the `list` component to wrap items on multiple lines when they are too long.
+ - New `max_pending_rows` [configuration option](https://sql.ophir.dev/configuration.md) to limit the number of messages that can be sent to the client before they are read. Usefule when sending large amounts of data to slow clients.
 
 ## 0.23.0 (2024-06-09)
 

configuration.md

@@ -23,6 +23,7 @@ Here are the available configuration options and their default values:
 | `configuration_directory`                     | `./sqlpage/`                                                | The directory where the `sqlpage.json` file is located. This is used to find the path to [`templates/`](https://sql.ophir.dev/custom_components.sql), [`migrations/`](https://sql.ophir.dev/your-first-sql-website/migrations.sql), and `on_connect.sql`. Obviously, this configuration parameter can be set only through environment variables, not through the `sqlpage.json` file itself in order to find the `sqlpage.json` file. Be careful not to use a path that is accessible from the public WEB_ROOT |
 | `allow_exec`                                  | false                                                       | Allow usage of the `sqlpage.exec` function. Do this only if all users with write access to sqlpage query files and to the optional `sqlpage_files` table on the database are trusted.                                                                  |
 | `max_uploaded_file_size`                      | 5242880                                                     | Maximum size of uploaded files in bytes. Defaults to 5 MiB.                                                                                                                                                                                            |
+| `max_pending_rows`                        | 256                                                        | Maximum number of rendered rows that can be queued up in memory when a client is slow to receive them. |
 | `https_domain`                                |                                                             | Domain name to request a certificate for. Setting this parameter will automatically make SQLPage listen on port 443 and request an SSL certificate. The server will take a little bit longer to start the first time it has to request a certificate.  |
 | `https_certificate_email`                     | contact@<https_domain>                                      | The email address to use when requesting a certificate.                                                                                                                                                                                                |
 | `https_certificate_cache_dir`                 | ./sqlpage/https                                             | A writeable directory where to cache the certificates, so that SQLPage can serve https traffic immediately when it restarts.                                                                                                                           |

src/app_config.rs

@@ -89,6 +89,10 @@ pub struct AppConfig {
         default = "default_site_prefix"
     )]
     pub site_prefix: String,
+
+    /// Maximum number of messages that can be stored in memory before sending them to the client.
+    #[serde(default = "default_max_pending_rows")]
+    pub max_pending_rows: usize,
 }
 
 impl AppConfig {
@@ -148,7 +152,7 @@ pub fn load_from_file(config_file: &Path) -> anyhow::Result<AppConfig> {
     let app_config = config
         .try_deserialize::<AppConfig>()
         .with_context(|| "Unable to load configuration")?;
-    log::debug!("Loaded configuration: {:?}", app_config);
+    log::debug!("Loaded configuration: {:#?}", app_config);
     Ok(app_config)
 }
 
@@ -294,6 +298,10 @@ fn default_https_acme_directory_url() -> String {
     "https://acme-v02.api.letsencrypt.org/directory".to_string()
 }
 
+fn default_max_pending_rows() -> usize {
+    256
+}
+
 #[derive(Debug, Deserialize, Serialize, PartialEq, Clone, Copy, Eq, Default)]
 #[serde(rename_all = "lowercase")]
 pub enum DevOrProd {

src/webserver/http.rs

@@ -32,7 +32,6 @@ use tokio::sync::mpsc;
 
 /// If the sending queue exceeds this number of outgoing messages, an error will be thrown
 /// This prevents a single request from using up all available memory
-const MAX_PENDING_MESSAGES: usize = 128;
 
 #[derive(Clone)]
 pub struct ResponseWriter {
@@ -76,9 +75,10 @@ impl ResponseWriter {
             .await
             .map_err(|err| {
                 use std::io::{Error, ErrorKind};
+                let capacity = self.response_bytes.capacity();
                 Error::new(
                     ErrorKind::BrokenPipe,
-                    format!("The HTTP response writer with a capacity of {MAX_PENDING_MESSAGES} has already been closed: {err}"),
+                    format!("The HTTP response writer with a capacity of {capacity} has already been closed: {err}"),
                 )
             })
     }
@@ -96,7 +96,7 @@ impl Write for ResponseWriter {
             .map_err(|e|
                 std::io::Error::new(
                     std::io::ErrorKind::WouldBlock,
-                    format!("{e}: Database messages limit exceeded. The server cannot store more than {} pending messages in memory.", self.response_bytes.capacity())
+                    format!("{e}: Row limit exceeded. The server cannot store more than {} pending messages in memory. Try again later or increase max_pending_rows in the configuration.", self.response_bytes.max_capacity())
                 )
             )
     }
@@ -157,7 +157,8 @@ async fn build_response_header_and_stream<S: Stream<Item = DbItem>>(
     database_entries: S,
     layout_context: &LayoutContext,
 ) -> anyhow::Result<ResponseWithWriter<S>> {
-    let (sender, receiver) = mpsc::channel(MAX_PENDING_MESSAGES);
+    let chan_size = app_state.config.max_pending_rows;
+    let (sender, receiver) = mpsc::channel(chan_size);
     let writer = ResponseWriter::new(sender);
     let mut head_context = HeaderContext::new(app_state, layout_context, writer);
     let mut stream = Box::pin(database_entries);