Ignore:
Timestamp:
Jun 10, 2010, 1:39:21 PM (12 years ago)
Author:
Paul Lelgemann
Message:

o CrypP2P: Code cleanup
o P2PEditor: job list will be reloaded in a BackgroundWorker

File:
1 edited

Legend:

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

    r1604 r1616  
    11/*
    2    Copyright 2010 Paul Lelgemann, University of Duisburg-Essen
     2   Copyright 2010 Paul Lelgemann and Christian Arnold,
     3                  University of Duisburg-Essen
    34
    45   Licensed under the Apache License, Version 2.0 (the "License");
     
    4748    public class P2PBase
    4849    {
    49         private readonly P2PManager _p2PManager;
    50 
    5150        #region Variables
    5251
    53         private readonly object _connectLock = new object();
    5452        private readonly AutoResetEvent _systemJoined;
    5553        private readonly AutoResetEvent _systemLeft;
     
    6361        ///   True if system was successfully joined, false if system is COMPLETELY left
    6462        /// </summary>
    65         public bool Started { get; private set; }
     63        public bool IsConnected { get; private set; }
    6664
    6765        /// <summary>
    6866        ///   True if the underlying peer to peer system has been fully initialized
    6967        /// </summary>
    70         public bool Initialized { get; private set; }
     68        public bool IsInitialized { get; private set; }
    7169
    7270        #endregion
     
    8583        #endregion
    8684
    87         public P2PBase(P2PManager p2PManager)
    88         {
    89             Started = false;
    90             Initialized = false;
    91 
    92             _p2PManager = p2PManager;
     85        public P2PBase()
     86        {
     87            IsConnected = false;
     88            IsInitialized = false;
     89
    9390            _systemJoined = new AutoResetEvent(false);
    9491            _systemLeft = new AutoResetEvent(false);
     
    10299        public void Initialize()
    103100        {
    104             lock (_connectLock)
    105             {
    106                 Scheduler scheduler = new STAScheduler("pap");
    107 
    108                 switch (P2PSettings.Default.LinkManager)
    109                 {
    110                     case P2PLinkManagerType.Snal:
    111                         LogToMonitor("Init LinkMgr: Using NAT Traversal stuff");
    112 
    113                         // NAT-Traversal stuff needs a different Snal-Version
    114                         _linkmanager = new Snal(scheduler);
    115 
    116                         var settings = new PeersAtPlay.P2PLink.SnalNG.Settings();
    117                         settings.LoadDefaults();
    118                         settings.ConnectInternal = true;
    119                         settings.LocalReceivingPort = P2PSettings.Default.LocalReceivingPort;
    120                         settings.UseLocalAddressDetection = P2PSettings.Default.UseLocalAddressDetection;
    121                         settings.AutoReconnect = false;
    122                         settings.NoDelay = false;
    123                         settings.ReuseAddress = false;
    124                         settings.UseNetworkMonitorServer = true;
    125                         settings.CloseConnectionAfterPingTimeout = false;
     101            Scheduler scheduler = new STAScheduler("pap");
     102
     103            switch (P2PSettings.Default.LinkManager)
     104            {
     105                case P2PLinkManagerType.Snal:
     106                    LogToMonitor("Init LinkMgr: Using NAT Traversal stuff");
     107
     108                    // NAT-Traversal stuff needs a different Snal-Version
     109                    _linkmanager = new Snal(scheduler);
     110
     111                    var settings = new PeersAtPlay.P2PLink.SnalNG.Settings();
     112                    settings.LoadDefaults();
     113                    settings.ConnectInternal = true;
     114                    settings.LocalReceivingPort = P2PSettings.Default.LocalReceivingPort;
     115                    settings.UseLocalAddressDetection = P2PSettings.Default.UseLocalAddressDetection;
     116                    settings.AutoReconnect = false;
     117                    settings.NoDelay = false;
     118                    settings.ReuseAddress = false;
     119                    settings.UseNetworkMonitorServer = true;
     120                    settings.CloseConnectionAfterPingTimeout = false;
    126121                       
    127                         switch(P2PSettings.Default.TransportProtocol)
    128                         {
    129                             case P2PTransportProtocol.UDP:
    130                                 settings.TransportProtocol = TransportProtocol.UDP;
    131                                 break;
    132                             case P2PTransportProtocol.TCP_UDP:
    133                                 settings.TransportProtocol = TransportProtocol.TCP_UDP;
    134                                 break;
    135                             default:
    136                                 settings.TransportProtocol = TransportProtocol.TCP;
    137                                 break;
    138                         }
    139 
    140                         _linkmanager.Settings = settings;
    141                         _linkmanager.ApplicationType = ApplicationType.CrypTool;
    142 
    143                         break;
    144                     default:
    145                         throw (new NotImplementedException());
    146                 }
    147 
    148                 switch (P2PSettings.Default.Bootstrapper)
    149                 {
    150                     case P2PBootstrapperType.LocalMachineBootstrapper:
    151                         // LocalMachineBootstrapper = only local connection (runs only on one machine)
    152                         _bootstrapper = new LocalMachineBootstrapper();
    153                         break;
    154                     case P2PBootstrapperType.IrcBootstrapper:
    155                         // setup nat traversal stuff
    156                         LogToMonitor("Init Bootstrapper: Using NAT Traversal stuff");
    157                         PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.DelaySymmetricResponse = true;
    158                         PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.IncludeSymmetricInResponse = false;
    159                         PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.SymmetricResponseDelay = 6000;
    160 
    161                         PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.DelaySymmetricResponse = true;
    162                         PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.IncludeSymmetricResponse = false;
    163 
    164                         _bootstrapper = new IrcBootstrapper(scheduler);
    165                         break;
    166                     default:
    167                         throw (new NotImplementedException());
    168                 }
    169 
    170                 switch (P2PSettings.Default.Overlay)
    171                 {
    172                     case P2POverlayType.FullMeshOverlay:
    173                         // changing overlay example: this.overlay = new ChordOverlay();
    174                         _overlay = new FullMeshOverlay(scheduler);
    175                         break;
    176                     default:
    177                         throw (new NotImplementedException());
    178                 }
    179 
    180                 switch (P2PSettings.Default.Dht)
    181                 {
    182                     case P2PDHTType.FullMeshDHT:
    183                         Dht = new FullMeshDHT(scheduler);
    184                         break;
    185                     default:
    186                         throw (new NotImplementedException());
    187                 }
    188 
    189                 _overlay.MessageReceived += OverlayMessageReceived;
    190                 Dht.SystemJoined += OnDhtSystemJoined;
    191                 Dht.SystemLeft += OnDhtSystemLeft;
    192 
    193                 VersionedDht = (IVersionedDHT) Dht;
    194 
    195                 _p2PManager.GuiLogMessage("Initializing DHT with world name " + P2PSettings.Default.WorldName,
    196                                                   NotificationLevel.Info);
    197                 Dht.Initialize(P2PSettings.Default.PeerName, string.Empty, P2PSettings.Default.WorldName, _overlay,
    198                                _bootstrapper,
    199                                _linkmanager, null);
    200 
    201                 Initialized = true;
    202             }
     122                    switch(P2PSettings.Default.TransportProtocol)
     123                    {
     124                        case P2PTransportProtocol.UDP:
     125                            settings.TransportProtocol = TransportProtocol.UDP;
     126                            break;
     127                        case P2PTransportProtocol.TCP_UDP:
     128                            settings.TransportProtocol = TransportProtocol.TCP_UDP;
     129                            break;
     130                        default:
     131                            settings.TransportProtocol = TransportProtocol.TCP;
     132                            break;
     133                    }
     134
     135                    _linkmanager.Settings = settings;
     136                    _linkmanager.ApplicationType = ApplicationType.CrypTool;
     137
     138                    break;
     139                default:
     140                    throw (new NotImplementedException());
     141            }
     142
     143            switch (P2PSettings.Default.Bootstrapper)
     144            {
     145                case P2PBootstrapperType.LocalMachineBootstrapper:
     146                    // LocalMachineBootstrapper = only local connection (runs only on one machine)
     147                    _bootstrapper = new LocalMachineBootstrapper();
     148                    break;
     149                case P2PBootstrapperType.IrcBootstrapper:
     150                    // setup nat traversal stuff
     151                    LogToMonitor("Init Bootstrapper: Using NAT Traversal stuff");
     152                    PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.DelaySymmetricResponse = true;
     153                    PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.IncludeSymmetricInResponse = false;
     154                    PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.SymmetricResponseDelay = 6000;
     155
     156                    PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.DelaySymmetricResponse = true;
     157                    PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.IncludeSymmetricResponse = false;
     158
     159                    _bootstrapper = new IrcBootstrapper(scheduler);
     160                    break;
     161                default:
     162                    throw (new NotImplementedException());
     163            }
     164
     165            switch (P2PSettings.Default.Overlay)
     166            {
     167                case P2POverlayType.FullMeshOverlay:
     168                    // changing overlay example: this.overlay = new ChordOverlay();
     169                    _overlay = new FullMeshOverlay(scheduler);
     170                    break;
     171                default:
     172                    throw (new NotImplementedException());
     173            }
     174
     175            switch (P2PSettings.Default.Dht)
     176            {
     177                case P2PDHTType.FullMeshDHT:
     178                    Dht = new FullMeshDHT(scheduler);
     179                    break;
     180                default:
     181                    throw (new NotImplementedException());
     182            }
     183
     184            _overlay.MessageReceived += OverlayMessageReceived;
     185            Dht.SystemJoined += OnDhtSystemJoined;
     186            Dht.SystemLeft += OnDhtSystemLeft;
     187
     188            VersionedDht = (IVersionedDHT) Dht;
     189
     190            P2PManager.GuiLogMessage("Initializing DHT with world name " + P2PSettings.Default.WorldName,
     191                                                NotificationLevel.Info);
     192            Dht.Initialize(P2PSettings.Default.PeerName, string.Empty, P2PSettings.Default.WorldName, _overlay,
     193                            _bootstrapper,
     194                            _linkmanager, null);
     195
     196            IsInitialized = true;
    203197        }
    204198
     
    215209        public bool SynchStart()
    216210        {
    217             lock (_connectLock)
    218             {
    219                 if (!Initialized)
    220                 {
    221                     throw new InvalidOperationException("Peer-to-peer is not initialized.");
    222                 }
    223 
    224                 if (Started)
    225                 {
    226                     return true;
    227                 }
    228 
    229                 Dht.BeginStart(BeginStartEventHandler);
    230 
    231                 // Wait for event SystemJoined. When it's invoked, the peer completely joined the P2P system
    232                 _systemJoined.WaitOne();
    233                 _p2PManager.GuiLogMessage("System join process ended.", NotificationLevel.Debug);
    234 
     211            if (!IsInitialized)
     212            {
     213                throw new InvalidOperationException("Peer-to-peer is not initialized.");
     214            }
     215
     216            if (IsConnected)
     217            {
    235218                return true;
    236219            }
     220
     221            Dht.BeginStart(BeginStartEventHandler);
     222
     223            // Wait for event SystemJoined. When it's invoked, the peer completely joined the P2P system
     224            _systemJoined.WaitOne();
     225            P2PManager.GuiLogMessage("System join process ended.", NotificationLevel.Debug);
     226
     227            return true;
    237228        }
    238229
    239230        private void BeginStartEventHandler(DHTEventArgs eventArgs)
    240231        {
    241             _p2PManager.GuiLogMessage("Received DHTEventArgs: " + eventArgs + ", state: " + eventArgs.State, NotificationLevel.Debug);
     232            P2PManager.GuiLogMessage("Received DHTEventArgs: " + eventArgs + ", state: " + eventArgs.State, NotificationLevel.Debug);
    242233        }
    243234
     
    248239        public bool SynchStop()
    249240        {
    250             lock (_connectLock)
    251             {
    252                 if (Dht == null) return false;
    253 
    254                 Dht.BeginStop(null);
    255 
    256                 // wait till systemLeft Event is invoked
    257                 _systemLeft.WaitOne();
    258 
     241            if (Dht == null) return false;
     242
     243            Dht.BeginStop(null);
     244
     245            if (!IsConnected)
     246            {
    259247                return true;
    260248            }
     249
     250            // wait till systemLeft Event is invoked
     251            _systemLeft.WaitOne();
     252
     253            return true;
    261254        }
    262255
     
    334327
    335328            _systemJoined.Set();
    336             Started = true;
     329            IsConnected = true;
    337330        }
    338331
     
    342335                OnSystemLeft();
    343336
    344             Started = false;
    345             Initialized = false;
     337            IsConnected = false;
     338            IsInitialized = false;
    346339
    347340            // Allow new connection to start and check for waiting / blocked tasks
    348             _p2PManager.IsP2PConnecting = false;
     341            // TODO reset running ConnectionWorkers?
    349342            _systemLeft.Set();
    350343            _systemJoined.Set();
Note: See TracChangeset for help on using the changeset viewer.