def from_old_json_schema(claim, payload: bytes):
value = json.loads(payload)
stream = claim.stream
stream.media_type = value.get(
'content_type', value.get('content-type', 'application/octet-stream'))
stream.title = value.get('title', '')
stream.description = value.get('description', '')
stream.thumbnail_url = value.get('thumbnail', '')
stream.author = value.get('author', '')
stream.license = value.get('license', '')
stream.license_url = value.get('license_url', '')
language = value.get('language', '')
if language:
if language.lower() == 'english':
language = 'en'
try:
stream.languages.append(language)
except:
pass
stream.sd_hash = value['sources']['lbry_sd_hash']
if value.get('nsfw', False):
stream.tags.append('mature')
if "fee" in value:
fee = value["fee"]
currency = list(fee.keys())[0]
if currency == 'LBC':
stream.fee.lbc = Decimal(fee[currency]['amount'])
elif currency == 'USD':
stream.fee.usd = Decimal(fee[currency]['amount'])
elif currency == 'BTC':
stream.fee.btc = Decimal(fee[currency]['amount'])
else:
raise DecodeError(f'Unknown currency: {currency}')
stream.fee.address = fee[currency]['address']
return claim
def _ipc_msg_cb(self, fd, eventmask): # pragma: no cover
del eventmask
try:
while self.ipc_sock.getsockopt(zmq.EVENTS) and zmq.POLLIN:
zmq_msg = self.ipc_sock.recv(flags=zmq.NOBLOCK)
self.logger.debug("IPC message from manager received, len[%d]",
len(zmq_msg))
if len(zmq_msg) > 0:
msg = t_RcpMessage()
msg.ParseFromString(zmq_msg)
self.logger.info(
"RCP message type: %s",
msg.t_RcpMessageType.Name(msg.RcpMessageType))
if msg.RcpMessageType == msg.ADD_CCAP_CORES:
self.add_ccap_cores(msg.RedirectCCAPAddresses)
elif msg.RcpMessageType == msg.REMOVE_ALL_CCAP_CORES:
self.orchestrator.remove_sessions_all()
elif msg.RcpMessageType == msg.RPD_CONFIGURATION:
# call the registered response callback
try:
self.ipc_rsp_callback(msg)
except Exception as ex:
self.logger.error(
"IPC RCP callback call failed: %s", ex)
else:
raise DecodeError("Unexpected message type received")
except zmq.Again:
# Ignore ... retry handled by dispatcher
return
except DecodeError as exception:
self.logger.error("Malformed IPC message, dropping ...: %s",
exception.message)
return
def from_bytes(cls, data: bytes):
purchase = cls()
if purchase.has_start_byte(data):
purchase.message.ParseFromString(data[1:])
else:
raise DecodeError('Message does not start with correct byte.')
return purchase
def user_decode(self, user_bytes):
user = User()
try:
user.ParseFromString(user_bytes)
except DecodeError as e:
raise DecodeError(f'Encountered error while decoding user: {e}')
return user
def snapshot_decode(self, snapshot_bytes):
snapshot = Snapshot()
try:
snapshot.ParseFromString(snapshot_bytes)
except DecodeError as e:
raise DecodeError(
f'Encountered error while decoding snapshot: {e}')
return snapshot
def GetContentFromProtoString(s, function_map):
for cls, func in function_map.items():
try:
obj = TryReadProtoWithClass(cls, s)
return func(obj)
except DecodeError:
continue
else:
raise DecodeError("Cannot find a fit protobuffer class.")
def from_types_v1(claim, payload: bytes):
old = OldClaimMessage()
old.ParseFromString(payload)
if old.claimType == 1:
stream = claim.stream
stream.title = old.stream.metadata.title
stream.description = old.stream.metadata.description
stream.author = old.stream.metadata.author
stream.license = old.stream.metadata.license
stream.license_url = old.stream.metadata.licenseUrl
stream.thumbnail_url = old.stream.metadata.thumbnail
if old.stream.metadata.HasField('language'):
stream.languages.add(
).message.language = old.stream.metadata.language
stream.media_type = old.stream.source.contentType
stream.sd_hash_bytes = old.stream.source.source
if old.stream.metadata.nsfw:
stream.tags.append('mature')
if old.stream.metadata.HasField('fee'):
fee = old.stream.metadata.fee
stream.fee.address_bytes = fee.address
currency = FeeMessage.Currency.Name(fee.currency)
if currency == 'LBC':
stream.fee.lbc = Decimal(fee.amount)
elif currency == 'USD':
stream.fee.usd = Decimal(fee.amount)
elif currency == 'BTC':
stream.fee.btc = Decimal(fee.amount)
else:
raise DecodeError(f'Unsupported currency: {currency}')
if old.HasField('publisherSignature'):
sig = old.publisherSignature
claim.signature = sig.signature
claim.signature_type = KeyType.Name(sig.signatureType)
claim.signing_channel_hash = sig.certificateId[::-1]
old.ClearField("publisherSignature")
claim.unsigned_payload = old.SerializeToString()
elif old.claimType == 2:
channel = claim.channel
channel.public_key_bytes = old.certificate.publicKey
else:
raise DecodeError('claimType must be 1 for Streams and 2 for Channel')
return claim
def from_bytes(cls, data: bytes):
signable = cls()
if data[0] == 0:
signable.message.ParseFromString(data[1:])
elif data[0] == 1:
signable.signing_channel_hash = data[1:21]
signable.signature = data[21:85]
signable.message.ParseFromString(data[85:])
else:
raise DecodeError('Could not determine message format version.')
return signable
def message_receive(self):
"""Awaits for an inquiry request from a client."""
recvd_data = self.socket.recv()
inquiry = Inquiry()
self.message_log_serialized("recvd", recvd_data)
inquiry.ParseFromString(recvd_data)
self.message_dump("received: %s", inquiry)
if inquiry.WhichOneof("inquiry") == "media":
self.handle_media_inquiry(inquiry.media)
else:
raise DecodeError("Invalid oneof field in Inquiry")
def _decode_index(buf, zigzag=True):
"""
Extracts message index from Schema Registry Protobuf formatted bytes.
Args:
buf (BytesIO): byte buffer
Returns:
int: Protobuf Message index.
"""
size = ProtobufDeserializer._decode_varint(buf, zigzag=zigzag)
if size < 0 or size > 100000:
raise DecodeError("Invalid Protobuf msgidx array length")
if size == 0:
return [0]
msg_index = []
for _ in range(size):
msg_index.append(
ProtobufDeserializer._decode_varint(buf, zigzag=zigzag))
return msg_index
def bblfsh_parse_raise_decode_error(*args, **kwargs):
raise DecodeError()
