cardamon 0.0.2

Cardamon is a tool to help development teams measure the power consumption and carbon emissions of their software.
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
92
93
94
95
96
97
98

use super::pagination::Page;
use crate::entities::iteration::{self, Entity as Iteration};
use anyhow::{self, Context};
use sea_orm::*;

#[derive(DerivePartialModel, FromQueryResult)]
#[sea_orm(entity = "Iteration")]
pub struct ScenarioName {
    pub scenario_name: String,
}

pub async fn fetch_all(
    page: &Option<Page>,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<ScenarioName>> {
    let query = iteration::Entity::find()
        .distinct_on([iteration::Column::ScenarioName])
        .order_by_asc(iteration::Column::StartTime)
        .into_partial_model::<ScenarioName>();

    let res = match page {
        Some(page) => query.paginate(db, page.size).fetch_page(page.num).await,

        _ => query.all(db).await,
    };

    res.context("Error fetching all scenarios")
}

pub async fn fetch_in_run(
    run: &str,
    page: &Option<Page>,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<ScenarioName>> {
    let query = iteration::Entity::find()
        .distinct_on([iteration::Column::ScenarioName])
        .filter(iteration::Column::RunId.eq(run))
        .order_by_asc(iteration::Column::StartTime)
        .into_partial_model::<ScenarioName>();

    let res = match page {
        Some(page) => query.paginate(db, page.size).fetch_page(page.num).await,
        _ => query.all(db).await,
    };

    res.context(format!(
        "Error fetching all scenarios executed in run {}",
        run
    ))
}

pub async fn fetch_in_range(
    from: i64,
    to: i64,
    page: &Option<Page>,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<ScenarioName>> {
    let query = iteration::Entity::find()
        .distinct_on([iteration::Column::ScenarioName])
        .filter(
            Condition::all()
                .add(iteration::Column::StopTime.gt(from))
                .add(iteration::Column::StartTime.lt(to)),
        )
        .order_by_asc(iteration::Column::StartTime)
        .into_partial_model::<ScenarioName>();

    let res = match page {
        Some(page) => query.paginate(db, page.size).fetch_page(page.num).await,

        _ => query.all(db).await,
    };

    res.context(format!(
        "Error fetching scenarios run between: from {}, to {}",
        from, to
    ))
}

pub async fn fetch_by_name(
    name: &str,
    page: &Option<Page>,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<ScenarioName>> {
    let query = iteration::Entity::find()
        .distinct_on([iteration::Column::ScenarioName])
        .filter(iteration::Column::ScenarioName.like(name))
        .order_by_asc(iteration::Column::StartTime)
        .into_partial_model::<ScenarioName>();

    let res = match page {
        Some(page) => query.paginate(db, page.size).fetch_page(page.num).await,

        _ => query.all(db).await,
    };

    res.context(format!("Error fetching scenarios by name: {}", name))
}