Ntp.Analyzer.Monitor.Server.Listener Class Reference

Inheritance diagram for Ntp.Analyzer.Monitor.Server.Listener:

Collaboration diagram for Ntp.Analyzer.Monitor.Server.Listener:

Public Member Functions
	Listener (string ip, int port, LogBase log)
	Initializes a new instance of the Listener class. More...
void	Close ()
	Close this listener. More...
void	Dispose ()
void	Open ()
	Open this listener. More...
override string	ToString ()

Private Member Functions
	~Listener ()
void	AcceptCallback (IAsyncResult asyncAccept)
	Accepts the callback from client. More...
void	Dispose (bool disposing)
void	ReceiveCallback (IAsyncResult asyncReceive)
	Receives the callback from client. More...
void	SendCallback (IAsyncResult asyncSend)
	Sends the callback response to client. More...

Private Attributes
bool	disposedValue
readonly IPEndPoint	endPoint
Socket	listenSocket
readonly LogBase	log
bool	shuttingDown

Detailed Description

Definition at line 32 of file Listener.cs.

Constructor & Destructor Documentation

Ntp.Analyzer.Monitor.Server.Listener.Listener ( string  ip, int  port, LogBase  log  )

inline

Initializes a new instance of the Listener class.

Parameters

ip	IP Address to listen on.
port	Port number.
log	Log.

Definition at line 40 of file Listener.cs.

        {
            IPAddress address = IPAddress.Parse(ip);
            endPoint = new IPEndPoint(address, port);
            this.log = log;
            shuttingDown = false;
        }

Ntp.Analyzer.Monitor.Server.Listener.~Listener ( )

inlineprivate

Definition at line 229 of file Listener.cs.

        {
            Dispose(false);
        }

Member Function Documentation

void Ntp.Analyzer.Monitor.Server.Listener.AcceptCallback ( IAsyncResult  asyncAccept )

inlineprivate

Accepts the callback from client.

Parameters

asyncAccept

Async accept.

Definition at line 96 of file Listener.cs.

        {
            try
            {
                Socket serverSocket = listenSocket.EndAccept(asyncAccept);

                if (serverSocket.Connected == false)
                    return;

                var req = new Request(128, serverSocket);

                serverSocket.BeginReceive(
                    req.Buffer,
                    0,
                    req.Buffer.Length,
                    SocketFlags.None,
                    ReceiveCallback,
                    req);
            }
            catch (Exception ex)
            {
                if (!shuttingDown)
                {
                    log.WriteLine("Unexpected error in listener " + ToString(), Severity.Error);
                    log.WriteLine(ex.Message, Severity.Debug);
                    log.WriteLine(ex, Severity.Trace);
                }
            }
        }

void Ntp.Analyzer.Monitor.Server.Listener.Close ( )

inline

Close this listener.

Definition at line 56 of file Listener.cs.

        {
            shuttingDown = true;
            listenSocket.Close();
        }

void Ntp.Analyzer.Monitor.Server.Listener.Dispose ( bool  disposing )

inlineprivate

Definition at line 209 of file Listener.cs.

        {
            if (disposedValue)
                return;

            if (disposing && listenSocket != null)
            {
                if (listenSocket.Connected)
                {
                    listenSocket.Shutdown(SocketShutdown.Both);
                    listenSocket.Close();
                }

                listenSocket.Dispose();
                listenSocket = null;
            }

            disposedValue = true;
        }

void Ntp.Analyzer.Monitor.Server.Listener.Dispose ( )

inline

Definition at line 234 of file Listener.cs.

        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

void Ntp.Analyzer.Monitor.Server.Listener.Open ( )

inline

Open this listener.

Definition at line 65 of file Listener.cs.

        {
            try
            {
                listenSocket = new Socket(
                    AddressFamily.InterNetwork,
                    SocketType.Stream,
                    ProtocolType.Tcp);

                listenSocket.Bind(endPoint);
                listenSocket.Listen(3);

                listenSocket.BeginAccept(AcceptCallback, null);
            }
            catch (Exception ex)
            {
                log.WriteLine("Error while initializing listener " + ToString(), Severity.Error);
                log.WriteLine(ex.Message, Severity.Debug);
                log.WriteLine(ex, Severity.Trace);
            }
        }

void Ntp.Analyzer.Monitor.Server.Listener.ReceiveCallback ( IAsyncResult  asyncReceive )

inlineprivate

Receives the callback from client.

Parameters

asyncReceive

Async receive.

Definition at line 130 of file Listener.cs.

References Ntp.Analyzer.Monitor.Server.Command.CommandType, Ntp.Analyzer.Monitor.Server.CommandFactory.Create(), and Ntp.Analyzer.Monitor.Server.Command.Execute().

        {
            try
            {
                var req = (Request) asyncReceive.AsyncState;
                int size = req.Socket.EndReceive(asyncReceive);
                req.ReSize(size);

                // Process request
                Command command = CommandFactory.Create(req.Command, req.Arguments);

                // Force correct time format in strings, etc.
                Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

                byte[] sendBuffer;

                if (command == null)
                {
                    sendBuffer = Encoding.UTF8.GetBytes("Unknown command");
                }
                else
                    switch (command.CommandType)
                    {
                        case CommandType.Binary:
                            sendBuffer = (byte[]) command.Execute();
                            break;
                        case CommandType.Text:
                            var text = command.Execute() as string;
                            sendBuffer = text != null ? Encoding.UTF8.GetBytes(text) : new byte[] {0};
                            break;
                        default:
                            sendBuffer = Encoding.UTF8.GetBytes("Error in command module. Unknown command type.");
                            break;
                    }

                req.Socket.BeginSend(
                    sendBuffer,
                    0,
                    sendBuffer.Length,
                    SocketFlags.None,
                    SendCallback,
                    req.Socket);
            }
            catch (Exception ex)
            {
                log.WriteLine("Unexpected error in listener " + ToString(), Severity.Error);
                log.WriteLine(ex.Message, Severity.Debug);
                log.WriteLine(ex, Severity.Trace);
            }
        }

Here is the call graph for this function:

void Ntp.Analyzer.Monitor.Server.Listener.SendCallback ( IAsyncResult  asyncSend )

inlineprivate

Sends the callback response to client.

Parameters

asyncSend

Async send.

Definition at line 185 of file Listener.cs.

        {
            try
            {
                var serverSocket = (Socket) asyncSend.AsyncState;
                serverSocket.EndSend(asyncSend);
                serverSocket.Shutdown(SocketShutdown.Both);
                serverSocket.Close();

                // Start new worker socket.
                listenSocket.BeginAccept(AcceptCallback, null);
            }
            catch (Exception ex)
            {
                log.WriteLine("Unexpected error in listener " + ToString(), Severity.Error);
                log.WriteLine(ex.Message, Severity.Debug);
                log.WriteLine(ex, Severity.Trace);
            }
        }

override string Ntp.Analyzer.Monitor.Server.Listener.ToString ( )

inline

Definition at line 87 of file Listener.cs.

        {
            return endPoint.ToString();
        }

Member Data Documentation

bool Ntp.Analyzer.Monitor.Server.Listener.disposedValue

private

Definition at line 207 of file Listener.cs.

readonly IPEndPoint Ntp.Analyzer.Monitor.Server.Listener.endPoint

private

Definition at line 48 of file Listener.cs.

Socket Ntp.Analyzer.Monitor.Server.Listener.listenSocket

private

Definition at line 50 of file Listener.cs.

readonly LogBase Ntp.Analyzer.Monitor.Server.Listener.log

private

Definition at line 49 of file Listener.cs.

bool Ntp.Analyzer.Monitor.Server.Listener.shuttingDown

private

Definition at line 51 of file Listener.cs.

---

The documentation for this class was generated from the following file:

• Ntp.Analyzer.Monitor.Server/Listener.cs