PatchUploader/PatchUploader/Program.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace PatchUploader
{
    class Program
    {
        private static void updateVersion(string file)
        {
            if (File.Exists(file))
            {
                string text = File.ReadAllText(file);
                int version = Int32.Parse(text);
                version++;
                text = text.Replace(text, version.ToString());
                File.WriteAllText(file, text);
            }
        }

        private static void createFtpDirectory(string dir)
        {
            try
            {
                var request = (FtpWebRequest)WebRequest.Create(ftp + dir);

                request.Method = WebRequestMethods.Ftp.MakeDirectory;
                request.Credentials = new NetworkCredential(user, pass);
                request.UsePassive = true;
                request.UseBinary = true;
                request.KeepAlive = false;
                request.EnableSsl = true;
                using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
                {
                    if (response.StatusCode != FtpStatusCode.PathnameCreated)
                    {
                        WriteConsoleLine(ConsoleColor.Green, "Dir created: " +  dir);
                    }
                    response.Close();
                }
            }
            catch (Exception ex)
            {
                //Console.WriteLine("createFtpDirectory -> " + ex.Message);
            }
        }

        private static void uploadFileToFtp(string file)
        {
            try
            {
                var request = (FtpWebRequest)WebRequest.Create(ftp + file);

                request.Method = WebRequestMethods.Ftp.UploadFile;
                request.Credentials = new NetworkCredential(user, pass);
                request.UsePassive = true;
                request.UseBinary = true;
                request.KeepAlive = false;
                request.EnableSsl = true;

                using (var fileStream = File.OpenRead(file))
                {
                    using (var requestStream = request.GetRequestStream())
                    {
                        fileStream.CopyTo(requestStream);
                        requestStream.Close();
                    }
                    fileStream.Close();
                }

                var response = (FtpWebResponse)request.GetResponse();
                WriteConsoleLine(ConsoleColor.Green, "Uploaded: " + file);
                response.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("uploadFileToFtp -> " + ex.Message);
            }
        }

        private static void deleteFileFromFtp(string path)
        {
            try
            {
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(ftp + path);
                request.Method = WebRequestMethods.Ftp.DownloadFile;
                request.Credentials = new NetworkCredential(user, pass);
                request.UsePassive = true;
                request.UseBinary = true;
                request.KeepAlive = false;
                request.EnableSsl = true;

                request.Method = WebRequestMethods.Ftp.DeleteFile;
                FtpWebResponse response = (FtpWebResponse)request.GetResponse();
                WriteConsoleLine(ConsoleColor.Red, "Deleted: " + path);
                response.Close();
            } catch (Exception ex)
            {
                Console.WriteLine("deleteFileFromFtp -> " + ex.Message);
            }
        }

        private static void downloadFileFromFtp(string dir, string file)
        {
            try
            {
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(ftp + dir + "/" + file);
                request.Method = WebRequestMethods.Ftp.DownloadFile;
                request.Credentials = new NetworkCredential(user, pass);
                request.UsePassive = true;
                request.UseBinary = true;
                request.KeepAlive = false;
                request.EnableSsl = true;

                FtpWebResponse response = (FtpWebResponse)request.GetResponse();

                Stream responseStream = response.GetResponseStream();
                StreamReader reader = new StreamReader(responseStream);

                using (StreamReader sr = new StreamReader(responseStream))
                {
                    string line;
                    while ((line = sr.ReadLine()) != null)
                    {
                        File.AppendAllText("srv_" + file, line + Environment.NewLine);
                    }
                }

                WriteConsoleLine(ConsoleColor.Green, "Download Complete: " + file);

                reader.Close();
                response.Close();
            } catch (Exception ex)
            {
                // ...
            }
        }

        private static void uploadDirectoryToFtp(string dir)
        {
            try
            {
                DirectoryInfo folderToUpload = new DirectoryInfo(dir);
                createFtpDirectory(dir);
                foreach (FileInfo file in folderToUpload.GetFiles())
                {
                    if (uploadList.Contains(file.Name))
                    {
                        uploadFileToFtp(dir + "/" + file.Name);
                    }
                }

                foreach (DirectoryInfo dirInfo in folderToUpload.GetDirectories())
                {
                    uploadDirectoryToFtp(dir + "/" + dirInfo.Name);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine("uploadDirectoryToFtp -> " + ex.Message);
            }
        }

        private static string getMD5HashFromFile(string fileName)
        {
            FileStream file = new FileStream(fileName, FileMode.Open);
            MD5 md5 = new MD5CryptoServiceProvider();
            byte[] retVal = md5.ComputeHash(file);
            file.Close();

            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < retVal.Length; i++)
            {
                sb.Append(retVal[i].ToString("x2"));
            }
            return sb.ToString();
        }

        private static void deleteFile(string file)
        {
            if (File.Exists(file))
            {
                File.Delete(file);
            }
        }

        private static void compareMD5ofFiles(string dir)
        {
            string filecontent = getFileContent(srv_md5file);
            if (Directory.Exists(dir))
            {
                DirectoryInfo folderToRead = new DirectoryInfo(dir);

                foreach (FileInfo f in folderToRead.GetFiles())
                {
                    if (!filecontent.Contains(getMD5HashFromFile(f.FullName)))
                    {
                        uploadList.Add(f.Name);
                        Console.WriteLine("Added to uploadlist: " + f.Name);
                    }
                }
                foreach (DirectoryInfo dirInfo in folderToRead.GetDirectories())
                {
                    compareMD5ofFiles(dir + "/" + dirInfo.Name);
                }
            }
        }

        private static void createMD5TableFile(string file, string dir)
        {
            if (Directory.Exists(dir))
            {
                DirectoryInfo folderToRead = new DirectoryInfo(dir);
                foreach (FileInfo f in folderToRead.GetFiles())
                {
                    File.AppendAllText(file, dir + "/" + f.Name + "=" + getMD5HashFromFile(f.FullName) + Environment.NewLine);
                }

                foreach (DirectoryInfo dirInfo in folderToRead.GetDirectories())
                {
                    createMD5TableFile(file, dir + "/" + dirInfo.Name);
                }
            }
        }

        private static void checkFilesToDelete()
        {
            String local_md5 = getFileContent(md5file);
            String srv_md5 = getFileContent(srv_md5file);

            String[] s_md5 = srv_md5.Split('\n');
            foreach (string line in s_md5)
            {
                if (!local_md5.Contains(line.Split('=')[0]))
                {
                    deleteList.Add(line.Split('=')[0]);
                    WriteConsoleLine(ConsoleColor.Green, "Added to deleteList: " + line.Split('=')[0]);
                }
            }
        }

        private static void deleteFilesFromFtp()
        {
            for (int i = 0; i < deleteList.Count; i++)
            {
                deleteFileFromFtp(deleteList[i].ToString());
            }
        }

        private static string getFileContent(string file)
        {
            string filecontent = "";
            if (File.Exists(file))
            {
                StreamReader f = new StreamReader(file);
                string line = "";

                while ((line = f.ReadLine()) != null)
                {
                    filecontent += line + "\n";
                }
                f.Close();
            }
            return filecontent;
        }

        private static void WriteConsoleLine(ConsoleColor c, String text)
        {
            Console.ForegroundColor = c;
            Console.WriteLine(text);
            Console.ResetColor();
        }


        // FTP Credentials
        static string ftp = "ftp://domain/path/to/files/";
        static string user = "";
        static string pass = "";

        // Directory to sync
        static string directory = "files";

        // FileNames
        static string versionfile = "version.txt";
        static string md5file = "md5table.txt";
        static string srv_md5file = "srv_" + md5file;

        static ArrayList uploadList = new ArrayList();
        static ArrayList deleteList = new ArrayList();

        static void Main(string[] args)
        {
            if (args.Count() > 0)
            {
                directory = args[0];
            }

            Console.WriteLine("Start synchronizing directory '" + directory + "' ...");

            Console.WriteLine("Updating '" + versionfile + "'...");
            updateVersion(directory + "/" + versionfile);

            Console.WriteLine("Creating local MD5 Table...");
            createMD5TableFile(md5file, directory);

            Console.WriteLine("Downloading MD5 Table from server...");
            downloadFileFromFtp("", md5file);

            Console.WriteLine("Comparing local MD5 Table with the one from server...");
            compareMD5ofFiles(directory);

            Console.WriteLine("Start uploading changed and missing files...");
            uploadDirectoryToFtp(directory);

            Console.WriteLine("Check what to delete from server...");
            checkFilesToDelete();
            deleteFilesFromFtp();

            Console.WriteLine("Replacing current '" + md5file + "' with the one from server...");
            uploadFileToFtp(md5file);

            Console.WriteLine("Cleaning up md5files...");
            deleteFile(srv_md5file);
            deleteFile(md5file);

            Console.WriteLine("Finished synchronizing directory '" + directory + "' !");           

            Console.ReadKey();
        }
    }
}