Changeset 2434


Ignore:
Timestamp:
Jan 23, 2011, 5:36:50 PM (11 years ago)
Author:
Sven Rech
Message:

some changes concerning reconnection (I hope this doesn't make things worse)

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypP2P/Worker/ConnectionWorker.cs

    r2276 r2434  
    1515*/
    1616
     17using System;
    1718using System.ComponentModel;
    1819using Cryptool.P2P.Helper;
     
    4849            {
    4950                P2PManager.GuiLogMessage("Connecting to P2P network...", NotificationLevel.Info);
    50                 p2PBase.Initialize();
    51                 p2PBase.SynchStart();
     51                try
     52                {
     53                    p2PBase.Initialize();
     54                    p2PBase.SynchStart();
     55                }
     56                catch (InvalidOperationException ex)
     57                {
     58                    P2PManager.GuiLogMessage(ex.Message, NotificationLevel.Error);
     59                }
    5260            }
    5361            else
  • trunk/CrypPlugins/KeySearcher/P2P/DistributedBruteForceManager.cs

    r2391 r2434  
    8383            while (!keySearcher.stop)
    8484            {
    85                 if(statupdate)
    86                 {
    87                     statisticTimer.Stop();
    88                     statisticTimer.Dispose();
    89                     keyPoolTree.Reset();
    90                     keySearcher.ResetStatistics();
    91                     keySearcher.SetInitialized(false);
    92                     status.CurrentOperation = Resources.Updating_statistic;
    93                     InitializeTree();
    94                     statupdate = false;
    95                     statisticTimer = new Timer { Interval = 30 * 60 * 1000 };
    96                     statisticTimer.Start();
    97                 }
    98 
    99                 status.IsCurrentProgressIndeterminate = true;
    100 
    101                 BigInteger displayablePatternId;
    10285                try
    10386                {
    104                     status.CurrentOperation = Resources.Finding_next_leaf_to_calculate;
    105                     currentLeaf = keyPoolTree.FindNextLeaf();
    106                     if (currentLeaf == null)
    107                     {
    108                         break;
    109                     }
    110                     displayablePatternId = currentLeaf.PatternId() + 1;
     87                    if (statupdate)
     88                    {
     89                        statisticTimer.Stop();
     90                        statisticTimer.Dispose();
     91                        keyPoolTree.Reset();
     92                        keySearcher.ResetStatistics();
     93                        keySearcher.SetInitialized(false);
     94                        status.CurrentOperation = Resources.Updating_statistic;
     95                        InitializeTree();
     96                        statupdate = false;
     97                        statisticTimer = new Timer { Interval = 30 * 60 * 1000 };
     98                        statisticTimer.Start();
     99                    }
     100
     101                    status.IsCurrentProgressIndeterminate = true;
     102
     103                    BigInteger displayablePatternId;
     104                    try
     105                    {
     106                        status.CurrentOperation = Resources.Finding_next_leaf_to_calculate;
     107                        currentLeaf = keyPoolTree.FindNextLeaf();
     108                        if (currentLeaf == null)
     109                        {
     110                            break;
     111                        }
     112                        displayablePatternId = currentLeaf.PatternId() + 1;
     113                    }
     114                    catch (AlreadyCalculatedException)
     115                    {
     116                        keySearcher.GuiLogMessage(Resources.Node_was_already_calculated_, NotificationLevel.Info);
     117                        keyPoolTree.Reset();
     118                        continue;
     119                    }
     120                    catch (KeySearcherStopException)  //Fullstopfunction
     121                    {
     122                        keySearcher.GuiLogMessage(Resources.Keysearcher_Fullstop__Please_Update_your_Version_, NotificationLevel.Debug);
     123                        status.CurrentOperation = Resources.PLEASE_UPDATE;
     124                        keyPoolTree.Reset();
     125                        keySearcher.Stop();
     126                        return;
     127                    }
     128
     129                    // TODO if reserve returns successfully, start timer to update our reserveration every few minutes
     130                    // if we cannot reacquire our lock in the timer, calculation must be aborted
     131                    if (!currentLeaf.ReserveLeaf())
     132                    {
     133                        keySearcher.GuiLogMessage(
     134                            string.Format(Resources.Pattern___0__was_reserved_before_it_could_be_reserved_for_this_CrypTool_instance_, displayablePatternId),
     135                            NotificationLevel.Info);
     136                        keyPoolTree.Reset();
     137                        continue;
     138                    }
     139
     140                    bool reservationRemoved = false;
     141                    var reservationTimer = new Timer { Interval = 18 * 60 * 1000 };    //Every 18 minutes
     142                    reservationTimer.Elapsed += new ElapsedEventHandler(delegate
     143                                                                            {
     144                                                                                var oldMessage = status.CurrentOperation;
     145                                                                                var message = string.Format(Resources.Rereserving_pattern___0_, displayablePatternId);
     146                                                                                keySearcher.GuiLogMessage(message, NotificationLevel.Info);
     147                                                                                status.CurrentOperation = message;
     148                                                                                try
     149                                                                                {
     150                                                                                    if (!currentLeaf.ReserveLeaf())
     151                                                                                        keySearcher.GuiLogMessage(Resources.Rereserving_pattern_failed_, NotificationLevel.Warning);
     152
     153                                                                                    //if (!currentLeaf.ReserveLeaf())
     154                                                                                    //{
     155                                                                                    //    keySearcher.GuiLogMessage("Rereserving pattern failed! Skipping to next pattern!",
     156                                                                                    //        NotificationLevel.Warning);
     157                                                                                    //    reservationRemoved = true;
     158                                                                                    //    keySearcher.stop = true;
     159                                                                                    //}
     160                                                                                }
     161                                                                                catch (Cryptool.P2P.Internal.NotConnectedException)
     162                                                                                {
     163                                                                                    keySearcher.GuiLogMessage(Resources.Rereserving_pattern_failed__because_there_is_no_connection_,
     164                                                                                            NotificationLevel.Warning);
     165                                                                                    //TODO: Register OnSystemJoined event to rereserve pattern immediately after reconnect
     166                                                                                }
     167                                                                                status.CurrentOperation = oldMessage;
     168                                                                            });
     169
     170                    statisticTimer.Elapsed += new ElapsedEventHandler(delegate
     171                                                                          {
     172                                                                              statupdate = true;
     173                                                                          });
     174
     175                    keySearcher.GuiLogMessage(
     176                        string.Format(Resources.Running_pattern___0__of__1_, displayablePatternId, patternPool.Length),
     177                        NotificationLevel.Info);
     178                    status.CurrentChunk = displayablePatternId;
     179                    status.CurrentOperation = Resources.Calculating_pattern_ + status.CurrentChunk;
     180
     181                    try
     182                    {
     183                        LinkedList<KeySearcher.ValueKey> result;
     184
     185                        status.IsCurrentProgressIndeterminate = false;
     186                        StopWatch.Start();
     187                        reservationTimer.Start();
     188                        try
     189                        {
     190                            result = keySearcher.BruteForceWithLocalSystem(patternPool[currentLeaf.PatternId()], true);
     191                            if (reservationRemoved)
     192                            {
     193                                keySearcher.stop = false;
     194                                throw new ReservationRemovedException("");
     195                            }
     196                        }
     197                        finally
     198                        {
     199                            reservationTimer.Stop();
     200                            reservationTimer.Dispose();
     201                            StopWatch.Stop();
     202                            status.IsCurrentProgressIndeterminate = true;
     203                        }
     204
     205                        if (!keySearcher.stop)
     206                        {
     207                            if (!P2PManager.IsConnected)
     208                            {
     209                                status.CurrentOperation = Resources.Connection_lost__Waiting_for_reconnection_to_store_the_results_;
     210                                keySearcher.GuiLogMessage(status.CurrentOperation, NotificationLevel.Info);
     211
     212                                P2PManager.P2PBase.OnSystemJoined += P2PBase_OnSystemJoined;
     213                                systemJoinEvent.WaitOne();
     214                            }
     215                            status.CurrentOperation = Resources.Processing_results_of_calculation;
     216                            KeyPoolTree.ProcessCurrentPatternCalculationResult(currentLeaf, result);
     217                            StatisticsGenerator.ProcessPatternResults(result);
     218
     219                            status.CurrentOperation = Resources.Calculating_global_statistics;
     220                            StatisticsGenerator.CalculateGlobalStatistics(displayablePatternId);
     221
     222                            status.LocalFinishedChunks++;
     223                            keySearcher.GuiLogMessage(
     224                                string.Format(Resources.Best_match___0__with__1_, result.First.Value.key, result.First.Value.value),
     225                                NotificationLevel.Info);
     226
     227                            status.CurrentOperation = Resources.Updating_status_in_DHT;
     228                            keyPoolTree.UpdateStatus(currentLeaf);
     229                        }
     230                        else
     231                        {
     232                            keySearcher.GuiLogMessage(Resources.Brute_force_was_stopped__not_saving_results___,
     233                                                      NotificationLevel.Info);
     234                            status.ProgressOfCurrentChunk = 0;
     235                            currentLeaf.GiveLeafFree();
     236                            var message = string.Format(Resources.Removed_reservation_of_pattern___0_, displayablePatternId);
     237                            keySearcher.GuiLogMessage(message, NotificationLevel.Info);
     238                            status.CurrentOperation = message;
     239                        }
     240                    }
     241                    catch (ReservationRemovedException)
     242                    {
     243                        keySearcher.GuiLogMessage(Resources.Reservation_removed_by_another_node__while_calculating___To_avoid_a_state_in_limbo__proceeding_to_first_available_leaf___,
     244                                                  NotificationLevel.Info);
     245                        keyPoolTree.Reset();
     246                        continue;
     247                    }
     248                    catch (UpdateFailedException e)
     249                    {
     250                        keySearcher.GuiLogMessage(Resources.Could_not_store_results__ + e.Message, NotificationLevel.Info);
     251                        keyPoolTree.Reset();
     252                        continue;
     253                    }
     254                    catch (KeySearcherStopException)  //Fullstopfunction
     255                    {
     256                        keySearcher.GuiLogMessage(Resources.Keysearcher_Fullstop__Please_Update_your_Version_, NotificationLevel.Debug);
     257                        status.CurrentOperation = Resources.PLEASE_UPDATE;
     258                        keyPoolTree.Reset();
     259                        keySearcher.Stop();
     260                        return;
     261                    }
     262
     263                    // Push statistics to database
     264                    status.CurrentOperation = Resources.Pushing_statistics_to_evaluation_database;
     265                    DatabaseStatistics.PushToDatabase(status, StopWatch.ElapsedMilliseconds, keyPoolTree.Identifier, settings, keySearcher);
    111266                }
    112                 catch (AlreadyCalculatedException)
     267                catch (NotConnectedException)
    113268                {
    114                     keySearcher.GuiLogMessage(Resources.Node_was_already_calculated_, NotificationLevel.Info);
    115                     keyPoolTree.Reset();
    116                     continue;
     269                    status.CurrentOperation = "Connection lost. Waiting for reconnect...";
     270                    keySearcher.GuiLogMessage(status.CurrentOperation, NotificationLevel.Info);
     271                           
     272                    P2PManager.P2PBase.OnSystemJoined += P2PBase_OnSystemJoined;
     273                    systemJoinEvent.WaitOne();
    117274                }
    118                 catch (KeySearcherStopException)  //Fullstopfunction
    119                 {
    120                     keySearcher.GuiLogMessage(Resources.Keysearcher_Fullstop__Please_Update_your_Version_, NotificationLevel.Debug);
    121                     status.CurrentOperation = Resources.PLEASE_UPDATE;
    122                     keyPoolTree.Reset();
    123                     keySearcher.Stop();
    124                     return;
    125                 }
    126 
    127                 // TODO if reserve returns successfully, start timer to update our reserveration every few minutes
    128                 // if we cannot reacquire our lock in the timer, calculation must be aborted
    129                 if (!currentLeaf.ReserveLeaf())
    130                 {
    131                     keySearcher.GuiLogMessage(
    132                         string.Format(Resources.Pattern___0__was_reserved_before_it_could_be_reserved_for_this_CrypTool_instance_, displayablePatternId),
    133                         NotificationLevel.Info);
    134                     keyPoolTree.Reset();
    135                     continue;
    136                 }
    137 
    138                 bool reservationRemoved = false;
    139                 var reservationTimer = new Timer {Interval = 18*60*1000};    //Every 18 minutes
    140                 reservationTimer.Elapsed += new ElapsedEventHandler(delegate
    141                                                                         {
    142                                                                             var oldMessage = status.CurrentOperation;
    143                                                                             var message = string.Format(Resources.Rereserving_pattern___0_, displayablePatternId);
    144                                                                             keySearcher.GuiLogMessage(message, NotificationLevel.Info);
    145                                                                             status.CurrentOperation = message;
    146                                                                             try
    147                                                                             {
    148                                                                                 if (!currentLeaf.ReserveLeaf())
    149                                                                                     keySearcher.GuiLogMessage(Resources.Rereserving_pattern_failed_, NotificationLevel.Warning);
    150 
    151                                                                                 //if (!currentLeaf.ReserveLeaf())
    152                                                                                 //{
    153                                                                                 //    keySearcher.GuiLogMessage("Rereserving pattern failed! Skipping to next pattern!",
    154                                                                                 //        NotificationLevel.Warning);
    155                                                                                 //    reservationRemoved = true;
    156                                                                                 //    keySearcher.stop = true;
    157                                                                                 //}
    158                                                                             }
    159                                                                             catch (Cryptool.P2P.Internal.NotConnectedException)
    160                                                                             {
    161                                                                                 keySearcher.GuiLogMessage(Resources.Rereserving_pattern_failed__because_there_is_no_connection_,
    162                                                                                         NotificationLevel.Warning);
    163                                                                                 //TODO: Register OnSystemJoined event to rereserve pattern immediately after reconnect
    164                                                                             }
    165                                                                             status.CurrentOperation = oldMessage;
    166                                                                         });
    167 
    168                 statisticTimer.Elapsed += new ElapsedEventHandler(delegate
    169                                                                       {
    170                                                                           statupdate = true;
    171                                                                       });
    172 
    173                 keySearcher.GuiLogMessage(
    174                     string.Format(Resources.Running_pattern___0__of__1_, displayablePatternId, patternPool.Length),
    175                     NotificationLevel.Info);
    176                 status.CurrentChunk = displayablePatternId;
    177                 status.CurrentOperation = Resources.Calculating_pattern_ + status.CurrentChunk;
    178 
    179                 try
    180                 {
    181                     LinkedList<KeySearcher.ValueKey> result;
    182 
    183                     status.IsCurrentProgressIndeterminate = false;
    184                     StopWatch.Start();
    185                     reservationTimer.Start();
    186                     try
    187                     {
    188                         result = keySearcher.BruteForceWithLocalSystem(patternPool[currentLeaf.PatternId()], true);
    189                         if (reservationRemoved)
    190                         {
    191                             keySearcher.stop = false;
    192                             throw new ReservationRemovedException("");
    193                         }
    194                     }
    195                     finally
    196                     {
    197                         reservationTimer.Stop();
    198                         reservationTimer.Dispose();
    199                         StopWatch.Stop();
    200                         status.IsCurrentProgressIndeterminate = true;
    201                     }
    202 
    203                     if (!keySearcher.stop)
    204                     {
    205                         if (!P2PManager.IsConnected)
    206                         {
    207                             status.CurrentOperation = Resources.Connection_lost__Waiting_for_reconnection_to_store_the_results_;
    208                             keySearcher.GuiLogMessage(status.CurrentOperation, NotificationLevel.Info);
    209                            
    210                             P2PManager.P2PBase.OnSystemJoined += new P2PBase.SystemJoined(P2PBase_OnSystemJoined);
    211                             systemJoinEvent.WaitOne();
    212                         }
    213                         status.CurrentOperation = Resources.Processing_results_of_calculation;
    214                         KeyPoolTree.ProcessCurrentPatternCalculationResult(currentLeaf, result);
    215                         StatisticsGenerator.ProcessPatternResults(result);
    216 
    217                         status.CurrentOperation = Resources.Calculating_global_statistics;
    218                         StatisticsGenerator.CalculateGlobalStatistics(displayablePatternId);
    219 
    220                         status.LocalFinishedChunks++;
    221                         keySearcher.GuiLogMessage(
    222                             string.Format(Resources.Best_match___0__with__1_, result.First.Value.key, result.First.Value.value),
    223                             NotificationLevel.Info);
    224 
    225                         status.CurrentOperation = Resources.Updating_status_in_DHT;
    226                         keyPoolTree.UpdateStatus(currentLeaf);
    227                     }
    228                     else
    229                     {
    230                         keySearcher.GuiLogMessage(Resources.Brute_force_was_stopped__not_saving_results___,
    231                                                   NotificationLevel.Info);
    232                         status.ProgressOfCurrentChunk = 0;
    233                         currentLeaf.GiveLeafFree();
    234                         var message = string.Format(Resources.Removed_reservation_of_pattern___0_, displayablePatternId);
    235                         keySearcher.GuiLogMessage(message, NotificationLevel.Info);
    236                         status.CurrentOperation = message;
    237                     }
    238                 }
    239                 catch (ReservationRemovedException)
    240                 {
    241                     keySearcher.GuiLogMessage(Resources.Reservation_removed_by_another_node__while_calculating___To_avoid_a_state_in_limbo__proceeding_to_first_available_leaf___,
    242                                               NotificationLevel.Info);
    243                     keyPoolTree.Reset();
    244                     continue;
    245                 }
    246                 catch (UpdateFailedException e)
    247                 {
    248                     keySearcher.GuiLogMessage(Resources.Could_not_store_results__ + e.Message, NotificationLevel.Info);
    249                     keyPoolTree.Reset();
    250                     continue;
    251                 }
    252                 catch (KeySearcherStopException)  //Fullstopfunction
    253                 {
    254                     keySearcher.GuiLogMessage(Resources.Keysearcher_Fullstop__Please_Update_your_Version_, NotificationLevel.Debug);
    255                     status.CurrentOperation = Resources.PLEASE_UPDATE;
    256                     keyPoolTree.Reset();
    257                     keySearcher.Stop();
    258                     return;
    259                 }
    260 
    261                 // Push statistics to database
    262                 status.CurrentOperation = Resources.Pushing_statistics_to_evaluation_database;
    263                 DatabaseStatistics.PushToDatabase(status, StopWatch.ElapsedMilliseconds, keyPoolTree.Identifier, settings, keySearcher);
    264275            }
    265276
Note: See TracChangeset for help on using the changeset viewer.