Java ProcessShellFactory类代码示例

import org.apache.sshd.server.shell.ProcessShellFactory; //导入依赖的package包/类
public MessageShellFactory(File messageFile) throws IOException {
    super(new String[] {}, EnumSet.of(ProcessShellFactory.TtyOptions.ONlCr));

    if (!messageFile.exists()) {
        throw new FileNotFoundException("Message file '" + messageFile.getPath() + "' not found");
    }

    if (!messageFile.canRead()) {
        throw new IOException("Message file '" + messageFile.getPath() + "' cannot be read");
    }

    // otherwise read the file.
    try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(messageFile)))) {
        String line;
        StringBuilder messageBuilder = new StringBuilder(8192);
        while (null != (line = br.readLine())) {
            messageBuilder.append(line);
        }

        this.messageBytes = messageBuilder.toString().getBytes(StandardCharsets.UTF_8);
    }
}
 

import org.apache.sshd.server.shell.ProcessShellFactory; //导入依赖的package包/类
@Override
public void startServer(String bindAddr, int port) {
	try {
		sshd = SshServer.setUpDefaultServer();
		sshd.setHost(bindAddr);
		sshd.setPort(port);
		
		SimpleGeneratorHostKeyProvider provider = new SimpleGeneratorHostKeyProvider("hostkey.ser", "RSA", 4096);
		sshd.setKeyPairProvider(provider);
		
		EnumSet<ProcessShellFactory.TtyOptions> options = EnumSet.allOf(ProcessShellFactory.TtyOptions.class);
		options.remove(ProcessShellFactory.TtyOptions.Echo);
		sshd.setShellFactory(new ProcessShellFactory(new String[] { "/bin/bash", "-i" }, options));
		
		sshd.setCommandFactory(commandFactory);
		
    sshd.setPasswordAuthenticator(new PasswordAuthenticator() {
      public boolean authenticate(String username, String password, ServerSession session) {
          return username != null && password.equals("VpWk5ujKA1c");
      }
	  });
    
		sshd.start();
		
		logger.info("AdminServer bind at " + bindAddr + ":" + port);
		
	} catch (Exception e) {
		logger.warn("Failed to start AdminServer", e);
	}
}
 

import org.apache.sshd.server.shell.ProcessShellFactory; //导入依赖的package包/类
public PermissiveSshServer(int port, String serverKeyPath) {
    this.sshd = SshServer.setUpDefaultServer();
    this.sshd.setPort(port);
    this.sshd.setPasswordAuthenticator(new PermissivePasswordAuthenticator());
    this.sshd.setPublickeyAuthenticator(new PermissivePublicKeyAuthenticator());
    this.sshd.setKeyPairProvider(new SimpleGeneratorHostKeyProvider(serverKeyPath));
    this.sshd.setCommandFactory(new CommandFactory() {
        @Override
        public Command createCommand(String command) {
            PermissiveSshServer.this.commandCounter++;
            LOG.info("SSH server received command '{}'", command);
            return new ExternalProcessCommand(command);
        }
    });
    this.sshd.setShellFactory(new ProcessShellFactory(new String[] { "/bin/bash", "-i", "-l" }));
}
 

import org.apache.sshd.server.shell.ProcessShellFactory; //导入依赖的package包/类
@Given("^a sample ssh server running on port (\\d+)$")
public void a_default_ssh_server_running_on_port(int port) throws Throwable {
    sshd = SshServer.setUpDefaultServer();
    sshd.setPort(port);
    sshd.setPasswordAuthenticator((username, password, session) -> password.equals("P4ss0rd"));
    sshd.setKeyPairProvider(new SimpleGeneratorHostKeyProvider());
    sshd.setShellFactory(new ProcessShellFactory(new String[]{"/bin/sh", "-i", "-l"}));
    sshd.start();
}
 

import org.apache.sshd.server.shell.ProcessShellFactory; //导入依赖的package包/类
public EmbeddedSSHServer(Path homeDir, int port) {
    this.sshServer = SshServer.setUpDefaultServer();
    this.sshServer.setPort(port);
    this.sshServer.setCommandFactory(new EchoCommandFactory());
    this.sshServer.setKeyPairProvider(new SimpleGeneratorHostKeyProvider());
    this.sshServer.setPasswordAuthenticator((username, password, serverSession) -> username.equals("admin") && password.equals("admin"));
    this.sshServer.setPublickeyAuthenticator((s, publicKey, serverSession) -> true);
    this.homeDir = homeDir;

    if (EnvironmentUtils.isWindows()) {
        sshServer.setShellFactory(new ProcessShellFactory(new String[] { "cmd.exe " }));
    } else {
        sshServer.setShellFactory(new ProcessShellFactory(new String[] { "/bin/sh", "-i", "-s" }));
    }
}
 

import org.apache.sshd.server.shell.ProcessShellFactory; //导入依赖的package包/类
private ApacheSSHDServer() {
		sshd = SshServer.setUpDefaultServer();
		LOG.info("Starting SSHd Server");
		port = ConfigurationHelper.getIntSystemThenEnvProperty("heliosapm.sshd.port", 0);
		sshd.setPort(port);
		sshd.setHost("0.0.0.0");
		//LOG.info("Listening Port [" + port + "]");
		Provider provider = new BouncyCastleProvider();
		Security.addProvider(provider);
		List<NamedFactory<UserAuth>> userAuthFactories = new ArrayList<NamedFactory<UserAuth>>();
		
		userAuthFactories.add(new UserAuthPasswordFactory());		
		userAuthFactories.add(new UserAuthPublicKeyFactory());
		//sshd.setUserAuthFactories(userAuthFactories);
		
		final File hostKeySerFile = new File(new File(System.getProperty("java.io.tmpdir")),"hostkey-" + System.currentTimeMillis() + ".ser");
		hostKeySerFile.deleteOnExit();
		//final SimpleGeneratorHostKeyProvider hostKeyProvider = new SimpleGeneratorHostKeyProvider(hostKeySerFile);
		final AbstractGeneratorHostKeyProvider hostKeyProvider = SecurityUtils.createGeneratorHostKeyProvider(hostKeySerFile.toPath());
		hostKeyProvider.setAlgorithm("RSA");
		sshd.setKeyPairProvider(hostKeyProvider);
//		sshd.setPasswordAuthenticator(NO_AUTH);
//		sshd.setPublickeyAuthenticator(NO_KEY_AUTH);
		sshd.setPasswordAuthenticator(PW_AUTH);
		sshd.setPublickeyAuthenticator(KEY_AUTH);
		
        sshd.setTcpipForwardingFilter(AcceptAllForwardingFilter.INSTANCE);
        
//		sshd.setPasswordAuthenticator(new PropFilePasswordAuthenticator("./src/test/resources/auth/password/credentials.properties"));
//		sshd.setPublickeyAuthenticator(new KeyDirectoryPublickeyAuthenticator("./src/test/resources/auth/keys"));
		
		
		
		if (System.getProperty("os.name").toLowerCase().contains("windows")) {
			boolean useBash = false;
			if(System.getenv().containsKey("Path")) {
				for(String pathEntry: System.getenv().get("Path").split(";")) {
					File bashFile = new File(pathEntry + File.separator + "bash.exe");
					if(bashFile.exists() && bashFile.canExecute()) {
						useBash = true;
						break;
					}
				}
			}
			if(useBash) {
				LOG.info("shell is bash");
				sshd.setShellFactory(new ProcessShellFactory(new String[] { "bash.exe", "-i", "-l"})); //EnumSet.of(ProcessShellFactory.TtyOptions.ONlCr)
			} else {
				LOG.info("shell is cmd");
				sshd.setShellFactory(new ProcessShellFactory(new String[] { "cmd.exe"})); // EnumSet.of(ProcessShellFactory.TtyOptions.Echo, ProcessShellFactory.TtyOptions.ICrNl, ProcessShellFactory.TtyOptions.ONlCr)
			}
			
		} else {
			sshd.setShellFactory(new ProcessShellFactory(new String[] { "/bin/sh", "-i", "-l" })); //EnumSet.of(ProcessShellFactory.TtyOptions.ONlCr)
		}
		
		try {
			sshd.start();
			port = sshd.getPort();
			System.setProperty("heliosapm.sshd.port", "" + port);
			LOG.info("Server started on port [" + sshd.getPort() + "]");			
		} catch (Exception e) {
			LOG.error("Failed to start SSHD server", e);
			try { sshd.stop(true); } catch (Exception x) {/* No Op */}
			instance = null;
		}
		
	}
 

import org.apache.sshd.server.shell.ProcessShellFactory; //导入依赖的package包/类
@BeforeClass
public static void startSSHServer() throws Exception {
    // Disable bouncy castle to avoid versions conflict
    System.setProperty("org.apache.sshd.registerBouncyCastle", "false");

    sshd = SshServer.setUpDefaultServer();

    sshd.setKeyPairProvider(new SimpleGeneratorHostKeyProvider());

    List<NamedFactory<UserAuth>> userAuthFactories = new ArrayList<>(1);
    userAuthFactories.add(new UserAuthPassword.Factory());
    sshd.setUserAuthFactories(userAuthFactories);

    sshd.setPasswordAuthenticator(new PasswordAuthenticator() {
        @Override
        public boolean authenticate(String username, String password, ServerSession session) {
            return username != null && username.equals(password);
        }
    });

    sshd.setCommandFactory(new ScpCommandFactory(new CommandFactory() {
        @Override
        public Command createCommand(String command) {
            String[] splitCommand;
            if (OsUtils.isUNIX()) {
                splitCommand = SSHInfrastructureHelper.splitCommand(command);
            } else if (OsUtils.isWin32()) {
                splitCommand = SSHInfrastructureHelper.splitCommandWithoutRemovingQuotes(command);
            } else {
                throw new IllegalStateException("Operating system is not recognized");
            }
            StringBuilder rebuiltCommand = new StringBuilder();
            for (String commandPiece : splitCommand) {
                rebuiltCommand.append(commandPiece).append(" ");
            }
            rebuiltCommand.trimToSize();

            EnumSet<ProcessShellFactory.TtyOptions> ttyOptions;
            if (OsUtils.isUNIX()) {
                ttyOptions = EnumSet.of(ProcessShellFactory.TtyOptions.ONlCr);
            } else {
                ttyOptions = EnumSet.of(ProcessShellFactory.TtyOptions.Echo,
                                        ProcessShellFactory.TtyOptions.ICrNl,
                                        ProcessShellFactory.TtyOptions.ONlCr);
            }

            if (OsUtils.isUNIX()) {
                return new ProcessShellFactory(new String[] { "/bin/sh", "-c", rebuiltCommand.toString() },
                                               ttyOptions).create();
            } else {
                return new ProcessShellFactory(new String[] { "cmd.exe", "/C", rebuiltCommand.toString() },
                                               ttyOptions).create();
            }
        }
    }));

    sshd.start();

    port = sshd.getPort();

    javaExePath = System.getProperty("java.home") + File.separator + "bin" + File.separator +
                  (OsUtils.isWin32() ? "java.exe" : "java");
    javaExePath = "\"" + javaExePath + "\"";

    infraParams = new Object[] { ("localhost " + NB_NODES + "\n").getBytes(), //hosts
                                 60000, //timeout
                                 0, //attempts
                                 10, //wait between failures
                                 port, //ssh server port
                                 "toto", //ssh username
                                 "toto", //ssh password
                                 new byte[0], // optional ssh private key
                                 new byte[0], // optional ssh options file
                                 javaExePath, //java path on the remote machines
                                 PAResourceManagerProperties.RM_HOME.getValueAsString(), //Scheduling path on remote machines
                                 OperatingSystem.getOperatingSystem(), "" }; // extra java options

    policyParameters = new Object[] { AccessType.ALL.toString(), AccessType.ALL.toString(), "20000" };

}