dragonfly-client-config 0.1.127

Configuration for the dragonfly client
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

/*
 *     Copyright 2024 The Dragonfly Authors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use std::env;
use std::path::Path;
use std::process::Command;
use std::time::{SystemTime, UNIX_EPOCH};

/// Commit represents the git commit information.
struct Commit {
    /// hash is the full hash of the commit.
    hash: String,

    /// short_hash is the short hash of the commit.
    short_hash: String,

    /// date is the date of the commit.
    date: String,
}

/// get_commit_from_git returns the git commit information.
fn get_commit_from_git() -> Option<Commit> {
    if !Path::new("../.git").exists() {
        return None;
    }

    let output = match Command::new("git")
        .arg("log")
        .arg("-1")
        .arg("--date=short")
        .arg("--format=%H %h %cd")
        .arg("--abbrev=9")
        .output()
    {
        Ok(output) if output.status.success() => output,
        _ => return None,
    };

    let stdout = String::from_utf8(output.stdout).unwrap();
    let mut parts = stdout.split_whitespace().map(|s| s.to_string());

    Some(Commit {
        hash: parts.next()?,
        short_hash: parts.next()?,
        date: parts.next()?,
    })
}

fn main() {
    // Set the environment variables for the build platform.
    let target = env::var("TARGET").unwrap_or_default();
    println!("cargo:rustc-env=BUILD_PLATFORM={}", target);

    // Get the RUSTFLAGS environment variable.
    let mut rustflags = env::var("RUSTFLAGS").unwrap_or_default();

    // Set the environment variables for the RUSTFLAGS.
    let additional_rustflags = if target.contains("x86_64") {
        "-C target-feature=+sse4.2"
    } else {
        ""
    };

    if !additional_rustflags.is_empty() {
        if !rustflags.is_empty() {
            rustflags.push(' ');
        }
        rustflags.push_str(additional_rustflags);
        println!("cargo:rustc-env=RUSTFLAGS={}", rustflags);
    }

    // Set the environment variables for the build time.
    if let Ok(build_time) = SystemTime::now().duration_since(UNIX_EPOCH) {
        println!("cargo:rustc-env=BUILD_TIMESTAMP={}", build_time.as_secs());
    }

    // Get the commit information from git.
    if let Some(commit) = get_commit_from_git() {
        // Set the environment variables for the git commit.
        println!("cargo:rustc-env=GIT_COMMIT_HASH={}", commit.hash);

        // Set the environment variables for the git commit short.
        println!(
            "cargo:rustc-env=GIT_COMMIT_SHORT_HASH={}",
            commit.short_hash
        );

        // Set the environment variables for the git commit date.
        println!("cargo:rustc-env=GIT_COMMIT_DATE={}", commit.date);
    }
}