Browse the code

Differences between 27 and 28 on /trunk.

Number of edited files:

3 (0 added, 0 deleted and 3 modified)

Author:

inouire

Log message:

fixes #1063 première version du master server

Date:

2010-01-24 20:28:09

Added file(s)	Deleted file(s)	Modified file(s)
		/trunk/masterserver/src/masterserver/Client.java ↓ /trunk/masterserver/src/masterserver/Register.java ↓ /trunk/masterserver/src/masterserver/RegisteredServer.java ↓


import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;


                if(firstWord.toUpperCase().startsWith("REGISTER")){
                    //register server
                    int port=12345;
                    boolean is_secured=false;
                    int nb_players=0;
                    int max_nb_players=6;
                    String description="pas de description";
                    try{
                        String info=firstWord.substring(firstWord.indexOf(":")+1);
                        port = Integer.parseInt(info.substring(0,info.indexOf(":")));
                        info=info.substring(info.indexOf(":")+1);
                        is_secured=Boolean.parseBoolean(info.substring(0,info.indexOf(":")));
                        info=info.substring(info.indexOf(":")+1);
                        nb_players=Integer.parseInt(info.substring(0,info.indexOf(":")));
                        info=info.substring(info.indexOf(":")+1);
                        max_nb_players=Integer.parseInt(info.substring(0,info.indexOf(":")));
                        description=info.substring(info.indexOf(":")+1);
                    }catch(Exception e){
                        Main.printLog("Bad REGISTER frame from "+socket.getInetAddress().toString()+":"+firstWord);
                        return;
                    }
                    String ip;
                    InetAddress iaddress = socket.getInetAddress();
                    if(iaddress.isLoopbackAddress()){
                       ip="inouire.net";
                    }else{
                        ip=iaddress.toString().substring(1);
                    }
                    RegisteredServer RS = new RegisteredServer(ip,port,is_secured,nb_players,max_nb_players,description);

                    RegisteredServer RS = new RegisteredServer(socket.getInetAddress(),port,description,false);

                    if(Main.register.isBlackListed(RS)){
                        Main.printLogIfVerbose("Server Blacklisted");
                        return;
    }

    private void getInfoRoutine(){
        this.send(Main.register.getRegisterList());
        this.out.println(Main.register.getRegisterInfo());
    }

    private void statRoutine(){

    }

    private void pingRoutine(){
        Main.printLogIfVerbose("Answering to PING request");
        send("PING");
    }

    private void closeStreams(){
        try {
            this.in.close();


Old	New	Code
22	22	import java.io.IOException;
23	23	import java.io.InputStreamReader;
24	24	import java.io.PrintWriter;
	25	import java.net.InetAddress;
25	26	import java.net.Socket;
26	27
27	28
63	64	if(firstWord.toUpperCase().startsWith("REGISTER")){
64	65	//register server
65	66	int port=12345;
	67	boolean is_secured=false;
	68	int nb_players=0;
	69	int max_nb_players=6;
66	70	String description="pas de description";
67	71	try{
68	72	String info=firstWord.substring(firstWord.indexOf(":")+1);
69	73	port = Integer.parseInt(info.substring(0,info.indexOf(":")));
	74	info=info.substring(info.indexOf(":")+1);
	75	is_secured=Boolean.parseBoolean(info.substring(0,info.indexOf(":")));
	76	info=info.substring(info.indexOf(":")+1);
	77	nb_players=Integer.parseInt(info.substring(0,info.indexOf(":")));
	78	info=info.substring(info.indexOf(":")+1);
	79	max_nb_players=Integer.parseInt(info.substring(0,info.indexOf(":")));
70	80	description=info.substring(info.indexOf(":")+1);
71	81	}catch(Exception e){
	82	Main.printLog("Bad REGISTER frame from "+socket.getInetAddress().toString()+":"+firstWord);
	83	return;
72	84	}
	85	String ip;
	86	InetAddress iaddress = socket.getInetAddress();
	87	if(iaddress.isLoopbackAddress()){
	88	ip="inouire.net";
	89	}else{
	90	ip=iaddress.toString().substring(1);
	91	}
	92	RegisteredServer RS = new RegisteredServer(ip,port,is_secured,nb_players,max_nb_players,description);
73	93
74		RegisteredServer RS = new RegisteredServer(socket.getInetAddress(),port,description,false);
75
76	94	if(Main.register.isBlackListed(RS)){
77	95	Main.printLogIfVerbose("Server Blacklisted");
78	96	return;
104	122	}
105	123
106	124	private void getInfoRoutine(){
107		this.send(Main.register.getRegisterList());
	125	this.out.println(Main.register.getRegisterInfo());
108	126	}
109	127
110		private void statRoutine(){
111
112		}
113
114		private void pingRoutine(){
115		Main.printLogIfVerbose("Answering to PING request");
116		send("PING");
117		}
118
119	128	private void closeStreams(){
120	129	try {
121	130	this.in.close();
122	131


public class Register {

    public ArrayList<RegisteredServer> listOfServers;
    private ArrayList<InetAddress> blackListedIP;
    private ArrayList<String> blackListedIP;

    public Register(){
        listOfServers=new ArrayList<RegisteredServer>();
    }

    public void heartBeat(RegisteredServer RS){
         Main.printLog("HEARTBEAT received from "+RS.getIP().toString()+":"+RS.getPort());
         RegisteredServer A = Main.register.getServer(RS);
         if(A!=null){
             A.rearmWatchdog();
             A.reAffect(RS);
             printRegisterList();
         }
         Main.register.printRegisterList();
    }

    public boolean isAlreadyRegistered(RegisteredServer RS){
    }

    public boolean isBlackListed(RegisteredServer RS){
        InetAddress ip = RS.getIP();
        for(InetAddress IP:blackListedIP){
        String ip = RS.getIP();
        for(String IP:blackListedIP){
            if(IP.equals(ip)){
                return true;
            }
    }

    public void printRegisterList(){
        System.out.println(getRegisterList());
    }

    public String getRegisterList(){
        String s="";
        String tmp="";
        int max=0;
        if(!listOfServers.isEmpty()){
            for(RegisteredServer rs : listOfServers){
                tmp="| "+rs.getIP()+" | "+rs.getPort()+" | "+rs.isActive()+" | "+rs.getDescription()+"\n";
                s+=tmp;
                if(tmp.length()>max){
                    max=tmp.length();
                if(rs.isActive()){
                    tmp="| "+rs.getIP()+":"+rs.getPort()+" | "+rs.isProtected()+" | "+rs.getNumberOfPlayers()+"/"+rs.getMaxNumberOfPlayers()+" | "+rs.getDescription()+"\n";
                    s+=tmp;
                    if(tmp.length()>max){
                        max=tmp.length();
                    }
                }
            }
            s="\n"+s;
                s+="-";
            }
        }
        System.out.println(s);
    }

    public String getRegisterInfo(){
        String s="";
        if(!listOfServers.isEmpty()){
            for(RegisteredServer rs : listOfServers){
                if(rs.isActive()){
                    s+=rs.getIP()+":"+rs.getPort()+":"+rs.isProtected()+":"+rs.getNumberOfPlayers()+":"+rs.getMaxNumberOfPlayers()+":"+rs.getDescription()+"\n";
                }
            }
            s=s.substring(0, s.length()-1);
        }
        return s;
    }



    private ArrayList<InetAddress> loadBlackListedIP(){
    private ArrayList<String> loadBlackListedIP(){
        //load blacklist from file
        return new ArrayList<InetAddress>();
        return new ArrayList<String>();
    }
}


Old	New	Code
19	19	public class Register {
20	20
21	21	public ArrayList<RegisteredServer> listOfServers;
22		private ArrayList<InetAddress> blackListedIP;
	22	private ArrayList<String> blackListedIP;
23	23
24	24	public Register(){
25	25	listOfServers=new ArrayList<RegisteredServer>();
71	71	}
72	72
73	73	public void heartBeat(RegisteredServer RS){
	74	Main.printLog("HEARTBEAT received from "+RS.getIP().toString()+":"+RS.getPort());
74	75	RegisteredServer A = Main.register.getServer(RS);
75	76	if(A!=null){
76	77	A.rearmWatchdog();
77	78	A.reAffect(RS);
78		printRegisterList();
79	79	}
	80	Main.register.printRegisterList();
80	81	}
81	82
82	83	public boolean isAlreadyRegistered(RegisteredServer RS){
104	105	}
105	106
106	107	public boolean isBlackListed(RegisteredServer RS){
107		InetAddress ip = RS.getIP();
108		for(InetAddress IP:blackListedIP){
	108	String ip = RS.getIP();
	109	for(String IP:blackListedIP){
109	110	if(IP.equals(ip)){
110	111	return true;
111	112	}
114	115	}
115	116
116	117	public void printRegisterList(){
117		System.out.println(getRegisterList());
118		}
119
120		public String getRegisterList(){
121	118	String s="";
122	119	String tmp="";
123	120	int max=0;
124	121	if(!listOfServers.isEmpty()){
125	122	for(RegisteredServer rs : listOfServers){
126		tmp="\| "+rs.getIP()+" \| "+rs.getPort()+" \| "+rs.isActive()+" \| "+rs.getDescription()+"\n";
127		s+=tmp;
128		if(tmp.length()>max){
129		max=tmp.length();
	123	if(rs.isActive()){
	124	tmp="\| "+rs.getIP()+":"+rs.getPort()+" \| "+rs.isProtected()+" \| "+rs.getNumberOfPlayers()+"/"+rs.getMaxNumberOfPlayers()+" \| "+rs.getDescription()+"\n";
	125	s+=tmp;
	126	if(tmp.length()>max){
	127	max=tmp.length();
	128	}
130	129	}
131	130	}
132	131	s="\n"+s;
135	134	s+="-";
136	135	}
137	136	}
	137	System.out.println(s);
	138	}
	139
	140	public String getRegisterInfo(){
	141	String s="";
	142	if(!listOfServers.isEmpty()){
	143	for(RegisteredServer rs : listOfServers){
	144	if(rs.isActive()){
	145	s+=rs.getIP()+":"+rs.getPort()+":"+rs.isProtected()+":"+rs.getNumberOfPlayers()+":"+rs.getMaxNumberOfPlayers()+":"+rs.getDescription()+"\n";
	146	}
	147	}
	148	s=s.substring(0, s.length()-1);
	149	}
138	150	return s;
139	151	}
140	152
141	153
142	154
143		private ArrayList<InetAddress> loadBlackListedIP(){
	155	private ArrayList<String> loadBlackListedIP(){
144	156	//load blacklist from file
145		return new ArrayList<InetAddress>();
	157	return new ArrayList<String>();
146	158	}
147	159	}
148	160


 */
public class RegisteredServer {

    private InetAddress IP;
    private String IP;
    private int port;
    private String description;
    private boolean isProtected;
    public int counter;//to verify every 10 heartbeat that the server is still accessible
    private boolean activate;

    public RegisteredServer(InetAddress IP,int port, String description,boolean isProtected){
    public RegisteredServer(String IP,int port,boolean isProtected,int nbPlayers,int maxPlayers, String description){
        this.IP=IP;
        this.port=port;
        this.description=description;
        this.isProtected=isProtected;
        this.nbPlayers=nbPlayers;
        this.maxPlayers=maxPlayers;
        this.watchdog=0;
        this.activate=false;
    }
        return activate;
    }

    public InetAddress getIP(){
    public String getIP(){
        return IP;
    }

    public int getPort(){
        return port;
    }

    public boolean isProtected(){
        return isProtected;
    }

    public String getDescription() {
        return description;
    }
    public int getNumberOfPlayers(){
        return nbPlayers;
    }
    public int getMaxNumberOfPlayers(){
        return maxPlayers;
    }

    public void reAffect(RegisteredServer RS){
        this.description=RS.description;
        this.isProtected=RS.isProtected;
        this.nbPlayers=RS.nbPlayers;
        this.maxPlayers=RS.maxPlayers;
        //and more...
    }
}


Old	New	Code
26	26	*/
27	27	public class RegisteredServer {
28	28
29		private InetAddress IP;
	29	private String IP;
30	30	private int port;
31	31	private String description;
32	32	private boolean isProtected;
37	37	public int counter;//to verify every 10 heartbeat that the server is still accessible
38	38	private boolean activate;
39	39
40		public RegisteredServer(InetAddress IP,int port, String description,boolean isProtected){
	40	public RegisteredServer(String IP,int port,boolean isProtected,int nbPlayers,int maxPlayers, String description){
41	41	this.IP=IP;
42	42	this.port=port;
43	43	this.description=description;
44	44	this.isProtected=isProtected;
	45	this.nbPlayers=nbPlayers;
	46	this.maxPlayers=maxPlayers;
45	47	this.watchdog=0;
46	48	this.activate=false;
47	49	}
64	66	return activate;
65	67	}
66	68
67		public InetAddress getIP(){
	69	public String getIP(){
68	70	return IP;
69	71	}
70
71	72	public int getPort(){
72	73	return port;
73	74	}
74
75	75	public boolean isProtected(){
76	76	return isProtected;
77	77	}
78
79	78	public String getDescription() {
80	79	return description;
81	80	}
	81	public int getNumberOfPlayers(){
	82	return nbPlayers;
	83	}
	84	public int getMaxNumberOfPlayers(){
	85	return maxPlayers;
	86	}
82	87
83	88	public void reAffect(RegisteredServer RS){
84	89	this.description=RS.description;
85	90	this.isProtected=RS.isProtected;
	91	this.nbPlayers=RS.nbPlayers;
	92	this.maxPlayers=RS.maxPlayers;
86	93	//and more...
87	94	}
88	95	}
89	96

Logiciel libre. Free software.

Browse the code