Denis Rystsov rystsov

## gist:5898584
<html>
<body>
    <div id="canvas"></div>
    <script type="text/javascript">
        var canvas = document.getElementById("canvas");
        var input = document.createElement("input");
        input.type = "textbox";
        input.value = "click here and then on address";
        input.style.cssText += ";width:200px;"
        input.addEventListener("blur", function(){

## portqsp.py
from Queue import Queue
from threading import Thread
from time import sleep

# main queues
tasks  = Queue()
results = Queue()

# auxiliary queues & workers ####################################################
preresults = Queue()

## regexp.py
import string

def ltot(l):
    def _ltot(l, i):
        if len(l)==i: return ()
        return (l[i], _ltot(l, i+1))
    return _ltot(l, 0)

def symbol(x):
    def parser(txt):

## dswitch.py
class Switch:
    def __init__(self, nodes, q, node_id):
        self.proposer = Proposer(nodes, q, node_id)
    @endpoint
    def write(self, value, due):
        def change(previous):
            return value if previous == None else previous
        def query(current):
            if current == value:
                return current

## dvar.py
class Variable:
    def __init__(self, nodes, q, node_id):
        self.proposer = Proposer(nodes, q, node_id)
    @endpoint
    def write(self, ver, value, due):
        def change(previous):
            if previous == None or previous.ver==ver:
                return Val(ver = ver+1, value = value)
            return previous
        def query(current):

## how-paxos-acceptor.py
Accepted = namedtuple('Accepted', ['n', 'state'])
class Acceptor:
    def __init__(self, node_id, hdd):
        self.node_id = node_id
        if hdd.is_empty():
            hdd.write(promise=0, accepted=Accepted(0,None))
            # emit_* functions are used to record a event and capture a bit of context
            # The proof is based on reasoning on the structure of the sequence of the event
            # that the program can generate
            emit_accepted(0, node_id=self.node_id, ts=now(), accepted_n=0, state=self.hdd.accepted.state)

## how-paxos-cas_update.py
def cas_update(old, new):
  def change(x):
    if x!=old: raise Conflict(x)
    return new
  return change

## multi-paxos-trivial.py
Accepted = namedtuple('Accepted', ['n', 'state'])

class Acceptor:
    def __init__(self, node_id):
        self.node_id = node_id
        self.promise = 0
        self.accepted = Accepted(0,None)
        emit_accepted(0, node_id=self.node_id, ts=now(), accepted_n=0, state=self.accepted.state)
    @synchronized
    def prepare(self, ballot_n):

## dpp-heart.py
    def _read_write_read(self, test, val, due):
        with self.mem.lock:
            # makes a snapshot of the current state
            era, nodes, q = self.mem.era, self.nodes, self.q
            # increase counter of era's active _read_write_read ops
            self.mem.ops+=1
        n = self._get_n(0)
        resps = net.send(nodes, lambda x: x.prepare(n), due-now())
        try:
            ok = resps.where(lambda x: isinstance(x.msg, Accepted)).wait(q)

## dpp-acceptor.py
Accepted = namedtuple('Accepted', ['n', 'val'])
class Variable:
    def __init__(self, nodes, q):
        self.q = q
        self.nodes = nodes
        self.promise = 0
        self.accepted = Accepted(0,None)
        self.mem = Mem()     # we don't persist self.mem and keep it in memory
        self.mem.era = 0     # current era
        self.mem.ops = 0     # number of active _read_write_read started in current era
	<html>
	<body>
	<div id="canvas"></div>
	<script type="text/javascript">
	var canvas = document.getElementById("canvas");
	var input = document.createElement("input");
	input.type = "textbox";
	input.value = "click here and then on address";
	input.style.cssText += ";width:200px;"
	input.addEventListener("blur", function(){
	from Queue import Queue
	from threading import Thread
	from time import sleep

	# main queues
	tasks = Queue()
	results = Queue()

	# auxiliary queues & workers ####################################################
	preresults = Queue()
	import string

	def ltot(l):
	def _ltot(l, i):
	if len(l)==i: return ()
	return (l[i], _ltot(l, i+1))
	return _ltot(l, 0)

	def symbol(x):
	def parser(txt):
	class Switch:
	def __init__(self, nodes, q, node_id):
	self.proposer = Proposer(nodes, q, node_id)
	@endpoint
	def write(self, value, due):
	def change(previous):
	return value if previous == None else previous
	def query(current):
	if current == value:
	return current
	class Variable:
	def __init__(self, nodes, q, node_id):
	self.proposer = Proposer(nodes, q, node_id)
	@endpoint
	def write(self, ver, value, due):
	def change(previous):
	if previous == None or previous.ver==ver:
	return Val(ver = ver+1, value = value)
	return previous
	def query(current):
	Accepted = namedtuple('Accepted', ['n', 'state'])
	class Acceptor:
	def __init__(self, node_id, hdd):
	self.node_id = node_id
	if hdd.is_empty():
	hdd.write(promise=0, accepted=Accepted(0,None))
	# emit_* functions are used to record a event and capture a bit of context
	# The proof is based on reasoning on the structure of the sequence of the event
	# that the program can generate
	emit_accepted(0, node_id=self.node_id, ts=now(), accepted_n=0, state=self.hdd.accepted.state)
	def cas_update(old, new):
	def change(x):
	if x!=old: raise Conflict(x)
	return new
	return change
	Accepted = namedtuple('Accepted', ['n', 'state'])

	class Acceptor:
	def __init__(self, node_id):
	self.node_id = node_id
	self.promise = 0
	self.accepted = Accepted(0,None)
	emit_accepted(0, node_id=self.node_id, ts=now(), accepted_n=0, state=self.accepted.state)
	@synchronized
	def prepare(self, ballot_n):
	def _read_write_read(self, test, val, due):
	with self.mem.lock:
	# makes a snapshot of the current state
	era, nodes, q = self.mem.era, self.nodes, self.q
	# increase counter of era's active _read_write_read ops
	self.mem.ops+=1
	n = self._get_n(0)
	resps = net.send(nodes, lambda x: x.prepare(n), due-now())
	try:
	ok = resps.where(lambda x: isinstance(x.msg, Accepted)).wait(q)
	Accepted = namedtuple('Accepted', ['n', 'val'])
	class Variable:
	def __init__(self, nodes, q):
	self.q = q
	self.nodes = nodes
	self.promise = 0
	self.accepted = Accepted(0,None)
	self.mem = Mem() # we don't persist self.mem and keep it in memory
	self.mem.era = 0 # current era
	self.mem.ops = 0 # number of active _read_write_read started in current era