Nachttrein #2 Op naar Berlin Hbf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

<?php
package blablabla;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;

import blablablalba.util.Logger;

public class NetworkListener implements Runnable
{
    public interface NewConnectionHandler
    {
        public Logger getLogger();

        public void onNewConnection(NetworkConnection connection);
    }

    private final int MAX_PACKET_SIZE = 1024;
    private int m_port;
    private Selector m_selector;
    private ServerSocketChannel m_channel;
    private NetworkListener.NewConnectionHandler m_handler;

    private boolean m_running;
    private Thread m_thread;

    public NetworkListener(int port, NetworkListener.NewConnectionHandler handler)
    {
        m_port = port;
        m_handler = handler;
    }

    public boolean start()
    {
        try
        {
            // Create the listening channel and bind it to the port
            m_channel = ServerSocketChannel.open();
            m_channel.configureBlocking(false);
            m_channel.socket().bind(new InetSocketAddress(m_port));

            // Create the selector and tell the channel to forward OP_ACCEPT
            // keys to this selector
            m_selector = Selector.open();
            m_channel.register(m_selector, SelectionKey.OP_ACCEPT);
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
            return false;
        }

        // Create and start the thread
        m_thread = new Thread(this, "NetworkListenerNew");
        m_running = true;
        m_thread.start();

        // Running!
        return true;
    }

    public void stop()
    {
        m_running = false;
        m_thread.interrupt();
    }

    @Override
    public void run()
    {
        // This is the reading buffer that will be used, m
        ByteBuffer buffer = ByteBuffer.allocate(MAX_PACKET_SIZE);

        // Run aslong we're told to run!
        while(m_running)
        {
            // Try grabbing all updated keys
            try
            {
                m_selector.select();
            }
            catch(IOException e)
            {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            // Process them all and remove them from the keys collection
            for(SelectionKey key : m_selector.selectedKeys())
            {
                try
                {
                    if(key.readyOps() == SelectionKey.OP_ACCEPT)
                    {
                        // Accept and configure as nonblocking socket
                        SocketChannel client = m_channel.accept();
                        client.configureBlocking(false);

                        // Create NetworkConnection and pass to handler
                        NetworkConnection connection = new NetworkConnection(client);
                        m_handler.onNewConnection(connection);

                        // Register OP_READ keys with this selector, and attach
                        // the connection as attachment
                        client.register(m_selector, SelectionKey.OP_READ, connection);
                    }
                    else if(key.readyOps() == SelectionKey.OP_READ)
                    {
                        buffer.position(0);
                        NetworkConnection connection = (NetworkConnection) key.attachment();
                        connection.onDataArrival(buffer);
                    }
                }
                catch(Exception ex)
                {
                    ex.printStackTrace();
                }
            }

            // Clear the keys, we have all handled them
            m_selector.selectedKeys().clear();
        }

        // Close the listening channel, we're done with running!
        try
        {
            m_channel.close();
        }
        catch(IOException e)
        {
            e.printStackTrace();
        }
    }
}
?>