added exporter service

src/bin/exporter/Exporter.hx

@@ -0,0 +1,67 @@
+package bin.exporter;
+
+import kernel.net.Package.GenericPackage;
+import kernel.peripherals.exports.RedstoneExport;
+import kernel.peripherals.Peripherals.Peripheral;
+import kernel.ps.ProcessHandle;
+import kernel.ps.IProcess;
+
+/**
+	A service to expose local peripherals to the network. 
+**/
+@:build(macros.Binstore.includeBin("Exporter", ["exporter"]))
+class Exporter implements IProcess {
+	public function new() {}
+
+	public function run(handle:ProcessHandle) {
+		if (handle.args.length < 2) {
+			handle.writeLine("Not enough args: <addr> <type>");
+			handle.close(false);
+		}
+
+		var addr = handle.args[0];
+		var expectedType = handle.args[1];
+
+		// Check if peripheral is present. Not the case for redstone.
+		if (expectedType != kernel.peripherals.Redstone.TYPE_NAME && !Peripheral.isPresent(addr)) {
+			handle.writeLine('Address: $addr not present');
+			handle.close(false);
+		}
+
+		var types = Peripheral.getTypes(addr);
+
+		// Check if the correct type is present. Not the case for redstone.
+		if (expectedType != kernel.peripherals.Redstone.TYPE_NAME && !types.contains(expectedType)) {
+			handle.writeLine('Expected type not machted on address: $addr. Wanted $expectedType got $types');
+			handle.close(false);
+		}
+
+		var peri = Peripheral.getFromType(addr, expectedType);
+
+		if (peri == null) {
+			handle.writeLine('Failed to create peripheral for address: $addr');
+			handle.close(false);
+		}
+
+		var handePackFunc:(GenericPackage) -> Bool = null;
+
+		// Cast to RPC class
+		// TODO: There must be a smarter way to do this.
+		switch expectedType {
+			case kernel.peripherals.Redstone.TYPE_NAME:
+				handePackFunc = (p) -> {
+					return RedstoneExport.handlePackage(cast peri, p);
+				};
+				// TODO: More peripherals
+		}
+
+		handle.writeLine('Listening on export:$addr with type $expectedType');
+
+		// Listen for packages
+		kernel.net.Net.registerProto('export:$addr', (p) -> {
+			if (!handePackFunc(p)) {
+				handle.writeLine("Failed handle package on export");
+			}
+		});
+	}
+}

src/kernel/peripherals/Peripherals.hx

@@ -83,7 +83,7 @@ class Peripheral {
 				return getPrinter(addr);
 			case Speaker.TYPE_NAME:
 				return getSpeaker(addr);
-			case "redstone":
+			case Redstone.TYPE_NAME:
 				return getRedstone(addr);
 		}
 

src/kernel/peripherals/Redstone.hx

@@ -1,5 +1,6 @@
 package kernel.peripherals;
 
+import kernel.peripherals.interfaces.IRedstone;
 import haxe.ds.ReadOnlyArray;
 import lib.Color;
 
@@ -41,7 +42,7 @@ abstract BundleMask(Int) from cc.Colors.Color to cc.Colors.Color {
 	}
 }
 
-class Redstone implements IPeripheral {
+class Redstone implements IPeripheral implements IRedstone {
 	public static inline final TYPE_NAME:String = "redstone"; // TODO: there is technically not a type for redstone.
 
 	public final onChange:Signal<Noise>;

src/kernel/peripherals/exports/RedstoneExport.hx

@@ -0,0 +1,7 @@
+package kernel.peripherals.exports;
+
+import macros.rpc.RPCBase;
+import kernel.peripherals.interfaces.IRedstone;
+
+@:build(macros.rpc.RPC.buildRPC(IRedstone))
+class RedstoneExport extends RPCBase {}

src/kernel/peripherals/interfaces/IRedstone.hx

@@ -0,0 +1,17 @@
+package kernel.peripherals.interfaces;
+
+import cc.Colors.Color;
+import kernel.peripherals.Redstone.BundleMask;
+
+interface IRedstone {
+	function setOutput(on:Bool):Void;
+	function getOutput():Bool;
+	function getInput():Bool;
+	function setAnalogOutput(strength:Int):Void;
+	function getAnalogOutput():Int;
+	function getAnalogInput():Int;
+	function setBundledOutput(output:BundleMask):Void;
+	function getBundledOutput():BundleMask;
+	function getBundledInput():BundleMask;
+	function testBundledInput(mask:Color):Bool;
+}