cardamon 0.0.1

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

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

#[derive(DerivePartialModel, FromQueryResult)]
#[sea_orm(entity = "Iteration")]
pub struct RunId {
    pub run_id: i32,
}

/// Return all iterations for the given scenario over all runs. Page the results.
pub async fn fetch_runs_all(
    scenario: &str,
    page: &Option<Page>,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<iteration::Model>> {
    let query = iteration::Entity::find()
        .filter(iteration::Column::ScenarioName.eq(scenario))
        .order_by_desc(iteration::Column::StartTime);

    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 iterations")
}

/// Return all iterations for the given scenario in the given date range. Page the results.
pub async fn fetch_runs_in_range(
    scenario: &str,
    from: i64,
    to: i64,
    page: &Option<Page>,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<iteration::Model>> {
    let query = iteration::Entity::find()
        .filter(
            Condition::all()
                .add(iteration::Column::ScenarioName.eq(scenario))
                .add(iteration::Column::StopTime.gt(from))
                .add(iteration::Column::StartTime.lt(to)),
        )
        .order_by_desc(iteration::Column::StartTime);

    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 iterations")
}

pub async fn fetch_runs_last_n(
    scenario: &str,
    last_n: u64,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<iteration::Model>> {
    // SELECT *
    //         FROM iteration
    //         WHERE scenario_name = ?1 AND run_id IN (
    //             SELECT run_id
    //             FROM iteration
    //             WHERE scenario_name = ?1
    //             GROUP BY run_id
    //             ORDER BY start_time DESC
    //             LIMIT ?2
    //         )
    let sub_query = Query::select()
        .expr(Expr::col(iteration::Column::RunId))
        .from(iteration::Entity)
        .cond_where(iteration::Column::ScenarioName.eq(scenario))
        .group_by_col(iteration::Column::RunId)
        .order_by(iteration::Column::StartTime, Order::Desc)
        .limit(last_n)
        .to_owned();

    let query = iteration::Entity::find().filter(
        Condition::all()
            .add(iteration::Column::ScenarioName.eq(scenario))
            .add(iteration::Column::RunId.in_subquery(sub_query)),
    );

    query.all(db).await.context(format!(
        "Error fetching iterations of the last {} runs of scenario {}",
        last_n, scenario
    ))
}

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

    query.all(db).await.context("Error fetching unique run ids")
}

pub async fn fetch_by_scenario_and_run(
    scenario: &str,
    run_id: i32,
    db: &DatabaseConnection,
) -> anyhow::Result<Vec<iteration::Model>> {
    let query = iteration::Entity::find()
        .filter(
            Condition::all()
                .add(iteration::Column::ScenarioName.eq(scenario))
                .add(iteration::Column::RunId.eq(run_id)),
        )
        .order_by_asc(iteration::Column::StartTime);

    query
        .all(db)
        .await
        .context("Error fetching iterations by scenario and run")
}