0
|
1 package rep;
|
|
2
|
|
3 import java.io.IOException;
|
|
4 import java.net.InetSocketAddress;
|
11
|
5 import java.net.SocketAddress;
|
2
|
6 import java.nio.channels.SelectableChannel;
|
0
|
7 import java.nio.channels.SelectionKey;
|
|
8 import java.nio.channels.Selector;
|
|
9 import java.nio.channels.ServerSocketChannel;
|
|
10 import java.nio.channels.SocketChannel;
|
15
|
11 import java.util.StringTokenizer;
|
0
|
12
|
1
|
13 //+-------+--------+--------+-------+--------+---------+------+
|
|
14 //| cmd | session| editor | seqid | lineno | textsiz | text |
|
|
15 //| | id | id | | | | |
|
|
16 //+-------+--------+--------+-------+--------+---------+------+
|
|
17 //o-------header section (network order)-------------o
|
|
18 /*int cmd; // command
|
|
19 int sid; // session ID
|
|
20 int eid; // editor ID
|
|
21 int seqno; // Sequence number
|
|
22 int lineno; // line number
|
|
23 int textsize; // textsize
|
|
24 byte[] text;*/
|
|
25
|
8
|
26 public class SessionManager implements ConnectionListener, REPActionListener{
|
0
|
27
|
|
28
|
|
29 private SessionList sessionlist;
|
5
|
30 //SocketChannel sessionchannel;
|
2
|
31 private SessionManagerGUI sessionmanagerGUI;
|
|
32 private Selector selector;
|
7
|
33 private SessionManagerList smList;
|
17
|
34 private String myHost;
|
21
|
35 private boolean isMaster = true;
|
23
|
36 private EditorList editorList;
|
6
|
37 //private SocketChannel sessionchannel;
|
7
|
38 //private boolean co;
|
2
|
39 public SessionManager(int port) {
|
|
40 sessionmanagerGUI = new SessionManagerGUI();
|
|
41 }
|
|
42
|
|
43 public void openSelector() throws IOException{
|
|
44 selector = Selector.open();
|
|
45 }
|
0
|
46
|
|
47 public void sessionManagerNet(int port) throws InterruptedException, IOException {
|
|
48 /**
|
|
49 * @param args
|
|
50 * @throws IOException
|
|
51 * @throws InterruptedException
|
|
52 * @throws IOException
|
|
53 * @throws InterruptedException
|
|
54 */
|
2
|
55 System.out.println("sessionManagerNet()");
|
|
56
|
0
|
57 ServerSocketChannel ssc = ServerSocketChannel.open();
|
38
|
58 ssc.configureBlocking(false);
|
0
|
59 ssc.socket().bind(new InetSocketAddress(port));
|
|
60 ssc.register(selector, SelectionKey.OP_ACCEPT);
|
6
|
61
|
|
62
|
0
|
63 sessionlist = new SessionList();
|
7
|
64 smList = new SessionManagerList();
|
23
|
65 editorList = new EditorList();
|
0
|
66
|
|
67 while(true){
|
|
68 selector.select();
|
|
69 for(SelectionKey key : selector.selectedKeys()){
|
|
70 if(key.isAcceptable()){
|
28
|
71 /*** serverChannelはenableになったSelectionKeyのchannel ***/
|
|
72 ServerSocketChannel serverChannel = (ServerSocketChannel)key.channel();
|
9
|
73 /*** EditorChannel を用いない記述 ***/
|
28
|
74 SocketChannel channel = serverChannel.accept(); //keyからchannelを取って、accept
|
2
|
75 registerChannel (selector, channel, SelectionKey.OP_READ);
|
0
|
76 channel = null;
|
9
|
77
|
|
78 /*** EditorChannel を用いた記述 ****/
|
|
79 //EditorChannel echannel = (EditorChannel) ssc.accept();
|
|
80 //echannel.setIO();
|
|
81 //registerChannel(selector, echannel, SelectionKey.OP_READ);
|
|
82 //echannel = null;
|
|
83
|
|
84 /*** SelectableEditorChannel ***/
|
|
85 //SocketChannel channel = ssc.accept();
|
|
86 //SelectableEditorChannel echannel2 = new SelectableEditorChannel(channel);
|
|
87 //registerChannel(selector, echannel2, SelectionKey.OP_READ);
|
|
88 //channel = null;
|
|
89 //echannel2 = null;
|
|
90
|
6
|
91 }else if(key.isReadable()){
|
9
|
92
|
|
93 /*** EditorChannel を用いない記述 ***/
|
0
|
94 SocketChannel channel = (SocketChannel)key.channel();
|
9
|
95 REPPacketReceive repRec = new REPPacketReceive(channel); //getPacket(), putPacket() にする。
|
28
|
96 repRec.setkey(key);
|
0
|
97 REPCommand repCom = repRec.unpack();
|
|
98 manager(channel, repCom);
|
9
|
99
|
|
100 /*** EditorChannel を用いた記述 ****/
|
|
101 //EditorChannel echannel = (EditorChannel) key.channel();
|
|
102 //REPCommand command = echannel.getPacket();
|
|
103 //manager(echannel, command);
|
|
104
|
6
|
105 }else if(key.isConnectable()){
|
|
106 System.out.println("Connectable");
|
21
|
107 }
|
0
|
108 }
|
|
109 }
|
|
110 }
|
1
|
111
|
2
|
112 private synchronized void registerChannel(Selector selector, SelectableChannel channel, int ops) throws IOException {
|
|
113 if(channel == null) {
|
|
114 return;
|
|
115 }
|
9
|
116 //System.out.println("registerChannel()");
|
2
|
117 channel.configureBlocking(false);
|
6
|
118 selector.wakeup();
|
2
|
119 channel.register(selector, ops);
|
|
120 }
|
|
121
|
0
|
122 private void manager(SocketChannel channel, REPCommand repCmd) {
|
|
123 if(repCmd == null) return;
|
|
124 switch(repCmd.cmd){
|
38
|
125
|
0
|
126 case REP.SMCMD_JOIN:
|
21
|
127 if(isMaster){
|
23
|
128 int eid = editorList.addEditor(channel, repCmd);
|
|
129 repCmd.setEID(eid);
|
|
130 editorList.sendJoinAck(channel, repCmd);
|
26
|
131 sessionmanagerGUI.setComboEditor(eid, channel);
|
21
|
132 }else{
|
23
|
133 editorList.addEditor(channel);
|
22
|
134 smList.sendJoin(repCmd);
|
30
|
135 //sessionmanagerGUI.setComboEditor(repCmd.eid, channel);
|
21
|
136 }
|
38
|
137 break;
|
31
|
138
|
1
|
139 case REP.SMCMD_JOIN_ACK:
|
31
|
140 // editorList.setEID(repCmd);
|
|
141 // editorList.sendJoinAck(repCmd);
|
|
142 // sessionmanagerGUI.setComboEditor(repCmd.eid, channel);
|
1
|
143 break;
|
31
|
144
|
0
|
145 case REP.SMCMD_PUT:
|
31
|
146 if(repCmd.string.length() == 0){
|
|
147 sessionlist.addEditor(channel, 0, 0);
|
|
148 }else if(repCmd.string.length() > 0){
|
|
149 int sid = sessionlist.addSession(channel, repCmd.string);
|
|
150 sessionlist.addEditor(channel, sid, 0);
|
|
151 }
|
38
|
152 break;
|
31
|
153
|
9
|
154 // case REP.SMCMD_PUT_ACK:
|
|
155 // break;
|
31
|
156
|
0
|
157 case REP.SMCMD_SELECT:
|
8
|
158 sessionlist.addEditor(channel, repCmd.sid, repCmd); //sessionlistへ追加
|
0
|
159 repCmd.setCMD(repCmd.cmd + 1);
|
|
160 REPPacketSend repSend3 = new REPPacketSend(channel);
|
9
|
161 repSend3.send(repCmd); //ACKを返す
|
8
|
162 break;
|
38
|
163
|
8
|
164 case REP.SMCMD_SELECT_ACK:
|
|
165 break;
|
38
|
166
|
1
|
167 case REP.SMCMD_SESSION:
|
|
168 break;
|
38
|
169
|
8
|
170 case REP.SMCMD_SM_JOIN:
|
31
|
171 if(isMaster){
|
38
|
172 smList.add(channel);
|
31
|
173 repCmd.setCMD(REP.SMCMD_SM_JOIN_ACK);
|
|
174 smList.sendSessionList(sessionlist, repCmd);
|
|
175 }
|
8
|
176 break;
|
38
|
177
|
8
|
178 case REP.SMCMD_SM_JOIN_ACK:
|
38
|
179 if(isMaster){
|
|
180 smList.send(channel, repCmd);
|
|
181 }
|
|
182
|
6
|
183 break;
|
38
|
184
|
8
|
185 case REP.SMCMD_UPDATE:
|
9
|
186 int sessionID2 = sessionlist.addSession(channel, repCmd.string); //Sessionを作成
|
|
187 sessionlist.addEditor(channel, sessionID2, repCmd);
|
|
188 sessionmanagerGUI.setComboSession(sessionID2, repCmd.string); //ComboBoxにSessionを追加
|
|
189 break;
|
38
|
190
|
9
|
191 case REP.SMCMD_UPDATE_ACK:
|
1
|
192 break;
|
38
|
193
|
3
|
194 case REP.REPCMD_READ:
|
17
|
195 //sessionlist.sendCmd(channel, repCmd);
|
3
|
196 break;
|
38
|
197
|
0
|
198 default:
|
9
|
199 //sessionlist.sendCmd(channel, repCmd);
|
|
200 sessionlist.sendToNextEditor(channel, repCmd);
|
0
|
201 break;
|
|
202 }
|
|
203 }
|
|
204
|
22
|
205 // private void sendJoin(REPCommand repCmd) {
|
|
206 // smList.sendJoin(repCmd);
|
|
207 // }
|
21
|
208
|
|
209 private void sendSessionManagerJoinAck(SocketChannel channel, REPCommand repCmd) {
|
16
|
210 String socketstring = getSocketString(channel);
|
|
211 System.out.println(socketstring);
|
12
|
212 smList.add(channel); //SessionManagerのリストへ追加
|
|
213 repCmd.setCMD(REP.SMCMD_SM_JOIN_ACK);
|
16
|
214 repCmd.setString(repCmd.string + ":" + socketstring);
|
12
|
215 REPPacketSend repSend4 = new REPPacketSend(channel);
|
|
216 repSend4.send(repCmd); //ACK
|
10
|
217 }
|
21
|
218
|
|
219 private void sendJoinAck(REPCommand repCmd) {
|
|
220
|
|
221 }
|
10
|
222
|
21
|
223 private void sendJoinAck(SocketChannel channel, REPCommand repCmd) {
|
23
|
224 //int eid = sessionlist.getNumberOfEditor(); //eidを取得
|
|
225 int eid = editorList.addEditor(channel, repCmd);
|
17
|
226 sessionmanagerGUI.setComboEditor(eid, channel); //ComboBoxにEditorを追加
|
|
227 repCmd.setEID(eid); //eidを決定して、
|
|
228 repCmd.setCMD(REP.SMCMD_JOIN_ACK);
|
|
229 repCmd.string = sessionlist.getSessionList(); //Session一覧を
|
|
230
|
|
231 String string = getSocketString(channel);
|
|
232 StringTokenizer stn = new StringTokenizer(string, ":");
|
|
233 String host = stn.nextToken();
|
|
234 String port = stn.nextToken();
|
|
235 repCmd.setString(repCmd.string + ":" + myHost + ":" + port);
|
|
236
|
|
237 REPPacketSend repSend = new REPPacketSend(channel); //Editor側へ送信
|
|
238 repSend.send(repCmd);
|
10
|
239 }
|
|
240
|
0
|
241 public static void main(String[] args) throws InterruptedException, IOException {
|
6
|
242 int port = 8766;
|
1
|
243
|
0
|
244 if(args.length == 1){
|
|
245 port = Integer.parseInt(args[1]);
|
|
246 }
|
|
247 SessionManager sm = new SessionManager(port);
|
2
|
248 sm.openSelector();
|
|
249 sm.openWindow();
|
0
|
250 sm.sessionManagerNet(port);
|
|
251 }
|
|
252
|
2
|
253 private void openWindow() {
|
|
254 Thread th = new Thread( sessionmanagerGUI );
|
|
255 th.start();
|
|
256 System.out.println(sessionmanagerGUI.toString());
|
|
257 sessionmanagerGUI.addConnectionListener(this);
|
8
|
258 sessionmanagerGUI.addREPActionListener(this);
|
2
|
259 }
|
|
260
|
|
261 private void connectSession(String host) {
|
6
|
262 int port = 8766;
|
|
263 //SocketChannel sessionchannel;
|
2
|
264 //int port = Integer.parseInt(args[2]);
|
1
|
265 InetSocketAddress addr = new InetSocketAddress(host, port);
|
|
266 try {
|
6
|
267 SocketChannel sessionchannel = SocketChannel.open();
|
1
|
268 sessionchannel.configureBlocking(true);
|
|
269 sessionchannel.connect(addr);
|
6
|
270 REPPacketSend send = new REPPacketSend(sessionchannel);
|
|
271 while(!sessionchannel.finishConnect()){
|
|
272 System.out.print(".");
|
|
273 }
|
|
274 System.out.println("");
|
2
|
275 registerChannel(selector, sessionchannel, SelectionKey.OP_READ);
|
24
|
276 //REPCommand sm_join_com = REPCommand.SMCMD_SESSION_JOIN;
|
|
277 //String socketString = getSocketString(sessionchannel);
|
|
278 //sm_join_com.setString(sm_join_com.string + ":" + socketString);
|
6
|
279 send.send(REPCommand.SMCMD_SESSION_JOIN);
|
7
|
280 smList.add(sessionchannel);
|
31
|
281 smList.setMaster(sessionchannel);
|
1
|
282 }catch (IOException e) {
|
|
283 e.printStackTrace();
|
|
284 }
|
|
285 }
|
2
|
286
|
15
|
287 private String getSocketString(SocketChannel sessionchannel) {
|
14
|
288 SocketAddress socket = sessionchannel.socket().getRemoteSocketAddress();
|
15
|
289 //String inetAddressString = sessionchannel.socket().getInetAddress().toString();
|
|
290 StringTokenizer stn = new StringTokenizer(socket.toString(), "/");
|
|
291 String socketString = null;
|
|
292 while(stn.hasMoreTokens()){
|
|
293 socketString = stn.nextToken();
|
16
|
294 //System.out.println(socketString);
|
15
|
295 }
|
|
296 return socketString;
|
14
|
297 }
|
|
298
|
2
|
299 public void connectionOccured(ConnectionEvent event) {
|
|
300 connectSession(event.getHost());
|
|
301 }
|
8
|
302
|
|
303 public void ActionOccured(REPActionEvent event) {
|
|
304 System.out.println("Action!");
|
|
305 SocketChannel editorChannel = event.getEditorChannel();
|
|
306 int sid = event.getSID();
|
|
307 int eid = event.getEID();
|
|
308 sessionlist.addEditor(editorChannel, sid, eid);
|
|
309 REPPacketSend send = new REPPacketSend(editorChannel);
|
|
310 send.send(new REPCommand(REP.SMCMD_SELECT_ACK, sid, eid, 0,0,0,""));
|
|
311 sessionlist.sendSelect(sid);
|
|
312 }
|
0
|
313 }
|