Ready to Go 🚀

Author: suryavirkapur

api/Cargo.lock

@@ -16,3 +16,8 @@ actix-web = "4.9.0"
 scylla = "0.13.2"
 tokio-postgres = "0.7.11"
 chrono = "0.4.38"
+actix-web-actors = "4.2.0"
+actix = "0.13.0"
+tokio-stream = "0.1"
+futures-core = "0.3"
+actix-cors = "0.7.0"

api/Cargo.toml

@@ -1,29 +1,28 @@
+use actix_cors::Cors;
 use actix_web::{web::Data, App, HttpServer};
 use db::connect_with_retry;
 use scylla::Session;
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
 use tokio_postgres::{Client, NoTls};
 
 mod db;
 mod routes;
 
 struct AppState {
-    db: Session,
+    db: Arc<Session>,
     client: Client,
 }
 
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
-    let uri = "host.docker.internal:9042";
+    let uri = "localhost:9042";
     let max_retries = 5;
     let initial_delay = Duration::from_secs(10);
 
-    let (client, connection) = tokio_postgres::connect(
-        "postgres://postgres:postgres@host.docker.internal:5432/example",
-        NoTls,
-    )
-    .await
-    .unwrap();
+    let (client, connection) =
+        tokio_postgres::connect("postgres://postgres:postgres@localhost:5432/example", NoTls)
+            .await
+            .unwrap();
 
     // Spawn the connection handler
     tokio::spawn(async move {
@@ -49,12 +48,19 @@ async fn main() -> std::io::Result<()> {
     println!("Successfully connected to Cassandra!");
 
     let data = Data::new(AppState {
-        db: session,
+        db: Arc::new(session),
         client,
     });
 
     HttpServer::new(move || {
+        let cors = Cors::default()
+            .allow_any_origin()
+            .allow_any_method()
+            .allow_any_header()
+            .max_age(3600);
+
         App::new()
+            .wrap(cors)
             .app_data(data.clone())
             .service(routes::log::hello)
             .service(routes::log::create_log)

api/src/main.rs

@@ -118,3 +118,67 @@ pub async fn hello(data: web::Data<AppState>) -> String {
 
     db_name
 }
+
+// #[get("/live-logs/{channel_id}")]
+// async fn live_logs(
+//     request: HttpRequest,
+//     path: web::Path<String>,
+//     state: web::Data<AppState>,
+// ) -> impl Responder {
+//     let channel_id = path.into_inner();
+//     let basic_auth = match request.headers().get("Authorization") {
+//         Some(header) => header.to_str().unwrap_or(""),
+//         None => return HttpResponse::Unauthorized().finish(),
+//     };
+//     let token = basic_auth.trim_start_matches("Basic ");
+//     if !verify_token(&state.client, token, &channel_id).await {
+//         return HttpResponse::Unauthorized().finish();
+//     }
+
+//     let db = Arc::clone(&state.db);
+
+//     let stream = tokio_stream::wrappers::IntervalStream::new(interval(Duration::from_secs(5)))
+//         .then(move |_| {
+//             let db = Arc::clone(&db);
+//             let channel_id = channel_id.clone();
+//             async move {
+//                 let result =   db.query(
+//                     "SELECT channel_id, timestamp, event_name, event_payload FROM raterlog.logs WHERE channel_id = ? ORDER BY timestamp DESC LIMIT 1",
+//                     (channel_id,)
+//                 ).await;
+//                 match result{
+//                     Ok(res) => {
+//                         let rows: Vec<Log> = res
+//                 .rows_typed::<Log>()
+//                 .unwrap()
+//                 .into_iter()
+//                 .map(|row| row.unwrap())
+//                 .collect();
+
+//                         match res.into_typed_rows::<Log>() {
+//                             Some(mut rows) => {
+//                                 if let Some(log) = rows.next() {
+//                                     match log {
+//                                         Ok(log) => {
+//                                             let data = serde_json::to_string(&log).unwrap();
+//                                             Ok(Bytes::from(format!("data: {}\n\n", data)))
+//                                         },
+//                                         Err(e) => Err(Error::from(e))
+//                                     }
+//                                 } else {
+//                                     Ok(Bytes::from(":\n\n")) // Keep-alive when no rows
+//                                 }
+//                             },
+//                             None => Ok(Bytes::from(":\n\n")) // Keep-alive when no typed rows
+//                         }
+//                     },
+//                     Err(e) => Err(Error::from(e)) // Convert database error to actix_web::Error
+//                 }
+//             }
+//         });
+
+//     HttpResponse::Ok()
+//         .insert_header(("Content-Type", "text/event-stream"))
+//         .insert_header(("Cache-Control", "no-cache"))
+//         .streaming(stream)
+// }

api/src/routes/log.rs

@@ -24,14 +24,14 @@ services:
       - "8001:8001"
       - "8444:8444"
 
-  # nextjs-app:
-  #   build:
-  #     context: ./web
-  #     dockerfile: Dockerfile
-  #   environment:
-  #     NODE_ENV: production
-  #   ports:
-  #     - "3000:3000"
+  nextjs-app:
+    build:
+      context: ./web
+      dockerfile: Dockerfile
+    environment:
+      NODE_ENV: production
+    ports:
+      - "3000:3000"
 
   rust-api:
     restart: unless-stopped

docker-compose.yml

@@ -26,6 +26,7 @@
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
     "react-hook-form": "^7.52.2",
+    "recharts": "^2.12.7",
     "tailwind-merge": "^2.4.0",
     "tailwindcss-animate": "^1.0.7",
     "zod": "^3.23.8"

rundocker.bat

@@ -1,16 +1,16 @@
 export const metadata = {
-  title: 'Next.js',
-  description: 'Generated by Next.js',
-}
-
+  title: "Raterlog Login",
+  description: "",
+};
+import "@radix-ui/themes/styles.css";
 export default function RootLayout({
   children,
 }: {
-  children: React.ReactNode
+  children: React.ReactNode;
 }) {
   return (
     <html lang="en">
       <body>{children}</body>
     </html>
-  )
+  );
 }