|
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;
|
|
|
128 switch(repCmd.cmd){
|
|
38
|
129
|
|
0
|
130 case REP.SMCMD_JOIN:
|
|
21
|
131 if(isMaster){
|
|
23
|
132 int eid = editorList.addEditor(channel, repCmd);
|
|
|
133 repCmd.setEID(eid);
|
|
|
134 editorList.sendJoinAck(channel, repCmd);
|
|
26
|
135 sessionmanagerGUI.setComboEditor(eid, channel);
|
|
21
|
136 }else{
|
|
23
|
137 editorList.addEditor(channel);
|
|
22
|
138 smList.sendJoin(repCmd);
|
|
30
|
139 //sessionmanagerGUI.setComboEditor(repCmd.eid, channel);
|
|
21
|
140 }
|
|
38
|
141 break;
|
|
31
|
142
|
|
1
|
143 case REP.SMCMD_JOIN_ACK:
|
|
31
|
144 // editorList.setEID(repCmd);
|
|
|
145 // editorList.sendJoinAck(repCmd);
|
|
|
146 // sessionmanagerGUI.setComboEditor(repCmd.eid, channel);
|
|
1
|
147 break;
|
|
31
|
148
|
|
0
|
149 case REP.SMCMD_PUT:
|
|
56
|
150 Editor editor = new Editor(channel);
|
|
|
151 editor.setEID(1);
|
|
|
152 editor.setName(repCmd.string);
|
|
|
153 Session session = new Session(editor);
|
|
63
|
154 session.addEditor(editor);
|
|
56
|
155 sessionlist.addSession(session);
|
|
|
156 sessionmanagerGUI.setComboSession(session.getSID(), session.getName());
|
|
59
|
157 sessionmanagerGUI.setComboEditor(editor.getEID(), editor.getChannel());
|
|
56
|
158 session.addToRoutingTable(editor);
|
|
|
159 repCmd.setCMD(REP.SMCMD_PUT_ACK);
|
|
|
160 repCmd.setEID(1);
|
|
60
|
161 repCmd.setSID(session.getSID());
|
|
56
|
162 editor.send(repCmd);
|
|
|
163
|
|
|
164 //if(isMaster){
|
|
|
165 SessionXMLEncoder encoder = new SessionXMLEncoder(session);
|
|
|
166 REPCommand command = new REPCommand();
|
|
|
167 command.setSID(session.getSID());
|
|
|
168 command.setString(encoder.sessionListToXML());
|
|
|
169 if(isMaster){
|
|
|
170 command.setCMD(REP.SMCMD_UPDATE_ACK);
|
|
|
171 smList.sendToSlave(command);
|
|
|
172 }else{
|
|
|
173 command.setCMD(REP.SMCMD_UPDATE);
|
|
|
174 smList.sendToMaster(command);
|
|
31
|
175 }
|
|
38
|
176 break;
|
|
31
|
177
|
|
9
|
178 // case REP.SMCMD_PUT_ACK:
|
|
|
179 // break;
|
|
31
|
180
|
|
0
|
181 case REP.SMCMD_SELECT:
|
|
8
|
182 sessionlist.addEditor(channel, repCmd.sid, repCmd); //sessionlistへ追加
|
|
0
|
183 repCmd.setCMD(repCmd.cmd + 1);
|
|
|
184 REPPacketSend repSend3 = new REPPacketSend(channel);
|
|
9
|
185 repSend3.send(repCmd); //ACKを返す
|
|
8
|
186 break;
|
|
38
|
187
|
|
8
|
188 case REP.SMCMD_SELECT_ACK:
|
|
|
189 break;
|
|
38
|
190
|
|
1
|
191 case REP.SMCMD_SESSION:
|
|
|
192 break;
|
|
38
|
193
|
|
8
|
194 case REP.SMCMD_SM_JOIN:
|
|
31
|
195 if(isMaster){
|
|
38
|
196 smList.add(channel);
|
|
31
|
197 repCmd.setCMD(REP.SMCMD_SM_JOIN_ACK);
|
|
|
198 smList.sendSessionList(sessionlist, repCmd);
|
|
45
|
199 }else {
|
|
|
200
|
|
31
|
201 }
|
|
8
|
202 break;
|
|
38
|
203
|
|
8
|
204 case REP.SMCMD_SM_JOIN_ACK:
|
|
38
|
205 if(isMaster){
|
|
|
206 smList.send(channel, repCmd);
|
|
39
|
207 }else{
|
|
|
208 smList.send(channel, repCmd);
|
|
38
|
209 }
|
|
|
210
|
|
6
|
211 break;
|
|
38
|
212
|
|
8
|
213 case REP.SMCMD_UPDATE:
|
|
56
|
214 //int sessionID2 = sessionlist.addSession(channel, repCmd.string); //Sessionを作成
|
|
|
215 //sessionlist.addEditor(channel, sessionID2, repCmd);
|
|
|
216 //sessionmanagerGUI.setComboSession(sessionID2, repCmd.string); //ComboBoxにSessionを追加
|
|
|
217 SessionXMLDecoder decoder = new SessionXMLDecoder(repCmd.string);
|
|
|
218 Editor editor1 = new Editor(channel);
|
|
65
|
219 editor1.setName(repCmd.string);
|
|
62
|
220 Session session1 = new Session(editor1);
|
|
65
|
221 session1.setSID(repCmd.sid);
|
|
62
|
222 sessionlist.addSession(session1);
|
|
64
|
223 sessionmanagerGUI.setComboSession(session1.getSID(), session1.getName());
|
|
58
|
224 if(isMaster){
|
|
|
225 repCmd.setCMD(REP.SMCMD_UPDATE_ACK);
|
|
|
226 smList.sendToSlave(repCmd);
|
|
|
227 }else{
|
|
|
228 repCmd.setCMD(REP.SMCMD_UPDATE);
|
|
|
229 smList.sendToMaster(repCmd);
|
|
|
230 }
|
|
9
|
231 break;
|
|
38
|
232
|
|
9
|
233 case REP.SMCMD_UPDATE_ACK:
|
|
56
|
234 smList.sendToSlave(repCmd);
|
|
1
|
235 break;
|
|
38
|
236
|
|
3
|
237 case REP.REPCMD_READ:
|
|
17
|
238 //sessionlist.sendCmd(channel, repCmd);
|
|
3
|
239 break;
|
|
38
|
240
|
|
0
|
241 default:
|
|
9
|
242 //sessionlist.sendCmd(channel, repCmd);
|
|
|
243 sessionlist.sendToNextEditor(channel, repCmd);
|
|
0
|
244 break;
|
|
|
245 }
|
|
|
246 }
|
|
|
247
|
|
22
|
248 // private void sendJoin(REPCommand repCmd) {
|
|
|
249 // smList.sendJoin(repCmd);
|
|
|
250 // }
|
|
21
|
251
|
|
|
252 private void sendSessionManagerJoinAck(SocketChannel channel, REPCommand repCmd) {
|
|
16
|
253 String socketstring = getSocketString(channel);
|
|
|
254 System.out.println(socketstring);
|
|
12
|
255 smList.add(channel); //SessionManagerのリストへ追加
|
|
|
256 repCmd.setCMD(REP.SMCMD_SM_JOIN_ACK);
|
|
16
|
257 repCmd.setString(repCmd.string + ":" + socketstring);
|
|
12
|
258 REPPacketSend repSend4 = new REPPacketSend(channel);
|
|
|
259 repSend4.send(repCmd); //ACK
|
|
10
|
260 }
|
|
21
|
261
|
|
|
262 private void sendJoinAck(REPCommand repCmd) {
|
|
|
263
|
|
|
264 }
|
|
10
|
265
|
|
21
|
266 private void sendJoinAck(SocketChannel channel, REPCommand repCmd) {
|
|
23
|
267 //int eid = sessionlist.getNumberOfEditor(); //eidを取得
|
|
|
268 int eid = editorList.addEditor(channel, repCmd);
|
|
17
|
269 sessionmanagerGUI.setComboEditor(eid, channel); //ComboBoxにEditorを追加
|
|
|
270 repCmd.setEID(eid); //eidを決定して、
|
|
|
271 repCmd.setCMD(REP.SMCMD_JOIN_ACK);
|
|
|
272 repCmd.string = sessionlist.getSessionList(); //Session一覧を
|
|
|
273
|
|
|
274 String string = getSocketString(channel);
|
|
|
275 StringTokenizer stn = new StringTokenizer(string, ":");
|
|
|
276 String host = stn.nextToken();
|
|
|
277 String port = stn.nextToken();
|
|
|
278 repCmd.setString(repCmd.string + ":" + myHost + ":" + port);
|
|
|
279
|
|
|
280 REPPacketSend repSend = new REPPacketSend(channel); //Editor側へ送信
|
|
|
281 repSend.send(repCmd);
|
|
10
|
282 }
|
|
|
283
|
|
0
|
284 public static void main(String[] args) throws InterruptedException, IOException {
|
|
6
|
285 int port = 8766;
|
|
1
|
286
|
|
0
|
287 if(args.length == 1){
|
|
39
|
288 port = Integer.parseInt(args[0]);
|
|
0
|
289 }
|
|
|
290 SessionManager sm = new SessionManager(port);
|
|
2
|
291 sm.openSelector();
|
|
|
292 sm.openWindow();
|
|
0
|
293 sm.sessionManagerNet(port);
|
|
|
294 }
|
|
|
295
|
|
2
|
296 private void openWindow() {
|
|
|
297 Thread th = new Thread( sessionmanagerGUI );
|
|
|
298 th.start();
|
|
|
299 System.out.println(sessionmanagerGUI.toString());
|
|
|
300 sessionmanagerGUI.addConnectionListener(this);
|
|
8
|
301 sessionmanagerGUI.addREPActionListener(this);
|
|
2
|
302 }
|
|
|
303
|
|
|
304 private void connectSession(String host) {
|
|
6
|
305 int port = 8766;
|
|
|
306 //SocketChannel sessionchannel;
|
|
2
|
307 //int port = Integer.parseInt(args[2]);
|
|
1
|
308 InetSocketAddress addr = new InetSocketAddress(host, port);
|
|
|
309 try {
|
|
6
|
310 SocketChannel sessionchannel = SocketChannel.open();
|
|
1
|
311 sessionchannel.configureBlocking(true);
|
|
|
312 sessionchannel.connect(addr);
|
|
6
|
313 REPPacketSend send = new REPPacketSend(sessionchannel);
|
|
|
314 while(!sessionchannel.finishConnect()){
|
|
|
315 System.out.print(".");
|
|
|
316 }
|
|
|
317 System.out.println("");
|
|
2
|
318 registerChannel(selector, sessionchannel, SelectionKey.OP_READ);
|
|
24
|
319 //REPCommand sm_join_com = REPCommand.SMCMD_SESSION_JOIN;
|
|
|
320 //String socketString = getSocketString(sessionchannel);
|
|
|
321 //sm_join_com.setString(sm_join_com.string + ":" + socketString);
|
|
45
|
322 SessionXMLEncoder encoder = new SessionXMLEncoder(sessionlist.getList());
|
|
|
323
|
|
|
324 REPCommand comm = new REPCommand();
|
|
|
325 comm.setCMD(REP.SMCMD_SM_JOIN);
|
|
|
326 comm.setString(encoder.sessionListToXML());
|
|
|
327 send.send(comm);
|
|
|
328
|
|
|
329 //send.send(REPCommand.SMCMD_SESSION_JOIN);
|
|
57
|
330 isMaster = false;
|
|
7
|
331 smList.add(sessionchannel);
|
|
31
|
332 smList.setMaster(sessionchannel);
|
|
1
|
333 }catch (IOException e) {
|
|
|
334 e.printStackTrace();
|
|
|
335 }
|
|
|
336 }
|
|
2
|
337
|
|
15
|
338 private String getSocketString(SocketChannel sessionchannel) {
|
|
14
|
339 SocketAddress socket = sessionchannel.socket().getRemoteSocketAddress();
|
|
15
|
340 //String inetAddressString = sessionchannel.socket().getInetAddress().toString();
|
|
|
341 StringTokenizer stn = new StringTokenizer(socket.toString(), "/");
|
|
|
342 String socketString = null;
|
|
|
343 while(stn.hasMoreTokens()){
|
|
|
344 socketString = stn.nextToken();
|
|
16
|
345 //System.out.println(socketString);
|
|
15
|
346 }
|
|
|
347 return socketString;
|
|
14
|
348 }
|
|
|
349
|
|
2
|
350 public void connectionOccured(ConnectionEvent event) {
|
|
|
351 connectSession(event.getHost());
|
|
|
352 }
|
|
8
|
353
|
|
|
354 public void ActionOccured(REPActionEvent event) {
|
|
|
355 System.out.println("Action!");
|
|
|
356 SocketChannel editorChannel = event.getEditorChannel();
|
|
|
357 int sid = event.getSID();
|
|
|
358 int eid = event.getEID();
|
|
|
359 sessionlist.addEditor(editorChannel, sid, eid);
|
|
|
360 REPPacketSend send = new REPPacketSend(editorChannel);
|
|
|
361 send.send(new REPCommand(REP.SMCMD_SELECT_ACK, sid, eid, 0,0,0,""));
|
|
|
362 sessionlist.sendSelect(sid);
|
|
|
363 }
|
|
0
|
364 }
|
