13486377277

Committed 23 Feb 2025 07:54PM UTC coverage: 36.597% (-0.4%) from 36.957%

Build # 13486377277

Build Type

push

github

Committed by

dariusbakunas

Commit Message

refactor: extract init code from adhoc cli to cli trait

Run Details

0 of 29 new or added lines in 2 files covered. (0.0%)

95 existing lines in 4 files now uncovered.

714 of 1951 relevant lines covered (36.6%)

1.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/cogrs-core/src/adhoc.rs

use crate::cli::Cli;
use crate::config::manager::ConfigManager;
use crate::executor::task_queue_manager::TaskQueueManager;
use crate::inventory::manager::InventoryManager;
use crate::playbook::play::Play;
use crate::playbook::task::{Action, TaskBuilder};
use crate::playbook::Playbook;
use crate::vars::manager::VariableManager;
use crate::vars::variable::Variable::Path;
use anyhow::{anyhow, Result};
use cogrs_plugins::plugin_type::PluginType;
use cogrs_plugins::{plugin_loader, plugin_type};
use log::info;
use std::collections::HashMap;
use std::fs;
use std::path::PathBuf;
use tokio::sync::Mutex;

pub struct AdHoc;

pub struct AdHocOptions {
    pub forks: u32,
    pub poll_interval: Option<u64>,
    pub task_timeout: Option<u64>,
    pub async_val: Option<u64>,
    pub one_line: bool,
    pub connection: String,
    pub connection_timeout: Option<u64>,
    pub private_key_file: Option<PathBuf>,
}

impl Cli for AdHoc {}

impl AdHoc {
    pub async fn run(
        pattern: &str,
        limit: Option<&str>,
        module_name: &str,
        module_args: Option<String>,
        inventory_manager: &InventoryManager,
        options: &AdHocOptions,
    ) -> Result<()> {
        info!(
            "Running adhoc module {} with args {:?}",
            module_name, module_args
        );

        Self::init().await?;

        let task = TaskBuilder::new(
            "AdHoc",
            &options.connection,
            Action::Module(module_name.to_string(), module_args),
        )
        .poll_interval(options.poll_interval)
        .async_val(options.async_val)
        .build();

        let tasks = vec![task];
        let roles = [];

        let variable_manager = VariableManager::new(inventory_manager.get_base_dir());

        let play = Play::builder("CogRS Ad-Hoc", &roles)
            .use_become(false)
            .gather_facts(false)
            .connection(&options.connection)
            .pattern(pattern)
            .limit(limit)
            .tasks(&tasks)
            .build();

        let _playbook = Playbook::new("__adhoc_playbook__", &[play.clone()]);

        let mut tqm = TaskQueueManager::new(Some(options.forks as usize));
        tqm.run(play, &variable_manager, inventory_manager).await?;

        Ok(())
    }
}

1	use crate::cli::Cli;
2	use crate::config::manager::ConfigManager;
3	use crate::executor::task_queue_manager::TaskQueueManager;
4	use crate::inventory::manager::InventoryManager;
5	use crate::playbook::play::Play;
6	use crate::playbook::task::{Action, TaskBuilder};
7	use crate::playbook::Playbook;
8	use crate::vars::manager::VariableManager;
9	use crate::vars::variable::Variable::Path;
10	use anyhow::{anyhow, Result};
11	use cogrs_plugins::plugin_type::PluginType;
12	use cogrs_plugins::{plugin_loader, plugin_type};
13	use log::info;
14	use std::collections::HashMap;
15	use std::fs;
16	use std::path::PathBuf;
17	use tokio::sync::Mutex;
18
19	pub struct AdHoc;
20
21	pub struct AdHocOptions {
22	pub forks: u32,
23	pub poll_interval: Option<u64>,
24	pub task_timeout: Option<u64>,
25	pub async_val: Option<u64>,
26	pub one_line: bool,
27	pub connection: String,
28	pub connection_timeout: Option<u64>,
29	pub private_key_file: Option<PathBuf>,
30	}
31
32	impl Cli for AdHoc {}
33
34	impl AdHoc {
UNCOV 35	pub async fn run(	×
36	pattern: &str,
37	limit: Option<&str>,
38	module_name: &str,
39	module_args: Option<String>,
40	inventory_manager: &InventoryManager,
41	options: &AdHocOptions,
42	) -> Result<()> {
UNCOV 43	info!(	×
44	"Running adhoc module {} with args {:?}",
45	module_name, module_args
46	);
47
NEW 48	Self::init().await?;	×
49
50	let task = TaskBuilder::new(
51	"AdHoc",
52	&options.connection,	×
UNCOV 53	Action::Module(module_name.to_string(), module_args),	×
54	)
55	.poll_interval(options.poll_interval)	×
UNCOV 56	.async_val(options.async_val)	×
57	.build();
58
UNCOV 59	let tasks = vec![task];	×
60	let roles = [];	×
61
UNCOV 62	let variable_manager = VariableManager::new(inventory_manager.get_base_dir());	×
63
64	let play = Play::builder("CogRS Ad-Hoc", &roles)	×
65	.use_become(false)
66	.gather_facts(false)
67	.connection(&options.connection)	×
68	.pattern(pattern)	×
UNCOV 69	.limit(limit)	×
70	.tasks(&tasks)	×
71	.build();
72
UNCOV 73	let _playbook = Playbook::new("__adhoc_playbook__", &[play.clone()]);	×
74
75	let mut tqm = TaskQueueManager::new(Some(options.forks as usize));	×
76	tqm.run(play, &variable_manager, inventory_manager).await?;	×
77
78	Ok(())	×
79	}
80	}

dariusbakunas / cogrs / 13486377277

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous