Software Evolved

Non-blocking UDP datagram replicator

pfranza — Mon, 15 Feb 2010 19:32:16 +0000

A class that listens to a UDP port and collects all the datagrams and then rebroadcasts those datagrams to other ports. This is useful for several reasons. I use it when stress testing UDP clients because I can subscribe to 1000 client sockets while only really having a single legitimate datasource.

public class Replicator {
	private final AsyncDatagramServer aserver;
 
	public Replicator(final int port, 
			final Collection<DataSinkPoint> endPoints) throws Exception {
		aserver = new AsyncDatagramServer(port, 
				new AsyncDatagramServer.AsyncDatagramServerListener() {
 
			@Override
			public void recieveDatagram(ByteBuffer buffer) {
				try {
					for(final DataSinkPoint d: endPoints) {
						d.send(buffer.duplicate());
					}
				} catch (final Exception e) {
					e.printStackTrace();
				}
			}
		});
	}
 
	private static class AsyncDatagramServer {
 
		private boolean running = true;
 
		public AsyncDatagramServer(final int port, 
				final AsyncDatagramServerListener listener) throws Exception {
 
			new Thread(){
 
				@Override
				public void run() {
					try {
						startSocket(port, listener);
					} catch (final Exception e) {
						throw new RuntimeException(e);
					}
				}
 
			}.start();
 
		}
 
		public interface AsyncDatagramServerListener {
			void recieveDatagram(ByteBuffer buffer);
		}
 
		public void shutdown() {
			running = false;
		}
 
		private void startSocket(final int port,
				AsyncDatagramServerListener listener) throws IOException,
				SocketException, ClosedChannelException, Exception {
			DatagramChannel serverChannel = DatagramChannel.open();
			Selector selector = Selector.open();
			DatagramSocket sock = serverChannel.socket();
			sock.setReuseAddress(true);
			sock.bind (new InetSocketAddress (port));
			serverChannel.configureBlocking (false);
			serverChannel.register(selector, SelectionKey.OP_READ);
			ByteBuffer buffer = ByteBuffer.allocate(2048);
 
			while (running) {
				if(selector.select(500) > 0) {
					processData(listener, selector, buffer);
				}
			}
 
			selector.close();
			serverChannel.close();
		}
 
		private void processData(AsyncDatagramServerListener listener,
				Selector selector, ByteBuffer buffer) throws Exception {
			Iterator<SelectionKey> it = selector.selectedKeys().iterator();
 
			while (it.hasNext()) {
				final SelectionKey key = it.next();
 
				if (key.isReadable()) {
					DatagramChannel channel = 
						(DatagramChannel) key.channel();
					buffer.clear();
					if (channel.receive(buffer) != null) {
						buffer.flip();
						listener.recieveDatagram(buffer.duplicate());
					}
				}
				it.remove();
			}
		}
 
 
 
	}
 
	public void shutdown() {
		aserver.shutdown();
	}
 
	public interface DataSinkPoint {
		void send(ByteBuffer buffer) throws IOException;
	}
 
	private static class DataSinkPointImpl implements DataSinkPoint {
		private final DatagramSocket socket;
 
		public DataSinkPointImpl(SocketAddress address) throws Exception {
			socket = new DatagramSocket();
			socket.connect(address);
		}
 
		@Override
		public void send(ByteBuffer buffer) throws IOException {
			socket.send(new DatagramPacket(buffer.array(),
					0, buffer.limit()));
		}
 
	}
 
}

Usage:

public static void main(String[] args) throws Exception {
	Collection<DataSinkPoint> endPoints = new ArrayList<DataSinkPoint>();
	for(int i = 4000; i < 5000; i++) {
		endPoints.add(new DataSinkPointImpl(
				new InetSocketAddress("127.0.0.1", i)));
	}
 
	final Replicator r = new Replicator(3000, endPoints);
	Thread.sleep(5000);
	r.shutdown();
	System.out.println("done.");
}

Announcing – “Announce” for Android

pfranza — Thu, 04 Feb 2010 03:29:53 +0000

Announce is an application for Android 2.0 and above. It intercepts incoming calls and and reads the name of the caller aloud. You can also record custom voice tags to use instead of the text to speech engine.

Project Page: http://www.peterfranza.com/projects/announce-for-android/

Price: Free (That’s a good value)

Enjoy.

BitArrayInputStream

pfranza — Fri, 09 Oct 2009 14:43:31 +0000

Sometime you just have to read the bits one by one at least now you don’t need to write your own class to do it. This class works for ‘Little Endian’ or ‘Big Endian’.

import java.io.IOException;
import java.io.InputStream;
 
public class BitArrayInputStream {
 
	private final BitDirection direction;
	private final InputStream inputStream;
	private int currentByte;
	private int currentPosition = -1;
 
	public BitArrayInputStream(InputStream inputStream) {
		this(BitDirection.HIGHLOW, inputStream);
	}
 
	public BitArrayInputStream(BitDirection direction,
			InputStream inputStream) {
		this.inputStream = inputStream;
		this.direction = direction;
	}
 
	public int readBit() throws IOException {
		if(currentPosition == -1) {
			currentByte = inputStream.read();
			if(currentByte == -1) {
				return -1;
			}
			currentPosition = 0;
		}
 
		int c = -1;
 
		if(direction.equals(BitDirection.HIGHLOW)) {
			c = (currentByte << currentPosition & 0x80) >> 7;
		} else {
			c = currentByte >> currentPosition & 0x1;
		}
 
		currentPosition += 1;
		if(currentPosition >= 8) {
			currentPosition = -1;
		}
 
		return c;
	}
 
	public static enum BitDirection {HIGHLOW, LOWHIGH}
 
}

And here is a unit test for it:

public class BitArrayInputStreamTest extends TestCase {
 
	public void testInit() throws Exception {
		assertNotNull(new BitArrayInputStream(null));
	}
 
	public void testReadBits() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(
				new ByteArrayInputStream(new byte[] {(byte) 0xA3}));
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
 
	}
 
	public void testReadBitsLowHigh() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(BitDirection.LOWHIGH,
				new ByteArrayInputStream(new byte[] {(byte) 0xA3}));
 
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
 
 
	}
 
	public void testReadBitsEnd() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(
				new ByteArrayInputStream(new byte[] {(byte) 0xA3}));
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
		assertEquals(-1, i.readBit());
 
 
	}
 
	public void testReadBitsMultiByte() throws Exception {
		BitArrayInputStream i = new BitArrayInputStream(
				new ByteArrayInputStream(
                                  new byte[] {(byte) 0xA3, (byte) 0xB6}));
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
 
		assertEquals(0, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(1, i.readBit());
		assertEquals(0, i.readBit());
 
	}
 
}

Look Mom, No Typing

pfranza — Sat, 27 Jun 2009 20:25:57 +0000

Always wanted to leave a comment about something you’ve read on my site, but couldn’t be bothered to type a response. Well now you can using my new Google Voice Call widget. Now you don’t have to worry about carpel tunnel or any of that fancy spelling stuff. Really all you need is a mouth and a phone.

Ignore Compiler Warnings

pfranza — Mon, 11 May 2009 13:55:58 +0000

Let me be upfront, I will be the first person to tell you that you should treat a warning as if it were an error. The compiler is trying to tell you something, it wants to help you. The very smart people who are designing our compiler aren’t identifying code patterns and exposing them as warnings for their health, so come on people … FIX YOUR WARNINGS!

Ok, now that I got that out of the way, we come to the special case. Third party source code generation tools, I actually love generated source, don’t ask me why but I find it much easier to deal with than all the mucking around you could do in meta-code etc. Just give me a plain ‘ol class that I can use. The drawback to generated source is some of the generators are pretty rough when it comes to warnings. They might have unneeded imports, referenced untyped classes, who knows. We all can agree that it would be optimal if the generators would just produce warning free code, and if it is in your power join up with some of these open-source projects and actually fix them (you’d be my hero).

When that isn’t an option I’d just ignore them, I’m adding an ant task that can read in a fileset and append warning suppression annotations to the class headings. Just remember you have not fixed anything, but to be perfectly practical you may never fix these things.

Download Jar File: suppresswarnings-05.jar

Usage:

Integer IP Addresses

pfranza — Wed, 04 Mar 2009 16:22:56 +0000

I know that every couple of years I need the snippet of code that helps me convert the integer version of an IP address back and forth to a string. You would think that after all this time I’d be able to write it blind.

public static String convertIntegerToIp(long ip) {
     StringBuffer buf = new StringBuffer();
      buf.append(((ip >> 24 ) & 0xFF)).append(".")
          .append(((ip >> 16 ) & 0xFF)).append(".")
          .append(((ip >>  8 ) & 0xFF)).append(".")
          .append(( ip        & 0xFF));		
      return buf.toString();
}
 
 public static long convertStringToIntegerIp(String ip) {
     String[] parts = ip.split("\\.");
     return (Long.valueOf(parts[0]) << 24) +
              (Long.valueOf(parts[1]) << 16) +
              (Long.valueOf(parts[2]) << 8) +
              (Long.valueOf(parts[3]));
 }

In C/C++ you can use an unsigned int instead of a long but in java there are no unsigned types and while I know that you can still do this calculation using a signed integer just as well in java, when you print out the address for visual inspection you will get a negative number and it won’t match the c++ printout so I’ve chosen to use a long to store the values.

Enjoy.

Asynchronous Executor

pfranza — Fri, 20 Feb 2009 18:48:07 +0000

I hate that sometimes I have to make calls to systems outside of my own system, essentially outside of my own control. And not all of these calls allow me to detect and recover when an operation is taking longer than it should.

So I’ve written a class that allows you to execute a task asynchronously and give it a maximum time to run, and you get a callback upon completion or upon failure. Now I can detect and recover when things happen that are outside of my control.

package com.peterfranza.synchro;
 
public class AsyncExecutor {
 
	private static java.util.concurrent.ExecutorService pool = 
		java.util.concurrent.Executors.newCachedThreadPool();
 
	public synchronized static void asyncExecuteTask(
			final Runnable task, 
			final long timeout, 
			final AsyncExecutorCallback callback) {
		pool.execute(new Runnable() {
 
			@Override
			public void run() {
				java.util.concurrent.Future<AsyncExecutorCallback> marker = 
					pool.submit(task, callback);
				try {
					marker.get(timeout, 
						java.util.concurrent.TimeUnit.MILLISECONDS)
						.taskCompleted();
				} catch (Exception e) {
                                        marker.cancel(true);
					callback.taskFailed();
				} 
			}
 
		});
	}
 
	public interface AsyncExecutorCallback {
		void taskCompleted();
		void taskFailed();
	}
 
}

Usage

package com.peterfranza.synchro;
 
import com.peterfranza.synchro.AsyncExecutor.AsyncExecutorCallback;
 
public class Usage {
 
	public static void main(String[] args) {
 
		AsyncExecutorCallback callback = new AsyncExecutorCallback() {
 
			@Override
			public void taskCompleted() {
				System.out.println("Task Completed");
			}
 
			@Override
			public void taskFailed() {
				System.out.println("Task Failed");
			}
 
		};
 
		AsyncExecutor.asyncExecuteTask(new QuickTask(), 1000, callback);
		AsyncExecutor.asyncExecuteTask(new LongTask(), 1000, callback);
	}
 
 
	private static class QuickTask implements Runnable {
		public void run() {
			try {Thread.sleep(10);}
			catch(Exception e){}
		}		
	}
 
	private static class LongTask implements Runnable {
		public void run() {
			try {Thread.sleep(100000);}
			catch(Exception e){}
		}		
	}
}

Copying Files Using NIO

pfranza — Sun, 26 Oct 2008 02:11:09 +0000

Prior to the JDK 1.4 introduction of the NIO package a tipical file copy routine would look something like:

public static void copyFile(File in, File out) throws Exception {
    FileInputStream fis  = new FileInputStream(in);
    FileOutputStream fos = new FileOutputStream(out);
    try {
        byte[] buf = new byte[1024];
        int i = 0;
        while ((i = fis.read(buf)) != -1) {
            fos.write(buf, 0, i);
        }
    } catch (Exception e) {
        throw e;
    } finally {
        if (fis != null) fis.close();
        if (fos != null) fos.close();
    }
  }

With the introduction of the NIO package’s conecpt of channels we can rewrite the fileCopy routine as:

public static void copyFile(File in, File out) 
        throws IOException  {
        FileChannel inChannel = new
            FileInputStream(in).getChannel();
        FileChannel outChannel = new
            FileOutputStream(out).getChannel();
        try {
            inChannel.transferTo(0, inChannel.size(),
                    outChannel);
        } catch (IOException e) {
            throw e;
        } finally {
            if (inChannel != null) inChannel.close();
            if (outChannel != null) outChannel.close();
        }
    }

However on windows platforms, you may have to replace

try {
            inChannel.transferTo(0, inChannel.size(),
                    outChannel);
        }

with

try {
           // magic number for Windows, 64Mb - 32Kb)
           int maxCount = (64 * 1024 * 1024) - (32 * 1024);
           long size = inChannel.size();
           long position = 0;
           while (position < size) {
              position += 
                inChannel.transferTo(position, maxCount, outChannel);
        }

when attempting to copy a file in excess of 64Mb.

Simplify Unit Testing With Dependency Injection

pfranza — Tue, 07 Oct 2008 03:07:56 +0000

After you read a bit about dependency injection you might say “So what? There isn’t much of a practical gain” and an the surface I actually agree with you, I mean how many instances are there where we really need to be able to create infinate class permutation without using subclassing? I believe the place where you are going to see dependency injection score major points is with your unit testing. The main reason is that you can provide mock implementations of all the dependencies and eliminate any vairance in their behaviour from the class you are testing.

For example, continuing from my previous post: with traditional composition we could test the Car class like this:

public class CarTest extends TestCase {
 
 public void testCar() throws Exception {
 Car c = new Car();
 assertEquals(.....);
 }
 
}

but the behaviour of the instance of car is really coupled to the behaviour of the AutomaticTransmission and GasEngine classes. If something breaks in the AutomaticTransmission class, more than likely our AutomaticTransmissionTest and CarTest cases will fail. This is slightly misleading because there isn’t really a problem with the Car class, and yet its test is failing because of the coupled behaviour to the AutomaticTransmission class. Using the dependency injection version of the class allows us to do something very different.

public class CarTest extends TestCase {
 
 private static class MockTransmission implements Transmission {
   ...
 }
 
 private static class MockEngine implements Engine {
   ...
 }
 
 public void testCar() throws Exception {
 Car c = new Car(new MockTransmission(), new MockEngine());
 assertEquals(.....);
 }
 
}

Now the Car we are testing has no dependencies outside of our testcase, this allows us to tightly control what we are putting under test and allow us to focus our effort on testing the single class rather than any extra behaviour that comes from the subcomponenets. In this scenerio if something breaks in the AutomaticTransmission class only the AutomaticTransmissionTest will fail because CarTest no longer has a dependency on AutomaticTransmission allowing them to operate (and fail) independently of one another.

Dependency Injection Basics

pfranza — Tue, 07 Oct 2008 02:39:08 +0000

Dependency Injection is a process of supplying external dependencies to componenets, changing the flow of control of the system to be inverted in comparison to the traditional architecture of software libraries. Dependency Injection builds of the concept that you should favor composition over inheritance [Effective Java Programming Language Guide, chapter 4, item 14], but extending it to say that the specific implementations of the subcomponenets that you are using to compose your class should be fully decoupled from the class itself.

public interface BrakeSystem {
 
}
 
public interface Engine {
 
}
 
public class Car {
 
 private Transmission transmission = new AutomaticTransmission();
 private Engine brakes = new GasEngine();
 
}

We can see that in class Car we’ve coupled the implementation of AutomaticTransmission and DiscBrakeSystem to the implementation of Car. What do we do when we want to create an instance of Car that has a manual Transmission? The answer is dependency injection. In this example we find it trivial to remove the coupling of subcomponent implementations by passing in the subcomponents at time of construction rather than at the time of compiliation.

public class Car {
 
 private Transmission transmission;
 private Engine engine;
 
 public Car(Transmission transmission, Engine engine) {
    this.transmission = transmission;
    this.engine = engine;
 }
 
}

Now we can use the constructor to create variations of the cars behaviour.

public class CarFactory {
 
 public static final Car createAutomaticCar() {
 return new Car(new AutomaticTransmission(),
 new GasEngine());
 }
 
 public static final Car createManualCar() {
 return new Car(new ManualTransmission(),
 new GasEngine());
 }
 
}

Using this method we can vary the components of car without subclassing it, allowing the freedom to provide numerious unique representations of cars without changing anything in the car class itself. Its all left to wiring the classes together in an appropriate way.

Can’t I just use the Service Locator Pattern?

Well it is true that dependency injection does aim to solve the same problem as the Service Locator Pattern, usage of the pattern requires you to build in logic that preforms the dependency resolution and construction. This introduces cross cutting behaviour that disrupts the cohesion and singular responsibility of the class. By removing the service location logic and relegating it into a factory or some other framework level function, a high level of cohesion can be maintained. This will be true for both the object and its factory, as the single responsibility of the factory is to construct instances of the class, and the class just has to be itself.

Usage of Dependency Injection Frameworks

I sit firmly on the fence about the usage of frameworks for dependency injection, becuase it seems that they all have a dark side to them that in one way or another reduces readability/traceability of the classes. Some like Google Guice use method annotations to define where the injection points are, and while this seems to be be a relativly consice way to inform the framework it adds a lot of extranious information to your code that doesn’t really make sense within the context of the class.

This is where I actually like the use of factories that construct the objects and do the injection for you. Its generally clean, and it localizes the couplings to a factory which is natually where they should be. The downside is sometimes dependency injection can get several layers deep (you have a class that requires classes which requre classes etc) and the notion that you would have a factory method for each one of the permutations is quite excessive. However if you only add a method that builds the specific combination that you are looking for this might strike a nice middle ground.