mirror of
https://github.com/denoland/deno.git
synced 2024-11-01 09:24:20 -04:00
108 lines
2.7 KiB
Rust
108 lines
2.7 KiB
Rust
// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
|
|
|
|
use google_storage1::api::Object;
|
|
use google_storage1::hyper;
|
|
use google_storage1::hyper_rustls;
|
|
use google_storage1::oauth2;
|
|
use google_storage1::Storage;
|
|
use once_cell::sync::Lazy;
|
|
use std::collections::HashMap;
|
|
use std::io::Cursor;
|
|
|
|
static GIT_HASH: Lazy<String> = Lazy::new(|| {
|
|
test_util::run_collect(&["git", "rev-parse", "HEAD"], None, None, None, true)
|
|
.0
|
|
.trim()
|
|
.to_string()
|
|
});
|
|
|
|
#[derive(serde::Serialize)]
|
|
struct Metric<T: serde::Serialize> {
|
|
name: String,
|
|
value: T,
|
|
sha1: String,
|
|
#[serde(rename = "type")]
|
|
type_: String,
|
|
time: i64,
|
|
}
|
|
|
|
pub struct Reporter {
|
|
wtr: csv::Writer<Vec<u8>>,
|
|
gcloud_client: Option<Storage>,
|
|
}
|
|
|
|
impl Reporter {
|
|
pub async fn new() -> Self {
|
|
dotenv::dotenv().ok();
|
|
let gcloud_client =
|
|
match std::env::var("CI").map(|_| std::env::var("GOOGLE_SVC_KEY")) {
|
|
Ok(Ok(key_str)) => {
|
|
let secret = oauth2::parse_service_account_key(key_str)
|
|
.expect("Failed to load service account key");
|
|
let auth =
|
|
oauth2::authenticator::ServiceAccountAuthenticator::builder(secret)
|
|
.build()
|
|
.await
|
|
.unwrap();
|
|
let client = hyper::Client::builder().build(
|
|
hyper_rustls::HttpsConnectorBuilder::new()
|
|
.with_native_roots()
|
|
.https_or_http()
|
|
.enable_http1()
|
|
.enable_http2()
|
|
.build(),
|
|
);
|
|
Some(Storage::new(client, auth))
|
|
}
|
|
_ => None,
|
|
};
|
|
Self {
|
|
wtr: csv::Writer::from_writer(vec![]),
|
|
gcloud_client,
|
|
}
|
|
}
|
|
|
|
pub fn write_one<T: serde::Serialize>(
|
|
&mut self,
|
|
type_: &str,
|
|
name: &str,
|
|
value: T,
|
|
) {
|
|
self
|
|
.wtr
|
|
.serialize(Metric {
|
|
name: name.to_string(),
|
|
type_: type_.to_string(),
|
|
value,
|
|
sha1: GIT_HASH.clone(),
|
|
time: chrono::Utc::now().timestamp_millis(),
|
|
})
|
|
.unwrap();
|
|
}
|
|
|
|
pub fn write<T: serde::Serialize + Copy>(
|
|
&mut self,
|
|
type_: &str,
|
|
hashmap: &HashMap<String, T>,
|
|
) {
|
|
for (name, value) in hashmap {
|
|
self.write_one(type_, name, *value);
|
|
}
|
|
}
|
|
|
|
pub async fn submit(mut self) {
|
|
self.wtr.flush().unwrap();
|
|
if let Some(client) = self.gcloud_client.take() {
|
|
let mut reader = Cursor::new(self.wtr.into_inner().unwrap());
|
|
let object: Object = Object::default();
|
|
client
|
|
.objects()
|
|
.insert(object, "deno_benchmark_data")
|
|
.name(&format!("{}.csv", *GIT_HASH))
|
|
.param("uploadType", "multipart")
|
|
.upload(&mut reader, "text/csv".parse().unwrap())
|
|
.await
|
|
.unwrap();
|
|
}
|
|
}
|
|
}
|