blob: 9f535d5c7bb20553e1cb7ead8edd1a846e85c924 [file] [log] [blame]
Alan Stokesb2cc79e2021-09-14 14:08:46 +01001/*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17//! Simple command-line tool to drive composd for testing and debugging.
18
19use android_system_composd::{
Alan Stokes9ca14ca2021-10-20 14:25:57 +010020 aidl::android::system::composd::{
Alan Stokes6fc18372021-11-25 17:50:27 +000021 ICompilationTask::ICompilationTask,
Alan Stokes9ca14ca2021-10-20 14:25:57 +010022 ICompilationTaskCallback::{BnCompilationTaskCallback, ICompilationTaskCallback},
Victor Hsiehbac923e2022-02-22 21:43:36 +000023 IIsolatedCompilationService::ApexSource::ApexSource,
Alan Stokes9ca14ca2021-10-20 14:25:57 +010024 IIsolatedCompilationService::IIsolatedCompilationService,
25 },
Alan Stokesdcb96022021-10-26 15:23:31 +010026 binder::{
27 wait_for_interface, BinderFeatures, DeathRecipient, IBinder, Interface, ProcessState,
Alan Stokes6fc18372021-11-25 17:50:27 +000028 Result as BinderResult, Strong,
Alan Stokesdcb96022021-10-26 15:23:31 +010029 },
Alan Stokesb2cc79e2021-09-14 14:08:46 +010030};
Alan Stokes9ca14ca2021-10-20 14:25:57 +010031use anyhow::{bail, Context, Result};
Alan Stokes17aed5c2021-10-20 14:25:57 +010032use compos_common::timeouts::timeouts;
Alan Stokes9ca14ca2021-10-20 14:25:57 +010033use std::sync::{Arc, Condvar, Mutex};
34use std::time::Duration;
Alan Stokesb2cc79e2021-09-14 14:08:46 +010035
36fn main() -> Result<()> {
Victor Hsiehbac923e2022-02-22 21:43:36 +000037 #[rustfmt::skip]
38 let app = clap::App::new("composd_cmd")
39 .subcommand(
40 clap::SubCommand::with_name("staged-apex-compile"))
41 .subcommand(
42 clap::SubCommand::with_name("test-compile")
43 .arg(clap::Arg::with_name("prefer-staged").long("prefer-staged")),
44 );
Alan Stokes388b88a2021-10-13 16:03:17 +010045 let args = app.get_matches();
Alan Stokes388b88a2021-10-13 16:03:17 +010046
Alan Stokesb2cc79e2021-09-14 14:08:46 +010047 ProcessState::start_thread_pool();
48
Victor Hsiehbac923e2022-02-22 21:43:36 +000049 match args.subcommand() {
50 ("staged-apex-compile", _) => run_staged_apex_compile()?,
51 ("test-compile", Some(sub_matches)) => {
52 let prefer_staged = sub_matches.is_present("prefer-staged");
53 run_test_compile(prefer_staged)?;
54 }
55 _ => panic!("Unrecognized subcommand"),
Alan Stokes388b88a2021-10-13 16:03:17 +010056 }
Alan Stokesb2cc79e2021-09-14 14:08:46 +010057
58 println!("All Ok!");
59
60 Ok(())
61}
Alan Stokes9ca14ca2021-10-20 14:25:57 +010062
63struct Callback(Arc<State>);
64
65#[derive(Default)]
66struct State {
67 mutex: Mutex<Option<Outcome>>,
68 completed: Condvar,
69}
70
71#[derive(Copy, Clone)]
72enum Outcome {
73 Succeeded,
74 Failed,
75}
76
77impl Interface for Callback {}
78
79impl ICompilationTaskCallback for Callback {
80 fn onSuccess(&self) -> BinderResult<()> {
81 self.0.set_outcome(Outcome::Succeeded);
82 Ok(())
83 }
84
85 fn onFailure(&self) -> BinderResult<()> {
86 self.0.set_outcome(Outcome::Failed);
87 Ok(())
88 }
89}
90
91impl State {
92 fn set_outcome(&self, outcome: Outcome) {
93 let mut guard = self.mutex.lock().unwrap();
94 *guard = Some(outcome);
95 drop(guard);
96 self.completed.notify_all();
97 }
98
99 fn wait(&self, duration: Duration) -> Result<Outcome> {
100 let (outcome, result) = self
101 .completed
102 .wait_timeout_while(self.mutex.lock().unwrap(), duration, |outcome| outcome.is_none())
103 .unwrap();
104 if result.timed_out() {
105 bail!("Timed out waiting for compilation")
106 }
107 Ok(outcome.unwrap())
108 }
109}
110
Alan Stokes6fc18372021-11-25 17:50:27 +0000111fn run_staged_apex_compile() -> Result<()> {
112 run_async_compilation(|service, callback| service.startStagedApexCompile(callback))
113}
114
Victor Hsiehbac923e2022-02-22 21:43:36 +0000115fn run_test_compile(prefer_staged: bool) -> Result<()> {
116 let apex_source = if prefer_staged { ApexSource::PreferStaged } else { ApexSource::NoStaged };
117 run_async_compilation(|service, callback| service.startTestCompile(apex_source, callback))
Alan Stokes6fc18372021-11-25 17:50:27 +0000118}
119
120fn run_async_compilation<F>(start_compile_fn: F) -> Result<()>
121where
122 F: FnOnce(
123 &dyn IIsolatedCompilationService,
124 &Strong<dyn ICompilationTaskCallback>,
125 ) -> BinderResult<Strong<dyn ICompilationTask>>,
126{
Alan Stokes9ca14ca2021-10-20 14:25:57 +0100127 let service = wait_for_interface::<dyn IIsolatedCompilationService>("android.system.composd")
128 .context("Failed to connect to composd service")?;
129
130 let state = Arc::new(State::default());
131 let callback = Callback(state.clone());
132 let callback = BnCompilationTaskCallback::new_binder(callback, BinderFeatures::default());
Alan Stokes6fc18372021-11-25 17:50:27 +0000133 let task = start_compile_fn(&*service, &callback).context("Compilation failed")?;
Alan Stokes9ca14ca2021-10-20 14:25:57 +0100134
135 // Make sure composd keeps going even if we don't hold a reference to its service.
136 drop(service);
137
Alan Stokesdcb96022021-10-26 15:23:31 +0100138 let state_clone = state.clone();
139 let mut death_recipient = DeathRecipient::new(move || {
140 eprintln!("CompilationTask died");
141 state_clone.set_outcome(Outcome::Failed);
142 });
143 // Note that dropping death_recipient cancels this, so we can't use a temporary here.
144 task.as_binder().link_to_death(&mut death_recipient)?;
Alan Stokes9ca14ca2021-10-20 14:25:57 +0100145
146 println!("Waiting");
147
Alan Stokes17aed5c2021-10-20 14:25:57 +0100148 match state.wait(timeouts()?.odrefresh_max_execution_time) {
Alan Stokes9ca14ca2021-10-20 14:25:57 +0100149 Ok(Outcome::Succeeded) => Ok(()),
150 Ok(Outcome::Failed) => bail!("Compilation failed"),
151 Err(e) => {
152 if let Err(e) = task.cancel() {
153 eprintln!("Failed to cancel compilation: {:?}", e);
154 }
155 Err(e)
156 }
157 }
158}