orign 0.2.3

A globally distributed container orchestrator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// src/db.rs
use crate::config::CONFIG;
use sea_orm::{ConnectionTrait, Database, DatabaseConnection, DbErr, Schema};

pub type DbPool = DatabaseConnection;

pub async fn init_db() -> Result<DbPool, DbErr> {
    let database_url = &CONFIG.database_url;
    println!("Connecting to database at: {}", database_url);

    let db = Database::connect(database_url).await?;

    // Create the schema builder
    let schema = Schema::new(db.get_database_backend());

    // Create tables if they don't exist
    db.execute(
        db.get_database_backend().build(
            schema
                .create_table_from_entity(crate::entities::chat_history::Entity)
                .if_not_exists(),
        ),
    )
    .await?;

    if let Err(e) = db
        .execute(
            db.get_database_backend().build(
                schema
                    .create_table_from_entity(crate::entities::llm::Entity)
                    .if_not_exists(),
            ),
        )
        .await
    {
        eprintln!("Error creating `llms` table: {}", e);
        return Err(e);
    } else {
        println!("`llms` table created or already exists.");
    }

    if let Err(e) = db
        .execute(
            db.get_database_backend().build(
                schema
                    .create_table_from_entity(crate::entities::buffer::Entity)
                    .if_not_exists(),
            ),
        )
        .await
    {
        eprintln!("Error creating `buffers` table: {}", e);
        return Err(e);
    } else {
        println!("`buffers` table created or already exists.");
    }

    if let Err(e) = db
        .execute(
            db.get_database_backend().build(
                schema
                    .create_table_from_entity(crate::entities::human::Entity)
                    .if_not_exists(),
            ),
        )
        .await
    {
        eprintln!("Error creating `humans` table: {}", e);
        return Err(e);
    } else {
        println!("`humans` table created or already exists.");
    }

    if let Err(e) = db
        .execute(
            db.get_database_backend().build(
                schema
                    .create_table_from_entity(crate::entities::feedback::Entity)
                    .if_not_exists(),
            ),
        )
        .await
    {
        eprintln!("Error creating `feedback` table: {}", e);
        return Err(e);
    } else {
        println!("`feedback` table created or already exists.");
    }

    Ok(db)
}