async def _readline(self, limit=65536):
"""Read one line from the socket.
It errs out when line length exceeds the limit.
"""
if self._buffer:
ASSERT.equal(len(self._buffer), 1)
line = self._search_line(0)
if line is not None:
return line
while not self._ended and self._size <= limit:
data = await self._sock.recv(limit + 1)
if not data:
self._ended = True
break
self._buffer.append(data)
self._size += len(data)
line = self._search_line(-1)
if line is not None:
ASSERT.in_(len(self._buffer), (0, 1))
return line
if self._size > limit:
raise _TooLong('request line length exceeds %d' % limit)
if self._buffer:
remaining = b''.join(self._buffer)
self._buffer.clear()
self._size = 0
return remaining
else:
return b''
def __post_init__(self):
ASSERT.in_(self.kind, ('range', 'values'))
if self.kind == 'range':
ASSERT.equal(len(self.args), 2)
ASSERT.all(self.args, lambda arg: isinstance(arg, int))
ASSERT.less_or_equal(self.args[0], self.args[1])
else:
ASSERT.equal(self.kind, 'values')
ASSERT.all(self.args, lambda arg: isinstance(arg, str))
def __post_init__(self):
validate_app_name(self.name)
if self.service_section is None:
ASSERT.not_empty(self.exec)
ASSERT.in_(self.type, _SERVICE_TYPES)
ASSERT.in_(self.kill_mode, _KILL_MODES)
else:
ASSERT.empty(self.exec)
ASSERT.none(self.type)
ASSERT.none(self.kill_mode)
def add_if_not_exists_clause(index, connectable):
"""Add "IF NOT EXISTS" clause to create index statement.
I don't know why but ``sqlalchemy.Index.create()`` does not take a
``checkfirst`` argument like the rest of others.
"""
stmt = str(CreateIndex(index).compile(connectable))
stmt = stmt.replace('CREATE INDEX', 'CREATE INDEX IF NOT EXISTS', 1)
ASSERT.in_('IF NOT EXISTS', stmt)
return stmt
def _iter_dirs(self, dir_object_type, target_top_path, env):
ASSERT.in_(env, self.envs)
# NOTE: rglob does NOT traverse into symlink directory (which is
# good in this case).
for link_path in (self.top_path / env).rglob('*'):
if not link_path.is_symlink():
continue
target_path = link_path.resolve()
# XXX Is there a better way to match path prefix?
if str(target_path).startswith(str(target_top_path)):
yield dir_object_type(target_top_path, target_path)
def cmd_assign(args):
oses.assert_root_privilege()
ASSERT.in_(
args.pod_id,
tokens.load_active_pod_ids(pod_ops_dirs.make_ops_dirs()),
)
with tokens.make_tokens_database().writing() as active_tokens:
ASSERT.predicate(args.token_name, active_tokens.has_definition)
active_tokens.assign(args.token_name, args.pod_id, args.name,
args.value)
return 0
def _apt_get(command, assume, extra_args):
bases.run([
'apt-get',
'--assume-%s' % ASSERT.in_(assume, ('yes', 'no')),
command,
*extra_args,
])
def unrelease(self, env, label):
ASSERT.in_(env, self.envs)
_remove_file_and_maybe_parents(
self.top_path / env / label.path / label.name,
self.top_path / env,
)
def _encode_value(self, value_type, value):
"""Encode a value into a raw value.
This and ``_decode_raw_value`` complement each other.
"""
if typings.is_recursive_type(value_type):
if value_type.__origin__ in (list, set, frozenset):
element_type = value_type.__args__[0]
return [
self._encode_value(element_type, element)
for element in value
]
elif value_type.__origin__ is tuple:
ASSERT.equal(len(value), len(value_type.__args__))
return tuple(
self._encode_value(element_type, element)
for element_type, element in zip(
value_type.__args__,
value,
))
elif typings.is_union_type(value_type):
# Make a special case for ``None``.
if value is None:
ASSERT.in_(NoneType, value_type.__args__)
return None
# Make a special case for ``Optional[T]``.
type_ = typings.match_optional_type(value_type)
if type_:
return self._encode_value(type_, value)
for type_ in value_type.__args__:
if typings.is_recursive_type(type_):
if _match_recursive_type(type_, value):
return {
str(type_): self._encode_value(type_, value)
}
elif isinstance(value, type_):
return {
type_.__name__: self._encode_value(type_, value)
}
return ASSERT.unreachable(
'value is not any union element type: {!r} {!r}',
value_type,
value,
)
else:
return ASSERT.unreachable('unsupported generic: {!r}',
value_type)
elif wiredata.is_message(value):
ASSERT.predicate(value_type, wiredata.is_message_type)
return {
f.name: self._encode_value(f.type, getattr(value, f.name))
for f in dataclasses.fields(value)
}
elif isinstance(value, datetime.datetime):
ASSERT.issubclass(value_type, datetime.datetime)
return value.isoformat()
elif isinstance(value, enum.Enum):
ASSERT.issubclass(value_type, enum.Enum)
return value.name
# JSON does not support binary type; so it has to be encoded.
elif isinstance(value, bytes):
ASSERT.issubclass(value_type, bytes)
return base64.standard_b64encode(value).decode('ascii')
elif isinstance(value, Exception):
ASSERT.issubclass(value_type, Exception)
return {
type(value).__name__: [
ASSERT.isinstance(arg, _DIRECTLY_SERIALIZABLE_TYPES)
for arg in value.args
]
}
elif isinstance(value, _DIRECTLY_SERIALIZABLE_TYPES):
ASSERT.issubclass(value_type, _DIRECTLY_SERIALIZABLE_TYPES)
return value
else:
return ASSERT.unreachable('unsupported value type: {!r} {!r}',
value_type, value)
def _decode_raw_value(self, value_type, raw_value):
"""Decode a raw value into ``value_type``-typed value.
This and ``_encode_value`` complement each other.
"""
if typings.is_recursive_type(value_type):
if value_type.__origin__ in (list, set, frozenset):
element_type = value_type.__args__[0]
return value_type.__origin__(
self._decode_raw_value(element_type, raw_element)
for raw_element in raw_value)
elif value_type.__origin__ is tuple:
ASSERT.equal(len(raw_value), len(value_type.__args__))
return tuple(
self._decode_raw_value(element_type, raw_element)
for element_type, raw_element in zip(
value_type.__args__,
raw_value,
))
elif typings.is_union_type(value_type):
# Handle ``None`` special case.
if raw_value is None:
ASSERT.in_(NoneType, value_type.__args__)
return None
# Handle ``Optional[T]`` special case.
type_ = typings.match_optional_type(value_type)
if type_:
return self._decode_raw_value(type_, raw_value)
ASSERT.equal(len(raw_value), 1)
type_name, raw_element = next(iter(raw_value.items()))
for type_ in value_type.__args__:
if typings.is_recursive_type(type_):
candidate = str(type_)
else:
candidate = type_.__name__
if type_name == candidate:
return self._decode_raw_value(type_, raw_element)
return ASSERT.unreachable(
'raw value is not any union element type: {!r} {!r}',
value_type,
raw_value,
)
else:
return ASSERT.unreachable('unsupported generic: {!r}',
value_type)
elif wiredata.is_message_type(value_type):
return value_type(
**{
f.name: self._decode_raw_value(f.type, raw_value[f.name])
for f in dataclasses.fields(value_type)
if f.name in raw_value
})
elif not isinstance(value_type, type):
# Non-``type`` instance cannot be passed to ``issubclass``.
return ASSERT.unreachable('unsupported value type: {!r}',
value_type)
elif issubclass(value_type, datetime.datetime):
return value_type.fromisoformat(raw_value)
elif issubclass(value_type, enum.Enum):
return value_type[raw_value]
elif issubclass(value_type, bytes):
return base64.standard_b64decode(raw_value.encode('ascii'))
elif issubclass(value_type, Exception):
ASSERT.equal(len(raw_value), 1)
return value_type(
*(ASSERT.isinstance(raw_arg, _DIRECTLY_SERIALIZABLE_TYPES)
for raw_arg in raw_value[value_type.__name__]))
elif issubclass(value_type, _DIRECTLY_SERIALIZABLE_TYPES):
if value_type in _DIRECTLY_SERIALIZABLE_TYPES:
return ASSERT.isinstance(raw_value, value_type)
else:
# Support sub-type of int, etc.
return value_type(raw_value)
else:
return ASSERT.unreachable('unsupported value type: {!r}',
value_type)
def disable(self, signum):
"""Disable receiving signal ``signum``."""
ASSERT.not_none(self._wakeup_fd)
ASSERT.in_(signum, self._handlers)
signal.signal(signum, self._handlers.pop(signum))
def _union_none_getter(reader, name): # pylint: disable=useless-return
ASSERT.in_(reader[name], (None, _capnp.VOID))
return None