File size: 8,701 Bytes
d5bfab8 |
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 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 |
use crate::analytics::{Analytics, AnalyticsDirectory};
use crate::common::PendingProgramsWithPriority;
use crate::config::Config;
use crate::mine::{CoordinatorWorkerMessage, MineEventDirectoryState};
use crate::oeis::{load_terms_to_program_id_set, TermsToProgramIdSet};
use super::{CreateFunnel, Funnel, FunnelConfig};
use super::{CreateGenomeMutateContextMode, create_genome_mutate_context, GenomeMutateContext};
use super::MinerWorkerMessageWithAnalytics;
use super::{create_prevent_flooding, PreventFlooding};
use super::{MinerSyncExecute, MinerSyncExecuteStatus};
use bastion::prelude::*;
use num_bigint::{BigInt, ToBigInt};
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AnalyticsWorkerMessage {
PerformSyncAndAnalytics,
}
pub async fn analytics_worker(
ctx: BastionContext,
config: Config,
prevent_flooding: Arc<Mutex<PreventFlooding>>,
) -> Result<(), ()> {
loop {
let message: SignedMessage = match ctx.recv().await {
Ok(message) => message,
Err(error) => {
error!("analytics_worker: Unknown error happened. error: {:?}", error);
continue;
}
};
MessageHandler::new(message)
.on_tell(|message: AnalyticsWorkerMessage, _| {
println!(
"analytics_worker: child {}, received broadcast message: {:?}",
ctx.current().id(),
message
);
match message {
AnalyticsWorkerMessage::PerformSyncAndAnalytics => {
perform_sync_and_analytics(&config, prevent_flooding.clone());
},
}
})
.on_fallback(|unknown, _sender_addr| {
error!(
"analytics_worker {}, received an unknown message!:\n{:?}",
ctx.current().id(),
unknown
);
});
}
}
fn perform_sync_and_analytics(
config: &Config,
prevent_flooding: Arc<Mutex<PreventFlooding>>,
) {
let command_windows: String = config.miner_sync_executable_command_windows();
let executable_path: PathBuf = config.miner_sync_executable();
let sync_status: MinerSyncExecuteStatus = match MinerSyncExecute::execute(&command_windows, &executable_path) {
Ok(value) => value,
Err(error) => {
Bastion::stop();
panic!("Problem executing MinerSyncExecute. config.miner_sync_executable_command_windows: {:?} config.miner_sync_executable: {:?} error: {:?}", command_windows, executable_path, error);
}
};
println!("Successfully executed MinerSyncExecute. status: {:?}", sync_status);
let analytics_run_result: anyhow::Result<()> = match sync_status {
MinerSyncExecuteStatus::NoChange => {
// Data is already uptodate, then skip no need to regenerate analytics.
println!("BEFORE analytics - run_if_expired");
Analytics::oeis_run_if_expired()
},
MinerSyncExecuteStatus::Changed => {
// Data has been modified, then analytics needs to be regenerated.
println!("BEFORE analytics - run_force");
Analytics::oeis_run_force()
}
};
match analytics_run_result {
Ok(()) => {},
Err(error) => {
Bastion::stop();
panic!("AFTER analytics. error: {:?}", error);
}
}
let prevent_flooding_x: PreventFlooding = match create_prevent_flooding(&config) {
Ok(value) => value,
Err(error) => {
Bastion::stop();
panic!("analytics_worker: create_prevent_flooding failed. error: {:?}", error);
}
};
match prevent_flooding.lock() {
Ok(mut instance) => {
*instance = prevent_flooding_x;
},
Err(error) => {
Bastion::stop();
panic!("analytics_worker: Unable to populate PreventFlooding mechanism. error: {:?}", error);
}
}
println!("populating terms_to_program_id");
let oeis_stripped_file: PathBuf = config.oeis_stripped_file();
let padding_value: BigInt = FunnelConfig::WILDCARD_MAGIC_VALUE.to_bigint().unwrap();
let terms_to_program_id_result = load_terms_to_program_id_set(
&oeis_stripped_file,
FunnelConfig::MINIMUM_NUMBER_OF_REQUIRED_TERMS,
FunnelConfig::TERM_COUNT,
&padding_value
);
let terms_to_program_id: TermsToProgramIdSet = match terms_to_program_id_result {
Ok(value) => value,
Err(error) => {
Bastion::stop();
panic!("analytics_worker: Unable to load terms for program ids. error: {:?}", error);
}
};
let terms_to_program_id_arc: Arc<TermsToProgramIdSet> = Arc::new(terms_to_program_id);
println!("populating funnel");
let funnel: Funnel = Funnel::create_funnel_with_file_data(&config);
println!("populating genome_mutate_context");
let analytics_directory = AnalyticsDirectory::new(
config.analytics_oeis_dir()
).expect("unable to create AnalyticsDirectory instance");
let genome_mutate_context: GenomeMutateContext = create_genome_mutate_context(CreateGenomeMutateContextMode::OEIS, analytics_directory)
.expect("analytics_worker couldn't create GenomeMutateContext");
// Pass on funnel+genome_mutate_context to miner_workers
println!("analytics_worker: sending analytics data to miner_workers");
let instance = MinerWorkerMessageWithAnalytics::new(
funnel,
genome_mutate_context,
terms_to_program_id_arc,
);
let arc_instance = Arc::new(instance);
debug!("analytics_worker: miner_workers.ask_everyone(MinerWorkerMessageWithAnalytics)");
let ask_result = Distributor::named("miner_worker").ask_everyone(arc_instance);
// wait for all the "miner_worker" instances to have received the data.
let answers: Vec<Answer> = ask_result
.expect("analytics_worker miner_workers.ask_everyone(MinerWorkerMessageWithAnalytics) couldn't ask everyone");
let mut count_answers: usize = 0;
let mut count_success: usize = 0;
for answer in answers.into_iter() {
count_answers += 1;
// Wait for a single miner_worker to respond to the question
let response_result: Option<bool> = run!(blocking! {
let mut success = false;
MessageHandler::new(answer.await.expect("couldn't receive reply"))
.on_tell(|response: String, _| {
if response == "miner_worker_updated_ok" {
success = true;
} else {
error!("analytics_worker: Unexpected response: {:?}", response);
}
})
.on_fallback(|unknown, _sender_addr| {
error!(
"analytics_worker: uh oh, I received a message I didn't understand\n {:?}",
unknown
);
});
success
});
// Only increment, if the miner_worker replied successfully
if let Some(value) = response_result {
if value {
count_success += 1;
}
}
}
if count_answers != count_success {
Bastion::stop();
panic!("analytics_worker: Expected same number of answers as there are workers. {} != {}", count_answers, count_success);
}
debug!("analytics_worker: received answers from all miner_workers");
// All the miner_workers have now received data
// Determine how many files are in the "~/.loda-rust/mine-event" directory
let mineevent_dir_state: MineEventDirectoryState = match PendingProgramsWithPriority::create(config) {
Ok(pending) => {
let mut instance = MineEventDirectoryState::new();
instance.set_number_of_mined_high_prio(pending.paths_high_prio().len());
instance.set_number_of_mined_low_prio(pending.paths_low_prio().len());
instance
},
Err(error) => {
error!("analytics_worker: Unable to determine the number of pending programs. {:?}", error);
MineEventDirectoryState::new()
}
};
let tell_result = Distributor::named("coordinator_worker").tell_everyone(
CoordinatorWorkerMessage::SyncAndAnalyticsIsComplete { mineevent_dir_state }
);
if let Err(error) = tell_result {
Bastion::stop();
panic!("analytics_worker: Unable to send SyncAndAnalyticsIsComplete to coordinator_worker. error: {:?}", error);
}
}
|