GabrielTofvesson/Broadcast
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Gabriel Tofvesson 2017-11-28 01:36:48 +01:00
commit 1ff10f0cc5
10 changed files with 572 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.idea/.name generated Normal file
View File

@ -0,0 +1 @@
Broadcast

9
.idea/artifacts/Broadcast_jar.xml generated Normal file
View File

@ -0,0 +1,9 @@
<component name="ArtifactManager">
<artifact type="jar" name="Broadcast:jar">
<output-path>$PROJECT_DIR$/out/artifacts/Broadcast_jar</output-path>
<root id="archive" name="Broadcast.jar">
<element id="module-output" name="Broadcast" />
<element id="dir-copy" path="$PROJECT_DIR$/src" />
</root>
</artifact>
</component>

15
.idea/inspectionProfiles/Project_Default.xml generated Normal file
View File

@ -0,0 +1,15 @@
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="EmptyCatchBlock" enabled="false" level="WARNING" enabled_by_default="false">
<option name="m_includeComments" value="true" />
<option name="m_ignoreTestCases" value="true" />
<option name="m_ignoreIgnoreParameter" value="true" />
</inspection_tool>
<inspection_tool class="WeakerAccess" enabled="false" level="WARNING" enabled_by_default="false">
<option name="SUGGEST_PACKAGE_LOCAL_FOR_MEMBERS" value="true" />
<option name="SUGGEST_PACKAGE_LOCAL_FOR_TOP_CLASSES" value="true" />
<option name="SUGGEST_PRIVATE_FOR_INNERS" value="false" />
</inspection_tool>
</profile>
</component>

6
.idea/misc.xml generated Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_9" default="true" project-jdk-name="9.0" project-jdk-type="JavaSDK">
<output url="file://$PROJECT_DIR$/out" />
</component>
</project>

8
.idea/modules.xml generated Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/Broadcast.iml" filepath="$PROJECT_DIR$/Broadcast.iml" />
</modules>
</component>
</project>

11
Broadcast.iml Normal file
View File

@ -0,0 +1,11 @@
<?xml version="1.0" encoding="UTF-8"?>
<module type="JAVA_MODULE" version="4">
<component name="NewModuleRootManager" inherit-compiler-output="true">
<exclude-output />
<content url="file://$MODULE_DIR$">
<sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
</content>
<orderEntry type="inheritedJdk" />
<orderEntry type="sourceFolder" forTests="false" />
</component>
</module>

202
src/net/tofvesson/broadcast/client/Accumulator.java Normal file
View File

@ -0,0 +1,202 @@
package net.tofvesson.broadcast.client;
import net.tofvesson.broadcast.support.ImmutableArray;
import net.tofvesson.broadcast.support.ImmutableReferenceMap;
import java.io.IOException;
import java.net.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Accumulates a list of hosts that are broadcasting to a given port.
*/
public class Accumulator {
/**
* Timeout (in milliseconds) until a host is considered to no longer be active.
*/
public static final long DEFAULT_HOST_TIMEOUT = 60_000;
/**
* Minimum timeout until a host is considered inactive.
*/
public static final long MINIMUM_HOST_TIMEOUT = 50;
private final Runnable accumulate;
private Thread accumulatorThread;
private final int port;
protected final DatagramSocket socket;
protected final DatagramPacket packet;
protected volatile long continueUntil = -1;
protected final Map<InetAddress, Long> hosts = new HashMap<>();
protected final ImmutableReferenceMap<InetAddress, Long> accessHosts = new ImmutableReferenceMap<>(hosts);
protected final long hostTimeout;
protected final ImmutableArray<Byte> signature;
public OnHostTimeoutListener timeoutListener;
public OnNewHostListener newHostListener;
/**
* Create an accumulator
* @param port Port to listen on.
* @param hostTimeout Timeout (milliseconds) until a host is lost (unless another broadcast is detected)
* @param sig Signature to check if a broadcast is originating from a compatible source.
* @throws SocketException Thrown if port is already bound
* @throws SecurityException Thrown if program isn't allowed to accept broadcasts
*/
public Accumulator(int port, long hostTimeout, byte[] sig) throws SocketException, SecurityException {
if(System.getSecurityManager()!=null) System.getSecurityManager().checkAccept("255.255.255.255", port); // Do a permission check
this.socket = new DatagramSocket(this.port = port);
socket.setSoTimeout(125);
this.packet = new DatagramPacket(new byte[sig.length + 1], sig.length + 1); // One extra byte implicitly serves as metadata during packet comparison
this.hostTimeout = hostTimeout;
this.signature = ImmutableArray.from(sig);
accumulate = () -> {
while(continueUntil==-1 || System.currentTimeMillis()<continueUntil){
try {
socket.receive(packet);
if(signature.length() == packet.getLength() && signature.compare(ImmutableArray.from(packet.getData()), packet.getOffset(), 0, packet.getLength()))
synchronized (hosts){
if(hosts.containsKey(packet.getAddress())) hosts.replace(packet.getAddress(), System.currentTimeMillis());
else{
hosts.put(packet.getAddress(), System.currentTimeMillis());
if(newHostListener!=null) newHostListener.onNewHost(packet.getAddress(), port);
}
}
} catch (SocketTimeoutException e) {
// NOP
} catch (IOException e) {
e.printStackTrace();
}
}
};
}
/**
* Create an accumulator
* @param port Port to listen on.
* @param signature Signature to check if a broadcast is originating from a compatible source.
* @throws SocketException Thrown if port is already bound
* @throws SecurityException Thrown if program isn't allowed to accept broadcasts
*/
public Accumulator(int port, byte[] signature) throws SocketException, SecurityException { this(port, DEFAULT_HOST_TIMEOUT, signature); }
/**
* Start the accumulator and let it run indefinitely
*/
public void start(){ startFor(-1); }
/**
* Start accumulator
* @param timeMillis Milliseconds until accumulator should automatically stop
*/
public void startFor(long timeMillis){
continueUntil = timeMillis==-1?-1:System.currentTimeMillis()+timeMillis;
TimeoutManager.theManager.addAccumulator(this);
if(accumulatorThread!=null && accumulatorThread.isAlive()) throw new IllegalStateException("Thread is still alive!");
accumulatorThread = new Thread(accumulate);
accumulatorThread.setName("Accumulator-"+port);
accumulatorThread.setPriority(Thread.MAX_PRIORITY);
accumulatorThread.setDaemon(true);
accumulatorThread.setUncaughtExceptionHandler((t, e) -> {
e.printStackTrace();
// NOP
});
accumulatorThread.start();
}
/**
* Pause the accumulator. Resume by calling {@link #start()}
*/
public void pause(){
continueUntil = 0;
if(accumulatorThread!=null && accumulatorThread.isAlive())
try {
accumulatorThread.join();
}
catch (InterruptedException e) { e.printStackTrace(); }
}
/**
* Stop accumulating hosts and disable host timeout checks. Cannot be resumed from
*/
public void stop(){
pause();
TimeoutManager.theManager.removeAccumulator(this);
socket.close();
}
/**
* Get an immutable map of the currently available hosts.
* @return Immutable host map.
*/
public ImmutableReferenceMap<InetAddress, Long> getHosts() { return accessHosts; }
/**
* Callback for when a new host is found
*/
public interface OnNewHostListener{
/**
* Called when a new host is found.
* @param host The IP address of the host
* @param port Listener port
*/
void onNewHost(InetAddress host, int port);
}
/**
* Callback for timed out remote hosts
*/
public interface OnHostTimeoutListener{
/**
* Called when a host is timed out.
* @param host The IP address of the host
* @param port Listener port
*/
void onTimeout(InetAddress host, int port);
}
private static class TimeoutManager{
static TimeoutManager theManager = new TimeoutManager();
private final List<Accumulator> checks = new ArrayList<>();
public TimeoutManager() {
Thread t = new Thread(() -> {
//noinspection InfiniteLoopStatement
while(true){
try{ Thread.sleep(Accumulator.MINIMUM_HOST_TIMEOUT); }catch(Exception e){}
Accumulator[] a1;
synchronized (checks){ a1 = checks.toArray(new Accumulator[checks.size()]); }
for(Accumulator a : a1)
synchronized (a.hosts){
for(InetAddress addr : a.hosts.keySet())
if(a.hosts.get(addr) <=System.currentTimeMillis()-a.hostTimeout) {
a.hosts.remove(addr);
if(a.timeoutListener!=null) a.timeoutListener.onTimeout(addr, a.port);
}
}
}
});
t.setDaemon(true);
t.setPriority(Thread.MIN_PRIORITY);
t.setName("Accumulator-TimeoutManager");
t.setUncaughtExceptionHandler((r, e)->{});
t.start();
}
void addAccumulator(Accumulator a){ checks.removeIf(it -> it==a); synchronized (checks){ checks.add(a); } }
void removeAccumulator(Accumulator a){ checks.removeIf(it -> it==a); synchronized (checks){ checks.remove(a); } }
}
}

98
src/net/tofvesson/broadcast/server/Server.java Normal file
View File

@ -0,0 +1,98 @@
package net.tofvesson.broadcast.server;
import java.net.*;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Broadcasts a signature on the current subnet
*/
public class Server {
private final Runnable serve;
private Thread serverThread;
private final int port;
protected final DatagramSocket serverSocket;
protected final DatagramPacket packet;
protected final AtomicBoolean isAlive = new AtomicBoolean(false);
/**
* Create broadcaster
* @param port Port to broadcast to
* @param delay Millisecond delay between broadcasts
* @param sig Signature to broadcast
* @param offset Offset in the signature to broadcast
* @param length Length of signature to broadcast
* @throws SocketException Thrown if broadcast socket could not be created
*/
public Server(int port, long delay, byte[] sig, int offset, int length) throws SocketException {
try {
this.serverSocket = new DatagramSocket();
this.packet = new DatagramPacket(sig, offset, length, InetAddress.getByAddress(new byte[]{-1, -1, -1, -1}), this.port = port);
serve = () -> {
while(getIsAlive()){
try {
serverSocket.send(packet);
} catch (Exception e) {
e.printStackTrace();
break;
}
try { Thread.sleep(delay); } catch (InterruptedException e) { }
}
};
} catch (UnknownHostException e) {
throw new RuntimeException(e); // This is an internal Java error and should not be a declared exception
}
}
/**
* Create broadcaster
* @param port Port to broadcast to
* @param delay Millisecond delay between broadcasts
* @param sig Signature to broadcast
* @throws SocketException Thrown if broadcast socket could not be created
*/
public Server(int port, long delay, byte[] sig) throws SocketException { this(port, delay, sig, 0, sig.length); }
protected boolean getIsAlive(){
boolean b;
synchronized (isAlive){ b = isAlive.get(); }
return b;
}
protected void setIsAlive(boolean b){ synchronized (isAlive){ isAlive.set(b); } }
/**
* Start broadcasting signature
*/
public void start(){
if(serverSocket.isClosed()) throw new IllegalStateException("Socket is closed");
if(serverThread!=null && serverThread.isAlive()) throw new IllegalStateException("Server is still alive");
setIsAlive(true);
serverThread = new Thread(serve);
serverThread.setDaemon(true);
serverThread.setPriority(Thread.MAX_PRIORITY);
serverThread.setName("Server-"+port);
serverThread.start();
}
/**
* Pause broadcasting of signature. Can be resumed by calling {@link #start()}
*/
public void pause(){
if(serverSocket.isClosed() && (serverThread==null || !serverThread.isAlive())) throw new IllegalStateException("Socket is closed");
setIsAlive(false);
serverThread.interrupt();
try { serverThread.join(); }
catch (InterruptedException e) { e.printStackTrace(); }
}
/**
* Stop broadcasting and close port. Cannot be resumed from
*/
public void stop(){
pause();
serverSocket.close();
}
}

85
src/net/tofvesson/broadcast/support/ImmutableArray.java Normal file
View File

@ -0,0 +1,85 @@
package net.tofvesson.broadcast.support;
import java.util.Arrays;
/**
* Wrapper for arrays to prevent modification
* @param <T> Element type
*/
public class ImmutableArray<T> {
protected final T[] array;
protected ImmutableArray(T[] array){ this.array = array; }
public int length(){ return array.length; }
public T at(int index){ return array[index]; }
@Override
public boolean equals(Object obj) {
Object[] compareTo;
if(obj instanceof ImmutableArray) compareTo = ((ImmutableArray) obj).array;
else if(obj!=null && obj.getClass().isArray()){
try{
compareTo = (Object[]) obj;
}catch(ClassCastException e){
return false; // Object was a primitive array
}
}
else return false;
return Arrays.equals(array, compareTo);
}
public boolean compare(ImmutableArray<T> to, int targetOffset, int offset, int length){
if(offset+length>array.length || targetOffset+length>to.array.length) return false;
for(int i = 0; i<length; ++i)
if(!areEqual(to.array[i+targetOffset], array[i+offset]))
return false;
return true;
}
protected static boolean areEqual(Object o1, Object o2){
return o1==o2 || (o1!=null && o1.equals(o2));
}
public static <T> ImmutableArray<T> from(T[] t){ return new ImmutableArray<>(t); }
public static ImmutableArray<Boolean> from(boolean[] t){
Boolean[] t1 = new Boolean[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
public static ImmutableArray<Character> from(char[] t){
Character[] t1 = new Character[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
public static ImmutableArray<Byte> from(byte[] t){
Byte[] t1 = new Byte[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
public static ImmutableArray<Short> from(short[] t){
Short[] t1 = new Short[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
public static ImmutableArray<Integer> from(int[] t){
Integer[] t1 = new Integer[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
public static ImmutableArray<Long> from(long[] t){
Long[] t1 = new Long[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
public static ImmutableArray<Float> from(float[] t){
Float[] t1 = new Float[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
public static ImmutableArray<Double> from(double[] t){
Double[] t1 = new Double[t.length];
for(int i = 0; i<t1.length; ++i) t1[i] = t[i];
return new ImmutableArray<>(t1);
}
}

137
src/net/tofvesson/broadcast/support/ImmutableReferenceMap.java Normal file
View File

@ -0,0 +1,137 @@
package net.tofvesson.broadcast.support;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;
/**
* Immutable map that references mutable map. Used to dissuade modification of a map
* @param <K> Key type
* @param <V> Value type
*/
public class ImmutableReferenceMap<K, V> implements Map<K, V> {
protected final Map<K, V> reference;
public ImmutableReferenceMap(Map<K, V> reference){
this.reference = reference;
}
@Override
public int size() {
return reference.size();
}
@Override
public boolean isEmpty() {
return reference.isEmpty();
}
@Override
public boolean containsKey(Object key) {
return reference.containsKey(key);
}
@Override
public boolean containsValue(Object value) {
return reference.containsValue(value);
}
@Override
public V get(Object key) {
return reference.get(key);
}
@Override
public V put(K key, V value) {
throw new IllegalStateException("Unsupported action");
}
@Override
public V remove(Object key) {
throw new IllegalStateException("Unsupported action");
}
@Override
public void putAll(Map<? extends K, ? extends V> m) {
throw new IllegalStateException("Unsupported action");
}
@Override
public void clear() {
throw new IllegalStateException("Unsupported action");
}
@Override
public Set<K> keySet() {
return reference.keySet();
}
@Override
public Collection<V> values() {
return reference.values();
}
@Override
public Set<Entry<K, V>> entrySet() {
return reference.entrySet();
}
@Override
public V getOrDefault(Object key, V defaultValue) {
return reference.getOrDefault(key, defaultValue);
}
@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
reference.forEach(action);
}
@Override
public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
throw new IllegalStateException("Unsupported action");
}
@Override
public V putIfAbsent(K key, V value) {
throw new IllegalStateException("Unsupported action");
}
@Override
public boolean remove(Object key, Object value) {
throw new IllegalStateException("Unsupported action");
}
@Override
public boolean replace(K key, V oldValue, V newValue) {
throw new IllegalStateException("Unsupported action");
}
@Override
public V replace(K key, V value) {
throw new IllegalStateException("Unsupported action");
}
@Override
public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
throw new IllegalStateException("Unsupported action");
}
@Override
public V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
throw new IllegalStateException("Unsupported action");
}
@Override
public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
throw new IllegalStateException("Unsupported action");
}
@Override
public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
throw new IllegalStateException("Unsupported action");
}
}