Kubernetes Java Exec不为输入提供任何输出

下面是我的代码，我试图通过Redis主题从另一个使用Redisson库的应用程序向流程OutputStream提供输入，但我无法看到控制台上打印的任何输出

这是因为Redisson库中的消息被拉入另一个线程，而exec进程正在另一个线程中运行，还是因为该进程无法获取并向System.in/System.out以外的其他线程提供输出

如您所见，我正试图通过redis topic发布命令，因为我的另一个应用程序负责将命令发送到此应用程序，该应用程序已使用pod启动exec进程

两个应用程序都使用SpringBoot2.0。我被困在这里很长时间了，非常感谢您的帮助

    package com.demo.kubeconnector.service;

import com.google.api.client.util.ByteStreams;
import com.demo.kubeconnector.model.Exec;
import com.demo.kubeconnector.utils.SocResponse;
import com.demo.kubeconnector.utils.WebSocket;
import io.kubernetes.client.ApiClient;
import io.kubernetes.client.ApiException;
import io.kubernetes.client.models.V1Pod;
import io.kubernetes.client.util.Config;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.redisson.api.RBucket;
import org.redisson.api.RTopic;
import org.redisson.api.RedissonClient;
import org.redisson.api.listener.MessageListener;
import org.springframework.messaging.simp.SimpMessagingTemplate;

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.TimeUnit;

@Slf4j
public class ExecStartThread extends Thread {

    private V1Pod mPod;
    private String mContainer;
    private RTopic<Exec> mRTopic;
    private SimpMessagingTemplate mSimpMessagingTemplate;
    private Process mProcess;
    private BufferedReader mBufferedReader;
    private ByteArrayInputStream mByteArrayInputStream;
    private int mListenerId;
    private String mToken;
    private RBucket<String> mSessionBucket;

    public ExecStartThread(RedissonClient redissonClient, RBucket<String> sessionBucket, String session, String topic, V1Pod pod, String container, SimpMessagingTemplate simpMessagingTemplate) {
        mPod = pod;
        mRTopic = redissonClient.getTopic(topic);
        mContainer = container;
        mSimpMessagingTemplate = simpMessagingTemplate;
        mToken = session;
        mSessionBucket = sessionBucket;
    }

    @Override
    public void run() {

        String destination = String.format(WebSocket.POD_EXEC, mToken);

        try {

            log.info(String.format("Starting a thread {%s} for process", Thread.currentThread().getName()));

            mProcess = getProcess();
            mBufferedReader = new BufferedReader(new InputStreamReader(mProcess.getInputStream()));

            mRTopic.addListener(new MessageListener<Exec>() {
                @Override
                public void onMessage(String channel, Exec msg) {
                    String command = msg.getCommand();

                    try {
                        if (!command.equals("exit")) {
                            log.info("Executing command in Thread " + Thread.currentThread().getName() + "-->:" + msg);
                            mByteArrayInputStream = new ByteArrayInputStream(command.getBytes());
                            ByteStreams.copy(mByteArrayInputStream, mProcess.getOutputStream());
                        } else {
                            log.info("Exiting thread.... " + Thread.currentThread().getId());

                            mSessionBucket.deleteAsync();
                            mRTopic.removeListener(mListenerId);

                            IOUtils.closeQuietly(mBufferedReader);
                            IOUtils.closeQuietly(mByteArrayInputStream);
                            mProcess.destroy();

                            interrupt();
                        }
                    } catch (IOException ex) {
                        log.info(String.format("IOException occurred in the SSH topic {%s}", mRTopic.getChannelNames()));
                    }
                }
            });

            /* Return the created session.
             * */
            mSimpMessagingTemplate.convertAndSend(destination, SocResponse.ok(mToken));

            String line;
            while ((line = mBufferedReader.readLine()) != null) {
                System.out.println("Thread is " + Thread.currentThread().getName() + "-->:" + line);
                mSimpMessagingTemplate.convertAndSend(destination, SocResponse.ok(line));
            }

            log.info("Buffer reader has ended");
        } catch (IOException e) {
            log.info(String.format("Exception occurred while getting process ---> \n %s", e.getMessage()), e);
        } catch (ApiException e) {
            log.error(String.format("APIException occurred while getting process ---> \n %s", e.getResponseBody()), e);
        }
    }

    private Process getProcess() throws IOException, ApiException {

        ApiClient client = Config.defaultClient();
        client.getHttpClient().setReadTimeout(0l, TimeUnit.MILLISECONDS);

//        Configuration.setDefaultApiClient(client);

        io.kubernetes.client.Exec exec = new io.kubernetes.client.Exec();
        exec.setApiClient(client);

        return exec.exec(
                mPod,
                new String[]{"sh"},
                mContainer,
                Boolean.TRUE,
                Boolean.TRUE);
    }
}

package com.demo.kubeconnector.service；
导入com.google.api.client.util.ByTestStreams；
导入com.demo.kubeconnector.model.Exec；
导入com.demo.kubeconnector.utils.SocResponse；
导入com.demo.kubeconnector.utils.WebSocket；
导入io.kubernetes.client.ApiClient；
导入io.kubernetes.client.ApiException；
导入io.kubernetes.client.models.V1Pod；
导入io.kubernetes.client.util.Config；
导入lombok.extern.slf4j.slf4j；
导入org.apache.commons.io.IOUtils；
导入org.redisson.api.RBucket；
导入org.redisson.api.RTopic；
导入org.redisson.api.RedissonClient；
导入org.redisson.api.listener.MessageListener；
导入org.springframework.messaging.simp.SimpMessagingTemplate；
导入java.io.BufferedReader；
导入java.io.ByteArrayInputStream；
导入java.io.IOException；
导入java.io.InputStreamReader；
导入java.util.concurrent.TimeUnit；
@Slf4j
公共类ExecStartThread扩展线程{
私营部门；
私有字符串mContainer；
私人主题；
私有SimpMessageTemplate mSimpMessagingTemplate；
私有进程；
专用缓冲读取器；
私有ByteArrayInputStream mbyterayinputstream；
私密的内部消息；
私有字符串mToken；
私人垃圾桶；
public ExecutStartThread（RedisonClient RedisonClient、RBucket sessionBucket、字符串会话、字符串主题、V1Pod pod、字符串容器、SimpMessageTemplate SimpMessageTemplate）{
mPod=pod；
mRTopic=redissonClient.getTopic（主题）；
mContainer=容器；
mSimpMessagingTemplate=SimpMessageTemplate；
mToken=会话；
mSessionBucket=会话bucket；
}
@凌驾
公开募捐{
String destination=String.format（WebSocket.POD_EXEC，mToken）；
试一试{
log.info（String.format（“为进程启动线程{%s}”，thread.currentThread（）.getName（））；
mpprocess=getProcess（）；
mBufferedReader=new BufferedReader（new InputStreamReader（mpprocess.getInputStream（））；
mRTopic.addListener（新MessageListener（）{
@凌驾
消息上的公共void（字符串通道，Exec消息）{
String command=msg.getCommand（）；
试一试{
如果（！command.equals（“exit”））{
log.info（“在线程中执行命令”+Thread.currentThread（）.getName（）+”-->:“+msg”）；
mbyteraryinputstream=newbytearrayinputstream（command.getBytes（））；
copy（mByteArrayInputStream，mpProcess.getOutputStream（））；
}否则{
log.info（“正在退出线程…”+thread.currentThread（）.getId（））；
mSessionBucket.deleteAsync（）；
mRTopic.removeListener（mListenerId）；
IOUtils.安静地关闭（mBufferedReader）；
IOUtils.closequity（mbyteraryInputStream）；
mpprocess.destroy（）；
中断（）；
}
}捕获（IOEX异常）{
log.info（String.format（“SSH主题{%s}中发生IOException”，mRTopic.getChannelNames（））；
}
}
});
/*返回创建的会话。
* */
mSimpMessagingTemplate.convertAndSend（destination，SocResponse.ok（mToken））；
弦线；
而（（line=mBufferedReader.readLine（））！=null）{
System.out.println（“线程是”+Thread.currentThread（）.getName（）+”-->:“+line”）；
mSimpMessagingTemplate.convertAndSend（目的地，SocResponse.ok（行））；
}
log.info（“缓冲区读取器已结束”）；
}捕获（IOE异常）{
log.info（String.format（“获取进程-->\n%s时发生异常”，e.getMessage（）），e）；
}捕获（APIE）{
log.error（String.format（“获取进程-->\n%s时发生APIException”，e.GetResponseBy（）），e）；
}
}
私有进程getProcess（）引发IOException，ApiException{
ApiClient client=Config.defaultClient（）；
client.getHttpClient（）.setReadTimeout（0l，时间单位为毫秒）；
//setDefaultApicClient（客户端）；
io.kubernetes.client.Exec Exec=新io.kubernetes.client.Exec（）；
执行setApiClient（客户）；
返回exec.exec(
mPod，
新字符串[]{“sh”}，
McContainer，
Boolean.TRUE，
布尔值（TRUE）；
}
}