starred/minne
1
0
Fork 0
mirror of https://github.com/perstarkse/minne.git synced 2026-03-25 10:52:07 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity

working on a queue length

Browse Source
This commit is contained in:
Per Stark
2024-09-20 22:57:47 +02:00
parent a9aee21db3
commit 7fbfa0fdbc
4 changed files with 52 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

169
src/server.rs
View File

@@ -1,140 +1,9 @@
// use axum::{
// routing::post,
// Router,
// response::{IntoResponse, Response},
// Error, Extension, Json,
// };
// use serde::Deserialize;
// use tracing_subscriber::{fmt, prelude::*, EnvFilter};
// #[derive(Deserialize)]
// struct IngressPayload {
// payload: String,
// }
// use tracing::{info, error};
// use zettle_db::rabbitmq::RabbitMQClient;
// async fn ingress_handler(
// // Extension(rabbitmq): Extension<RabbitMQ>,
// Json(payload): Json<IngressPayload>
// ) -> Response {
// info!("Received payload: {:?}", payload.payload);
// let rabbitmqclient = RabbitMQClient::new("127.0.0.1").await;
// match rabbitmq.publish(&payload.payload).await {
// Ok(_) => {
// info!("Message published successfully");
// "thank you".to_string().into_response()
// },
// Err(e) => {
// error!("Failed to publish message: {:?}", e);
// (axum::http::StatusCode::INTERNAL_SERVER_ERROR, "Failed to publish message").into_response()
// }
// }
// }
// #[tokio::main(flavor = "multi_thread", worker_threads = 2)]
// async fn main() -> Result<(), Error> {
// // Set up tracing
// tracing_subscriber::registry()
// .with(fmt::layer())
// .with(EnvFilter::from_default_env())
// .try_init()
// .ok();
// // Set up RabbitMQ
// // let rabbitmq = RabbitMQ::new("amqprs.examples.basic2", "amq.topic", "amqprs.example2").await;
// // Create Axum router
// let app = Router::new()
// .route("/ingress", post(ingress_handler)); // .layer(Extension(rabbitmq));
// tracing::info!("Listening on 0.0.0.0:3000");
// let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
// axum::serve(listener, app).await.unwrap();
// Ok(())
// }
// use axum::{
// routing::post,
// Router,
// response::{IntoResponse, Response},
// Error, Extension, Json,
// };
// use serde::Deserialize;
// use tracing_subscriber::{fmt, prelude::*, EnvFilter};
// use zettle_db::rabbitmq::{RabbitMQProducer};
// use std::sync::Arc;
// #[derive(Deserialize)]
// struct IngressPayload {
// payload: String,
// }
// use tracing::{info, error};
// async fn ingress_handler(
// // Extension(rabbitmq): Extension<Arc<RabbitMQClient>>,
// Extension(producer): Extension<Arc<RabbitMQProducer>>,
// Json(payload): Json<IngressPayload>
// ) -> Response {
// info!("Received payload: {:?}", payload.payload);
// match producer.publish(&payload.payload).await {
// Ok(_) => {
// info!("Message published successfully");
// "thank you".to_string().into_response()
// },
// Err(e) => {
// error!("Failed to publish message: {:?}", e);
// (axum::http::StatusCode::INTERNAL_SERVER_ERROR, "Failed to publish message").into_response()
// }
// }
// // match rabbitmq.publish("hello", payload.payload.as_bytes()).await {
// // Ok(_) => {
// // info!("Message published successfully");
// // "thank you".to_string().into_response()
// // },
// // Err(e) => {
// // error!("Failed to publish message: {:?}", e);
// // (axum::http::StatusCode::INTERNAL_SERVER_ERROR, "Failed to publish message").into_response()
// // }
// // }
// }
// #[tokio::main(flavor = "multi_thread", worker_threads = 2)]
// async fn main() -> Result<(), Error> {
// // Set up tracing
// tracing_subscriber::registry()
// .with(fmt::layer())
// .with(EnvFilter::from_default_env())
// .try_init()
// .ok();
// // Set up RabbitMQ
// // let rabbitmq = Arc::new(RabbitMQClient::new("amqp://guest:guest@localhost:5672").await.expect("Failed to connect to RabbitMQ"));
// let producer = Arc::new(RabbitMQProducer::new("amqp://localhost", "my_exchange", "my_routing_key").await);
// // Create Axum router
// let app = Router::new()
// .route("/ingress", post(ingress_handler))
// .layer(Extension(producer));
// tracing::info!("Listening on 0.0.0.0:3000");
// let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
// axum::serve(listener, app).await.unwrap();
// Ok(())
// }
use axum::{
routing::post,
Router,
response::{IntoResponse, Response},
Extension, Json,
http::StatusCode, response::{IntoResponse, Response}, routing::{get, post}, Extension, Json, Router
};
use serde::Deserialize;
use tracing_subscriber::{fmt, prelude::*, EnvFilter};
use zettle_db::rabbitmq::{producer::RabbitMQProducer, RabbitMQConfig};
use zettle_db::rabbitmq::{consumer::RabbitMQConsumer, producer::RabbitMQProducer, RabbitMQConfig};
use std::sync::Arc;
#[derive(Deserialize)]
@@ -161,6 +30,37 @@ async fn ingress_handler(
}
}
async fn queue_length_handler() -> Response {
info!("Getting queue length");
// Set up RabbitMQ config
let config = RabbitMQConfig {
amqp_addr: "amqp://localhost".to_string(),
exchange: "my_exchange".to_string(),
queue: "my_queue".to_string(),
routing_key: "my_key".to_string(),
};
// Create a new consumer
match RabbitMQConsumer::new(&config).await {
Ok(consumer) => {
info!("Consumer connected to RabbitMQ");
// Get the queue length
let queue_length = consumer.queue.message_count();
info!("Queue length: {}", queue_length);
// Return the queue length with a 200 OK status
(StatusCode::OK, queue_length.to_string()).into_response()
},
Err(e) => {
error!("Failed to create consumer: {:?}", e);
(StatusCode::INTERNAL_SERVER_ERROR, "Failed to connect to RabbitMQ".to_string()).into_response()
}
}
}
#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Set up tracing
@@ -171,7 +71,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
.ok();
// Set up RabbitMQ
let config = RabbitMQConfig {
let config = RabbitMQConfig {
amqp_addr: "amqp://localhost".to_string(),
exchange: "my_exchange".to_string(),
queue: "my_queue".to_string(),
@@ -183,6 +83,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Create Axum router
let app = Router::new()
.route("/ingress", post(ingress_handler))
.route("/message_count", get(queue_length_handler))
.layer(Extension(producer));
tracing::info!("Listening on 0.0.0.0:3000");