Horizon – Diff between revs 11 and 12

Subversion Repositories:

?pathlinks?

Rev 11 – Rev 13 – Go to most recent revision – Details – Blame – Last modification – View Log

 using System.ComponentModel;
 using System.Data.SQLite;
 using System.Diagnostics;
 using System.Drawing;
 using System.IO;
+using System.IO.Ports;
 using System.Linq;
+using System.Net.Sockets;
 using System.Security.Cryptography;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Forms;
 using Horizon.Database;
 using Horizon.Utilities;
 using Microsoft.WindowsAPICodePack.Dialogs;
+using Mono.Zeroconf;
+using Mono.Zeroconf.Providers.Bonjour;
+using Newtonsoft.Json;
 using Org.BouncyCastle.Crypto;
+using Org.BouncyCastle.Utilities.Net;
 using Serilog;
+using WatsonTcp;
 namespace Horizon.Snapshots
+{
     public partial class SnapshotManagerForm : Form
         private readonly CancellationTokenSource _localCancellationTokenSource;
+        private readonly CancellationToken _localCancellationToken;
+        private readonly Mono.Zeroconf.ServiceBrowser _horizonServiceBrowser;
+        private IResolvableService _resolvedService;
-        private readonly CancellationToken _localCancellationToken;
+        private readonly ConcurrentDictionary<string, Service> _discoveredHorizonNetworkShares;
             _searchTextBoxChangedContinuation = new ScheduledContinuation();
+            _localCancellationTokenSource = new CancellationTokenSource();
+            _localCancellationToken = _localCancellationTokenSource.Token;
+            _discoveredHorizonNetworkShares = new ConcurrentDictionary<string, Service>();
-            _localCancellationTokenSource = new CancellationTokenSource();
+            _horizonServiceBrowser = new Mono.Zeroconf.ServiceBrowser();
-            _localCancellationToken = _localCancellationTokenSource.Token;
+            _horizonServiceBrowser.ServiceAdded += OnHorizonServiceBrowserOnServiceAdded;
+        }
                 components.Dispose();
+            }
+            _snapshotDatabase.SnapshotCreate -= SnapshotManager_SnapshotCreate;
-            _snapshotDatabase.SnapshotCreate -= SnapshotManager_SnapshotCreate;
+            _horizonServiceBrowser.ServiceAdded -= OnHorizonServiceBrowserOnServiceAdded;
             _horizonServiceBrowser.Dispose();
             _localCancellationTokenSource.Cancel();
             base.Dispose(disposing);
+        }
+        #endregion
+        #region Event Handlers
+        private void contextMenuStrip1_Opening(object sender, CancelEventArgs e)
+        {
+        }
         private void contextMenuStrip1_Opened(object sender, EventArgs e)
+        {
-        #endregion
+            _horizonServiceBrowser.Browse("_horizon._tcp", "local");
+        }
             });
+        }
         private async void SnapshotManagerForm_Load(object sender, EventArgs e)
+        {
+            // Start browsing for network services.
+            _horizonServiceBrowser.Browse("_horizon._tcp", "local");
             // Load snapshots.
             toolStripProgressBar1.Minimum = 0;
             toolStripProgressBar1.Maximum = (int)await _snapshotDatabase.CountSnapshotsAsync(_cancellationToken);
                 Log.Error(exception, "Unable to load snapshots.");
+            }
+        }
+        private void OnHorizonServiceBrowserOnServiceAdded(object o, Mono.Zeroconf.ServiceBrowseEventArgs args)
+        {
+            _resolvedService = args.Service;
+            Log.Information("Found Service: {0}", _resolvedService.Name);
+            _resolvedService.Resolved += OnServiceOnResolved;
+            _resolvedService.Resolve();
+            _resolvedService.Resolved -= OnServiceOnResolved;
+        }
+        private void OnServiceOnResolved(object o, ServiceResolvedEventArgs args)
+        {
+            var service = (Service) args.Service;
+            Log.Information("Resolved Service: {0} - {1}:{2} ({3} TXT record entries)", service.FullName, service.HostEntry.AddressList[0], service.UPort, service.TxtRecord.Count);
+            _discoveredHorizonNetworkShares.TryAdd(service.Name, service);
+            var discoveredServiceMenuItem = new ToolStripMenuItem(service.Name, null, OnShareWithNodeClicked);
+            discoveredServiceMenuItem.Tag = service;
+            shareToToolStripMenuItem.DropDownItems.Add(discoveredServiceMenuItem);
+        }
+        private async void OnShareWithNodeClicked(object sender, EventArgs e)
+        {
+            var toolStripMenuItem = (ToolStripMenuItem)sender;
+            var service = (Service)toolStripMenuItem.Tag;
+            var rows = GetSelectedDataGridViewRows(dataGridView1);
+            var count = rows.Count;
+            toolStripProgressBar1.Minimum = 0;
+            toolStripProgressBar1.Maximum = count;
+            var progress = new Progress<DataGridViewRowProgress>(rowProgress =>
+            {
+                if (rowProgress is DataGridViewRowProgressFailure rowProgressFailure)
+                {
+                    Log.Error(rowProgressFailure.Exception, "Unable to transfer data.");
+                    toolStripStatusLabel1.Text =
+                        $"Could not transfer {rowProgress.Row.Cells["NameColumn"].Value}...";
+                    toolStripProgressBar1.Value = rowProgress.Index + 1;
+                    statusStrip1.Update();
+                    return;
+                }
+                toolStripStatusLabel1.Text =
+                    $"Transferred {rowProgress.Row.Cells["NameColumn"].Value}...";
+                toolStripProgressBar1.Value = rowProgress.Index + 1;
+                statusStrip1.Update();
+            });
+            await Task.Run(() => TransferFiles(rows, service, progress, _cancellationToken), _cancellationToken);
+            if (_cancellationToken.IsCancellationRequested)
+            {
+                toolStripProgressBar1.Value = toolStripProgressBar1.Maximum;
+                toolStripStatusLabel1.Text = "Done.";
+            }
+        }
         private void SnapshotManagerForm_Closing(object sender, FormClosingEventArgs e)
+        {
+        }
         #endregion
+        #region Private Methods
+        private void DataGridView1_RowPrePaint(object sender, DataGridViewRowPrePaintEventArgs e)
+        {
+            DataGridView dataGridView = sender as DataGridView;
+            foreach (DataGridViewCell cell in dataGridView.Rows[e.RowIndex].Cells)
+            {
+                if (cell.Selected == false) { continue; }
+                var bgColorCell = Color.White;
+                if (cell.Style.BackColor != Color.Empty) { bgColorCell = cell.Style.BackColor; }
+                else if (cell.InheritedStyle.BackColor != Color.Empty) { bgColorCell = cell.InheritedStyle.BackColor; }
+                cell.Style.SelectionBackColor = MixColor(bgColorCell, Color.FromArgb(0, 150, 255), 10, 4);
+            }
+        }
+        //Mix two colors
+        //Example: Steps=10 & Position=4 makes Color2 mix 40% into Color1
+        /// <summary>
+        /// Mix two colors.
+        /// </summary>
+        /// <param name="Color1"></param>
+        /// <param name="Color2"></param>
+        /// <param name="Steps"></param>
+        /// <param name="Position"></param>
+        /// <example>Steps=10 & Positon=4 makes Color2 mix 40% into Color1</example>
+        /// <remarks>https://stackoverflow.com/questions/38337849/transparent-selectionbackcolor-for-datagridview-cell</remarks>
+        /// <returns></returns>
+        public static Color MixColor(Color Color1, Color Color2, int Steps, int Position)
+        {
+            if (Position <= 0 || Steps <= 1) { return Color1; }
+            if (Position >= Steps) { return Color2; }
+            return Color.FromArgb(
+                Color1.R + ((Color2.R - Color1.R) / Steps * Position),
+                Color1.G + ((Color2.G - Color1.G) / Steps * Position),
+                Color1.B + ((Color2.B - Color1.B) / Steps * Position)
                 );
         #region Private Methods
         private async Task DeleteFiles(IReadOnlyList<DataGridViewRow> rows, IProgress<DataGridViewRowProgress> progress,
                     progress.Report(new DataGridViewRowProgressFailure(rows[i], i, exception));
+                }
+            }
+        }
+        private async Task TransferFiles(IReadOnlyList<DataGridViewRow> rows, Service service,
+            IProgress<DataGridViewRowProgress> progress, CancellationToken cancellationToken)
+        {
+            var client = new WatsonTcpClient($"{service.HostEntry.AddressList[0]}", service.UPort);
+            client.Events.MessageReceived += (sender, args) =>
+            {
+                Log.Information($"{args.Data.Length} byte long message received from {args.Client.IpPort}");
+            };
+            try
+            {
+                client.Connect();
+                var count = rows.Count;
+                for (var i = 0; i < count && !cancellationToken.IsCancellationRequested; ++i)
+                {
+                    try
+                    {
+                        var completeSnapshot = await _snapshotDatabase.GetCompleteSnapshot((string)rows[i].Cells["HashColumn"].Value, cancellationToken);
+                        var jsonSnapshot = JsonConvert.SerializeObject(completeSnapshot);
+                        await client.SendAsync(jsonSnapshot, null, cancellationToken);
+                        progress.Report(new DataGridViewRowProgressSuccess(rows[i], i));
+                    }
+                    catch (Exception exception)
+                    {
+                        progress.Report(new DataGridViewRowProgressFailure(rows[i], i, exception));
+                    }
+                }
+            }
+            finally
+            {
+                client.Dispose();
+            }
+        }
         private async Task RevertFile(IReadOnlyList<DataGridViewRow> rows, IProgress<DataGridViewRowProgress> progress,
                                       CancellationToken cancellationToken)
+        {
+                }
+            }
+        }
-        #endregion
-        private void DataGridView1_RowPrePaint(object sender, DataGridViewRowPrePaintEventArgs e)
-        {
-            DataGridView dataGridView = sender as DataGridView;
-            foreach (DataGridViewCell cell in dataGridView.Rows[e.RowIndex].Cells)
-            {
-                if (cell.Selected == false) { continue; }
-                var bgColorCell = Color.White;
-                if (cell.Style.BackColor != Color.Empty) { bgColorCell = cell.Style.BackColor; }
-                else if (cell.InheritedStyle.BackColor != Color.Empty) { bgColorCell = cell.InheritedStyle.BackColor; }
-                cell.Style.SelectionBackColor = MixColor(bgColorCell, Color.FromArgb(0, 150, 255), 10, 4);
-            }
-        }
-        //Mix two colors
-        //Example: Steps=10 & Position=4 makes Color2 mix 40% into Color1
-        /// <summary>
-        /// Mix two colors.
-        /// </summary>
-        /// <param name="Color1"></param>
-        /// <param name="Color2"></param>
-        /// <param name="Steps"></param>
-        /// <param name="Position"></param>
-        /// <example>Steps=10 & Positon=4 makes Color2 mix 40% into Color1</example>
-        /// <remarks>https://stackoverflow.com/questions/38337849/transparent-selectionbackcolor-for-datagridview-cell</remarks>
-        /// <returns></returns>
-        public static Color MixColor(Color Color1, Color Color2, int Steps, int Position)
-        {
-            if (Position <= 0 || Steps <= 1) { return Color1; }
-            if (Position >= Steps) { return Color2; }
-            return Color.FromArgb(
-                Color1.R + ((Color2.R - Color1.R) / Steps * Position),
-                Color1.G + ((Color2.G - Color1.G) / Steps * Position),
-                Color1.B + ((Color2.B - Color1.B) / Steps * Position)
-                );
         #endregion
+    }
+}