itsi-server 0.1.7 → 0.1.8

data/ext/itsi_server/Cargo.toml

@@ -19,6 +19,7 @@ parking_lot = "0.12.3"
 rustls-pemfile = "2.2.0"
 tokio-rustls = "0.26.2"
 bytes = "1.3"
+tokio-rustls-acme = "0.6.0"
 rcgen = { version = "0.13.2", features = ["x509-parser", "pem"] }
 base64 = "0.22.1"
 http-body-util = "0.1.2"
@@ -39,7 +40,6 @@ httparse = "1.10.1"
 async-channel = "2.3.1"
 tempfile = "3.18.0"
 sysinfo = "0.33.1"
-tokio-rustls-acme = "0.6.0"
 rustls = "0.23.23"
 fs2 = "0.4.3"
 ring = "0.17.14"

data/ext/itsi_server/src/request/itsi_request.rs

@@ -6,7 +6,7 @@ use crate::{
     response::itsi_response::ItsiResponse,
     server::{
         itsi_server::{RequestJob, Server},
-        listener::{SockAddr, TokioListener},
+        listener::{ListenerInfo, SockAddr},
         serve_strategy::single_mode::RunningPhase,
     },
 };
@@ -44,7 +44,7 @@ pub struct ItsiRequest {
     pub remote_addr: String,
     pub version: String,
     #[debug(skip)]
-    pub(crate) listener: Arc<TokioListener>,
+    pub(crate) listener: Arc<ListenerInfo>,
     #[debug(skip)]
     pub server: Arc<Server>,
     pub response: ItsiResponse,
@@ -128,7 +128,7 @@ impl ItsiRequest {
         hyper_request: Request<Incoming>,
         sender: async_channel::Sender<RequestJob>,
         server: Arc<Server>,
-        listener: Arc<TokioListener>,
+        listener: Arc<ListenerInfo>,
         addr: SockAddr,
         shutdown_rx: watch::Receiver<RunningPhase>,
     ) -> itsi_error::Result<Response<BoxBody<Bytes, Infallible>>> {
@@ -153,7 +153,7 @@ impl ItsiRequest {
         request: Request<Incoming>,
         sock_addr: SockAddr,
         server: Arc<Server>,
-        listener: Arc<TokioListener>,
+        listener: Arc<ListenerInfo>,
     ) -> (ItsiRequest, mpsc::Receiver<Option<Bytes>>) {
         let (parts, body) = request.into_parts();
         let body = if server.stream_body.is_some_and(|f| f) {
@@ -231,7 +231,7 @@ impl ItsiRequest {
             .uri
             .host()
             .map(|host| host.to_string())
-            .unwrap_or_else(|| self.listener.host()))
+            .unwrap_or_else(|| self.listener.host.clone()))
     }
 
     pub(crate) fn scheme(&self) -> MagnusResult<String> {
@@ -240,7 +240,7 @@ impl ItsiRequest {
             .uri
             .scheme()
             .map(|scheme| scheme.to_string())
-            .unwrap_or_else(|| self.listener.scheme()))
+            .unwrap_or_else(|| self.listener.scheme.clone()))
     }
 
     pub(crate) fn headers(&self) -> MagnusResult<Vec<(String, &str)>> {
@@ -264,7 +264,7 @@ impl ItsiRequest {
     }
 
     pub(crate) fn port(&self) -> MagnusResult<u16> {
-        Ok(self.parts.uri.port_u16().unwrap_or(self.listener.port()))
+        Ok(self.parts.uri.port_u16().unwrap_or(self.listener.port))
     }
 
     pub(crate) fn body(&self) -> MagnusResult<Value> {

data/ext/itsi_server/src/server/bind.rs

@@ -9,6 +9,7 @@ use std::{
     path::PathBuf,
     str::FromStr,
 };
+
 #[derive(Debug, Clone)]
 pub enum BindAddress {
     Ip(IpAddr),
@@ -129,13 +130,13 @@ impl FromStr for Bind {
             BindProtocol::Unix => None,
             BindProtocol::Unixs => Some(configure_tls(host, &options)?),
         };
-
-        Ok(Self {
+        let bind = Self {
             address,
             port,
             protocol,
             tls_config,
-        })
+        };
+        Ok(bind)
     }
 }
 

data/ext/itsi_server/src/server/itsi_server.rs

@@ -19,7 +19,7 @@ use parking_lot::Mutex;
 use std::{cmp::max, ops::Deref, sync::Arc};
 use tracing::{info, instrument};
 
-static DEFAULT_BIND: &str = "localhost:3000";
+static DEFAULT_BIND: &str = "http://localhost:3000";
 
 #[magnus::wrap(class = "Itsi::Server", free_immediately, size)]
 #[derive(Clone)]
@@ -231,13 +231,6 @@ impl Server {
             drop(strategy);
             Ok(())
         })?;
-        if let Ok(listeners) = Arc::try_unwrap(listeners) {
-            listeners.into_iter().for_each(|listener| {
-                if let Ok(listener) = Arc::try_unwrap(listener) {
-                    listener.unbind()
-                };
-            });
-        }
         clear_signal_handlers();
         Ok(())
     }

data/ext/itsi_server/src/server/listener.rs

@@ -1,6 +1,7 @@
 use super::bind::{Bind, BindAddress};
 use super::bind_protocol::BindProtocol;
 use super::io_stream::IoStream;
+use super::serve_strategy::single_mode::RunningPhase;
 use super::tls::ItsiTlsAcceptor;
 use itsi_error::{ItsiError, Result};
 use itsi_tracing::info;
@@ -11,6 +12,7 @@ use std::{os::unix::net::UnixListener, path::PathBuf};
 use tokio::net::TcpListener as TokioTcpListener;
 use tokio::net::UnixListener as TokioUnixListener;
 use tokio::net::{unix, TcpStream, UnixStream};
+use tokio::sync::watch::Receiver;
 use tokio_rustls::TlsAcceptor;
 use tokio_stream::StreamExt;
 use tracing::error;
@@ -23,45 +25,79 @@ pub(crate) enum Listener {
 }
 
 pub(crate) enum TokioListener {
-    Tcp {
-        listener: TokioTcpListener,
-        host: String,
-        port: u16,
-    },
-    TcpTls {
-        listener: TokioTcpListener,
-        acceptor: ItsiTlsAcceptor,
-        host: String,
-        port: u16,
-    },
-    Unix {
-        listener: TokioUnixListener,
-    },
-    UnixTls {
-        listener: TokioUnixListener,
-        acceptor: ItsiTlsAcceptor,
-    },
+    Tcp(TokioTcpListener),
+    TcpTls(TokioTcpListener, ItsiTlsAcceptor),
+    Unix(TokioUnixListener),
+    UnixTls(TokioUnixListener, ItsiTlsAcceptor),
+}
+
+#[derive(Debug, Clone)]
+pub struct ListenerInfo {
+    pub host: String,
+    pub port: u16,
+    pub scheme: String,
 }
 
 impl TokioListener {
-    pub fn unbind(self) {
+    pub fn listener_info(&self) -> ListenerInfo {
         match self {
-            TokioListener::Tcp { listener, .. } => drop(listener.into_std().unwrap()),
-            TokioListener::TcpTls { listener, .. } => drop(listener.into_std().unwrap()),
-            TokioListener::Unix { listener } => drop(listener.into_std().unwrap()),
-            TokioListener::UnixTls { listener, .. } => drop(listener.into_std().unwrap()),
-        };
+            TokioListener::Tcp(listener) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .ip()
+                    .to_canonical()
+                    .to_string(),
+                port: listener.local_addr().unwrap().port(),
+                scheme: "http".to_string(),
+            },
+            TokioListener::TcpTls(listener, _) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .ip()
+                    .to_canonical()
+                    .to_string(),
+                port: listener.local_addr().unwrap().port(),
+                scheme: "https".to_string(),
+            },
+            TokioListener::Unix(listener) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .as_pathname()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .to_owned(),
+                port: 0,
+                scheme: "unix".to_string(),
+            },
+            TokioListener::UnixTls(listener, _) => ListenerInfo {
+                host: listener
+                    .local_addr()
+                    .unwrap()
+                    .as_pathname()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .to_owned(),
+                port: 0,
+                scheme: "ssl".to_string(),
+            },
+        }
     }
+
     pub(crate) async fn accept(&self) -> Result<IoStream> {
         match self {
-            TokioListener::Tcp { listener, .. } => TokioListener::accept_tcp(listener).await,
-            TokioListener::TcpTls {
-                listener, acceptor, ..
-            } => TokioListener::accept_tls(listener, acceptor).await,
-            TokioListener::Unix { listener, .. } => TokioListener::accept_unix(listener).await,
-            TokioListener::UnixTls {
-                listener, acceptor, ..
-            } => TokioListener::accept_unix_tls(listener, acceptor).await,
+            TokioListener::Tcp(listener) => TokioListener::accept_tcp(listener).await,
+            TokioListener::TcpTls(listener, acceptor) => {
+                TokioListener::accept_tls(listener, acceptor).await
+            }
+            TokioListener::Unix(listener) => TokioListener::accept_unix(listener).await,
+            TokioListener::UnixTls(listener, acceptor) => {
+                TokioListener::accept_unix_tls(listener, acceptor).await
+            }
         }
     }
 
@@ -70,17 +106,24 @@ impl TokioListener {
         Self::to_tokio_io(Stream::TcpStream(tcp_stream), None).await
     }
 
-    pub async fn spawn_state_task(&self) {
-        if let TokioListener::TcpTls {
-            acceptor: ItsiTlsAcceptor::Automatic(_acme_acceptor, state, _server_config),
-            ..
-        } = self
+    pub async fn spawn_state_task(&self, mut shutdown_receiver: Receiver<RunningPhase>) {
+        if let TokioListener::TcpTls(
+            _,
+            ItsiTlsAcceptor::Automatic(_acme_acceptor, state, _server_config),
+        ) = self
         {
             let mut state = state.lock().await;
             loop {
-                match StreamExt::next(&mut *state).await {
-                    Some(event) => info!("Received acme event: {:?}", event),
-                    None => error!("Received no acme event"),
+                tokio::select! {
+                  stream_event = StreamExt::next(&mut *state) => {
+                      match stream_event {
+                        Some(event) => info!("Received acme event: {:?}", event),
+                        None => error!("Received no acme event"),
+                      }
+                  },
+                  _ = shutdown_receiver.changed() => {
+                      break;
+                  }
                 }
             }
         }
@@ -175,33 +218,6 @@ impl TokioListener {
             },
         }
     }
-
-    pub(crate) fn scheme(&self) -> String {
-        match self {
-            TokioListener::Tcp { .. } => "http".to_string(),
-            TokioListener::TcpTls { .. } => "https".to_string(),
-            TokioListener::Unix { .. } => "http".to_string(),
-            TokioListener::UnixTls { .. } => "https".to_string(),
-        }
-    }
-
-    pub(crate) fn port(&self) -> u16 {
-        match self {
-            TokioListener::Tcp { port, .. } => *port,
-            TokioListener::TcpTls { port, .. } => *port,
-            TokioListener::Unix { .. } => 0,
-            TokioListener::UnixTls { .. } => 0,
-        }
-    }
-
-    pub(crate) fn host(&self) -> String {
-        match self {
-            TokioListener::Tcp { host, .. } => host.to_string(),
-            TokioListener::TcpTls { host, .. } => host.to_string(),
-            TokioListener::Unix { .. } => "unix".to_string(),
-            TokioListener::UnixTls { .. } => "unix".to_string(),
-        }
-    }
 }
 
 enum Stream {
@@ -227,48 +243,22 @@ impl std::fmt::Display for SockAddr {
 }
 
 impl Listener {
-    pub fn unbind(self) {
-        match self {
-            Listener::Tcp(listener) => drop(listener),
-            Listener::TcpTls((listener, _)) => drop(listener),
-            Listener::Unix(listener) => drop(listener),
-            Listener::UnixTls((listener, _)) => drop(listener),
-        };
-    }
     pub fn to_tokio_listener(&self) -> TokioListener {
         match self {
-            Listener::Tcp(listener) => TokioListener::Tcp {
-                listener: TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap())
-                    .unwrap(),
-                host: listener
-                    .local_addr()
-                    .unwrap()
-                    .ip()
-                    .to_canonical()
-                    .to_string(),
-                port: listener.local_addr().unwrap().port(),
-            },
-            Listener::TcpTls((listener, acceptor)) => TokioListener::TcpTls {
-                listener: TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap())
-                    .unwrap(),
-                acceptor: acceptor.clone(),
-                host: listener
-                    .local_addr()
-                    .unwrap()
-                    .ip()
-                    .to_canonical()
-                    .to_string(),
-                port: listener.local_addr().unwrap().port(),
-            },
-            Listener::Unix(listener) => TokioListener::Unix {
-                listener: TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap())
-                    .unwrap(),
-            },
-            Listener::UnixTls((listener, acceptor)) => TokioListener::UnixTls {
-                listener: TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap())
-                    .unwrap(),
-                acceptor: acceptor.clone(),
-            },
+            Listener::Tcp(listener) => TokioListener::Tcp(
+                TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap()).unwrap(),
+            ),
+            Listener::TcpTls((listener, acceptor)) => TokioListener::TcpTls(
+                TokioTcpListener::from_std(TcpListener::try_clone(listener).unwrap()).unwrap(),
+                acceptor.clone(),
+            ),
+            Listener::Unix(listener) => TokioListener::Unix(
+                TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap()).unwrap(),
+            ),
+            Listener::UnixTls((listener, acceptor)) => TokioListener::UnixTls(
+                TokioUnixListener::from_std(UnixListener::try_clone(listener).unwrap()).unwrap(),
+                acceptor.clone(),
+            ),
         }
     }
 }
@@ -307,6 +297,7 @@ fn connect_tcp_socket(addr: IpAddr, port: u16) -> Result<TcpListener> {
     socket.set_nonblocking(true).ok();
     socket.set_nodelay(true).ok();
     socket.set_recv_buffer_size(262_144).ok();
+    info!("Binding to {:?}", socket_address);
     socket.bind(&socket_address.into())?;
     socket.listen(1024)?;
     Ok(socket.into())

data/ext/itsi_server/src/server/serve_strategy/single_mode.rs

@@ -4,7 +4,7 @@ use crate::{
         io_stream::IoStream,
         itsi_server::{RequestJob, Server},
         lifecycle_event::LifecycleEvent,
-        listener::{Listener, TokioListener},
+        listener::{Listener, ListenerInfo},
         thread_worker::{build_thread_workers, ThreadWorker},
     },
 };
@@ -87,18 +87,25 @@ impl SingleMode {
     pub fn run(self: Arc<Self>) -> Result<()> {
         let mut listener_task_set = JoinSet::new();
         let self_ref = Arc::new(self);
-        self_ref.build_runtime().block_on(async {
+        let runtime = self_ref.build_runtime();
 
-          for listener in self_ref.listeners.clone().iter() {
-              let listener = Arc::new(listener.to_tokio_listener());
+        runtime.block_on(async {
+          let tokio_listeners = self_ref
+              .listeners
+              .iter()
+              .map(|list| Arc::new(list.to_tokio_listener()))
+              .collect::<Vec<_>>();
+          for listener in tokio_listeners.iter() {
               let mut lifecycle_rx = self_ref.lifecycle_channel.subscribe();
+              let listener_info = Arc::new(listener.listener_info());
               let self_ref = self_ref.clone();
               let listener = listener.clone();
               let (shutdown_sender, mut shutdown_receiver) = tokio::sync::watch::channel::<RunningPhase>(RunningPhase::Running);
               let listener_clone = listener.clone();
 
-              tokio::spawn(async move {
-                listener_clone.spawn_state_task().await;
+              let shutdown_receiver_clone = shutdown_receiver.clone();
+              listener_task_set.spawn(async move {
+                listener_clone.spawn_state_task(shutdown_receiver_clone).await;
               });
 
               listener_task_set.spawn(async move {
@@ -107,8 +114,11 @@ impl SingleMode {
                     tokio::select! {
                         accept_result = listener.accept() => match accept_result {
                           Ok(accept_result) => {
-                            if let Err(e) = strategy.serve_connection(accept_result, listener.clone(), shutdown_receiver.clone()).await {
-                              error!("Error in serve_connection {:?}", e)
+                            match strategy.serve_connection(accept_result, listener_info.clone(), shutdown_receiver.clone()).await {
+                              Ok(_) => {
+                                debug!("Connection accepted and served");
+                              },
+                              Err(e) => error!("Error in serve_connection {:?}", e)
                             }
                           },
                           Err(e) => debug!("Listener.accept failed {:?}", e),
@@ -130,23 +140,23 @@ impl SingleMode {
                       }
                     }
                 }
-                if let Ok(listener) = Arc::try_unwrap(listener){
-                  listener.unbind();
-                }
             });
 
           }
 
           while let Some(_res) = listener_task_set.join_next().await {}
+
         });
+        runtime.shutdown_timeout(Duration::from_millis(100));
 
+        info!("Runtime has shut down");
         Ok(())
     }
 
     pub(crate) async fn serve_connection(
         &self,
         stream: IoStream,
-        listener: Arc<TokioListener>,
+        listener: Arc<ListenerInfo>,
         shutdown_channel: tokio::sync::watch::Receiver<RunningPhase>,
     ) -> Result<()> {
         let sender_clone = self.sender.clone();

data/ext/itsi_server/src/server/tls.rs

@@ -186,7 +186,15 @@ pub fn load_private_key(path: &str) -> PrivateKeyDer<'static> {
 pub fn generate_ca_signed_cert(
     domains: Vec<String>,
 ) -> Result<(Vec<CertificateDer<'static>>, PrivateKeyDer<'static>)> {
-    info!("Generating New Itsi CA - Self signed Certificate. Use `itsi ca export` to export the CA certificate for import into your local trust store.");
+    info!(
+        domains = format!("{}", domains.join(", ")),
+        "Self signed cert",
+    );
+    info!(
+        "Add {} to your system's trusted cert store to resolve certificate errors.",
+        format!("{}/itsi_dev_ca.crt", ITSI_LOCAL_CA_DIR.to_str().unwrap())
+    );
+    info!("Dev CA path can be overridden by setting env var: `ITSI_LOCAL_CA_DIR`.");
     let (ca_key_pem, ca_cert_pem) = get_or_create_local_dev_ca()?;
 
     let ca_kp = KeyPair::from_pem(&ca_key_pem).expect("Failed to load CA key");
@@ -198,10 +206,6 @@ pub fn generate_ca_signed_cert(
     let ee_key = KeyPair::generate_for(&rcgen::PKCS_ECDSA_P256_SHA256).unwrap();
     let mut ee_params = CertificateParams::default();
 
-    info!(
-        "Generated certificate will be valid for domains {:?}",
-        domains
-    );
     use std::net::IpAddr;
 
     ee_params.subject_alt_names = domains

data/lib/itsi/index.html.erb

@@ -0,0 +1,91 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>Itsi - Default</title>
+  <style>
+    * {
+      box-sizing: border-box;
+      margin: 0;
+      padding: 0;
+    }
+    body {
+      font-family: "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      background-color: #f4f4f4;
+      color: #333;
+      line-height: 1.6;
+    }
+    .container {
+      max-width: 700px;
+      margin: 3rem auto;
+      background: #fff;
+      border-radius: 8px;
+      box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
+      padding: 2rem;
+    }
+    h1 {
+      font-size: 1.8rem;
+      margin-bottom: 1rem;
+      text-align: center;
+      color: #444;
+    }
+    p {
+      margin-bottom: 1rem;
+      text-align: center;
+      color: #666;
+    }
+    ul.fields {
+      list-style: none;
+      margin-top: 1.5rem;
+      padding: 0;
+    }
+    ul.fields li {
+      background: #fafafa;
+      border: 1px solid #eee;
+      border-radius: 5px;
+      padding: 0.75rem;
+      margin-bottom: 0.75rem;
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .label {
+      font-weight: bold;
+      margin-right: 1rem;
+    }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>You're running on Itsi!</h1>
+    <p>RACK environment:</p>
+
+    <ul class="fields">
+      <li>
+        <span class="label">REQUEST_METHOD:</span>
+        <span>%{REQUEST_METHOD}</span>
+      </li>
+      <li>
+        <span class="label">PATH_INFO:</span>
+        <span>%{PATH_INFO}</span>
+      </li>
+      <li>
+        <span class="label">SERVER_NAME:</span>
+        <span>%{SERVER_NAME}</span>
+      </li>
+      <li>
+        <span class="label">SERVER_PORT:</span>
+        <span>%{SERVER_PORT}</span>
+      </li>
+      <li>
+        <span class="label">REMOTE_ADDR:</span>
+        <span>%{REMOTE_ADDR}</span>
+      </li>
+      <li>
+        <span class="label">HTTP_USER_AGENT:</span>
+        <span>%{HTTP_USER_AGENT}</span>
+      </li>
+    </ul>
+  </div>
+</body>
+</html>

data/lib/itsi/server/scheduler_mode.rb

@@ -1,6 +1,6 @@
 if defined?(ActiveSupport::IsolatedExecutionState) && !ENV["ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL"]
   Itsi.log_info \
     "ActiveSupport Isolated Execution state detected. Automatically switching to :fiber mode. "\
-    "Use ENV['ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL'] to disable this behavior"
+    "Set ITSI_DISABLE_AS_AUTO_FIBER_ISOLATION_LEVEL to disable this behavior"
   ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
 end

data/lib/itsi/server/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Server
-    VERSION = "0.1.7"
+    VERSION = "0.1.8"
   end
 end

data/lib/itsi/server.rb

@@ -6,6 +6,9 @@ require_relative "signals"
 require_relative "request"
 require_relative "stream_io"
 require_relative "server/rack/handler/itsi"
+require 'erb'
+
+DEFAULT_INDEX = IO.read(__dir__ + '/index.html.erb')
 
 module Itsi
   class Server
@@ -14,8 +17,25 @@ module Itsi
       @running ||= false
     end
 
-    def self.start(app:, **opts)
-      server = new(app: ->{app}, **opts)
+    def self.start(
+      app: ->(env){
+        [env['CONTENT_TYPE'], env['HTTP_ACCEPT']].include?('application/json') ?
+          [200, {"Content-Type" => "application/json"}, ["{\"message\": \"You're running on Itsi!\"}"]] :
+          [200, {"Content-Type" => "text/html"}, [
+            DEFAULT_INDEX % {
+              REQUEST_METHOD: env['REQUEST_METHOD'],
+              PATH_INFO: env['PATH_INFO'],
+              SERVER_NAME: env['SERVER_NAME'],
+              SERVER_PORT: env['SERVER_PORT'],
+              REMOTE_ADDR: env['REMOTE_ADDR'],
+              HTTP_USER_AGENT: env['HTTP_USER_AGENT']
+            }
+          ]]
+      },
+      binds: ['http://0.0.0.0:3000'],
+      **opts
+    )
+      server = new(app: ->{app}, binds: binds, **opts)
       @running = true
       Signal.trap('INT', 'DEFAULT')
       server.start

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: itsi-server
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Wouter Coppieters
@@ -49,6 +49,8 @@ files:
 - ".rubocop.yml"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
+- Cargo.lock
+- Cargo.toml
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -70,6 +72,7 @@ files:
 - ext/itsi_scheduler/src/itsi_scheduler/io_waiter.rs
 - ext/itsi_scheduler/src/itsi_scheduler/timer.rs
 - ext/itsi_scheduler/src/lib.rs
+- ext/itsi_server/Cargo.lock
 - ext/itsi_server/Cargo.toml
 - ext/itsi_server/extconf.rb
 - ext/itsi_server/src/body_proxy/big_bytes.rs
@@ -99,6 +102,7 @@ files:
 - ext/itsi_tracing/Cargo.lock
 - ext/itsi_tracing/Cargo.toml
 - ext/itsi_tracing/src/lib.rs
+- lib/itsi/index.html.erb
 - lib/itsi/request.rb
 - lib/itsi/server.rb
 - lib/itsi/server/rack/handler/itsi.rb