coodev-runner 0.1.42

A simple runner for coodev
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
92
93
94
95
96

use crate::{
  runner::{CreateWorkflowOptions, GithubAuthorization, Runner, WorkflowRunner},
  WorkflowAPIEvent, WorkflowEvent, WorkflowMessage, WorkflowRunOptions, WorkflowRunResult,
};
use std::{env, fs};

pub struct Config {
  pub github_app_id: u64,
  pub github_app_private_key: String,
}

pub fn read_env(key: &str) -> anyhow::Result<String> {
  env::var(key).map_err(|_| anyhow::anyhow!("{} is not set", key))
}

pub fn load_config() -> anyhow::Result<Config> {
  dotenv::dotenv().ok();
  let github_app_id = read_env("GITHUB_APP_ID")?;
  let github_app_private_key_path = read_env("GITHUB_APP_PRIVATE_KEY_PATH")?;

  let github_app_private_key = fs::read_to_string(github_app_private_key_path)
    .map_err(|err| anyhow::anyhow!("Failed to read github app private key: {}", err.to_string()))?;

  Ok(Config {
    github_app_id: github_app_id.parse::<u64>()?,
    github_app_private_key,
  })
}

pub fn create_runner() -> anyhow::Result<Runner> {
  enable_logger();
  let config = load_config()?;
  let github_authorization = GithubAuthorization::GithubApp {
    app_id: config.github_app_id,
    private_key: config.github_app_private_key,
  };
  let runner = Runner::builder()
    .github_authorization(github_authorization)
    .build()?;

  runner.on_event(|event| match event {
    WorkflowMessage::Log {
      number, message, ..
    } => {
      log::info!("{}: {}", number, message);
    }
    _ => {}
  });
  Ok(runner)
}

pub fn get_default_run_options() -> WorkflowRunOptions {
  let options = WorkflowRunOptions {
    run_id: "default-run-id".to_string(),
    environments: None,
  };

  options
}

pub fn create_workflow_options(config: impl Into<String>) -> CreateWorkflowOptions {
  let options = CreateWorkflowOptions {
    event: WorkflowEvent::API(WorkflowAPIEvent {
      repo_owner: "panghu-huang".to_string(),
      repo_name: "octocrate".to_string(),
      ref_name: "refs/heads/main".to_string(),
      sha: "95409faeae0e81635075091f56888e4bb5fc1a76".to_string(),
      pr_number: None,
    }),
    config: config.into(),
  };

  options
}

pub fn create_workflow_runner(workflow_str: &str) -> anyhow::Result<WorkflowRunner> {
  let runner = create_runner()?;
  let workflow_runner = runner.create_workflow_runner(create_workflow_options(workflow_str))?;

  Ok(workflow_runner)
}

pub async fn run_workflow(workflow_str: &str) -> anyhow::Result<WorkflowRunResult> {
  let workflow_runner = create_workflow_runner(workflow_str)?;
  let res = workflow_runner.run(get_default_run_options()).await?;

  Ok(res)
}

pub fn enable_logger() {
  let _res = env_logger::builder()
    .target(env_logger::Target::Stdout)
    .filter_level(log::LevelFilter::Info)
    .is_test(true)
    .try_init();
}