private void InitSocket()
{
Exec(Request.Create(RequestCommand.Use).AppendArgument(DEFAULT_TUBE).ExpectStatuses(ResponseStatus.Using));
var client = ((IWatchedTubeClient)this);
var tubes = new HashSet <string>();
foreach (var tube in client.ListWatchedTubes())
{
tubes.Add(tube);
}
if (tubes.Contains(DEFAULT_TUBE))
{
tubes.Remove(DEFAULT_TUBE);
}
else
{
client.Watch(DEFAULT_TUBE);
}
var watched = 1;
foreach (var tube in tubes)
{
watched = client.Ignore(tube);
}
if (watched != 1)
{
_socket.Dispose();
throw new InitException();
}
}
public void Leave()
{
if (!_isJoined)
{
return;
}
_processor.Stop();
var keys = _processor.Get(_processor.KeyCount);
// Do this before instantiating leaver since it uses the same socket
_group.OnReceiveMessage -= _group_OnReceiveMessage;
// If we're the only node, there is no need to redistribute keys
if (_nodeCount > 1)
{
using (var _leaver = new Leaver(_config, _group, keys))
_leaver.Leave();
}
// Kill socket so we don't respond to group messages
_group.Dispose();
_isJoined = false;
LogBroker.Log(string.Format("{0} keys processed", _processor.ProcessedKeyCount));
LogBroker.Log("Leave Complete");
}
public void Dispose()
{
if (_socket != null)
{
_socket.Dispose();
_socket = null;
}
}
/// <summary>
/// Causes the server to stop listening for multicast messages, being SSDP search requests and notifications.
/// </summary>
/// <exception cref="System.ObjectDisposedException">Thrown if the <see cref="DisposableManagedObjectBase.IsDisposed"/> property is true (because <seealso cref="DisposableManagedObjectBase.Dispose()" /> has been called previously).</exception>
public void StopListeningForBroadcasts()
{
ThrowIfDisposed();
lock (_BroadcastListenSocketSynchroniser)
{
if (_BroadcastListenSocket != null)
{
_BroadcastListenSocket.Dispose();
_BroadcastListenSocket = null;
}
}
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (Interlocked.Exchange(ref _state, 1) == 0)
{
try
{
_socket.Shutdown(SocketShutdown.Both);
}
catch { }
}
if (Interlocked.Exchange(ref _state, 2) == 1)
{
try
{
_socket.Close(100);
}
catch { }
}
if (Interlocked.Exchange(ref _state, 3) == 2)
{
try
{
_socket.Dispose();
}
catch { }
}
}
base.Dispose(disposing);
}
internal void Dispose()
{
LoggedIn = false;
socket.Dispose();
socket = null;
guid = Guid.Empty;
name = null;
orgname = null;
version = null;
region = null;
message = null;
avatar = null;
orgavatar = null;
localip = null;
nodeip = null;
counters.Clear();
counters = null;
ignored.Clear();
ignored = null;
extended_props.Clear();
extended_props = null;
}
public void Dispose()
{
_disposed = true;
if (_socket != null)
{
_socket.Dispose();
}
}
private void CloseInternal()
{
_isDisposed = true;
RecordOpenCloseInfo("Tunnel closed");
_socket.Close();
_socket.Dispose();
Closed?.Invoke();
}
/// <summary>
/// Stops this instance.
/// </summary>
public void Stop()
{
_isDisposed = true;
if (_udpClient != null)
{
_udpClient.Dispose();
}
}
public void Shutdown()
{
IsAlive = false;
if (socket != null)
{
socket.Dispose();
//socket = null;
}
}
public void TearDown()
{
if (stopListening != null)
{
stopListening.Dispose();
}
wh.Dispose();
server.Dispose();
client.Dispose();
}
protected override void Dispose(bool disposing)
{
if (m_isConnected)
{
m_socket.Disconnect(false);
}
m_isConnected = false;
m_isConnecting = false;
m_socket.Dispose();
}
internal static async Task SimplePubSub(SocketConfiguration configuration)
{
ISocket socket = ToSocket(configuration);
socket.RegisterSubscriber <PubSubMessage>(msg => System.Console.WriteLine("msg received: " + msg.Message));
await socket.PublishAsync(new PubSubMessage { Message = "Published simply" });
Console.ReadLine();
socket.Dispose();
}
public virtual void OnClose(ISocket socket)
{
Debug.WriteLine("Socket OnClose.");
socket.Dispose();
// release (indirect) reference to socket
transactionDelegateSubscription.Dispose();
transactionDelegateSubscription = null;
// XXX return self to freelist
}
protected override void OnDispose(bool disposing)
{
base.OnDispose(disposing);
var host = _Host;
// 如果是已连接的会话，可以销毁
if (host != null && Connected)
{
_Host.Dispose();
}
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
protected virtual void Dispose(bool dispose)
{
if (dispose)
{
_isDisposed = true;
if (_udpClient != null)
{
_udpClient.Dispose();
}
}
}
private void Reclaim(ISocket socket)
{
if (_disposed)
{
socket.Dispose();
return;
}
lock (_availableSockets) {
if (!_busySockets.Remove(socket))
{
return;
}
if (!socket.Connected || _availableSockets.Count + _busySockets.Count >= MaxConnections)
{
// drop socket
socket.Dispose();
return;
}
_availableSockets.Enqueue(new Available(socket));
}
}
/// <summary>
/// Causes the server to stop listening for multicast messages, being SSDP search requests and notifications.
/// </summary>
/// <exception cref="ObjectDisposedException">Thrown if the <see cref="DisposableManagedObjectBase.IsDisposed"/> property is true (because <seealso cref="DisposableManagedObjectBase.Dispose()" /> has been called previously).</exception>
public void StopListeningForBroadcasts()
{
lock (_BroadcastListenSocketSynchroniser)
{
if (_BroadcastListenSocket != null)
{
_logger.LogInformation("{0} disposing _BroadcastListenSocket", GetType().Name);
_BroadcastListenSocket.Dispose();
_BroadcastListenSocket = null;
}
}
}
public void OnClose(ISocket socket)
{
Debug.WriteLine("Socket OnClose.");
socket.Dispose();
// release (indirect) reference to socket
transactionDelegateSubscription.Dispose();
transactionDelegateSubscription = null;
// XXX return self to freelist
}
public void Send_ThrowsInterruptConnection_ShouldBeCaught()
{
var paramToSent = new byte[] { 0b01010101 };
Mock.Arrange(() => _socket.Send(null)).IgnoreArguments().Throws(new SocketException(10054));
_sut = new NetworkTunnel(_socket, _recorder);
_sut.Send(paramToSent);
Mock.Assert(() => _socket.Dispose(), Occurs.Exactly(1));
Mock.Assert(() => _recorder.RecordInfo(Arg.AnyString, Arg.AnyString), Occurs.Exactly(3));
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Never());
}
public void Dispose()
{
if (_isDisposed)
{
return;
}
_listenerSocket?.Dispose();
_cts.Dispose();
_isDisposed = true;
}
public ISocketDelegate OnConnection(IServer server, ISocket socket)
{
NumOnConnectionEvents++;
if (OnConnectionAction != null)
{
return OnConnectionAction(server, socket);
}
else
{
socket.Dispose();
return null;
}
}
public void Stop()
{
cancellationTokenSource.Cancel();
heartBeating?.Dispose();
inMessageQueue.CompleteAdding();
outMessageQueue.CompleteAdding();
receiving?.Wait(TerminationWaitTimeout);
sending?.Wait(TerminationWaitTimeout);
notifyListeners?.Wait(TerminationWaitTimeout);
inMessageQueue.Dispose();
outMessageQueue.Dispose();
cancellationTokenSource.Dispose();
intercomSocket?.Dispose();
}
public ISocketDelegate OnConnection(IServer server, ISocket socket)
{
NumOnConnectionEvents++;
if (OnConnectionAction != null)
{
return(OnConnectionAction(server, socket));
}
else
{
socket.Dispose();
return(null);
}
}
public string LookupDotComDomain(string domainName, int port, string whoisServer,
string whoisServerLookupQueryPrefix, int responseBufferSizeInBytes)
{
Guard.WhenArgument(domainName, "DomainName").IsNullOrEmpty().Throw();
if (domainName.StartsWith(WhoisConstants.ForbiddenDomainStartSymbol))
{
throw new ArgumentException("Domain name cannot start with hyphen.");
}
if (!domainName.ToLower().EndsWith(WhoisConstants.DomainEndPattern))
{
throw new ArgumentException("Domain name should be a .com domain.");
}
var regex = new Regex(WhoisConstants.RegexDomainPattern);
// remove ".com"
if (!regex.IsMatch(domainName.ToLower().Substring(0, domainName.Length - 4)))
{
throw new ArgumentException("Domain should only contain letters, numbers or hyphen.");
}
Guard.WhenArgument(domainName.Length, "DomainName").IsLessThan(WhoisConstants.MinimumDomainNameLength).Throw();
Guard.WhenArgument(domainName.Length, "DomainName").IsGreaterThan(WhoisConstants.MaximumDomainNameLength).Throw();
Guard.WhenArgument(port, "Port").IsLessThan(WhoisConstants.TcpMinPort).Throw();
Guard.WhenArgument(port, "Port").IsGreaterThan(WhoisConstants.TcpMaxPort).Throw();
Guard.WhenArgument(whoisServer, "WhoisServer").IsNullOrEmpty().Throw();
Guard.WhenArgument(whoisServerLookupQueryPrefix, "WhoisServerLookupQueryPrefix").IsNullOrEmpty().Throw();
Guard.WhenArgument(responseBufferSizeInBytes, "ResponseBufferSizeInBytes").IsLessThan(WhoisConstants.MinimumResponseBufferSizeInBytes).Throw();
Guard.WhenArgument(responseBufferSizeInBytes, "ResponseBufferSizeInBytes").IsGreaterThan(WhoisConstants.MaximumResponseBufferSizeInBytes).Throw();
socket.Connect(whoisServer, port);
byte[] query = Encoding.ASCII.GetBytes(whoisServerLookupQueryPrefix + domainName + Environment.NewLine);
socket.Send(query);
byte[] responseBytes = new byte[responseBufferSizeInBytes];
socket.Receive(responseBytes);
socket.Dispose();
string humanReadableResponse = Encoding.UTF8.GetString(responseBytes);
return(humanReadableResponse);
}
protected virtual void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
ISocket socket = this._socket;
if (null == socket)
{
return;
}
this._socket = (ISocket)null;
socket.Dispose();
}
protected virtual void Dispose(bool suppressFinalizer)
{
if (_disposed)
{
return;
}
if (suppressFinalizer)
{
GC.SuppressFinalize(this);
}
if (_socket != null)
{
_socket.Dispose();
}
_disposed = true;
}
protected virtual void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
_disposed = true;
CurrentState = State.Stopped;
// create a task which cleans up
Task.Run(async() =>
{
// Dispose should not throw anything
try
{
// we are called from Dispose()
if (disposing)
{
if (null != _socket)
{
await _socket.DisconnectAsync();
}
if (null != _receivingTask)
{
await _receivingTask;
_receivingTask = null;
}
if (null != _socket)
{
_socket.Dispose();
_socket = null;
}
if (null != _serializer)
{
_serializer = null;
}
}
}
catch { }
});
}
internal static async Task PubSubWithCancellation(SocketConfiguration configuration)
{
ISocket socket = ToSocket(configuration);
using var cts = new CancellationTokenSource();
var token = cts.Token;
socket.RegisterSubscriber <PubSubMessage>(msg => System.Console.WriteLine("msg received: " + msg.Message), token);
cts.Cancel();
System.Console.WriteLine("try multiple Publishes");
foreach (var item in Enumerable.Range(0, 3))
{
await socket.PublishAsync(new PubSubMessage { Message = "Published with cancellation" });
}
System.Console.WriteLine("press any key to exit");
Console.ReadLine();
socket.Dispose();
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_currentState = States.Stopped;
_disposingTask = Task.Run(async() =>
{
try
{
if (null != _socket)
{
await _socket.DisconnectAsync();
}
if (null != _receivingTask)
{
await _receivingTask;
_receivingTask = null;
}
if (null != _socket)
{
_socket.Dispose();
_socket = null;
}
if (null != _serializer)
{
_serializer = null;
}
}
catch
{
}
});
GC.SuppressFinalize(this);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (!disposedValue)
{
if (disposing)
{
// TODO: dispose managed state (managed objects)
_socketSubscription?.Dispose();
_socket.Stop();
_socket.Dispose();
_httpClient.Dispose();
}
// TODO: free unmanaged resources (unmanaged objects) and override finalizer
// TODO: set large fields to null
disposedValue = true;
}
}
public bool Close()
{
bool rt = false;
int errorCode = 0; string errorMsg = "关闭成功";
try
{
//若Socket已经打开，则关闭
if (ISocket != null && ISocket.Connected)
{
ISocket.Shutdown(System.Net.Sockets.SocketShutdown.Both);
System.Threading.Thread.Sleep(100);
ISocket.Close();
}
rt = true;
}
catch (Exception ex)
{
errorCode = 1;
errorMsg = string.Format("服务器[{0}]{1}", ISocket.RemoteEndPoint, ex.Message);
if (ClosedEvt != null)
{
System.Windows.Forms.Control target = ClosedEvt.Target as System.Windows.Forms.Control;
errorCode = 1;
errorMsg = string.Format("服务器[{0}]{1}", ISocket.RemoteEndPoint, errorMsg);
if (target != null && target.InvokeRequired)
{
//非创建控件线程同步调用事件：SocketClosed
target.Invoke(ClosedEvt, new object[] { errorCode, errorMsg });
}
else
{
//创建控件线程调用事件
ClosedEvt(SktProperty, errorCode, errorMsg);
}
}
ISocket.Dispose();
ISocket = null;
}
finally { }
return(rt);
}
private void Reclaim(ISocket socket) {
if(_disposed) {
socket.Dispose();
return;
}
lock(_availableSockets) {
if(!_busySockets.Remove(socket)) {
return;
}
if(!socket.Connected || _availableSockets.Count + _busySockets.Count >= MaxConnections) {
// drop socket
socket.Dispose();
return;
}
_availableSockets.Enqueue(new Available(socket));
}
}
private void Reclaim(ISocket socket) {
if(_disposed) {
socket.Dispose();
return;
}
lock(_syncroot) {
if(!_busySockets.Remove(socket)) {
return;
}
if(socket.IsDisposed) {
// drop disposed sockets
socket.Dispose();
return;
}
// Try to hand the socket to the next client waiting in line
if(_waitingQueue.ProvideSocket(socket)) {
return;
}
if(_availableSockets.Count + _busySockets.Count >= MaxConnections) {
// drop socket if we've already hit the max
socket.Dispose();
return;
}
// Add reclaimed socket to end of available list
_availableSockets.Add(new Available(socket));
}
}
