org.apache.sshd.server.ExitCallback Java Examples

public SshShellRunnable(SshShellProperties properties, ChannelSession session,
                        SshShellListenerService shellListenerService, Banner shellBanner,
                        PromptProvider promptProvider, Shell shell,
                        JLineShellAutoConfiguration.CompleterAdapter completerAdapter, Parser parser,
                        Environment environment, org.apache.sshd.server.Environment sshEnv,
                        SshShellCommandFactory sshShellCommandFactory, InputStream is,
                        OutputStream os, ExitCallback ec) {
    this.properties = properties;
    this.session = session;
    this.shellListenerService = shellListenerService;
    this.shellBanner = shellBanner;
    this.promptProvider = promptProvider;
    this.shell = shell;
    this.completerAdapter = completerAdapter;
    this.parser = parser;
    this.environment = environment;
    this.sshEnv = sshEnv;
    this.sshShellCommandFactory = sshShellCommandFactory;
    this.is = is;
    this.os = os;
    this.ec = ec;
}
 

/**
 * Creates a pipe thread that connects an input to an output
 *
 * @param name     The name of the thread (for debugging purposes)
 * @param in       The input stream
 * @param out      The output stream
 * @param callback An object whose method {@linkplain ExitCallback#onExit(int)} will be called when the pipe is
 *                 broken. The integer argument is 0 if everything went well.
 */
private static void connect(final String name, final InputStream in, final OutputStream out,
                            final ExitCallback callback) {
    final Thread thread = new Thread((Runnable) () -> {
        int code = 0;
        try {
            final byte buffer[] = new byte[1024];
            int len;
            while ((len = in.read(buffer, 0, buffer.length)) != -1) {
                out.write(buffer, 0, len);
                out.flush();
            }
        } catch (final SshException ex1) {
            // Nothing to do, this occurs when the connection
            // is closed on the remote side
        } catch (final IOException ex2) {
            if (!ex2.getMessage().equals("Pipe closed")) {
                code = -1;
            }
        }
        if (callback != null) {
            callback.onExit(code);
        }
    }, name);
    thread.setDaemon(true);
    thread.start();
}
 

@SuppressWarnings({"boxing", "resource"})
NewScpCommand getFailureScpCommand(int returnVal, ExitCallback callback) throws IOException {
    String filePath = "/mep-testing-gradle/foo/bar/maven-metadata.xml";
    FileSystemView viewMock = Mockito.mock(FileSystemView.class);

    Mockito.when(viewMock.getFile(Matchers.any(SshFile.class), Matchers.anyString())).thenReturn(null);

    OutputStream osMock = Mockito.mock(OutputStream.class);
    InputStream isMock = Mockito.mock(InputStream.class);
    LoggingHelper loggingHelper = Mockito.mock(LoggingHelper.class);

    Mockito.when(isMock.read()).thenReturn(returnVal);

    final NewScpHelper helperMocked = new NewScpHelper(isMock, osMock, viewMock, loggingHelper, null, null) {
        @Override
        public String readLine() throws IOException {
            return "filename";
        }

    };


    SshRequestLog requestLog = Mockito.mock(SshRequestLog.class);
    NewScpCommand scpCommand = new NewScpCommand("scp -t " + filePath, requestLog, null) {
        @Override
        protected NewScpHelper createScpHelper() {
            return helperMocked;
        }
    };

    scpCommand.setFileSystemView(viewMock);
    scpCommand.setOutputStream(osMock);
    scpCommand.setInputStream(isMock);
    scpCommand.setExitCallback(callback);

    return scpCommand;
}
 

@Test
public void testFileFailure() throws IOException {
    ExitCallback callback = Mockito.mock(ExitCallback.class);
    NewScpCommand scpCommand = getFailureScpCommand((int) 'C', callback);
    scpCommand.run();

    Mockito.verify(callback).onExit(Matchers.anyInt(), Matchers.anyString());
}
 

public REPLCommandProcessor(String prompt, KeyMap keyMap, CommandProcessor commandProcessor,
                            InputStream stdin, OutputWriterImpl outputWriter, ExitCallback exitCallback) {
    this.stdin = stdin;
    this.outputWriter = outputWriter;
    this.exitCallback = exitCallback;
    this.commandProcessor = commandProcessor;
    this.keyMap = keyMap;
    this.prompt = prompt;
    this.charset = Charset.forName("UTF-8");
}
 

@Override
public Command create() {
    return new Command() {
        @Override
        public void setInputStream(InputStream in) {
            SshEchoCommandFactory.this.in = in;
        }

        @Override
        public void setOutputStream(OutputStream out) {
            SshEchoCommandFactory.this.out = out;
        }

        @Override
        public void setErrorStream(OutputStream err) {

        }

        @Override
        public void setExitCallback(ExitCallback callback) {

        }

        @Override
        public void start(Environment env) throws IOException {
            executor.scheduleWithFixedDelay(
                    SshEchoCommandFactory.this,
                    0,
                    100,
                    TimeUnit.MILLISECONDS);
        }

        @Override
        public void destroy() {
            executor.shutdownNow();
        }
    };
}
 

public SshClientCommandProcessor(InputStream stdin, OutputWriterImpl outputWriter,
                                 ExitCallback exitCallback, CommandProcessor commandProcessor, KeyMap keyMap) {
    this.stdin = stdin;
    this.outputWriter = outputWriter;
    this.exitCallback = exitCallback;
    this.commandProcessor = commandProcessor;
    this.keyMap = keyMap;
    this.charset = Charset.forName("UTF-8");
}
 

@Test
public void testDirFailure() throws IOException {
    ExitCallback callback = Mockito.mock(ExitCallback.class);
    NewScpCommand scpCommand = getFailureScpCommand((int) 'D', callback);
    scpCommand.run();

    Mockito.verify(callback).onExit(Matchers.anyInt(), Matchers.anyString());
}
 

@Override
public void setExitCallback(ExitCallback callback) {
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    // ignored
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(ExitCallback exitCallback) {
    this.exitCallback = exitCallback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    cbk = callback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(final ExitCallback callback) {
	this.callback = callback;
}
 

public SshClientSessionImpl(long sessionId, OutputStream stdout, ExitCallback exitCallback) {
    this.sessionId = sessionId;
    this.stdout = stdout;
    this.exitCallback = exitCallback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    // ignored
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(ExitCallback ec) {
    SSH_IO_CONTEXT.get().setEc(ec);
}
 

@Override
public void setExitCallback(ExitCallback exitCallBack) {
	this.exitCallBack = exitCallBack;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}
 

@Override
public void setExitCallback(ExitCallback exitCallback) {
    this.exitCallback = exitCallback;
}
 

@Override
public void setExitCallback(ExitCallback exitCallback) {
    this.exitCallback = exitCallback;
}
 

@Override
public void setExitCallback(ExitCallback callback) {
    this.callback = callback;
}