Implement shutdown feature

* Pass is_shutdown to loopchain when revision has just been changed to Revision.SHUTDOWN(13)
* Fix integrate-test errors
* Add is_shutdown property to PrecommitData

iconservice/icon_constant.py

@@ -144,7 +144,9 @@ class Revision(Enum):
  VERIFY_ASSET_INTEGRITY = 12
  USE_RLP = 12
 
- LATEST = 12
+ SHUTDOWN = 13
+
+ LATEST = 13
 
 
 RC_DB_VERSION_0 = 0

iconservice/icon_inner_service.py

@@ -172,13 +172,15 @@ def _invoke(self, request: dict):
  converted_prev_block_validators = params.get('prevBlockValidators')
  converted_prev_votes = params.get('prevBlockVotes')
 
- tx_results, state_root_hash, added_transactions, next_preps = self._icon_service_engine.invoke(
- block=block,
- tx_requests=converted_tx_requests,
- prev_block_generator=converted_prev_block_generator,
- prev_block_validators=converted_prev_block_validators,
- prev_block_votes=converted_prev_votes,
- is_block_editable=converted_is_block_editable)
+ tx_results, state_root_hash, added_transactions, next_preps, is_shutdown = \
+ self._icon_service_engine.invoke(
+ block=block,
+ tx_requests=converted_tx_requests,
+ prev_block_generator=converted_prev_block_generator,
+ prev_block_validators=converted_prev_block_validators,
+ prev_block_votes=converted_prev_votes,
+ is_block_editable=converted_is_block_editable
+ )
 
  if convert_tx_result_to_dict:
  convert_tx_results = [tx_result.to_dict(to_camel_case) for tx_result in tx_results]
@@ -194,6 +196,8 @@ def _invoke(self, request: dict):
 
  if next_preps:
  results["prep"] = next_preps
+ if is_shutdown:
+ results["is_shutdown"] = True
 
  response = MakeResponse.make_response(results)
  except FatalException as e:

iconservice/icon_service_engine.py

@@ -396,7 +396,7 @@ def invoke(self,
  prev_block_generator: Optional['Address'] = None,
  prev_block_validators: Optional[List['Address']] = None,
  prev_block_votes: Optional[List[Tuple['Address', int]]] = None,
- is_block_editable: bool = False) -> Tuple[List['TransactionResult'], bytes, dict, Optional[dict]]:
+ is_block_editable: bool = False) -> Tuple[List['TransactionResult'], bytes, dict, Optional[dict], bool]:
 
  """Process transactions in a block sent by loopchain
 
@@ -406,7 +406,7 @@ def invoke(self,
  :param prev_block_validators: previous block validators (legacy)
  :param prev_block_votes: previous block vote info
  :param is_block_editable: boolean which imply whether creating base transaction or not
- :return: (TransactionResult[], bytes, added transaction{}, main prep as dict{})
+ :return: (TransactionResult[], bytes, added transaction{}, main prep as dict{}, is_shutdown)
  """
  # If the block has already been processed,
  # return the result from PrecommitDataManager
@@ -422,11 +422,7 @@ def invoke(self,
  msg=f"Block result already exists: \n"
  f"state_root_hash={bytes_to_hex(precommit_data.state_root_hash)}")
 
- return \
- precommit_data.block_result, \
- precommit_data.state_root_hash, \
- precommit_data.added_transactions, \
- precommit_data.next_preps
+ return _get_invoke_result_from_precommit_data(precommit_data)
 
  # Check for block validation before invoke
  self._precommit_data_manager.validate_block_to_invoke(block)
@@ -563,16 +559,12 @@ def invoke(self,
  rc_state_hash,
  added_transactions,
  next_preps,
- context.prep_address_converter)
+ context.prep_address_converter,
+ context.is_revision_changed(Revision.SHUTDOWN.value))
  if context.precommitdata_log_flag:
- Logger.info(tag=_TAG,
- msg=f"Created precommit_data: \n{precommit_data}")
+ Logger.info(tag=_TAG, msg=f"Created precommit_data: \n{precommit_data}")
  self._precommit_data_manager.push(precommit_data)
- return \
- block_result, \
- precommit_data.state_root_hash, \
- precommit_data.added_transactions, \
- precommit_data.next_preps
+ return _get_invoke_result_from_precommit_data(precommit_data)
 
  @classmethod
  def _get_rc_db_revision_before_process_transactions(cls, context: 'IconScoreContext') -> int:
@@ -1487,8 +1479,8 @@ def _check_contract_call_step(context: 'IconScoreContext',
  # - dataType is not 'call'
  if to == SYSTEM_SCORE_ADDRESS:
  return (
- context.revision < Revision.SYSTEM_SCORE_ENABLED.value
- and data_type != DataType.CALL
+  context.revision < Revision.SYSTEM_SCORE_ENABLED.value
+  and data_type != DataType.CALL
  )
 
  return True
@@ -2255,3 +2247,14 @@ def _handle_debug_get_account(
  account_filter=account_filter
  )
  return raw_data
+
+
+def _get_invoke_result_from_precommit_data(
+ precommit_data: PrecommitData) -> Tuple[List['TransactionResult'], bytes, dict, Optional[dict], bool]:
+ return (
+ precommit_data.block_result,
+ precommit_data.state_root_hash,
+ precommit_data.added_transactions,
+ precommit_data.next_preps,
+ precommit_data.is_shutdown,
+ )

iconservice/precommit_data_manager.py

@@ -135,7 +135,8 @@ def __init__(self,
  rc_state_root_hash: Optional[bytes],
  added_transactions: dict,
  next_preps: Optional[dict],
- prep_address_converter: 'PRepAddressConverter'):
+ prep_address_converter: 'PRepAddressConverter',
+ is_shutdown: bool):
  """
 
  :param block_batch: changed states for a block
@@ -166,6 +167,7 @@ def __init__(self,
  self.next_preps: Optional[dict] = next_preps
 
  self.prep_address_converter: 'PRepAddressConverter' = prep_address_converter
+ self.is_shutdown = is_shutdown
 
  # To prevent redundant precommit data logging
  self.already_exists = False
@@ -185,7 +187,8 @@ def __str__(self):
  f"state_root_hash: {bytes_to_hex(self.state_root_hash)}",
  f"prev_block_generator: {self.prev_block_generator}",
  f"added_transactions: {self.added_transactions}",
- f"next_preps: {self.next_preps}"
+ f"next_preps: {self.next_preps}",
+ f"is_shutdown: {self.is_shutdown}",
  ]
  return "\n".join(lines)
 

tests/integrate_test/iiss/decentralized/test_decentralized.py

@@ -132,12 +132,14 @@ def test_overlapped_block(self):
  self.set_revision(Revision.IISS.value)
  self.init_decentralized()
 
- block, var1_1, var1_2, var1_3, var1_4 = self.debug_make_and_req_block(tx_list=[])
- _, var2_1, var2_2, var2_3, var2_4 = self.debug_make_and_req_block(tx_list=[], block=block)
+ block, var1_1, var1_2, var1_3, var1_4, is_shutdown1 = self.debug_make_and_req_block(tx_list=[])
+ _, var2_1, var2_2, var2_3, var2_4, is_shutdown2 = self.debug_make_and_req_block(tx_list=[], block=block)
  self.assertEqual(var1_1, var2_1)
  self.assertEqual(var1_2, var2_2)
  self.assertEqual(var1_3, var2_3)
  self.assertEqual(var1_4, var2_4)
+ self.assertFalse(is_shutdown1)
+ self.assertFalse(is_shutdown2)
 
  def test_estimate_step(self):
  self.init_decentralized()

tests/integrate_test/iiss/decentralized/test_decentralized2.py

@@ -192,8 +192,9 @@ def test_check_update_endpoint1(self):
  tx: dict = self.create_set_prep_tx(from_=address,
  set_data={"p2pEndpoint": new_p2p_endpoint})
 
- _, _, _, _, next_preps = self.debug_make_and_req_block(tx_list=[tx])
+ _, _, _, _, next_preps, is_shutdown = self.debug_make_and_req_block(tx_list=[tx])
  self.assertIsNone(next_preps)
+ self.assertFalse(is_shutdown)
 
  self.set_revision(Revision.FIX_TOTAL_ELECTED_PREP_DELEGATED.value)
  self.set_revision(Revision.REALTIME_P2P_ENDPOINT_UPDATE.value)
@@ -203,16 +204,18 @@ def test_check_update_endpoint1(self):
  tx: dict = self.create_set_prep_tx(from_=address,
  set_data={"p2pEndpoint": new_p2p_endpoint})
 
- _, _, _, _, next_preps = self.debug_make_and_req_block(tx_list=[tx])
+ _, _, _, _, next_preps, is_shutdown = self.debug_make_and_req_block(tx_list=[tx])
  self.assertEqual(new_p2p_endpoint, next_preps["preps"][0]["p2pEndpoint"])
+ self.assertFalse(is_shutdown)
 
  # set prep with the same p2pEndpoint as the old one
  tx: dict = self.create_set_prep_tx(from_=address,
  set_data={"p2pEndpoint": old_p2p_endpoint})
 
  # next_preps should not be modified
- _, _, _, _, next_preps = self.debug_make_and_req_block(tx_list=[tx])
+ _, _, _, _, next_preps, is_shutdown = self.debug_make_and_req_block(tx_list=[tx])
  assert next_preps is None
+ assert is_shutdown is False
 
  def test_check_update_endpoint2(self):
  self.update_governance()
@@ -250,8 +253,9 @@ def test_check_update_endpoint2(self):
  tx_list.append(tx)
 
  # To change the p2pEndpoints of sub P-Reps cannot affect next_preps
- _, _, _, _, next_preps = self.debug_make_and_req_block(tx_list)
+ _, _, _, _, next_preps, is_shutdown = self.debug_make_and_req_block(tx_list)
  assert next_preps is None
+ assert is_shutdown is False
 
  self.process_confirm_block_tx(tx_list)
 
@@ -265,6 +269,6 @@ def test_check_update_endpoint2(self):
 
  # Unregistered main P-Rep is replaced by the first sub P-Rep in descending order by delegated
  tx: dict = self.create_unregister_prep_tx(self._accounts[0])
- _, _, _, _, next_preps = self.debug_make_and_req_block(tx_list=[tx])
-
+ _, _, _, _, next_preps, is_shutdown = self.debug_make_and_req_block(tx_list=[tx])
+ assert is_shutdown is False
  assert f"192.168.0.{start}:7100" == next_preps["preps"][0]["p2pEndpoint"]