Session.SynchronizeDirectories Method

SynchronizationResult. See also Capturing results of operations.

Event Session.FileTransferred is raised for every uploaded or downloaded file.

Imports WinSCP
 
Friend Class Example
 
    Public Shared Function Main() As Integer
 
        Try 
            ' Setup session options
            Dim sessionOptions As New SessionOptions
            With sessionOptions
                .Protocol = Protocol.Sftp
                .HostName = "example.com"
                .UserName = "user"
                .Password = "mypassword"
                .SshHostKeyFingerprint = "ssh-rsa 2048 xx:xx:xx:xx:xx:xx:xx:xx..."
            End With
 
            Using session As New Session
                ' Will continuously report progress of synchronization
                AddHandler session.FileTransferred, AddressOf FileTransferred
 
                ' Connect
                session.Open(sessionOptions)
 
                ' Synchronize files
                Dim synchronizationResult As SynchronizationResult
                synchronizationResult =
                    session.SynchronizeDirectories(
                        SynchronizationMode.Remote, "d:\www", "/home/martin/public_html", False)
 
                ' Throw on any error
                synchronizationResult.Check()
            End Using
 
            Return 0
        Catch e As Exception
            Console.WriteLine("Error: {0}", e)
            Return 1
        End Try
 
    End Function
 
    Private Shared Sub FileTransferred(sender As Object, e As TransferEventArgs)
 
        If e.Error Is Nothing Then
            Console.WriteLine("Upload of {0} succeeded", e.FileName)
        Else
            Console.WriteLine("Upload of {0} failed: {1}", e.FileName, e.Error)
        End If
 
        If e.Chmod IsNot Nothing Then
            If e.Chmod.Error Is Nothing Then
                Console.WriteLine(
                    "Permissions of {0} set to {1}", e.Chmod.FileName, e.Chmod.FilePermissions)
            Else
                Console.WriteLine(
                    "Setting permissions of {0} failed: {1}", e.Chmod.FileName, e.Chmod.Error)
            End If
        Else
            Console.WriteLine("Permissions of {0} kept with their defaults", e.Destination)
        End If
 
        If e.Touch IsNot Nothing Then
            If e.Touch.Error Is Nothing Then
                Console.WriteLine(
                    "Timestamp of {0} set to {1}", e.Touch.FileName, e.Touch.LastWriteTime)
            Else
                Console.WriteLine(
                    "Setting timestamp of {0} failed: {1}", e.Touch.FileName, e.Touch.Error)
            End If
        Else
            ' This should never happen during "local to remote" synchronization
            Console.WriteLine(
                "Timestamp of {0} kept with its default (current time)", e.Destination)
        End If
 
    End Sub
 
End Class

Learn more about using WinSCP .NET assembly from PowerShell.

# Load WinSCP .NET assembly
Add-Type -Path "WinSCPnet.dll"
 
# Session.FileTransferred event handler
 
function FileTransferred
{
    param($e)
 
    if ($e.Error -eq $Null)
    {
        Write-Host "Upload of $($e.FileName) succeeded"
    }
    else
    {
        Write-Host "Upload of $($e.FileName) failed: $($e.Error)"
    }
 
    if ($e.Chmod -ne $Null)
    {
        if ($e.Chmod.Error -eq $Null)
        {
            Write-Host "Permissions of $($e.Chmod.FileName) set to $($e.Chmod.FilePermissions)"
        }
        else
        {
            Write-Host "Setting permissions of $($e.Chmod.FileName) failed: $($e.Chmod.Error)"
        }
 
    }
    else
    {
        Write-Host "Permissions of $($e.Destination) kept with their defaults"
    }
 
    if ($e.Touch -ne $Null)
    {
        if ($e.Touch.Error -eq $Null)
        {
            Write-Host "Timestamp of $($e.Touch.FileName) set to $($e.Touch.LastWriteTime)"
        }
        else
        {
            Write-Host "Setting timestamp of $($e.Touch.FileName) failed: $($e.Touch.Error)"
        }
 
    }
    else
    {
        # This should never happen during "local to remote" synchronization
        Write-Host "Timestamp of $($e.Destination) kept with its default (current time)"
    }
}
 
# Main script
 
try
{
    $sessionOptions = New-Object WinSCP.SessionOptions -Property @{
        Protocol = [WinSCP.Protocol]::Sftp
        HostName = "example.com"
        UserName = "user"
        Password = "mypassword"
        SshHostKeyFingerprint = "ssh-rsa 2048 xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx:xx"
    }
 
    $session = New-Object WinSCP.Session
    try
    {
        # Will continuously report progress of synchronization
        $session.add_FileTransferred( { FileTransferred($_) } )
 
        # Connect
        $session.Open($sessionOptions)
 
        # Synchronize files
        $synchronizationResult = $session.SynchronizeDirectories(
            [WinSCP.SynchronizationMode]::Remote, "d:\www", "/home/martin/public_html", $False)
 
        # Throw on any error
        $synchronizationResult.Check()
    }
    finally
    {
        # Disconnect, clean up
        $session.Dispose()
    }
 
    exit 0
}
catch
{
    Write-Host "Error: $($_.Exception.Message)"
    exit 1
}

In this example the JScript script is embedded into WSF file, to allow access to enumeration values.

<job>
<reference object="WinSCP.Session" />
<script language="JScript">
 
// Session.FileTransferred event handler
 
function session_FileTransferred(sender, e)
{
    if (e.Error == null)
    {
        WScript.Echo("Upload of " + e.FileName + " succeeded");
    }
    else
    {
        WScript.Echo("Upload of " + e.FileName + " failed: " + e.Error);
    }
 
    if (e.Chmod != null)
    {
        if (e.Chmod.Error == null)
        {
            WScript.Echo(
                "Permissions of " + e.Chmod.FileName + " set to " + e.Chmod.FilePermissions);
        }
        else
        {
            WScript.Echo(
                "Setting permissions of " + e.Chmod.FileName + " failed: " + e.Chmod.Error);
        }
    }
    else
    {
        WScript.Echo("Permissions of " + e.Destination + " kept with their defaults");
    }
 
    if (e.Touch != null)
    {
        if (e.Touch.Error == null)
        {
            WScript.Echo(
                "Timestamp of " + e.Touch.FileName + " set to " + e.Touch.LastWriteTime);
        }
        else
        {
            WScript.Echo(
                "Setting timestamp of " + e.Touch.FileName + " failed: " + e.Touch.Error);
        }
    }
    else
    {
        // This should never happen during "local to remote" synchronization
        WScript.Echo(
            "Timestamp of " + e.Destination + " kept with its default (current time)");
    }
}
 
// Main script
 
try
{
    // Setup session options
    var sessionOptions = WScript.CreateObject("WinSCP.SessionOptions");
    sessionOptions.Protocol = Protocol_Sftp;
    sessionOptions.HostName = "example.com";
    sessionOptions.UserName = "user";
    sessionOptions.Password = "mypassword";
    sessionOptions.SshHostKeyFingerprint = "ssh-rsa 2048 xx:xx:xx:xx:xx:xx:xx:xx...";
 
    var session = WScript.CreateObject("WinSCP.Session", "session_");
 
    try
    {
        // Connect
        session.Open(sessionOptions);
 
        // Synchronize files
        var synchronizationResult = session.SynchronizeDirectories(
            SynchronizationMode_Remote, "D:\\www", "/home/martin/public_html", false);
 
        // Throw on any error
        synchronizationResult.Check();
    }
    finally
    {
        // Disconnect, clean up
        session.Dispose();
    }
}
catch (e)
{
    WScript.Echo("Error: " + e.message);
    WScript.Quit(1);
}
 
</script>
</job>

• Deleting remote files after successful remote to local synchronization;
• Keep local directory up to date (download changed files from remote SFTP/FTP server).