जावा के माध्यम से एससीपी


81

जावा प्रोग्रामिंग लैंग्वेज के माध्यम से एक स्कैप ट्रांसफ़र करने का सबसे अच्छा तरीका क्या है? ऐसा लगता है कि मैं JSSE, JSch या उछाल वाले महल जावा पुस्तकालयों के माध्यम से यह प्रदर्शन करने में सक्षम हो सकता हूं। इन समाधानों में से कोई भी एक आसान जवाब नहीं है।


2
क्या आप विभिन्न पुस्तकालयों के साथ जुड़े मुद्दों को तोड़ सकते हैं, वे आपके लिए काम क्यों नहीं करते हैं?
टिम हावलैंड

जवाबों:


59

मैंने Jsch का उपयोग करके समाप्त किया - यह बहुत सीधा था, और बहुत अच्छी तरह से ऊपर पैमाने पर लग रहा था (मैं हर कुछ मिनटों में कुछ हज़ार फाइलें हड़प रहा था)।


1
jsch बेहतर विकल्प निकला, लेकिन प्रलेखन भयानक है। चींटियों के scp कार्य को देखने के लिए Abarax से टिप बहुत मददगार थी। यह वास्तव में स्पष्ट नहीं है कि क्या परियोजना अभी भी बहुत सक्रिय है। पारितोषिक के लिए धन्यवाद।
लॉयड मेन्हॉलज़

30
@LloydMeinholz: मैंने इस लाइब्रेरी के लिए Javadocs लिखी हैं ।
पाओलो एबरमन

पाउलो- बढ़िया काम! वे वास्तव में मददगार दिखते हैं।
टिम हावलैंड

4
मुझे यह पृष्ठ बहुत ज्ञानवर्धक
Daniel Kaplan

23

प्लग: sshj एकमात्र समझदार विकल्प है! आरंभ करने के लिए ये उदाहरण देखें: डाउनलोड करें , अपलोड करें


4
मैं Jsch पर sshj के साथ गया क्योंकि इसमें बहुत सरल इंटरफ़ेस था।
क्रिस

1
मुख्य github साइट का प्रयोग करें या
बजे

Jsch और sshj के बीच मैं sshj के साथ सरल, उच्च स्तरीय API के कारण गया। Jsch के लिए समान उदाहरण के साथ उत्तर से अपलोड उदाहरण की तुलना करें: jcraft.com/jsch/examples/ScpTo.java.html । यह हो सकता है कि इसे "एकमात्र समझदार विकल्प" कहा गया था।
बोगदान कैलमैक

1
मेरे समय की बर्बादी क्या। उदाहरणों का उपयोग किए गए तर्कों को नहीं दिखाया जाता है। अलग-अलग दूरस्थ उपयोगकर्ता नाम दस्तावेज़ मौजूद नहीं है। इस सुझाव से लोग बचें।
कियवेली १। ’

17

यहाँ एक नज़र रखना

यह चींटियों के एससीपी कार्य के लिए स्रोत कोड है। "निष्पादित" विधि में कोड वह जगह है जहां नट और बोल्ट हैं। इसके लिए आपको एक उचित विचार देना चाहिए। यह JSch i विश्वास का उपयोग करता है।

वैकल्पिक रूप से आप सीधे इस चींटी कार्य को अपने जावा कोड से निष्पादित कर सकते हैं।


7

मैंने Jsch को कुछ यूटिलिटी मेथड के साथ लपेटा ताकि इसे थोड़ा फ्रेंडली बनाया जा सके और इसे बुलाया

Jscp

यहाँ उपलब्ध है: https://github.com/willwarren/jscp

एक फ़ोल्डर को टार करने के लिए एससीपी उपयोगिता, इसे ज़िप करें, और इसे कहीं स्केप करें, फिर इसे अनज़िप करें।

उपयोग:

// create secure context
SecureContext context = new SecureContext("userName", "localhost");

// set optional security configurations.
context.setTrustAllHosts(true);
context.setPrivateKeyFile(new File("private/key"));

// Console requires JDK 1.7
// System.out.println("enter password:");
// context.setPassword(System.console().readPassword());

Jscp.exec(context, 
           "src/dir",
           "destination/path",
           // regex ignore list 
           Arrays.asList("logs/log[0-9]*.txt",
           "backups") 
           );

इसमें उपयोगी कक्षाएं भी शामिल हैं - एससीपी और एक्सेक, और एक टारगेंजीपिप, जो उसी तरह से काम करते हैं।


5

यह उच्च-स्तरीय समाधान है , जिसे सुदृढ़ करने की आवश्यकता नहीं है। जल्दी और गन्दी!

1) सबसे पहले, http://ant.apache.org/bindownload.cgi पर जाएं और लेटेस्ट अपाचे एंट बाइनरी डाउनलोड करें। (आजकल, अपाचे-ant-1.9.4-bin.zip)।

2) डाउनलोड की गई फ़ाइल को निकालें और JAR ant-jsch.jar ("अपाचे-चींटी-1.9.4 / lib / ant-jsch.jar") ढूंढें। इस JAR को अपने प्रोजेक्ट में जोड़ें । इसके अलावा ant.-launcher.jar और ant.jar।

3) पर जाएं Jcraft jsch SouceForge परियोजना और जार डाउनलोड करें। आजकल, jsch-0.1.52.jarइस JAR को अपने प्रोजेक्ट में भी जोड़ें

अब, आप easyly जावा कोड में चींटी वर्ग का उपयोग कर सकते Scp नेटवर्क या अधिक प्रति फ़ाइलों के लिए SSHExec SSH सर्वर में आदेश के लिए।

4) कोड उदाहरण एसपीपी:

// This make scp copy of 
// one local file to remote dir

org.apache.tools.ant.taskdefs.optional.ssh.Scp scp = new Scp();
int portSSH = 22;
String srvrSSH = "ssh.your.domain";
String userSSH = "anyuser"; 
String pswdSSH = new String ( jPasswordField1.getPassword() );
String localFile = "C:\\localfile.txt";
String remoteDir = "/uploads/";

scp.setPort( portSSH );
scp.setLocalFile( localFile );
scp.setTodir( userSSH + ":" + pswdSSH + "@" + srvrSSH + ":" + remoteDir );
scp.setProject( new Project() );
scp.setTrust( true );
scp.execute();

मैं यह कोशिश कर रहा हूं, लेकिन यदि कोई समाधान है तो त्रुटि हुई है तो कृपया टिप्पणी करें ---> com.jcraft.jsch.JSchException: Session.connect: java.security.NoSuchAlgorithmException: एल्गोरिथम डीएच उपलब्ध नहीं है
करण

1
यदि आपको एक त्वरित समाधान की आवश्यकता है तो यह जादू की तरह काम करता है और अधिक सरल आवंटित करता है तो सीधे जेएसएच का उपयोग करके, धन्यवाद।
हैम रमन

Org.apache.tools.ant.taskdefs.optional.ssh.Scp के साथ रिमोट सर्वर से पढ़ना संभव है?
मिनिषा

3

अधिभारित परियोजना सूचियों कई जावा विकल्प, जावा के लिए Trilead SSH फिट करने के लिए आप जो चाह रहे हैं लगता है।


ट्रिलैड जेस्च की तुलना में अधिक परिपक्व लगते हैं, लेकिन sftp और scp सपोर्ट की कमी थी, जो कि मैं बाद में था। वर्तमान में, sftp ने केवल समर्थन प्राप्त किया और डाला (मुझे ls और rm की भी आवश्यकता है) और scp समर्थन को अनुभवात्मक के रूप में सूचीबद्ध किया गया था।
लॉयड मेन्होलज़

2

मैं इस एसएफटीपी एपीआई का उपयोग करता हूं जिसमें एससीपी है जिसे ज़होन कहा जाता है, यह बहुत अच्छा है, इसलिए बहुत सारे नमूना कोड के साथ उपयोग करना आसान है। यहाँ साइट http://www.zehon.com है


2

मैंने इनमें से बहुत सारे समाधानों को देखा और उनमें से कई को पसंद नहीं किया। ज्यादातर क्योंकि अपने ज्ञात मेजबानों की पहचान करने के कष्टप्रद कदम। वह और JSCH, scp कमांड के सापेक्ष एक निम्न स्तर पर है।

मुझे एक लाइब्रेरी मिली जिसकी आवश्यकता नहीं है लेकिन यह बंडल है और कमांड लाइन टूल के रूप में उपयोग किया जाता है। https://code.google.com/p/scp-java-client/

मैंने स्रोत कोड के माध्यम से देखा और यह पता लगाया कि कमांड लाइन के बिना इसका उपयोग कैसे किया जाए। यहाँ अपलोड करने का एक उदाहरण है:

    uk.co.marcoratto.scp.SCP scp = new uk.co.marcoratto.scp.SCP(new uk.co.marcoratto.scp.listeners.SCPListenerPrintStream());
    scp.setUsername("root");
    scp.setPassword("blah");
    scp.setTrust(true);
    scp.setFromUri(file.getAbsolutePath());
    scp.setToUri("root@host:/path/on/remote");
    scp.execute();

सबसे बड़ी नकारात्मक बात यह है कि यह मावेन रेपो में नहीं है (जो मुझे मिल सकता है)। लेकिन, उपयोग की आसानी मेरे लिए इसके लायक है।


1

jsCH ने मेरे लिए बहुत अच्छा काम किया है। नीचे एक विधि का एक उदाहरण है जो sftp सर्वर से कनेक्ट होगा और निर्दिष्ट निर्देशिका में फ़ाइलों को डाउनलोड करेगा। यह StrictHostKeyChecking को अक्षम करने से दूर रहने के लिए अनुशंसित है। हालांकि सुरक्षा कारणों के लिए थोड़ा और अधिक मुश्किल है, क्योंकि ज्ञात मेजबानों को निर्दिष्ट करना आदर्श होना चाहिए।

jsch.setKnownHosts ("C: \ Users \ test \ know_hosts"); की सिफारिश की

JSch.setConfig ("StrictHostKeyChecking", "no"); - सिफारिश नहीं की गई

import com.jcraft.jsch.*;
 public void downloadFtp(String userName, String password, String host, int port, String path) {


        Session session = null;
        Channel channel = null;
        try {
            JSch ssh = new JSch();
            JSch.setConfig("StrictHostKeyChecking", "no");
            session = ssh.getSession(userName, host, port);
            session.setPassword(password);
            session.connect();
            channel = session.openChannel("sftp");
            channel.connect();
            ChannelSftp sftp = (ChannelSftp) channel;
            sftp.get(path, "specify path to where you want the files to be output");
        } catch (JSchException e) {
            System.out.println(userName);
            e.printStackTrace();


        } catch (SftpException e) {
            System.out.println(userName);
            e.printStackTrace();
        } finally {
            if (channel != null) {
                channel.disconnect();
            }
            if (session != null) {
                session.disconnect();
            }
        }

    }

1

यहाँ कुछ की तरह, मैंने JSch लाइब्रेरी के चारों ओर एक आवरण लिखना समाप्त किया।

इसे रास्ता-सेकंड कहा जाता है और इसे GitHub पर होस्ट किया जाता है:

https://github.com/objectos/way-secshell

// scp myfile.txt localhost:/tmp
File file = new File("myfile.txt");
Scp res = WaySSH.scp()
  .file(file)
  .toHost("localhost")
  .at("/tmp")
  .send();

1

JSch साथ काम करने के लिए एक अच्छी लाइब्रेरी है। यह आपके प्रश्न के लिए काफी आसान उत्तर है।

JSch jsch=new JSch();
  Session session=jsch.getSession(user, host, 22);
  session.setPassword("password");


  Properties config = new Properties();
  config.put("StrictHostKeyChecking","no");
  session.setConfig(config);
  session.connect();

  boolean ptimestamp = true;

  // exec 'scp -t rfile' remotely
  String command="scp " + (ptimestamp ? "-p" :"") +" -t "+rfile;
  Channel channel=session.openChannel("exec");
  ((ChannelExec)channel).setCommand(command);

  // get I/O streams for remote scp
  OutputStream out=channel.getOutputStream();
  InputStream in=channel.getInputStream();

  channel.connect();

  if(checkAck(in)!=0){
    System.exit(0);
  }

  File _lfile = new File(lfile);

  if(ptimestamp){
    command="T "+(_lfile.lastModified()/1000)+" 0";
    // The access time should be sent here,
    // but it is not accessible with JavaAPI ;-<
    command+=(" "+(_lfile.lastModified()/1000)+" 0\n");
    out.write(command.getBytes()); out.flush();
    if(checkAck(in)!=0){
      System.exit(0);
    }
  }

आप पर पूरा कोड पा सकते हैं

http://faisalbhagat.blogspot.com/2013/09/java-uploading-file-remotely-via-scp.html


1

जेस्च का उपयोग करके फ़ाइल अपलोड करने के लिए एक उदाहरण यहां दिया गया है :

ScpUploader.java:

import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;

import java.io.ByteArrayInputStream;
import java.util.Properties;

public final class ScpUploader
{
    public static ScpUploader newInstance()
    {
        return new ScpUploader();
    }

    private volatile Session session;
    private volatile ChannelSftp channel;

    private ScpUploader(){}

    public synchronized void connect(String host, int port, String username, String password) throws JSchException
    {
        JSch jsch = new JSch();

        Properties config = new Properties();
        config.put("StrictHostKeyChecking", "no");

        session = jsch.getSession(username, host, port);
        session.setPassword(password);
        session.setConfig(config);
        session.setInputStream(System.in);
        session.connect();

        channel = (ChannelSftp) session.openChannel("sftp");
        channel.connect();
    }

    public synchronized void uploadFile(String directoryPath, String fileName, byte[] fileBytes, boolean overwrite) throws SftpException
    {
        if(session == null || channel == null)
        {
            System.err.println("No open session!");
            return;
        }

        // a workaround to check if the directory exists. Otherwise, create it
        channel.cd("/");
        String[] directories = directoryPath.split("/");
        for(String directory : directories)
        {
            if(directory.length() > 0)
            {
                try
                {
                    channel.cd(directory);
                }
                catch(SftpException e)
                {
                    // swallowed exception

                    System.out.println("The directory (" + directory + ") seems to be not exist. We will try to create it.");

                    try
                    {
                        channel.mkdir(directory);
                        channel.cd(directory);
                        System.out.println("The directory (" + directory + ") is created successfully!");
                    }
                    catch(SftpException e1)
                    {
                        System.err.println("The directory (" + directory + ") is failed to be created!");
                        e1.printStackTrace();
                        return;
                    }

                }
            }
        }

        channel.put(new ByteArrayInputStream(fileBytes), directoryPath + "/" + fileName, overwrite ? ChannelSftp.OVERWRITE : ChannelSftp.RESUME);
    }

    public synchronized void disconnect()
    {
        if(session == null || channel == null)
        {
            System.err.println("No open session!");
            return;
        }

        channel.exit();
        channel.disconnect();
        session.disconnect();

        channel = null;
        session = null;
    }
}

AppEntryPoint.java:

import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.SftpException;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public final class AppEntryPoint
{
    private static final String HOST = "192.168.1.1";
    private static final int PORT = 22;
    private static final String USERNAME = "root";
    private static final String PASSWORD = "root";

    public static void main(String[] args) throws IOException
    {
        ScpUploader scpUploader = ScpUploader.newInstance();

        try
        {
            scpUploader.connect(HOST, PORT, USERNAME, PASSWORD);
        }
        catch(JSchException e)
        {
            System.err.println("Failed to connect the server!");
            e.printStackTrace();
            return;
        }

        System.out.println("Successfully connected to the server!");

        byte[] fileBytes = Files.readAllBytes(Paths.get("C:/file.zip"));

        try
        {
            scpUploader.uploadFile("/test/files", "file.zip", fileBytes, true); // if overwrite == false, it won't throw exception if the file exists
            System.out.println("Successfully uploaded the file!");
        }
        catch(SftpException e)
        {
            System.err.println("Failed to upload the file!");
            e.printStackTrace();
        }

        scpUploader.disconnect();
    }
}

1

- - फर्नांडो के उत्तर को थोड़ा परिष्कृत करते हुए, यदि आप निर्भरता प्रबंधन के लिए मावेन का उपयोग करते हैं: -

pom.xml :

<dependency>
  <groupId>org.apache.ant</groupId>
  <artifactId>ant-jsch</artifactId>
  <version>${ant-jsch.version}</version>
</dependency>

अपने प्रोजेक्ट में इस निर्भरता को जोड़ें। नवीनतम संस्करण यहां पाया जा सकता है

जावा कोड :

public void scpUpload(String source, String destination) {
    Scp scp = new Scp();
    scp.setPort(port);
    scp.setLocalFile(source);
    scp.setTodir(username + ":" + password + "@" + host + ":" + destination);
    scp.setProject(new Project());
    scp.setTrust(true);
    scp.execute();
}

0

मैंने एक scp सर्वर लिखा है जो दूसरों की तुलना में बहुत आसान है। मैं इसे विकसित करने के लिए Apache MINA परियोजना (Apache SSHD) का उपयोग करता हूं। आप यहां देख सकते हैं: https://github.com/boomz/JSCP इसके अलावा आप /jarनिर्देशिका से जार फ़ाइल डाउनलोड कर सकते हैं । कैसे इस्तेमाल करे? इस पर एक नज़र: https://github.com/boomz/JSCP/blob/master/src/Main.wava


0

मुझे अलग-अलग समाधानों की कोशिश करने के बाद, पुन: फ़ोल्डर की प्रतिलिपि बनाने की आवश्यकता है, अंत में ProcessBuilder + उम्मीद / स्पॉन द्वारा समाप्त करें

scpFile("192.168.1.1", "root","password","/tmp/1","/tmp");

public void scpFile(String host, String username, String password, String src, String dest) throws Exception {

    String[] scpCmd = new String[]{"expect", "-c", String.format("spawn scp -r %s %s@%s:%s\n", src, username, host, dest)  +
            "expect \"?assword:\"\n" +
            String.format("send \"%s\\r\"\n", password) +
            "expect eof"};

    ProcessBuilder pb = new ProcessBuilder(scpCmd);
    System.out.println("Run shell command: " + Arrays.toString(scpCmd));
    Process process = pb.start();
    int errCode = process.waitFor();
    System.out.println("Echo command executed, any errors? " + (errCode == 0 ? "No" : "Yes"));
    System.out.println("Echo Output:\n" + output(process.getInputStream()));
    if(errCode != 0) throw new Exception();
}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.