mirror of
https://github.com/modrinth/code.git
synced 2026-08-26 01:26:23 +00:00
Josiah GlossonandJai A
650ab71a83
* Fix not being able to connect to local friends socket
* Start basic work on tunneling protocol and move some code into a common crate
* Commonize message serialization logic
* Serialize Base62Ids as u64 when human-readability is not required
* Move ActiveSockets tuple into struct
* Make CI run when rust-common is updated
CI is currently broken for labrinth, however
* Fix theseus-release.yml to reference itself correctly
* Implement Labrinth side of tunneling
* Implement non-friend part of theseus tunneling
* Implement client-side except for socket loop
* Implement the socket loop
Doesn't work though. Debugging time!
* Fix config.rs
* Fix deadlock in labrinth socket handling
* Update dockerfile
* switch to workspace prepare at root level
* Wait for connection before tunneling in playground
* Move rust-common into labrinth
* Remove rust-common references from Actions
* Revert "Update dockerfile"
This reverts commit 3caad59bb4.
* Fix Docker build
* Rebuild Theseus if common code changes
* Allow multiple connections from the same user
* Fix test building
* Move FriendSocketListening and FriendSocketStoppedListening to non-panicking TODO for now
* Make message_serialization macro take varargs for binary messages
* Improve syntax of message_serialization macro
* Remove the ability to connect to a virtual socket, and disable the ability to listen on one
* Allow the app to compile without running labrinth
* Clippy fix
* Update Rust and Clippy fix again
---------
Co-authored-by: Jai A <jaiagr+gpg@pm.me>
62 lines
1.8 KiB
Rust
62 lines
1.8 KiB
Rust
#![cfg_attr(
|
|
all(not(debug_assertions), target_os = "windows"),
|
|
windows_subsystem = "windows"
|
|
)]
|
|
|
|
use std::time::Duration;
|
|
use theseus::prelude::*;
|
|
use tokio::signal::ctrl_c;
|
|
|
|
// A simple Rust implementation of the authentication run
|
|
// 1) call the authenticate_begin_flow() function to get the URL to open (like you would in the frontend)
|
|
// 2) open the URL in a browser
|
|
// 3) call the authenticate_await_complete_flow() function to get the credentials (like you would in the frontend)
|
|
pub async fn authenticate_run() -> theseus::Result<Credentials> {
|
|
println!("A browser window will now open, follow the login flow there.");
|
|
let login = minecraft_auth::begin_login().await?;
|
|
|
|
println!("URL {}", login.redirect_uri.as_str());
|
|
webbrowser::open(login.redirect_uri.as_str())?;
|
|
|
|
println!("Please enter URL code: ");
|
|
let mut input = String::new();
|
|
std::io::stdin()
|
|
.read_line(&mut input)
|
|
.expect("error: unable to read user input");
|
|
|
|
println!("You entered: {}", input.trim());
|
|
|
|
let credentials = minecraft_auth::finish_login(&input, login).await?;
|
|
|
|
println!("Logged in user {}.", credentials.username);
|
|
Ok(credentials)
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> theseus::Result<()> {
|
|
println!("Starting.");
|
|
|
|
let _log_guard = theseus::start_logger();
|
|
|
|
// Initialize state
|
|
State::init().await?;
|
|
|
|
loop {
|
|
if State::get().await?.friends_socket.is_connected().await {
|
|
break;
|
|
}
|
|
tokio::time::sleep(Duration::from_millis(500)).await;
|
|
}
|
|
|
|
tracing::info!("Starting host");
|
|
|
|
let socket = State::get().await?.friends_socket.open_port(25565).await?;
|
|
tracing::info!("Running host on socket {}", socket.socket_id());
|
|
|
|
ctrl_c().await?;
|
|
tracing::info!("Stopping host");
|
|
socket.shutdown().await?;
|
|
|
|
Ok(())
|
|
}
|