Fuse

This requires latest rupy.

This is how the current client/server tools work in a co-operative solution:

time <----------------  goes forth & back  ------------------>
wait      ....   .....   ....   ....   .....   ....           
loss             .....                 .....                  (CPU)

+--------+    +---------+           +---------+    +---------+
|        | -> |         | ---+----> |         |    |         |
|  brow  |    |  sync1  |    |      |  sync2  | .. |  serv2  |
|        | <- |         | <----+--- |         |    |         |
+--------+    +---------+    | |    +---------+    +---------+
                             | |
                         +---------+
                         |         |
                         |  serv1  |
                         |         |
                         +---------+

• brow = sync req (browser)
• serv = sync res (database)
• sync = sync req & res (old web-server)

The idea is to only wait in the network (no related IO-wait) and to wait for multiple things at the same time:

time <---------------  goes forth & back  --------------->
wait      ....           ..   ..           ....

+--------+    +---------+       +---------+    +---------+
|        | -> |         | -+--> |         |    |         |
|  brow  |    |  asyn1  |  |    |  asyn2  | .. |  serv2  |
|        | <- |         | <--+- |         |    |         |
+--------+    +---------+  | |  +---------+    +---------+
                           | |
                           | +---+
                           +---+ |
                               | |
                           +---------+
                           |         |
                           |  serv1  |
                           |         |
                           +---------+

• brow = sync req (browser)
• serv = sync res (database)
• asyn = asyn req & res (FUSE)

For this we introduce a new concept; FUSE. With FUSE all threads asyn end-to-end or socket-to-socket if you will, they never wait for anything.

Another way to describe this is time and IO-wait shown in the graph below:

1. sync req & res (old web-server)
2. asyn req (netflix)
3. asyn req & res (FUSE)

You can imagine that the compounded savings in terms of time and wait are huge, specially when the system grows in concurrency and depth. As a matter of fact, you can't scale at all without asyn req and with asyn req & res you're far better off.

If you want to use µSOA this is the most performant way to build your services network.

You can even use this as a load balancer.

Another use case for this is our cluster database ROOT.

This example fuses data asyn from multiple servers to your browser ASAP on a raspberry pi with zero thread IO-wait:

// TODO: Improve latch.
public static class Fuse extends Service {
	public String path() { return "/fuse"; }

	public void filter(final Event event) throws Event, Exception {
		if(event.push()) {
			Http[] http = (Http[]) event.query().get("http");
			Output out = event.output();
			int done = 0;

			for(int i = 0; i < http.length; i++) {
				if(http[i].print(out)) {
					done++;
				}
			}

			if(done == http.length) {
				out.println("</body></html>");
				out.finish();
			}

			out.flush();
		}
		else {
			event.query().put("time", System.currentTimeMillis());

			Http[] http = new Http[2];

			String path = "/v1/public/yql" +
			"?q=select%20*%20from%20yahoo.finance.xchange%20where%20pair%20in%20(%22USDSEK%22)" +
			"&format=json&env=store%3A%2F%2Fdatatables.org%2Falltableswithkeys";

			http[0] = new Http("one", "strip.rupy.se", "/?a=martin+kellerman&body", event);
			http[1] = new Http("two", "query.yahooapis.com", path, event);

			for(int i = 0; i < http.length; i++) {
				// The 10 at the end is very important.
				// It means the socket will be kept alive 
				// for 10 seconds since last active.
				// This is our Murphy's law solution.
				event.daemon().client().send(http[i].host, http[i], 10);
			}

			event.query().put("http", http);
		}
	}

	public static class Http extends Async.Work {
		private String name;
		private String host;
		private String path;
		private String body;
		private Event event;

		public Http(String name, String host, String path, Event event) {
			this.name = name;
			this.host = host;
			this.path = path;
			this.event = event;
		}

		public boolean print(Output out) throws Exception {
			if(event.query().get(name) instanceof Http) {
				long time = System.currentTimeMillis() - event.big("time");
				System.out.println("  " + name + " " + time + " ms.");
				out.println(body);
				event.query().put(name, "done");
				return true;
			}
			else if(event.query().get(name) instanceof String) {
				return ((String) event.query().get(name)).equals("done");
			}

			return false;
		}

		public void send(Async.Call call) throws Exception {
			call.get(path, "Host: " + host + "\r\n");
		}

		public void read(String body) throws Exception {
			this.body = body;
			event.query().put(name, this);
			System.out.println("  " + name + " success " + event.reply().wakeup());
			// Normally it's better to wakeup the response after all client requests are finished, 
			// but we wan't to show you the parts as they complete on-the-fly!
		}

		public void fail(String host, Exception e) throws Exception {
			if(e instanceof Async.Timeout) {
				System.out.println("  " + e);
				event.daemon().client().send(host, this, 10);
			}
			else {
				e.printStackTrace();
				event.query().put("response", e.toString());
				System.out.println("  " + name + " failure " + event.reply().wakeup());
			}
		}
	};
}