Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
acl = acl or self.default_acl
paths_to_make = []
for segment in path[1:].split("/"):
if not paths_to_make:
paths_to_make.append("/" + segment)
continue
paths_to_make.append("/".join([paths_to_make[-1], segment]))
while paths_to_make:
path = paths_to_make[0]
if self.features.create_with_stat:
request = protocol.Create2Request(path=path, acl=acl)
else:
request = protocol.CreateRequest(path=path, acl=acl)
request.set_flags(
ephemeral=False, sequential=False, container=self.features.containers
)
try:
await self.send(request)
except exc.NodeExists:
pass
paths_to_make.pop(0)
async def commit(self):
if not self.request.requests:
raise ValueError("No operations to commit.")
response = await self.client.send(self.request)
pairs = zip(self.request.requests, response.responses)
result = Result()
for request, reply in pairs:
if isinstance(reply, protocol.CheckVersionResponse):
result.checked.add(self.client.denormalize_path(request.path))
elif isinstance(reply, protocol.CreateResponse):
result.created.add(self.client.denormalize_path(request.path))
elif isinstance(reply, protocol.SetDataResponse):
result.updated.add(self.client.denormalize_path(request.path))
elif isinstance(reply, protocol.DeleteResponse):
result.deleted.add(self.client.denormalize_path(request.path))
return result
if not self.watch_callbacks:
return
request = protocol.SetWatchesRequest(
relative_zxid=self.last_zxid or 0,
data_watches=[],
exist_watches=[],
child_watches=[],
)
for event_type, path in self.watch_callbacks.keys():
if event_type == protocol.WatchEvent.CREATED:
request.exist_watches.append(path)
if event_type == protocol.WatchEvent.DATA_CHANGED:
request.data_watches.append(path)
elif event_type == protocol.WatchEvent.CHILDREN_CHANGED:
request.child_watches.append(path)
await self.send(request)
if self.closing:
f.set_exception(exc.ConnectError(self.host, self.port))
return f
if request.special_xid:
xid = request.special_xid
payload_log.debug("[SEND] (xid: %s) %s", xid, request)
payload = request.serialize(xid)
payload = size_struct.pack(len(payload)) + payload
self.opcode_xref[xid] = request.opcode
if xid in protocol.SPECIAL_XIDS:
self.pending_specials[xid].append(f)
else:
self.pending[xid] = f
try:
self.writer.write(payload)
except Exception as e:
log.exception('Exception during write')
self.abort()
return f
raw_payload = await self._read(size)
response = protocol.ConnectResponse.deserialize(raw_payload)
return (None, None, response)
raw_header = await self._read(reply_header_struct.size)
xid, zxid, error_code = reply_header_struct.unpack_from(raw_header)
if error_code:
self.opcode_xref.pop(xid)
return (xid, zxid, exc.get_response_error(error_code))
size -= reply_header_struct.size
raw_payload = await self._read(size)
if xid == protocol.WATCH_XID:
response = protocol.WatchEvent.deserialize(raw_payload)
else:
opcode = self.opcode_xref.pop(xid)
response = protocol.response_xref[opcode].deserialize(raw_payload)
return (xid, zxid, response)
async def establish_session(self):
log.info("Establishing session. {!r}".format(self.session_id))
connection_response = await self.conn.send_connect(
protocol.ConnectRequest(
protocol_version=0,
last_seen_zxid=self.last_zxid or 0,
timeout=int((self.timeout or 0) * 1000),
session_id=self.session_id or 0,
password=self.password,
read_only=self.allow_read_only,
)
)
if connection_response is None:
# handle issue with inconsistent zxid on reconnection
if self.state.current_state != States.LOST:
self.state.transition_to(States.LOST)
self.last_zxid = None
raise exc.SessionLost()
zxid, response = connection_response
def drain_all_pending(self):
for special_xid in protocol.SPECIAL_XIDS:
for f in iterables.drain(self.pending_specials[special_xid]):
yield f
for _, f in iterables.drain(self.pending):
yield f
retry_policy=None,
allow_read_only=False,
read_timeout=None,
loop=None,
):
self.loop = loop or asyncio.get_event_loop()
self.chroot = None
if chroot:
self.chroot = self.normalize_path(chroot)
log.info("Using chroot '%s'", self.chroot)
self.session = Session(
servers, session_timeout, retry_policy, allow_read_only, read_timeout, loop=self.loop
)
self.default_acl = default_acl or [protocol.UNRESTRICTED_ACCESS]
self.stat_cache = {}
self.recipes = RecipeProxy(self)
def __init__(self, client):
self.client = client
self.request = protocol.TransactionRequest()