Beispiel #1
0
 public ServerDuplexSessionChannel(MessageEncoderFactory messageEncoderFactory, BufferManager bufferManager, int maxBufferSize,
                                   IAsyncDvcChannel socket, EndpointAddress localAddress, ChannelManagerBase channelManager)
     : base(messageEncoderFactory, bufferManager, maxBufferSize, AnonymousAddress, localAddress,
            AnonymousAddress.Uri, channelManager)
 {
     base.InitializeSocket(socket);
 }
Beispiel #2
0
 private static async void ReceiveAsync(IAsyncDvcChannel obj)
 {
     while (true)
     {
         Console.WriteLine($"{obj.GetHashCode():x8}\t > " + Encoding.UTF8.GetString(await obj.ReadMessageAsync()));
     }
 }
 public ConnectionProxy(string serviceName, IAsyncDvcChannel connection)
 {
     this.ServiceName   = serviceName;
     this.Connection    = connection;
     this.CallbackProxy = new ClientCallbackProxy(this);
     this.ReadThread    = RunReadThread();
 }
Beispiel #4
0
        private static async Task ReadAsync(IAsyncDvcChannel dvc)
        {
            while (true)
            {
                var packet = await dvc.ReadMessageAsync();

                Console.WriteLine("> " + Encoding.UTF8.GetString(packet));
            }
        }
        protected void InitializeSocket(IAsyncDvcChannel socket)
        {
            if (this.channel != null)
            {
                throw new InvalidOperationException("Socket is already set");
            }

            this.channel = socket;
        }
 protected override void OnAbort()
 {
     try
     {
         channel?.Dispose();
     }
     catch (ObjectDisposedException) { /* no-op */ }
     catch (OperationCanceledException) { /* no-op */ }
     catch (DvcChannelDisconnectedException) { /* no-op */ }
     channel = null;
 }
Beispiel #7
0
        private static async void HandleTest1(IAsyncDvcChannel obj)
        {
            await obj.SendMessageAsync(Encoding.UTF8.GetBytes("Connected"));

            while (true)
            {
                var text = Encoding.UTF8.GetString(await obj.ReadMessageAsync());
                Console.WriteLine($"{obj.GetHashCode():x8}\tReceived {text}");
                await obj.SendMessageAsync(Encoding.UTF8.GetBytes(text));
            }
        }
        // Called from DVC API
        public async void AcceptConnection(IAsyncDvcChannel channel)
        {
            ServiceRegistration existingRegistration;

            try
            {
                var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));

                // Read service name
                var serviceNameUtf8 = await channel.ReadMessageAsync(cts.Token).ConfigureAwait(false);

                var serviceName = Encoding.UTF8.GetString(serviceNameUtf8);

                // Lookup service
                lock (syncRegisteredServices)
                {
                    if (!RegisteredServices.TryGetValue(serviceName, out existingRegistration))
                    {
                        throw new ChannelNotAvailableException($"Service '{serviceName}' not registered");
                    }
                }

                // Accept
                await channel.SendMessageAsync(Encoding.UTF8.GetBytes("ACCEPTED")).ConfigureAwait(false);
            }
            catch (Exception ex)
            {
                Logger.Error(ex, "Exception trying to accept a new brokered connection");

                try
                {
                    await channel.SendMessageAsync(Encoding.UTF8.GetBytes("ERROR Service not registered")).ConfigureAwait(false);

                    channel.Dispose();
                }
                catch (OperationCanceledException) { /* no-op */ }
                catch (ObjectDisposedException) { /* no-op */ }
                catch (DvcChannelDisconnectedException) { /* no-op */ }
                catch (Exception ex2)
                {
                    Logger.Error(ex2, "Could not notify RDS endpoint of failed conncetion attempt");
                }
                return;
            }

            if (!existingRegistration.TryAcceptConnection(channel))
            {
                KillRegistration(existingRegistration);
            }
        }
 private void AcceptConnection(IAsyncDvcChannel obj)
 {
     this.target = obj;
     Dispatcher.Invoke(() =>
     {
         ReadAsync(obj);
     });
     obj.Disconnected += (_1, e) =>
     {
         Dispatcher.Invoke(() =>
         {
             listBox.Items.Add("Disconnected");
         });
     };
 }
Beispiel #10
0
        internal bool TryAcceptConnection(IAsyncDvcChannel connection)
        {
            AssertAlive();

            var connectionProxy = new ConnectionProxy(ServiceName, connection);

            try
            {
                connectionProxy.SetHandler(Target.AcceptConnection(connectionProxy.CallbackProxy));
                return(true);
            }
            catch (COMException ex) when(ex.HResult == unchecked ((int)0x800706ba) /* RPC_S_SERVER_UNAVAILABLE */)
            {
                // caller needs to ditch this instance
                try
                {
                    connection.SendMessage(Encoding.UTF8.GetBytes("ERROR Service is no longer available"));
                }
                catch (OperationCanceledException) { /* no-op */ }
                catch (ObjectDisposedException) { /* no-op */ }
                catch (DvcChannelDisconnectedException) { /* no-op */ }
                catch (Exception ex2)
                {
                    Logger.Error(ex2, "Could not notify RDS endpoint of failed conncetion attempt");
                }

                // this will tear down connection, too.
                connectionProxy.Dispose();
                return(false);
            }
            catch (Exception ex)
            {
                try
                {
                    connectionProxy.Dispose();
                }
                catch (Exception ex2)
                {
                    Logger.Error(ex2, $"Could not tear down new connection for {ServiceName}");
                }
                Logger.Error(ex, $"Could not handle new connection for {ServiceName}");
                return(true);
            }
        }
Beispiel #11
0
        private static async void HandleTest2(IAsyncDvcChannel obj)
        {
            Console.WriteLine($"{obj.GetHashCode():x8}\tConnected");
            obj.Disconnected += (_2, e) => Console.WriteLine($"{obj.GetHashCode():x8}\tDisconnected");
            ReceiveAsync(obj);

            try
            {
                while (true)
                {
                    await Task.Delay(5000);

                    obj.SendMessage(Encoding.UTF8.GetBytes($"{obj.GetHashCode():x8}\t HB {DateTime.Now}"));
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{obj.GetHashCode():x8}\tCannot reply {ex}");
            }
        }
 private async void ReadAsync(IAsyncDvcChannel obj)
 {
     try
     {
         while (true)
         {
             listBox.Items.Add(Encoding.UTF8.GetString(await obj.ReadMessageAsync()));
         }
     }
     catch (TaskCanceledException)
     {
         listBox.Items.Add("Ending read due to cancelled");
     }
     catch (ObjectDisposedException)
     {
         listBox.Items.Add("Ending read due to ODE");
     }
     catch (DvcChannelDisconnectedException)
     {
         listBox.Items.Add("Ending read due to disconnected");
     }
 }
 public static Task SendMessageAsync(this IAsyncDvcChannel @this, byte[] data)
 => @this.SendMessageAsync(data, 0, data.Length);
 public static void SendMessage(this IAsyncDvcChannel @this, byte[] data)
 => @this.SendMessage(data, 0, data.Length);