Changeset 1634


Ignore:
Timestamp:
Jun 14, 2010, 1:23:24 PM (11 years ago)
Author:
Paul Lelgemann
Message:

o Fixed KeySearcher progress display
+ Work on the distributed KeySearcher part

Location:
trunk
Files:
11 added
10 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypP2P/Internal/P2PBase.cs

    r1616 r1634  
    399399
    400400            responseWait.success = storeResult.Status == OperationStatus.Success;
     401            responseWait.operationStatus = storeResult.Status;
    401402            responseWait.Message = Encoding.UTF8.GetBytes(storeResult.Status.ToString());
    402403
    403404            // unblock WaitHandle in the synchronous method
    404405            responseWait.WaitHandle.Set();
    405 
    406             LogToMonitor("Received and handled OnSynchStoreCompleted.");
    407406        }
    408407
     
    441440            }
    442441
    443             LogToMonitor("Received retrieve callback, local ThreadId: " + Thread.CurrentThread.ManagedThreadId);
    444 
    445442            switch (retrieveResult.Status)
    446443            {
     
    459456            }
    460457
     458            responseWait.operationStatus = retrieveResult.Status;
     459
    461460            // unblock WaitHandle in the synchronous method
    462461            responseWait.WaitHandle.Set();
    463 
    464             LogToMonitor("Received and handled OnSynchRetrieveCompleted.");
    465462        }
    466463
     
    499496            }
    500497
    501             responseWait.success = removeResult.Status == OperationStatus.Success;
     498            responseWait.success = removeResult.Status != OperationStatus.Failure &&
     499                                   removeResult.Status != OperationStatus.VersionMismatch;
     500            responseWait.operationStatus = removeResult.Status;
    502501            responseWait.Message = Encoding.UTF8.GetBytes(removeResult.Status.ToString());
    503502
    504503            // unblock WaitHandle in the synchronous method
    505504            responseWait.WaitHandle.Set();
    506 
    507             LogToMonitor("Received and handled OnSynchRemoveCompleted.");
    508505        }
    509506
  • trunk/CrypPlugins/KeySearcher/KeyPatternPool.cs

    r1606 r1634  
    247247        }
    248248
     249        [Obsolete("Only for first version of Christian Arnolds plugin needed, use length!")]
    249250        public long Count()
    250251        {
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r1456 r1634  
    22using System.Linq;
    33using System.Text;
     4using Cryptool.P2P;
    45using Cryptool.PluginBase.Analysis;
    56using Cryptool.PluginBase;
     
    1516using Cryptool.PluginBase.IO;
    1617using System.Numerics;
     18using KeySearcher.Helper;
     19using KeySearcher.P2P;
    1720
    1821namespace KeySearcher
     
    3336        private Mutex maxThreadMutex = new Mutex();
    3437
     38        private KeyQualityHelper _keyQualityHelper;
     39
    3540        private KeyPattern pattern = null;
    3641        public KeyPattern Pattern
     
    4853        }
    4954
    50         private bool stop;
     55        internal bool stop;
    5156
    5257        #region IControlEncryption + IControlCost + InputFields
     
    9095            {
    9196                costMaster = value;
     97                _keyQualityHelper = new KeyQualityHelper(costMaster);
    9298            }
    9399        }
     
    199205
    200206        private KeySearcherSettings settings;
     207        private AutoResetEvent _connectResetEvent;
    201208
    202209        public KeySearcher()
     
    204211            settings = new KeySearcherSettings(this);
    205212            QuickWatchPresentation = new KeySearcherQuickWatchPresentation();
    206            
    207213        }
    208214
     
    231237        {
    232238            //either byte[] CStream input or CryptoolStream Object input
    233             if (this.encryptedData != null || this.csEncryptedData != null) //to prevent execution on initialization
    234             {
    235                 if (this.ControlMaster != null)
    236                     this.process(this.ControlMaster);
     239            if (encryptedData != null || csEncryptedData != null) //to prevent execution on initialization
     240            {
     241                if (ControlMaster != null)
     242                    process(ControlMaster);
    237243                else
    238244                {
     
    533539            }
    534540            Pattern.WildcardKey = settings.Key;
    535             bruteforcePattern(Pattern, sender);
    536         }
     541            this.sender = sender;
     542
     543            bruteforcePattern(Pattern);
     544        }
     545
     546        internal LinkedList<ValueKey> costList = new LinkedList<ValueKey>();
     547        private int bytesToUse;
     548        private IControlEncryption sender;
     549        private DateTime beginBruteforcing;
    537550
    538551        // modified by Christian Arnold 2009.12.07 - return type LinkedList (top10List)
    539552        // main entry point to the KeySearcher
    540         private LinkedList<ValueKey> bruteforcePattern(KeyPattern pattern, IControlEncryption sender)
     553        private LinkedList<ValueKey> bruteforcePattern(KeyPattern pattern)
    541554        {
    542555            //For evaluation issues - added by Arnold 2010.03.17
    543             DateTime beginBruteforcing = DateTime.Now;
     556            beginBruteforcing = DateTime.Now;
    544557            GuiLogMessage("Start bruteforcing pattern '" + pattern.getKey() + "'", NotificationLevel.Debug);
    545558
     
    547560                       
    548561            int maxInList = 10;
    549             LinkedList<ValueKey> costList = new LinkedList<ValueKey>();
     562            costList = new LinkedList<ValueKey>();
    550563            fillListWithDummies(maxInList, costList);
     564            valuequeue = Queue.Synchronized(new Queue());
    551565
    552566            stop = false;
     
    557571            }
    558572
    559             int bytesToUse = 0;
     573            bytesToUse = 0;
    560574
    561575            try
     
    569583            }
    570584
     585            if (settings.UsePeerToPeer)
     586            {
     587                BruteForceWithPeerToPeerSystem();
     588                return null;
     589            }
     590
     591            return BruteForceWithLocalSystem(pattern);
     592        }
     593
     594        private Dispatcher _dispatcher;
     595
     596        private void BruteForceWithPeerToPeerSystem()
     597        {
     598            _dispatcher = Dispatcher.CurrentDispatcher;
     599            GuiLogMessage("Launching p2p based bruteforce logic...", NotificationLevel.Info);
     600            ValidateConnectionToPeerToPeerSystem();
     601            new P2PBruteForce(this, pattern, settings, _keyQualityHelper);
     602        }
     603
     604
     605        #region P2P connection validation
     606
     607        private void ValidateConnectionToPeerToPeerSystem()
     608        {
     609            if (P2PManager.IsConnected)
     610            {
     611                return;
     612            }
     613
     614            if(settings.AutoconnectPeerToPeer)
     615            {
     616                HandleAutoconnect();
     617            } else
     618            {
     619                GuiLogMessage("P2P network not connected and autoconnect disabled. Cannot compute job.",
     620                              NotificationLevel.Error);
     621            }
     622        }
     623
     624        private void HandleAutoconnect()
     625        {
     626            P2PManager.ConnectionManager.OnP2PConnectionStateChangeOccurred += HandleConnectionStateChange;
     627            _connectResetEvent = new AutoResetEvent(false);
     628
     629            P2PManager.Connect();
     630
     631            _connectResetEvent.WaitOne();
     632
     633            if (P2PManager.IsConnected)
     634            {
     635                GuiLogMessage("P2P network was connected due to plugin setting.",
     636                              NotificationLevel.Info);
     637            }
     638            else
     639            {
     640                GuiLogMessage("P2P network could not be connected.",
     641                              NotificationLevel.Error);
     642                throw new ApplicationException("Workaround for wrong error handling... Workspace should be stopped now.");
     643            }
     644        }
     645
     646        void HandleConnectionStateChange(object sender, bool newState)
     647        {
     648            _connectResetEvent.Set();
     649        }
     650
     651        #endregion
     652
     653        internal LinkedList<ValueKey> BruteForceWithLocalSystem(KeyPattern pattern)
     654        {
    571655            BigInteger size = pattern.size();
    572656            KeyPattern[] patterns = splitPatternForThreads(pattern);
    573 
    574             valuequeue = Queue.Synchronized(new Queue());
    575657
    576658            BigInteger[] doneKeysA = new BigInteger[patterns.Length];
     
    585667                Thread.Sleep(1000);
    586668
    587                 updateToplist(costList);
     669                updateToplist();
    588670
    589671                #region calculate global counters from local counters
     
    670752        }
    671753
    672         private void showProgress(LinkedList<ValueKey> costList, BigInteger size, BigInteger keycounter, BigInteger doneKeys)
     754        internal void showProgress(LinkedList<ValueKey> costList, BigInteger size, BigInteger keycounter, BigInteger doneKeys)
    673755        {
    674756            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
    675757
    676758            LinkedListNode<ValueKey> linkedListNode;
    677             ProgressChanged((double)(keycounter/size), 1.0);
     759            ProgressChanged((double)keycounter / (double) size, 1.0);
    678760
    679761            if (QuickWatchPresentation.IsVisible && doneKeys != 0 && !stop)
     
    791873        }
    792874
    793         private void updateToplist(LinkedList<ValueKey> costList)
     875        internal void IntegrateNewResults(LinkedList<ValueKey> costList)
     876        {
     877            foreach (var valueKey in costList)
     878            {
     879                if (_keyQualityHelper.IsBetter(valueKey.value, value_threshold))
     880                {
     881                    valuequeue.Enqueue(valueKey);
     882                }
     883            }
     884
     885            updateToplist();
     886            UpdateWithShowProgress();
     887        }
     888
     889        internal void updateToplist()
    794890        {
    795891            LinkedListNode<ValueKey> node;
     
    797893            {
    798894                ValueKey vk = (ValueKey)valuequeue.Dequeue();
     895
     896                //if (costList.Contains(vk)) continue;
     897                var result = costList.Where(valueKey => valueKey.key == vk.key);
     898                if (result.Count() > 0)
     899                {
     900                    continue;
     901                }
     902
    799903                if (this.costMaster.getRelationOperator() == RelationOperator.LargerThen)
    800904                {
     
    838942                }
    839943            }
     944        }
     945
     946        private void UpdateWithShowProgress()
     947        {
     948            showProgress(costList, 1, 0, 0);
    840949        }
    841950
     
    9191028            this.initVector = initVector;
    9201029            /* End: New stuff because of changing the IControl data flow - Arnie 2010.01.18 */
    921            
    922             LinkedList<ValueKey> lstRet = bruteforcePattern(pattern, encryptControl);
     1030
     1031            this.sender = encryptControl;
     1032            LinkedList<ValueKey> lstRet = bruteforcePattern(pattern);
    9231033            if(OnBruteforcingEnded != null)
    9241034                OnBruteforcingEnded(lstRet);
  • trunk/CrypPlugins/KeySearcher/KeySearcher.csproj

    r1585 r1634  
    103103  </ItemGroup>
    104104  <ItemGroup>
     105    <Compile Include="Helper\KeyQualityHelper.cs" />
    105106    <Compile Include="KeyPattern.cs" />
    106107    <Compile Include="KeyPatternPool.cs" />
     
    110111    </Compile>
    111112    <Compile Include="KeySearcherSettings.cs" />
     113    <Compile Include="P2P\KeyPoolTree.cs" />
     114    <Compile Include="P2P\Nodes\Leaf.cs" />
     115    <Compile Include="P2P\Nodes\Node.cs" />
     116    <Compile Include="P2P\Nodes\NodeBase.cs" />
     117    <Compile Include="P2P\Nodes\NodeFactory.cs" />
     118    <Compile Include="P2P\Nodes\P2PHelper.cs" />
     119    <Compile Include="P2P\P2PBruteForce.cs" />
    112120    <Compile Include="Properties\AssemblyInfo.cs" />
    113121    <Compile Include="Wildcard.cs" />
    114122  </ItemGroup>
    115123  <ItemGroup>
     124    <ProjectReference Include="..\..\CrypP2P\CrypP2P.csproj">
     125      <Project>{7D3E4C88-7EA8-45EA-AC1E-FC8ED8EDDB7A}</Project>
     126      <Name>CrypP2P</Name>
     127      <Private>True</Private>
     128    </ProjectReference>
    116129    <ProjectReference Include="..\..\CrypPluginBase\CrypPluginBase.csproj">
    117130      <Project>{25DB2B47-A457-4EC2-960B-395CE07AE093}</Project>
  • trunk/CrypPlugins/KeySearcher/KeySearcherSettings.cs

    r952 r1634  
    1313        private KeySearcher keysearcher;
    1414        private int coresUsed;
     15        private const string GroupPeerToPeer = "Peer-to-Peer network";
    1516
    1617        public KeySearcherSettings(KeySearcher ks)
     
    2122                CoresAvailable.Add((i + 1).ToString());
    2223            CoresUsed = Environment.ProcessorCount - 1;
     24
     25            distributedJobIdentifier = Guid.NewGuid().ToString();
    2326        }
    2427
     
    3740                if (!(keysearcher.Pattern != null && keysearcher.Pattern.testWildcardKey(value)))
    3841                    keysearcher.GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
     42                HasChanges = true;
    3943            }
    4044        }
     
    6165        }
    6266
     67        private bool usePeerToPeer;
     68        [TaskPane("Use Peer-to-Peer network", "Distributes the operation on available peers by using the built-in peer-to-peer network.", GroupPeerToPeer, 0, false, DisplayLevel.Beginner,
     69            ControlType.CheckBox)]
     70        public bool UsePeerToPeer
     71        {
     72            get { return usePeerToPeer; }
     73            set
     74            {
     75                if (value != usePeerToPeer)
     76                {
     77                    usePeerToPeer = value;
     78                    OnPropertyChanged("UsePeerToPeer");
     79                    HasChanges = true;
     80                }
     81            }
     82        }
     83
     84        private bool autoconnectPeerToPeer;
     85        [TaskPane("Autoconnect network", "Establish a connection to the network if the workspace is started without the background connection being active.", GroupPeerToPeer, 1, false, DisplayLevel.Beginner,
     86            ControlType.CheckBox)]
     87        public bool AutoconnectPeerToPeer
     88        {
     89            get { return autoconnectPeerToPeer; }
     90            set
     91            {
     92                if (value != autoconnectPeerToPeer)
     93                {
     94                    autoconnectPeerToPeer = value;
     95                    OnPropertyChanged("AutoconnectPeerToPeer");
     96                    HasChanges = true;
     97                }
     98            }
     99        }
     100
     101        private string distributedJobIdentifier;
     102        [TaskPane("Job identifier", "Arbitrary description, that allows other peers to join this calculation.", GroupPeerToPeer, 2, false, DisplayLevel.Professional,
     103            ControlType.TextBox)]
     104        public string DistributedJobIdentifier
     105        {
     106            get { return distributedJobIdentifier; }
     107            set
     108            {
     109                if (value != distributedJobIdentifier)
     110                {
     111                    distributedJobIdentifier = value;
     112                    OnPropertyChanged("DistributedJobIdentifier");
     113                    HasChanges = true;
     114                }
     115            }
     116        }
     117
     118        private int chunkSize;
     119        [TaskPane("Chunk size", "Amount of keys (x 10.000), that will be calculated by one peer at a time.", GroupPeerToPeer, 3, false, DisplayLevel.Professional,
     120            ControlType.NumericUpDown, ValidationType.RangeInteger, 250, int.MaxValue)]
     121        public int ChunkSize
     122        {
     123            get { return chunkSize; }
     124            set
     125            {
     126                if (value != chunkSize)
     127                {
     128                    chunkSize = value;
     129                    OnPropertyChanged("ChunkSize");
     130                    HasChanges = true;
     131                }
     132            }
     133        }
     134
    63135        private ObservableCollection<string> coresAvailable = new ObservableCollection<string>();
    64136        public ObservableCollection<string> CoresAvailable
     
    74146            }
    75147        }
    76        
     148
    77149        #region ISettings Members
    78150
  • trunk/CrypPlugins/P2PEditor/GUI/Controls/JobDisplay.xaml.cs

    r1616 r1634  
    6262        void RefreshListTimerElapsed(object sender, ElapsedEventArgs e)
    6363        {
     64            if (!IsVisible)
     65            {
     66                return;
     67            }
     68
    6469            Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(UpdateJobList));
    6570        }
  • trunk/CrypPlugins/P2PEditor/GUI/P2PEditorPresentation.xaml.cs

    r1619 r1634  
    7373            if (P2PManager.IsConnected)
    7474            {
    75                 ShowActiveJobs();
     75                Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(ShowActiveJobs));
    7676            }
    7777            else
    7878            {
    79                 ShowConnectTab();
     79                Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(ShowConnectTab));
    8080            }
    8181        }
     
    101101        private void UpdateDisplay()
    102102        {
    103             UpdateConnectionState();
    104             ActiveJobsControl.UpdateJobList();
     103            Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(UpdateConnectionState));
     104            Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(ActiveJobsControl.UpdateJobList));
    105105        }
    106106
  • trunk/CrypPlugins/PeerToPeer/PeerToPeer.csproj

    r1498 r1634  
    9191    <Compile Include="DHT_CommonManagement.cs" />
    9292    <Compile Include="IP2PControl.cs" />
    93     <Compile Include="KeySearcherResult.cs" />
    9493    <Compile Include="PeedId.cs" />
    9594    <Compile Include="Properties\AssemblyInfo.cs" />
     
    118117      <Name>CrypPluginBase</Name>
    119118    </ProjectReference>
    120     <ProjectReference Include="..\KeySearcher\KeySearcher.csproj">
    121       <Project>{0579E099-66B2-43C3-B8A0-43CAE4895E68}</Project>
    122       <Name>KeySearcher</Name>
    123       <Private>False</Private>
    124     </ProjectReference>
    125119  </ItemGroup>
    126120  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/CrypPlugins/PeerToPeer/ResponseWait.cs

    r1458 r1634  
    11using System.Threading;
     2using PeersAtPlay.P2PStorage.DHT;
    23
    34namespace Cryptool.Plugins.PeerToPeer.Internal
     
    1112        public bool success;
    1213        public byte[] value;
     14        public OperationStatus operationStatus;
    1315    }
    1416}
  • trunk/CrypPlugins/PeerToPeerBaseProxy/P2PPeer.cs

    r1616 r1634  
    2222using Cryptool.P2P;
    2323using Cryptool.P2P.Internal;
    24 using Cryptool.P2P.Worker;
    2524using Cryptool.PluginBase;
    2625using Cryptool.PluginBase.Control;
Note: See TracChangeset for help on using the changeset viewer.