Xbase++

SFTP Upload Large File in Parts

See more SFTP Examples

Demonstrates how to split a large file into N parts and then upload each part separately. This technique can be used to potentially avoid limits a SFTP server might impose on upload file size. Xbase++

LOCAL nSuccess
LOCAL oSftp
LOCAL cHostname
LOCAL nPort
LOCAL cHandle
LOCAL cLocalFilePath
LOCAL oFac
LOCAL nBlockSize
LOCAL nNumBlocks
LOCAL oBd
LOCAL i

nSuccess := 0

//  This example assumes the Chilkat API to have been previously unlocked.
//  See Global Unlock Sample for sample code.

oSftp := CreateObject("Chilkat.SFtp")

//  Set some timeouts, in milliseconds:
oSftp:ConnectTimeoutMs := 5000
oSftp:IdleTimeoutMs := 10000

//  Connect to the SSH server.  
//  The standard SSH port = 22
//  The hostname may be a hostname or IP address.
cHostname := "sftp.example.com"
nPort := 22
nSuccess := oSftp:Connect(cHostname, nPort)
IF (nSuccess != 1)
    ? oSftp:LastErrorText
    oSftp:destroy()
    RETURN
ENDIF

//  Authenticate with the SSH server.  Chilkat SFTP supports
//  both password-based authenication as well as public-key
//  authentication.  This example uses password authenication.
nSuccess := oSftp:AuthenticatePw("myLogin", "myPassword")
IF (nSuccess != 1)
    ? oSftp:LastErrorText
    oSftp:destroy()
    RETURN
ENDIF

//  After authenticating, the SFTP subsystem must be initialized:
nSuccess := oSftp:InitializeSftp()
IF (nSuccess != 1)
    ? oSftp:LastErrorText
    oSftp:destroy()
    RETURN
ENDIF

//  Open a remote file for writing on the SSH server.
//  If the file already exists, it is overwritten.
//  (Specify "createNew" instead of "createTruncate" to
//  prevent overwriting existing files.)
cHandle := oSftp:OpenFile("big.zip", "writeOnly", "createTruncate")
IF (oSftp:LastMethodSuccess != 1)
    ? oSftp:LastErrorText
    oSftp:destroy()
    RETURN
ENDIF

//  We're going to upload the local file "qa_data/zips/big.zip" (a relative local path from our current working directory)
//  to the SFTP server.
cLocalFilePath := "qa_data/zips/big.zip"

//  Rather than uploading in one shot, we'll read the local file in chunks
//  and upload a chunk at a time.
oFac := CreateObject("Chilkat.FileAccess")

nSuccess := oFac:OpenForRead(cLocalFilePath)
IF (nSuccess == 0)
    oSftp:CloseHandle(cHandle)
    ? oFac:LastErrorText
    oSftp:destroy()
    oFac:destroy()
    RETURN
ENDIF

//  If we were to split the local file into 128K chunks, how many chunks (blocks) would
//  we have, including the last partial block?
nBlockSize := 131072
nNumBlocks := oFac:GetNumBlocks(nBlockSize)
? "Number of blocks = " + Str(nNumBlocks)

oBd := CreateObject("Chilkat.BinData")
i := 0
DO WHILE i < nNumBlocks
    //  Read the Nth block, which gets appended to the bd.  (which means
    //  we must clear the contents of bd before the next iteration)
    nSuccess := oFac:ReadBlockBd(i, nBlockSize, oBd)
    IF (nSuccess == 0)
        oSftp:CloseHandle(cHandle)
        ? oFac:LastErrorText
        oSftp:destroy()
        oFac:destroy()
        oBd:destroy()
        RETURN
    ENDIF

    //  Upload this block to the open remote file.
    nSuccess := oSftp:WriteFileBd(cHandle, oBd)
    IF (nSuccess == 0)
        ? oSftp:LastErrorText
        oSftp:destroy()
        oFac:destroy()
        oBd:destroy()
        RETURN
    ENDIF

    //  Clear the contents for the next iteration.
    oBd:Clear()

    i := i + 1
ENDDO

//  Close the local file.
oFac:FileClose()

//  -----------------------------------------------------------------------------
//  This is important.  You must close the handle on the server.
//  Otherwise open handles will accumulate on the server until eventually a limit
//  is reached and the server will fail on a call to OpenFile.
//  -----------------------------------------------------------------------------

//  Close the remote file handle on the server.
nSuccess := oSftp:CloseHandle(cHandle)
IF (nSuccess != 1)
    ? oSftp:LastErrorText
    oSftp:destroy()
    oFac:destroy()
    oBd:destroy()
    RETURN
ENDIF

? "Success."

oSftp:destroy()
oFac:destroy()
oBd:destroy()