Changeset 1696


Ignore:
Timestamp:
Jun 24, 2010, 10:55:44 AM (11 years ago)
Author:
Paul Lelgemann
Message:

o Simplified peer-to-peer settings: overlay and DHT type are now selected by architecture

Location:
trunk
Files:
11 edited

Legend:

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

    r1672 r1696  
    161161            }
    162162
    163             switch (P2PSettings.Default.Overlay)
    164             {
    165                 case P2POverlayType.FullMeshOverlay:
    166                     // changing overlay example: this.overlay = new ChordOverlay();
     163            switch (P2PSettings.Default.Architecture)
     164            {
     165                case P2PArchitecture.FullMesh:
    167166                    _overlay = new FullMeshOverlay(scheduler);
    168                     break;
    169                 case P2POverlayType.ChordOverlay:
    170                     _overlay = new ChordNGCore(scheduler);
    171                     break;
    172                 default:
    173                     throw (new NotImplementedException());
    174             }
    175 
    176             switch (P2PSettings.Default.Dht)
    177             {
    178                 case P2PDHTType.FullMeshDHT:
    179167                    Dht = new FullMeshDHT(scheduler);
    180168                    break;
    181                 case P2PDHTType.ChordDHT:
     169                case P2PArchitecture.Chord:
     170                    _overlay = new ChordNGCore(scheduler);
    182171                    Dht = (IDHT) _overlay;
    183172                    break;
  • trunk/CrypP2P/P2PSettings.Designer.cs

    r1604 r1696  
    8686        [global::System.Configuration.UserScopedSettingAttribute()]
    8787        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    88         [global::System.Configuration.DefaultSettingValueAttribute("FullMeshOverlay")]
    89         public global::Cryptool.Plugins.PeerToPeer.Internal.P2POverlayType Overlay {
    90             get {
    91                 return ((global::Cryptool.Plugins.PeerToPeer.Internal.P2POverlayType)(this["Overlay"]));
    92             }
    93             set {
    94                 this["Overlay"] = value;
    95             }
    96         }
    97        
    98         [global::System.Configuration.UserScopedSettingAttribute()]
    99         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    100         [global::System.Configuration.DefaultSettingValueAttribute("FullMeshDHT")]
    101         public global::Cryptool.Plugins.PeerToPeer.Internal.P2PDHTType Dht {
    102             get {
    103                 return ((global::Cryptool.Plugins.PeerToPeer.Internal.P2PDHTType)(this["Dht"]));
    104             }
    105             set {
    106                 this["Dht"] = value;
    107             }
    108         }
    109        
    110         [global::System.Configuration.UserScopedSettingAttribute()]
    111         [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    11288        [global::System.Configuration.DefaultSettingValueAttribute("False")]
    11389        public bool ConnectOnStartup {
     
    179155            }
    180156        }
     157       
     158        [global::System.Configuration.UserScopedSettingAttribute()]
     159        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
     160        [global::System.Configuration.DefaultSettingValueAttribute("Chord")]
     161        public global::Cryptool.Plugins.PeerToPeer.Internal.P2PArchitecture Architecture {
     162            get {
     163                return ((global::Cryptool.Plugins.PeerToPeer.Internal.P2PArchitecture)(this["Architecture"]));
     164            }
     165            set {
     166                this["Architecture"] = value;
     167            }
     168        }
    181169    }
    182170}
  • trunk/CrypP2P/P2PSettings.settings

    r1604 r1696  
    1818      <Value Profile="(Default)">IrcBootstrapper</Value>
    1919    </Setting>
    20     <Setting Name="Overlay" Type="Cryptool.Plugins.PeerToPeer.Internal.P2POverlayType" Scope="User">
    21       <Value Profile="(Default)">FullMeshOverlay</Value>
    22     </Setting>
    23     <Setting Name="Dht" Type="Cryptool.Plugins.PeerToPeer.Internal.P2PDHTType" Scope="User">
    24       <Value Profile="(Default)">FullMeshDHT</Value>
    25     </Setting>
    2620    <Setting Name="ConnectOnStartup" Type="System.Boolean" Scope="User">
    2721      <Value Profile="(Default)">False</Value>
     
    4236      <Value Profile="(Default)">TCP</Value>
    4337    </Setting>
     38    <Setting Name="Architecture" Type="Cryptool.Plugins.PeerToPeer.Internal.P2PArchitecture" Scope="User">
     39      <Value Profile="(Default)">Chord</Value>
     40    </Setting>
    4441  </Settings>
    4542</SettingsFile>
  • trunk/CrypP2P/app.config

    r1604 r1696  
    2323                <value>IrcBootstrapper</value>
    2424            </setting>
    25             <setting name="Overlay" serializeAs="String">
    26                 <value>FullMeshOverlay</value>
    27             </setting>
    28             <setting name="Dht" serializeAs="String">
    29                 <value>FullMeshDHT</value>
    30             </setting>
    3125            <setting name="ConnectOnStartup" serializeAs="String">
    3226                <value>False</value>
     
    4741                <value>TCP</value>
    4842            </setting>
     43            <setting name="Architecture" serializeAs="String">
     44                <value>Chord</value>
     45            </setting>
    4946        </Cryptool.P2P.P2PSettings>
    5047    </userSettings>
  • trunk/CrypPlugins/P2PEditor/P2PEditorSettings.cs

    r1672 r1696  
    187187        }
    188188
    189         [TaskPane("overlay_caption", "overlay_tooltip", GroupExpert, 2, false, DisplayLevel.Expert,
    190             ControlType.ComboBox, new[] {"FullMeshOverlay", "ChordOverlay"})]
    191         public int Overlay
    192         {
    193             get { return (int) _settings.Overlay; }
    194             set
    195             {
    196                 if ((P2POverlayType) value != _settings.Overlay)
    197                 {
    198                     _settings.Overlay = (P2POverlayType) value;
    199                     OnPropertyChanged("Overlay");
    200                     HasChanges = true;
    201                 }
    202             }
    203         }
    204 
    205         [TaskPane("dht_caption", "dht_tooltip", GroupExpert, 3, false, DisplayLevel.Expert,
    206             ControlType.ComboBox, new[] {"FullMeshDHT", "ChordDHT"})]
    207         public int Dht
    208         {
    209             get { return (int) _settings.Dht; }
    210             set
    211             {
    212                 if ((P2PDHTType) value != _settings.Dht)
    213                 {
    214                     _settings.Dht = (P2PDHTType) value;
    215                     OnPropertyChanged("Dht");
     189        [TaskPane("architecture_caption", "architecture_tooltip", GroupExpert, 2, false, DisplayLevel.Expert,
     190            ControlType.ComboBox, new[] { "FullMesh", "Chord" })]
     191        public int Architecture
     192        {
     193            get { return (int)_settings.Architecture; }
     194            set
     195            {
     196                if ((P2PArchitecture)value != _settings.Architecture)
     197                {
     198                    _settings.Architecture = (P2PArchitecture)value;
     199                    OnPropertyChanged("Architecture");
    216200                    HasChanges = true;
    217201                }
  • trunk/CrypPlugins/P2PEditor/Resources/Attributes.Designer.cs

    r1611 r1696  
    6262       
    6363        /// <summary>
     64        ///   Looks up a localized string similar to Architecture.
     65        /// </summary>
     66        internal static string architecture_caption {
     67            get {
     68                return ResourceManager.GetString("architecture_caption", resourceCulture);
     69            }
     70        }
     71       
     72        /// <summary>
     73        ///   Looks up a localized string similar to Architecture of the P2P network..
     74        /// </summary>
     75        internal static string architecture_tooltip {
     76            get {
     77                return ResourceManager.GetString("architecture_tooltip", resourceCulture);
     78            }
     79        }
     80       
     81        /// <summary>
    6482        ///   Looks up a localized string similar to Bootstrapper type.
    6583        /// </summary>
     
    89107       
    90108        /// <summary>
    91         ///   Looks up a localized string similar to DHT type.
    92         /// </summary>
    93         internal static string dht_caption {
    94             get {
    95                 return ResourceManager.GetString("dht_caption", resourceCulture);
    96             }
    97         }
    98        
    99         /// <summary>
    100         ///   Looks up a localized string similar to DHT type.
    101         /// </summary>
    102         internal static string dht_tooltip {
    103             get {
    104                 return ResourceManager.GetString("dht_tooltip", resourceCulture);
    105             }
    106         }
    107        
    108         /// <summary>
    109109        ///   Looks up a localized string similar to Job list refresh interval (seconds).
    110110        /// </summary>
     
    220220            get {
    221221                return ResourceManager.GetString("onnectOnStartup_tooltip", resourceCulture);
    222             }
    223         }
    224        
    225         /// <summary>
    226         ///   Looks up a localized string similar to Overlay type.
    227         /// </summary>
    228         internal static string overlay_caption {
    229             get {
    230                 return ResourceManager.GetString("overlay_caption", resourceCulture);
    231             }
    232         }
    233        
    234         /// <summary>
    235         ///   Looks up a localized string similar to Overlay type.
    236         /// </summary>
    237         internal static string overlay_tooltip {
    238             get {
    239                 return ResourceManager.GetString("overlay_tooltip", resourceCulture);
    240222            }
    241223        }
  • trunk/CrypPlugins/P2PEditor/Resources/Attributes.resx

    r1611 r1696  
    118118    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
    119119  </resheader>
     120  <data name="architecture_caption" xml:space="preserve">
     121    <value>Architecture</value>
     122  </data>
     123  <data name="architecture_tooltip" xml:space="preserve">
     124    <value>Architecture of the P2P network.</value>
     125  </data>
    120126  <data name="bootstrapper_caption" xml:space="preserve">
    121127    <value>Bootstrapper type</value>
     
    127133    <value>Connect on startup</value>
    128134  </data>
    129   <data name="dht_caption" xml:space="preserve">
    130     <value>DHT type</value>
    131   </data>
    132   <data name="dht_tooltip" xml:space="preserve">
    133     <value>DHT type</value>
    134   </data>
    135135  <data name="distributedJobListRefreshInterval_caption" xml:space="preserve">
    136136    <value>Job list refresh interval (seconds)</value>
     
    172172    <value>Establish a connection to the peer-to-peer network during CrypTool startup.</value>
    173173  </data>
    174   <data name="overlay_caption" xml:space="preserve">
    175     <value>Overlay type</value>
    176   </data>
    177   <data name="overlay_tooltip" xml:space="preserve">
    178     <value>Overlay type</value>
    179   </data>
    180174  <data name="start_caption" xml:space="preserve">
    181175    <value>Connect</value>
  • trunk/CrypPlugins/PeerToPeer/IP2PControl.cs

    r1672 r1696  
    1 using Cryptool.PluginBase.Control;
     1using System;
     2using Cryptool.PluginBase.Control;
    23
    34namespace Cryptool.Plugins.PeerToPeer.Internal
     
    1718    }
    1819
    19     public enum P2POverlayType
     20    public enum P2PArchitecture
    2021    {
    21         FullMeshOverlay = 0,
    22         ChordOverlay = 1
     22        FullMesh = 0,
     23        Chord = 1
    2324    }
    24 
    25     public enum P2PDHTType
    26     {
    27         FullMeshDHT = 0,
    28         ChordDHT = 1
    29     }
    30 
     25   
    3126    public enum P2PTransportProtocol
    3227    {
  • trunk/CrypPlugins/PeerToPeerBase/P2PBase.cs

    r1643 r1696  
    164164        /// <param name="overlayType"></param>
    165165        /// <param name="dhtType"></param>
    166         public void Initialize(string sUserName, string sWorldName, P2PLinkManagerType linkManagerType, P2PBootstrapperType bsType, P2POverlayType overlayType, P2PDHTType dhtType)
     166        public void Initialize(string sUserName, string sWorldName, P2PLinkManagerType linkManagerType, P2PBootstrapperType bsType, P2PArchitecture architecture)
    167167        {
    168168            #region Setting LinkManager, Bootstrapper, Overlay and DHT to the specified types
     
    211211                    throw (new NotImplementedException());
    212212            }
    213             switch (overlayType)
    214             {
    215                 case P2POverlayType.FullMeshOverlay:
     213            switch (architecture)
     214            {
     215                case P2PArchitecture.FullMesh:
    216216                    // changing overlay example: this.overlay = new ChordOverlay();
    217217                    this.overlay = new FullMeshOverlay(scheduler);
    218                     break;
    219                 default:
    220                     throw (new NotImplementedException());
    221             }
    222             switch (dhtType)
    223             {
    224                 case P2PDHTType.FullMeshDHT:
    225218                    this.dht = new FullMeshDHT(scheduler);
    226219                    break;
     220                case P2PArchitecture.Chord:
     221                    throw (new NotImplementedException());
    227222                default:
    228223                    throw (new NotImplementedException());
  • trunk/CrypPlugins/PeerToPeerBase/P2PPeer.cs

    r1433 r1696  
    209209                    this.p2pBase.Initialize(this.settings.P2PPeerName, this.settings.P2PWorldName,
    210210                        (P2PLinkManagerType)this.settings.P2PLinkMngrType, (P2PBootstrapperType)this.settings.P2PBSType,
    211                         (P2POverlayType)this.settings.P2POverlType, (P2PDHTType)this.settings.P2PDhtType);
     211                        (P2PArchitecture)this.settings.P2PArchitecture);
    212212                    this.PeerStarted = this.p2pBase.SynchStart();
    213213
  • trunk/CrypPlugins/PeerToPeerBase/P2PPeerSettings.cs

    r1672 r1696  
    186186        }
    187187
    188         private P2POverlayType p2pOverlayType = P2POverlayType.FullMeshOverlay;
    189         [TaskPane("Overlay-Type", "Select the Overlay-Type", "P2P Expert Settings", 4, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "FullMeshOverlay", "ChordOverlay" })]
    190         public int P2POverlType
    191         {
    192             get { return (int)this.p2pOverlayType; }
    193             set
    194             {
    195                 if ((P2POverlayType)value != this.p2pOverlayType)
    196                 {
    197                     this.p2pOverlayType = (P2POverlayType)value;
    198                     OnPropertyChanged("P2POverlType");
    199                     HasChanges = true;
    200                 }
    201             }
    202         }
    203 
    204         private P2PDHTType p2pDhtType = P2PDHTType.FullMeshDHT;
    205         [TaskPane("DHT-Type", "Select the DHT-Type", "P2P Expert Settings", 5, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "FullMeshDHT", "ChordDHT" })]
    206         public int P2PDhtType
    207         {
    208             get { return (int)this.p2pDhtType;  }
    209             set
    210             {
    211                 if ((P2PDHTType)value != this.p2pDhtType)
    212                 {
    213                     this.p2pDhtType = (P2PDHTType)value;
    214                     OnPropertyChanged("P2PDhtType");
    215                     HasChanges = true;
    216                 }
    217             }
    218         }
    219 
     188        private P2PArchitecture p2pArchitecture = Internal.P2PArchitecture.FullMesh;
     189        [TaskPane("Architecture", "Select the Architecture", "P2P Expert Settings", 4, false, DisplayLevel.Beginner, ControlType.ComboBox, new string[] { "FullMesh" })]
     190        public int P2PArchitecture
     191        {
     192            get { return (int)this.p2pArchitecture; }
     193            set
     194            {
     195                if ((P2PArchitecture)value != this.p2pArchitecture)
     196                {
     197                    this.p2pArchitecture = (P2PArchitecture)value;
     198                    OnPropertyChanged("P2PArchitecture");
     199                    HasChanges = true;
     200                }
     201            }
     202        }
    220203        #endregion
    221204
Note: See TracChangeset for help on using the changeset viewer.