# HG changeset patch
# User Brad Greco <brad@bgreco.net>
# Date 1558811666 14400
# Node ID 68d7834dc28ec58dfa51e0cf97b2b5dc1464c88a
# Parent  7626b099aefd8d6e03ca834d74d7917b8c94f198
More comments.

diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Attributes.cs
--- a/ServerMonitor/Attributes.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Attributes.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,10 +1,11 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace ServerMonitorApp
 {
+    /// <summary>
+    /// Attribute for use by check controls to indicate
+    /// the type of check they correspond to.
+    /// </summary>
     internal class CheckTypeAttribute : Attribute
     {
         public Type CheckType { get; private set; }
@@ -12,6 +13,10 @@
         public CheckTypeAttribute(Type checkType) { CheckType = checkType; }
     }
 
+    /// <summary>
+    /// Attribute for use by checks to determine the order
+    /// they appear in the check type selection combo box.
+    /// </summary>
     internal class DisplayWeightAttribute : Attribute
     {
         public int DisplayWeight { get; private set; }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Controls/SizeUnitsComboBox.cs
--- a/ServerMonitor/Controls/SizeUnitsComboBox.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Controls/SizeUnitsComboBox.cs	Sat May 25 15:14:26 2019 -0400
@@ -19,5 +19,6 @@
     }
 
     /// <summary>Size units.</summary>
+    /// <remarks>The integer values must equal the power of 1024 needed to convert from bytes to each unit.</remarks>
     public enum SizeUnits { B = 0, KB = 1, MB = 2, GB = 3 }
 }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Helpers.cs
--- a/ServerMonitor/Helpers.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Helpers.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,49 +1,66 @@
-using Renci.SshNet;
-using Renci.SshNet.Common;
-using ServerMonitorApp.Properties;
+using ServerMonitorApp.Properties;
 using System;
-using System.Collections.Generic;
 using System.ComponentModel;
 using System.Drawing;
 using System.Linq;
 using System.Net.NetworkInformation;
-using System.Text;
 using System.Windows.Forms;
 
 namespace ServerMonitorApp
 {
     static class Helpers
     {
+        /// <summary>Resizes the image on a button to fit inside the button's dimensions.</summary>
+        /// <param name="button">A button containing an image.</param>
         public static void FormatImageButton(Button button)
         {
             button.Image = new Bitmap(button.Image, button.Height - 8, button.Height - 8);
         }
 
+        /// <summary>Recursively collects the messages for an exception and its inner exceptions.</summary>
+        /// <param name="ex">The parent exception.</param>
+        /// <returns>A string containing the messages for the exception and its inner exceptions.</returns>
         public static string GetAllMessages(this Exception ex)
         {
             return "\t" + (ex.InnerException == null ? ex.Message : ex.Message + Environment.NewLine + ex.InnerException.GetAllMessages());
         }
 
+        /// <summary>Gets the value of the DisplayNameAttribute for a type.</summary>
+        /// <param name="type">The type to get the display name of.</param>
+        /// <returns>The type's display name, or the type name if no display name is defined.</returns>
         public static string GetDisplayName(Type type)
         {
             return type?.GetAttribute<DisplayNameAttribute>()?.DisplayName ?? type?.Name ?? "null";
         }
 
+        /// <summary>Checks whether a string is null, an empty string, or only contains white space.</summary>
+        /// <param name="aString">The string to test.</param>
+        /// <returns>True if the string is null, an empty string, or only contains white space. False otherwise.</returns>
         public static bool IsNullOrEmpty(this string aString)
         {
             return aString == null || aString.Trim() == string.Empty;
         }
 
+        /// <summary>Converts all newlines in a string to unix format.</summary>
+        /// <param name="aString">The string to convert.</param>
+        /// <returns>The string with all newlines converted to unix format.</returns>
         public static string ConvertNewlines(this string aString)
         {
             return aString.Replace("\r\n", "\n").Replace('\r', '\n');
         }
 
+        /// <summary>Gets an attribute on a class.</summary>
+        /// <typeparam name="T">The type of the attribute to return.</typeparam>
+        /// <param name="type">The type of the class the attribute is on.</param>
+        /// <returns>The attribute, or null if the attribute does not exist on the class.</returns>
         public static T GetAttribute<T>(this Type type) where T : Attribute
         {
             return type.GetCustomAttributes(typeof(T), false).SingleOrDefault() as T;
         }
 
+        /// <summary>Gets an image associated with a check status for use in the UI.</summary>
+        /// <param name="checkStatus">The check status.</param>
+        /// <returns>The image associated with the check status.</returns>
         public static Image GetImage(this CheckStatus checkStatus)
         {
             switch (checkStatus)
@@ -58,6 +75,9 @@
             }
         }
 
+        /// <summary>Gets a program icon associated with a check status.</summary>
+        /// <param name="checkStatus">The check status.</param>
+        /// <returns>The program icon associated with the check status.</returns>
         public static Icon GetIcon(this CheckStatus checkStatus)
         {
             switch (checkStatus)
@@ -69,6 +89,10 @@
             }
         }
 
+        /// <summary>Returns whether an enum is in a list of values.</summary>
+        /// <param name="value">The value to check.</param>
+        /// <param name="values">The list of possible values.</param>
+        /// <returns>True if the value was in the list, false otherwise.</returns>
         public static bool In(this Enum value, params Enum[] values) {
             return values.Contains(value);
         }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/CheckResult.cs
--- a/ServerMonitor/Objects/CheckResult.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/CheckResult.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,41 +1,56 @@
 using ServerMonitorApp.Properties;
 using System;
-using System.Drawing;
 
 namespace ServerMonitorApp
 {
+    /// <summary>
+    /// The result of an executed check.
+    /// Contains data about the check's last execution including status, time, and log message.
+    /// </summary>
     public class CheckResult
     {
-        public const string dateFormat = "yyyy-MM-dd HH:mm:ss.fff";
+        // The date format to use in log files.
+        private const string dateFormat = "yyyy-MM-dd HH:mm:ss.fff";
 
+        /// <summary>The originating check of this check result.</summary>
         public Check Check { get; private set; }
 
+        /// <summary>The result status of the check execution.</summary>
         public CheckStatus CheckStatus { get; private set; }
 
+        /// <summary>The message generated by the check execution.</summary>
         public string Message { get; set; }
 
+        /// <summary>The time the check execution began.</summary>
         public DateTime StartTime { get; set; }
 
+        /// <summary>The time the check execution ended.</summary>
         public DateTime EndTime { get; set; }
 
+        /// <summary>Whether the check execution resulted in success or failure.</summary>
         public bool Failed => CheckStatus.In(CheckStatus.Error, CheckStatus.Warning, CheckStatus.Information);
 
+        /// <summary>Action to perform when the check fails.</summary>
         public FailAction FailAction
         {
             get
             {
+                // Use the global preferences for each status to determine the action to take.
                 switch (CheckStatus)
                 {
                     case CheckStatus.Error: return Settings.Default.ErrorAction;
                     case CheckStatus.Warning: return Settings.Default.WarningAction;
                     case CheckStatus.Information: return Settings.Default.InformationAction;
+                    // On success (or any other status), do nothing.
                     default: return FailAction.None;
                 }
             }
         }
 
-        public bool FlashTaskbar => FailAction == FailAction.FlashTaskbar;
-
+        /// <summary>CheckResult constructor.</summary>
+        /// <param name="check">The originating check of this check result.</param>
+        /// <param name="status">The result status of the check execution.</param>
+        /// <param name="message">The message generated by the check execution.</param>
         public CheckResult(Check check, CheckStatus status, string message)
         {
             Check = check;
@@ -43,22 +58,42 @@
             Message = message;
         }
 
+        /// <summary>Generates a string representation of the check result that can be logged.</summary>
+        /// <returns>A string representation of the check result that can be logged.</returns>
+        /// <remarks>
+        /// The log string is in the format:
+        /// [Check ID] [Start time] [End time] [Check status] [Check output]
+        /// 
+        /// The check ID is left-padded with zeros to simplify log parsing and filtering by check ID.
+        /// Dates are formatted according to the dateFormat defined in this class.
+        /// Newlines in check output are escaped so the log string contains no literal newline characters.
+        /// </remarks>
         public string ToLogString()
         {
             return string.Format("{0:00000} {1} {2} {3} {4}",
                 Check.Id,
-                StartTime.ToString(dateFormat).Replace("T", " "),
-                EndTime.ToString(dateFormat).Replace("T", " "),
+                StartTime.ToString(dateFormat),
+                EndTime.ToString(dateFormat),
                 CheckStatus,
                 Message.ConvertNewlines().Replace("\n", "\\n"));
         }
 
+        /// <summary>Parses a log string to create a check result object.</summary>
+        /// <param name="check">The originating check for the check result.</param>
+        /// <param name="logString">The log string to parse.</param>
+        /// <returns>A check result object.</returns>
         public static CheckResult FromLogString(Check check, string logString)
         {
+            // The check ID, start time, and end time are fixed in length, so no pattern matching is needed.
             DateTime startTime = DateTime.Parse(logString.Substring(6, 23));
             DateTime endTime = DateTime.Parse(logString.Substring(30, 23));
+            // The check status is not fixed in length, but will not contain any spaces.
+            // So, the first space following the beginning of the checks status will
+            // mark the start of the result message.
             int messageStartPos = logString.IndexOf(' ', 54);
+            // Now we know the length of the status token, so we can extract and parse it.
             Enum.TryParse(logString.Substring(54, messageStartPos - 54), out CheckStatus status);
+            // Put it all together.
             return new CheckResult(check, status, logString.Substring(messageStartPos + 1)) { StartTime = startTime, EndTime = endTime };
         }
     }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Checks/DiskSpaceCheck.cs
--- a/ServerMonitor/Objects/Checks/DiskSpaceCheck.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Checks/DiskSpaceCheck.cs	Sat May 25 15:14:26 2019 -0400
@@ -2,47 +2,63 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Checks the available disk space on a remote server.</summary>
     [DisplayName("Disk space check"), Description("Check the remaining free disk space"), DisplayWeight(11)]
     public class DiskSpaceCheck : SshCheck
     {
+        /// <summary>The command to execute. Must return the POSIX output format of df(1).</summary>
         public override string Command => string.Format(DiskSpaceCommand, Device);
 
+        /// <summary>The command to execute, with a placeholder of {0} for the device to check.</summary>
         protected string DiskSpaceCommand => "df -P -k {0}";
 
+        /// <summary>The device or file on the device to check.</summary>
         public string Device { get; set; }
 
+        /// <summary>The minimum free space allowed for the check to pass.</summary>
         public double MinFreeSpace { get; set; }
 
+        /// <summary>The storage units or percentage for MinFreeSpace.</summary>
         public FreeSpaceUnits FreeSpaceUnits { get; set; }
 
         public DiskSpaceCheck()
         {
+            // Set general SSH check settings for disk space checks.
             CheckExitCode = true;
             ExitCode = 0;
         }
 
+        /// <summary>Processes the output of the disk space check command.</summary>
         protected override List<CheckResult> ProcessCommandResult(string output, int exitCode)
         {
+            // Check for general SSH failures.
             List<CheckResult> results = base.ProcessCommandResult(output, exitCode);
+            // If there was an error running the command, fail immediately.
             if (results.Any(r => r.Failed))
                 return results;
 
+            /* Parse the command results, expected in the POSIX output format of df(1):
+               Filesystem 1024-blocks Used Available Capacity Mounted on
+               <file system name> <total space> <space used> <space free> <percentage used> <file system root>
+            */
+            // Split the output into lines and remove the header row.
             List<string> lines = output.Split('\n').ToList();
             lines.RemoveAt(0);
+            // Make sure there is only a single line of output remaining.
             if (lines.Count > 1)
             {
                 results.Add(Fail("df output was more than one line: " + string.Join("\n", lines)));
             }
             else
             {
+                // Split the string into tokens on whitespace.
                 string[] tokens = lines[0].Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
                 if (FreeSpaceUnits == FreeSpaceUnits.percent)
                 {
+                    // Test on percentage: calculate the capacity free percent from the capacity used percent reported.
                     if (int.TryParse(tokens[4].Replace("%", ""), out int percent))
                     {
                         percent = 100 - percent;
@@ -59,9 +75,12 @@
                 }
                 else
                 {
+                    // Test on bytes: calculate the remaining available space from the reported available space.
                     if (int.TryParse(tokens[3], out int freeSpace))
                     {
+                        // Available space is returned in KB. Convert to MB (our default unit).
                         freeSpace /= 1024;
+                        // If the unit is GB, convert MB to GB.
                         if (FreeSpaceUnits == FreeSpaceUnits.GB)
                             freeSpace /= 1024;
                         string message = string.Format("Free disk space is {0} {1}", freeSpace, FreeSpaceUnits);
@@ -79,6 +98,7 @@
             return results;
         }
 
+        /// <summary>Validates disk space check options.</summary>
         public override string Validate(bool saving = true)
         {
             string message = base.Validate();
@@ -92,5 +112,14 @@
         }
     }
 
-    public enum FreeSpaceUnits { MB = 0, GB = 1, percent = 2 }
+    /// <summary>The units to use when testing available disk space.</summary>
+    public enum FreeSpaceUnits
+    {
+        /// <summary>Tests available disk space in megabytes.</summary>
+        MB = 0,
+        /// <summary>Tests available disk space in gigabytes.</summary>
+        GB = 1,
+        /// <summary>Tests available disk space as a percentage of the total space.</summary>
+        percent = 2
+    }
 }
\ No newline at end of file
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Checks/FileCheck.cs
--- a/ServerMonitor/Objects/Checks/FileCheck.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Checks/FileCheck.cs	Sat May 25 15:14:26 2019 -0400
@@ -2,74 +2,96 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Linq;
-using System.Text;
 using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using System.Xml.Serialization;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Checks file metadata on a remote server.</summary>
     [DisplayName("File check"), Description("Check file size or modified time"), DisplayWeight(12)]
     public class FileCheck : SshCheck
     {
+        /// <summary>The command to execute. Must return the output format of GNU ls(1) with the long-iso time style.</summary>
+        /// <remarks>Would be better to not rely on the output of ls.</remarks>
         public override string Command => string.Format(FileCommand, Regex.Replace(File, "^~", "$HOME"));
 
+        /// <summary>The command to execute, with a placeholder of {0} for the file to check.</summary>
         protected string FileCommand
         {
             get
             {
-                int timeZoneOffset = TimeZoneInfo.Local.GetUtcOffset(DateTime.Now).Hours * -1; // Invert because POSIX says so.
+                // Invert because POSIX says so.
+                int timeZoneOffset = TimeZoneInfo.Local.GetUtcOffset(DateTime.Now).Hours * -1;
+                // Set the date format to long-iso since it's easy to parse.
+                // Set the time zone to the match the client time zone so comparisons are reliable.
                 return "export TIME_STYLE=long-iso; export TZ=UTC" + timeZoneOffset + "; ls -l \"{0}\"";
             }
         }
 
+        /// <summary>The path of the file to check.</summary>
         public string File { get; set; }
 
+        /// <summary>Whether the file size will be checked.</summary>
         public bool CheckFileSize { get; set; }
 
+        /// <summary>Whether the file is expected to be less than or greater than a certain size.</summary>
         public bool FileSizeLessThan { get; set; }
 
+        /// <summary>The size to compare the file against in bytes.</summary>
         public int FileSize { get; set; }
 
+        /// <summary>The size to compare the file against in the selected size units.</summary>
         public double FileSizeInSelectedUnits
         {
             get => Math.Round(ConvertBytesToSelectedUnits(FileSize), 1);
             set => FileSize = ConvertSelectedUnitsToBytes(value);
         }
 
+        /// <summary>The units of the file size.</summary>
         public SizeUnits FileSizeUnits { get; set; }
 
+        /// <summary>Whether the file modified time will be checked.</summary>
         public bool CheckDateModified { get; set; }
 
+        /// <summary>Whether the file is expected to be older than or newer than a certain date.</summary>
         public bool DateModifiedOlderThan { get; set; }
 
+        /// <summary>The number of time units to compare then file modified time against.</summary>
         public double DateModified { get; set; }
 
+        /// <summary>The units of the file date modified.</summary>
         public TimeUnits DateModifiedUnits { get; set; }
 
         public FileCheck()
         {
+            // Set general SSH check settings for file checks.
             CheckExitCode = true;
             ExitCode = 0;
         }
 
+        /// <summary>Processes the output of the file check command.</summary>
         protected override List<CheckResult> ProcessCommandResult(string output, int exitCode)
         {
+            // Check for general SSH failures.
             List<CheckResult> results = base.ProcessCommandResult(output, exitCode);
+            // If there was an error running the command, fail immediately.
             if (results.Any(r => r.Failed))
                 return results;
 
+            // Make sure there is only a single line of output.
             if (output.Split('\n').Length > 1)
             {
                 results.Add(Fail("ls output was more than one line: " + output));
             }
             else
             {
+                // Split the string into tokens on whitespace.
                 string[] tokens = output.Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
                 if (CheckFileSize)
                 {
+                    // Check file size.
                     if (int.TryParse(tokens[4], out int bytes))
                     {
+                        // Prepare a human-readable message with the comparison results.
                         string message = string.Format("File size is {0} {1}", Math.Round(ConvertBytesToSelectedUnits(bytes), 1), FileSizeUnits);
                         if ((bytes < FileSize && FileSizeLessThan) || (bytes > FileSize && !FileSizeLessThan))
                             results.Add(Pass(message));
@@ -83,10 +105,13 @@
                 }
                 if (CheckDateModified)
                 {
+                    // Check date modified.
+                    // Tokens[5] contains the date, tokens[6] contains the time.
                     string dateString = tokens[5] + " " + tokens[6];
                     if (DateTime.TryParse(dateString, out DateTime modified))
                     {
                         string message = string.Format("Last modified date is {0}", modified);
+                        // Determine how old the file is. The command output is in the client time zone.
                         TimeSpan age = DateTime.Now.Subtract(modified);
                         double ageCompare = DateModifiedUnits == TimeUnits.Minute ? age.TotalMinutes :
                                          DateModifiedUnits == TimeUnits.Hour ? age.TotalHours :
@@ -105,6 +130,7 @@
             return results;
         }
 
+        /// <summary>Validates file check options.</summary>
         public override string Validate(bool saving = true)
         {
             string message = base.Validate();
@@ -119,11 +145,17 @@
             return message;
         }
 
+        /// <summary>Converts bytes to a different size unit.</summary>
+        /// <param name="sizeInBytes">The size to convert in bytes.</param>
+        /// <returns>The size in the units used by this file check.</returns>
         private double ConvertBytesToSelectedUnits(int sizeInBytes)
         {
             return sizeInBytes / Math.Pow(1024, (double)FileSizeUnits);
         }
 
+        /// <summary>Converts a size in a different unit to bytes.</summary>
+        /// <param name="sizeInSelectedUnits">The size to convert in the units used by this file check.</param>
+        /// <returns>The size in bytes.</returns>
         private int ConvertSelectedUnitsToBytes(double sizeInSelectedUnits)
         {
             return (int)(sizeInSelectedUnits * Math.Pow(1024, (int)FileSizeUnits));
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Checks/HttpCheck.cs
--- a/ServerMonitor/Objects/Checks/HttpCheck.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Checks/HttpCheck.cs	Sat May 25 15:14:26 2019 -0400
@@ -35,6 +35,32 @@
         protected override Task<CheckResult> ExecuteCheckAsync(CancellationToken token)
         {
             throw new NotImplementedException();
+
+
+
+
+            // Cancellable version that doesn't actulaly work
+            // might be useful as a TaskCompletionSource example though
+            //
+            //TaskCompletionSource<CheckResult> tcs = new TaskCompletionSource<CheckResult
+            //
+            //using (Ping ping = new Ping())
+            //{
+            //    token.Register(ping.SendAsyncCancel);
+            //    ping.PingCompleted += (sender, e) =>
+            //    {
+            //        if (e.Error != null)
+            //            tcs.SetResult(Fail("Ping failed: " + e.Error.GetBaseException().Message));
+            //        else if (e.Reply.Status != IPStatus.Success)
+            //            tcs.SetResult(Fail("Ping failed: " + e.Reply.Status.ToString()));
+            //        else
+            //            tcs.SetResult(Pass("Ping completed in " + e.Reply.RoundtripTime + "ms"));
+            //    };
+            //    ping.SendAsync(Server.Host, Timeout, null);
+            //}
+
+            //return tcs.Task;
+
         }
 
         public override string Validate(bool saving = true)
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Checks/PingCheck.cs
--- a/ServerMonitor/Objects/Checks/PingCheck.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Checks/PingCheck.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,17 +1,15 @@
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Linq;
+using System.ComponentModel;
 using System.Net.NetworkInformation;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Checks that a server responds to ping.</summary>
     [DisplayName("Ping check"), Description("Check if the server responds to a ping request"), DisplayWeight(0)]
     public class PingCheck : Check
     {
+        /// <summary>Sends a ping and waits for a response.</summary>
         protected async override Task<CheckResult> ExecuteCheckAsync(CancellationToken token)
         {
             using (Ping ping = new Ping())
@@ -29,28 +27,6 @@
                     return Fail(e);
                 }
             }
-
-            // Cancellable version that doesn't actulaly work
-            // might be useful as a TaskCompletionSource example though
-            //
-            //TaskCompletionSource<CheckResult> tcs = new TaskCompletionSource<CheckResult
-            //
-            //using (Ping ping = new Ping())
-            //{
-            //    token.Register(ping.SendAsyncCancel);
-            //    ping.PingCompleted += (sender, e) =>
-            //    {
-            //        if (e.Error != null)
-            //            tcs.SetResult(Fail("Ping failed: " + e.Error.GetBaseException().Message));
-            //        else if (e.Reply.Status != IPStatus.Success)
-            //            tcs.SetResult(Fail("Ping failed: " + e.Reply.Status.ToString()));
-            //        else
-            //            tcs.SetResult(Pass("Ping completed in " + e.Reply.RoundtripTime + "ms"));
-            //    };
-            //    ping.SendAsync(Server.Host, Timeout, null);
-            //}
-
-            //return tcs.Task;
         }
     }
 }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Checks/SshCheck.cs
--- a/ServerMonitor/Objects/Checks/SshCheck.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Checks/SshCheck.cs	Sat May 25 15:14:26 2019 -0400
@@ -2,57 +2,70 @@
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
-using System.Linq;
-using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Executes an SSH command and checks the output or exit code.</summary>
     [DisplayName("SSH check"), Description("Check the result of a command run over SSH"), DisplayWeight(10)]
     public class SshCheck : Check
     {
+        /// <summary>The command to execute on the server.</summary>
         public virtual string Command { get; set; }
 
+        /// <summary>Whether the exit code of the command should be checked.</summary>
         public bool CheckExitCode { get; set; }
 
+        /// <summary>The required exit code of the command if CheckExitCode is true.</summary>
         public int ExitCode { get; set; }
 
+        /// <summary>Whether the text output of the command should be checked.</summary>
         public bool CheckCommandOutput { get; set; }
 
+        /// <summary>The method to use when checking the command output against the pattern.</summary>
         public MatchType CommandOutputMatchType { get; set; }
 
+        /// <summary>The string or pattern that the command output must match if CommandOutputMatchType is true.</summary>
         public string CommandOutputPattern { get; set; }
 
+        /// <summary>Whether the CommandOutputPattern should be interpreted as a regular expression.</summary>
         public bool CommandOutputUseRegex { get; set; }
 
+        /// <summary>Executes the SSH command on the server.</summary>
         protected override Task<CheckResult> ExecuteCheckAsync(CancellationToken token)
         {
-            try
-            {
-                if (!Server.SshClient.IsConnected)
-                {
-                    if (Server.LoginType == LoginType.PrivateKey && Server.PrivateKeyFile == null)
-                        return Task.FromResult(Fail(string.Format("Private key '{0}' is locked or not accessible", Server.KeyFile)));
-                    Server.SshClient.Connect();
-                }
-            }
-            catch (Exception e)
-            {
-                return Task.FromResult(Fail(e));
-            }
             return Task.Run(() =>
             {
                 try
                 {
+                    // Exit now if the user cancelled the execution.
                     token.ThrowIfCancellationRequested();
+
+                    // Connect to the server if needed.
+                    if (!Server.SshClient.IsConnected)
+                    {
+                        // If the server private key file has not been opened, it is probably encrypted.
+                        // Report failure until the user enters the password.
+                        if (Server.LoginType == LoginType.PrivateKey && Server.PrivateKeyFile == null)
+                            return Fail(string.Format("Private key '{0}' is locked or not accessible", Server.KeyFile));
+                        Server.SshClient.Connect();
+                    }
+
+                    // Exit now if the user cancelled the execution.
+                    token.ThrowIfCancellationRequested();
+
                     using (SshCommand command = Server.SshClient.CreateCommand(Command))
                     {
+                        // Execute the command.
                         token.Register(command.CancelAsync);
                         IAsyncResult ar = command.BeginExecute();
                         token.ThrowIfCancellationRequested();
+                        // Store both the command output and the error streams so they can
+                        // be logged and checked.
                         string output = (command.EndExecute(ar).Trim() + command.Error.Trim()).ConvertNewlines();
+                        // Process the results (exit code and command output) and merge them into a single result.
                         return MergeResults(ProcessCommandResult(output, command.ExitStatus).ToArray());
                     }
                 }
@@ -63,11 +76,17 @@
             }, token);
         }
 
+        /// <summary>Processes the command results and checks they match the expected values.</summary>
+        /// <param name="output">The command output.</param>
+        /// <param name="exitCode">The command exit code.</param>
+        /// <returns>A list of check results according to user preferences.</returns>
         protected virtual List<CheckResult> ProcessCommandResult(string output, int exitCode)
         {
             List<CheckResult> results = new List<CheckResult>();
+            // Check the actual output against the expected output if command output checking is enabled.
             if (CheckCommandOutput)
                 results.Add(GetStringResult(CommandOutputMatchType, CommandOutputPattern, CommandOutputUseRegex, output, "Command output"));
+            // Check the actual exit code against the expected exit code if exit code checking is enabled.
             if (CheckExitCode)
             {
                 CheckResult result = GetIntResult(ExitCode, exitCode, "Exit code");
@@ -78,6 +97,7 @@
             return results;
         }
 
+        /// <summary>Validates SSH check options.</summary>
         public override string Validate(bool saving = true)
         {
             string message = base.Validate();
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Logger.cs
--- a/ServerMonitor/Objects/Logger.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Logger.cs	Sat May 25 15:14:26 2019 -0400
@@ -3,26 +3,32 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Manages reading and writing check results to a log file.</summary>
     public class Logger
     {
         private const int logVersion = 1;
         private readonly string logFile;
         
+        /// <summary>Logger constructor.</summary>
+        /// <param name="file">The path of the log file to use.</param>
         public Logger(string file)
         {
             logFile = file;
         }
 
+        /// <summary>Appends a string to the log file, creating the log file if it does not exist.</summary>
+        /// <param name="logString">The string to log.</param>
         public async void Log(string logString)
         {
+            // Create the file if it does not exist.
+            // Write the current version at the beginning in case we ever change the format.
             if (!File.Exists(logFile))
                 logString = "Server Monitor log version " + logVersion + Environment.NewLine + logString;
+            // Write the message.
             using (FileStream stream = new FileStream(logFile, FileMode.Append, FileAccess.Write, FileShare.Read, 4096, true))
             using (StreamWriter writer = new StreamWriter(stream, Encoding.UTF8))
             {
@@ -30,43 +36,61 @@
             }
         }
 
+        /// <summary>Appends a check result to the log file, creating the log file if it does not exist.</summary>
+        /// <param name="result">The check result to log.</param>
         public void Log(CheckResult result)
         {
             Log(result.ToLogString());
         }
 
+        /// <summary>Reads all check results from the log for a server.</summary>
+        /// <param name="server">The server whose check results should be read.</param>
+        /// <returns>A list of all check results found in the log file for the given server.</returns>
         public IList<CheckResult> Read(Server server)
         {
+            // Store the checks by ID.
             Dictionary<int, Check> checks = server.Checks.ToDictionary(c => c.Id);
             List<CheckResult> results = new List<CheckResult>();
             using (FileStream stream = new FileStream(logFile, FileMode.Open, FileAccess.Read, FileShare.Read))
             using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
             {
+                // Read through the whole file, searching for results belonging to the server.
                 while (true)
                 {
                     try
                     {
                         string line = reader.ReadLine();
+                        // Exit the loop when we reach the end.
                         if (line == null)
                             break;
+                        // The check ID is a fixed length.
+                        // Parse it and see if it matches any of the checks we are interested in.
                         if (int.TryParse(line.Substring(0, 5), out int id) && checks.TryGetValue(id, out Check check))
                         {
+                            // If it is, add it to our results list.
                             results.Add(CheckResult.FromLogString(check, line));
                         }
                     }
+                    // Don't know why this catch block is empty.
+                    // Maybe to ignore errors if the file does not exist?
                     catch (Exception) { }
                 }
             }
+            // Return the newest results first since that's how they are displayed.
             results.Reverse();
             return results;
         }
 
+        /// <summary>Removes old entries from the log.</summary>
         public async void TrimLog()
         {
+            // Delete entries older than this date.
             DateTime maxAge = DateTime.Now.AddDays(-1 * Settings.Default.KeepLogDays);
             string tempFile = logFile + ".tmp";
             try
             {
+                // Read through the log file and check the date of each entry.
+                // If it is newer than the max age, copy it to a temporary file.
                 using (FileStream stream = new FileStream(logFile, FileMode.Open, FileAccess.Read, FileShare.Read))
                 using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
                 using (FileStream outStream = new FileStream(tempFile, FileMode.Create, FileAccess.Write, FileShare.None))
@@ -87,6 +111,7 @@
                         catch (Exception) { }
                     }
                 }
+                // Delete the original file and rename the temporary file that contains only recent entries.
                 File.Delete(logFile);
                 File.Move(tempFile, logFile);
             }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Schedule.cs
--- a/ServerMonitor/Objects/Schedule.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Schedule.cs	Sat May 25 15:14:26 2019 -0400
@@ -2,10 +2,22 @@
 
 namespace ServerMonitorApp
 {
+    /// <summary>Schedule to control when a check is automatically executed.<summary>
     public class Schedule
     {
+        // Required empty constructor for XML serialization.
         public Schedule() { }
 
+        /// <summary>Schedule constructor</summary>
+        /// <param name="units">The time units to use.</param>
+        /// <param name="frequency">How frequently to run the check.</param>
+        /// <param name="startTime">Time of day the check should begin running.</param>
+        /// <param name="endTime">Time of day the check should stop running.</param>
+        /// <remarks>
+        /// If endTime is before startTime, then the endTime is interpreted as being on the next day.
+        /// For example, if startTime = 17:00 and endTime is 8:00, then the check will start running
+        /// at 17:00 and stop running at 8:00 the next day.
+        /// </remarks>
         public Schedule(FrequencyUnits units, int frequency, TimeSpan startTime, TimeSpan endTime)
         {
             Units = units;
@@ -14,32 +26,57 @@
             EndTime = endTime;
         }
 
+        /// <summary>How often the check should be executed.</summary>
         public int Frequency { get; set; }
 
+        /// <summary>The time units used to interpret the frequency.</summary>
         public FrequencyUnits Units { get; set; }
 
+        /// <summary>Time of day the check should begin running.</summary>
         public TimeSpan StartTime { get; set; }
 
+        /// <summary>Time of day the check should stop running.</summary>
         public TimeSpan EndTime { get; set; }
 
+        /// <summary>Given the last time a check was scheduled to run, calculates the next time in the future it should run.</summary>
+        /// <param name="lastScheduledTime">The last time a check was scheduled to run.</param>
         public DateTime GetNextTime(DateTime lastScheduledTime)
         {
             return GetNextTime(lastScheduledTime, DateTime.Now);
         }
 
+        /// <summary>Given the last time a check was scheduled to run, calculates the next time after the given date it should run.</summary>
+        /// <param name="lastScheduledTime">The last time a check was scheduled to run.</param>
+        /// <param name="minStartTime">The earliest allowed time to return.</param>
+        /// <remarks>
+        /// The next execution time of a check cannot necessarily be determined by taking the
+        /// last execution time and adding the configured number of time units. The computer might
+        /// have been asleep or the program might have not been running, so the next date might
+        /// be in the past.
+        /// 
+        /// To best follow the schedule, we take the last execution time and fast-forward time
+        /// by adding the configured time interval until we get a resulting time that is in the future.
+        /// For example, suppose a check is scheduled to run every 5 minutes starting at 7:00.
+        /// The check last ran at 7:40, and the computer was suspended shortly thereafter and resumed
+        /// at 8:28. The next execution time is determined by adding 5 minutes to 7:40 until we obtain
+        /// a time after 8:28, in this case, 8:30.
+        /// </remarks>
         public DateTime GetNextTime(DateTime lastScheduledTime, DateTime minStartTime)
         {
+            // Start by setting the next time to the last time the check was run.
             DateTime nextTime = lastScheduledTime;
             if (Units == FrequencyUnits.Day)
             {
+                // If the check is scheduled only once a day, simply add days until we find a time in the future.
                 while (nextTime < minStartTime)
                     nextTime = nextTime.AddDays(Frequency).Date.Add(StartTime);
             }
             else
             {
-                // If the last run time was more than a day ago, fast-forward to reduce the number of loops
+                // If the last run time was more than a day ago, fast-forward a day at a time to reduce the number of loops.
                 if (nextTime < minStartTime.AddHours(-24))
                     nextTime = minStartTime.Date.Add(StartTime).AddHours(-24);
+                // Add the configured time interval to the last run time until we obtain a time in the future.
                 while (nextTime < minStartTime)
                 {
                     switch (Units)
@@ -50,15 +87,25 @@
                         default: throw new InvalidOperationException("Unexpected frequency units: " + Units);
                     }
                 }
+                // Now we have the next date and time, but we don't know yet if it is within
+                // the active times of day the check is allowed to run between.
                 if (StartTime < EndTime)
                 {
+                    // The allowed start and end times are on the same day.
+                    // If the next scheduled time is too early (before the allowed start time),
+                    // wait to run it until the start time happens.
                     if (nextTime.TimeOfDay < StartTime)
                         nextTime = nextTime.Date + StartTime;
+                    // If the next scheduled time is too late (after the allowed end time),
+                    // wait to run it until the start time happens on the following day.
                     else if (nextTime.TimeOfDay > EndTime)
                         nextTime = nextTime.Date.AddDays(1) + StartTime;
                 }
                 else if (nextTime.TimeOfDay > EndTime && nextTime.TimeOfDay < StartTime)
                 {
+                    // The allowed start time is on the day after the allowed end time,
+                    // and the next scheduled time is too early (before the allowed start time).
+                    // Wait to run the check until the allowed start time happens.
                     nextTime = nextTime.Date + StartTime;
                 }
             }
@@ -71,5 +118,6 @@
         }
     }
 
+    /// <summary>Units of time that a check can be scheduled to run in intervals of.</summary>
     public enum FrequencyUnits { Second, Minute, Hour, Day }
 }
\ No newline at end of file
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/Server.cs
--- a/ServerMonitor/Objects/Server.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/Server.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,17 +1,17 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Security.Cryptography;
 using System.ComponentModel;
 using Renci.SshNet;
-using System.Runtime.Serialization;
 using System.Xml.Serialization;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Types of SSH logins supported by the server monitor.</summary>
     public enum LoginType { PrivateKey = 0, Password = 1 };
 
+    /// <summary>Remote server that checks can be run against.</summary>
     public class Server
     {
         private string _host;
@@ -24,59 +24,78 @@
         private byte[] passwordHash;
         private PrivateKeyFile _privateKeyFile;
 
+        /// <summary>Fires when a check belonging to this server is modifed.</summary>
         public event EventHandler CheckModified;
+        /// <summary>Fires when the server enabled state changes.</summary>
         public event EventHandler EnabledChanged;
 
+        /// <summary>The checks that belong to this server.</summary>
         public readonly BindingList<Check> Checks = new BindingList<Check>();
 
+        /// <summary>Internal ID of the server.</summary>
         public int Id { get; set; }
 
+        /// <summary>Name of the server.</summary>
         public string Name { get; set; }
 
+        /// <summary>Hostname of the server.</summary>
         public string Host
         {
             get { return _host; }
             set { _host = value; InvalidateSshConnection(); }
         }
 
+        /// <summary>Port to use when connecting using SSH.</summary>
         public int Port
         {
             get { return _port; }
             set { _port = value; InvalidateSshConnection(); }
         }
 
+        /// <summary>Username to use when connecting using SSH.</summary>
         public string Username
         {
             get { return _username; }
             set { _username = value; InvalidateSshConnection(); }
         }
 
+        /// <summary>Login type to use when connecting using SSH.</summary>
         public LoginType LoginType
         {
             get { return _loginType; }
             set { _loginType = value; InvalidateSshConnection(); }
         }
 
+        /// <summary>Path to the private key file to use when connecting using SSH.</summary>
         public string KeyFile
         {
             get { return _keyFile; }
             set { _keyFile = value; InvalidateSshConnection(); }
         }
 
+        /// <summary>Password to use when connecting using SSH.</summary>
+        /// <remarks>The password is encrypted using the current Windows user account.</remarks>
         public string Password
         {
             get {
                 return passwordHash == null ? null :
-                    Encoding.UTF8.GetString(ProtectedData.Unprotect(passwordHash, Encoding.UTF8.GetBytes("Server".Reverse().ToString()), DataProtectionScope.CurrentUser));
+                    Encoding.UTF8.GetString(ProtectedData.Unprotect(passwordHash
+                    , Encoding.UTF8.GetBytes("Server".Reverse().ToString()) // Super-secure obfuscation of additional entropy
+                    , DataProtectionScope.CurrentUser));
             }
             set
             {
                 passwordHash = ProtectedData.Protect(Encoding.UTF8.GetBytes(value),
-                                    Encoding.UTF8.GetBytes("Server".Reverse().ToString()), // Minor obfuscation of additional entropy
+                                    Encoding.UTF8.GetBytes("Server".Reverse().ToString()), // Super-secure obfuscation of additional entropy
                                     DataProtectionScope.CurrentUser);
             }
         }
 
+        /// <summary>Private key file to use when connecting using SSH.</summary>
+        /// <remarks>
+        /// If the private key file is encrypted, will be null until the user enters
+        /// the decryption key.
+        /// </remarks>
         [XmlIgnore]
         public PrivateKeyFile PrivateKeyFile
         {
@@ -88,11 +107,18 @@
                 {
                     if (_privateKeyFile == null)
                     {
+                        // The private key has not been opened yet.
+                        // Disable the server until the user enters the decryption key,
+                        // and set the KeyStatus to indicate why the server was disabled.
                         KeyStatus = KeyStatus.Closed;
                         Enabled = false;
                     }
                     else
                     {
+                        // The private key is open and accessible.
+                        // Automatically re-enable the server if it was previously disabled
+                        // due to a locked or inaccessible private key (i.e. disabled
+                        // programatically and not by user request).
                         if (!KeyStatus.In(KeyStatus.Open, KeyStatus.Closed))
                             Enabled = true;
                         KeyStatus = KeyStatus.Open;
@@ -101,13 +127,18 @@
             }
         }
 
+        /// <summary>The current status of the private key file.</summary>
         public KeyStatus KeyStatus { get; set; }
 
+        /// <summary>Whether this server's checks will be automatically executed on their schedules.</summary>
         public bool Enabled
         {
             get { return _enabled; }
             set
             {
+                // Do not allow enabling the server if the private key is not accessible.
+                // Do not fire the EnabledChanged event if the Enabled state is not actually changing
+                // from its existing value.
                 if ((LoginType == LoginType.PrivateKey && PrivateKeyFile == null && value == true) || value == _enabled)
                     return;
                 _enabled = value;
@@ -115,14 +146,23 @@
             }
         }
 
-        //public bool WaitingForUser { get; set; }
-
+        /// <summary>The status of the server.</summary>
+        /// <remarks>
+        /// The status of the server is the most severe status of all its enabled checks.
+        /// The integer value of the CheckStatus enum increases with the severity,
+        /// so the maximum value of all checks gives the most severe status.
+        /// </remarks>
         public CheckStatus Status => !Enabled ? CheckStatus.Disabled : Checks
             .Where(c => c.Enabled)
             .Select(c => c.LastRunStatus)
             .DefaultIfEmpty(CheckStatus.Success)
             .Max();
 
+        /// <summary>The SSH client to use when running checks on the server.</summary>
+        /// <remarks>
+        /// The connection is stored and kept open at the server level so it can be reused
+        /// by all SSH checks.
+        /// </remarks>
         public SshClient SshClient
         {
             get
@@ -136,19 +176,8 @@
             }
         }
 
-        /*public Server() { }
-
-        public Server(Server server)
-        {
-            Name = server.Name;
-            Host = server.Host;
-            Port = server.Port;
-            Username = server.Username;
-            LoginType = server.LoginType;
-            KeyFile = server.KeyFile;
-            Enabled = server.Enabled;
-        }*/
-
+        /// <summary>Deletes a check from the server.</summary>
+        /// <param name="check">The check to delete.</param>
         public void DeleteCheck(Check check)
         {
             Checks.Remove(check);
@@ -156,6 +185,8 @@
             CheckModified?.Invoke(check, new EventArgs());
         }
 
+        /// <summary>Validates server settings.</summary>
+        /// <returns>An empty string if the server is valid, or the reason the server is invalid.</returns>
         public string Validate()
         {
             string message = string.Empty;
@@ -166,11 +197,15 @@
             return message.Length > 0 ? message : null;
         }
 
+        /// <summary>Updates a check.</summary>
         public void UpdateCheck(Check check)
         {
+            // See if there is already a check with this ID.
             Check oldCheck = Checks.FirstOrDefault(c => c.Id == check.Id);
             if (!ReferenceEquals(check, oldCheck))
             {
+                // If there is already a check, but it is a different object instance,
+                // replace the old check with the new one (or add it if it is new).
                 int index = Checks.IndexOf(oldCheck);
                 if (index == -1)
                     Checks.Add(check);
@@ -180,6 +215,7 @@
             CheckModified?.Invoke(check, new EventArgs());
         }
 
+        /// <summary>Returns true if the server looks empty (no user data has been entered).</summary>
         public bool IsEmpty()
         {
             return Name.IsNullOrEmpty()
@@ -187,6 +223,7 @@
                 && Checks.Count == 0;
         }
 
+        /// <summary>Generates the authentication method based on user preferences.</summary>
         private AuthenticationMethod GetAuthentication()
         {
             if (LoginType == LoginType.Password)
@@ -195,6 +232,7 @@
                 return new PrivateKeyAuthenticationMethod(Username, PrivateKeyFile);
         }
 
+        /// <summary>Releases the open SSH connection.</summary>
         private void InvalidateSshConnection()
         {
             _sshClient?.Dispose();
@@ -207,13 +245,17 @@
         }
     }
 
+    /// <summary>Possible statuses of the private key file.</summary>
     public enum KeyStatus
     {
+        /// <summary>The private key file is closed for an unspecified reason.</summary>
         Closed,
+        /// <summary>The private key file is accessible and open.</summary>
         Open,
+        /// <summary>The private key file is not accessible (missing, access denied, etc).</summary>
         NotAccessible,
+        /// <summary>The private key file is encrypted and the user has not entered the password yet.</summary>
         NeedPassword,
     }
 
-
 }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/ServerMonitor.cs
--- a/ServerMonitor/Objects/ServerMonitor.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/ServerMonitor.cs	Sat May 25 15:14:26 2019 -0400
@@ -4,11 +4,9 @@
 using ServerMonitorApp.Properties;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Net.NetworkInformation;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
@@ -16,51 +14,74 @@
 
 namespace ServerMonitorApp
 {
+    /// <summary>Central class for scheduling and executing checks against remote servers.</summary>
     public class ServerMonitor
     {
         private readonly string configFileDir;
         private readonly Logger logger;
+        // Cancellation tokens for executing checks, keyed by check ID.
         private readonly Dictionary<int, CancellationTokenSource> tokens = new Dictionary<int, CancellationTokenSource>();
+        // SSH private keys, keyed by the path to the private key file.
+        // A value of NULL indicates that the private key is inaccessible or encrypted.
         private readonly Dictionary<string, PrivateKeyFile> privateKeys = new Dictionary<string, PrivateKeyFile>();
+        // IDs of all checks that have been paused due to network unavailability,
+        // or due to the system being suspended.
+        // Not to be confused with checks that have been disabled by the user.
         private readonly List<int> pausedChecks = new List<int>();
         private bool running, networkAvailable, suspend;
+        // List of check execution tasks that have been started.
+        // A check task begins by sleeping until the next scheduled execution time,
+        // then executes.
         private Dictionary<Task<CheckResult>, int> tasks;
         private ServerSummaryForm mainForm;
 
-        //private List<Task<CheckResult>> tasks;
-
+        /// <summary>Fires when the status of a check changes.</summary>
         public event EventHandler<CheckStatusChangedEventArgs> CheckStatusChanged;
 
+        /// <summary>The collection of registered servers.</summary>
         public List<Server> Servers { get; private set; } = new List<Server>();
 
+        /// <summary>A collection of all checks belonging to all registerd servers.</summary>
         public IEnumerable<Check> Checks => Servers.SelectMany(s => s.Checks);
 
+        /// <summary>Path to the file that stores server and check configuration.</summary>
         public string ConfigFile { get; private set; }
 
+        /// <summary>Path to the file that stores server and check configuration.</summary>
         public IEnumerable<string> LockedKeys { get { return privateKeys.Where(kvp => kvp.Value == null).Select(kvp => kvp.Key); } }
 
+        /// <summary>ServerMonitor constructor.</summary>
+        /// <param name="mainForm">A reference to the main form.</param>
         public ServerMonitor(ServerSummaryForm mainForm)
         {
             this.mainForm = mainForm;
+            // Store configuration in %appdata%\ServerMonitor
             configFileDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "ServerMonitor");
             ConfigFile = Path.Combine(configFileDir, "servers.xml");
             logger = new Logger(Path.Combine(configFileDir, "monitor.log"));
         }
 
+        /// <summary>Registers a new server with the server monitor.</summary>
+        /// <param name="server">The server to be added.</param>
         public void AddServer(Server server)
         {
             Servers.Add(server);
             SaveServers();
         }
 
+        /// <summary>Deletes a server from the server monitor.</summary>
+        /// <param name="server">The server to be deleted.</param>
         public void DeleteServer(Server server)
         {
             Servers.Remove(server);
             SaveServers();
         }
 
+        /// <summary>Loads all servers and checks from the config file.</summary>
         public void LoadServers()
         {
+            bool triedBackup = false;
+
             Read:
             TextReader reader = null;
             try
@@ -69,16 +90,23 @@
                 XmlSerializer serializer = CreateXmlSerializer();
                 Servers.Clear();
                 Servers.AddRange((List<Server>)serializer.Deserialize(reader));
-                // Update the Checks so they know what Server they belong to.
-                // Would rather do this in the Server object on deserialization, but
-                // that doesn't work when using the XML serializer for some reason.
+                // Do some more set-up now that the servers and checks have been loaded.
                 foreach (Server server in Servers)
                 {
+                    // Read private keys into memory if they are accessible and not encrypted.
+                    // If PrivateKeyFile != null, it means same the key has already been loaded for
+                    // a different server and nothing more needs to be done.
                     if (server.LoginType == LoginType.PrivateKey && server.PrivateKeyFile == null)
                         OpenPrivateKey(server.KeyFile);
                     foreach (Check check in server.Checks)
                     {
+                        // Update the checks so they know what server they belong to.
+                        // Would rather do this in the Server object on deserialization, but
+                        // that doesn't work when using the XML serializer for some reason.
                         check.Server = server;
+                        // If the program last exited while the check was running, change its status
+                        // to the result of its last execution (since, at this point, the check is
+                        // not running).
                         if (check.Status == CheckStatus.Running)
                             check.Status = check.LastRunStatus;
                     }
@@ -92,9 +120,23 @@
             catch (InvalidOperationException)
             {
                 reader?.Close();
-                File.Copy(ConfigFile, ConfigFile + ".error", true);
-                File.Copy(ConfigFile + ".bak", ConfigFile, true);
-                goto Read;
+                // If there was an error parsing the XML, try again with the backup config file.
+                if (!triedBackup)
+                {
+                    File.Copy(ConfigFile, ConfigFile + ".error", true);
+                    string backupConfig = ConfigFile + ".bak";
+                    if (File.Exists(backupConfig))
+                    {
+                        File.Copy(backupConfig, ConfigFile, true);
+                    }
+                    triedBackup = true;
+                    goto Read;
+                }
+                else
+                {
+                    // If there was an error reading the backup file too, give up.
+                    throw;
+                }
             }
             finally
             {
@@ -103,10 +145,14 @@
             Application.ApplicationExit += Application_ApplicationExit;
             NetworkChange.NetworkAddressChanged += NetworkChange_NetworkAddressChanged;
             SystemEvents.PowerModeChanged += SystemEvents_PowerModeChanged;
+
+            // Remove old entries from the log file according to user preferences.
             logger.TrimLog();
+
             Run();
         }
 
+        /// <summary>Saves all servers and checks to the config file.</summary>
         public void SaveServers()
         {
             GenerateIds();
@@ -114,6 +160,7 @@
             XmlSerializer serializer = null;
             try
             {
+                // Make a backup first in case something goes wrong in the middle of writing.
                 File.Copy(ConfigFile, ConfigFile + ".bak", true);
             }
             catch { }
@@ -125,6 +172,7 @@
             }
             catch (DirectoryNotFoundException)
             {
+                // If the directory does not exist, create it and try again.
                 Directory.CreateDirectory(configFileDir);
                 writer = new StreamWriter(ConfigFile);
                 serializer = CreateXmlSerializer();
@@ -136,11 +184,17 @@
             }
         }
 
+        /// <summary>Main server monitor loop. Schedules and executes checks.</summary>
         private async void Run()
         {
+            // Do not run again if already running or if the system is suspending or resuming.
             if (running || suspend)
                 return;
+
             running = true;
+
+            // If the network is available, immediately execute checks that were supposed to run
+            // earlier but could not due to network unavailability or the system being suspended.
             networkAvailable = Helpers.IsNetworkAvailable();
             if (networkAvailable)
             {
@@ -150,41 +204,110 @@
                 }
                 pausedChecks.Clear();
             }
+
+            // Schedule all checks to run according to their schedules.
+            // Each check will sleep until it is scheduled to run, then execute.
             tasks = Checks.ToDictionary(c => ScheduleExecuteCheckAsync(c), c => c.Id);
             while (tasks.Count > 0)
             {
+                // When any check is done sleeping and executing, remove the completed
+                // task and queue a new task to schedule it again.
                 Task<CheckResult> task = await Task.WhenAny(tasks.Keys);
                 tasks.Remove(task);
                 try
                 {
                     CheckResult result = await task;
-                    // Result will be null if a scheduled check was disabled
+                    // Do not schedule the task again if it is now disabled.
+                    // Result will be null if a scheduled check was disabled.
                     if (result != null && result.CheckStatus != CheckStatus.Disabled)
                         tasks.Add(ScheduleExecuteCheckAsync(result.Check), result.Check.Id);
                 }
                 catch (OperationCanceledException)
                 {
-
+                    // When a server's state changes to Disabled, any checks that are executing
+                    // are immediately cancelled. Silently catch these expected exceptions.
                 }
             }
+            // If there are no enabled checks scheduled, exit the main loop.
+            // It will be restarted when a check or server is enabled.
             running = false;
         }
 
+        /// <summary>Schedules a check to be run on its schedule.</summary>
+        /// <param name="check">The check to execute.</param>
+        /// <returns>The async check result.</returns>
+        private async Task<CheckResult> ScheduleExecuteCheckAsync(Check check)
+        {
+            // Do not schedule or execute the check if it or its server is disabled.
+            if (!check.Enabled || !check.Server.Enabled)
+                return await Task.FromResult(new CheckResult(check, CheckStatus.Disabled, null));
+
+            // Create a cancellation token that will be used to cancel the check if it or
+            // its server is disabled while it is executing.
+            CancellationTokenSource cts = new CancellationTokenSource();
+            tokens[check.Id] = cts;
+
+            // Sleep until next time the check is supposed to be executed.
+            // Use the LastScheduledRunTime so manual executions by the user do not
+            // interfere with the schedule.
+            check.NextRunTime = check.Schedule.GetNextTime(check.LastScheduledRunTime);
+            int delay = Math.Max(0, (int)(check.NextRunTime - DateTime.Now).TotalMilliseconds);
+            await Task.Delay(delay, cts.Token);
+            check.LastScheduledRunTime = check.NextRunTime;
+
+            // Execute the check if not cancelled.
+            if (!cts.IsCancellationRequested)
+            {
+                // If the network is available, execute the check.
+                // Otherwise, add it to the list of paused checks to be executed
+                // when the network becomes available again.
+                if (networkAvailable)
+                {
+                    return await ExecuteCheckAsync(check, cts.Token);
+                }
+                else
+                {
+                    if (!pausedChecks.Contains(check.Id))
+                        pausedChecks.Add(check.Id);
+                }
+            }
+            return await Task.FromResult(new CheckResult(check, CheckStatus.Disabled, null));
+        }
+
+        /// <summary>Executes a check asynchronously.</summary>
+        /// <param name="check">The check to execute.</param>
+        /// <param name="token">A chancellation token that may be used to cancel the check execution.</param>
+        /// <returns>The async check result.</returns>
         public async Task<CheckResult> ExecuteCheckAsync(Check check, CancellationToken token = default(CancellationToken))
         {
+            // Update the status.
             check.Status = CheckStatus.Running;
             OnCheckStatusChanged(check);
+
+            // Execute the check.
             CheckResult result = await check.ExecuteAsync(token);
+
+            // Increment the consecutive failure counter on failue, or reset
+            // the counter on success.
             if (result.Failed)
                 check.ConsecutiveFailures++;
+            else
+                check.ConsecutiveFailures = 0;
+
             OnCheckStatusChanged(check, result);
             HandleResultAsync(result);
             return result;
         }
 
+        /// <summary>Handles the result of a check execution.</summary>
+        /// <param name="result">The result.</param>
         private void HandleResultAsync(CheckResult result)
         {
+            // Log the result.
             logger.Log(result);
+
+            // Notify the user of failure according to user preferences.
+            // If the check succeeded, result.FailAction will be None.
             if (result.Check.ConsecutiveFailures >= result.Check.MaxConsecutiveFailures)
             {
                 if (result.FailAction == FailAction.FlashTaskbar)
@@ -194,31 +317,41 @@
             }
         }
 
+        /// <summary>Reads all check results from the log for a server.</summary>
+        /// <param name="server">The server whose check results should be read.</param>
+        /// <returns>A list of all check results found in the log file for the given server.</returns>
         public IList<CheckResult> GetLog(Server server)
         {
             return logger.Read(server);
         }
 
+        /// <summary>Saves the check settings and notifies event subscribers when the status of a check changes.</summary>
+        /// <param name="check">The check whose status has changed.</param>
+        /// <param name="result">The check result that caused the status to change, if any.</param>
         private void OnCheckStatusChanged(Check check, CheckResult result = null)
         {
             SaveServers();
             CheckStatusChanged?.Invoke(check, new CheckStatusChangedEventArgs(check, result));
         }
 
+        /// <summary>Handles user modifications to a check's settings.</summary>
+        /// <param name="sender">The check that was modified.</param>
         private void Server_CheckModified(object sender, EventArgs e)
         {
             Check check = (Check)sender;
-            Task<CheckResult> task = tasks.FirstOrDefault(kvp => kvp.Value == check.Id).Key;
+
+            // No need to mess with the task queue if not currently running.
             if (running)
             {
+                Task<CheckResult> task = tasks.FirstOrDefault(kvp => kvp.Value == check.Id).Key;
                 if (task == null)
                 {
-                    // No tasks associated with the check, so schedule a new one
+                    // No tasks associated with the check, so schedule a new one.
                     tasks.Add(ScheduleExecuteCheckAsync(check), check.Id);
                 }
                 else
                 {
-                    // Check was modified or deleted, so remove any waiting tasks
+                    // Check was modified or deleted, so remove any waiting tasks.
                     CancelCheck(check);
                     if (check.Server != null)
                     {
@@ -230,19 +363,26 @@
                     }
                 }
             }
-            // Run again in case removing a task above caused it to stop
+            // Run again in case removing a task above caused it to stop.
             Run();
         }
 
+        /// <summary>Handles the enabled state of a server changing.</summary>
+        /// <param name="sender">The server that was enabled or disabled.</param>
         private void Server_EnabledChanged(object sender, EventArgs e)
         {
             Server server = (Server)sender;
+
+            // Make sure the monitor is running. If no servers were enabled before this
+            // one was enabled, it is not running.
             if (server.Enabled)
             {
                 Run();
             }
             else
             {
+                // Cancel all queued and executing checks belonging to a
+                // server that was disabled.
                 foreach (Check check in server.Checks)
                 {
                     CancelCheck(check);
@@ -250,50 +390,42 @@
             }
         }
 
+        /// <summary>Cancels a check that may be executing.</summary>
+        /// <param name="check">The check to cancel.</param>
         private void CancelCheck(Check check)
         {
             if (tasks == null)
                 return;
+
+            // Find the waiting or executing task for the check and remove it.
             Task<CheckResult> task = tasks.FirstOrDefault(kvp => kvp.Value == check.Id).Key;
             if (task != null)
                 tasks.Remove(task);
+
+            // Remove it from the list of paused checks so it doesn't get restarted later.
             pausedChecks.RemoveAll(id => id == check.Id);
+
+            // Cancel the current execution.
             if (tokens.TryGetValue(check.Id, out CancellationTokenSource cts))
                 cts.Cancel();
         }
 
-        private async Task<CheckResult> ScheduleExecuteCheckAsync(Check check)
-        {
-            if (!check.Enabled || !check.Server.Enabled)
-                return await Task.FromResult(new CheckResult(check, CheckStatus.Disabled, null));
-
-            CancellationTokenSource cts = new CancellationTokenSource();
-            tokens[check.Id] = cts;
-            check.NextRunTime = check.Schedule.GetNextTime(check.LastScheduledRunTime);
-            int delay = Math.Max(0, (int)(check.NextRunTime - DateTime.Now).TotalMilliseconds);
-            await Task.Delay(delay, cts.Token);
-            check.LastScheduledRunTime = check.NextRunTime;
-            if (networkAvailable && !cts.IsCancellationRequested)
-            {
-                return await ExecuteCheckAsync(check, cts.Token);
-            }
-            else
-            {
-                if (!pausedChecks.Contains(check.Id))
-                    pausedChecks.Add(check.Id);
-                return await Task.FromResult(new CheckResult(check, CheckStatus.Disabled, null));
-            }
-        }
-
+        /// <summary>Handles network state changing.</summary>
         private void NetworkChange_NetworkAddressChanged(object sender, EventArgs e)
         {
             networkAvailable = Helpers.IsNetworkAvailable();
+            // If the network is available, it might not have been before.
+            // This method is not called from the correct thread, so special
+            // handling is needed to start it on the UI thread again.
             if (networkAvailable)
                 mainForm.Invoke((MethodInvoker)(() => Run()));
         }
 
+        /// <summary>Handles system power mode changes.</summary>
         private async void SystemEvents_PowerModeChanged(object sender, PowerModeChangedEventArgs e)
         {
+            // If the system is being suspended, cancel all waiting and executing checks.
+            // Once all the checks are removed, the main loop will exit.
             if (e.Mode == PowerModes.Suspend)
             {
                 foreach (Check check in Checks)
@@ -304,32 +436,45 @@
             }
             else if (e.Mode == PowerModes.Resume)
             {
+                // When resuming from suspend, examine each check to find out if it was
+                // scheduled to be executed during the time period when the systems was
+                // suspended. Add them to the paused checks list, to be executed almost
+                // immediately.
+                // Make sure the list is empty to start.
                 pausedChecks.Clear();
                 foreach (Check check in Checks)
                 {
-                    //CancelCheck(check);
                     if (check.Enabled && check.Server.Enabled && check.NextRunTime < DateTime.Now)
                     {
                         pausedChecks.Add(check.Id);
                     }
                 }
+                // Wait 10 seconds to give things time to quiet down after resuming.
                 await Task.Delay(10000);
                 suspend = false;
                 Run();
             }
         }
 
+        /// <summary>Unregister system events when exiting.</summary>
         private void Application_ApplicationExit(object sender, EventArgs e)
         {
             NetworkChange.NetworkAddressChanged -= NetworkChange_NetworkAddressChanged;
             SystemEvents.PowerModeChanged -= SystemEvents_PowerModeChanged;
         }
 
+        /// <summary>Attempts to read a private file.</summary>
+        /// <param name="path">The path to the private key file.</param>
+        /// <param name="password">The password used to encrypt the key.</param>
+        /// <returns>A status indicating the result of the attempt.</returns>
         public KeyStatus OpenPrivateKey(string path, string password = null)
         {
             KeyStatus keyStatus;
+
             if (path == null)
                 keyStatus = KeyStatus.NotAccessible;
+
+            // Check if the key has already been open and read.
             if (privateKeys.TryGetValue(path, out PrivateKeyFile key) && key != null)
                 keyStatus = KeyStatus.Open;
             else
@@ -339,15 +484,20 @@
                     key = new PrivateKeyFile(path, password);
                     keyStatus = KeyStatus.Open;
                 }
+                // If the key is encrypted and the password is empty or incorrect,
+                // return the NeedPassword status.
                 catch (Exception e) when (e is SshPassPhraseNullOrEmptyException || e is InvalidOperationException)
                 {
                     keyStatus = KeyStatus.NeedPassword;
                 }
+                // For any other failure reason, return the NotAccessible status.
                 catch (Exception)
                 {
                     keyStatus = KeyStatus.NotAccessible;
                 }
             }
+            // A single private key may be used by multiple servers. Update all servers
+            // that use this private key with the results of the above operations.
             foreach (Server server in Servers)
             {
                 if (server.KeyFile == path)
@@ -356,14 +506,21 @@
                     server.KeyStatus = keyStatus;
                 }
             }
+            // Keep a reference to this private key so we don't have to re-open
+            // it later if the same key is used on a different server.
             privateKeys[path] = key;
+
             return keyStatus;
         }
 
+        /// <summary>Generates internal IDs for servers and checks.</summary>
         private void GenerateIds()
         {
             if (Servers.Any())
             {
+                // Start at the maximum ID to make sure IDs are not reused
+                // if a server was deleted so old log entries do not get associated
+                // with a new server.
                 int id = Servers.Max(s => s.Id);
                 foreach (Server server in Servers)
                 {
@@ -374,6 +531,8 @@
 
             if (Checks.Any())
             {
+                // Start with the max check ID, same reasons as above.
+                // Is there a reason this is stored in a setting?
                 int id = Math.Max(Settings.Default.MaxCheckId, Checks.Max(c => c.Id));
                 foreach (Check check in Checks)
                 {
@@ -385,16 +544,21 @@
             }
         }
 
+        /// <summary>Creates an XML serializer that can handle servers and all check types.</summary>
+        /// <returns>An XML serializer that can handle servers and all check types.</returns>
         private XmlSerializer CreateXmlSerializer()
         {
             return new XmlSerializer(typeof(List<Server>), Check.CheckTypes);
         }
     }
 
+    /// <summary>Event arguments for when a check status changes.</summary>
     public class CheckStatusChangedEventArgs : EventArgs
     {
+        /// <summary>The check whose status changed.</summary>
         public Check Check { get; private set; }
 
+        /// <summary>The check result that caused the status to change, if any.</summary>
         public CheckResult CheckResult { get; private set; }
 
         public CheckStatusChangedEventArgs(Check check, CheckResult result)
@@ -404,5 +568,15 @@
         }
     }
 
-    public enum FailAction { FlashTaskbar = 0, NotificationBalloon = 1, None = 10 }
+    /// <summary>Possible actions that may be taken when a check fails.</summary>
+    public enum FailAction
+    {
+        /// <summary>Flashes the Server Monitor tasbar program icon.</summary>
+        FlashTaskbar = 0,
+        /// <summary>Shows a balloon in the notification area.</summary>
+        NotificationBalloon = 1,
+        /// <summary>Take no action.</summary>
+        None = 10
+    }
+
 }
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Objects/UpdateCheckException.cs
--- a/ServerMonitor/Objects/UpdateCheckException.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Objects/UpdateCheckException.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,8 +1,8 @@
 using System;
-using System.Runtime.Serialization;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Thrown when invalid data is entered on the check settings form.</summary>
     public class UpdateCheckException : Exception
     {
         public UpdateCheckException(string message) : base(message)
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Program.cs
--- a/ServerMonitor/Program.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Program.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Windows.Forms;
@@ -16,8 +15,10 @@
         [STAThread]
         static void Main()
         {
+            // Check if the program is already running.
             if (mutex.WaitOne(TimeSpan.Zero, true))
             {
+                // Show unhandled exceptions to the user.
                 Application.ThreadException += new ThreadExceptionEventHandler(Application_ThreadException);
                 Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
                 AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
@@ -28,6 +29,8 @@
             }
             else
             {
+                // If the program is already running, send a message to the main form
+                // asking it to show itself, then exit.
                 Win32Helpers.PostMessage(
                     (IntPtr)Win32Helpers.HWND_BROADCAST,
                     Win32Helpers.WM_SHOWMONITOR,
@@ -36,18 +39,22 @@
             }
         }
 
+        /// <summary>Shows unhandled exceptions in a message box.</summary>
         static void Application_ThreadException(object sender, ThreadExceptionEventArgs e)
         {
-            //if (!System.Diagnostics.Debugger.IsAttached)
+            if (!System.Diagnostics.Debugger.IsAttached)
                 ShowError(e.Exception);
         }
 
+        /// <summary>Shows unhandled exceptions in a message box.</summary>
         static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
         {
-            //if (!System.Diagnostics.Debugger.IsAttached)
+            if (!System.Diagnostics.Debugger.IsAttached)
                 ShowError(e.ExceptionObject as Exception);
         }
 
+        /// <summary>Shows exception details in a message box.</summary>
+        /// <param name="e">The exception to show.</param>
         static void ShowError(Exception e)
         {
             string simpleStackTrace = string.Join(Environment.NewLine, new System.Diagnostics.StackTrace(e).GetFrames()
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/ServerMonitor.csproj
--- a/ServerMonitor/ServerMonitor.csproj	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/ServerMonitor.csproj	Sat May 25 15:14:26 2019 -0400
@@ -236,12 +236,6 @@
     <None Include="App.config" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="Resources\Icon1.ico" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="Resources\Image1.png" />
-  </ItemGroup>
-  <ItemGroup>
     <None Include="Resources\delete.png" />
   </ItemGroup>
   <ItemGroup>
diff -r 7626b099aefd -r 68d7834dc28e ServerMonitor/Win32Helpers.cs
--- a/ServerMonitor/Win32Helpers.cs	Tue Apr 30 20:40:58 2019 -0400
+++ b/ServerMonitor/Win32Helpers.cs	Sat May 25 15:14:26 2019 -0400
@@ -1,13 +1,10 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading.Tasks;
 using System.Windows.Forms;
 
 namespace ServerMonitorApp
 {
+    /// <summary>Methods for interacting with the Win32 API.</summary>
     class Win32Helpers
     {
         [DllImport("user32.dll")]
@@ -65,6 +62,8 @@
             FLASHW_TIMERNOFG = 12
         }
 
+        /// <summary>Flashes a window icon in the taskbar.</summary>
+        /// <param name="form">The form to flash.</param>
         public static bool FlashWindowEx(Form form)
         {
             IntPtr hWnd = form.Handle;
@@ -79,6 +78,8 @@
             return FlashWindowEx(ref fInfo);
         }
 
+        /// <summary>Stops flashing a window icon in the taskbar.</summary>
+        /// <param name="form">The form to stop flashing.</param>
         public static bool StopFlashWindowEx(Form form)
         {
             IntPtr hWnd = form.Handle;