Changeset 2142


Ignore:
Timestamp:
Dec 1, 2010, 11:59:21 AM (11 years ago)
Author:
nolte
Message:

Full working Versionnumber code added.
INFO: THE UNCOMMENTED UPDATE WILL BE COMITTED THURSDAY 8PM (20Uhr :P )
PLEASE UPDATE YOUR SVN AFTERWARDS!

Location:
trunk/CrypPlugins
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/KeySearcher/P2P/DistributedBruteForceManager.cs

    r2122 r2142  
    7373
    7474            status.CurrentOperation = "Initializing distributed key pool tree";
    75             keyPoolTree = new KeyPoolTree(patternPool, keySearcher, keyQualityHelper, keyGenerator, status, StatisticsGenerator);
     75            try
     76            {
     77                keyPoolTree = new KeyPoolTree(patternPool, keySearcher, keyQualityHelper, keyGenerator, status, StatisticsGenerator);
     78            }
     79            catch (KeySearcherStopException)
     80            {
     81                status.CurrentOperation = "PLEASE UPDATE";
     82                keySearcher.GuiLogMessage("Keysearcher Fullstop.Please Update your Version.", NotificationLevel.Error);
     83                keySearcher.Stop();
     84                throw new KeySearcherStopException();
     85            }
     86           
    7687
    7788            keySearcher.GuiLogMessage(
     
    111122                catch (KeySearcherStopException)  //Fullstopfunction
    112123                {
    113                     keySearcher.GuiLogMessage("Keysearcher Fullstop.", NotificationLevel.Error);
    114                     keySearcher.GuiLogMessage("Please Update your Version.", NotificationLevel.Error);
    115                     keySearcher.stop = true;
     124                    keySearcher.GuiLogMessage("Keysearcher Fullstop.Please Update your Version.", NotificationLevel.Debug);
     125                    keyPoolTree.Reset();
     126                    keySearcher.Stop();
    116127                    return;
    117128                }
     
    238249                    continue;
    239250                }
     251                catch (KeySearcherStopException)  //Fullstopfunction
     252                {
     253                    keySearcher.GuiLogMessage("Keysearcher Fullstop.Please Update your Version.", NotificationLevel.Debug);
     254                    keyPoolTree.Reset();
     255                    keySearcher.Stop();
     256                    return;
     257                }
    240258
    241259                // Push statistics to database
  • trunk/CrypPlugins/KeySearcher/P2P/Storage/StorageHelper.cs

    r2121 r2142  
    33using Cryptool.P2P;
    44using Cryptool.P2P.Internal;
     5using Cryptool.PluginBase;
     6using KeySearcher.P2P.Exceptions;
    57using KeySearcher.P2P.Presentation;
    68using KeySearcher.P2P.Tree;
     
    9799            } else
    98100            {
    99                 UpdateLeafFromDht((Leaf) nodeToUpdate, binaryReader);
     101                try
     102                {
     103                    UpdateLeafFromDht((Leaf)nodeToUpdate, binaryReader);
     104                }
     105                catch(KeySearcherStopException)
     106                {
     107                    throw new KeySearcherStopException();
     108                }
    100109            }
    101110
     
    141150        private static void UpdateLeafFromDht(Leaf nodeToUpdate, BinaryReader binaryReader)
    142151        {
    143             //---------------------------------------------------------------------------------
    144             //TODO: Versionnumber read
    145             //CheckVersion(binaryReader);
    146             //----------------------------------------------------------------------------------
    147            
     152            try
     153            {
     154                //---------------------------------------------------------------------------------
     155                //TODO: Versionnumber read
     156                //CheckVersion(binaryReader);
     157                //----------------------------------------------------------------------------------           
     158            }
     159            catch (KeySearcherStopException)
     160            {
     161                throw new KeySearcherStopException();
     162            }
     163               
    148164            var date = DateTime.FromBinary(binaryReader.ReadInt64());
    149165            if (date > nodeToUpdate.LastReservationDate)
     
    177193
    178194        //----------------------------------------------------------------------------
    179         public static void CheckVersion(BinaryReader binaryReader)
    180         {
    181             /*
     195        private static void CheckVersion(BinaryReader binaryReader)
     196        {           
    182197            try
    183198            {
    184                 //Checking in theres a version in the stream
    185                 if (binaryReader.PeekChar().Equals('V'))
     199                //Checking if there's a version in the stream
     200                int vers = binaryReader.PeekChar();
     201                if (vers == 86)
    186202                {
    187203                    //Reading the char and the versionnumber
    188                     binaryReader.ReadChar();
     204                    char magic = binaryReader.ReadChar();
    189205                    int versionInUse = binaryReader.ReadInt32();
    190206                    //Check if a newer Version is in use
     
    195211                }
    196212            }
    197             catch(Exception)
     213            catch(KeySearcherStopException)
    198214            {
    199215                throw new KeySearcherStopException();
    200216            }
    201             */
     217           
    202218        }
    203219        //-----------------------------------------------------------------------------
  • trunk/CrypPlugins/KeySearcher/P2P/Tree/KeyPoolTree.cs

    r2074 r2142  
    55using KeySearcher.Helper;
    66using KeySearcher.KeyPattern;
     7using KeySearcher.P2P.Exceptions;
    78using KeySearcher.P2P.Presentation;
    89using KeySearcher.P2P.Storage;
     
    99100        private Leaf FindNextLeaf(SearchOption useReservedLeafsOption)
    100101        {
    101             if (currentNode == null)
    102             {
    103                 keySearcher.GuiLogMessage("Inside FindNextLeaf: currentNode is null!", NotificationLevel.Debug);
    104                 return null;
    105             }
    106 
    107             var isReserved = false;
    108             var useReservedLeafs = useReservedLeafsOption == SearchOption.UseReservedLeafs;
    109 
    110             keySearcher.GuiLogMessage("Inside FindNextLeaf: updating currentNode now!", NotificationLevel.Debug);
    111             storageHelper.UpdateFromDht(currentNode, true);
    112             currentNode.UpdateCache();
    113             keySearcher.GuiLogMessage("Inside FindNextLeaf: Now entering while loop!", NotificationLevel.Debug);
    114             while (currentNode.IsCalculated() || (!useReservedLeafs && (isReserved = currentNode.IsReserved())))
    115             {
    116                 if (isReserved)
    117                 {
    118                     keySearcher.GuiLogMessage("Inside FindNextLeaf: currentNode was reserved!", NotificationLevel.Debug);
    119                     skippedReservedNodes = true;
    120                 }
    121                 if (currentNode.IsCalculated())
    122                     keySearcher.GuiLogMessage("Inside FindNextLeaf: currentNode is already calculated!", NotificationLevel.Debug);
    123 
    124                 // Current node is calculated or reserved,
    125                 // move one node up and update it
    126                 keySearcher.GuiLogMessage("Inside FindNextLeaf: set currentNode to its own parent!", NotificationLevel.Debug);
    127                 currentNode = currentNode.ParentNode;
    128 
    129                 // Root node calculated => everything finished
     102            try
     103            {
    130104                if (currentNode == null)
    131105                {
    132                     keySearcher.GuiLogMessage("Inside FindNextLeaf: parent was null, so set currentNode to rootNode!", NotificationLevel.Debug);
    133                     currentNode = rootNode;
     106                    keySearcher.GuiLogMessage("Inside FindNextLeaf: currentNode is null!", NotificationLevel.Debug);
    134107                    return null;
    135108                }
    136109
     110                var isReserved = false;
     111                var useReservedLeafs = useReservedLeafsOption == SearchOption.UseReservedLeafs;
     112
    137113                keySearcher.GuiLogMessage("Inside FindNextLeaf: updating currentNode now!", NotificationLevel.Debug);
    138                 // Update the new _currentNode
    139114                storageHelper.UpdateFromDht(currentNode, true);
    140115                currentNode.UpdateCache();
    141             }
    142 
    143             keySearcher.GuiLogMessage("Inside FindNextLeaf: Exiting loop! Updating currentNode!", NotificationLevel.Debug);
    144             // currentNode is calculateable => find leaf
    145             currentNode.UpdateCache();
    146             return currentNode.CalculatableLeaf(useReservedLeafs);
     116                keySearcher.GuiLogMessage("Inside FindNextLeaf: Now entering while loop!", NotificationLevel.Debug);
     117                while (currentNode.IsCalculated() || (!useReservedLeafs && (isReserved = currentNode.IsReserved())))
     118                {
     119                    if (isReserved)
     120                    {
     121                        keySearcher.GuiLogMessage("Inside FindNextLeaf: currentNode was reserved!", NotificationLevel.Debug);
     122                        skippedReservedNodes = true;
     123                    }
     124                    if (currentNode.IsCalculated())
     125                        keySearcher.GuiLogMessage("Inside FindNextLeaf: currentNode is already calculated!", NotificationLevel.Debug);
     126
     127                    // Current node is calculated or reserved,
     128                    // move one node up and update it
     129                    keySearcher.GuiLogMessage("Inside FindNextLeaf: set currentNode to its own parent!", NotificationLevel.Debug);
     130                    currentNode = currentNode.ParentNode;
     131
     132                    // Root node calculated => everything finished
     133                    if (currentNode == null)
     134                    {
     135                        keySearcher.GuiLogMessage("Inside FindNextLeaf: parent was null, so set currentNode to rootNode!", NotificationLevel.Debug);
     136                        currentNode = rootNode;
     137                        return null;
     138                    }
     139
     140                    keySearcher.GuiLogMessage("Inside FindNextLeaf: updating currentNode now!", NotificationLevel.Debug);
     141                    // Update the new _currentNode
     142                    storageHelper.UpdateFromDht(currentNode, true);
     143                    currentNode.UpdateCache();
     144                }
     145
     146                keySearcher.GuiLogMessage("Inside FindNextLeaf: Exiting loop! Updating currentNode!", NotificationLevel.Debug);
     147                // currentNode is calculateable => find leaf
     148                currentNode.UpdateCache();
     149                return currentNode.CalculatableLeaf(useReservedLeafs);
     150            }
     151            catch (KeySearcherStopException)
     152            {
     153                throw new KeySearcherStopException();
     154            }
    147155        }
    148156
     
    150158        internal bool IsCalculationFinished()
    151159        {
    152             storageHelper.UpdateFromDht(rootNode, true);
    153             return rootNode.IsCalculated();
     160            try
     161            {
     162                storageHelper.UpdateFromDht(rootNode, true);
     163                return rootNode.IsCalculated();
     164            }
     165            catch (KeySearcherStopException)
     166            {
     167                throw new KeySearcherStopException();
     168            }
    154169        }
    155170
  • trunk/CrypPlugins/KeySearcher/P2P/Tree/Leaf.cs

    r2038 r2142  
    6565        public void GiveLeafFree()
    6666        {
    67             StorageHelper.UpdateFromDht((this));
     67            try
     68            {
     69                StorageHelper.UpdateFromDht((this));
     70            }
     71            catch (KeySearcherStopException)
     72            {
     73                throw new KeySearcherStopException();
     74            }         
    6875            //Only give leaf free, if the reservation is still ours:
    6976            if (clientIdentifier == Cryptool.PluginBase.Miscellaneous.UniqueIdentifier.GetID())
  • trunk/CrypPlugins/KeySearcher/P2P/Tree/Node.cs

    r2024 r2142  
    2424        private void LoadOrUpdateChildNodes()
    2525        {
    26             var middle = (From + To)/2;
     26            try
     27            {
     28                var middle = (From + To) / 2;
    2729
    28             if (!LeftChildFinished)
    29             {
    30                 if (leftChild == null)
     30                if (!LeftChildFinished)
    3131                {
    32                     leftChild = NodeFactory.CreateNode(StorageHelper, KeyQualityHelper, this, From, middle,
    33                                                         DistributedJobIdentifier);
     32                    if (leftChild == null)
     33                    {
     34                        leftChild = NodeFactory.CreateNode(StorageHelper, KeyQualityHelper, this, From, middle,
     35                                                            DistributedJobIdentifier);
     36                    }
     37                    else
     38                    {
     39                        StorageHelper.UpdateFromDht(leftChild);
     40                    }
    3441                }
    35                 else
     42
     43                // Only load right node, if the left one is finished or reserved
     44                if ((LeftChildFinished || leftChild.IsReserved()) && !RightChildFinished)
    3645                {
    37                     StorageHelper.UpdateFromDht(leftChild);
     46                    if (rightChild == null)
     47                    {
     48                        rightChild = NodeFactory.CreateNode(StorageHelper, KeyQualityHelper, this, middle + 1, To,
     49                                                             DistributedJobIdentifier);
     50                    }
     51                    else
     52                    {
     53                        StorageHelper.UpdateFromDht(rightChild);
     54                    }
    3855                }
    3956            }
    40 
    41             // Only load right node, if the left one is finished or reserved
    42             if ((LeftChildFinished || leftChild.IsReserved()) && !RightChildFinished)
     57            catch (KeySearcherStopException)
    4358            {
    44                 if (rightChild == null)
    45                 {
    46                     rightChild = NodeFactory.CreateNode(StorageHelper, KeyQualityHelper, this, middle + 1, To,
    47                                                          DistributedJobIdentifier);
    48                 }
    49                 else
    50                 {
    51                     StorageHelper.UpdateFromDht(rightChild);
    52                 }
    53             }
     59                throw new KeySearcherStopException();
     60            }               
    5461        }
    5562
     
    6774        public override void UpdateCache()
    6875        {
    69             LoadOrUpdateChildNodes();
     76            try
     77            {
     78                LoadOrUpdateChildNodes();
     79            }
     80            catch (KeySearcherStopException)
     81            {
     82                throw new KeySearcherStopException();
     83            }
    7084
    7185            leftChildReserved = LeftChildFinished || leftChild.IsReserved();
  • trunk/CrypPlugins/WorkspaceManager/Execution/ExecutionEngine.cs

    r2059 r2142  
    469469            catch (Exception ex)
    470470            {
    471                 this.PluginModel.WorkspaceModel.WorkspaceManagerEditor.GuiLogMessage("An error occured while executing  \"" + PluginModel.Name + "\": " + ex.Message, NotificationLevel.Error);
    472                 this.PluginModel.State = PluginModelState.Error;
    473                 this.PluginModel.GuiNeedsUpdate = true;
    474                 return;
     471                if (ex.Message.Equals("Exception of type 'KeySearcher.P2P.Exceptions.KeySearcherStopException' was thrown."))
     472                {
     473                    //KeysearcherStopExceptions need to shutdown the sheduler. Otherwise the process would start over and over again.
     474                    this.Stop();
     475                    return;
     476                }
     477                else
     478                {
     479                    this.PluginModel.WorkspaceModel.WorkspaceManagerEditor.GuiLogMessage("An error occured while executing  \"" + PluginModel.Name + "\": " + ex.Message, NotificationLevel.Error);
     480                    this.PluginModel.State = PluginModelState.Error;
     481                    this.PluginModel.GuiNeedsUpdate = true;
     482                    return;
     483                }
    475484            }
    476485
Note: See TracChangeset for help on using the changeset viewer.