Changeset 1589


Ignore:
Timestamp:
Jun 5, 2010, 2:36:48 PM (12 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
Location:
trunk
Files:
5 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();
  • trunk/CrypP2P/P2PManager.cs

    r1580 r1589  
    3535        private P2PManager()
    3636        {
    37             P2PBase = new P2PBase();
     37            P2PBase = new P2PBase(this);
    3838
    3939            // to forward event from overlay/dht MessageReceived-Event from P2PBase
  • trunk/CrypPlugins/PeerToPeerBaseProxy/P2PPeer.cs

    r1545 r1589  
    6161                                       new GuiLogEventArgs(p + "(" + DebugToFile.GetTimeStamp() + ")", this,
    6262                                                           notificationLevel));
    63             //EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
    64         }
    65 
    66         public void LogInternalState()
    67         {
    68             P2PManager.Instance.P2PBase.LogInternalState();
    6963        }
    7064
     
    110104        public void StopPeer()
    111105        {
    112             GuiLogMessage("Peer cannot be stopped, it is running in CrypTool!", NotificationLevel.Info);
     106            P2PManager.Instance.P2PBase.OnP2PMessageReceived -= P2PBaseOnP2PMessageReceived;
     107            GuiLogMessage("Removed event registration, but peer cannot be stopped, it is running in CrypTool!", NotificationLevel.Info);
    113108        }
    114109
     
    126121        public P2PPeer()
    127122        {
    128             _settings = new P2PPeerSettings(this);
     123            _settings = new P2PPeerSettings();
    129124            _settings.TaskPaneAttributeChanged += SettingsTaskPaneAttributeChanged;
    130125            _settings.OnPluginStatusChanged += SettingsOnPluginStatusChanged;
     
    156151        public void Execute()
    157152        {
    158             // TODO: For future use copy functionality to Execute instead of PreExecute
    159             //       so we don't need the workaround anymore!!!
    160             // StartPeer();
    161153        }
    162154
     
    197189        private static void SettingsTaskPaneAttributeChanged(ISettings settings, TaskPaneAttributeChangedEventArgs args)
    198190        {
    199             //throw new NotImplementedException();
    200191        }
    201192
     
    280271        public bool DHTstore(string sKey, byte[] byteValue)
    281272        {
    282             if (P2PManager.Instance.IsP2PConnected())
    283                 return P2PManager.Store(sKey, byteValue);
    284             return false;
     273            return P2PManager.Instance.IsP2PConnected() && P2PManager.Store(sKey, byteValue);
    285274        }
    286275
    287276        public bool DHTstore(string sKey, string sValue)
    288277        {
    289             if (P2PManager.Instance.IsP2PConnected())
    290                 return P2PManager.Store(sKey, sValue);
    291             return false;
     278            return P2PManager.Instance.IsP2PConnected() && P2PManager.Store(sKey, sValue);
    292279        }
    293280
    294281        public byte[] DHTload(string sKey)
    295282        {
    296             if (P2PManager.Instance.IsP2PConnected())
    297                 return P2PManager.Retrieve(sKey);
    298             return null;
     283            return P2PManager.Instance.IsP2PConnected() ? P2PManager.Retrieve(sKey) : null;
    299284        }
    300285
    301286        public bool DHTremove(string sKey)
    302287        {
    303             if (P2PManager.Instance.IsP2PConnected())
    304                 return P2PManager.Remove(sKey);
    305             return false;
     288            return P2PManager.Instance.IsP2PConnected() && P2PManager.Remove(sKey);
    306289        }
    307290
     
    322305                return _peerId;
    323306            }
     307
    324308            sPeerName = _sPeerName;
    325309            return null;
  • trunk/CrypPlugins/PeerToPeerBaseProxy/P2PPeerSettings.cs

    r1458 r1589  
    1919        #endregion
    2020
    21         private readonly P2PPeer p2pPeer;
    22 
    2321        #region ISettings Members
    2422
     
    3129        #region taskPane
    3230
    33         public P2PPeerSettings(P2PPeer p2pPeer)
     31        public P2PPeerSettings()
    3432        {
    3533            if (TaskPaneAttributeChanged != null)
     
    3836                                                                                                             Visibility.
    3937                                                                                                                 Hidden)));
    40             this.p2pPeer = p2pPeer;
    4138            ChangePluginIcon(PeerStatus.NotConnected);
    42         }
    43 
    44         #endregion
    45 
    46         #region Start- and Stop-Buttons incl. functionality
    47 
    48         [TaskPane("Internal state dump", "Dumps the interla state of the P2P system to syslog.", "P2P Expert Settings",
    49             0, true, DisplayLevel.Beginner, ControlType.Button)]
    50         public void BtnLogInternalState()
    51         {
    52             p2pPeer.LogInternalState();
    5339        }
    5440
     
    6551        }
    6652
    67         // Index depends on icon-position in P2PPeer-Class properties
    68 
    6953        /// <summary>
    7054        /// Changes icon of P2PPeer and visibility of the control buttons in settings
     
    7458        {
    7559            ChangePluginIcon(peerStat);
    76             // Only set visibility in final states!
    77             switch (peerStat)
    78             {
    79                 case PeerStatus.Online:
    80                     TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(
    81                                                        new TaskPaneAttribteContainer("BtnStart", Visibility.Collapsed)));
    82                     TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(
    83                                                        new TaskPaneAttribteContainer("BtnStop", Visibility.Visible)));
    84                     break;
    85                 case PeerStatus.NotConnected:
    86                     TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(
    87                                                        new TaskPaneAttribteContainer("BtnStart", Visibility.Visible)));
    88                     TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(
    89                                                        new TaskPaneAttribteContainer("BtnStop", Visibility.Hidden)));
    90                     break;
    91                 case PeerStatus.Error:
    92                 case PeerStatus.Connecting:
    93                 default:
    94                     break;
    95             }
    9660        }
    9761
  • trunk/CrypPlugins/PeerToPeerPublisher/P2PPublisherBase.cs

    r1587 r1589  
    181181                    return;
    182182                }
    183             } else
    184             {
    185                 GuiLogging("byRead not available. Aborting.", NotificationLevel.Error);
    186                 return;
    187183            }
    188184            /* END: CHECKING WHETHER THERE HAS ALREADY EXIST ANOTHER PUBLISHER */
Note: See TracChangeset for help on using the changeset viewer.