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