def _get_failure_from_exception(
e: BaseException) -> TransactionResult.Failure:
"""
Gets `Failure` from an exception
:param e: exception
:return: a Failure
"""
try:
if isinstance(e, IconServiceBaseException):
if e.code >= ExceptionCode.SCORE_ERROR or isinstance(
e, IconScoreException):
Logger.warning(e.message, ICON_SERVICE_LOG_TAG)
else:
Logger.exception(e.message, ICON_SERVICE_LOG_TAG)
code = int(e.code)
message = str(e.message)
else:
Logger.exception(e, ICON_SERVICE_LOG_TAG)
Logger.error(e, ICON_SERVICE_LOG_TAG)
code: int = ExceptionCode.SYSTEM_ERROR.value
message = str(e)
except:
code: int = ExceptionCode.SYSTEM_ERROR.value
message = 'Invalid exception: code or message is invalid'
return TransactionResult.Failure(code, message)
def _commit_claim(self, context: 'IconScoreContext', iscore: int):
address: 'Address' = context.tx.origin
block: 'Block' = context.block
tx: 'Transaction' = context.tx
success = True
try:
icx: int = self._iscore_to_icx(iscore)
from_account: 'Account' = context.storage.icx.get_account(
context, address)
treasury_address: 'Address' = context.storage.icx.fee_treasury
treasury_account: 'Account' = context.storage.icx.get_account(
context, treasury_address)
treasury_account.withdraw(icx)
from_account.deposit(icx)
context.storage.icx.put_account(context, treasury_account)
context.storage.icx.put_account(context, from_account)
except BaseException as e:
Logger.exception(tag=_TAG, msg=str(e))
success = False
raise e
finally:
self._reward_calc_proxy.commit_claim(success, address,
block.height, block.hash,
tx.index, tx.hash)
async def dispatch(request: 'SanicRequest', channel_name: str = ""):
req_json = request.json
url = request.url
channel = channel_name if channel_name else StubCollection().conf[ConfigKey.CHANNEL]
context = {
"url": url,
"channel": channel,
}
response: Union[Response, DictResponse, BatchResponse]
try:
client_ip = request.remote_addr if request.remote_addr else request.ip
Logger.info(f'rest_server_v3 request with {req_json}', DISPATCH_V3_TAG)
Logger.info(f"{client_ip} requested {req_json} on {url}")
validate_jsonschema_v3(request=req_json)
except GenericJsonRpcServerError as e:
response = ApiErrorResponse(id=req_json.get('id', 0),
code=e.code,
message=str(e),
http_status=e.http_status,
debug=False)
except Exception as e:
Logger.exception(e)
response = ExceptionResponse(e, id=req_json.get('id', 0), debug=False)
else:
response = await async_dispatch(request.body, methods, context=context)
Logger.info(f'rest_server_v3 with response {response}', DISPATCH_V3_TAG)
return sanic_response.json(response.deserialized(), status=response.http_status, dumps=json.dumps)
def _get_failure_from_exception(
e: BaseException) -> TransactionResult.Failure:
"""
Gets `Failure` from an exception
:param e: exception
:return: a Failure
"""
if isinstance(e, IconServiceBaseException):
if e.code == ExceptionCode.SCORE_ERROR or isinstance(
e, ScoreErrorException):
Logger.warning(e.message, ICON_SERVICE_LOG_TAG)
else:
Logger.exception(e.message, ICON_SERVICE_LOG_TAG)
code = e.code
message = e.message
else:
Logger.exception(e, ICON_SERVICE_LOG_TAG)
Logger.error(e, ICON_SERVICE_LOG_TAG)
code = ExceptionCode.SERVER_ERROR
message = str(e)
return TransactionResult.Failure(code, message)
def run(self, context: 'IconScoreContext'):
Logger.info(tag=TAG, msg="UnstakePatcher.run() start")
storage = context.storage.icx
for target in self._targets:
try:
address = target.address
coin_part = storage.get_part(context, AccountPartFlag.COIN,
address)
stake_part = storage.get_part(context, AccountPartFlag.STAKE,
address)
result: Result = self._check_removable(coin_part, stake_part,
target)
if result == Result.FALSE:
self._add_failure_item(target)
else:
if result == Result.REMOVABLE_V0:
stake_part = self._remove_invalid_expired_unstakes_v0(
stake_part, target)
else:
stake_part = self._remove_invalid_expired_unstakes_v1(
stake_part, target)
assert stake_part.is_dirty()
storage.put_stake_part(context, address, stake_part)
self._emit_event_log(context, target)
self._add_success_item(target)
except BaseException as e:
# Although some unexpected errors happen, keep going
Logger.exception(tag=TAG, msg=str(e))
Logger.info(tag=TAG, msg="UnstakePatcher.run() end")
def _deploy_score(context: 'IconScoreContext',
score_name: str,
score_address: 'Address',
builtin_score_owner: 'Address'):
score_deploy_storage: IconScoreDeployStorage = \
context.icon_score_deploy_engine.icon_deploy_storage
score_source_path_in_iconservice: str = os.path.join(
IconBuiltinScoreLoader._pre_builtin_score_root_path(), score_name)
# Save deploy_info for a builtin score to score_deploy_storage.
deploy_info = IconScoreDeployInfo(
score_address=score_address,
deploy_state=DeployState.ACTIVE,
owner=builtin_score_owner,
current_tx_hash=ZERO_TX_HASH,
next_tx_hash=ZERO_TX_HASH)
score_deploy_storage.put_deploy_info(context, deploy_info)
tx_hash: bytes = deploy_info.current_tx_hash
# score_path is score_root_path/score_address/ directory.
score_path: str = os.path.join(
context.score_root_path, score_address.to_bytes().hex())
# Make a directory for a builtin score with a given score_address.
os.makedirs(score_path, exist_ok=True)
try:
score_deploy_path: str = os.path.join(score_path, f'0x{tx_hash.hex()}')
# remove_path() supports directory as well as file.
remove_path(score_deploy_path)
# Copy builtin score source files from iconservice package to score_deploy_path.
copytree(score_source_path_in_iconservice, score_deploy_path)
except FileExistsError:
pass
try:
# Import score class from deployed builtin score sources
score_info: 'IconScoreInfo' =\
IconScoreContextUtil.create_score_info(context, score_address, tx_hash)
# Create a score instance from the imported score class.
score = score_info.create_score()
# Call on_install() to initialize the score database of the builtin score.
score.on_install()
except BaseException as e:
Logger.exception(
f'Failed to deploy a builtin score: {score_address}\n{str(e)}',
ICON_DEPLOY_LOG_TAG)
raise e
def write_result(self, path: str):
Logger.info(tag=TAG,
msg=f"UnstakePatcher.write_result() start: {path}")
total_unstake = self._success_unstake + self._failure_unstake
Logger.info(
tag=TAG,
msg="Invalid expired unstakes management result: "
f"total_unstake={total_unstake} "
f"success_unstake={self._success_unstake} "
f"failure_unstake={self._failure_unstake} "
f"total_items={len(self._targets)} "
f"success_items={len(self._success_targets)} "
f"failure_items={len(self._failure_targets)}",
)
try:
report = {
# Unstake amount
"total_unstake":
total_unstake,
"success_unstake":
self._success_unstake,
"failure_unstake":
self._failure_unstake,
# Item count
"total":
len(self._targets),
"success":
len(self._success_targets),
"failure":
len(self._failure_targets),
# Item list
"success_targets":
[target.to_dict() for target in self._success_targets],
"failure_targets":
[target.to_dict() for target in self._failure_targets],
}
with open(path, "w") as f:
text = json.dumps(report, indent=4)
f.write(text)
except BaseException as e:
Logger.exception(tag=TAG, msg=str(e))
Logger.info(tag=TAG, msg=f"UnstakePatcher.write_result() end")
def _charge_transaction_fee(self, context: 'IconScoreContext',
params: dict, status: int,
step_used: int) -> (int, int):
"""Charge a fee to from account
Because it is on finalizing a transaction,
this method MUST NOT throw any exceptions
Assume that from account can charge a failed tx fee
:param params:
:param status: 1: SUCCESS, 0: FAILURE
:return: final step_used, step_price
"""
version: int = params.get('version', 2)
from_: 'Address' = params['from']
step_price = context.step_counter.step_price
if version < 3:
# Support coin transfer based on protocol v2
# 0.01 icx == 10**16 loop
# FIXED_FEE(0.01 icx) == step_used(10**6) * step_price(10**10)
step_used = 10**6
if status == TransactionResult.FAILURE:
# protocol v2 does not charge a fee for a failed tx
step_price = 0
elif IconScoreContextUtil.is_service_flag_on(
context, IconServiceFlag.FEE):
# 0.01 icx == 10**16 loop
# FIXED_FEE(0.01 icx) == step_used(10**6) * step_price(10**10)
step_price = 10**10
# Charge a fee to from account
fee: int = step_used * step_price
try:
self._icx_engine.charge_fee(context, from_, fee)
except BaseException as e:
if hasattr(e, 'message'):
message = e.message
else:
message = str(e)
Logger.exception(message, ICON_SERVICE_LOG_TAG)
step_used = 0
# final step_used and step_price
return step_used, step_price
def serve(self, config: 'IconConfig'):
async def _serve():
await self._inner_service.connect(exclusive=True)
Logger.info(f'Start IconService Service serve!', ICON_SERVICE)
channel = config[ConfigKey.CHANNEL]
amqp_key = config[ConfigKey.AMQP_KEY]
amqp_target = config[ConfigKey.AMQP_TARGET]
score_root_path = config[ConfigKey.SCORE_ROOT_PATH]
db_root_path = config[ConfigKey.STATE_DB_ROOT_PATH]
self._set_icon_score_stub_params(channel, amqp_key, amqp_target)
Logger.info(f'==========IconService Service params==========',
ICON_SERVICE)
Logger.info(f'score_root_path : {score_root_path}', ICON_SERVICE)
Logger.info(f'icon_score_state_db_root_path : {db_root_path}',
ICON_SERVICE)
Logger.info(f'amqp_target : {amqp_target}', ICON_SERVICE)
Logger.info(f'amqp_key : {amqp_key}', ICON_SERVICE)
Logger.info(f'icon_score_queue_name : {self._icon_score_queue_name}',
ICON_SERVICE)
Logger.info(f'==========IconService Service params==========',
ICON_SERVICE)
# Before creating IconScoreInnerService instance,
# loop SHOULD be set as a current event loop for the current thread.
# Otherwise connection between iconservice and rc will be failed.
loop = MessageQueueService.loop
asyncio.set_event_loop(loop)
try:
self._inner_service = IconScoreInnerService(
amqp_target, self._icon_score_queue_name, conf=config)
except FatalException as e:
Logger.exception(e, ICON_EXCEPTION_LOG_TAG)
Logger.error(e, ICON_EXCEPTION_LOG_TAG)
self._inner_service.clean_close()
finally:
Logger.debug(
"icon service will be closed while open the icon service engine. "
"check if the config is valid")
loop.create_task(_serve())
loop.add_signal_handler(signal.SIGINT, self.close)
loop.add_signal_handler(signal.SIGTERM, self.close)
try:
loop.run_forever()
except FatalException as e:
Logger.exception(e, ICON_EXCEPTION_LOG_TAG)
Logger.error(e, ICON_EXCEPTION_LOG_TAG)
self._inner_service.clean_close()
finally:
"""
If the function is called when the operation is not an endless loop
in an asynchronous function, the await is terminated immediately.
"""
Logger.debug("loop has been stopped and will be closed")
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
def _log_exception(self,
e: BaseException,
tag: str = ICON_INNER_LOG_TAG) -> None:
Logger.exception(e, tag)
Logger.error(e, tag)
def _log_exception(e: BaseException, tag: str) -> None:
Logger.exception(str(e), tag)
Logger.error(str(e), tag)
def test_exception(self):
Logger.exception('exception log')
Logger.exception('exception log', TAG)
def test_exception(self):
try:
raise Exception()
except:
Logger.exception(TAG, 'exception log')
