spacejam

{
  "targets": [
    {
      "name": "mesos-master",
      "type": "master"
    },
    {
      "name": "mesos-slave",
      "type": "slave"
    },

spacejam

compile rust code with DWARF symbols

cargo -g ...

open in gdb

gdb target/debug/...

set a breakpoint at src/native/mod.rs line 57

spacejam

2015/08/21 15:16:36 etcdmain: setting maximum number of CPUs to 1, total number of available CPUs is 4
2015/08/21 15:16:36 etcdmain: listening for peers on http://localhost.localdomain:31000
2015/08/21 15:16:36 etcdmain: listening for client requests on http://localhost.localdomain:31001
2015/08/21 15:16:36 etcdserver: name = etcd-1440192979
2015/08/21 15:16:36 etcdserver: data dir = etcd_data
2015/08/21 15:16:36 etcdserver: member dir = etcd_data/member
2015/08/21 15:16:36 etcdserver: heartbeat = 100ms
2015/08/21 15:16:36 etcdserver: election = 1000ms
2015/08/21 15:16:36 etcdserver: snapshot count = 10000
2015/08/21 15:16:36 etcdserver: advertise client URLs = http://localhost.localdomain:31001

spacejam

Step 1: DNS

/etc/defaults/docker:

DOCKER_OPTS="--bip=172.17.42.1/24 --dns 172.17.42.1"

restart docker sysctl restart docker

start dns container

spacejam

apl shell

I want a shell to be a terse DSL for invoking syscalls in a maximally composable fashion.

J is an extremely terse functional language with a rich set of standard operators.

Can we merge a traditional shell with a J interpreter? oleg seems to have some related work

spacejam

create KEYSPACE test WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 3};   -- pick replication factor of size of cluster
create table test.test ( thing text PRIMARY KEY);

-- on each host
CONSISTENCY ALL;
INSERT INTO test.test (thing) VALUES ('A');
-- does this complete?  if not, you may have a partition x_x

spacejam

import etcd, json

def traverse(node):
    if node.dir and len(node._children) != 0:
        for child in node.children:
            traverse(c.read(child.key))
    elif not node.dir:
        print node.key
        try:
            print json.dumps(json.loads(node.value),

spacejam

otp/lib/kernel/src/net_kernel.erl

-spec connect_node(Node) -> boolean() | ignored when
  Node :: node().
%% explicit connects
connect_node(Node) when is_atom(Node) ->
  request({connect, normal, Node}).

otp/lib/kernel/src/net_kernel.erl

spacejam

Basic idea: distributed OS with ZSH-like interface
Slave OS - Linux (CoreOS?)
DFS - Ceph, GlusterFS (latency optimized)

Scheduler - mesos framework that considers:
  machine composite utilization
  locality to replica of binary
  workload characterization databaes

spacejam

Stream Algorithms
  One-Pass Heavy Hitters
    Deterministic
      Misra-Gries
      Lossy counting
      Quantile Digest
    Randomized
      Fast AMS + heap
      Hierarchical Fast AMS