demo/chat/Telnet_ChatRoom.java

   1 /**
   2  *    Copyright 2011 Huize Dai
   3  *
   4  *    This file is part of MFW.
   5  *
   6  *    MFW is free software: you can redistribute it and/or modify
   7  *    it under the terms of the GNU Lesser General Public License as published by
   8  *    the Free Software Foundation, either version 3 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    MFW is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU Lesser General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU Lesser General Public License
  17  *    along with MFW.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19 package chat;
  20
  21 import java.io.BufferedReader;
  22 import java.io.IOException;
  23 import java.io.InputStreamReader;
  24 import java.net.InetSocketAddress;
  25 import java.nio.channels.SelectionKey;
  26 import java.util.HashSet;
  27 import java.util.Iterator;
  28 import java.util.Set;
  29
  30 import javax.xml.parsers.DocumentBuilderFactory;
  31 import mfw.buff.CommandReceiver;
  32 import mfw.buff.Returnable;
  33 import mfw.ctrl.ReceiverFactory;
  34 import mfw.ctrl.Trigger;
  35 import mfw.ctrl.Cmd.Parameter;
  36 import mfw.fw.Client;
  37 import mfw.fw.Server;
  38 import mfw.pool.Mission;
  39 import mfw.timer.ClockThread;
  40 import mfw.timer.TimerEvent;
  41 import mfw.timer.TimerEventGroup;
  42
  43 public class Telnet_ChatRoom {
  44         private static boolean flag = true;
  45         private static Server srv = new Server();
  46         private static CommandReceiver chatReceiver;
  47         private static CommandReceiver adminReceiver;
  48         static {
  49                 try {
  50                         chatReceiver = ReceiverFactory
  51                                         .newReceiverInstance(DocumentBuilderFactory
  52                                                         .newInstance()
  53                                                         .newDocumentBuilder()
  54                                                         .parse(
  55                                                                         ClassLoader
  56                                                                                         .getSystemResourceAsStream("chat/chat_cmd.xml"))
  57                                                         .getDocumentElement());
  58                         adminReceiver = ReceiverFactory
  59                                         .newReceiverInstance(DocumentBuilderFactory
  60                                                         .newInstance()
  61                                                         .newDocumentBuilder()
  62                                                         .parse(
  63                                                                         ClassLoader
  64                                                                                         .getSystemResourceAsStream("chat/admin_cmd.xml"))
  65                                                         .getDocumentElement());
  66                 } catch (Exception e) {
  67                         throw new Error(e);
  68                 }
  69         }
  70
  71         private static Returnable admin = new Returnable() {
  72
  73                 public boolean isReturnable() {
  74                         return true;
  75                 }
  76
  77                 public void returnResult(byte[] result, int offset, int len) {
  78                         System.out.print(new String(result, offset, len));
  79                 }
  80         };
  81
  82         public static Set<Client> list = new HashSet<Client>();
  83
  84         private static TimerEventGroup timer = new TimerEventGroup();
  85
  86         private static byte[] content = new byte[0];
  87
  88         public static void main(String[] args) throws IOException {
  89                 Mission.begin(256);
  90                 new ClockThread(timer, 30000).start();
  91                 timer.add(new CleanTimer());
  92                 timer.add(new PubTimer());
  93                 srv.setWelcomeStr("Welcome!\r\n".getBytes());
  94                 srv.setAddress(new InetSocketAddress(8081));
  95                 srv.setCmdLength(256);
  96                 srv.setCoreReceiver(chatReceiver);
  97                 srv.start();
  98                 BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
  99                 while (flag) {
 100                         byte[] cmd = in.readLine().getBytes();
 101                         adminReceiver.receive(admin, cmd, 0, cmd.length);
 102                 }
 103                 srv.stop();
 104                 timer.cancel();
 105                 Mission.end();
 106         }
 107
 108         public static class ListSockets extends Trigger {
 109
 110                 protected void execute(Returnable subject, Parameter param) {
 111                         Iterator<SelectionKey> iter = srv.getKeys().iterator();
 112                         while (iter.hasNext()) {
 113                                 byte[] socket = (iter.next().channel().toString() + "\r\n")
 114                                                 .getBytes();
 115                                 subject.returnResult(socket, 0, socket.length);
 116                         }
 117                 }
 118         }
 119
 120         public static class ListClients extends Trigger {
 121
 122                 protected void execute(Returnable subject, Parameter param) {
 123                         Iterator<Client> iter = list.iterator();
 124                         while (iter.hasNext()) {
 125                                 byte[] client = (iter.next().attachment().toString() + "\r\n")
 126                                                 .getBytes();
 127                                 subject.returnResult(client, 0, client.length);
 128                         }
 129                 }
 130         }
 131
 132         public static class StopClient extends Trigger {
 133
 134                 protected void execute(Returnable subject, Parameter param) {
 135                         byte[] warning = "Warning!!!\r\n".getBytes();
 136                         String nick = new String(param.getBytes());
 137                         Iterator<Client> iter = list.iterator();
 138                         while (iter.hasNext()) {
 139                                 Client cl = iter.next();
 140                                 if (cl.attachment().toString().equals(nick)) {
 141                                         cl.returnResult(warning, 0, warning.length);
 142                                         cl.attach(null);
 143                                         iter.remove();
 144                                 }
 145                         }
 146                 }
 147         }
 148
 149         public static class Exit extends Trigger {
 150
 151                 protected void execute(Returnable subject, Parameter param) {
 152                         byte[] bye = "GoodBye!\r\n".getBytes();
 153                         subject.returnResult(bye, 0, bye.length);
 154                         flag = false;
 155                 }
 156         }
 157
 158         public static class Pub extends Trigger {
 159
 160                 protected void execute(Returnable subject, Parameter param) {
 161                         content = param.getBytes();
 162                 }
 163         }
 164
 165         static class PubTimer extends TimerEvent {
 166
 167                 protected boolean isContinue() {
 168                         Iterator<Client> iter = list.iterator();
 169                         while (iter.hasNext()) {
 170                                 iter.next().returnResult(content, 0, content.length);
 171                         }
 172                         return true;
 173                 }
 174         }
 175
 176         static class CleanTimer extends TimerEvent {
 177
 178                 protected boolean isContinue() {
 179                         Iterator<Client> iter = list.iterator();
 180                         while (iter.hasNext()) {
 181                                 if (!iter.next().isReturnable())
 182                                         iter.remove();
 183                         }
 184                         return true;
 185                 }
 186         }
 187 }