private async Task Handler()
        {
            while (this.IsRunning)
            {
                try
                {
                    bool isListening      = false;
                    var  connectionString = this.FrontendEndpoint.ToConnectionString();

                    using (var frontendSocket = new RouterSocket())
                        using (this.FrontendBuffer = new NetMQQueue <TransportMessage>())
                            using (var poller = new NetMQPoller()
                            {
                                frontendSocket, this.FrontendBuffer
                            })
                                using (var monitor = new NetMQ.Monitoring.NetMQMonitor(frontendSocket, $"inproc://monitor.forwarderdevice.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Accepted | SocketEvents.Disconnected | SocketEvents.Closed))
                                {
                                    frontendSocket.ReceiveReady += (sender, e) =>
                                    {
                                        try
                                        {
                                            var netmqMessage = new NetMQMessage();
                                            while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage))
                                            {
                                                var    message           = netmqMessage.ToMessage(out var envelope);
                                                string serviceIdentifier = message.Metadata.TryGetLast("serviceIdentifier", out var encodedService) ? Encoding.UTF8.GetString(encodedService) : null;

                                                try
                                                {
                                                    var cancellationSource = new CancellationTokenSource(5000);
                                                    var registeredBackend  = this.ResolveBackend(serviceIdentifier, cancellationSource.Token);
                                                    //var registeredBackend = this.InprocTransportScope.GetNextServerTransport(serviceIdentifier, cancellationSource.Token);

                                                    message.Metadata.Add($"envelope[{this.Identity}]", envelope);

                                                    //registeredBackend.ReceiveBuffer.QueueMessage(message);

                                                    registeredBackend.Send(message).ContinueWith(task =>
                                                    {
                                                        this.OnDiagnosticMessage($"Failed to forward to backend [{task.Exception.InnerException.Message}]");
                                                    }, TaskContinuationOptions.OnlyOnFaulted);
                                                }
                                                catch (OperationCanceledException)
                                                {
                                                    this.OnDiagnosticMessage($"No backends available for {serviceIdentifier}!!!");

                                                    var nmqm = MessageHelpers.CreateNetMQErrorMessage(envelope, "No backends found", message.Metadata);
                                                    e.Socket.SendMultipartMessage(nmqm);
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                                        }
                                    };

                                    this.FrontendBuffer.ReceiveReady += (sender, e) =>
                                    {
                                        try
                                        {
                                            while (this.FrontendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero))
                                            {
                                                if (!message.Metadata.TryPluckLast($"envelope[{this.Identity}]", out var envelope))
                                                {
                                                    throw new Exception("Message envelope not found");
                                                }

                                                if (!frontendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope)))
                                                {
                                                    this.OnDiagnosticMessage("Failed to forward to frontend");
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                                        }
                                    };

                                    monitor.Listening += (sender, e) =>
                                    {
                                        this.OnDiagnosticMessage($"Frontend router socket listening at {connectionString}");
                                        isListening = true;
                                    };
                                    monitor.Closed += (sender, e) =>
                                    {
                                        this.OnDiagnosticMessage($"Frontend router socket closed on {connectionString}");
                                        isListening = false;
                                    };
                                    monitor.Accepted += (sender, e) =>
                                    {
                                        this.OnDiagnosticMessage($"Frontend router socket connection accepted at {connectionString}");
                                    };
                                    monitor.Disconnected += (sender, e) =>
                                    {
                                        this.OnDiagnosticMessage($"Frontend router socket disconnected at {connectionString}");
                                    };

                                    this.OnDiagnosticMessage($"Attempting to bind frontend socket to {connectionString}");
                                    monitor.StartAsync();
                                    monitor.AttachToPoller(poller);

                                    var pollerTask = new Task(poller.Run);
                                    pollerTask.ContinueWith(task =>
                                    {
                                        var ex = task.Exception;

                                        this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                                        isListening = false;
                                    }, TaskContinuationOptions.OnlyOnFaulted);
                                    pollerTask.Start();

                                    frontendSocket.Bind(connectionString);

                                    var start = DateTime.Now;
                                    while (!isListening)
                                    {
                                        if ((DateTime.Now - start).TotalMilliseconds > 5000)
                                        {
                                            throw new Exception($"Frontend socket bind timeout ({connectionString})");
                                        }

                                        await Task.Delay(1000);
                                    }

                                    while (this.IsRunning && isListening)
                                    {
                                        await Task.Delay(1000);
                                    }

                                    poller.StopAsync();
                                    frontendSocket.Disconnect(connectionString);
                                    monitor.DetachFromPoller();
                                    monitor.Stop();
                                }
                }
                catch (Exception ex)
                {
                    this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                }
            }
        }
예제 #2
0
        private async Task BackendHandler()
        {
            while (this.IsRunning)
            {
                try
                {
                    while (this.RegisteredBackendIdentifiers.TryDequeue(out string identifier))
                    {
                    }

                    bool isListening      = false;
                    var  connectionString = this.BackendEndpoint.ToConnectionString();

                    using (var backendSocket = new RouterSocket())
                        using (this.AltBackendBuffer = new NetMQQueue <TransportMessage>())
                            using (var poller = new NetMQPoller()
                            {
                                backendSocket, this.AltBackendBuffer
                            })
                                using (var monitor = new NetMQ.Monitoring.NetMQMonitor(backendSocket, $"inproc://monitor.routerdevice.backend.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Disconnected | SocketEvents.Closed | SocketEvents.BindFailed))
                                {
                                    backendSocket.ReceiveReady += (sender, e) =>
                                    {
                                        try
                                        {
                                            //Console.WriteLine("Backend message received");
                                            //Console.WriteLine($"RECEIVED BACKEND ({this.BackendSocket.HasIn}) ({this.BackendSocket.HasOut})");

                                            var netmqMessage = new NetMQMessage();
                                            while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage))
                                            {
                                                var message = netmqMessage.ToMessage(out var envelope);

                                                this.OnBackendReceived(message);

                                                //this.BackendBuffer.Enqueue(message);

                                                if (message.Metadata.TryPluck("Greeting", out var encodedGreeting))
                                                {
                                                    var identifier = BitConverter.ToString(envelope);

                                                    if (this.RegisteredBackends.TryAdd(identifier, new RegisteredBackend(envelope, DateTime.UtcNow)))
                                                    {
                                                        Console.WriteLine($"Backend registered [ {identifier} ]");
                                                        this.RegisteredBackendIdentifiers.Enqueue(identifier);
                                                    }
                                                    else
                                                    {
                                                        this.RegisteredBackends[identifier].RegsiteredDate = DateTime.UtcNow;
                                                    }
                                                }
                                                else
                                                {
                                                    this.AltFrontendBuffer.Enqueue(message);
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                        }
                                    };

                                    //var lastFlushed = DateTime.UtcNow;
                                    //backendSocket.SendReady += (sender, e) =>
                                    //{
                                    //    try
                                    //    {
                                    //        if (!this.FrontendBuffer.IsEmpty)
                                    //        {
                                    //            while (this.FrontendBuffer.TryDequeue(out Message message))
                                    //            {
                                    //                Console.WriteLine("Frontend forwarding");

                                    //                if (!e.Socket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(true)))
                                    //                {
                                    //                    Console.WriteLine("Failed to forward to backend");

                                    //                    //var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope);
                                    //                    //this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true));
                                    //                }
                                    //            }

                                    //            lastFlushed = DateTime.UtcNow;
                                    //        }

                                    //        if ((DateTime.UtcNow - lastFlushed).TotalSeconds > 1)
                                    //            Task.Delay(1).Wait();
                                    //    }
                                    //    catch (Exception ex)
                                    //    {
                                    //        Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                    //    }
                                    //};
                                    this.AltBackendBuffer.ReceiveReady += (sender, e) =>
                                    {
                                        try
                                        {
                                            while (this.AltBackendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero))
                                            {
                                                if (!message.Metadata.TryPluck($"backendEnvelope[{this.Identity}]", out var envelope))
                                                {
                                                    throw new Exception("Message backend envelope not found");
                                                }

                                                this.OnFrontendForwarded(message);

                                                if (!backendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope)))
                                                {
                                                    Console.WriteLine("Failed to forward to backend");

                                                    //var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope);
                                                    //this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true));
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                        }
                                    };

                                    monitor.Listening += (sender, e) =>
                                    {
                                        Console.WriteLine($"Backend router socket listening at {connectionString}");
                                        isListening = true;
                                    };
                                    monitor.Closed += (sender, e) =>
                                    {
                                        Console.WriteLine($"Backend router socket accepted connection on {connectionString}");
                                        isListening = false;
                                    };
                                    monitor.Disconnected += (sender, e) =>
                                    {
                                        Console.WriteLine($"Backend router socket disconnected at {connectionString}");
                                    };
                                    monitor.BindFailed += (sender, e) =>
                                    {
                                        Console.WriteLine($"Backend router bind failed {connectionString}");
                                    };

                                    Console.WriteLine($"Attempting to bind backend socket to {connectionString}");
                                    monitor.StartAsync();
                                    monitor.AttachToPoller(poller);

                                    var pollerTask = new Task(poller.Run);
                                    pollerTask.ContinueWith((Task task) =>
                                    {
                                        var ex = task.Exception;

                                        Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                        isListening = false;
                                    }, TaskContinuationOptions.OnlyOnFaulted);
                                    pollerTask.Start();

                                    backendSocket.Bind(connectionString);

                                    var start = DateTime.Now;
                                    while (!isListening)
                                    {
                                        if ((DateTime.Now - start).TotalMilliseconds > 5000)
                                        {
                                            throw new Exception($"Backend socket bind timeout ({connectionString})");
                                        }

                                        await Task.Delay(1000);
                                    }

                                    while (this.IsRunning && isListening)
                                    {
                                        if (this.BackendAnnouncer != null)
                                        {
                                            //Console.WriteLine("Registering backend");
                                            await this.BackendAnnouncer.Register(this.BackendEndpoint);
                                        }

                                        await Task.Delay(1000);
                                    }

                                    poller.StopAsync();
                                    backendSocket.Disconnect(connectionString);
                                    monitor.DetachFromPoller();
                                    monitor.Stop();
                                }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                }
            }
        }
예제 #3
0
            private async Task Handler()
            {
                while (this.IsRunning)
                {
                    try
                    {
                        using (var socket = new DealerSocket())
                            using (this.BackendBuffer = new NetMQQueue <TransportMessage>())
                                using (var poller = new NetMQPoller()
                                {
                                    socket, this.BackendBuffer
                                })
                                    using (var monitor = new NetMQ.Monitoring.NetMQMonitor(socket, $"inproc://monitor.forwarderdevice.backend.{Guid.NewGuid().ToString()}", SocketEvents.Connected | SocketEvents.Disconnected))
                                    {
                                        socket.Options.Identity = System.Text.Encoding.ASCII.GetBytes(Guid.NewGuid().ToString().Replace("-", "").ToLowerInvariant());

                                        socket.ReceiveReady += (sender, e) =>
                                        {
                                            try
                                            {
                                                var netmqMessage = new NetMQMessage();
                                                if (e.Socket.TryReceiveMultipartMessage(ref netmqMessage))
                                                {
                                                    var message = netmqMessage.ToMessage();

                                                    this.ForwarderDevice.OnBackendReceived(message);

                                                    this.ForwarderDevice.frontendBuffer.Enqueue(message);
                                                }
                                            }
                                            catch (Exception ex)
                                            {
                                                this.ForwarderDevice.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                                            }
                                        };

                                        this.BackendBuffer.ReceiveReady += (sender, e) =>
                                        {
                                            try
                                            {
                                                while (this.BackendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero))
                                                {
                                                    this.ForwarderDevice.OnFrontendForwarded(message);

                                                    this.ForwarderDevice.OnDiagnosticMessage("Forwarding message to " + this.Endpoint.ToConnectionString());
                                                    if (!socket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage()))
                                                    {
                                                        this.ForwarderDevice.OnDiagnosticMessage("Failed to send message");
                                                    }
                                                }
                                            }
                                            catch (Exception ex)
                                            {
                                                this.ForwarderDevice.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                                            }
                                        };

                                        monitor.Connected += (sender, e) =>
                                        {
                                            this.ForwarderDevice.OnDiagnosticMessage($"Dealer socket conntected to {this.Endpoint.ToConnectionString()}");
                                            this.IsConnected = true;
                                        };
                                        monitor.Disconnected += (sender, e) =>
                                        {
                                            this.ForwarderDevice.OnDiagnosticMessage($"Dealer socket disconntected from {this.Endpoint.ToConnectionString()}");
                                            this.IsConnected = false;
                                        };

                                        this.ForwarderDevice.OnDiagnosticMessage($"Attempting to connect to {this.Endpoint.ToConnectionString()}");
                                        monitor.StartAsync();
                                        monitor.AttachToPoller(poller);

                                        var pollerTask = new Task(poller.Run);
                                        pollerTask.ContinueWith((Task task) =>
                                        {
                                            var ex = task.Exception;

                                            this.ForwarderDevice.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                                            this.IsConnected = false;
                                        }, TaskContinuationOptions.OnlyOnFaulted);
                                        pollerTask.Start();

                                        socket.Connect(this.Endpoint.ToConnectionString());

                                        var start = DateTime.Now;
                                        while (!this.IsConnected)
                                        {
                                            if ((DateTime.Now - start).TotalMilliseconds > 5000)
                                            {
                                                throw new Exception($"Connection timeout [{this.ServiceName}]");
                                            }

                                            await Task.Delay(1000);
                                        }

                                        while (this.IsConnected && this.IsRunning)
                                        {
                                            await Task.Delay(1000);
                                        }

                                        this.ForwarderDevice.OnDiagnosticMessage("Closing dealer socket...");
                                        poller.StopAsync();
                                        socket.Disconnect(this.Endpoint.ToConnectionString());
                                        monitor.DetachFromPoller();
                                        monitor.Stop();

                                        this.IsConnected = false;
                                    }

                        if (this.IsRunning)
                        {
                            await Task.Delay(1000);
                        }
                    }
                    catch (Exception ex)
                    {
                        this.ForwarderDevice.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                    }
                }
            }
예제 #4
0
        private async Task FrontendHandler()
        {
            while (this.IsRunning)
            {
                try
                {
                    bool isListening      = false;
                    var  connectionString = this.FrontendEndpoint.ToConnectionString();

                    using (var frontendSocket = new RouterSocket())
                        using (this.AltFrontendBuffer = new NetMQQueue <TransportMessage>())
                            using (var poller = new NetMQPoller()
                            {
                                frontendSocket, this.AltFrontendBuffer
                            })
                                using (var monitor = new NetMQ.Monitoring.NetMQMonitor(frontendSocket, $"inproc://monitor.routerdevice.frontend.{Guid.NewGuid().ToString()}", SocketEvents.Listening | SocketEvents.Accepted | SocketEvents.Disconnected | SocketEvents.Closed))
                                {
                                    frontendSocket.ReceiveReady += (sender, e) =>
                                    {
                                        try
                                        {
                                            var netmqMessage = new NetMQMessage();
                                            while (e.Socket.TryReceiveMultipartMessage(ref netmqMessage))
                                            {
                                                //Console.WriteLine("Frontend message received");

                                                var message = netmqMessage.ToMessage(out var envelope);

                                                this.OnFrontendReceived(message);

                                                //this.receiveCount++;
                                                //Console.WriteLine("RECEIVED " + this.receiveCount);

                                                //var sourceEnvelope = message.Envelope;

                                                RegisteredBackend registeredBackend = null;
                                                var forwardStart = DateTime.UtcNow;
                                                while (this.IsRunning && registeredBackend == null)
                                                {
                                                    while (this.RegisteredBackendIdentifiers.TryDequeue(out string backendIdentifier))
                                                    {
                                                        registeredBackend = this.RegisteredBackends[backendIdentifier];

                                                        if ((DateTime.UtcNow - registeredBackend.RegsiteredDate).TotalMilliseconds < 2000)
                                                        {
                                                            this.RegisteredBackendIdentifiers.Enqueue(backendIdentifier);
                                                            break;
                                                        }
                                                        else
                                                        {
                                                            if (this.RegisteredBackends.TryRemove(backendIdentifier, out RegisteredBackend expiredBackend))
                                                            {
                                                                Console.WriteLine($"Backend {backendIdentifier} expired");
                                                            }
                                                        }
                                                    }

                                                    if (registeredBackend != null || (DateTime.Now - forwardStart).TotalMilliseconds > 30000)
                                                    {
                                                        break;
                                                    }

                                                    System.Threading.Thread.Sleep(100);
                                                }

                                                if (registeredBackend != null)
                                                {
                                                    //Console.WriteLine($"Forwarding to [ {BitConverter.ToString(registeredBackend.Envelope)} ]");

                                                    message.Metadata.Add($"envelope[{this.Identity}]", envelope);
                                                    message.Metadata.Add($"backendEnvelope[{this.Identity}]", registeredBackend.Envelope);

                                                    this.AltBackendBuffer.Enqueue(message);

                                                    ////this.BackendSocket.SendMultipartMessage(message.ToNetMQMessage(true));
                                                    //if (!this.BackendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(true)))
                                                    //{
                                                    //    Console.WriteLine("Failed to forward to backend");

                                                    //    var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope);
                                                    //    this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true));
                                                    //}
                                                }
                                                else
                                                {
                                                    Console.WriteLine("No backends available!!!");

                                                    var nmqm = MessageHelpers.CreateNetMQErrorMessage(envelope, "No backends found", message.Metadata);
                                                    e.Socket.SendMultipartMessage(nmqm);
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                        }
                                    };

                                    //var lastFlushed = DateTime.UtcNow;
                                    //frontendSocket.SendReady += (sender, e) =>
                                    //{
                                    //    try
                                    //    {
                                    //        if (!this.BackendBuffer.IsEmpty)
                                    //        {
                                    //            while (this.BackendBuffer.TryDequeue(out Message message))
                                    //            {
                                    //                Console.WriteLine("Backend forwarding");

                                    //                if (!e.Socket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(true)))
                                    //                {
                                    //                    Console.WriteLine("Failed to forward to frontend");

                                    //                    //var forwardedMessage = new Message(1, message.Frames, System.Text.Encoding.UTF8.GetBytes("Failed to forward to backend"), sourceEnvelope);
                                    //                    //this.FrontendSocket.SendMultipartMessage(forwardedMessage.ToNetMQMessage(true));
                                    //                }
                                    //            }

                                    //            lastFlushed = DateTime.UtcNow;
                                    //        }

                                    //        if ((DateTime.UtcNow - lastFlushed).TotalSeconds > 1)
                                    //            Task.Delay(1).Wait();
                                    //    }
                                    //    catch (Exception ex)
                                    //    {
                                    //        Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                    //    }
                                    //};
                                    this.AltFrontendBuffer.ReceiveReady += (sender, e) =>
                                    {
                                        try
                                        {
                                            while (this.AltFrontendBuffer.TryDequeue(out TransportMessage message, TimeSpan.Zero))
                                            {
                                                if (!message.Metadata.TryPluck($"envelope[{this.Identity}]", out var envelope))
                                                {
                                                    throw new Exception("Message envelope not found");
                                                }

                                                this.OnBackendForwarded(message);

                                                if (!frontendSocket.TrySendMultipartMessage(TimeSpan.FromSeconds(1), message.ToNetMQMessage(envelope)))
                                                {
                                                    Console.WriteLine("Failed to forward to frontend");
                                                }
                                            }
                                        }
                                        catch (Exception ex)
                                        {
                                            Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                        }
                                    };

                                    monitor.Listening += (sender, e) =>
                                    {
                                        Console.WriteLine($"Frontend router socket listening at {connectionString}");
                                        isListening = true;
                                    };
                                    monitor.Closed += (sender, e) =>
                                    {
                                        Console.WriteLine($"Frontend router socket closed on {connectionString}");
                                        isListening = false;
                                    };
                                    monitor.Accepted += (sender, e) =>
                                    {
                                        Console.WriteLine($"Frontend router socket connection accepted at {connectionString}");
                                    };
                                    monitor.Disconnected += (sender, e) =>
                                    {
                                        Console.WriteLine($"Frontend router socket disconnected at {connectionString}");
                                    };

                                    Console.WriteLine($"Attempting to bind frontend socket to {connectionString}");
                                    monitor.StartAsync();
                                    monitor.AttachToPoller(poller);

                                    var pollerTask = new Task(poller.Run);
                                    pollerTask.ContinueWith((Task task) =>
                                    {
                                        var ex = task.Exception;

                                        Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                                        isListening = false;
                                    }, TaskContinuationOptions.OnlyOnFaulted);
                                    pollerTask.Start();

                                    frontendSocket.Bind(connectionString);

                                    var start = DateTime.Now;
                                    while (!isListening)
                                    {
                                        if ((DateTime.Now - start).TotalMilliseconds > 5000)
                                        {
                                            throw new Exception($"Frontend socket bind timeout ({connectionString})");
                                        }

                                        await Task.Delay(1000);
                                    }

                                    while (this.IsRunning && isListening)
                                    {
                                        if (this.FrontendAnnouncer != null)
                                        {
                                            //Console.WriteLine("Registering frontend");
                                            await this.FrontendAnnouncer.Register(this.FrontendEndpoint);
                                        }

                                        await Task.Delay(1000);
                                    }

                                    poller.StopAsync();
                                    frontendSocket.Disconnect(connectionString);
                                    monitor.DetachFromPoller();
                                    monitor.Stop();
                                }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                }
            }
        }