how to run kubectl exec -it <mypod>-c <mycontainer> -- sh and keep the terminal open and connected to stdin and stdout

[Masber]

Hi,

I am checking the examples provided and can't figure out how to hook the stdin in my laptop to the one in the container. Basically I want to be able to reproduce the same functionality as kubectl exec -it <pod name> -c <container name> -- sh.

This is what I tried so far:

pub async fn test(xname: &str) -> Result<(), Box<dyn Error>>{

    let client = get_k8s_client_programmatically().await?;

    let pods_api: Api<Pod> = Api::namespaced(client, "services");

    let params = kube::api::ListParams::default().limit(1).labels(format!("app.kubernetes.io/name=console-operator").as_str());
        
    let pods = pods_api.list(&params).await?;

    let console_pod = &pods.items[0];
    let console_pod_name = console_operator_pod.metadata.name.clone().unwrap();

    log::info!("Connecting to console {} - kubectl -n services exec -it {} -c console-node -- sh", xname, console_pod_name);

    let mut attached = pods_api.exec(
        &console_pod_name, 
        // vec!["conman", "-j", xname], 
        vec!["sh"],
        &AttachParams::default()
            .container("console-node")
            .stdin(true)
            .stdout(true)
            .stderr(false) // Note to self: tty and stderr cannot both be true
            .tty(true)
    ).await?;

    let mut user_input;
    let stdin = std::io::stdin(); // We get `Stdin` here.
    
    let mut stdin_writer = attached.stdin().unwrap();
    let mut stdout_stream = tokio_util::io::ReaderStream::new(attached.stdout().unwrap());

    loop {

        let next_stdout = stdout_stream.next();
        let stdout = String::from_utf8(next_stdout.await.unwrap().unwrap().to_vec()).unwrap();
        print!("{}", stdout); // printing shell prompt

        user_input = String::new();
        stdin.read_line(&mut user_input)?;
        stdin_writer.write_all(format!("{}", user_input).as_bytes()).await?;
    }
}

I am not sure I am doing it properly because the stdout seems out of sync meaning I need to press enter twice for each command to see the output.

As an example

[2022-10-25T22:58:58Z INFO  manta::node_console] Connecting to console x1500c3s0b0n0 - kubectl -n services exec -it console-node-0 -c console-node -- sh
                             # <<------------- PRESS ENTER
sh-4.4$ 
ls /                         # <<------------- type command and PRESS ENTER
sh-4.4$ ls /
app  boot  etc        home  lib64  opt   root  sbin      srv  tmp  var
bin  dev   gitInfo.txt    lib   mnt    proc  run     selinux  sys  usr
ls /tmp                      # <<------------- type command and PRESS ENTER
sh-4.4$ ls /tmp
                             # <<------------- PRESS ENTER
consoleAgg  rot_conman.state  test.file  test.file2
sh-4.4$ 

I guess I am doing it wrong...

Any hint on how to get the interactive session done properly?

[clux]

Not a real answer, but as you have found out in #1063, this is hard due to actual terminal behaviour is hard to deal with. We just expose the raw streams, whereas kubectl invokes a terminal handling library (moby/term) for its stream handling. And we are more a trying to match behaviour of client-go than kubectl (kubectl-like behaviour is just for showcasing in the examples).

We currently do not have a good way to show how to do this, so if anyone have more full examples that they can link to / would like to extend our examples / or have some way of plugging crossterm into the stdout stream, it would be very cool to see! This PR is the first thing we have that is using crossterm in examples.

[Masber]

thanks!
I agree with you that terminal behaviour is not under the scope of this library, I realised this when I was reading about how terminal work in Linux...
I got something working using termion, my solution is not as nice as the one in the PR tho.

    let mut stdin_writer = attached.stdin().unwrap();
    let mut stdout_stream = ReaderStream::new(attached.stdout().unwrap());

    let mut stdin = std::io::stdin();
    let mut stdout = stdout().into_raw_mode().unwrap();

    let rt = Runtime::new().unwrap();
    rt.spawn(async move {

        let mut next_stdout;

        loop {

            next_stdout = stdout_stream.next().await;
            match next_stdout {
                Some(next_from_remote_stdout) => { // Print stream to stdout while steam lives
                    print!("{}", std::str::from_utf8(&next_from_remote_stdout.unwrap()).unwrap());
                    stdout.flush().unwrap();
                }
                None => { // Stream has finished. Reseting terminal and Exiting application.
                    stdout.suspend_raw_mode().unwrap();
                    std::process::exit(0);
                }
            }
        }
    });

    loop {
        let mut buffer = [0; 1];

        let n = stdin.read(&mut buffer[..])?;

        stdin_writer.write_all(format!("{}", String::from_utf8((&buffer[..n]).to_vec()).unwrap()).as_bytes()).await?;
    }