Samuele Locatelli
513 lines
28 KiB
C#
513 lines
28 KiB
C#
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Configuration;
|
|
using System.Diagnostics;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using static System.Net.Mime.MediaTypeNames;
|
|
|
|
namespace EgwProxy.Ftp.Test
|
|
{
|
|
internal class Program
|
|
{
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// legge conf in formato stringa
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
protected static string ReadSetting(string key)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = $"{ConfigurationManager.AppSettings[key]}" ?? "";
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Console.Write("Eccezione in ReadSettings");
|
|
Console.Write(exc.Message);
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// Helper separatore dash
|
|
/// </summary>
|
|
private const string separator = "------------------------";
|
|
|
|
private static Stopwatch sw = new Stopwatch();
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Private Methods
|
|
|
|
/// <summary>
|
|
/// Programma principale
|
|
/// </summary>
|
|
/// <param name="args"></param>
|
|
private static void Main(string[] args)
|
|
{
|
|
Console.WriteLine(separator);
|
|
Console.WriteLine("Test FTP Client");
|
|
Console.WriteLine(separator);
|
|
Console.WriteLine();
|
|
string exePath = System.Reflection.Assembly.GetExecutingAssembly().Location;
|
|
string BaseDirectory = System.IO.Path.GetDirectoryName(exePath);
|
|
string testFile = Path.Combine(BaseDirectory, ReadSetting("testFile"));
|
|
Manager ftpClient = new Manager("", "", "", "", false);
|
|
if (!string.IsNullOrEmpty(testFile))
|
|
{
|
|
Console.WriteLine(separator);
|
|
Console.WriteLine($"Mode json ({testFile})");
|
|
Console.WriteLine(separator);
|
|
Console.WriteLine();
|
|
if (File.Exists(testFile))
|
|
{
|
|
var rawData = File.ReadAllText(testFile);
|
|
if (!string.IsNullOrEmpty(rawData))
|
|
{
|
|
TestSetup testConf = new TestSetup();
|
|
try
|
|
{
|
|
testConf = JsonConvert.DeserializeObject<TestSetup>(rawData);
|
|
}
|
|
catch
|
|
{ }
|
|
// setup server
|
|
ftpClient = new Manager(testConf.server, testConf.user, testConf.password, testConf.rawCert, testConf.skipCert);
|
|
serverTest(ftpClient);
|
|
|
|
bool doRepeat = true;
|
|
while (doRepeat)
|
|
{
|
|
// eseguo per ogni step
|
|
foreach (var item in testConf.steps)
|
|
{
|
|
Console.WriteLine($"------ Step {item.id} | {item.description} ------");
|
|
string esitoStep = "";
|
|
switch (item.action)
|
|
{
|
|
case stepType.checkDir:
|
|
if (item.paramList != null && item.paramList.Count > 0)
|
|
{
|
|
string dir2check = item.paramList[0];
|
|
var dirCheckExists = ftpClient.DirExists(dir2check);
|
|
esitoStep = dirCheckExists ? $"Directory {dir2check} found!" : $"Directory {dir2check} NOT found!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameter!";
|
|
}
|
|
break;
|
|
|
|
case stepType.checkFile:
|
|
if (item.paramList != null && item.paramList.Count > 0)
|
|
{
|
|
string file2check = item.paramList[0];
|
|
var dirCheckExists = ftpClient.FileExists(file2check);
|
|
esitoStep = dirCheckExists ? $"File {file2check} found!" : $"File {file2check} NOT found!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameter!";
|
|
}
|
|
break;
|
|
|
|
case stepType.createDir:
|
|
if (item.paramList != null && item.paramList.Count > 0)
|
|
{
|
|
string dir2check = item.paramList[0];
|
|
var preTest = ftpClient.DirExists(dir2check);
|
|
if (preTest)
|
|
{
|
|
esitoStep = "Error: Folder already exists!";
|
|
}
|
|
else
|
|
{
|
|
var dirCreate = ftpClient.CreateDir(dir2check);
|
|
esitoStep = dirCreate ? $"Directory {dir2check} created!" : $"Error: {dir2check} NOT created!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameter!";
|
|
}
|
|
break;
|
|
|
|
case stepType.delDir:
|
|
if (item.paramList != null && item.paramList.Count > 0)
|
|
{
|
|
string dir2check = item.paramList[0];
|
|
var preTest = ftpClient.DirExists(dir2check);
|
|
if (preTest)
|
|
{
|
|
var dirDelete = ftpClient.DeleteDir(dir2check);
|
|
esitoStep = dirDelete ? $"Directory {dir2check} deleted!" : $"Error: {dir2check} NOT deleted!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: Folder doesn't exists, delete not possible!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameter!";
|
|
}
|
|
break;
|
|
|
|
case stepType.delFile:
|
|
if (item.paramList != null && item.paramList.Count > 0)
|
|
{
|
|
string file2check = item.paramList[0];
|
|
var preTest = ftpClient.FileExists(file2check);
|
|
if (preTest)
|
|
{
|
|
var dirDelete = ftpClient.DeleteFile(file2check);
|
|
esitoStep = dirDelete ? $"File {file2check} deleted!" : $"Error: {file2check} NOT deleted!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: File doesn't exists, delete not possible!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameter!";
|
|
}
|
|
break;
|
|
|
|
case stepType.downloadDir:
|
|
if (item.paramList != null && item.paramList.Count > 1)
|
|
{
|
|
string dir2check = item.paramList[0];
|
|
string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
|
|
var preTest = ftpClient.DirExists(dir2check);
|
|
if (preTest)
|
|
{
|
|
var dirDelete = ftpClient.GetDir(localDir, dir2check);
|
|
esitoStep = dirDelete ? $"Directory {dir2check} downloaded!" : $"Error: {dir2check} NOT downloaded!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: Folder doesn't exists, download not possible!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameters!";
|
|
}
|
|
break;
|
|
|
|
case stepType.downloadFile:
|
|
if (item.paramList != null && item.paramList.Count > 1)
|
|
{
|
|
string dir2check = item.paramList[0];
|
|
string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
|
|
var preTest = ftpClient.DirExists(dir2check);
|
|
if (preTest)
|
|
{
|
|
var dirDelete = ftpClient.GetDir(localDir, dir2check);
|
|
esitoStep = dirDelete ? $"Directory {dir2check} downloaded!" : $"Error: {dir2check} NOT downloaded!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: Folder doesn't exists, download not possible!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameters!";
|
|
}
|
|
break;
|
|
|
|
case stepType.uploadDir:
|
|
if (item.paramList != null && item.paramList.Count > 1)
|
|
{
|
|
string remoteDir = item.paramList[0];
|
|
string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
|
|
var dirUploaded = ftpClient.SendDir(localDir, remoteDir);
|
|
esitoStep = dirUploaded ? $"Directory {remoteDir} uploaded!" : $"Error: {remoteDir} NOT uploaded!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameters!";
|
|
}
|
|
break;
|
|
|
|
case stepType.uploadFile:
|
|
if (item.paramList != null && item.paramList.Count > 1)
|
|
{
|
|
string remotePath = item.paramList[0];
|
|
string localPath = Path.Combine(BaseDirectory, item.paramList[1]);
|
|
var fileUploaded = ftpClient.SendFile(localPath, remotePath);
|
|
esitoStep = fileUploaded ? $"File {remotePath} uploaded!" : $"Error: {remotePath} NOT uploaded!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameters!";
|
|
}
|
|
break;
|
|
|
|
case stepType.listContent:
|
|
if (item.paramList != null && item.paramList.Count > 0)
|
|
{
|
|
string remoteDir = item.paramList[0];
|
|
var preTest = ftpClient.DirExists(remoteDir);
|
|
if (preTest)
|
|
{
|
|
var listResult = ftpClient.ListDir(remoteDir, false);
|
|
Console.WriteLine($"Content of dir {remoteDir}:");
|
|
foreach (var itemList in listResult)
|
|
{
|
|
Console.WriteLine(itemList);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: Folder doesn't exists, list not possible!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameter!";
|
|
}
|
|
break;
|
|
|
|
case stepType.genRandomDir:
|
|
if (item.paramList != null && item.paramList.Count > 0)
|
|
{
|
|
sw.Restart();
|
|
// crea una struttura ricorsiva di 3 livelli con 20 file
|
|
// con contenuto random ogni livello
|
|
string localDir = Path.Combine(BaseDirectory, item.paramList[0]);
|
|
if (!Directory.Exists(localDir))
|
|
{
|
|
Directory.CreateDirectory(localDir);
|
|
}
|
|
// ora vado a creare 3 livelli di folder
|
|
int numDepth = 3;
|
|
int numFile = 20;
|
|
int numRows = 1000;
|
|
string baseDir = localDir;
|
|
for (int iDir = 0; iDir < numDepth; iDir++)
|
|
{
|
|
DateTime adesso = DateTime.Now;
|
|
string newSub = $"{adesso:HHmmss_fff}";
|
|
// sposto puntamento folder...
|
|
baseDir = Path.Combine(baseDir, newSub);
|
|
if (!Directory.Exists(baseDir))
|
|
{
|
|
Directory.CreateDirectory(baseDir);
|
|
}
|
|
for (int iFile = 0; iFile < numFile; iFile++)
|
|
{
|
|
string filePath = Path.Combine(baseDir, $"File_{iFile:000}.txt");
|
|
using (StreamWriter writer = new StreamWriter(filePath))
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
// compongo un testo di numRow righe da GUID...
|
|
for (int i = 0; i < numRows; i++)
|
|
{
|
|
var newId = Guid.NewGuid();
|
|
sb.AppendLine($"{DateTime.Now:HH:mm:ss.ffffff} | {newId} | {newId}");
|
|
}
|
|
writer.WriteLine(sb.ToString());
|
|
}
|
|
}
|
|
}
|
|
sw.Stop();
|
|
esitoStep = $"Completata generazione test data: {sw.ElapsedMilliseconds:N1} ms";
|
|
}
|
|
break;
|
|
|
|
case stepType.mirrorDirL2R:
|
|
if (item.paramList != null && item.paramList.Count > 1)
|
|
{
|
|
sw.Restart();
|
|
string localDir = Path.Combine(BaseDirectory, item.paramList[0]);
|
|
string remoteDir = item.paramList[1];
|
|
var preTest = ftpClient.DirExists(remoteDir);
|
|
if (!preTest)
|
|
{
|
|
ftpClient.CreateDir(remoteDir);
|
|
}
|
|
|
|
var mirrorDone = ftpClient.SendDir(localDir, remoteDir, FluentFTP.FtpFolderSyncMode.Mirror);
|
|
esitoStep = mirrorDone ? $"Directory {localDir} mirrored L2R!" : $"Error: {remoteDir} NOT mirrored!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameters!";
|
|
}
|
|
sw.Stop();
|
|
esitoStep = $"Completato mirror L2R: {sw.ElapsedMilliseconds:N1} ms";
|
|
break;
|
|
|
|
case stepType.mirrorDirR2L:
|
|
if (item.paramList != null && item.paramList.Count > 1)
|
|
{
|
|
sw.Restart();
|
|
string remoteDir = item.paramList[0];
|
|
string localDir = Path.Combine(BaseDirectory, item.paramList[1]);
|
|
var preTest = ftpClient.DirExists(remoteDir);
|
|
if (preTest)
|
|
{
|
|
var mirrorDone = ftpClient.GetDir(localDir, remoteDir, FluentFTP.FtpFolderSyncMode.Mirror);
|
|
esitoStep = mirrorDone ? $"Directory {remoteDir} mirrored R2L!" : $"Error: {remoteDir} NOT mirrored!";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Dir remota non trovata!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameters!";
|
|
}
|
|
sw.Stop();
|
|
esitoStep = $"Completato mirror R2L: {sw.ElapsedMilliseconds:N1} ms";
|
|
break;
|
|
|
|
case stepType.delFileList:
|
|
if (item.paramList != null && item.paramList.Count > 1)
|
|
{
|
|
sw.Restart();
|
|
string remoteDir = item.paramList[0];
|
|
string fileSearch= item.paramList[1];
|
|
List<FluentFTP.FtpListItem> resList = ftpClient.GetRemoteList(remoteDir, true);
|
|
// cerco solo i file di tipo fileSearch
|
|
List<FluentFTP.FtpListItem> resListFilt = new List<FluentFTP.FtpListItem>();
|
|
foreach (var flItem in resList)
|
|
{
|
|
if(flItem.Type == FluentFTP.FtpObjectType.File && flItem.Name.EndsWith(fileSearch))
|
|
{
|
|
resListFilt.Add(flItem);
|
|
}
|
|
}
|
|
// elimino quelli trovati
|
|
if (resListFilt.Count>0)
|
|
{
|
|
var fList = resListFilt.Select(x => x.FullName).ToList();
|
|
var numDel = ftpClient.DeleteFileList(fList);
|
|
// indico esito eliminazione
|
|
esitoStep = $"Eliminati {numDel}/{resListFilt.Count} file";
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "File non trovati!";
|
|
}
|
|
}
|
|
else
|
|
{
|
|
esitoStep = "Error: missing parameters!";
|
|
}
|
|
sw.Stop();
|
|
esitoStep += $"{Environment.NewLine}Completato GetRemotList : {sw.ElapsedMilliseconds:N1} ms";
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
Console.WriteLine(esitoStep);
|
|
Console.WriteLine($"------ Done Step {item.id} ------");
|
|
Console.WriteLine();
|
|
Console.WriteLine("Press a key to continue...");
|
|
Console.ReadKey();
|
|
}
|
|
Console.WriteLine();
|
|
Console.WriteLine("Do you want to repeat from the beginnning? esc to close");
|
|
ConsoleKeyInfo answ = Console.ReadKey();
|
|
doRepeat = answ.Key != ConsoleKey.Escape;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// test base su server steamware
|
|
else
|
|
{
|
|
Console.WriteLine(separator);
|
|
Console.WriteLine("Mode: base");
|
|
Console.WriteLine(separator);
|
|
Console.WriteLine();
|
|
|
|
string sSkipCert = ReadSetting("skipCert");
|
|
bool skipCert = false;
|
|
bool.TryParse(sSkipCert, out skipCert);
|
|
ftpClient = new Manager(ReadSetting("server"), ReadSetting("userName"), ReadSetting("passwd"), ReadSetting("rawCert"), skipCert);
|
|
serverTest(ftpClient);
|
|
|
|
Console.WriteLine("--- Folder ---");
|
|
var testExists = ftpClient.DirExists($"data/test_folder");
|
|
if (testExists)
|
|
{
|
|
Console.WriteLine("Folder already exists!");
|
|
}
|
|
else
|
|
{
|
|
Console.WriteLine("--- Create folder ---");
|
|
var testCreate = ftpClient.CreateDir($"data/test_folder");
|
|
Console.WriteLine();
|
|
}
|
|
|
|
Console.WriteLine("Contenuto folder remota: ");
|
|
var folderContent = ftpClient.ListDir("data/", true);
|
|
foreach (var item in folderContent)
|
|
{
|
|
Console.WriteLine(item);
|
|
}
|
|
Console.WriteLine();
|
|
Console.WriteLine("Premere un tasto x continuare...");
|
|
Console.ReadKey();
|
|
|
|
Console.WriteLine("--- Upload file ---");
|
|
ftpClient.SendFile("test/FileProva.txt", "data/test_folder/FileProva.txt");
|
|
Console.WriteLine("Contenuto folder remota: ");
|
|
folderContent = ftpClient.ListDir("data/", true);
|
|
foreach (var item in folderContent)
|
|
{
|
|
Console.WriteLine(item);
|
|
}
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("Premere un tasto x continuare...");
|
|
Console.ReadKey();
|
|
|
|
Console.WriteLine("--- Download File ---");
|
|
|
|
ftpClient.GetFile("test/FileProva_02.txt", "data/test_folder/FileProva.txt");
|
|
Console.WriteLine("Contenuto folder remota: ");
|
|
folderContent = ftpClient.ListDir("data/", true);
|
|
foreach (var item in folderContent)
|
|
{
|
|
Console.WriteLine(item);
|
|
}
|
|
|
|
Console.WriteLine();
|
|
Console.WriteLine("Premere un tasto x continuare...");
|
|
Console.ReadKey();
|
|
}
|
|
}
|
|
|
|
private static void serverTest(Manager ftpClient)
|
|
{
|
|
Console.WriteLine(separator);
|
|
var testServer = ftpClient.ServerOk();
|
|
Console.WriteLine($"Test connessione: esito {testServer}");
|
|
var srvType = ftpClient.ServerType();
|
|
Console.WriteLine($"Server: {srvType}");
|
|
Console.WriteLine(separator);
|
|
Console.WriteLine();
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |