C# SparkleGit.StartAndWaitForExit方法代码示例

        public SparkleRepo(string path, SparkleConfig config)
            : base(path, config)
        {
            // TODO: Set git locale to en-US

            SparkleGit git = new SparkleGit (LocalPath, "config core.ignorecase false");
            git.StartAndWaitForExit ();

            // Check if we should use git-bin
            git = new SparkleGit (LocalPath, "config --get filter.bin.clean");
            git.StartAndWaitForExit ();

            this.use_git_bin = (git.ExitCode == 0);

            if (this.use_git_bin) {
                git = new SparkleGit (LocalPath, "config git-bin.sshUrl \"" + RemoteUrl + "\"");
                git.StartAndWaitForExit ();

                git = new SparkleGit (LocalPath, "config git-bin.sshPrivateKeyFile \"" + config.User.PrivateKeyFilePath + "\"");
                git.StartAndWaitForExit ();
            }

            git = new SparkleGit (LocalPath, "config remote.origin.url \"" + RemoteUrl + "\"");
            git.StartAndWaitForExit ();

            string password_file_path = Path.Combine (LocalPath, ".git", "password");

            if (File.Exists (password_file_path))
                this.is_encrypted = true;
        }

        public SparkleRepo(string path, SparkleConfig config)
            : base(path, config)
        {
            // TODO: Set git locale to en-US

            // Check if we should use git-bin
            SparkleGit git = new SparkleGit (LocalPath, "config --get filter.bin.clean");
            git.StartAndWaitForExit ();

            this.use_git_bin = (git.ExitCode == 0);

            git = new SparkleGit (LocalPath, "config remote.origin.url \"" + RemoteUrl + "\"");
            git.StartAndWaitForExit ();

            string rebase_apply_path = new string [] { LocalPath, ".git", "rebase-apply" }.Combine ();

            if (Directory.Exists (rebase_apply_path)) {
                git = new SparkleGit (LocalPath, "rebase --abort");
                git.StartAndWaitForExit ();
            }

            string password_file_path = Path.Combine (LocalPath, ".git", "password");

            if (File.Exists (password_file_path))
                this.is_encrypted = true;
        }

        public SparkleRepo(string path, SparkleConfig config)
            : base(path, config)
        {
            SparkleGit git = new SparkleGit (LocalPath, "config --get filter.bin.clean");
            git.Start ();
            git.WaitForExit ();

            this.use_git_bin = (git.ExitCode == 0);

            string rebase_apply_path = SparkleHelpers.CombineMore (LocalPath, ".git", "rebase-apply");

            if (Directory.Exists (rebase_apply_path)) {
                git = new SparkleGit (LocalPath, "rebase --abort");
                git.StartAndWaitForExit ();
            }
        }

        public SparkleRepo(string path, SparkleConfig config)
            : base(path, config)
        {
            // TODO: Set git locale to en-US

            SparkleGit git = new SparkleGit (LocalPath, "config --get filter.bin.clean");
            git.StartAndWaitForExit ();

            this.use_git_bin = (git.ExitCode == 0);

            git = new SparkleGit (LocalPath, "config remote.origin.url \"" + RemoteUrl + "\"");
            git.StartAndWaitForExit ();

            string rebase_apply_path = new string [] { LocalPath, ".git", "rebase-apply" }.Combine ();

            if (Directory.Exists (rebase_apply_path)) {
                git = new SparkleGit (LocalPath, "rebase --abort");
                git.StartAndWaitForExit ();
            }
        }

        public SparkleRepo(string path, SparkleConfig config)
            : base(path, config)
        {
            SparkleGit git = new SparkleGit (LocalPath, "config core.ignorecase false");
            git.StartAndWaitForExit ();

            // Check if we should use git-bin
            git = new SparkleGit (LocalPath, "config --get filter.bin.clean");
            git.StartAndWaitForExit ();

            this.use_git_bin = (git.ExitCode == 0);

            if (this.use_git_bin)
                ConfigureGitBin ();

            git = new SparkleGit (LocalPath, "config remote.origin.url \"" + RemoteUrl + "\"");
            git.StartAndWaitForExit ();

            string password_file_path = Path.Combine (LocalPath, ".git", "password");

            if (File.Exists (password_file_path))
                this.is_encrypted = true;
        }

        public override void RestoreFile(string path, string revision, string target_file_path)
        {
            if (path == null)
                throw new ArgumentNullException ("path");

            if (revision == null)
                throw new ArgumentNullException ("revision");

            SparkleLogger.LogInfo ("Git", Name + " | Restoring \"" + path + "\" (revision " + revision + ")");

            // git-show doesn't decrypt objects, so we can't use it to retrieve
            // files from the index. This is a suboptimal workaround but it does the job
            if (this.is_encrypted) {
                // Restore the older file...
                SparkleGit git = new SparkleGit (LocalPath, "checkout " + revision + " \"" + path + "\"");
                git.StartAndWaitForExit ();

                string local_file_path = Path.Combine (LocalPath, path);

                // ...move it...
                try {
                    File.Move (local_file_path, target_file_path);

                } catch {
                    SparkleLogger.LogInfo ("Git",
                        Name + " | Could not move \"" + local_file_path + "\" to \"" + target_file_path + "\"");
                }

                // ...and restore the most recent revision
                git = new SparkleGit (LocalPath, "checkout " + CurrentRevision + " \"" + path + "\"");
                git.StartAndWaitForExit ();

            // The correct way
            } else {
                path = path.Replace ("\"", "\\\"");

                SparkleGit git = new SparkleGit (LocalPath, "show " + revision + ":\"" + path + "\"");
                git.Start ();

                FileStream stream = File.OpenWrite (target_file_path);
                git.StandardOutput.BaseStream.CopyTo (stream);
                stream.Close ();

                git.WaitForExit ();
            }

            if (target_file_path.StartsWith (LocalPath))
                new Thread (() => OnFileActivity (null)).Start ();
        }

        private void ConfigureGitBin()
        {
            SparkleGit git = new SparkleGit (LocalPath, "config filter.bin.clean \"git bin clean %f\"");
            git.StartAndWaitForExit ();

            git = new SparkleGit (LocalPath, "config filter.bin.smudge \"git bin smudge\"");
            git.StartAndWaitForExit ();

            git = new SparkleGit (LocalPath, "config git-bin.sftpUrl \"" + RemoteUrl + "\"");
            git.StartAndWaitForExit ();

            git = new SparkleGit (LocalPath, "config git-bin.sftpPrivateKeyFile \"" + base.local_config.User.PrivateKeyFilePath + "\"");
            git.StartAndWaitForExit ();
        }

        // Merges the fetched changes
        private void Rebase()
        {
            if (HasLocalChanges) {
                Add ();

                string commit_message = FormatCommitMessage ();
                Commit (commit_message);
            }

            SparkleGit git = new SparkleGit (LocalPath, "rebase FETCH_HEAD");
            git.StartInfo.RedirectStandardOutput = false;
            git.StartAndWaitForExit ();

            if (git.ExitCode != 0) {
                SparkleLogger.LogInfo ("Git", Name + " | Conflict detected, trying to get out...");

                while (HasLocalChanges) {
                    try {
                        ResolveConflict ();

                    } catch (IOException e) {
                        SparkleLogger.LogInfo ("Git",
                            Name + " | Failed to resolve conflict, trying again... (" + e.Message + ")");
                    }
                }

                SparkleLogger.LogInfo ("Git", Name + " | Conflict resolved");
                OnConflictResolved ();
            }
        }

        // Stages the made changes
        private void Add()
        {
            SparkleGit git = new SparkleGit (LocalPath, "add --all");
            git.StartAndWaitForExit ();

            SparkleLogger.LogInfo ("Git", Name + " | Changes staged");
        }

        public override void RevertFile(string path, string revision)
        {
            if (path == null)
                throw new ArgumentNullException ("path");

            if (revision == null)
                throw new ArgumentNullException ("revision");

            path = path.Replace ("\\", "/");

            SparkleGit git = new SparkleGit (LocalPath, "checkout " + revision + " \"" + path + "\"");
            git.StartAndWaitForExit ();

            if (git.ExitCode == 0)
                SparkleLogger.LogInfo ("Git", Name + " | Checked out \"" + path + "\" (" + revision + ")");
             else
                SparkleLogger.LogInfo ("Git", Name + " | Failed to check out \"" + path + "\" (" + revision + ")");
        }

        private void InstallConfiguration()
        {
            string [] settings = new string [] {
                "core.quotepath false", // Don't quote "unusual" characters in path names
                "core.ignorecase false", // Be case sensitive explicitly to work on Mac
                "core.filemode false", // Ignore permission changes
                "core.autocrlf false", // Don't change file line endings
                "core.precomposeunicode true", // Use the same Unicode form on all filesystems
                "core.safecrlf false",
                "core.excludesfile \"\"",
                "core.packedGitLimit 128m", // Some memory limiting options
                "core.packedGitWindowSize 128m",
                "pack.deltaCacheSize 128m",
                "pack.packSizeLimit 128m",
                "pack.windowMemory 128m",
                "push.default matching"
            };

            foreach (string setting in settings) {
                SparkleGit git_config = new SparkleGit (TargetFolder, "config " + setting);
                git_config.StartAndWaitForExit ();
            }

            if (this.use_git_bin)
                InstallGitBinConfiguration ();
        }

        private void ResolveConflict()
        {
            // This is a list of conflict status codes that Git uses, their
            // meaning, and how SparkleShare should handle them.
            //
            // DD    unmerged, both deleted    -> Do nothing
            // AU    unmerged, added by us     -> Use server's, save ours as a timestamped copy
            // UD    unmerged, deleted by them -> Use ours
            // UA    unmerged, added by them   -> Use server's, save ours as a timestamped copy
            // DU    unmerged, deleted by us   -> Use server's
            // AA    unmerged, both added      -> Use server's, save ours as a timestamped copy
            // UU    unmerged, both modified   -> Use server's, save ours as a timestamped copy
            // ??    unmerged, new files       -> Stage the new files

            SparkleGit git_status = new SparkleGit (LocalPath, "status --porcelain");
            string output         = git_status.StartAndReadStandardOutput ();

            string [] lines = output.Split ("\n".ToCharArray ());
            bool trigger_conflict_event = false;

            foreach (string line in lines) {
                string conflicting_path = line.Substring (3);
                conflicting_path        = EnsureSpecialCharacters (conflicting_path);
                conflicting_path        = conflicting_path.Trim ("\"".ToCharArray ());

                SparkleLogger.LogInfo ("Git", Name + " | Conflict type: " + line);

                // Ignore conflicts in the .sparkleshare file and use the local version
                if (conflicting_path.EndsWith (".sparkleshare") || conflicting_path.EndsWith (".empty")) {
                    SparkleLogger.LogInfo ("Git", Name + " | Ignoring conflict in special file: " + conflicting_path);

                    // Recover local version
                    SparkleGit git_ours = new SparkleGit (LocalPath, "checkout --ours \"" + conflicting_path + "\"");
                    git_ours.StartAndWaitForExit ();

                    File.SetAttributes (Path.Combine (LocalPath, conflicting_path), FileAttributes.Hidden);

                    continue;
                }

                SparkleLogger.LogInfo ("Git", Name + " | Resolving: " + conflicting_path);

                // Both the local and server version have been modified
                if (line.StartsWith ("UU") || line.StartsWith ("AA") ||
                    line.StartsWith ("AU") || line.StartsWith ("UA")) {

                    // Recover local version
                    SparkleGit git_ours = new SparkleGit (LocalPath, "checkout --ours \"" + conflicting_path + "\"");
                    git_ours.StartAndWaitForExit ();

                    // Append a timestamp to local version.
                    // Windows doesn't allow colons in the file name, so
                    // we use "h" between the hours and minutes instead.
                    string timestamp  = DateTime.Now.ToString ("MMM d H\\hmm");
                    string our_path = Path.GetFileNameWithoutExtension (conflicting_path) +
                        " (" + base.local_config.User.Name + ", " + timestamp + ")" + Path.GetExtension (conflicting_path);

                    string abs_conflicting_path = Path.Combine (LocalPath, conflicting_path);
                    string abs_our_path         = Path.Combine (LocalPath, our_path);

                    if (File.Exists (abs_conflicting_path) && !File.Exists (abs_our_path))
                        File.Move (abs_conflicting_path, abs_our_path);

                    // Recover server version
                    SparkleGit git_theirs = new SparkleGit (LocalPath, "checkout --theirs \"" + conflicting_path + "\"");
                    git_theirs.StartAndWaitForExit ();

                    trigger_conflict_event = true;

                // The server version has been modified, but the local version was removed
                } else if (line.StartsWith ("DU")) {

                    // The modified local version is already in the checkout, so it just needs to be added.
                    // We need to specifically mention the file, so we can't reuse the Add () method
                    SparkleGit git_add = new SparkleGit (LocalPath, "add \"" + conflicting_path + "\"");
                    git_add.StartAndWaitForExit ();

                // The local version has been modified, but the server version was removed
                } else if (line.StartsWith ("UD")) {

                    // Recover server version
                    SparkleGit git_theirs = new SparkleGit (LocalPath, "checkout --theirs \"" + conflicting_path + "\"");
                    git_theirs.StartAndWaitForExit ();

                // Server and local versions were removed
                } else if (line.StartsWith ("DD")) {
                    SparkleLogger.LogInfo ("Git", Name + " | No need to resolve: " + line);

                // New local files
                } else if (line.StartsWith ("??")) {
                    SparkleLogger.LogInfo ("Git", Name + " | Found new file, no need to resolve: " + line);

                } else {
                    SparkleLogger.LogInfo ("Git", Name + " | Don't know what to do with: " + line);
                }
            }

            Add ();

            SparkleGit git = new SparkleGit (LocalPath, "commit --message \"Conflict resolution by SparkleShare\"");
//.........这里部分代码省略.........

        // Merges the fetched changes
        private bool Rebase()
        {
            if (HasLocalChanges) {
                Add ();

                string commit_message = FormatCommitMessage ();
                Commit (commit_message);
            }

            // Temporarily change the ignorecase setting to true to avoid
            // conflicts in file names due to case changes
            SparkleGit git = new SparkleGit (LocalPath, "config core.ignorecase true");
            git.StartAndWaitForExit ();

            git = new SparkleGit (LocalPath, "rebase FETCH_HEAD");
            git.StartInfo.RedirectStandardOutput = false;

            string error_output = git.StartAndReadStandardError ();

            if (git.ExitCode != 0) {
                // Stop when we can't rebase due to locked local files
                // error: cannot stat 'filename': Permission denied
                if (error_output.Contains ("error: cannot stat")) {
                    Error = ErrorStatus.LockedFiles;
                    SparkleLogger.LogInfo ("Git", Name + " | Error status changed to " + Error);

                    git = new SparkleGit (LocalPath, "rebase --abort");
                    git.StartAndWaitForExit ();

                    git = new SparkleGit (LocalPath, "config core.ignorecase false");
                    git.StartAndWaitForExit ();

                    return false;

                } else {
                    SparkleLogger.LogInfo ("Git", Name + " | Conflict detected, trying to get out...");
                    string rebase_apply_path = new string [] { LocalPath, ".git", "rebase-apply" }.Combine ();

                    while (Directory.Exists (rebase_apply_path) && HasLocalChanges) {
                        try {
                            ResolveConflict ();

                        } catch (IOException e) {
                            SparkleLogger.LogInfo ("Git", Name + " | Failed to resolve conflict, trying again...", e);
                        }
                    }

                    SparkleLogger.LogInfo ("Git", Name + " | Conflict resolved");
                    OnConflictResolved ();
                }
            }

            git = new SparkleGit (LocalPath, "config core.ignorecase false");
            git.StartAndWaitForExit ();

            return true;
        }

        public override void EnableFetchedRepoCrypto (string password)
        {
            // Set up the encryption filter
            SparkleGit git_config_smudge = new SparkleGit (TargetFolder,
                "config filter.encryption.smudge \"openssl enc -d -aes-256-cbc -base64 -S " + this.crypto_salt +
                " -pass file:.git/info/encryption_password\"");

            SparkleGit git_config_clean = new SparkleGit (TargetFolder,
                "config filter.encryption.clean  \"openssl enc -e -aes-256-cbc -base64 -S " + this.crypto_salt +
                " -pass file:.git/info/encryption_password\"");

            git_config_smudge.StartAndWaitForExit ();
            git_config_clean.StartAndWaitForExit ();

            // Pass all files through the encryption filter
            string git_attributes_file_path = new string [] { TargetFolder, ".git", "info", "attributes" }.Combine ();
            File.WriteAllText (git_attributes_file_path, "\n* filter=encryption");

            // Store the password
            string password_file_path = new string [] { TargetFolder, ".git", "info", "encryption_password" }.Combine ();

            if (this.crypto_password_is_hashed)
                File.WriteAllText (password_file_path, password.SHA256 (this.crypto_salt));
            else
                File.WriteAllText (password_file_path, password);
        }

        // Merges the fetched changes
        private void Rebase()
        {
            if (HasLocalChanges) {
                Add ();

                string commit_message = FormatCommitMessage ();
                Commit (commit_message);
            }

            // Temporarily change the ignorecase setting to true to avoid
            // conflicts in file names due to case changes
            SparkleGit git = new SparkleGit (LocalPath, "config core.ignorecase true");
            git.StartAndWaitForExit ();

            git = new SparkleGit (LocalPath, "rebase FETCH_HEAD");
            git.StartInfo.RedirectStandardOutput = false;

            string error_output = git.StartAndReadStandardError ();

            if (git.ExitCode != 0) {
                SparkleLogger.LogInfo ("Git", Name + " | Conflict detected, trying to get out...");

                // error: cannot stat 'filename': Permission denied
                if (SparkleBackend.Platform != PlatformID.Unix &&
                    error_output.Contains ("error: cannot stat")) {

                    // TODO
                }

                while (HasLocalChanges) {
                    try {
                        ResolveConflict ();

                    } catch (IOException e) {
                        SparkleLogger.LogInfo ("Git", Name + " | Failed to resolve conflict, trying again... (" + e.Message + ")");
                    }
                }

                SparkleLogger.LogInfo ("Git", Name + " | Conflict resolved");
                OnConflictResolved ();
            }

            git = new SparkleGit (LocalPath, "config core.ignorecase false");
            git.StartAndWaitForExit ();
        }