Ignore:
Timestamp:
Jun 5, 2010, 2:36:48 PM (11 years ago)
Author:
Paul Lelgemann
Message:

+ Added log message for P2P initialization
+ Added locking to P2P methods initialize/connect/disconnect for debugging

  • Removed fix in P2PPublisherBase from r1587
File:
1 edited

Legend:

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

    r1587 r1589  
    4747    public class P2PBase
    4848    {
     49        private readonly P2PManager _p2PManager;
     50
    4951        #region Variables
    5052
     53        private readonly object _connectLock = new object();
    5154        private readonly AutoResetEvent _systemJoined;
    5255        private readonly AutoResetEvent _systemLeft;
     
    8285        #endregion
    8386
    84         public P2PBase()
     87        public P2PBase(P2PManager p2PManager)
    8588        {
    8689            Started = false;
    8790            Initialized = false;
    8891
     92            _p2PManager = p2PManager;
    8993            _systemJoined = new AutoResetEvent(false);
    9094            _systemLeft = new AutoResetEvent(false);
     
    98102        public void Initialize()
    99103        {
    100             Scheduler scheduler = new STAScheduler("pap");
    101 
    102             switch (P2PSettings.Default.LinkManager)
    103             {
    104                 case P2PLinkManagerType.Snal:
    105                     LogToMonitor("Init LinkMgr: Using NAT Traversal stuff");
    106 
    107                     // NAT-Traversal stuff needs a different Snal-Version
    108                     _linkmanager = new Snal(scheduler);
    109 
    110                     var settings = new PeersAtPlay.P2PLink.SnalNG.Settings();
    111                     settings.LoadDefaults();
    112                     settings.ConnectInternal = true;
    113                     settings.LocalReceivingPort = P2PSettings.Default.LocalReceivingPort;
    114                     settings.UseLocalAddressDetection = P2PSettings.Default.UseLocalAddressDetection;
    115                     settings.AutoReconnect = false;
    116                     settings.NoDelay = false;
    117                     settings.ReuseAddress = false;
    118                     settings.UseNetworkMonitorServer = true;
    119 
    120                     _linkmanager.Settings = settings;
    121                     _linkmanager.ApplicationType = ApplicationType.CrypTool;
    122 
    123                     break;
    124                 default:
    125                     throw (new NotImplementedException());
    126             }
    127 
    128             switch (P2PSettings.Default.Bootstrapper)
    129             {
    130                 case P2PBootstrapperType.LocalMachineBootstrapper:
    131                     // LocalMachineBootstrapper = only local connection (runs only on one machine)
    132                     _bootstrapper = new LocalMachineBootstrapper();
    133                     break;
    134                 case P2PBootstrapperType.IrcBootstrapper:
    135                     // setup nat traversal stuff
    136                     LogToMonitor("Init Bootstrapper: Using NAT Traversal stuff");
    137                     PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.DelaySymmetricResponse = true;
    138                     PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.IncludeSymmetricInResponse = false;
    139                     PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.SymmetricResponseDelay = 6000;
    140                    
    141                     PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.DelaySymmetricResponse = true;
    142                     PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.IncludeSymmetricResponse = false;
    143 
    144                     _bootstrapper = new IrcBootstrapper(scheduler);
    145                     break;
    146                 default:
    147                     throw (new NotImplementedException());
    148             }
    149 
    150             switch (P2PSettings.Default.Overlay)
    151             {
    152                 case P2POverlayType.FullMeshOverlay:
    153                     // changing overlay example: this.overlay = new ChordOverlay();
    154                     _overlay = new FullMeshOverlay(scheduler);
    155                     break;
    156                 default:
    157                     throw (new NotImplementedException());
    158             }
    159 
    160             switch (P2PSettings.Default.Dht)
    161             {
    162                 case P2PDHTType.FullMeshDHT:
    163                     Dht = new FullMeshDHT(scheduler);
    164                     break;
    165                 default:
    166                     throw (new NotImplementedException());
    167             }
    168 
    169             _overlay.MessageReceived += OverlayMessageReceived;
    170             Dht.SystemJoined += OnDhtSystemJoined;
    171             Dht.SystemLeft += OnDhtSystemLeft;
    172 
    173             VersionedDht = (IVersionedDHT) Dht;
    174 
    175             Dht.Initialize(P2PSettings.Default.PeerName, string.Empty, P2PSettings.Default.WorldName, _overlay,
    176                             _bootstrapper,
    177                             _linkmanager, null);
    178 
    179             Initialized = true;
     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
     126                        _linkmanager.Settings = settings;
     127                        _linkmanager.ApplicationType = ApplicationType.CrypTool;
     128
     129                        break;
     130                    default:
     131                        throw (new NotImplementedException());
     132                }
     133
     134                switch (P2PSettings.Default.Bootstrapper)
     135                {
     136                    case P2PBootstrapperType.LocalMachineBootstrapper:
     137                        // LocalMachineBootstrapper = only local connection (runs only on one machine)
     138                        _bootstrapper = new LocalMachineBootstrapper();
     139                        break;
     140                    case P2PBootstrapperType.IrcBootstrapper:
     141                        // setup nat traversal stuff
     142                        LogToMonitor("Init Bootstrapper: Using NAT Traversal stuff");
     143                        PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.DelaySymmetricResponse = true;
     144                        PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.IncludeSymmetricInResponse = false;
     145                        PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapper.Settings.SymmetricResponseDelay = 6000;
     146
     147                        PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.DelaySymmetricResponse = true;
     148                        PeersAtPlay.P2POverlay.Bootstrapper.IrcBootstrapperV2.Settings.IncludeSymmetricResponse = false;
     149
     150                        _bootstrapper = new IrcBootstrapper(scheduler);
     151                        break;
     152                    default:
     153                        throw (new NotImplementedException());
     154                }
     155
     156                switch (P2PSettings.Default.Overlay)
     157                {
     158                    case P2POverlayType.FullMeshOverlay:
     159                        // changing overlay example: this.overlay = new ChordOverlay();
     160                        _overlay = new FullMeshOverlay(scheduler);
     161                        break;
     162                    default:
     163                        throw (new NotImplementedException());
     164                }
     165
     166                switch (P2PSettings.Default.Dht)
     167                {
     168                    case P2PDHTType.FullMeshDHT:
     169                        Dht = new FullMeshDHT(scheduler);
     170                        break;
     171                    default:
     172                        throw (new NotImplementedException());
     173                }
     174
     175                _overlay.MessageReceived += OverlayMessageReceived;
     176                Dht.SystemJoined += OnDhtSystemJoined;
     177                Dht.SystemLeft += OnDhtSystemLeft;
     178
     179                VersionedDht = (IVersionedDHT) Dht;
     180
     181                _p2PManager.GuiLogMessage("Initializing DHT with world name " + P2PSettings.Default.WorldName,
     182                                                  NotificationLevel.Info);
     183                Dht.Initialize(P2PSettings.Default.PeerName, string.Empty, P2PSettings.Default.WorldName, _overlay,
     184                               _bootstrapper,
     185                               _linkmanager, null);
     186
     187                Initialized = true;
     188            }
    180189        }
    181190
     
    192201        public bool SynchStart()
    193202        {
    194             if (!Initialized)
    195             {
    196                 throw new InvalidOperationException("Peer-to-peer is not initialized.");
    197             }
    198 
    199             if (Started)
    200             {
     203            lock (_connectLock)
     204            {
     205                if (!Initialized)
     206                {
     207                    throw new InvalidOperationException("Peer-to-peer is not initialized.");
     208                }
     209
     210                if (Started)
     211                {
     212                    return true;
     213                }
     214
     215                Dht.BeginStart(BeginStartEventHandler);
     216
     217                // Wait for event SystemJoined. When it's invoked, the peer completely joined the P2P system
     218                _systemJoined.WaitOne();
     219                _p2PManager.GuiLogMessage("System join process ended.", NotificationLevel.Debug);
     220
    201221                return true;
    202222            }
    203 
    204             Dht.BeginStart(null);
    205 
    206             // Wait for event SystemJoined. When it's invoked, the peer completely joined the P2P system
    207             _systemJoined.WaitOne();
    208 
    209             return true;
     223        }
     224
     225        private void BeginStartEventHandler(DHTEventArgs eventArgs)
     226        {
     227            _p2PManager.GuiLogMessage("Received DHTEventArgs: " + eventArgs + ", state: " + eventArgs.State, NotificationLevel.Debug);
    210228        }
    211229
     
    216234        public bool SynchStop()
    217235        {
    218             if (Dht == null) return false;
    219 
    220             Dht.BeginStop(null);
    221 
    222             // wait till systemLeft Event is invoked
    223             _systemLeft.WaitOne();
    224 
    225             return true;
     236            lock (_connectLock)
     237            {
     238                if (Dht == null) return false;
     239
     240                Dht.BeginStop(null);
     241
     242                // wait till systemLeft Event is invoked
     243                _systemLeft.WaitOne();
     244
     245                return true;
     246            }
    226247        }
    227248
     
    311332
    312333            // Allow new connection to start and check for waiting / blocked tasks
    313             P2PManager.Instance.IsP2PConnecting = false;
     334            _p2PManager.IsP2PConnecting = false;
    314335            _systemLeft.Set();
    315336            _systemJoined.Set();
Note: See TracChangeset for help on using the changeset viewer.