work version
This commit is contained in:
commit
e03af7466b
5 files changed
+4135
No files matched your search
+651
@@ -0,0 +1,651 @@
|
||||
use axum::{
|
||||
extract::{
|
||||
ws::{Message, WebSocket, WebSocketUpgrade},
|
||||
State, Json,
|
||||
},
|
||||
response::Response,
|
||||
routing::{get, post},
|
||||
Router,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use sqlx::{sqlite::SqlitePool, Row};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
net::SocketAddr,
|
||||
sync::Arc,
|
||||
};
|
||||
use tokio::sync::{mpsc, RwLock};
|
||||
use tower_http::services::ServeDir;
|
||||
use futures_util::{StreamExt, SinkExt};
|
||||
use bcrypt::{hash, verify, DEFAULT_COST};
|
||||
use rand::distributions::Alphanumeric;
|
||||
use rand::{thread_rng, Rng};
|
||||
use chrono::{Utc, Duration};
|
||||
|
||||
// Types for shared state
|
||||
type UserMap = Arc<RwLock<HashMap<String, mpsc::UnboundedSender<Message>>>>;
|
||||
|
||||
#[derive(Clone)]
|
||||
struct AppState {
|
||||
users: UserMap,
|
||||
db_pool: SqlitePool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize, Clone)]
|
||||
struct ChatMessage {
|
||||
id: String,
|
||||
from_user: String,
|
||||
to_user: String,
|
||||
content: String,
|
||||
timestamp: i64,
|
||||
message_type: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize, Deserialize)]
|
||||
struct UserList {
|
||||
users: Vec<String>,
|
||||
}
|
||||
|
||||
// Структуры для аутентификации
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct RegisterRequest {
|
||||
phone: String,
|
||||
username: String,
|
||||
password: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct LoginRequest {
|
||||
phone: String,
|
||||
password: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
struct AuthResponse {
|
||||
success: bool,
|
||||
message: String,
|
||||
username: Option<String>,
|
||||
token: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
struct UserProfile {
|
||||
username: String,
|
||||
phone: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
struct ValidateTokenResponse {
|
||||
success: bool,
|
||||
username: Option<String>,
|
||||
phone: Option<String>,
|
||||
message: Option<String>,
|
||||
}
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
||||
// Initialize logging
|
||||
tracing_subscriber::fmt::init();
|
||||
|
||||
// Initialize database
|
||||
let db_pool = init_db().await?;
|
||||
|
||||
// Create shared state
|
||||
let state = Arc::new(AppState {
|
||||
users: Arc::new(RwLock::new(HashMap::new())),
|
||||
db_pool,
|
||||
});
|
||||
|
||||
// Build the application
|
||||
let app = Router::new()
|
||||
.route("/ws", get(websocket_handler))
|
||||
.route("/api/register", post(register_handler))
|
||||
.route("/api/login", post(login_handler))
|
||||
.route("/api/validate-token", post(validate_token_handler))
|
||||
.route("/api/profile", get(profile_handler))
|
||||
.nest_service("/", ServeDir::new("web"))
|
||||
.with_state(state);
|
||||
|
||||
let addr = SocketAddr::from(([127, 0, 0, 1], 3333));
|
||||
println!("Server running on http://{}", addr);
|
||||
|
||||
let listener = tokio::net::TcpListener::bind(addr).await?;
|
||||
axum::serve(listener, app).await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn init_db() -> Result<SqlitePool, Box<dyn std::error::Error>> {
|
||||
let pool = SqlitePool::connect("sqlite:chat.db").await?;
|
||||
|
||||
// Create users table
|
||||
sqlx::query(
|
||||
r#"
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
phone TEXT UNIQUE NOT NULL,
|
||||
username TEXT UNIQUE NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
||||
)
|
||||
"#,
|
||||
)
|
||||
.execute(&pool)
|
||||
.await?;
|
||||
|
||||
// Create messages table
|
||||
sqlx::query(
|
||||
r#"
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id TEXT PRIMARY KEY,
|
||||
from_user TEXT NOT NULL,
|
||||
to_user TEXT NOT NULL,
|
||||
content TEXT NOT NULL,
|
||||
timestamp INTEGER NOT NULL,
|
||||
message_type TEXT NOT NULL
|
||||
)
|
||||
"#,
|
||||
)
|
||||
.execute(&pool)
|
||||
.await?;
|
||||
|
||||
// Create sessions table
|
||||
sqlx::query(
|
||||
r#"
|
||||
CREATE TABLE IF NOT EXISTS sessions (
|
||||
token TEXT PRIMARY KEY,
|
||||
username TEXT NOT NULL,
|
||||
phone TEXT NOT NULL,
|
||||
expires_at DATETIME NOT NULL,
|
||||
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
|
||||
)
|
||||
"#,
|
||||
)
|
||||
.execute(&pool)
|
||||
.await?;
|
||||
|
||||
Ok(pool)
|
||||
}
|
||||
|
||||
// Обработчики HTTP API
|
||||
async fn register_handler(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Json(payload): Json<RegisterRequest>,
|
||||
) -> Json<AuthResponse> {
|
||||
// Validate input
|
||||
if payload.phone.len() < 5 {
|
||||
return Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Phone number is too short".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
});
|
||||
}
|
||||
|
||||
if payload.username.len() < 3 {
|
||||
return Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Username must be at least 3 characters".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
});
|
||||
}
|
||||
|
||||
if payload.password.len() < 6 {
|
||||
return Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Password must be at least 6 characters".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
});
|
||||
}
|
||||
|
||||
// Hash password
|
||||
let password_hash = match hash(&payload.password, DEFAULT_COST) {
|
||||
Ok(hash) => hash,
|
||||
Err(_) => {
|
||||
return Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Error hashing password".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
// Insert user into database
|
||||
let result = sqlx::query(
|
||||
"INSERT INTO users (phone, username, password_hash) VALUES (?, ?, ?)"
|
||||
)
|
||||
.bind(&payload.phone)
|
||||
.bind(&payload.username)
|
||||
.bind(&password_hash)
|
||||
.execute(&state.db_pool)
|
||||
.await;
|
||||
|
||||
match result {
|
||||
Ok(_) => {
|
||||
// Generate session token
|
||||
let token = generate_token();
|
||||
let expires_at = Utc::now() + Duration::days(30);
|
||||
|
||||
// Store session
|
||||
let _ = sqlx::query(
|
||||
"INSERT INTO sessions (token, username, phone, expires_at) VALUES (?, ?, ?, ?)"
|
||||
)
|
||||
.bind(&token)
|
||||
.bind(&payload.username)
|
||||
.bind(&payload.phone)
|
||||
.bind(expires_at.naive_utc())
|
||||
.execute(&state.db_pool)
|
||||
.await;
|
||||
|
||||
Json(AuthResponse {
|
||||
success: true,
|
||||
message: "Registration successful".to_string(),
|
||||
username: Some(payload.username),
|
||||
token: Some(token),
|
||||
})
|
||||
}
|
||||
Err(e) => {
|
||||
let error_message = if e.to_string().contains("UNIQUE constraint failed: users.phone") {
|
||||
"Phone number already registered".to_string()
|
||||
} else if e.to_string().contains("UNIQUE constraint failed: users.username") {
|
||||
"Username already taken".to_string()
|
||||
} else {
|
||||
"Registration failed".to_string()
|
||||
};
|
||||
|
||||
Json(AuthResponse {
|
||||
success: false,
|
||||
message: error_message,
|
||||
username: None,
|
||||
token: None,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn login_handler(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Json(payload): Json<LoginRequest>,
|
||||
) -> Json<AuthResponse> {
|
||||
// Get user from database
|
||||
let user_result = sqlx::query(
|
||||
"SELECT username, password_hash FROM users WHERE phone = ?"
|
||||
)
|
||||
.bind(&payload.phone)
|
||||
.fetch_optional(&state.db_pool)
|
||||
.await;
|
||||
|
||||
match user_result {
|
||||
Ok(Some(row)) => {
|
||||
let username: String = row.get("username");
|
||||
let password_hash: String = row.get("password_hash");
|
||||
|
||||
// Verify password
|
||||
match verify(&payload.password, &password_hash) {
|
||||
Ok(true) => {
|
||||
// Generate session token
|
||||
let token = generate_token();
|
||||
let expires_at = Utc::now() + Duration::days(30);
|
||||
|
||||
// Store session
|
||||
let _ = sqlx::query(
|
||||
"INSERT INTO sessions (token, username, phone, expires_at) VALUES (?, ?, ?, ?)"
|
||||
)
|
||||
.bind(&token)
|
||||
.bind(&username)
|
||||
.bind(&payload.phone)
|
||||
.bind(expires_at.naive_utc())
|
||||
.execute(&state.db_pool)
|
||||
.await;
|
||||
|
||||
Json(AuthResponse {
|
||||
success: true,
|
||||
message: "Login successful".to_string(),
|
||||
username: Some(username),
|
||||
token: Some(token),
|
||||
})
|
||||
}
|
||||
Ok(false) => Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Invalid password".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
}),
|
||||
Err(_) => Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Error verifying password".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
Ok(None) => Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Phone number not found".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
}),
|
||||
Err(_) => Json(AuthResponse {
|
||||
success: false,
|
||||
message: "Login failed".to_string(),
|
||||
username: None,
|
||||
token: None,
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct ValidateTokenRequest {
|
||||
token: String,
|
||||
}
|
||||
|
||||
async fn validate_token_handler(
|
||||
State(state): State<Arc<AppState>>,
|
||||
Json(payload): Json<ValidateTokenRequest>,
|
||||
) -> Json<ValidateTokenResponse> {
|
||||
match verify_token(&state.db_pool, &payload.token).await {
|
||||
Ok(Some(username)) => {
|
||||
// Get user details
|
||||
let user_result = sqlx::query(
|
||||
"SELECT phone FROM users WHERE username = ?"
|
||||
)
|
||||
.bind(&username)
|
||||
.fetch_optional(&state.db_pool)
|
||||
.await;
|
||||
|
||||
match user_result {
|
||||
Ok(Some(row)) => {
|
||||
let phone: String = row.get("phone");
|
||||
Json(ValidateTokenResponse {
|
||||
success: true,
|
||||
username: Some(username),
|
||||
phone: Some(phone),
|
||||
message: None,
|
||||
})
|
||||
}
|
||||
Ok(None) => Json(ValidateTokenResponse {
|
||||
success: false,
|
||||
username: None,
|
||||
phone: None,
|
||||
message: Some("User not found".to_string()),
|
||||
}),
|
||||
Err(_) => Json(ValidateTokenResponse {
|
||||
success: false,
|
||||
username: None,
|
||||
phone: None,
|
||||
message: Some("Database error".to_string()),
|
||||
}),
|
||||
}
|
||||
}
|
||||
Ok(None) => Json(ValidateTokenResponse {
|
||||
success: false,
|
||||
username: None,
|
||||
phone: None,
|
||||
message: Some("Invalid or expired token".to_string()),
|
||||
}),
|
||||
Err(_) => Json(ValidateTokenResponse {
|
||||
success: false,
|
||||
username: None,
|
||||
phone: None,
|
||||
message: Some("Token verification error".to_string()),
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
async fn profile_handler() -> Json<UserProfile> {
|
||||
// This would normally verify the token and return user profile
|
||||
// For now, return a placeholder
|
||||
Json(UserProfile {
|
||||
username: "user".to_string(),
|
||||
phone: "+1234567890".to_string(),
|
||||
})
|
||||
}
|
||||
|
||||
// WebSocket handlers
|
||||
async fn websocket_handler(
|
||||
ws: WebSocketUpgrade,
|
||||
State(state): State<Arc<AppState>>,
|
||||
) -> Response {
|
||||
ws.on_upgrade(|socket| handle_websocket(socket, state))
|
||||
}
|
||||
|
||||
async fn handle_websocket(socket: WebSocket, state: Arc<AppState>) {
|
||||
// Split the socket into sender and receiver
|
||||
let (mut sender, mut receiver) = socket.split();
|
||||
|
||||
// Create channel for sending messages to this client
|
||||
let (tx, mut rx) = mpsc::unbounded_channel();
|
||||
|
||||
// Handle authentication - receive first message with token
|
||||
let username = match receiver.next().await {
|
||||
Some(Ok(Message::Text(auth_msg))) => {
|
||||
match serde_json::from_str::<serde_json::Value>(&auth_msg) {
|
||||
Ok(auth) => {
|
||||
if let (Some(token), Some(auth_type)) = (auth["token"].as_str(), auth["type"].as_str()) {
|
||||
if auth_type == "auth" {
|
||||
// Verify token and get username
|
||||
match verify_token(&state.db_pool, token).await {
|
||||
Ok(Some(user_username)) => {
|
||||
// Check if username is already connected
|
||||
if state.users.read().await.contains_key(&user_username) {
|
||||
let _ = sender.send(Message::Text(
|
||||
serde_json::json!({
|
||||
"type": "error",
|
||||
"content": "User already connected"
|
||||
}).to_string(),
|
||||
)).await;
|
||||
return;
|
||||
}
|
||||
|
||||
// Register user
|
||||
state.users.write().await.insert(user_username.clone(), tx);
|
||||
|
||||
// Send success message
|
||||
let _ = sender.send(Message::Text(
|
||||
serde_json::json!({
|
||||
"type": "system",
|
||||
"content": "Connected successfully"
|
||||
}).to_string(),
|
||||
)).await;
|
||||
|
||||
// Send user list
|
||||
broadcast_user_list(&state.users).await;
|
||||
|
||||
// Send message history
|
||||
if let Ok(messages) = get_message_history(&state.db_pool, &user_username).await {
|
||||
for msg in messages {
|
||||
let message_json = serde_json::to_string(&msg).unwrap();
|
||||
let _ = sender.send(Message::Text(message_json)).await;
|
||||
}
|
||||
}
|
||||
|
||||
user_username
|
||||
}
|
||||
Ok(None) => {
|
||||
let _ = sender.send(Message::Text(
|
||||
serde_json::json!({
|
||||
"type": "error",
|
||||
"content": "Invalid or expired token"
|
||||
}).to_string(),
|
||||
)).await;
|
||||
return;
|
||||
}
|
||||
Err(_) => {
|
||||
let _ = sender.send(Message::Text(
|
||||
serde_json::json!({
|
||||
"type": "error",
|
||||
"content": "Authentication error"
|
||||
}).to_string(),
|
||||
)).await;
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
}
|
||||
Err(_) => return,
|
||||
}
|
||||
}
|
||||
_ => return,
|
||||
};
|
||||
|
||||
println!("User {} connected", username);
|
||||
|
||||
// Clone state for cleanup
|
||||
let state_clone = state.clone();
|
||||
let username_clone = username.clone();
|
||||
|
||||
// Spawn a task to handle sending messages to the client
|
||||
let mut send_sender = sender;
|
||||
let send_task = tokio::spawn(async move {
|
||||
while let Some(message) = rx.recv().await {
|
||||
if send_sender.send(message).await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Handle receiving messages from the client in the main task
|
||||
let recv_state = state.clone();
|
||||
|
||||
let recv_task = tokio::spawn(async move {
|
||||
while let Some(result) = receiver.next().await {
|
||||
match result {
|
||||
Ok(Message::Text(text)) => {
|
||||
println!("Received message from {}: {}", username, text);
|
||||
|
||||
if let Ok(mut chat_msg) = serde_json::from_str::<ChatMessage>(&text) {
|
||||
// Set the from_user to the authenticated username
|
||||
chat_msg.from_user = username.clone();
|
||||
|
||||
println!("Processing message from {} to {}", chat_msg.from_user, chat_msg.to_user);
|
||||
|
||||
// Save message to database
|
||||
if let Err(e) = save_message(&recv_state.db_pool, &chat_msg).await {
|
||||
eprintln!("Failed to save message: {}", e);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Send to recipient if online
|
||||
let users = recv_state.users.read().await;
|
||||
if let Some(recipient_tx) = users.get(&chat_msg.to_user) {
|
||||
let message_json = serde_json::to_string(&chat_msg).unwrap();
|
||||
println!("Sending message to {}: {}", chat_msg.to_user, message_json);
|
||||
let _ = recipient_tx.send(Message::Text(message_json));
|
||||
} else {
|
||||
println!("Recipient {} not found online", chat_msg.to_user);
|
||||
}
|
||||
|
||||
// Also send the message back to the sender for confirmation
|
||||
if let Some(sender_tx) = users.get(&username) {
|
||||
let message_json = serde_json::to_string(&chat_msg).unwrap();
|
||||
let _ = sender_tx.send(Message::Text(message_json));
|
||||
}
|
||||
} else {
|
||||
println!("Failed to parse message as ChatMessage: {}", text);
|
||||
}
|
||||
}
|
||||
Ok(Message::Close(_)) => {
|
||||
println!("WebSocket closed by client");
|
||||
break;
|
||||
}
|
||||
Err(e) => {
|
||||
eprintln!("WebSocket error: {}", e);
|
||||
break;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Wait for both tasks to finish
|
||||
tokio::select! {
|
||||
_ = send_task => {},
|
||||
_ = recv_task => {},
|
||||
}
|
||||
|
||||
// Cleanup
|
||||
state_clone.users.write().await.remove(&username_clone);
|
||||
broadcast_user_list(&state_clone.users).await;
|
||||
println!("User {} disconnected", username_clone);
|
||||
}
|
||||
|
||||
// Utility functions
|
||||
fn generate_token() -> String {
|
||||
thread_rng()
|
||||
.sample_iter(&Alphanumeric)
|
||||
.take(32)
|
||||
.map(char::from)
|
||||
.collect()
|
||||
}
|
||||
|
||||
async fn verify_token(pool: &SqlitePool, token: &str) -> Result<Option<String>, sqlx::Error> {
|
||||
let result = sqlx::query(
|
||||
"SELECT username FROM sessions WHERE token = ? AND expires_at > datetime('now')"
|
||||
)
|
||||
.bind(token)
|
||||
.fetch_optional(pool)
|
||||
.await?;
|
||||
|
||||
Ok(result.map(|row| row.get("username")))
|
||||
}
|
||||
|
||||
async fn broadcast_user_list(users: &UserMap) {
|
||||
let user_list: Vec<String> = users.read().await.keys().cloned().collect();
|
||||
let user_list_msg = serde_json::json!({
|
||||
"type": "user_list",
|
||||
"users": user_list
|
||||
});
|
||||
|
||||
for tx in users.read().await.values() {
|
||||
let _ = tx.send(Message::Text(user_list_msg.to_string()));
|
||||
}
|
||||
}
|
||||
|
||||
async fn save_message(pool: &SqlitePool, msg: &ChatMessage) -> Result<(), sqlx::Error> {
|
||||
sqlx::query(
|
||||
"INSERT OR REPLACE INTO messages (id, from_user, to_user, content, timestamp, message_type) VALUES (?, ?, ?, ?, ?, ?)",
|
||||
)
|
||||
.bind(&msg.id)
|
||||
.bind(&msg.from_user)
|
||||
.bind(&msg.to_user)
|
||||
.bind(&msg.content)
|
||||
.bind(msg.timestamp)
|
||||
.bind(&msg.message_type)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn get_message_history(pool: &SqlitePool, username: &str) -> Result<Vec<ChatMessage>, sqlx::Error> {
|
||||
let rows = sqlx::query(
|
||||
"SELECT id, from_user, to_user, content, timestamp, message_type FROM messages WHERE from_user = ? OR to_user = ? ORDER BY timestamp"
|
||||
)
|
||||
.bind(username)
|
||||
.bind(username)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
|
||||
let mut messages = Vec::new();
|
||||
for row in rows {
|
||||
let message = ChatMessage {
|
||||
id: row.get("id"),
|
||||
from_user: row.get("from_user"),
|
||||
to_user: row.get("to_user"),
|
||||
content: row.get("content"),
|
||||
timestamp: row.get("timestamp"),
|
||||
message_type: row.get("message_type"),
|
||||
};
|
||||
messages.push(message);
|
||||
}
|
||||
|
||||
Ok(messages)
|
||||
}
|
||||
Reference in new issue
Block a user