Changeset 813


Ignore:
Timestamp:
Nov 2, 2009, 7:35:09 PM (12 years ago)
Author:
arnold
Message:

P2P Classes updated (Remove, Base) and removed old P2P Classes (P2PStore, P2PLoad)

Location:
trunk/CrypPlugins
Files:
2 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/Caesar/Caesar.csproj

    r281 r813  
    44    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    55    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    6     <ProductVersion>9.0.30729</ProductVersion>
     6    <ProductVersion>9.0.21022</ProductVersion>
    77    <SchemaVersion>2.0</SchemaVersion>
    88    <ProjectGuid>{AFBEAA94-3998-4C4A-805F-670ECF12029E}</ProjectGuid>
     
    8585  <ItemGroup>
    8686    <EmbeddedResource Include="Resources\res.de-DE.resx">
     87      <SubType>Designer</SubType>
    8788    </EmbeddedResource>
    8889    <EmbeddedResource Include="Resources\res.resx">
     90      <SubType>Designer</SubType>
    8991    </EmbeddedResource>
    9092  </ItemGroup>
  • trunk/CrypPlugins/PeerToPeerBase/IP2PControl.cs

    r789 r813  
    55
    66namespace Cryptool.PluginBase.Control
    7 {   
     7{
     8    #region P2P Initialisation Enums
     9    public enum P2PLinkManagerType
     10    {
     11        Snal
     12    }
     13
     14    public enum P2PBootstrapperType
     15    {
     16        LocalMachineBootstrapper,
     17        IrcBootstrapper
     18    }
     19
     20    public enum P2POverlayType
     21    {
     22        FullMeshOverlay
     23    }
     24
     25    public enum P2PDHTType
     26    {
     27        FullMeshDHT
     28    }
     29    #endregion
     30
    831    public interface IP2PControl : IControl
    932    {
     
    1134        byte[] DHTload(string sKey);
    1235        bool DHTremove(string sKey);
     36
     37        string GetPeerName();
    1338
    1439        /// <summary>
  • trunk/CrypPlugins/PeerToPeerBase/P2PPeer.cs

    r794 r813  
    2525using Cryptool.PluginBase.IO;
    2626
     27/*
     28 * TODO:
     29 * - Events des Start- und Stop-Button aus Settings auffangen und entsprechend
     30 *   Peer starten/stoppen. Natürlich auch Behandlung, daß nach START spätestens
     31 *   der Peer gestartet wird...
     32 */
     33
    2734namespace Cryptool.Plugins.PeerToPeer
    2835{
     
    4653            this.p2pBase = new P2PBase();
    4754            this.settings = new P2PPeerSettings(p2pBase);
     55            this.settings.TaskPaneAttributeChanged += new TaskPaneAttributeChangedHandler(settings_TaskPaneAttributeChanged);
     56        }
     57
     58        void settings_TaskPaneAttributeChanged(ISettings settings, TaskPaneAttributeChangedEventArgs args)
     59        {
     60            //throw new NotImplementedException();
    4861        }
    4962
     
    8194            else
    8295            {
    83                 this.p2pBase.Initialize(settings.P2PPeerName, settings.P2PWorldName);
    84                 this.p2pBase.SynchStart();
     96                // TODO: When started on PreExecution hide Start-Button of Settings and set Stop-Button to visible!
     97                if (!settings.PeerStarted)
     98                {
     99                    // starts peer in the settings class
     100                    this.settings.PeerStarted = true;
     101                    //this.p2pBase.InitializeAll(settings.P2PPeerName, settings.P2PWorldName, settings.P2PLinkMngrType, settings.P2PBSType, settings.P2POverlType, settings.P2PDhtType);
     102                }
     103
     104                //this.p2pBase.Initialize(settings.P2PPeerName, settings.P2PWorldName);
     105                // use the settings-Buttons "Start" and "Stop" to start and stop the P2P-System...
     106                //this.p2pBase.SynchStart();
    85107            }
    86108        }
     
    114136        public void Dispose()
    115137        {
    116             p2pBase.SynchStop();
     138            //settings are already set to null in this Step...
     139            //unsolved design problem in CT2...
     140            //this.settings.PeerStopped = true;
     141            if (p2pBase != null)
     142            {
     143                p2pBase.SynchStop();
     144                p2pBase = null;
     145            }
    117146        }
    118147
     
    209238            // erkennt den Übergabeparameter nicht an und wirft dann "ArgumentNotNullException"...
    210239            // Problem an M.Helling und S.Holzapfel von p@p weitergegeben...
    211             // return this.p2pBase.SynchRemove(sKey);
    212             return false;
    213         }
     240            return this.p2pBase.SynchRemove(sKey);
     241            //return false;
     242        }
     243
     244        public string GetPeerName()
     245        {
     246            return this.p2pBase.GetPeerName();
     247        }
     248
    214249
    215250        //public event PeerJoinedP2P OnPeerJoinedCompletely;
  • trunk/CrypPlugins/PeerToPeerBase/P2PPeerSettings.cs

    r783 r813  
    55using Cryptool.PluginBase;
    66using System.ComponentModel;
     7using Cryptool.PluginBase.Control;
     8using System.Windows;
     9
     10/*
     11 * TODO:
     12 * - Standardwerte in P2P-Settings setzen
     13 * - Start- und Stop-Button fürs Beenden und Starten des Peers auch außerhalb des Starts des PlugIns
     14 *
     15 * FRAGE:
     16 * - Wie kann ich statt StringArrays die Enum-Werte als Parameter wählen?
     17 */
    718
    819namespace Cryptool.Plugins.PeerToPeer
     
    1021    class P2PPeerSettings : ISettings
    1122    {
     23        public event TaskPaneAttributeChangedHandler TaskPaneAttributeChanged;
     24        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     25
    1226        private bool hasChanges = false;
    1327        private P2PBase p2pBase;
     
    3145        #region taskPane
    3246
     47        // Parse String-Value to a valid Enum-Value
     48        private static T StringToEnum<T>(string sName)
     49        {
     50            return (T)Enum.Parse(typeof(T), sName);
     51        }
    3352
    3453        public P2PPeerSettings (P2PBase p2pBase)
    3554            {
     55            if(TaskPaneAttributeChanged != null)
     56                TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("BtnStop", Visibility.Hidden)));
    3657            this.p2pBase = p2pBase;
    3758            }
    3859
    39         [TaskPane("Log internal state of peer", "Log internal state of peer", null, 2, false, DisplayLevel.Beginner, ControlType.Button)]
    40         public void btnTest()
    41         {
    42             this.p2pBase.LogInternalState();
    43         }
     60        #endregion
     61
     62        #region Start- and Stop-Buttons incl. functionality
     63
     64        [TaskPane("Start", "Initializes and starts Peer", null, 3, false, DisplayLevel.Beginner, ControlType.Button)]
     65        public void BtnStart()
     66        {
     67            PeerStarted = !this.peerStarted;
     68        }
     69
     70        //private int iTest = 2;
     71        //[PropertySaveOrder(4)]
     72        //[ContextMenu("CaptionText","ContextToolTip",4,DisplayLevel.Beginner,ContextMenuControlType.ComboBox,new int[]{1,2},"Welt","Hallo")]
     73        //[TaskPane("Testfunktion","",null,4,false,DisplayLevel.Beginner,ControlType.ComboBox,new string[]{"Welt","Hallo"})]
     74        //public int Test
     75        //{
     76        //    get {return this.iTest;}
     77        //    set
     78        //    {
     79        //        if (value != this.iTest)
     80        //            this.iTest = value;
     81        //    }
     82        //}
     83
     84        private bool peerStarted = false;
     85        /// <summary>
     86        /// If peer isn't started by clicking the Button, it will be started by setting to true
     87        /// </summary>
     88        public bool PeerStarted
     89        {
     90            get { return this.peerStarted; }
     91            set
     92            {
     93                if (!this.peerStarted)
     94                {
     95                    if (P2PPeerName != null && P2PWorldName != null)
     96                    {
     97                        this.p2pBase.InitializeAll(P2PPeerName, P2PWorldName, P2PLinkMngrType, P2PBSType, P2POverlType, P2PDhtType);
     98                        this.p2pBase.SynchStart();
     99                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("BtnStart", Visibility.Collapsed)));
     100                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("BtnStop", Visibility.Visible)));
     101                    }
     102                    else
     103                    {
     104                        // can not initialize Peer, because P2PUserName and/or P2PWorldName are missing
     105                        throw (new Exception("You must set P2PPeerName and/or P2PWorldName, otherwise starting the peer isn't possible"));
     106                    }
     107                }
     108                if (value != this.peerStarted)
     109                {
     110                    this.peerStarted = value;
     111                    //don't use the PeerStopped-Property, because you will run into a recursive loop!!!
     112                    this.peerStopped = !value;
     113                    OnPropertyChanged("PeerStarted");
     114                    HasChanges = true;
     115                }
     116            }
     117        }
     118
     119        [TaskPane("Stop", "Stops the Peer", null, 4, false, DisplayLevel.Beginner, ControlType.Button)]
     120        public void BtnStop()
     121        {
     122            PeerStopped = !this.peerStopped;
     123        }
     124
     125        private bool peerStopped = true;
     126        /// <summary>
     127        /// if peer is already started, it will be stopped by setting to true
     128        /// </summary>
     129        public bool PeerStopped
     130        {
     131            get { return this.peerStopped; }
     132            set
     133            {
     134                if (this.peerStarted)
     135                {
     136                    this.p2pBase.SynchStop();
     137                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("BtnStart", Visibility.Visible)));
     138                    TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("BtnStop", Visibility.Collapsed)));
     139                }
     140                if (value != this.peerStopped)
     141                {
     142                    //don't use the PeerStarted-Property, because you will run into a recursive loop!!!
     143                    this.peerStarted = !value;
     144                    this.peerStopped = value;
     145                    OnPropertyChanged("PeerStopped");
     146                    HasChanges = true;
     147                }
     148            }
     149        }
     150
     151        #endregion
     152
     153        #region Setting-Fields
    44154
    45155        private string p2pPeerName;
     
    75185        }
    76186
     187        [TaskPane("Log internal state of peer", "Log internal state of peer", null, 2, false, DisplayLevel.Beginner, ControlType.Button)]
     188        public void btnTest()
     189        {
     190            this.p2pBase.LogInternalState();
     191        }
     192
     193        private P2PLinkManagerType p2pLinkManagerType = P2PLinkManagerType.Snal;
     194        [TaskPane("LinkManager-Type", "Select the LinkManager-Type", "P2P Settings", 2, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "Snal" })]
     195        public P2PLinkManagerType P2PLinkMngrType
     196        {
     197            get { return this.p2pLinkManagerType; }
     198            set
     199            {
     200                if (value != this.p2pLinkManagerType)
     201                {
     202                    this.p2pLinkManagerType = StringToEnum<P2PLinkManagerType>(value.ToString());
     203                    OnPropertyChanged("P2PLinkManagerType");
     204                    HasChanges = true;
     205                }
     206            }
     207        }
     208
     209        //private P2PBootstrapperType p2pBSType = P2PBootstrapperType.LocalMachineBootstrapper;
     210        private P2PBootstrapperType p2pBSType;
     211        [TaskPane("Bootstrapper-Type", "Select the Bootstrapper-Type", "P2P Settings", 3, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "LocalMachineBootstrapper", "IrcBootstrapper" })]
     212        public P2PBootstrapperType P2PBSType
     213        {
     214            get { return this.p2pBSType; }
     215            set
     216            {
     217                if (value != this.p2pBSType)
     218                {
     219                    this.p2pBSType = StringToEnum<P2PBootstrapperType>(value.ToString());
     220                    OnPropertyChanged("P2PBSType");
     221                    HasChanges = true;
     222                }
     223            }
     224        }
     225
     226        private P2POverlayType p2pOverlayType = P2POverlayType.FullMeshOverlay;
     227        [TaskPane("Overlay-Type", "Select the Overlay-Type", "P2P Settings", 4, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "FullMeshOverlay" })]
     228        public P2POverlayType P2POverlType
     229        {
     230            get { return this.p2pOverlayType; }
     231            set
     232            {
     233                if (value != this.p2pOverlayType)
     234                {
     235                    this.p2pOverlayType = StringToEnum<P2POverlayType>(value.ToString());
     236                    OnPropertyChanged("P2POverlType");
     237                    HasChanges = true;
     238                }
     239            }
     240        }
     241
     242        private P2PDHTType p2pDhtType = P2PDHTType.FullMeshDHT;
     243        [TaskPane("DHT-Type", "Select the DHT-Type", "P2P Settings", 5, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "FullMeshDHT" })]
     244        public P2PDHTType P2PDhtType
     245        {
     246            get { return this.p2pDhtType;  }
     247            set
     248            {
     249                if (value != this.p2pDhtType)
     250                {
     251                    this.p2pDhtType = StringToEnum<P2PDHTType>(value.ToString());
     252                    OnPropertyChanged("P2PDhtType");
     253                    HasChanges = true;
     254                }
     255            }
     256        }
     257
    77258        #endregion
    78259
    79260        #region INotifyPropertyChanged Members
    80 
    81         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    82261
    83262        private void OnPropertyChanged(string p)
  • trunk/CrypPlugins/PeerToPeerBase/PeerToPeerBase.cs

    r797 r813  
    3636/*
    3737 * Synchronous functions successfully tested (store, retrieve)
     38 * !!! remove-Function is faulty !!!
    3839 * Standard connection for test issues is LocalMachineBootstrapper.
    3940 * IrcBootstrapper also works, but it's to lame for testing issues!
    4041 *
    4142 * TODO:
     43 * - Add enums (BS,LinkManager,Overlay) to class - make it public to use in cross-cutting classes
    4244 * - dht.Remove-Method makes problems... "ArgumentNotNullException"
    4345 *   event though the Parameter is correctly set to a valid value!
    4446 *   --> forwarded to the p@p-Team
    4547 * - Testing asynchronous methods incl. EventHandlers
    46  *
    47  * TO DO in Related Projects:
    48  * - Change stand-alone P2P-Apps to IControl-Slaves from one P2P-Master (store, load, (remove))
    4948 */
    5049namespace Cryptool.Plugins.PeerToPeer
     
    117116        /// <param name="sUserName">Choose an individual name for the user</param>
    118117        /// <param name="sWorldName">fundamental: two peers are only in the SAME P2P system, when they initialized the SAME WORLD!</param>
     118        /// <param name="linkManagerType"></param>
     119        /// <param name="bsType"></param>
     120        /// <param name="overlayType"></param>
     121        /// <param name="dhtType"></param>
     122        public void InitializeAll(string sUserName, string sWorldName, P2PLinkManagerType linkManagerType, P2PBootstrapperType bsType, P2POverlayType overlayType, P2PDHTType dhtType)
     123        {
     124            #region Setting LinkManager, Bootstrapper, Overlay and DHT to the specified types
     125            switch (linkManagerType)
     126            {
     127                case P2PLinkManagerType.Snal:
     128                    //snal = secure network abstraction layer
     129                    this.linkmanager = new Snal();
     130                    break;
     131                default:
     132                    throw (new NotImplementedException());
     133                    break;
     134            }
     135            switch (bsType)
     136            {
     137                case P2PBootstrapperType.LocalMachineBootstrapper:
     138                    //LocalMachineBootstrapper = only local connection (runs only on one machine)
     139                    this.bootstrapper = new LocalMachineBootstrapper();
     140                    break;
     141                case P2PBootstrapperType.IrcBootstrapper:
     142                    this.bootstrapper = new IrcBootstrapper();
     143                    break;
     144                default:
     145                    throw (new NotImplementedException());
     146                    break;
     147            }
     148            switch (overlayType)
     149            {
     150                case P2POverlayType.FullMeshOverlay:
     151                    // changing overlay example: this.overlay = new ChordOverlay();
     152                    this.overlay = new FullMeshOverlay();
     153                    break;
     154                default:
     155                    throw (new NotImplementedException());
     156                    break;
     157            }
     158            switch (dhtType)
     159            {
     160                case P2PDHTType.FullMeshDHT:
     161                    this.dht = new FullMeshDHT();
     162                    break;
     163                default:
     164                    throw (new NotImplementedException());
     165                    break;
     166            }
     167            #endregion
     168
     169            this.dht.Initialize(sUserName, sWorldName, this.overlay, this.bootstrapper, this.linkmanager, null);
     170
     171            this.dht.MessageReceived += new EventHandler<MessageReceived>(OnDHT_MessageReceived);
     172            this.dht.SystemJoined += new EventHandler(OnDHT_SystemJoined);
     173            this.dht.SystemLeft += new EventHandler(OnDHT_SystemLeft);
     174        }
     175
     176        /// <summary>
     177        /// Initializing is the first step to build a new or access an existing p2p network
     178        /// </summary>
     179        /// <param name="sUserName">Choose an individual name for the user</param>
     180        /// <param name="sWorldName">fundamental: two peers are only in the SAME P2P system, when they initialized the SAME WORLD!</param>
    119181        public void Initialize(string sUserName, string sWorldName)
    120182        {
     
    203265        #endregion
    204266
     267        // not tested and not sure that this function return the right PeerName...
     268        /// <summary>
     269        /// Get PeerName of the actual peer
     270        /// </summary>
     271        /// <returns>Peer name of the actual peer</returns>
     272        public string GetPeerName()
     273        {
     274            return this.overlay.LocalAddress.ToString();
     275        }
     276
    205277        #region Event Handling (System Joined, Left and Message Received)
    206278
     
    216288            if (OnSystemLeft != null)
    217289                OnSystemLeft();
     290            // as an experiment
     291            this.dht = null;
    218292            this.systemLeft.Set();
    219293        }
  • trunk/CrypPlugins/PeerToPeer_DHTremove/P2PDHTremove.cs

    r797 r813  
    1313   limitations under the License.
    1414*/
    15 
    1615
    1716using System;
Note: See TracChangeset for help on using the changeset viewer.