Ignore:
Timestamp:
Jan 29, 2011, 1:45:47 PM (11 years ago)
Author:
nolte
Message:

Defined new Storage Helper Standard...further changes will
follow soon. With this update all former Challenges won't
work anymore.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/KeySearcher/P2P/Storage/StorageHelper.cs

    r2454 r2522  
    1919
    2020        //VERSIONNUMBER: Important. Set it +1 manually everytime the length of the MemoryStream Changes
    21         private const int version = 5;
    22         /*
    23         -----------------------------Versionnumber Changelog---------------------------------------------
    24         |   Version 1: Added the Versionnumber to the Stream (Leafs)
    25         |   Version 2: Added the first User Statistics (Avatar,ID,Count) to the Stream
    26         |   Version 3: Added version question (in front of results) + more statistic information (hostname,date) to the Stream
    27         |   Version 4: Reorganisation of the DHT structure. Update fully working now + features from previous versions available
    28         |   Version 5: Extended the key information by the user who found it. (Username,Date,Maschid,Host)
    29         -------------------------------------------------------------------------------------------------
    30          */
     21        private const int version = 1;
    3122
    3223        public StorageHelper(KeySearcher keySearcher, StatisticsGenerator statisticsGenerator, StatusContainer statusContainer)
     
    4637
    4738            //Append Updater Version
    48             binaryWriter.Write('W');
     39            binaryWriter.Write('V');
    4940            binaryWriter.Write(version); 
    5041
     
    6657                binaryWriter.Write(valueKey.decryption);
    6758
    68                 //--------------------------------------------------------
    6959                binaryWriter.Write(valueKey.user);
    7060                var buffertime = valueKey.time.ToBinary();
     
    7262                binaryWriter.Write(valueKey.maschid);
    7363                binaryWriter.Write(valueKey.maschname);
    74                 //---------------------------------------------------------
    7564            }                       
    7665             
     
    10897        private static void UpdateLeafInDht(Leaf nodeToUpdate, BinaryWriter binaryWriter)
    10998        {
    110             binaryWriter.Write('V');
    111             binaryWriter.Write(version);
    11299            var buffer = nodeToUpdate.LastReservationDate.ToBinary();
    113100            binaryWriter.Write(buffer);
     
    153140                for (var i = 0; i < resultCount; i++)
    154141                {
    155                     if (oldVersionFlag < 5)
    156                     {
    157                         var newResult = new KeySearcher.ValueKey
    158                                             {
    159                                                 key = binaryReader.ReadString(),
    160                                                 value = binaryReader.ReadDouble(),
    161                                                 decryption = binaryReader.ReadBytes(binaryReader.ReadInt32()),
    162                                                 user = "Unknown",
    163                                                 time = DateTime.MinValue,
    164                                                 maschid = 666,
    165                                                 maschname = "Devil"
    166                                             };
    167                         nodeToUpdate.Result.AddLast(newResult);
    168                     }
    169                     else
    170                     {
    171                         var newResult = new KeySearcher.ValueKey
     142                    var newResult = new KeySearcher.ValueKey
    172143                                            {
    173144                                                key = binaryReader.ReadString(),
     
    179150                                                maschname = binaryReader.ReadString()
    180151                                            };
    181                         nodeToUpdate.Result.AddLast(newResult);
     152                    nodeToUpdate.Result.AddLast(newResult);                   
     153                }
     154
     155                //Reading the number of avatarnames
     156                int avatarcount = binaryReader.ReadInt32();
     157                for (int i = 0; i < avatarcount; i++)
     158                {
     159                    //Reading the avatarname and the maschine-count for this name
     160                    string avatarname = binaryReader.ReadString();
     161                    int maschcount = binaryReader.ReadInt32();
     162                    var readMaschcount = new Dictionary<long, Information>();
     163
     164                    for (int j = 0; j < maschcount; j++)
     165                    {
     166                        //reading the IDs and patterncount
     167                        long maschID = binaryReader.ReadInt64();
     168                        int count = binaryReader.ReadInt32();
     169                        string host = binaryReader.ReadString();
     170                        var date = DateTime.FromBinary(binaryReader.ReadInt64());
     171                        readMaschcount.Add(maschID, new Information() { Count = count, Hostname = host, Date = date });
    182172                    }
    183                 }
    184 
    185                 if (binaryReader.BaseStream.Length != binaryReader.BaseStream.Position)
    186                 {
    187                     //Reading the number of avatarnames
    188                     int avatarcount = binaryReader.ReadInt32();
    189                     for (int i = 0; i < avatarcount; i++)
     173
     174                    if (nodeToUpdate.Activity.ContainsKey(avatarname))
    190175                    {
    191                         //Reading the avatarname and the maschine-count for this name
    192                         string avatarname = binaryReader.ReadString();
    193                         int maschcount = binaryReader.ReadInt32();
    194                         var readMaschcount = new Dictionary<long, Information>();
    195 
    196                         for (int j = 0; j < maschcount; j++)
    197                         {
    198                             //reading the IDs and patterncount
    199                             long maschID = binaryReader.ReadInt64();
    200                             int count = binaryReader.ReadInt32();
    201                             string host = binaryReader.ReadString();
    202                             var date = DateTime.FromBinary(binaryReader.ReadInt64());
    203                             readMaschcount.Add(maschID, new Information() { Count = count, Hostname = host, Date = date });
    204 
    205                         }
    206 
    207                         if (nodeToUpdate.Activity.ContainsKey(avatarname))
    208                         {
    209                             nodeToUpdate.Activity[avatarname] = readMaschcount;
    210                         }
    211                         else
    212                         {
    213                             nodeToUpdate.Activity.Add(avatarname, readMaschcount);
    214                         }
     176                        nodeToUpdate.Activity[avatarname] = readMaschcount;
    215177                    }
    216                 }
    217 
     178                    else
     179                    {
     180                        nodeToUpdate.Activity.Add(avatarname, readMaschcount);
     181                    }
     182                }
     183               
    218184                if (resultCount > 0)
    219185                {
     
    222188                    statisticsGenerator.ProcessPatternResults(nodeToUpdate.Result);
    223189                }
    224 
    225190                nodeToUpdate.UpdateCache();
    226191                return requestResult;
     
    233198                    throw new NotConnectedException();
    234199
    235                 // client id not available, use default
    236200                keySearcher.GuiLogMessage(e.Message + ": Node causing the failure: " + nodeToUpdate.ToString(), NotificationLevel.Error);
    237201                nodeToUpdate.Reset();
     
    248212        private static void UpdateLeafFromDht(Leaf nodeToUpdate, BinaryReader binaryReader)
    249213        {
    250             var oldVersionFlag = CheckVersion(binaryReader);
    251 
    252214            try
    253215            {   
     
    257219                    nodeToUpdate.LastReservationDate = date;
    258220                }
    259            
    260 
    261                 if (binaryReader.BaseStream.Length - binaryReader.BaseStream.Position >= 8)
    262                 {
    263                     nodeToUpdate.setClientIdentifier(binaryReader.ReadInt64());
    264                 }
    265                 else
     221                nodeToUpdate.setClientIdentifier(binaryReader.ReadInt64());
     222            }
     223            catch (Exception)
     224            {
     225                throw new Exception();
     226            }           
     227        }
     228
     229        internal static string KeyInDht(NodeBase node)
     230        {
     231            return string.Format("{0}_node_{1}_{2}", node.DistributedJobIdentifier, node.From, node.To);
     232        }
     233
     234        private static int CheckNodeVersion(BinaryReader binaryReader)
     235        {
     236            try
     237            {
     238                //Reading the char and the versionnumber
     239                char magic = binaryReader.ReadChar();
     240                if (magic != 86) //V infront of a Node
    266241                {
    267242                    throw new Exception();
    268243                }
    269             }
    270             catch (Exception)
    271             {
    272                 throw new Exception();
    273             }
    274            
    275         }
    276 
    277         internal static string KeyInDht(NodeBase node)
    278         {
    279             return string.Format("{0}_node_{1}_{2}", node.DistributedJobIdentifier, node.From, node.To);
    280         }
    281 
    282         private static int CheckVersion(BinaryReader binaryReader)
    283         {           
    284             try
    285             {
    286                 //Checking if there's a version in the stream
    287                 int vers = binaryReader.PeekChar();
    288                 if (vers == 86) //V infront of a Leaf
    289                 {
    290                     //Reading the char and the versionnumber
    291                     char magic = binaryReader.ReadChar();
    292                     int versionInUse = binaryReader.ReadInt32();
    293                     //Check if a newer Version is in use
    294                     if (versionInUse > version)
    295                     {
    296                         throw new KeySearcherStopException();
    297                     }
    298                     return versionInUse;
    299                 }
    300                 else
    301                 {
    302                     return 0;
    303                 }
    304             }
    305             catch(KeySearcherStopException)
    306             {
    307                 throw new KeySearcherStopException();
    308             }           
    309         }
    310 
    311         private static int CheckNodeVersion(BinaryReader binaryReader)
    312         {
    313             try
    314             {
    315                 //Checking if there's a version in the stream
    316                 int vers = binaryReader.PeekChar();
    317                 if (vers == 87) //W infront of a Node
    318                 {
    319                     //Reading the char and the versionnumber
    320                     char magic = binaryReader.ReadChar();
    321                     int versionInUse = binaryReader.ReadInt32();
    322                     //Check if a newer Version is in use
    323                     if (versionInUse > version)
    324                     {
    325                         throw new KeySearcherStopException();
    326                     }
    327                     return versionInUse;
    328                 }
    329                 else
    330                 {
    331                     return 0;
    332                 }
     244                var versionInUse = binaryReader.ReadInt32();
     245                if (versionInUse > version) //Check if a newer Version is in use
     246                {
     247                    throw new KeySearcherStopException();
     248                }
     249                return versionInUse;
    333250            }
    334251            catch (KeySearcherStopException)
Note: See TracChangeset for help on using the changeset viewer.