ambee/giterated

1

use anyhow::Error;

2

use connection::{connection_worker, Connections, RawConnection};

3

use giterated_daemon::{

4

authentication::AuthenticationTokenGranter,

5

backend::{

6

discovery::GiteratedDiscoveryProtocol, git::GitBackend, user::UserAuth, DiscoveryBackend,

7

RepositoryBackend, UserBackend,

8

},

9

connection, listener,

10

model::instance::Instance,

11

};

12

use listener::Listeners;

13

use sqlx::{postgres::PgConnectOptions, ConnectOptions, PgPool};

14

use std::{net::SocketAddr, str::FromStr, sync::Arc};

15

use tokio::{

16

fs::File,

17

io::{AsyncRead, AsyncReadExt, AsyncWrite},

18

net::{TcpListener, TcpStream},

19

sync::Mutex,

20

};

21

use tokio_tungstenite::{accept_async, WebSocketStream};

use toml::Table;

#[macro_use]

extern crate tracing;

26

27

#[tokio::main]

28

async fn main() -> Result<(), Error> {

29

tracing_subscriber::fmt::init();

30

let mut listener = TcpListener::bind("0.0.0.0:7270").await?;

31

let connections: Arc<Mutex<Connections>> = Arc::default();

32

let listeners: Arc<Mutex<Listeners>> = Arc::default();

33

let config: Table = {

34

let mut file = File::open("Giterated.toml").await?;

35

let mut text = String::new();

36

file.read_to_string(&mut text).await?;

37

text.parse()?

38

};

39

let db_conn_options = PgConnectOptions::new()

40

.host(config["postgres"]["host"].as_str().unwrap())

41

.port(config["postgres"]["port"].as_integer().unwrap() as u16)

42

.database(config["postgres"]["database"].as_str().unwrap())

43

.username(config["postgres"]["user"].as_str().unwrap())

44

.password(config["postgres"]["password"].as_str().unwrap())

45

.log_statements(log::LevelFilter::Off);

46

let db_pool = PgPool::connect_with(db_conn_options).await?;

47

48

debug!("Running database migrations...");

49

sqlx::migrate!().run(&db_pool).await?;

50

info!("Connected");

51

52

let repository_backend: Arc<Mutex<dyn RepositoryBackend + Send>> = Arc::new(Mutex::new({

53

let foo: GitBackend = GitBackend {

54

pg_pool: db_pool.clone(),

55

repository_folder: String::from(

56

config["giterated"]["backend"]["git"]["root"]

.as_str()

.unwrap(),

),

};

foo

}));

let token_granter = Arc::new(Mutex::new(AuthenticationTokenGranter {

65

config: config.clone(),

66

}));

67

68

let user_backend: Arc<Mutex<dyn UserBackend + Send>> = Arc::new(Mutex::new(UserAuth::new(

69

db_pool,

70

&Instance::from_str("giterated.dev").unwrap(),

71

token_granter.clone(),

72

)));

73

74

let discovery_backend: Arc<Mutex<dyn DiscoveryBackend + Send>> =

75

Arc::new(Mutex::new(GiteratedDiscoveryProtocol {}));

info!("Connected");

loop {

let stream = accept_stream(&mut listener).await;

81

info!("Connected");

82

83

let (stream, address) = match stream {

84

Ok(stream) => stream,

85

Err(err) => {

86

error!("Failed to accept connection. {:?}", err);

continue;

}

};

info!("Accepted connection from {}", address);

92

93

let connection = accept_websocket_connection(stream).await;

94

95

let connection = match connection {

96

Ok(connection) => connection,

97

Err(err) => {

98

error!(

99

"Failed to initiate Websocket connection from {}. {:?}",

address, err

);

continue;

}

};

info!("Websocket connection established with {}", address);

107

108

let connection = RawConnection {

109

task: tokio::spawn(connection_worker(

connection,

listeners.clone(),

connections.clone(),

repository_backend.clone(),

114

user_backend.clone(),

115

token_granter.clone(),

116

discovery_backend.clone(),

address,

)),

};

connections.lock().await.connections.push(connection);

}

}

async fn accept_stream(listener: &mut TcpListener) -> Result<(TcpStream, SocketAddr), Error> {

126

let stream = listener.accept().await?;

Ok(stream)

}

async fn accept_websocket_connection<S: AsyncRead + AsyncWrite + Unpin>(

132

stream: S,

133

) -> Result<WebSocketStream<S>, Error> {

134

let connection = accept_async(stream).await?;

Ok(connection)

}