public static void Sync()
{
var optoins = new SessionOptions()
{
Protocol = Protocol.Ftp,
FtpSecure = WinSCP.FtpSecure.ExplicitTls,
HostName = Config.FTP_HOSTNAME,
PortNumber = Config.FTP_PORT,
UserName = Config.FTP_USER,
Password = Config.FTP_PWD,
};
using (var session = new Session())
{
Logger.Debug("About to try to connect to the TRTH server...",typeof(FTPSynchroniser));
session.Open(optoins);
Logger.Debug("Synchronising directories...",typeof(FTPSynchroniser));
var result = session.SynchronizeDirectories(SynchronizationMode.Local, Config.DIR_SYNC_TO, Config.DIR_REMOTE, false);
Logger.Debug(string.Format("FTP Sync Result = {0}", result), typeof (FTPSynchroniser));
foreach (var file in result.Downloads)
Logger.DebugFormat(typeof (FTPSynchroniser), "Downloaded {0}", file);
}
}
void synchroniseAllFiles()
{
Console.WriteLine("Upload files started...");
ServicePointManager.ServerCertificateValidationCallback =
(s, certificate, chain, sslPolicyErrors) => true;
try
{
using (WinSCP.Session session = new WinSCP.Session())
{
session.FileTransferProgress += SessionFileTransferProgress;
// Connect
session.Open(_sessionOptions);
string localDir = _rootPath;
WinSCP.SynchronizationResult result = session.SynchronizeDirectories(WinSCP.SynchronizationMode.Remote, localDir, "Ents/Logs", false);
if (result.IsSuccess)
{
Console.WriteLine("Directories successfully synchronised!");
}
else
{
for (int i = 0; i < result.Failures.Count; i++)
{
Console.WriteLine("Error: {0}", result.Failures[i].Message);
}
}
}
}
catch (Exception excp)
{
Console.WriteLine("Exception: {0}, {1}", excp.Message, excp.StackTrace);
}
}
private void Run()
{
FileTransferredEventHandler onFileTransferred = (sender, args) =>
{
_log.DebugFormat("Transferred {0} to {1}", args.FileName, args.Destination);
if (args.Error != null)
_log.Error("Error while transferring file " + args.FileName, args.Error);
};
ThreadPool.QueueUserWorkItem((state) =>
{
using (_currSession = new Session())
{
try
{
_currSession.FileTransferred += onFileTransferred;
_currSession.Open(Options);
_log.InfoFormat("Session was opened and going to sync directories from {0}...", TransferSource);
var result = _currSession.SynchronizeDirectories(
(SynchronizationMode)Enum.Parse(typeof(SynchronizationMode), Job.SyncMode),
Job.Source,
Job.Destination,
Job.RemoveFiles);
try
{
result.Check(); // it will throw on any error
// only marking as stopped when everything went ok.
// this way it will run again whenever the service restarts or a change happens on this same directory
MarkAsStopped();
_log.InfoFormat("{0} was synced with success", TransferSource);
}
catch (Exception exception)
{
_log.Error("Some errors occured while syncing " + TransferSource, exception);
}
}
catch (SessionLocalException sle)
{
// Probably aborted
_log.Error("Something happened locally while syncing " + TransferSource, sle);
ErrorHappened(sle.GetBaseException().Message);
}
catch (SessionRemoteException sre)
{
// Connection went down or refused
_log.Error("Something happened remotely while syncing " + TransferSource, sre);
ErrorHappened(sre.GetBaseException().Message);
}
catch (SessionException sessionException)
{
_log.Error("Unexpected session exception while syncing " + TransferSource, sessionException);
ErrorHappened(sessionException.GetBaseException().Message);
}
catch (Exception exception)
{
_log.Error("Unexpected exception while syncing " + TransferSource, exception);
ErrorHappened(exception.GetBaseException().Message);
}
_log.InfoFormat("Session for {0} ended", TransferSource);
}
_currSession = null;
});
}
public static void synchro(string typeSynchro)
{
try
{
string repertoireLocal = FSFLauncherCore.cheminARMA3 + @"\@FSF\";
string repertoireDistant="";
fenetrePrincipale.textBox11.Text = "Synchronisation procedure " + typeSynchro + " en cours :" + Environment.NewLine;
fenetrePrincipale.textBox11.Text += "────────────────────────────" + Environment.NewLine;
fenetrePrincipale.textBox11.Text += Environment.NewLine + "IMPORTANT : " + Environment.NewLine + "Pour stopper la synchronisation en cours, il vous faut Arreter le processus WinSCP.exe en faisant appel à la combinaison de touche" + Environment.NewLine + " CTRL + MAJ + ESC (onglet processus)." + Environment.NewLine;
// Setup session options
SessionOptions sessionOptions = new SessionOptions { };
switch (typeSynchro)
{
case "beta":
SessionOptions sessionOptions1 = new SessionOptions
{
Protocol = Protocol.Ftp,
HostName = constCheminFTP,
UserName = constLoginFTP,
Password = constMdpFTP
};
repertoireDistant = "/@FSF/";
sessionOptions = sessionOptions1;
break;
case "officielle":
SessionOptions sessionOptions2 = new SessionOptions
{
Protocol = Protocol.Ftp,
HostName = constCheminFTP,
UserName = constLoginFTP,
Password = constMdpFTP
};
repertoireDistant = "/@FSF_OFFICIELLE/";
sessionOptions = sessionOptions2;
break;
}
using (Session session = new Session())
{
switch (typeSynchro)
{
default:
Directory.CreateDirectory(repertoireLocal + "@TEMPLATE");
Directory.CreateDirectory(repertoireLocal + "@CLIENT");
Directory.CreateDirectory(repertoireLocal + "@TEST");
Directory.CreateDirectory(repertoireLocal + "@UNITS");
Directory.CreateDirectory(repertoireLocal + "@MATERIEL");
Directory.CreateDirectory(repertoireLocal + "@ISLANDS");
Directory.CreateDirectory(repertoireLocal + "@FRAMEWORK");
break;
}
// Will continuously report progress of synchronization
session.FileTransferred += FileTransferred;
session.FileTransferProgress += FileTransferProgress;
// session log
session.DebugLogPath = FSFLauncherCore.cheminARMA3 + @"\userconfig\FSF-LauncherA3\log.txt";
// Connect
session.Open(sessionOptions);
TransferOptions transferOptions = new TransferOptions();
transferOptions.TransferMode = TransferMode.Binary;
SynchronizationResult synchronizationResult;
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "**** SYNCHRO @TEMPLATE ******" + Environment.NewLine);
synchronizationResult =
session.SynchronizeDirectories(
SynchronizationMode.Local,
repertoireLocal + "@TEMPLATE",
repertoireDistant + "@TEMPLATE",
true,
false,
SynchronizationCriteria.Size);
effaceProgressBar();
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "**** SYNCHRO @FRAMEWORK ******" + Environment.NewLine);
synchronizationResult =
session.SynchronizeDirectories(
SynchronizationMode.Local,
repertoireLocal + "@FRAMEWORK",
repertoireDistant + "@FRAMEWORK",
true,
false,
SynchronizationCriteria.Size);
effaceProgressBar();
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "**** SYNCHRO @CLIENT ******" + Environment.NewLine);
synchronizationResult =
session.SynchronizeDirectories(
SynchronizationMode.Local,
repertoireLocal + "@CLIENT",
repertoireDistant + "@CLIENT",
true,
false,
SynchronizationCriteria.Size);
effaceProgressBar();
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "**** SYNCHRO @TEST ******" + Environment.NewLine);
synchronizationResult =
session.SynchronizeDirectories(
SynchronizationMode.Local,
repertoireLocal + "@TEST",
repertoireDistant + "@TEST",
true,
false,
SynchronizationCriteria.Size);
effaceProgressBar();
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "**** SYNCHRO @UNITS ******" + Environment.NewLine);
synchronizationResult =
session.SynchronizeDirectories(
SynchronizationMode.Local,
repertoireLocal + "@UNITS",
repertoireDistant + "@UNITS",
true,
false,
SynchronizationCriteria.Size);
effaceProgressBar();
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "**** SYNCHRO @MATERIEL ******" + Environment.NewLine);
synchronizationResult =
session.SynchronizeDirectories(
SynchronizationMode.Local,
repertoireLocal + "@MATERIEL",
repertoireDistant + "@MATERIEL",
true,
false,
SynchronizationCriteria.Size);
effaceProgressBar();
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "**** SYNCHRO @ISLANDS ******" + Environment.NewLine);
synchronizationResult =
session.SynchronizeDirectories(
SynchronizationMode.Local,
repertoireLocal + "@ISLANDS",
repertoireDistant + "@ISLANDS",
true,
false,
SynchronizationCriteria.Size);
effaceProgressBar();
// Throw on any error
synchronizationResult.Check();
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "->fichier " + repertoireLocal + "Organisation.txt mis a jour." + Environment.NewLine);
downloadnouvelleVersion("Organisation.txt", FSFLauncherCore.constCheminFTP + repertoireDistant, FSFLauncherCore.constLoginFTP, FSFLauncherCore.constMdpFTP, repertoireLocal);
downloadnouvelleVersion("version.xml", FSFLauncherCore.constCheminFTP + repertoireDistant, FSFLauncherCore.constLoginFTP, FSFLauncherCore.constMdpFTP, repertoireLocal);
}
}
catch (Exception z)
{
fenetrePrincipale.textBox11.Text += "Error: " + z;
}
fenetrePrincipale.textBox11.AppendText(Environment.NewLine + "_______________" + Environment.NewLine);
fenetrePrincipale.textBox11.Text += "Fin de la synchro";
Interface.AlerteVersionArma3();
Interface.AlerteVersionSynchro();
}
// End of bExportDataToXML
// Post data via sftp
//
public static Boolean bsFtp(String sFtpSite, String sUserName, String sPassword, String sSshHostKeyFingerprint, String sDatabaseLocation, Boolean bSearchAll = false, Boolean bDebug = false, Boolean bExposeCredentials = false)
{
clsLog clsLog_ = new clsLog(msLogFile, msVersionData);
clsError clsError_ = new clsError();
// String sAuditRootUCase = "";
// String sTRAMSFtpAuditRootDir = "";
// String sTRAMSFtpRootDir = "";
SynchronizationResult synchronizationResult;
try
{
clsLog_.mLog(Constants.gcInfo, "Posting data to sftp site ...");
byte[] data = Convert.FromBase64String(sPassword);
String decodedSitePassword = Encoding.UTF8.GetString(data);
//clsLog_.mLog(Constants.gcInfo, "");
// clsLog_.mLog(Constants.gcInfo, "onelan.bsFtp, sftp (winscp) process starting **************");
if (bDebug) { clsLog_.mLog(Constants.gcInfo, sIndent +"onelan.bsFtp, sftpSite = " + sFtpSite); }
if (bDebug) { clsLog_.mLog(Constants.gcInfo, sIndent + "onelan.bsFtp, sUserName = "******"************ Credentials *****************");
clsLog_.mLog(Constants.gcInfo, sIndent +"onelan.bsFtp, sPassword = "******"onelan.bsFtp, sSshHostKeyFingerprint = " + sSshHostKeyFingerprint);
clsLog_.mLog(Constants.gcInfo, "");
}
if (bDebug) { clsLog_.mLog(Constants.gcInfo, sIndent + "onelan.bsFtp, local root folder = " + sDatabaseLocation); }
// clsLog_.mLog(Constants.gcInfo, "onelan.bsFtp, SearchAll = " + bSearchAll);
// clsLog_.mLog(Constants.gcInfo, "onelan.bsFtp, Debug = " + bDebug);
// Setup session options
SessionOptions sessionOptions = new SessionOptions
{
Protocol = Protocol.Sftp,
HostName = sFtpSite,
UserName = sUserName,
Password = decodedSitePassword,
SshHostKeyFingerprint = sSshHostKeyFingerprint
};
using (Session session = new Session())
{
// Connect
if (bDebug) { clsLog_.mLog(Constants.gcInfo, sIndent + "onelan.bsFtp, connecting ..."); }
session.Open(sessionOptions);
// Upload files
if (bDebug) { clsLog_.mLog(Constants.gcInfo, sIndent + "onelan.bsFtp, uploading ..."); }
// Get list of directories to transfer
// Will continuously report progress of synchronization
// if (bDebug) { session.FileTransferred += FileTransferred; }
if (bDebug) { clsLog_.mLog(Constants.gcInfo, sIndent + "onelan.bsFtp, Processing sql files ..."); }
// Synchronise the xml directory
synchronizationResult = session.SynchronizeDirectories(SynchronizationMode.Remote, sDatabaseLocation + "\\data", "onelan/data", true);
synchronizationResult.Check();
if (bDebug) { clsLog_.mLog(Constants.gcInfo, sIndent + "onelan.bsFtp, Posting images ..."); }
synchronizationResult = session.SynchronizeDirectories(SynchronizationMode.Remote, sDatabaseLocation + "\\images", "onelan/images", false);
synchronizationResult.Check();
// Clean up
session.Dispose();
}
// clsLog_.mLog(Constants.gcInfo, "********** Completed sftp processing **********");
return true;
}
catch (Exception e)
{
clsError_.mLogError("Problem running sftpTransfer", "onelan", "bsFtp", e, msVersionData, msLogFile, false);
return false;
}
finally
{
}
// End of Post data via sftp
//
}
public static void SyncFile()
{
SessionOptions sessionOptions = new SessionOptions
{
Protocol = Protocol.Sftp,
HostName = Param.SqlCeConfig["sshServer"].ToString(),
UserName = Param.SqlCeConfig["sshUsername"].ToString(),
SshPrivateKeyPath = Param.SqlCeConfig["sshKeyPath"].ToString(),
PortNumber = int.Parse(Param.SqlCeConfig["sshPort"].ToString()),
SshHostKeyFingerprint = Param.SqlCeConfig["sshHostKey"].ToString()
};
if (CanConnectInternet())
{
using (Session session = new Session())
{
session.Open(sessionOptions);
RemoteFileInfo fileInfo = session.GetFileInfo(Param.ScpSoftwarePath + "/Updater.exe");
FileInfo fi = new FileInfo("Updater.exe");
if (DateTimeToUnixTimestamp(fi.LastWriteTime) != DateTimeToUnixTimestamp(fileInfo.LastWriteTime))
{
try
{
TransferOptions transferOptions = new TransferOptions();
transferOptions.TransferMode = TransferMode.Automatic;
TransferOperationResult transferResult;
transferResult = session.GetFiles(Param.ScpSoftwarePath + "/Updater.exe", "Updater.exe", false, transferOptions);
transferResult.Check();
foreach (TransferEventArgs transfer in transferResult.Transfers)
{
WriteLog(string.Format("Download of {0} : {1} succeeded", transfer.FileName, transfer.Destination));
}
}
catch (Exception ex)
{
WriteErrorLog(string.Format("SCP Download Error : {0}", ex.Message));
}
}
//session.FileTransferred += FileTransferred;
if (Directory.Exists(Param.ApplicationDataPath + @"\log"))
{
try
{
TransferOptions transferOptions = new TransferOptions();
transferOptions.TransferMode = TransferMode.Automatic;
SynchronizationResult synchronizationResult;
synchronizationResult = session.SynchronizeDirectories(SynchronizationMode.Remote,
Param.ApplicationDataPath + @"\log", Param.ScpLogPath, false, false, SynchronizationCriteria.Time, transferOptions);
synchronizationResult.Check();
}
catch (Exception ex)
{
WriteErrorLog(string.Format("SCP SynchronizeDirectories Error : {0}", ex.Message));
}
}
session.Close();
}
}
}
