package ca.digitalrapids.net;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.logging.Level;
import java.util.logging.Logger;
import ca.digitalrapids.util.concurrent.DRThreadFactory;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
/** Monitors the local system's IP, and informs of any changes.
*/
public class IpChangeNotifier {
static public class IpChangeEvent {
private final IpChangeEventType type;
private final NetworkInterface networkInterface;
private final Set oldAddresses;
private final Set newAddresses;
public IpChangeEvent(IpChangeEventType type,
NetworkInterface networkInterface,
Set oldAddresses, Set newAddresses) {
super();
this.type = type;
this.networkInterface = networkInterface;
this.oldAddresses = oldAddresses == null ? null :
Collections.unmodifiableSet(oldAddresses);
this.newAddresses = newAddresses == null ? null :
Collections.unmodifiableSet(newAddresses);
}
public IpChangeEventType getType() {
return type;
}
public NetworkInterface getNetworkInterface() {
return networkInterface;
}
public Set getOldAddresses() {
return oldAddresses;
}
public Set getNewAddresses() {
return newAddresses;
}
@Override
public String toString() {
return "Event [type=" + type + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((type == null) ? 0 : type.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
IpChangeEvent other = (IpChangeEvent) obj;
if (type != other.type)
return false;
return true;
}
}
static public enum IpChangeEventType {
INTERFACE_ADDED,
INTERFACE_REMOVED,
ADDRESSES_CHANGED
}
static private class InterfaceInfo {
public final NetworkInterface networkInterface;
public final Set lastAddresses;
public InterfaceInfo(NetworkInterface networkInterface,
Set lastAddresses) {
super();
this.networkInterface = networkInterface;
this.lastAddresses = lastAddresses;
}
}
public interface Listener {
void handleIpChange(IpChangeEvent event);
}
interface NetworkInterfacesFactory {
List get() throws SocketException;
}
static private final transient Logger logger = Logger
.getLogger(IpChangeNotifier.class.getName());
private final List listeners =
new CopyOnWriteArrayList();
private final ScheduledExecutorService executor =
Executors.newSingleThreadScheduledExecutor(
new DRThreadFactory("IpChangeNotifier", true));
private final long delayMillis;
private NetworkInterfacesFactory networkInterfacesFactory =
new NetworkInterfacesFactory()
{
@Override
public List get() throws SocketException {
return Collections.list(NetworkInterface.getNetworkInterfaces());
}
};
private Map interfaceInfosByName =
Maps.newHashMap();
public IpChangeNotifier(long delayMillis) {
super();
this.delayMillis = delayMillis;
}
public void setNetworkInterfacesFactory(
NetworkInterfacesFactory networkInterfacesFactory) {
this.networkInterfacesFactory = networkInterfacesFactory;
}
public void addListener(Listener listener) {
this.listeners.add(listener);
}
public void removeListener(Listener listener) {
this.listeners.remove(listener);
}
/**
* Remove all listeners
*/
public void clear() {
this.listeners.clear();
}
public void start() {
setBaseline();
executor.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
try {
check();
} catch (Throwable e) {
logger.log(Level.SEVERE, e.getMessage(), e);
}
}
}, 0, delayMillis, TimeUnit.MILLISECONDS);
}
public void stop() {
executor.shutdown();
}
public void check()
{
check(true);
}
private void check(boolean fire) {
try {
Collection removedInterfaces =
Sets.newHashSet(interfaceInfosByName.values());
for (NetworkInterface networkInterface : networkInterfacesFactory.get())
{
String interfaceName = networkInterface.getName();
Set currentAddresses =
getInetAddresses(networkInterface);
InterfaceInfo interfaceInfo =
interfaceInfosByName.get(interfaceName);
if ( interfaceInfo == null )
{
interfaceInfosByName.put(interfaceName,
new InterfaceInfo(networkInterface, currentAddresses));
if ( fire )
fireIpChanged(new IpChangeEvent(
IpChangeEventType.INTERFACE_ADDED,
networkInterface, null, currentAddresses));
} else {
removedInterfaces.remove(interfaceInfo);
if ( !interfaceInfo.lastAddresses.equals(currentAddresses) ) {
logger.info("interface "+interfaceName+" addresses " +
"changed from "+interfaceInfo.lastAddresses+" to "+
currentAddresses);
interfaceInfosByName.put(interfaceName,
new InterfaceInfo(networkInterface, currentAddresses));
if ( fire )
fireIpChanged(new IpChangeEvent(
IpChangeEventType.ADDRESSES_CHANGED,
networkInterface, interfaceInfo.lastAddresses,
currentAddresses));
}
}
}
handleInterfacesRemoved(removedInterfaces);
} catch (SocketException e) {
logger.log(Level.WARNING, "IP check failed. Could not get " +
"network interfaces", e);
}
}
private void handleInterfacesRemoved(
Collection removedInterfaces)
{
for (InterfaceInfo interfaceInfo : removedInterfaces) {
interfaceInfosByName.remove(interfaceInfo.networkInterface.getName());
fireIpChanged(new IpChangeEvent(IpChangeEventType.INTERFACE_REMOVED,
interfaceInfo.networkInterface, interfaceInfo.lastAddresses,
null));
}
}
private HashSet getInetAddresses(
NetworkInterface networkInterface) {
return Sets.newHashSet(Collections.list(
networkInterface.getInetAddresses()));
}
private void fireIpChanged(IpChangeEvent event) {
for (Listener listener : listeners) {
listener.handleIpChange(event);
}
}
public static void main(String[] args) {
IpChangeNotifier ipChangeNotifier = new IpChangeNotifier(1000);
ipChangeNotifier.addListener(new Listener() {
@Override
public void handleIpChange(IpChangeEvent event) {
System.out.println("ip changed "+event);
}
});
ipChangeNotifier.start();
System.out.println("kevin");
}
public void setBaseline() {
check(false);
}
}
package ca.digitalrapids.net;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.util.Collections;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import ca.digitalrapids.net.IpChangeNotifier.IpChangeEvent;
import ca.digitalrapids.net.IpChangeNotifier.IpChangeEventType;
import ca.digitalrapids.net.IpChangeNotifier.Listener;
import ca.digitalrapids.net.IpChangeNotifier.NetworkInterfacesFactory;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
public class IpChangeNotifierTest {
private IpChangeNotifier subject;
@Mock
private NetworkInterfacesFactory interfacesFactory;
@Mock
private Listener listener;
@Mock
private InterfaceAddress interfaceAddress;
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
subject = new IpChangeNotifier(500);
subject.setNetworkInterfacesFactory(interfacesFactory);
subject.addListener(listener);
}
@Test
public void testGeneral() throws Exception {
List interfaces = Lists.newArrayList();
when(interfacesFactory.get()).thenReturn(interfaces);
/* NetworkInterface is final, so we can't mock it. Need to think of
* another way to test this class. */
NetworkInterface networkInterface0 =
NetworkInterface.getNetworkInterfaces().nextElement();
subject.check();
verifyZeroInteractions(listener);
interfaces.add(networkInterface0);
subject.check();
ArgumentCaptor captor =
ArgumentCaptor.forClass(IpChangeEvent.class);
verify(listener).handleIpChange(captor.capture());
IpChangeEvent resultEvent = captor.getValue();
assertEquals(IpChangeEventType.INTERFACE_ADDED, resultEvent.getType());
assertEquals(networkInterface0, resultEvent.getNetworkInterface());
assertNull(resultEvent.getOldAddresses());
assertEquals(Sets.newHashSet(Collections.list(
networkInterface0.getInetAddresses())),
resultEvent.getNewAddresses());
subject.check();
verifyZeroInteractions(listener);
}
@Test
public void testSetBaseline() throws Exception {
List interfaces = Lists.newArrayList();
when(interfacesFactory.get()).thenReturn(interfaces);
/* NetworkInterface is final, so we can't mock it. Need to think of
* another way to test this class. */
NetworkInterface networkInterface0 =
NetworkInterface.getNetworkInterfaces().nextElement();
interfaces.add(networkInterface0);
subject.setBaseline();
subject.check();
verifyZeroInteractions(listener);
}
@Test
public void testInterfaceRemoved() throws Exception {
List interfaces = Lists.newArrayList();
when(interfacesFactory.get()).thenReturn(interfaces);
/* NetworkInterface is final, so we can't mock it. Need to think of
* another way to test this class. */
NetworkInterface networkInterface0 =
NetworkInterface.getNetworkInterfaces().nextElement();
interfaces.add(networkInterface0);
subject.setBaseline();
interfaces.clear();
subject.check();
ArgumentCaptor captor =
ArgumentCaptor.forClass(IpChangeEvent.class);
verify(listener).handleIpChange(captor.capture());
IpChangeEvent resultEvent = captor.getValue();
assertEquals(IpChangeEventType.INTERFACE_REMOVED, resultEvent.getType());
assertEquals(networkInterface0, resultEvent.getNetworkInterface());
assertNull(resultEvent.getNewAddresses());
assertEquals(Sets.newHashSet(Collections.list(
networkInterface0.getInetAddresses())),
resultEvent.getOldAddresses());
subject.check();
verifyZeroInteractions(listener);
}
}
