UDPSampleSender.java

package com.activequant.server.components;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

import com.activequant.component.ComponentBase;

/**
 * work in progress.
 * 
 * @author GhostRider
 * 
 */
public class UDPSampleSender extends ComponentBase {
	//
	private final String udpTargetHost;
	private final int udpTargetPort;

	public static void main(String[] args) throws Exception {
		new UDPSampleSender();
	}

	// //
	// public UDPRelay(ITransportFactory remoteNode, ITransportFactory
	// localNode)
	// throws Exception {
	// super("FeedMirror", localNode);
	public UDPSampleSender() throws Exception {
		super("UDP Relay", null);
		//
		this.udpTargetHost = super.properties.getProperty("UDP_TARGET_HOST",
				"192.168.0.177");
		this.udpTargetPort = Integer.parseInt(super.properties.getProperty(
				"UDP_TARGET_HOST", "54321"));

		//
		Thread t = new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					subscribe();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});

		// let's start a separate thread for this component.
		t.start();

		Thread t2 = new Thread(new ListenerThread());
		t2.start();
	}

	class ListenerThread implements Runnable {
		//
		public void run() {
			try {
				System.out.println("Starting listener thread at port "
						+ udpTargetPort + " ...");
				DatagramSocket serverSocket = new DatagramSocket(udpTargetPort);
				while (true) {
					// read packets, we will take a maximum size of 1300.
					byte[] buffer = new byte[6 * 200];
					DatagramPacket packet = new DatagramPacket(buffer,
							buffer.length);

					serverSocket.receive(packet);
					handlePacket(packet);
					//
				}
			} catch (SocketException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		private void handlePacket(DatagramPacket packet) {
			// let's process
			for (int i = 0; i < 200; i++) {
				//
				int startPos = i * 6;
				//
				byte[] floatValue = new byte[4];
				//
				if (packet.getData()[startPos] == 0x00)
					break;
				//
				System.arraycopy(packet.getData(), startPos + 2, floatValue, 0,
						4);
				//
				byte instId = packet.getData()[startPos + 1];
				//
				float f = ByteBuffer.wrap(floatValue)
						.order(ByteOrder.BIG_ENDIAN).getFloat();
				System.out.println("Theoretical price for instrument id "
						+ new Integer(instId) + " = " + f);
				//
			}

			System.out.println("===PacketDump======");
			for (int i = 0; i < packet.getData().length; i++) {
				System.out.print(packet.getData()[i] + " ");
			}
			System.out.println("\n=========");
		}
	}

	private void subscribe() throws Exception {
		//
		final DatagramSocket clientSocket = new DatagramSocket();
		final InetAddress ipAddress = InetAddress.getByName(this.udpTargetHost);
		while (true) {
			Thread.sleep(1000);
			byte[] data = new byte[6];
			data[0] = 0x01;

			data[1] = 0x00;
			//
			byte[] bytes = new byte[4];
			double r = Math.random();
			ByteBuffer.wrap(bytes).putFloat((float) r);
			//
			data[2] = bytes[0];
			data[3] = bytes[1];
			data[4] = bytes[2];
			data[5] = bytes[3];
			//
			try {
				clientSocket.send(new DatagramPacket(data, data.length,
						ipAddress, udpTargetPort));
				System.out.println("Market price sent for underlying: "
						+ (float) r);
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		//
		//
		// //
		// for (final String s : channels) {
		// //
		// IReceiver receiver = transFac.getReceiver(ETransportType.STATE, s);
		// //
		// final IPublisher publisher = transFac.getPublisher(s);
		// receiver.getRawEvent().addEventListener(
		// new IEventListener<byte[]>() {
		// @Override
		// public void eventFired(byte[] arg0) {
		// // base message.
		// ValueSet vs = null;
		// String field = vs.getField();
		// String value = vs.getValue();
		// Double v = Double.parseDouble(value);
		// //
		// byte commandByte = 0x00;
		// if(field.equals("M")){
		// //
		// commandByte = 0x00;
		// }
		// else if(field.equals("V")){
		// //
		// commandByte = 0x01;
		// }
		// //
		// Integer id = Integer.parseInt(s);
		// //
		// byte instrumentId = id.byteValue();
		// //
		// // assemble a datagram and send it ...
		// byte[] data = new byte[6];
		// data[0] = commandByte;
		// data[1] = instrumentId;
		// //
		// byte[] bytes = new byte[4];
		// ByteBuffer.wrap(bytes).putFloat(v.floatValue());
		// //
		// data[2] = bytes[0];
		// data[3] = bytes[1];
		// data[4] = bytes[2];
		// data[5] = bytes[3];
		// //
		// try {
		// clientSocket.send(new DatagramPacket(bytes, bytes.length, ipAddress,
		// udpTargetPort));
		// } catch (IOException e) {
		// e.printStackTrace();
		// }
		// //
		// }
		// });
		// }
		//
	}

	//
	@Override
	public String getDescription() {
		//
		return "Target host: " + this.udpTargetHost + " - target port: "
				+ this.udpTargetPort;
	}

}