1. DistributionHandler no longer responsible for storing independent list of trusted peers for data exchange, this will now be solely handled by peer channel IsTrustedPeer and PeerNetwork trust policy. Internal GET accessor changed to use LINQ to get trusted peers from ActivePeerChannels.

2. DistributionHandler slightly refactored to use memory mapped files. MemoryEntry struct simplified to be stored in dictionary.
3. New DataPayloadFormat 'MiscData' that will be stored as simple Object in MemoryEntry
4. Clarifying documentation for the DataPayloadFormat structt in DataTransmissionPacket
5. Removing default fill in `ping` behavior built into PeerChannel. Handling of trusting peers has been delegated to public delegate `DefaultTrustProtocol` which runs based on value set in IncomingPeerTrustPolicy.RunDefaultTrustProtocol. Default implementation mimics the basic `ping` behavior but will allow for more advanced logic to be implemented by overriding delegate value
6. Added BlockedIP and BlockedIdentifiers lists to IncomingPeerTrustPolicy. Default DiscernPeerChannels routine now checks these lists along with inbound peer acceptance

Author: realChrisDeBon

P2PNet/Distribution/DistributionHandler.cs

@@ -2,35 +2,30 @@
 using P2PNet.Peers;
 using System;
 using System.Collections.Concurrent;
+using System.IO.MemoryMappedFiles;
 using System.Text;
 using System.Timers;
 
 namespace P2PNet.Distribution
     {
-    // Data structure for entries
-    internal record struct MemoryEntry
-        {
-        public int StartPosition { get; }
-        public int Length { get; }
-        public DataPayloadFormat DataType { get; }
-        public string AutoGenTags {get;}
-        public MemoryEntry(int position, int length, DataPayloadFormat datatype)
-            {
-            StartPosition = position;
-            Length = length;
-            DataType = datatype;
-            }
-        }
-
     /// <summary>
     /// Provides methods and properties to handle data distribution to trusted peer channels.
     /// </summary>
     public static class DistributionHandler
         {
+        internal struct MemoryEntry
+        {
+            string Key { get; set; }
+            object Data { get; set; }
+        }
+        
         /// <summary>
-        /// Gets or sets the list of trusted peer channels.
+        /// Gets the list of trusted peer channels.
         /// </summary>
-        static List<PeerChannel> TrustedPeerChannels { get; set; } = new List<PeerChannel>();
+        static List<PeerChannel> TrustedPeerChannels
+        {
+            get { return PeerNetwork.ActivePeerChannels.Where(pc => pc.IsTrustedPeer).ToList(); }
+        }
 
         /// <summary>
         /// Queue for outgoing data packets to be distributed to trusted peers.
@@ -46,16 +41,6 @@ public static class DistributionHandler
         private static Timer _timer;
         private static Timer _queueChecker;
 
-
-        /// <summary>
-        /// Adds a peer channel to the list of trusted peer channels.
-        /// </summary>
-        /// <param name="peerChannel">The peer channel to add.</param>
-        public static void AddTrustedPeer(PeerChannel peerChannel)
-            {
-            TrustedPeerChannels.Add(peerChannel);
-            }
-
         /// <summary>
         /// Queues a data packet for distribution.
         /// </summary>
@@ -130,138 +115,52 @@ private static async void HandleIncomingDataPackets(System.Object source, Elapse
                     switch (packet.DataType)
                         {
                         case DataPayloadFormat.File:
-                            MemoryHandler.LoadDataToMemory(packet);
+                            MemoryHandler.LoadFileToMemoryMappedFile(packet);
                             break;
                         case DataPayloadFormat.Task:
 
                             break;
-                        }
+                        case DataPayloadFormat.MiscData:
+
+                            break;
+                    }
                     }
                 }
             }
 
         internal static class MemoryHandler
             {
-            private static Memory<byte> _data = new Memory<byte>(new byte[1024]); // change this later
-            private static int _position = 0;
             private static object _lock = new object(); // For thread safety
-            private static List<MemoryEntry> _entries = new List<MemoryEntry>();
-            private static bool validentry = true;
 
-            public static async Task LoadDataToMemory(DataTransmissionPacket packet)
-                {
-                lock (_lock)
-                    {
-                    int startPosition = _position;
-                    int totallen = Encoding.UTF8.GetBytes(packet.Data.ToString()).Length;
-
-                    MemoryEntry newentry = new MemoryEntry(startPosition, totallen, packet.DataType);
-                    // Resize if needed
-                    if (_data.Length - _position < packet.Data.Length)
-                        {
-                        ResizeInternalMemory(_data.Length + totallen);
-                        }
-
-                    // Append data
-                    validentry = true;
-                    try
-                        {
-                        Encoding.UTF8.GetBytes(packet.Data.ToString()).AsSpan().CopyTo(_data.Span.Slice(_position));
-                        } catch
-                        {
-                        validentry = false;
-                        }
-                    finally
-                        {
-                        if (validentry == true)
-                            {
-                            _position += totallen; // Adjust position 
+            // memory mapped files dictionary
+            private static readonly Dictionary<string, MemoryMappedFile> _memoryMappedFiles = new Dictionary<string, MemoryMappedFile>();
 
-                            // Add entry
-                            _entries.Add(newentry);
+            private static readonly Dictionary<string, MemoryEntry> _miscDataEntries = new Dictionary<string, MemoryEntry>();
 
-                            DebugMessage($"\nLoaded {totallen} bytes into memory.\n", ConsoleColor.Magenta);
-
-                            }
-                        }
-                    }
-                }
-
-            public static async Task<byte[]> ReadDataFromMemory(int index)
-                {
-                lock (_lock)
-                    {
-                    if (index < 0 || index >= _entries.Count)
-                        {
-
-                        DebugMessage($"Index out of range.\n", MessageType.Warning);
-
-                        throw new ArgumentOutOfRangeException(nameof(index));
-                        }
-
-                    var entry = _entries[index];
-                    return _data.Slice(entry.StartPosition, entry.Length).ToArray();
-                    }
-                }
-
-            public static async Task<byte[]> ReadDataFromMemory(DataPayloadFormat dataType, string dataTag)
-                {
+            public static async Task LoadFileToMemoryMappedFile(DataTransmissionPacket packet)
+            {
+                byte[] fileData = UnwrapData(packet);
+                string tempFileName = Path.GetTempFileName();
+                await File.WriteAllBytesAsync(tempFileName, fileData);
+ 
                 lock (_lock)
-                    {
-                    var matchingEntry = _entries.FirstOrDefault(e => e.DataType == dataType);
-
-                    if (matchingEntry.StartPosition == 0) // Check if entry was found
-                        {
-
-                        DebugMessage($"Entry in memory not found.\n", MessageType.Warning);
-
-                        }
-
-                    return _data.Slice(matchingEntry.StartPosition, matchingEntry.Length).ToArray();
-                    }
-                }
-
-            private static void ResizeInternalMemory(int newSize)
                 {
-                var newMemory = new Memory<byte>(new byte[newSize]);
-                _data.Span.CopyTo(newMemory.Span);
-                _data = newMemory;
-                }
-
-            public static ReadOnlySpan<byte> Search(DataPayloadFormat datatype)
-                {
-                int startIndex = FindBlockStart(DataFormatTagMap[datatype].OpeningTag);
-                if (startIndex == -1)
+                    if (!_memoryMappedFiles.ContainsKey(tempFileName))
                     {
-
-                    DebugMessage($"Tag not found.\n", MessageType.Warning);
-
+                        var memoryMappedFile = MemoryMappedFile.CreateFromFile(tempFileName, FileMode.Open, tempFileName);
+                        _memoryMappedFiles[tempFileName] = memoryMappedFile;
+                        DebugMessage($"\nLoaded file into memory-mapped file.\n", ConsoleColor.Magenta);
                     }
-
-                int endIndex = FindBlockEnd(startIndex + DataFormatTagMap[datatype].OpeningTag.Length);
-                if (endIndex == -1)
+                    else
                     {
-
-                    DebugMessage($"Invalid data format: Missing TAGEND.\n", MessageType.Warning);
-
-                    }
-
-                return _data.Span.Slice(startIndex + DataFormatTagMap[datatype].OpeningTag.Length, endIndex - startIndex - DataFormatTagMap[datatype].OpeningTag.Length);
-
-                // Helper to find the start of a data block
-                  int FindBlockStart(string tag)
-                    {
-                    return _data.Span.IndexOf(Encoding.UTF8.GetBytes(tag));
-                    }
-
-                // Helper to find the end of a data block
-                  int FindBlockEnd(int start)
-                    {
-                    return _data.Span.Slice(start).IndexOf(Encoding.UTF8.GetBytes(DataFormatTagMap[datatype].ClosingTag));
+                        DebugMessage($"\nFile is already loaded as a memory-mapped file.\n", ConsoleColor.Yellow);
                     }
                 }
             }
 
+            
+            }
+
         private static void DistributeData(DataTransmissionPacket outgoingpacket)
             {
             string outdata = Serialize<DataTransmissionPacket>(outgoingpacket);

P2PNet/Distribution/DistributionProtocol.cs

@@ -47,6 +47,11 @@ public enum PacketType
             PureMessage,
             BADPACKET
             }
+        /// <summary>
+        /// Wraps the packet data with the appropriate tags for transmission through the network. This helps the receiving peer identify the packet type and data.
+        /// </summary>
+        /// <param name="packetType">The type of packet being readied for transmissiion through the network.</param>
+        /// <param name="data">This should be the JSON serialized string of the packet before transmission.</param>
         public static void WrapPacket(PacketType packetType, ref string data)
             {
             string header = PacketTagMap[packetType].OpeningTag;
@@ -60,16 +65,19 @@ public enum DataPayloadFormat
             {
             File,
             Task,
+            MiscData
             }
         public readonly static Dictionary<DataPayloadFormat, MessageTags> DataFormatTagMap = new Dictionary<DataPayloadFormat, MessageTags>()
             {
                 { DataPayloadFormat.File, new MessageTags() { OpeningTag = "<File>", ClosingTag = "</File>" } },
                 { DataPayloadFormat.Task, new MessageTags() { OpeningTag = "<Task>", ClosingTag = "</Task>" } },
+                { DataPayloadFormat.MiscData, new MessageTags() { OpeningTag = "<MiscData>", ClosingTag = "</MiscData>" } }
             };
 
         /// <summary>
-        /// Removes the <see cref="DataFormatTagMap"/> tags that are placed in the byte[] payload of the <see cref="DataTransmissionPacket"/>.
+        /// Removes the <see cref="DistributionProtocol.DataFormatTagMap"/> tags that are placed in the byte[] payload of the <see cref="DataTransmissionPacket"/>.
         /// These tags are automatically placed upon instantiation in the constructor to help identify and handle the payload throughout its lifecycle.
+        /// It is necessary to unwrap the data before processing it, which should be primarily done in the <see cref="DistributionHandler"/>
         /// </summary>
         /// <param name="packet">The packet whose payloads needs extracting</param>
         /// <returns>The payload of the packet with the opening and closing data format tags removed (ie the raw data).</returns>

P2PNet/NetworkPackets/DataTransmissionPacket.cs

@@ -12,7 +12,7 @@ namespace P2PNet.NetworkPackets
     /// <summary>
     /// Represents a data transmission packet used for transmitting data throughout the peer-to-peer network.
     /// </summary>
-    /// <remarks>This packet can be used to transmit <see cref="NetworkTask"/> and files throughout the network.</remarks>
+    /// <remarks>This packet can be used to transmit files, data, and <see cref="NetworkTask"/> objects throughout the network.</remarks>
     public sealed class DataTransmissionPacket : INetworkPacket
         {
         /// <summary>
@@ -22,6 +22,18 @@ public sealed class DataTransmissionPacket : INetworkPacket
 
         /// <summary>
         /// Gets or sets the format of the data.
+        /// Acceptable data formats include:
+        /// <list type="bullet">
+        /// <item>
+        /// <description>File - represents an in-memory file</description>
+        /// </item>
+        /// <item>
+        /// <description>Task - represents a <see cref="NetworkTask"/></description>
+        /// </item>
+        /// <item>
+        /// <description>MiscData - represents any other type of object or class</description>
+        /// </item>
+        /// </list>
         /// </summary>
         public DataPayloadFormat DataType { get; set; }