async def act(self):
loop = asyncio.get_running_loop()
prev_write_id = self.last_write_id
curr_write_id = str(uuid.uuid1())
curr_version = self.last_version + 1
read_id = str(uuid.uuid1())
op_started = None
try:
self.stat.assign("size", self.checker.size())
cmdlog.info(
m(type="write_stared",
node=self.node.name,
key=self.key,
write_id=curr_write_id,
read_id=read_id,
prev_write_id=prev_write_id,
version=curr_version,
value=f"42:{curr_version}").with_time())
self.checker.read_started(read_id, self.key)
self.checker.cas_started(curr_write_id, self.key, prev_write_id,
curr_version, f"42:{curr_version}")
op_started = loop.time()
response = await self.node.cas_aio(self.key, prev_write_id,
f"42:{curr_version}",
curr_write_id)
data = response.record
op_ended = loop.time()
log_latency("ok", op_ended - self.started_at,
op_ended - op_started, self.node.idx, response.metrics)
cmdlog.info(
m(type="write_ended",
node=self.node.name,
key=self.key,
write_id=data.write_id,
value=data.value).with_time())
if data.write_id == curr_write_id:
self.checker.cas_ended(curr_write_id, self.key)
else:
self.checker.cas_canceled(curr_write_id, self.key)
self.checker.read_ended(read_id, self.key, data.write_id,
data.value)
read_version = int(data.value.split(":")[1])
self.last_write_id = data.write_id
if self.last_version < read_version:
self.last_version = read_version
self.stat.inc(self.node.name + ":ok")
self.stat.inc("all:ok")
except RequestTimedout:
try:
self.stat.inc(self.node.name + ":out")
op_ended = loop.time()
log_latency("out", op_ended - self.started_at,
op_ended - op_started, self.node.idx)
cmdlog.info(
m(type="write_timedout",
node=self.node.name,
write_id=curr_write_id,
key=self.key).with_time())
self.checker.read_canceled(read_id, self.key)
self.checker.cas_timeouted(curr_write_id, self.key)
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on write/timedout",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
except RequestCanceled:
try:
self.stat.inc(self.node.name + ":err")
op_ended = loop.time()
log_latency("err", op_ended - self.started_at,
op_ended - op_started, self.node.idx)
cmdlog.info(
m(type="write_canceled",
node=self.node.name,
write_id=curr_write_id,
key=self.key).with_time())
self.checker.read_canceled(read_id, self.key)
try:
self.checker.cas_canceled(curr_write_id, self.key)
except Violation as e:
cmdlog.info(
m(e.message,
type="linearizability_violation",
write_id=curr_write_id).with_time())
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on write/canceled",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
except RequestViolated as e:
try:
self.checker.report_violation("internal violation: " +
json.dumps(e.info))
except Violation as e:
cmdlog.info(
m(e.message,
type="linearizability_violation",
write_id=curr_write_id).with_time())
except Violation as e:
cmdlog.info(
m(e.message,
type="linearizability_violation",
write_id=curr_write_id).with_time())
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on write",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
async def start(self):
loop = asyncio.get_running_loop()
while self.is_active and self.checker.is_valid:
await asyncio.sleep(random.uniform(0, 0.05))
op_started = None
read_id = str(uuid.uuid1())
try:
self.stat.assign("size", self.checker.size())
cmdlog.info(
m(type="read_started",
node=self.node.name,
pid=self.pid,
read_id=read_id,
key=self.key).with_time())
self.checker.read_started(self.pid, self.key)
op_started = loop.time()
response = await self.node.get_aio(self.key, read_id)
read = response.record
op_ended = loop.time()
log_latency("ok", op_ended - self.started_at,
op_ended - op_started, self.node.idx,
response.metrics)
if read == None:
cmdlog.info(
m(type="read_404",
node=self.node.name,
pid=self.pid,
read_id=read_id,
key=self.key).with_time())
self.checker.read_none(self.pid, self.key)
else:
cmdlog.info(
m(type="read_ended",
node=self.node.name,
pid=self.pid,
read_id=read_id,
key=self.key,
write_id=read.write_id,
value=read.value).with_time())
self.checker.read_ended(self.pid, self.key, read.write_id,
read.value)
self.stat.inc(self.node.name + ":ok")
self.stat.inc("all:ok")
except RequestTimedout:
try:
op_ended = loop.time()
log_latency("out", op_ended - self.started_at,
op_ended - op_started, self.node.idx)
self.stat.inc(self.node.name + ":out")
cmdlog.info(
m(type="read_timedout",
node=self.node.name,
pid=self.pid,
read_id=read_id,
key=self.key).with_time())
self.checker.read_canceled(self.pid, self.key)
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on handing read timedout exception",
type="error",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
break
except RequestCanceled:
try:
op_ended = loop.time()
log_latency("err", op_ended - self.started_at,
op_ended - op_started, self.node.idx)
self.stat.inc(self.node.name + ".err")
cmdlog.info(
m(type="read_canceled",
node=self.node.name,
pid=self.pid,
read_id=read_id,
key=self.key).with_time())
self.checker.read_canceled(self.pid, self.key)
except:
# TODO: handle violation
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on handing read canceled exception",
type="error",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
break
except RequestViolated as e:
try:
self.checker.report_violation("internal violation: " +
json.dumps(e.info))
except Violation as e:
log_violation(self.pid, e.message)
break
except Violation as e:
log_violation(self.pid, e.message)
break
async def act(self):
loop = asyncio.get_running_loop()
op_started = None
read_id = str(uuid.uuid1())
try:
self.stat.assign("size", self.checker.size())
cmdlog.info(
m(type="read_started",
node=self.node.name,
read_id=read_id,
key=self.key).with_time())
self.checker.read_started(read_id, self.key)
op_started = loop.time()
response = await self.node.get_aio(self.key, read_id)
read = response.record
op_ended = loop.time()
log_latency("ok", op_ended - self.started_at,
op_ended - op_started, self.node.idx, response.metrics)
if read == None:
cmdlog.info(
m(type="read_404",
node=self.node.name,
read_id=read_id,
key=self.key).with_time())
self.checker.read_none(read_id, self.key)
else:
cmdlog.info(
m(type="read_ended",
node=self.node.name,
read_id=read_id,
key=self.key,
write_id=read.write_id,
value=read.value).with_time())
self.checker.read_ended(read_id, self.key, read.write_id,
read.value)
self.stat.inc(self.node.name + ":ok")
self.stat.inc("all:ok")
except RequestTimedout:
try:
op_ended = loop.time()
log_latency("out", op_ended - self.started_at,
op_ended - op_started, self.node.idx)
self.stat.inc(self.node.name + ":out")
cmdlog.info(
m(type="read_timedout",
node=self.node.name,
read_id=read_id,
key=self.key).with_time())
self.checker.read_canceled(read_id, self.key)
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on read/timedout",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
except RequestCanceled:
try:
op_ended = loop.time()
log_latency("err", op_ended - self.started_at,
op_ended - op_started, self.node.idx)
self.stat.inc(self.node.name + ".err")
cmdlog.info(
m(type="read_canceled",
node=self.node.name,
read_id=read_id,
key=self.key).with_time())
self.checker.read_canceled(read_id, self.key)
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on read/canceled",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
except RequestViolated as e:
try:
self.checker.report_violation("internal violation: " +
json.dumps(e.info))
except Violation as e:
cmdlog.info(
m(e.message,
type="linearizability_violation",
read_id=read_id).with_time())
except Violation as e:
cmdlog.info(
m(e.message, type="linearizability_violation",
read_id=read_id).with_time())
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on read",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
async def start(self):
loop = asyncio.get_running_loop()
while self.is_active and self.checker.is_valid and not self.checker.is_aborted:
await asyncio.sleep(random.uniform(0, 0.05))
prev = self.last_write_id
curr_write_id = str(uuid.uuid1())
curr_version = self.last_version + 1
op_started = None
try:
self.stat.assign("size", self.checker.size())
cmdlog.info(
m(type="write_stared",
node=self.node.name,
pid=self.pid,
key=self.key,
write_id=curr_write_id,
prev_write_id=prev,
version=curr_version,
value=f"42:{curr_version}").with_time())
self.checker.read_started(self.pid, self.key)
self.checker.cas_started(curr_write_id, self.key, prev,
curr_version, f"42:{curr_version}")
op_started = loop.time()
response = await self.node.cas_aio(self.key, prev,
f"42:{curr_version}",
curr_write_id)
data = response.record
op_ended = loop.time()
log_latency("ok", op_ended - self.started_at,
op_ended - op_started, response.metrics)
cmdlog.info(
m(type="write_ended",
node=self.node.name,
pid=self.pid,
key=self.key,
write_id=data.write_id,
value=data.value).with_time())
if data.write_id == curr_write_id:
self.checker.cas_ended(curr_write_id, self.key)
else:
self.checker.cas_canceled(curr_write_id, self.key)
self.checker.read_ended(self.pid, self.key, data.write_id,
data.value)
if data.write_id == curr_write_id:
self.last_version = curr_version
self.last_write_id = data.write_id
self.last_version = int(data.value.split(":")[1])
self.stat.inc(self.node.name + ":ok")
self.stat.inc("all:ok")
except RequestTimedout:
try:
self.stat.inc(self.node.name + ":out")
op_ended = loop.time()
log_latency("out", op_ended - self.started_at,
op_ended - op_started)
cmdlog.info(
m(type="write_timedout",
node=self.node.name,
pid=self.pid,
key=self.key).with_time())
self.checker.read_canceled(self.pid, self.key)
self.checker.cas_timeouted(curr_write_id, self.key)
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on handing write timedout exception",
type="error",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
break
except RequestCanceled:
try:
self.stat.inc(self.node.name + ":err")
op_ended = loop.time()
log_latency("err", op_ended - self.started_at,
op_ended - op_started)
cmdlog.info(
m(type="write_canceled",
node=self.node.name,
pid=self.pid,
key=self.key).with_time())
self.checker.read_canceled(self.pid, self.key)
try:
self.checker.cas_canceled(curr_write_id, self.key)
except Violation as e:
log_violation(self.pid, e.message)
break
except:
e, v = sys.exc_info()[:2]
cmdlog.info(
m("unexpected error on handing write canceled exception",
type="error",
error_type=str(e),
error_value=str(v),
stacktrace=traceback.format_exc()).with_time())
self.checker.abort()
break
except Violation as e:
log_violation(self.pid, e.message)
break