org.apache.sshd.server.Environment Java Examples

@Override
public void start(Environment env) throws IOException {
    log.info("Starting");

    ExecutorService service = ThreadUtils.newSingleThreadExecutor(getClass().getSimpleName() + "-" + POOL_COUNT.incrementAndGet());
    executorHolder.set(service);

    futureHolder.set(service.submit(new Runnable() {
        @SuppressWarnings("synthetic-access")
        @Override
        public void run() {
            log.info("Start heavy load sending " + sendCount + " messages of " + msg.length + " bytes");
            for (int i = 0; i < sendCount; i++) {
                pendingWrapper.write(new ByteArrayBuffer(msg));
            }
            log.info("Sending EOF signal");
            pendingWrapper.write(new ByteArrayBuffer(new byte[]{eofSignal}));
        }
    }));
    log.info("Started");
}
 

public void start(Environment env) throws IOException {
    try {
        consoleReader = new ConsoleReader(in, new FlushyOutputStream(out), new SshTerminal());
        consoleReader.setExpandEvents(true);
        consoleReader.addCompleter(new ConsoleCommandCompleter());

        StreamHandler streamHandler = new FlushyStreamHandler(out, new ConsoleLogFormatter(), consoleReader);
        streamHandlerAppender = new StreamHandlerAppender(streamHandler);

        ((Logger) LogManager.getRootLogger()).addAppender(streamHandlerAppender);

        environment = env;
        thread = new Thread(this, "SSHD ConsoleShell " + env.getEnv().get(Environment.ENV_USER));
        thread.start();
    } catch (Exception e) {
        throw new IOException("Error starting shell", e);
    }
}
 

@Override
public void start(Environment env) throws IOException {
    log.info("Starting");

    ExecutorService service = ThreadUtils.newSingleThreadExecutor(getClass().getSimpleName() + "-" + POOL_COUNT.incrementAndGet());
    executorHolder.set(service);

    futureHolder.set(service.submit(new Runnable() {
        @SuppressWarnings("synthetic-access")
        @Override
        public void run() {
            log.info("Start heavy load sending " + sendCount + " messages of " + msg.length + " bytes");
            for (int i = 0; i < sendCount; i++) {
                pendingWrapper.write(new ByteArrayBuffer(msg));
            }
            log.info("Sending EOF signal");
            pendingWrapper.write(new ByteArrayBuffer(new byte[]{eofSignal}));
        }
    }));
    log.info("Started");
}
 

@Override
public void start(final ChannelSession channel, final Environment env) throws IOException {
	if (err != null) {
		err.write("shell not allowed\r\n".getBytes("ISO-8859-1"));
		err.flush();
	}
	if (callback != null)
		callback.onExit(-1, "shell not allowed");
}
 

public void run() {
    try {
        if (!SshdPlugin.instance.getConfig().getString("mode").equals("RPC"))
            printPreamble(consoleReader);
        while (true) {
            String command = consoleReader.readLine("\r>", null);
            if (command == null) continue;
            if (command.equals("exit") || command.equals("quit")) break;
            Bukkit.getScheduler().runTask(SshdPlugin.instance, () -> {
                if (SshdPlugin.instance.getConfig().getString("mode").equals("RPC") &&
                    command.startsWith("rpc")) {
                    //NO ECHO NO PREAMBLE AND SHIT
                    String cmd = command.substring("rpc".length() + 1, command.length());
                    Bukkit.dispatchCommand(sshdCommandSender, cmd);
                } else {
                    SshdPlugin.instance.getLogger()
                            .info("<" + environment.getEnv().get(Environment.ENV_USER) + "> " + command);
                    Bukkit.dispatchCommand(Bukkit.getConsoleSender(), command);
                }
            });
        }
    } catch (IOException e) {
        SshdPlugin.instance.getLogger().log(Level.SEVERE, "Error processing command from SSH", e);
    } finally {
        callback.onExit(0);
    }
}
 

@Override
public void start(Environment environment) throws IOException {
    try {
        SshdPlugin.instance.getLogger()
                .info("[U: " + environment.getEnv().get(Environment.ENV_USER) + "] " + command);
        Bukkit.dispatchCommand(Bukkit.getConsoleSender(), command);
    } catch (Exception e) {
        SshdPlugin.instance.getLogger().severe("Error processing command from SSH -" + e.getMessage());
    } finally {
        callback.onExit(0);
    }
}
 

@Override
public void start(Environment env) throws IOException {
    this.env = env;
    state = NetconfMessageState.NO_MATCHING_PATTERN;
    outputStream = new PrintWriter(out, false);
    try {
        pendingFuture = executors.submit(this);
    } catch (RuntimeException e) {    // e.g., RejectedExecutionException
        log.error("Failed (" + e.getClass().getSimpleName() + ") to start command: " + e.getMessage(), e);
        throw new IOException(e);
    }
}
 

/**
 * Default implementation just waits for the command to be destroyed.
 *
 * @param environment env.
 * @throws IOException if so.
 */
@Override
public void start(Environment environment) throws IOException {
    System.out.println("Starting command: " + command);
    //Default implementation just waits for a disconnect
    while (!isDestroyed()) {
        try {
            synchronized (this) {
                this.wait(WAIT_FOR_DESTROYED);
            }
        } catch (InterruptedException e) {
            System.err.println("[SSHD-CommandMock] Awake.");
        }
    }
}
 

@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 NewScpHelper(@Nonnull final InputStream in, @Nonnull final OutputStream out,
                @Nonnull final FileSystemView root, final LoggingHelper loggingHelper, @Nonnull Environment env,
                @Nonnull Map<String, String> envToAfPropertyMapping) {
    super(in, out, root);
    this.loggingHelper = loggingHelper;
    this.env = env;
    this.envToAfPropertyMapping = envToAfPropertyMapping;
}
 

@Override
public void start(Environment env) throws IOException {
    if (error != null) {
        throw error;
    }
    new Thread(this, "MkdirCommand: " + name).start();
}
 

@Override
public synchronized void start(Environment env) throws IOException {
    // TODO propagate the Environment itself and support signal sending.
    executor.execute(new Runnable() {
        @Override
        public void run() {
            runShell();
        }
    });
    LOGGER.info("Leaving start");
}
 

@Override
public synchronized void start(Environment env) throws IOException {
    // TODO propagate the Environment itself and support signal sending.
    executor.execute(new Runnable() {
        @Override
        public void run() {
            runGroovy();
        }
    });
    LOGGER.info("Leaving start");
}
 

@Override
public void start(Environment env) throws IOException {
	this.out.write(("Welcome to " + InetAddress.getLocalHost().getHostName() + "! \n").getBytes(ENCODING));
	this.out.write(("It is " + new Date() + " now. \n>").getBytes(ENCODING));
	this.out.flush();
	
	Thread t = new Thread(this);
	t.start();
}
 

@Override
public void start(Environment env) throws IOException {
    environment = env;
    thread = new Thread(this, "EchoShell");
    thread.setDaemon(true);
    thread.start();
}
 

@Override
public void start(final Environment env) throws IOException {
  String lcctype = env.getEnv().get("LC_CTYPE");
  if (lcctype != null) {
    charset = parseCharset(lcctype);
  }
  if (charset == null) {
    charset = defaultCharset;
  }
  env.addSignalListener(signal -> updateSize(env), EnumSet.of(org.apache.sshd.server.Signal.WINCH));
  updateSize(env);

  // Event handling
  int vintr = getControlChar(env, PtyMode.VINTR, 3);
  int vsusp = getControlChar(env, PtyMode.VSUSP, 26);
  int veof = getControlChar(env, PtyMode.VEOF, 4);

  //
  eventDecoder = new TtyEventDecoder(vintr, vsusp, veof);
  decoder = new BinaryDecoder(512, charset, eventDecoder);
  stdout = new TtyOutputMode(new BinaryEncoder(charset, out));
  term = env.getEnv().get("TERM");
  conn = new Connection();

  //
  session.setDataReceiver(this);
  handler.accept(conn);
}
 

@Override
public void start(Environment env) throws IOException {
    err.write(Constants.encode(generateWelcomeMessage()));
    err.flush();
    callback.onExit(0);

    in.close();
    out.close();
    err.close();
}
 

@Override
public void start(Environment env) throws IOException {
    environment = env;
    thread = new Thread(this, "EchoShell");
    thread.setDaemon(true);
    thread.start();
}
 

@Override
public void start(Environment env) throws IOException {
    long sessionId = sshClientSessionCounter.getNewSessionId();
    OutputWriter outputWriter = new OutputWriterImpl(stdout, stderr);
    commandProcessor.onSessionStart(sessionId, outputWriter);
    LOG.info("start single command processor with sessionId: {}", sessionId);
    CommandResult commandResult = commandProcessor.processCommand(command);
    exitCallback.onExit(commandResult.getReturnCode());
}
 

@Override
public void start(Environment env) throws IOException {
    environment = env;
    thread = new Thread(this, "EchoShell");
    thread.setDaemon(true);
    thread.start();
}
 

@Override
public void start(final Environment env) throws IOException {
    String lcctype = env.getEnv().get("LC_CTYPE");
    if (lcctype != null) {
        charset = parseCharset(lcctype);
    }
    if (charset == null) {
        charset = defaultCharset;
    }
    env.addSignalListener(signal -> updateSize(env), EnumSet.of(org.apache.sshd.server.Signal.WINCH));
    updateSize(env);

    // Event handling
    int vintr = getControlChar(env, PtyMode.VINTR, 3);
    int veof = getControlChar(env, PtyMode.VEOF, 4);
    int vsusp = getControlChar(env, PtyMode.VSUSP, 26);

    device = new SSHDevice(env.getEnv().get("TERM"));
    attributes = SSHAttributesBuilder.builder().environment(env).build();
    eventDecoder = new EventDecoder(attributes);
    decoder = new Decoder(512, charset, eventDecoder);
    stdout = new TtyOutputMode(new Encoder(charset, out));
    conn = new SSHConnection();

    session.setDataReceiver(this);
    handler.accept(conn);
}
 

@Override
public void start(Environment env) throws IOException {
    long sessionId = sshClientSessionCounter.getNewSessionId();
    OutputWriterImpl outputWriter = new OutputWriterImpl(stdout, stderr);
    commandProcessor.onSessionStart(sessionId, outputWriter);
    LOG.info("start ssh-client command processor with sessionId: {}", sessionId);
    SshClientSession sshClientSession =
            new SshClientSessionImpl(sessionId, stdout, exitCallback);
    SshClientCommandProcessor robotCommandProcessor = new SshClientCommandProcessor(stdin, outputWriter,
            exitCallback, commandProcessor, keyMap);
    executorService.submit(robotCommandProcessor);
    sshClientMessageDispatcherRegistration.onNewSession(sshClientSession);
}
 

@Override
public void start(ChannelSession channel, Environment env) throws IOException {
    terminalType = env.getEnv().get(Environment.ENV_TERM);
    this.channel = channel;
    sshThread = new Thread(this, "ssh-cli " + channel.getSession().getIoSession().getAttribute(Constants.USER));
    sshThread.start();
}
 

@Override
public void start(Environment env) throws IOException {
    long sessionId = sshClientSessionCounter.getNewSessionId();
    OutputWriterImpl outputWriter = new OutputWriterImpl(stdout, stderr);
    commandProcessor.onSessionStart(sessionId, outputWriter);
    LOG.info("start REPL command processor with sessionId: {}", sessionId);
    REPLCommandProcessor replCommandProcessor = new REPLCommandProcessor(prompt, keyMap, commandProcessor,
            stdin, outputWriter, exitCallback);
    executorService.submit(replCommandProcessor);
}
 

@Override
public void start(Environment env) throws IOException {
    start();
}
 

@Override
public void start(Environment environment) throws IOException {
    thread = new Thread(this, "WaitLongTimeCommand " + this.command);
    thread.setDaemon(true);
    thread.start();
}
 

@Override
public void start(Environment env) throws IOException {
    environment = env;
    session.setDataReceiver(this);
}
 

@Override
public void start(Environment env) throws IOException {
    super.start(env);
}
 

@Override
public void start(Environment env) throws IOException {
    this.thread = new Thread(this, "EchoCommand");
    this.thread.start();
}
 

public Environment getEnvironment() {
    return environment;
}