async def _on_send(self, writer: 'StreamWriter'): Logger.info(tag=_TAG, msg="_on_send() start") while self._running: try: request: 'Request' = await self._queue.get() self._queue.task_done() if request.msg_type == MessageType.NONE: # Stopping IPCServer break data: bytes = request.to_bytes() Logger.debug(tag=_TAG, msg=f"on_send(): data({data.hex()}") Logger.info(tag=_TAG, msg=f"Sending Data : {request}") writer.write(data) await writer.drain() except asyncio.CancelledError: pass except BaseException as e: Logger.warning(tag=_TAG, msg=str(e)) writer.close() Logger.info(tag=_TAG, msg="_on_send() end")
def invoke(self, context: 'IconScoreContext', to: 'Address', icon_score_address: 'Address', data: dict) -> None: """Handle data contained in icx_sendTransaction message :param context: :param to: :param icon_score_address: cx0000000000000000000000000000000000000000 on install otherwise score address to update :param data: SCORE deploy data """ assert icon_score_address is not None assert icon_score_address != ZERO_SCORE_ADDRESS assert icon_score_address.is_contract if icon_score_address in (None, ZERO_SCORE_ADDRESS): raise InvalidParamsException( f'Invalid SCORE address: {icon_score_address}') try: IconScoreContextUtil.validate_deployer(context, context.tx.origin) deploy_type: 'DeployType' = \ DeployType.INSTALL if to == ZERO_SCORE_ADDRESS else DeployType.UPDATE context.storage.deploy.put_deploy_info_and_tx_params( context, icon_score_address, deploy_type, context.tx.origin, context.tx.hash, data) if not self._is_audit_needed(context, icon_score_address): self.deploy(context, context.tx.hash) except BaseException as e: Logger.warning('Failed to write deploy info and tx params', ICON_DEPLOY_LOG_TAG) raise e
def _invoke(self, context: "IconScoreContext", to: "Address", icon_score_address: "Address", data: dict) -> None: assert icon_score_address is not None assert icon_score_address != SYSTEM_SCORE_ADDRESS assert icon_score_address.is_contract if icon_score_address in (None, SYSTEM_SCORE_ADDRESS): raise InvalidParamsException( f'Invalid SCORE address: {icon_score_address}') try: deploy_type: 'DeployType' = \ DeployType.INSTALL if to == SYSTEM_SCORE_ADDRESS else DeployType.UPDATE context.storage.deploy.put_deploy_info_and_tx_params( context, icon_score_address, deploy_type, context.tx.origin, context.tx.hash, data) if not self._is_audit_needed(context, icon_score_address): self.deploy(context, context.tx.hash) except BaseException as e: Logger.warning('Failed to write deploy info and tx params', ICON_DEPLOY_LOG_TAG) raise e
def _on_deploy(self, context: 'IconScoreContext', tx_params: 'IconScoreDeployTXParams') -> None: """ Decompress a SCORE zip file and write them to file system Create a SCORE instance from SCORE class Call a SCORE initialization function (on_install or on_update) :param tx_params: use deploy_data, score_address, tx_hash, deploy_type from IconScoreDeployTxParams :return: """ data = tx_params.deploy_data score_address = tx_params.score_address params: dict = data.get('params', {}) deploy_info: 'IconScoreDeployInfo' = context.storage.deploy.get_deploy_info( context, tx_params.score_address) next_tx_hash: bytes = deploy_info.next_tx_hash self._write_score_to_filesystem(context, score_address, next_tx_hash, data) backup_msg = context.msg backup_tx = context.tx new_tx_score_mapper: dict = {} try: IconScoreContextUtil.validate_score_package( context, score_address, next_tx_hash) score_info: 'IconScoreInfo' =\ self._create_score_info(context, score_address, next_tx_hash) if context.revision >= Revision.STRICT_SCORE_DECORATOR_CHECK.value: check_score_flag(score_info.score_class) # score_info.get_score() returns a cached or created score instance # according to context.revision. score: 'IconScoreBase' = score_info.get_score(context.revision) # check_on_deploy will be done by normalize_signature() # since Revision.THREE if context.revision < Revision.THREE.value: ScoreApiGenerator.check_on_deploy(context, score) # owner is set in IconScoreBase.__init__() context.msg = Message(sender=score.owner) context.tx = None self._initialize_score(context, tx_params.deploy_type, score, params) new_tx_score_mapper[score_address] = score_info except BaseException as e: Logger.warning(f'Failed to deploy a SCORE: {score_address}', ICON_DEPLOY_LOG_TAG) raise e finally: context.msg = backup_msg context.tx = backup_tx self._update_new_score_mapper(context.new_icon_score_mapper, new_tx_score_mapper)
def _remove_score_dir(cls, address: 'Address', converted_tx_hash: Optional[str] = None): if cls.icon_score_loader is None: return score_root_path = cls.icon_score_loader.score_root_path if converted_tx_hash is None: target_path = os.path.join(score_root_path, bytes.hex(address.to_bytes())) else: target_path = os.path.join(score_root_path, bytes.hex(address.to_bytes()), converted_tx_hash) try: rmtree(target_path) except Exception as e: Logger.warning(e)
def commit(self, block: 'Block'): node = self._precommit_data_mapper.get(block.hash) if node is None: Logger.warning( tag=_TAG, msg= f"No precommit data: height={block.height} hash={bytes_to_hex(block.hash)}" ) return if not node.parent.is_root() and self._root == node.parent: raise InternalServiceErrorException(f"Parent should be a root") self._remove_sibling_precommit_data(block) del self._precommit_data_mapper[self._root.block.hash] self._set_root(node)
def _on_deploy_for_builtin(self, context: 'IconScoreContext', score_address: 'Address', src_score_path: str) -> None: """Install an icon score for builtin """ score_root_path = context.icon_score_mapper.score_root_path target_path = path.join(score_root_path, score_address.to_bytes().hex()) makedirs(target_path, exist_ok=True) deploy_info = self._icon_score_deploy_storage.get_deploy_info( context, score_address) if deploy_info is None: next_tx_hash = None else: next_tx_hash = deploy_info.next_tx_hash if next_tx_hash is None: next_tx_hash = bytes(DEFAULT_BYTE_SIZE) converted_tx_hash: str = f'0x{bytes.hex(next_tx_hash)}' target_path = path.join(target_path, converted_tx_hash) try: copytree(src_score_path, target_path) except FileExistsError: pass try: score = context.icon_score_mapper.load_score( score_address, next_tx_hash) if score is None: raise InvalidParamsException( f'score is None : {score_address}') self._initialize_score(on_deploy=score.on_install, params={}) except BaseException as e: Logger.warning( f'load wait icon score fail!! address: {score_address}', ICON_DEPLOY_LOG_TAG) Logger.warning('revert to add wait icon score', ICON_DEPLOY_LOG_TAG) raise e context.icon_score_mapper.put_score_info(score_address, score, next_tx_hash)
async def _on_recv(self, reader: 'StreamReader'): Logger.info(tag=_TAG, msg="_on_recv() start") while self._running: try: data: bytes = await reader.read(1024) if not isinstance(data, bytes) or len(data) == 0: break Logger.debug(tag=_TAG, msg=f"_on_recv(): data({data.hex()})") self._unpacker.feed(data) for response in self._unpacker: Logger.info(tag=_TAG, msg=f"Received Data : {response}") self._queue.message_handler(response) except asyncio.CancelledError: pass except BaseException as e: Logger.warning(tag=_TAG, msg=str(e)) Logger.info(tag=_TAG, msg="_on_recv() end")
def invoke(self, context: 'IconScoreContext', to: 'Address', icon_score_address: 'Address', data: dict) -> None: """Handle calldata contained in icx_sendTransaction message :param context: :param to: :param icon_score_address: cx0000000000000000000000000000000000000000 on install otherwise score address to update :param data: calldata """ assert icon_score_address is not None assert icon_score_address != ZERO_SCORE_ADDRESS assert icon_score_address.is_contract if icon_score_address in (None, ZERO_SCORE_ADDRESS): raise ServerErrorException( f'Invalid SCORE address: {icon_score_address}') deploy_type: 'DeployType' = \ DeployType.INSTALL if to == ZERO_SCORE_ADDRESS else DeployType.UPDATE try: context.validate_score_blacklist(icon_score_address) if self._is_flag_on(IconDeployFlag.ENABLE_DEPLOY_WHITELIST): context.validate_deployer(context.tx.origin) self.write_deploy_info_and_tx_params(context, deploy_type, icon_score_address, data) if self._check_audit_ignore(context, icon_score_address): self.deploy(context, context.tx.hash) except BaseException as e: Logger.warning('Failed to write deploy info and tx params', ICON_DEPLOY_LOG_TAG) raise e
def _on_deploy(self, context: 'IconScoreContext', tx_params: 'IconScoreDeployTXParams') -> None: """ load score on memory write file system call on_deploy(install, update) :param tx_params: use deploy_data, score_address, tx_hash, deploy_type from IconScoreDeployTxParams :return: """ data = tx_params.deploy_data score_address = tx_params.score_address content_type: str = data.get('contentType') content: bytes = data.get('content') params: dict = data.get('params', {}) _, next_tx_hash =\ self._icon_score_deploy_storage.get_tx_hashes_by_score_address(context, tx_params.score_address) if next_tx_hash is None: next_tx_hash = bytes(DEFAULT_BYTE_SIZE) if content_type == 'application/tbears': score_root_path = context.icon_score_mapper.score_root_path target_path = path.join(score_root_path, score_address.to_bytes().hex()) makedirs(target_path, exist_ok=True) converted_tx_hash: str = f'0x{bytes.hex(next_tx_hash)}' target_path = path.join(target_path, converted_tx_hash) try: symlink(content, target_path, target_is_directory=True) except FileExistsError: pass else: self._icon_score_deployer.deploy(address=score_address, data=content, tx_hash=next_tx_hash) backup_msg = context.msg backup_tx = context.tx try: score = context.new_icon_score_mapper.load_score( score_address, next_tx_hash) if score is None: raise InvalidParamsException( f'score is None : {score_address}') deploy_type = tx_params.deploy_type if deploy_type == DeployType.INSTALL: on_deploy = score.on_install elif deploy_type == DeployType.UPDATE: on_deploy = score.on_update else: on_deploy = None context.msg = Message(sender=score.owner) context.tx = None self._initialize_score(on_deploy=on_deploy, params=params) except BaseException as e: Logger.warning( f'load wait icon score fail!! address: {score_address}', ICON_DEPLOY_LOG_TAG) Logger.warning('revert to add wait icon score', ICON_DEPLOY_LOG_TAG) raise e finally: context.msg = backup_msg context.tx = backup_tx context.icon_score_mapper.put_score_info(score_address, score, next_tx_hash)
def test_warning(self): Logger.warning(TAG, 'warning log')