use std::path::{Path, PathBuf};
use super::{LoginView, by_hand, login_args};
use crate::cli_outbound::{Cli, Streamed, StreamedOutcome, StreamedPoll, stderr_text};
use crate::opslog::{self, OpEntry, Origin};
pub struct LoginRun {
streamed: Streamed,
view: LoginView,
argv: Vec<String>,
by_hand: String,
provider: String,
from: usize,
state_root: PathBuf,
ts: String,
}
fn fire(
bz: &Cli,
provider: &str,
code: Option<&str>,
state_root: &Path,
ts: &str,
) -> std::io::Result<(Streamed, Vec<String>)> {
let args = login_args(provider, code);
let mut argv = vec![bz.binary().display().to_string()];
argv.extend(args.iter().cloned());
let words: Vec<&str> = args.iter().map(String::as_str).collect();
match bz.run(&words) {
Ok(stream) => Ok((Streamed::new(stream), argv)),
Err(spawn) => {
let entry = OpEntry::synthetic_failure(
ts.to_owned(),
argv,
String::new(),
spawn.to_string(),
Origin::World,
bz.client(),
);
opslog::append(state_root, &entry)?;
Err(std::io::Error::other(spawn))
}
}
}
pub fn start(
bz: &Cli,
provider: &str,
state_root: &Path,
ts: &str,
workspace: Option<&Path>,
) -> std::io::Result<LoginRun> {
let (streamed, argv) = fire(bz, provider, None, state_root, ts)?;
Ok(LoginRun {
streamed,
view: LoginView::default(),
argv,
by_hand: by_hand(workspace, provider),
provider: provider.to_owned(),
from: 0,
state_root: state_root.to_path_buf(),
ts: ts.to_owned(),
})
}
impl LoginRun {
pub fn view(&self) -> LoginView {
self.view.clone()
}
pub fn poll(&mut self) -> bool {
if self.view.outcome.is_some() || self.view.authorize.is_some() {
return false;
}
match self.streamed.poll() {
StreamedPoll::Lines(lines) => {
self.view.lines.extend(lines);
true
}
StreamedPoll::Pending => true,
StreamedPoll::Done(outcome) => {
self.finalize(outcome);
false
}
}
}
pub fn redeem(&mut self, bz: &Cli, code: &str, ts: &str) -> std::io::Result<()> {
let (streamed, argv) = fire(bz, &self.provider, Some(code), &self.state_root, ts)?;
self.streamed = streamed;
self.argv = argv;
ts.clone_into(&mut self.ts);
self.from = self.view.lines.len();
self.view.authorize = None;
Ok(())
}
fn finalize(&mut self, outcome: StreamedOutcome) {
self.view.lines.extend(outcome.lines);
let said = self.view.lines.get(self.from..).unwrap_or_default();
let url = said.iter().rev().find(|line| !line.err);
let url = url.map(|line| line.text.clone());
let entry = OpEntry {
ts: self.ts.clone(),
argv: self.argv.clone(),
cwd: String::new(),
exit: outcome.exit,
stdout: String::new(),
stderr: stderr_text(said),
origin: Origin::World,
client: crate::registry::Client::default(),
};
match (outcome.exit, url) {
(0, Some(url)) => self.view.authorize = Some(url),
(exit, _) => {
self.view.outcome = Some(exit);
self.view.fallback = (exit != 0).then(|| self.by_hand.clone());
}
}
let _ = opslog::append(&self.state_root, &entry);
}
#[cfg(test)]
pub(crate) fn from_streamed(streamed: Streamed, argv: Vec<String>, state_root: &Path) -> Self {
Self {
streamed,
view: LoginView::default(),
by_hand: by_hand(Some(Path::new("/ws")), "openai"),
provider: "openai".to_owned(),
from: 0,
argv,
state_root: state_root.to_path_buf(),
ts: "TS".to_owned(),
}
}
}