Jonas_Jones/jonas_jones-api
1
0
Fork 0
mirror of https://github.com/JonasunderscoreJones/jonas_jones-api.git synced 2025-10-23 00:59:18 +02:00
Code Issues Projects Releases Packages Wiki Activity

something more

Browse source
This commit is contained in:
J-onasJones 2023-12-07 20:15:01 +01:00
parent fbbcede694
commit 9b75ff869b
8 changed files with 170 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/logger/mod.rs
View file

@ -43,7 +43,7 @@ impl Logger {
}
pub fn format_time(timestamp: u64) -> String {
let datetime = NaiveDateTime::from_timestamp(timestamp as i64, 0);
let datetime = NaiveDateTime::from_timestamp_millis((timestamp * 1000).try_into().unwrap()).unwrap();
datetime.format("%H:%M:%S").to_string()
}
@ -63,9 +63,3 @@ impl Logger {
Self::log("PANIC", message);
}
}
fn main() {
Logger::info("This is an informational log message.");
Logger::warn("This is a warning log message.");
Logger::error("This is an error log message.");
}

54
src/main.rs
View file

@ -1,56 +1,18 @@
use warp::Filter;
use dotenv::dotenv;
use std::env;
mod v1;
mod logger;
pub mod v1;
pub mod logger;
pub mod tools;
pub mod server;
use logger::Logger;
pub use logger::Logger;
pub use tools::parse_ip;
// load .env file
fn load_env() -> Vec<String> {
dotenv().ok();
let env_var_value = match env::var("YOUR_ENV_VARIABLE") {
Ok(value) => value,
Err(_) => {
Logger::panic("Environment variable not found");
std::process::exit(1);
}
};
env_var_value.split('.').map(String::from).collect()
}
#[tokio::main(flavor = "current_thread")]
async fn main() {
// load .env file
load_env();
dotenv().ok();
logger::Logger::info("Starting server on {}:{}", );
logger::Logger::warn("This is a warning!");
logger::Logger::error("This is an error!");
v1::builtin_help();
//print env variables
println!("PORT: {}", env::var("API_PORT").unwrap());
// GET /hello/warp => 200 OK with body "Hello, warp!"
let hello = warp::path!("hello" / String)
.map(|name| format!("Hello, {}!", name));
let root = warp::path::end()
.map(|| warp::reply::html("<h1>Hello, World!</h1>"));
let routes = hello.or(root);
warp::serve(routes)
.run(([127, 0, 0, 1], 3030))
.await;
server::serve().await;
}

35
src/server.rs Normal file
View file

@ -0,0 +1,35 @@
use std::env;
use warp::Filter;
use crate::{Logger, parse_ip};
pub async fn serve() {
let api_ip = env::var("API_IP").unwrap();
let api_port = env::var("API_PORT").unwrap();
Logger::info(&format!("Server started on {}:{}", api_ip, api_port));
let socket_addr = parse_ip();
// GET /hello/warp => 200 OK with body "Hello, warp!"
let hello = warp::path!("hello" / String)
.map(|name| format!("Hello, {}!", name));
let root = warp::path::end()
.map(|| warp::reply::html("<h1>jonas_jones-api!</h1>\n<p>this is a placeholder (hopefully)</p>"));
let v1 = warp::path!("v1" / String)
.map(|name| format!("Hello, {}!", name));
let routes = hello.or(v1).or(root);
warp::serve(routes)
.run(socket_addr)
.await;
Logger::info("Server stopped");
}

62
src/std_error_respomses.rs Normal file
View file

@ -0,0 +1,62 @@
pub fn internal_server_error() -> Response<Body> {
Response::builder()
.status(StatusCode::INTERNAL_SERVER_ERROR)
.body(Body::from("Internal Server Error"))
.unwrap()
}
pub fn not_found_error() -> Response<Body> {
Response::builder()
.status(StatusCode::NOT_FOUND)
.body(Body::from("Not Found"))
.unwrap()
}
pub fn bad_request_error() -> Response<Body> {
Response::builder()
.status(StatusCode::BAD_REQUEST)
.body(Body::from("Bad Request"))
.unwrap()
}
pub fn unauthorized_error() -> Response<Body> {
Response::builder()
.status(StatusCode::UNAUTHORIZED)
.body(Body::from("Unauthorized"))
.unwrap()
}
pub fn forbidden_error() -> Response<Body> {
Response::builder()
.status(StatusCode::FORBIDDEN)
.body(Body::from("Forbidden"))
.unwrap()
}
pub fn method_not_allowed_error() -> Response<Body> {
Response::builder()
.status(StatusCode::METHOD_NOT_ALLOWED)
.body(Body::from("Method Not Allowed"))
.unwrap()
}
pub fn not_acceptable_error() -> Response<Body> {
Response::builder()
.status(StatusCode::NOT_ACCEPTABLE)
.body(Body::from("Not Acceptable"))
.unwrap()
}
pub fn conflict_error() -> Response<Body> {
Response::builder()
.status(StatusCode::CONFLICT)
.body(Body::from("Conflict"))
.unwrap()
}
pub fn gone_error() -> Response<Body> {
Response::builder()
.status(StatusCode::GONE)
.body(Body::from("Gone"))
.unwrap()
}

61
src/tools/mod.rs Normal file
View file

@ -0,0 +1,61 @@
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use crate::logger::Logger;
use std::env;
pub fn parse_ip() -> SocketAddr {
let env_api_ip = return_env_var("API_IP");
let env_api_port = return_env_var("API_PORT");
let result: Result<Vec<i32>, _> = env_api_ip
.split('.')
.map(|s| s.parse::<i32>())
.collect();
let ip_parts = match result {
Ok(numbers) => numbers,
Err(_4) => {
Logger::panic(&format!("Illegal character in Environment variable 'API_IP'"));
std::process::exit(1)
}
};
// Attempt to parse the string into a u16
let parsed_env_api_port: u16 = match env_api_port.parse::<u16>() {
Ok(parsed_env_api_port) => parsed_env_api_port,
Err(_) => {
Logger::panic(&format!("Illegal character in Environment variable 'Api_PORT'"));
std::process::exit(1)
}
};
// Convert Vec<i32> to Ipv4Addr
let ipv4_addr: Ipv4Addr = Ipv4Addr::new(
ip_parts[0] as u8,
ip_parts[1] as u8,
ip_parts[2] as u8,
ip_parts[3] as u8,
);
// Convert Ipv4Addr to IpAddr
let ip_addr: IpAddr = IpAddr::V4(ipv4_addr);
// Create SocketAddr from IpAddr and port
let socket_addr: SocketAddr = SocketAddr::new(ip_addr, parsed_env_api_port);
return socket_addr;
}
pub fn return_env_var(key: &str) -> String {
return match env::var(key) {
Ok(value) => value,
Err(_) => {
Logger::panic(&format!("Environment variable '{}' not found", key));
std::process::exit(1);
}
};
}

3
src/v1/kcomebacks/mod.rs Normal file
View file

@ -0,0 +1,3 @@
pub fn main() {
}

0
src/v1/minecraft/mod.rs Normal file
View file

0
src/v1/minecraft/mods/mod.rs Normal file
View file