示例#1
0
        public void Disconnect(SPClient client)
        {
            try
            {
                EventAggregator.UnsubscribeFromAllChannels(client);
                RemoteMethodEventAggregator.UnsubscribeFromAllChannels(client);
                ReplicationEventAggregator.ReleaseClient(client);

                client.Reset();
                client.Socket.BeginDisconnect(false, EndDisconect, client);
            }
            catch (Exception e)
            {
                _log.Error($"Exception occured on begin disconnect, {e}");
            }
        }
示例#2
0
        private void ReadCallback(IAsyncResult ar)
        {
            var connection = (SPClient)ar.AsyncState;

            try
            {
                var readed = connection.Socket.EndReceive(ar, out var err);
                if (err != SocketError.Success || readed <= 0)
                {
                    connection.Socket.Disconnect(false);
                    connection.Socket.Close();
                    _connectionsPool.Release(connection);
                    return;
                }

                var buf = connection.WaitPacketLength;
                var len = BitConverter.ToUInt16(buf, 0);
                if (len > 0)
                {
                    var packetDataBuffer = new byte[len];
                    var r = 0;
                    while (r < packetDataBuffer.Length)
                    {
                        r += connection.Socket.Receive(packetDataBuffer, r, packetDataBuffer.Length - r, SocketFlags.None);
                    }

                    ThreadPool.QueueUserWorkItem((callback) =>
                    {
                        var message = MessagePackSerializer.Deserialize <IMessageEvent>(packetDataBuffer);

                        switch (message)
                        {
                        case PublishEvent publish:
                            EventAggregator.Publish(publish.Channel, publish.Message.Data, publish.Message.Header, connection);
                            break;

                        case SubscribeEvent subscribe:
                            EventAggregator.Subscribe(subscribe.Channel, connection);
                            break;

                        case UnsubscribeEvent unsubsribe:
                            if (unsubsribe.FromAll)
                            {
                                EventAggregator.UnsubscribeFromAllChannels(connection);
                            }
                            else
                            {
                                EventAggregator.Unsubscribe(unsubsribe.Channel, connection);
                            }
                            break;

                        case RMINotyfiEvent rmiEvent:
                            RemoteMethodEventAggregator.Subscribe(connection, rmiEvent);
                            break;

                        case RemoteMethodEvent remoteEvent:
                            RemoteMethodEventAggregator.Publish(remoteEvent, connection);
                            break;

                        case ReplicationListUpdateEvent repListEvent:
                            ReplicationEventAggregator.DispatchGenericReplicationInfo(connection, repListEvent);
                            break;

                        case ReplicationNotyfiEvent repNotyfi:
                            ReplicationEventAggregator.SetReplicationInfo(connection, repNotyfi.ObjectsToReplicate);
                            break;

                        case ReplicationPrimitiveUpdateEvent primitiveUpdateEvent:
                            ReplicationEventAggregator.DispatchPrimitiveReplicationInfo(connection, primitiveUpdateEvent);
                            break;
                        }
                    });
                }
                else
                {
                    connection.Socket.BeginReceive(connection.WaitPacketLength, 0, connection.WaitPacketLength.Length, SocketFlags.None, ReadCallback, connection);
                    return;
                }

                connection.Socket.BeginReceive(connection.WaitPacketLength, 0, connection.WaitPacketLength.Length, SocketFlags.None, ReadCallback, connection);
            }
            catch (ObjectDisposedException)
            {
                connection.ReadyForRMI = false;
            }
            catch (Exception e)
            {
                if (connection != null)
                {
                    Disconnect(connection);
                }

                _log.Error(e);
            }
        }