source: trunk/CrypP2P/Internal/ConnectionManager.cs @ 2164

Last change on this file since 2164 was 2164, checked in by Sven Rech, 11 years ago

better p2p world behaviour

File size: 7.2 KB
Line 
1/*
2   Copyright 2010 Paul Lelgemann, University of Duisburg-Essen
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System;
18using System.Threading;
19using System.Windows.Threading;
20using Cryptool.P2P.Worker;
21using Cryptool.PluginBase;
22
23namespace Cryptool.P2P.Internal
24{
25    public class ConnectionManager
26    {
27        #region Delegates
28
29        public delegate void P2PConnectionStateChangeEventHandler(object sender, bool newState);
30        public delegate void P2PTryConnectingStateChangeEventHandler(object sender, bool newState);
31
32        #endregion
33
34        #region Events
35
36        public event P2PConnectionStateChangeEventHandler OnP2PConnectionStateChangeOccurred;
37        public event P2PTryConnectingStateChangeEventHandler OnP2PTryConnectingStateChangeOccurred;
38
39        #endregion
40
41        private readonly object connectLock = new object();
42        private readonly P2PBase p2PBase;
43        private DateTime lastConnectionAttempt;
44        private Dispatcher guiLogDispatcher = null;
45        private bool disconnected = false;
46
47        public ConnectionManager(P2PBase p2PBase)
48        {
49            this.p2PBase = p2PBase;
50
51            bool reconnecting = false;
52            p2PBase.OnSystemLeft += new P2PBase.SystemLeft(delegate
53                                                               {
54                                                                   if (disconnected)
55                                                                       return;
56
57                                                                   //Enforce a minimum of 2 seconds between each connection attempt:
58                                                                   if ((lastConnectionAttempt - DateTime.Now).TotalSeconds < 2)
59                                                                       Thread.Sleep(2000);
60
61                                                                   P2PManager.GuiLogMessage("Lost P2P Connection. Try reconnecting...",
62                                                                        NotificationLevel.Error);
63                                                                   reconnecting = true;
64                                                                   this.Connect();
65                                                                   guiLogDispatcher = Dispatcher.CurrentDispatcher;
66                                                               });
67            p2PBase.OnSystemJoined += new P2PBase.SystemJoined(delegate
68                                                                   {
69                                                                       if (p2PBase.IsConnected && reconnecting)
70                                                                       {
71                                                                           //TODO: This doesn't work. GuiLogMessage will never be shown:
72                                                                           if (guiLogDispatcher != null)
73                                                                                guiLogDispatcher.Invoke(DispatcherPriority.Send, (SendOrPostCallback)delegate
74                                                                                {
75                                                                                    P2PManager.GuiLogMessage("Successfully reconnected!",
76                                                                                        NotificationLevel.Balloon);
77                                                                                }, null);
78                                                                           reconnecting = false;
79                                                                       }
80                                                                   });
81        }
82
83        private bool isConnecting;
84        public bool IsConnecting { 
85            get { return isConnecting; } 
86            internal set
87            {
88                isConnecting = value;
89                if (OnP2PTryConnectingStateChangeOccurred != null)
90                {
91                    OnP2PTryConnectingStateChangeOccurred(this, isConnecting);
92                }
93            }
94        }
95
96        public void Connect()
97        {
98            lock (connectLock)
99            {
100                disconnected = false;
101                lastConnectionAttempt = DateTime.Now;
102
103                if (p2PBase.IsConnected || IsConnecting)
104                {
105                    P2PManager.GuiLogMessage("Cannot connect, already connected or connecting.",
106                                             NotificationLevel.Warning);
107                    return;
108                }
109
110                if (!IsReadyToConnect())
111                {
112                    P2PManager.GuiLogMessage("Cannot connect, configuration is broken.", NotificationLevel.Warning);
113                    return;
114                }
115
116                IsConnecting = true;
117            }
118
119            P2PManager.GuiLogMessage("Dispatching connect request with ConnectionWorker.", NotificationLevel.Debug);
120            new ConnectionWorker(p2PBase, this).Start();
121        }
122
123        public void Disconnect()
124        {
125            lock (connectLock)
126            {
127                disconnected = true;
128                if (!p2PBase.IsConnected || IsConnecting)
129                {
130                    P2PManager.GuiLogMessage("Cannot disconnect, no connection or connection attempt active.",
131                                             NotificationLevel.Warning);
132                    return;
133                }
134
135                IsConnecting = true;
136            }
137
138            P2PManager.GuiLogMessage("Dispatching disconnect request with ConnectionWorker.", NotificationLevel.Debug);
139            new ConnectionWorker(p2PBase, this).Start();
140        }
141
142        public bool IsReadyToConnect()
143        {
144            if (String.IsNullOrEmpty(P2PSettings.Default.PeerName))
145            {
146                P2PManager.GuiLogMessage("Peer-to-peer not fully configured: username missing.", NotificationLevel.Error);
147                return false;
148            }
149
150            if (String.IsNullOrEmpty(P2PSettings.Default.PeerName))
151            {
152                P2PManager.GuiLogMessage("Peer-to-peer not fully configured: world name missing.",
153                                         NotificationLevel.Error);
154                return false;
155            }
156
157            return true;
158        }
159
160        public void FireConnectionStatusChange()
161        {
162            if (OnP2PConnectionStateChangeOccurred != null)
163            {
164                OnP2PConnectionStateChangeOccurred(this, p2PBase.IsConnected);
165            }
166        }
167    }
168}
Note: See TracBrowser for help on using the repository browser.