def _initialise_server(self):
if type(self.auth) == EtcdAuth:
self._server = Etcd3Client(self.host,
self.port,
user=self.auth.username,
password=self.auth.password,
timeout=self.timeout)
else:
self._server = Etcd3Client(self.host,
self.port,
timeout=self.timeout)
def initiate(cls, db: Etcd3Client, frz: FrozenThreadContext, r: 'Request', stack):
# we need:
# - create a new stack frame in the context of the http request
sf = StackFrame.new(
uuid4().hex,
{
**stack,
'req_id': r.id
}
)
a1, b1 = frz.call(db, sf)
a2, b2 = sf.create(db)
ok, _ = db.transaction(
compare=[
a1,
a2
],
success=[
b1,
b2,
], failure=[
]
)
return ok, r
def exec(self, db: Etcd3Client):
ok, items = db.transaction(
compare=self.comp,
success=self.succ,
failure=self.fail,
)
# we might want the mapper not to be so strict.
if ok:
items_ok = [
y.deserialize_range(z) for z, y in zip(items, self.succ_map)
if y
]
else:
items_ok = [None for _ in self.succ_map]
if not ok:
items_fail = [
y.deserialize_range(z) for z, y in zip(items, self.fail_map)
if y
]
else:
items_fail = [None for _ in self.fail_map]
return ok, items_ok, items_fail
def follow(self, db: Etcd3Client, lock_ident, f: FollowUp):
updated = None
if self.id in [x.id for x in f.create_threads]:
updated = [x for x in f.create_threads if x.id == self.id][0]
# spinlock-based modification procedure
# UNLOCK: THREAD
# todo: we need to realise that the only reason we have locks is to reduce the contention in the queue
compare = [
db.transactions.value(self.lock_key) == lock_ident,
]
# CREATE: THREAD
success = [
db.transactions.put(y.key, y.serialize()) for y in f.create_threads
]
# UNLOCK
success += [db.transactions.delete(self.key)
] if updated is None else []
# DELETE LOCK
success += [
db.transactions.delete(self.lock_key),
]
# UPDATE: STACK
compare += [
db.transactions.version(x.key) == x.version
for x in f.update_stacks
]
success += [
db.transactions.put(x.key, x.serialize()) for x in f.update_stacks
]
# CREATE: STACK
success += [
db.transactions.put(x.key, x.serialize()) for x in f.create_stacks
]
# DELETE: STACK
compare += [
db.transactions.version(x.key) == x.version
for x in f.delete_stacks
]
success += [db.transactions.delete(x.key) for x in f.delete_stacks]
ok, _ = db.transaction(compare=compare, success=success, failure=[])
return ok, updated
def unlock(self, db: Etcd3Client, lock_ident):
ok, _ = db.transaction(compare=[
db.transactions.value(self.lock_key) == lock_ident,
],
success=[
db.transactions.delete(self.lock_key),
],
failure=[])
return ok
def unfreeze(self, db: Etcd3Client):
ok, _ = db.transaction(compare=[
db.transactions.version(self.ctx.key) == 0,
db.transactions.version(self.key) == self.version,
],
success=[
db.transactions.put(self.ctx.key,
self.ctx.serialize()),
db.transactions.delete(self.key),
])
return ok
def load_all(cls: Type[T], db: Etcd3Client) -> Dict[str, T]:
r = {}
prefix = cls.key_fn('')
for v, v_m in db.get_prefix(prefix):
k = cls.key_fn_rev(v_m.key.decode())
try:
r[k] = cls.deserialize(k, v_m.version, v)
except Exception as e:
raise ValueError(f'While deserializing ID={k}: {e}')
return r
def watch_range_queue(queue: Queue, db: Etcd3Client, prefix):
kwargs = {}
kwargs['range_end'] = \
utils.increment_last_byte(utils.to_bytes(prefix))
def cb(event):
ident = event.key.decode()[len(prefix):]
if isinstance(event, DeleteEvent):
queue.put(
RangeEvent(prefix, ident, Ev.Delete, event.value,
event.version))
elif isinstance(event, PutEvent):
queue.put(
RangeEvent(prefix, ident, Ev.Put, event.value, event.version))
else:
logger.error(f'UnknownEvent: {event}')
return db.add_watch_callback(key=prefix, callback=cb, **kwargs)
def connect(self):
endpoints = []
if len(self._endpoints) == 0:
endpoints.append(self.SRV(self.host, self.port, 0, 0))
else:
endpoints = self._endpoints
for endpoint in endpoints:
host = gethostbyname(endpoint[0])
port = endpoint[1]
try:
self._etcd = Etcd3Client(host, port, self.ca_cert,
self.cert_key, self.cert_cert,
self.timeout, self.user,
self.password)
with self._etcd.lock('health.lock') as lock:
self._etcd.put('/health', str(time()))
lock.release()
except Exception as e:
self._error = str(e)
self._etcd = None
break
return self._etcd
from etcd3 import Etcd3Client, Lock
from kazoo.client import KazooClient
from kubernetes import client, config, watch
config.load_kube_config()
my_id = uuid.uuid4()
def work():
print("I get the lock {}".format(str(my_id)))
etc3client = Etcd3Client(host='192.168.0.172',
ca_cert='../ca.pem',
cert_cert='../kubernetes.pem',
cert_key='../kubernetes-key.pem',
port=2379)
v1 = client.CoreV1Api()
logging.basicConfig()
#获得zk地址，建立地址映射
ret = v1.list_pod_for_all_namespaces(watch=False)
zk_namespaceh_dict = {}
zkpodname = re.compile('zk.*')
for i in ret.items:
if not zk_namespaceh_dict.get(i.metadata.namespace):
zk_namespaceh_dict[i.metadata.namespace] = []
if zkpodname.match(i.metadata.name):
tmp = "%s:2181" % (i.status.pod_ip)