private string CopyComparisonScript(string refHost, string refEnv)
 {
     string remoteScriptName = string.Empty;
     FtpConnection connection = new FtpConnection(refHost, "mxftp", "mxftp");
     string localFileName = Path.GetTempFileName();
     CommonUtils.WriteFile(localFileName, ComparisonScript);
     try {
         try {
             connection.Open();
             //bgDoServerWork.ReportProgress(5, "Validating Results...");
         } catch (Exception ex) {
             CommonUtils.ShowError(ex.Message, ex);
         }
         connection.Login();
         connection.SetCurrentDirectory(refEnv);
         //Path.GetTempFileName
         remoteScriptName = Path.GetFileName(localFileName);
         connection.PutFile(localFileName);
         connection.RenameFile(remoteScriptName, Path.GetFileNameWithoutExtension(remoteScriptName) + ".sh");
         //connection.SendCommand("chmod 777 " + Path.GetFileNameWithoutExtension(remoteScriptName) + ".sh");
         remoteScriptName = Path.GetFileNameWithoutExtension(remoteScriptName) + ".sh";
     } finally {
         connection.Close();
         connection.Dispose();
     }
     return remoteScriptName;
 }
        private bool IsValidToBeginDiff(string inputEnv, string inputHost, string refEnv, string refHost, string compareScriptLocation, string scriptHost)
        {
            FtpConnection connection;

            #region RefEnvValidation

            connection = new FtpConnection(refHost, "mxftp", "mxftp");
            try {
                try {
                    connection.Open();
                    // bgDoServerWork.ReportProgress(5, "Validating Results...");
                } catch (Exception ex) {
                    CommonUtils.ShowError(ex.Message, ex);
                    return false;
                }
                connection.Login();
                if (!connection.DirectoryExists(refEnv)) {
                    CommonUtils.ShowInformation("The reference environment path is incorrect!",true);
                    return false;
                }
                if (!connection.FileExists(refEnv + "/mxg2000_settings.sh")) {
                    CommonUtils.ShowInformation("The reference environment path is incorrect!", true);
                    return false;
                }
                if (connection.FileExists(refEnv + "/clean.log")) {
                    CommonUtils.ShowInformation("The reference environment is cleaned!", true);
                    return false;
                }
            } finally {
                connection.Close();
                connection.Dispose();
            }

            #endregion

            #region inputEnvValidations

            connection = new FtpConnection(inputHost, "mxftp", "mxftp");
            try {
                try {
                    connection.Open();
                    // bgDoServerWork.ReportProgress(5, "Validating Results...");
                } catch (Exception ex) {
                    CommonUtils.ShowError(ex.Message, ex);
                    return false;
                }
                connection.Login();
                if (!connection.DirectoryExists(inputEnv)) {
                    CommonUtils.ShowInformation("The input environment path is incorrect!",true);
                    return false;
                }
                if (!connection.FileExists(inputEnv + "/mxg2000_settings.sh")) {
                    CommonUtils.ShowInformation("The input environment path is incorrect!", true);
                    return false;
                }
                if (connection.FileExists(inputEnv + "/clean.log")) {
                    CommonUtils.ShowInformation("The input environment is cleaned!", true);
                    return false;
                }
            } finally {
                connection.Close();
                connection.Dispose();
            }

            #endregion

            #region ComparisonHostValidation

            connection = new FtpConnection(scriptHost, "mxftp", "mxftp");
            try {
                try {
                    connection.Open();
                } catch (Exception ex) {
                    CommonUtils.ShowError(ex.Message, ex);
                    return false;
                }
                connection.Login();
                if (!connection.DirectoryExists(compareScriptLocation)) {
                    CommonUtils.ShowInformation("Could not connect to master host!", true);
                    return false;
                }
                if (!connection.FileExists(compareScriptLocation + "/comparison.sh")) {
                    //testing
                }
            } finally {
                connection.Close();
                connection.Dispose();
            }

            #endregion

            return true;
        }
        private void StartComparison(string inputEnv, string inputHost, string refEnv, string refHost, string compareScriptLocation, out DataTable resultsTable)
        {
            resultsTable = new DataTable();
            string scriptHost = "dell014srv";
            bgDoServerWork.ReportProgress(5, "Validating environments...");
            if (LOCAL_TA_USAGE || IsValidToBeginDiff(inputEnv, inputHost, refEnv, refHost, compareScriptLocation, scriptHost)) {
                bgDoServerWork.ReportProgress(5, "Connecting to Hosts...");
                if (bgDoServerWork.CancellationPending) {
                    WorkerWasCancelled = true;
                    return;
                }
                //CopyComparisonScript(refHost, refEnv);
                SshStream ssh = new SshStream(scriptHost, "autoengine", "");
                //Set the end of response matcher character
                string response = string.Empty;
                try {
                    ssh.Prompt = "\\$";
                    //Remove terminal emulation characters
                    ssh.RemoveTerminalEmulationCharacters = true;
                    //Writing to the SSH channel
                    //tmReturn.Start();
                    //Remove terminal emulation characters
                    ssh.RemoveTerminalEmulationCharacters = true;
                    //Writing to the SSH channel
                    ssh.Write("cd " + compareScriptLocation);
                    //Reading from the SSH channel
                    response = ssh.ReadResponse();
                } catch (Exception ex) {
                    CommonUtils.LogError(ex.Message, ex);
                }
                string comparisonFolderName = DateTime.Now.Ticks.ToString();
                string comparisonFileName = comparisonFolderName + "comparison.log";

                if (bgDoServerWork.CancellationPending) {
                    WorkerWasCancelled = true;
                    return;
                }
                try {
                    ssh.Write("mkdir " + comparisonFolderName);
                    response = ssh.ReadResponse();
                    ssh.Write("cp comparison88.sh " + comparisonFolderName);
                    response = ssh.ReadResponse();
                    ssh.Write("cd " + comparisonFolderName);
                    //Reading from the SSH channel
                    response = ssh.ReadResponse();
                    ssh.Write("comparison88.sh " + "/net/" + refHost + refEnv + " /net/" + inputHost + inputEnv + " -A >" + comparisonFileName);
                    bgDoServerWork.ReportProgress(5, "Starting Comparison...");
                    response = ssh.ReadResponse();
                    ssh.Write("d");
                    response = ssh.ReadResponse();
                } catch (Exception ex) {
                    CommonUtils.LogError(ex.Message, ex);
                }
                bgDoServerWork.ReportProgress(5, "Comparison Completed");
                if (bgDoServerWork.CancellationPending) {
                    WorkerWasCancelled = true;
                    return;
                }
                FtpConnection connection = new FtpConnection(scriptHost, "mxftp", "mxftp");
                string localFileName = Path.GetTempFileName();
                try {
                    try {
                        try {
                            connection.Open();
                            bgDoServerWork.ReportProgress(5, "Validating Results...");
                        } catch (Exception ex) {
                            CommonUtils.ShowError(ex.Message, ex);
                        }
                        connection.Login();
                        connection.SetCurrentDirectory(compareScriptLocation + comparisonFolderName);
                        //Path.GetTempFileName
                        connection.GetFile(comparisonFileName, localFileName, false);
                        connection.RemoveFile(comparisonFileName);
                        connection.SetCurrentDirectory(compareScriptLocation);
                        bgDoServerWork.ReportProgress(5, "Building Output...");
                    } finally {
                        connection.Close();
                        connection.Dispose();
                    }
                } catch (Exception ex) {
                    CommonUtils.LogError(ex.Message, ex);
                }
                try {
                    ssh.Write("cd ..");
                    //Reading from the SSH channel
                    response = ssh.ReadResponse();
                    ssh.Write("rm -rf " + comparisonFolderName);
                    //Reading from the SSH channel
                    response = ssh.ReadResponse();
                    ssh.Flush();
                    ssh.Close();
                    ssh.Dispose();
                    if (bgDoServerWork.CancellationPending) {
                        WorkerWasCancelled = true;
                        return;
                    }
                } catch (Exception ex) {
                    CommonUtils.LogError(ex.Message, ex);
                }
                try {
                    string readFile = CommonUtils.ReadFile(localFileName);
                    //      Regex regex = new Regex("-.*-");
                    string[] array = new string[1];
                    //  array[0]= regex.Match(readFile).Value;
                    array[0] = "\n\n";
                    string[] splitFile = readFile.Split(array, StringSplitOptions.RemoveEmptyEntries);
                    int counter = 1;
                    bgDoServerWork.ReportProgress(5, "Displaying Results...");
                    Regex diffRegex = new Regex("diff.*");
                    DataTable results = new DataTable();
                    results.Columns.Add("Number");
                    results.Columns.Add("Operation");
                    results.Columns.Add("FileSize");
                    results.Columns.Add("FileModifyDate");
                    results.Columns.Add("FileType");
                    results.Columns.Add("FileName");
                    List<string> monthAbbreviations = new List<string>() { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
                    };
                    for (int j = 2; j < splitFile.Length; j++) {
                        string[] splitByLines = splitFile[j].Split(new char[] { '\n' }, StringSplitOptions.RemoveEmptyEntries);
                        for (int k = 3; k < splitByLines.Length; k++) {
                            //-rw-rw-r--   1 autoengine murex       1201 Jul 10 16:58 test.txt
                            //-rwxrwxr-x   1 autoengine murex        546 May 10  2008 script.sh*
                            // "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", and "Dec"
                            if (j == 2) {
                                string fileName = splitByLines[k].Replace("/net/" + refHost + refEnv, "").Replace("/net/" + inputHost + inputEnv, "");
                                string[] splitFileName = fileName.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                                if (diffRegex.Matches(fileName).Count == 0) {
                                    DateTime date;
                                    try {
                                        if (splitFileName[7].Contains(":")) {
                                            date = new DateTime(DateTime.Now.Year, monthAbbreviations.IndexOf(splitFileName[5]), Convert.ToInt32(splitFileName[6]), Convert.ToInt32(splitFileName[7].Split(new char[] { ':' })[0]), Convert.ToInt32(splitFileName[7].Split(new char[] { ':' })[1]), 0);
                                        } else {
                                            date = new DateTime(Convert.ToInt32(splitFileName[7]), monthAbbreviations.IndexOf(splitFileName[5]), Convert.ToInt32(splitFileName[6]));
                                        }
                                    } catch (Exception ex) {
                                        CommonUtils.LogError("Could not get Date", ex);
                                        date = DateTime.Now;
                                    }
                                    long fileSize = (Convert.ToInt64(splitFileName[4]) / 1024) == 0 ? 1 : (Convert.ToInt64(splitFileName[4]) / 1024);
                                    results.Rows.Add(new object[] { counter, "Added", fileSize, date.ToString(), GetFileTypeFromExtension(splitFileName[8]), splitFileName[8] });
                                }
                            } else {
                                string fileName = splitByLines[k].Replace("/net/" + refHost + refEnv, "").Replace("/net/" + inputHost + inputEnv, "");
                                string[] splitFileName = fileName.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
                                if (diffRegex.Matches(fileName).Count == 0) {
                                    DateTime date;
                                    try {
                                        if (splitFileName[7].Contains(":")) {
                                            date = new DateTime(DateTime.Now.Year, monthAbbreviations.IndexOf(splitFileName[5]), Convert.ToInt32(splitFileName[6]), Convert.ToInt32(splitFileName[7].Split(new char[] { ':' })[0]), Convert.ToInt32(splitFileName[7].Split(new char[] { ':' })[1]), 0);
                                        } else {
                                            date = new DateTime(Convert.ToInt32(splitFileName[7]), monthAbbreviations.IndexOf(splitFileName[5]), Convert.ToInt32(splitFileName[6]));
                                        }
                                    } catch (Exception ex) {
                                        CommonUtils.LogError("Could not get Date", ex);
                                        date = DateTime.Now;
                                    }
                                    long fileSize = (Convert.ToInt64(splitFileName[4]) / 1024) == 0 ? 1 : (Convert.ToInt64(splitFileName[4]) / 1024);
                                    results.Rows.Add(new object[] { counter, "Modified", fileSize, date.ToString(), GetFileTypeFromExtension(splitFileName[8]), splitFileName[8] });
                                }
                            }
                            counter++;
                        }
                    }
                    SAVED_SEARCH_RESULTS = results.Copy();
                    GOLDEN_ORIGINAL_RESTULS = results.Copy();
                    resultsTable = SAVED_SEARCH_RESULTS;
                } catch (Exception ex) {
                    CommonUtils.LogError(ex.Message, ex);
                }
            } else {
                bgDoServerWork.CancelAsync();
                WorkerWasCancelled = true;
            }
        }
        private string GetVersionFile(string appDirectory, string host, bool forCleanup)
        {
            //generates size.log containing env size

                if (forCleanup) {
                    GenerateSizeFile();

                }
            string readFile = string.Empty;
            FtpConnection connection = new FtpConnection(host,21 ,"mxftp", "mxftp");
            string localFileName = Path.GetTempFileName();
            string localSizeFileName = Path.GetTempFileName();
            try {
                try {
                    try {
                        connection.Open();
                        //bgDoServerWork.ReportProgress(5, "Validating Results...");
                    } catch (Exception ex) {
                        CommonUtils.ShowError(ex.Message, ex);
                    }
                    connection.Login();
                    connection.SetCurrentDirectory(appDirectory );
                    //Path.GetTempFileName
                    if (forCleanup) {
                        connection.GetFile("size.log", localSizeFileName, false);
                        string sizeFileRead = CommonUtils.ReadFile(localSizeFileName);
              						environmentSize = sizeFileRead.Replace("\t.\n","");
                    }
                    connection.SetCurrentDirectory(appDirectory + "/logs");
                    //Path.GetTempFileName
                    connection.GetFile("mxversion.log", localFileName, false);

                } finally {
                    connection.Close();
                    connection.Dispose();
                }
                readFile = CommonUtils.ReadFile(localFileName);

            } catch (Exception ex) {
                //   FrontendUtils.ShowInformation("Could not validate environment version \n["+appDirectory+"]");
                CommonUtils.LogError(ex.Message, ex);
            }
            return readFile;
        }
 void GetSizeAfterCleanup(string fileName)
 {
     string hostName = txtHostForCleanup.Text.Trim();
     string appDirectory = txtInputEnvForCleanup.Text.Trim();
     FtpConnection connection = new FtpConnection(hostName, "mxftp", "mxftp");
     string localSizeFileName = Path.GetTempFileName();
     try {
         try {
             try {
                 connection.Open();
                 //bgDoServerWork.ReportProgress(5, "Validating Results...");
             } catch (Exception ex) {
                 CommonUtils.ShowError(ex.Message, ex);
             }
             connection.Login();
             connection.SetCurrentDirectory(appDirectory );
             connection.GetFile(fileName, localSizeFileName, false);
         } finally {
             connection.Close();
             connection.Dispose();
         }
         string sizeFileRead = CommonUtils.ReadFile(localSizeFileName);
         lblEnvironmentInfo.Text =  lblEnvironmentInfo.Text +"\r\nSize After Cleanup:"+ sizeFileRead.Replace("\t.\n","");
     } catch (Exception ex) {
         CommonUtils.LogError(ex.Message, ex);
     }
 }
        private void GetFilesByFtp(string host, string remoteLocation)
        {
            List<string> remoteFiles = new List<string>();
            string localDownloadDirectory = string.Empty;
            FtpConnection connection = new FtpConnection(host, "mxftp", "mxftp");
            try {

                try {
                    connection.Open();
                } catch (Exception ex) {
                    CommonUtils.ShowError(ex.Message, ex);
                }

                connection.Login();
                connection.SetCurrentDirectory(remoteLocation);
                FtpFileInfo[] ftpFileInfo = connection.GetFiles("*act.rftvp");
                ScriptName = connection.GetCurrentDirectoryInfo().Name;

                localDownloadDirectory = downloadDir + ScriptName;
                //if(Directory.Exists(localDownloadDirectory)){
                //       Directory.Delete(localDownloadDirectory,true);
                //     }
                DirectoryInfo downloadDirectoryInfo = Directory.CreateDirectory(localDownloadDirectory);
                connection.SetLocalDirectory(downloadDirectoryInfo.FullName);
                for (int i = 0; i < ftpFileInfo.Length; i++) {
                    connection.GetFile(ftpFileInfo[i].Name, false);
                }
            } finally {
                connection.SetLocalDirectory(Path.GetTempPath());
                connection.Close();
                connection.Dispose();

            }
            ReplaceFiles(localDownloadDirectory, txtDest.Text);

            //deleting local files
            //Directory.Delete(localDownloadDirectory);
        }
        private void SendFileToServer(string filename)
        {
            List<string> remoteFiles = new List<string>();
            string localDownloadDirectory = string.Empty;
            FtpConnection connection = new FtpConnection("dell014srv", "mxftp", "mxftp");
            try {
                try {
                    connection.Open();
                } catch (Exception ex) {
                    CommonUtils.ShowError(ex.Message, ex);
                }

                connection.Login();
                connection.SetCurrentDirectory("/dell014srv1/automation/automation-Jobs/");
                connection.PutFile(filename, "launchJob.sh");

            } finally {
                connection.SetLocalDirectory(Path.GetTempPath());
                connection.Close();
                connection.Dispose();

            }
        }
 private void DownloadFileList(List<string> fileList, string remoteHost, string remoteLocation, string localLocation)
 {
     FtpConnection connection = new FtpConnection(remoteHost, "mxftp", "mxftp");
     string localFileName = Path.GetTempFileName();
     string currentProcessedFile = string.Empty;
     try {
         try {
             try {
                 connection.Open();
             } catch (Exception ex) {
                 CommonUtils.ShowError(ex.Message, ex);
             }
             connection.Login();
             connection.SetCurrentDirectory(remoteLocation);
             //Path.GetTempFileName
             connection.SetLocalDirectory(localLocation);
             for (int i = 0; i < fileList.Count; i++) {
                 currentProcessedFile = fileList[i];
                 string localDownloadPath = string.Empty;
                 if (fileList[i].StartsWith("/")) {
                     localDownloadPath = Path.GetDirectoryName(localLocation + fileList[i]);
                 } else {
                     localDownloadPath = Path.GetDirectoryName(localLocation + "/" + fileList[i]);
                 }
                 if (!Directory.Exists(localDownloadPath)) {
                     Directory.CreateDirectory(localDownloadPath);
                 }
                 connection.GetFile(fileList[i], false);
             }
         } finally {
             connection.Close();
             connection.Dispose();
         }
     } catch (Exception ex) {
         CommonUtils.ShowError("Stopped @"+currentProcessedFile+"!\n"+ex.Message, ex);
     }
 }