Navigation

← Previous Changeset
Next Changeset →

Changeset 337

Timestamp:

03/21/06 00:42:51 (3 years ago)

Author:

alban

Message:

[Bug 69] added STUN support to determinate the right public reference

Files:

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/.classpath

r333	r337
28	28	<classpathentry kind="lib" path="track/commons-logging/releases/1.1.0/commons-logging-1.1-RC5.jar"/>
29	29	<classpathentry kind="lib" path="track/log4j/releases/1.2.13/dist/lib/log4j-1.2.13.jar"/>
	30	<classpathentry sourcepath="track/jstun/releases/0.5.9.2/src" kind="lib" path="track/jstun/releases/0.5.9.2/jstun-0.5.9.2.jar"/>
30	31	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
31	32	<classpathentry kind="output" path=".eclipse"/>

trunk/build.xml

r309	r337
198	198	</library>
199	199
	200	<library id="lib.jstun">
	201	<lib-entry groupid="jstun" version="0.5.9.2"/>
	202	</library>
	203
200	204	<library id="core">
201	205	<lib-entry groupid="commons-collections" version="3.1" />
…	…
210	214	<lib-entry groupid="concurrent" version="kolaka" />
211	215	<library refid="lib.mina" />
	216	<library refid="lib.jstun" />
212	217	</library>
213	218

trunk/source/org/kolaka/freecast/peer/AutomaticPeerReferenceFactory.java

r71	r337
24	24
25	25	import java.io.IOException;
26		~~import java.net.Inet4Address;~~
27	26	import java.net.InetAddress;
28		~~import java.net.NetworkInterface;~~
29		~~import java.util.Enumeration;~~
30		~~import java.util.HashSet;~~
31		~~import java.util.Iterator;~~
32		~~import java.util.Set;~~
33	27
34		~~import org.apache.commons.collections.CollectionUtils;~~
35		~~import org.apache.commons.collections.EnumerationUtils;~~
36		~~import org.apache.commons.collections.Predicate;~~
37		~~import org.apache.commons.collections.functors.InstanceofPredicate;~~
38		~~import org.apache.commons.collections.functors.NotPredicate;~~
39	28	import org.apache.commons.lang.Validate;
40	29	import org.kolaka.freecast.net.PublicAddressResolver;
…	…
45	34	public class AutomaticPeerReferenceFactory implements PeerReferenceFactory {
46	35
47		private ~~int defaultPort = UNDEFINED~~;
	36	private final int port;
48	37
49	38	private PublicAddressResolver publicAddressResolver;
50	39
51		private static final int UNDEFINED = -1;
52
53		public void setDefaultPort(int defaultPort) {
54		Validate.isTrue(InetPeerReference.validatePort(defaultPort),
55		"Invalid port: " + defaultPort);
56		this.defaultPort = defaultPort;
	40	public AutomaticPeerReferenceFactory(int port) {
	41	Validate.isTrue(InetPeerReference.validatePort(port));
	42	this.port = port;
	43	this.localFactory = new LocalPeerReferenceFactory(port);
57	44	}
58	45
59		public void setPublicAddressResolver(
60		PublicAddressResolver publicAddressResolver) {
61		Validate.notNull(publicAddressResolver,
62		"No specified PublicAddressResolver");
	46	public void setPublicAddressResolver(PublicAddressResolver publicAddressResolver) {
	47	Validate.notNull(publicAddressResolver);
63	48	this.publicAddressResolver = publicAddressResolver;
64	49	}
	50
	51	private final LocalPeerReferenceFactory localFactory;
65	52
66	53	public PeerReference create() throws PeerReferenceFactoryException {
67		if (defaultPort == UNDEFINED) {
68		throw new IllegalStateException("No defined default port");
69		}
70
71		Set addresses;
72		try {
73		addresses = getLocalInetAddress();
74		} catch (IOException e) {
75		throw new PeerReferenceFactoryException(
76		"Can't determinate the local inet addresses", e);
77		}
	54	InetAddress publicAddress;
78	55
79	56	try {
80		~~addresses.add(getPublicAddress()~~);
	57	publicAddress = getPublicAddress();
81	58	} catch (IOException e) {
82	59	throw new PeerReferenceFactoryException(
83	60	"Can't determinate the public inet addresses", e);
84	61	}
85
86		Set references = new HashSet();
87		for (Iterator iter = addresses.iterator(); iter.hasNext();) {
88		InetAddress address = (InetAddress) iter.next();
89		references.add(InetPeerReference.getInstance(address
90		.getHostAddress(), defaultPort, false));
91		}
92		return new MultiplePeerReference(references);
	62
	63	InetPeerReference publicReference = InetPeerReference.getInstance(publicAddress.getHostAddress(), port, false);
	64	return InetPeerReferences.create(localFactory.create(),publicReference);
93	65	}
94	66
…	…
100	72	}
101	73
102		~~private Set getLocalInetAddress() throws IOException {~~
103		~~Set inetAddresses = new HashSet();~~
104
105		~~Enumeration networkInterfaces = NetworkInterface.getNetworkInterfaces();~~
106		~~while (networkInterfaces.hasMoreElements()) {~~
107		~~NetworkInterface networkInterface = (NetworkInterface) networkInterfaces~~
108		~~.nextElement();~~
109		~~inetAddresses.addAll(EnumerationUtils.toList(networkInterface~~
110		~~.getInetAddresses()));~~
111		}
112
113		~~CollectionUtils.filter(inetAddresses, new InstanceofPredicate(~~
114		~~Inet4Address.class));~~
115
116		~~if (inetAddresses.size() > 1) {~~
117		~~Predicate loopback = new Predicate() {~~
118
119		~~public boolean evaluate(Object object) {~~
120		~~return ((InetAddress) object).isLoopbackAddress();~~
121		}
122		};
123		~~CollectionUtils.filter(inetAddresses, new NotPredicate(loopback));~~
124		}
125
126		~~return inetAddresses;~~
127		}
128
129	74	}

trunk/source/org/kolaka/freecast/peer/PeerReferenceLoader.java

r71	r337
23	23	package org.kolaka.freecast.peer;
24	24
	25	import java.net.InetAddress;
25	26	import java.net.InetSocketAddress;
26	27	import java.util.HashSet;
…	…
59	60	}
60	61
61		private PeerReference createReference(Configuration configuration)
	62	private PeerReference createReference(final Configuration configuration)
62	63	throws ConfigurationException {
63		~~PeerReference reference;~~
64	64	String referenceClass = configuration.getString("class", "inet");
	65
	66	PeerReferenceFactory factory;
	67
65	68	if (referenceClass.equals("inet")) {
66		reference = InetPeerReference.getInstance(configuration
67		.getString("host"), configuration.getInt("port",
68		listenAddress.getPort()), true);
	69	factory = new PeerReferenceFactory() {
	70	public PeerReference create() throws PeerReferenceFactoryException {
	71	return InetPeerReference.getInstance(configuration
	72	.getString("host"), configuration.getInt("port",
	73	listenAddress.getPort()), true);
	74	};
	75	};
69	76	} else if (referenceClass.equals("multiple")) {
	77	factory = new PeerReferenceFactory() {
	78	public PeerReference create() throws PeerReferenceFactoryException {
70	79	Set references = new HashSet();
71	80	// TODO horrible limitation of Commons Configuration ..
…	…
76	85	listenAddress.getPort(), true));
77	86	}
78		reference = new MultiplePeerReference(references);
	87	return new MultiplePeerReference(references);
	88	}};
79	89	} else if (referenceClass.equals("auto")) {
80		AutomaticPeerReferenceFactory factory = new AutomaticPeerReferenceFactory();
81		factory.setDefaultPort(listenAddress.getPort());
82		try {
83		reference = factory.create();
84		} catch (PeerReferenceFactoryException e) {
85		throw new ConfigurationException(
86		"Can't create the automatic reference", e);
87		}
	90	factory = new AutomaticPeerReferenceFactory(listenAddress.getPort());
	91	} else if (referenceClass.equals("stun")) {
	92	InetSocketAddress stunServer = new InetSocketAddress(
	93	configuration.getString("host"), configuration.getInt("port",3478));
	94	factory = new StunPeerReferenceFactory(listenAddress.getPort(), stunServer);
88	95	} else {
89	96	throw new ConfigurationException("Unknow reference class: "
90	97	+ referenceClass);
91	98	}
92
93		return reference;
	99
	100	try {
	101	return factory.create();
	102	} catch (PeerReferenceFactoryException e) {
	103	throw new ConfigurationException(
	104	"Can't create the automatic reference", e);
	105	}
94	106	}
95	107

trunk/source/org/kolaka/freecast/peer/test/AutomaticPeerReferenceFactoryTest.java

r71	r337
35	35
36	36	public void testCreate() throws PeerReferenceFactoryException {
37		AutomaticPeerReferenceFactory factory = new AutomaticPeerReferenceFactory();
38
39		try {
40		factory.create();
41		fail();
42		} catch (IllegalStateException e) {
43		// expected exception
44		}
45
46		factory.setDefaultPort(1000);
47
	37	AutomaticPeerReferenceFactory factory = new AutomaticPeerReferenceFactory(1000);
48	38	MultiplePeerReference reference = (MultiplePeerReference) factory
49	39	.create();

trunk/source/org/kolaka/freecast/transport/MinaPeerReceivingConnection.java

r333	r337
172	172
173	173	protected void sendNodeStatus(PeerStatus peerStatus) {
174		if (!getStatus().equals(PeerConnection.Status.OPEN~~ING~~)) {
	174	if (!getStatus().equals(PeerConnection.Status.OPENED)) {
175	175	latencyMonitor.statusSent(peerStatus);
176	176	}
…	…
218	218	public void statusReceived(PeerStatus remoteStatus) {
219	219	if (sendingTimeStamp == UNKNOWN_TIMESTAMP) {
220		LogFactory.getLog(getClass()).debug(
221		"unexpected remote PeerStatus received: "
222		+ remoteStatus);
	220	LogFactory.getLog(getClass()).trace("unexpected remote PeerStatus received: " + remoteStatus);
223	221	return;
224	222	}

trunk/source/org/kolaka/freecast/transport/receiver/PeerReceiverControler.java

r333	r337
150	150
151	151	try {
	152	final PeerConnectionStatusListener closeListener = new PeerConnectionStatusAdapter() {
	153	protected void connectionClosed(PeerConnection connection) {
	154	LogFactory.getLog(getClass()).debug("lost connection with " + peer);
	155	openedConnections.remove(peer);
	156	}
	157	};
152	158	PeerConnectionStatusListener listener = new PeerConnectionStatusAdapter() {
153	159	private boolean registered;
154	160
155		~~protected void connectionClosed(PeerConnection connection) {~~
156		~~LogFactory.getLog(getClass()).trace("lost connection with " + peer);~~
157		~~openedConnections.remove(peer);~~
158		}
159	161	protected synchronized void connectionOpened(PeerConnection connection) {
160	162	if (registered) {
…	…
165	167	registered = true;
166	168	LogFactory.getLog(getClass()).debug("new opened connection with " + peer);
	169	connection.add(closeListener);
167	170	openedConnections.put(peer, connection);
168	171	}
…	…
174	177	}
175	178	}
	179
	180
	181
176	182
177	183	private PeerReceiver receiver;

Download in other formats: