def test_setting_levels(self, mocked_prompt, mocked_config_stdio,
mocked_stdout):
# we mocked stdout such that we can mute the print statements. We don't need to see them in the tests
# reset current loggers to have a clean slate
log_manager.loggers = dict()
# setup logging for 3 components
logger_generic = log_manager.getLogger()
logger_network = log_manager.getLogger('network')
logger_db = log_manager.getLogger('db')
# we expect to be prompted for 3 components (generic, network and db) setup at INFO level by default
# and then we choose option 1 twice (option 1 = DEBUG level) and something invalid the 3rd time.
mocked_prompt.side_effect = ['1', '1', 'nope']
start_output_config()
# then we assert that for `generic` and `network` we te to configure the level to DEBUG
# and for `db` we find no entry because it was an invalid choice.
# Invalid or `enter` as choice means keep as is
mocked_config_stdio.assert_called_with([('generic', logging.DEBUG),
('network', logging.DEBUG)])
import datetime
from neo.Core.IO.Mixins import SerializableMixin
from neo.Network.Payloads.NetworkAddressWithTime import NetworkAddressWithTime
from neo.Core.Blockchain import Blockchain
from neo.Core.Size import Size as s
from neo.Core.Size import GetVarSize
from neo.logging import log_manager
logger = log_manager.getLogger()
class VersionPayload(SerializableMixin):
Version = None
Services = None
Timestamp = None
Port = None
Nonce = None
UserAgent = None
StartHeight = 0
Relay = False
def __init__(self, port=None, nonce=None, userAgent=None):
"""
Create an instance.
Args:
port (int):
nonce (int):
userAgent (str): client user agent string.
"""
if port and nonce and userAgent:
import binascii
from neo.SmartContract.Iterable import EnumeratorBase
from neo.logging import log_manager
logger = log_manager.getLogger('db')
class DBCollection:
DB = None
Prefix = None
ClassRef = None
Collection = {}
Changed = []
Deleted = []
_built_keys = False
DebugStorage = False
_ChangedResetState = None
_DeletedResetState = None
def __init__(self, db, prefix, class_ref):
self.DB = db
self.Prefix = prefix
from neocore.IO.BinaryWriter import BinaryWriter
from neocore.IO.BinaryReader import BinaryReader
from neocore.UInt160 import UInt160
from neocore.BigInteger import BigInteger
from neocore.Cryptography.Crypto import Crypto
from neo.IO.MemoryStream import StreamManager
from neo.SmartContract.ContractParameter import ContractParameter, ContractParameterType
from neocore.IO.Mixins import SerializableMixin
import binascii
from neo.Core.State.ContractState import ContractState
from neo.logging import log_manager
logger = log_manager.getLogger('vm')
class SmartContractEvent(SerializableMixin):
"""
SmartContractEvent is sent as argument to all smart contract event handlers. It
includes all the information about the current event, such as type, payload,
contract hash, transaction hash, and block number.
- event_type (str)
- contract_hash (UInt160)
- tx_hash (UInt256)
- block_number (int)
- event_payload (object[])
- execution_success (bool)
- test_mode (bool)
`event_payload` is always a list of object, depending on what data types you sent
in the smart contract.
from socket import AF_INET as IP4_FAMILY
from typing import Optional, List
from neo.Core.TX.Transaction import Transaction as OrigTransaction
from neo.Network.common import msgrouter, wait_for
from neo.Network.common.singleton import Singleton
from neo.Network import utils as networkutils
from neo.Network.mempool import MemPool
from neo.Network.node import NeoNode
from neo.Network.protocol import NeoProtocol
from neo.Network.relaycache import RelayCache
from neo.Network.requestinfo import RequestInfo
from neo.Settings import settings
from neo.logging import log_manager
logger = log_manager.getLogger('network')
class NodeManager(Singleton):
PEER_QUERY_INTERVAL = 15
NODE_POOL_CHECK_INTERVAL = 10 # 2.5 * PEER_QUERY_INTERVAL # this allows for enough time to get new addresses
ONE_MINUTE = 60
MAX_ERROR_COUNT = 5 # maximum number of times adding a block or header may fail before we disconnect it
MAX_TIMEOUT_COUNT = 15 # maximum count the node responds slower than our threshold
MAX_NODE_POOL_ERROR = 2
MAX_NODE_POOL_ERROR_COUNT = 0
# we override init instead of __init__ due to the Singleton (read class documentation)
import logging
from peewee import Proxy, SqliteDatabase
from neo.logging import log_manager
logger = log_manager.getLogger('peewee')
log_manager.config_stdio([('peewee', logging.ERROR)])
class PWDatabase:
__proxy = None
@staticmethod
def DBProxy():
if not PWDatabase.__proxy:
PWDatabase.__proxy = Proxy()
return PWDatabase.__proxy
_db = None
def __init__(self, path):
try:
self._db = SqliteDatabase(path, check_same_thread=False)
PWDatabase.DBProxy().initialize(self._db)
self.startup()
except Exception as e:
logger.error("database file does not exist, or incorrect permissions")
def close(self):
self._db.close()
self._db = None
def __init__(self, test_case, component_name, level):
_BaseTestCaseContext.__init__(self, test_case)
self.component_name = component_name
self.level = level
self._logger = log_manager.getLogger(self.component_name)
import asyncio
import traceback
from datetime import datetime
from neo.Network.core.header import Header
from typing import TYPE_CHECKING, List
from neo.Network.flightinfo import FlightInfo
from neo.Network.requestinfo import RequestInfo
from neo.Network.payloads.inventory import InventoryType
from neo.Network.common import msgrouter
from neo.Network.common.singleton import Singleton
from contextlib import suppress
from neo.Network.core.uint256 import UInt256
from neo.logging import log_manager
logger = log_manager.getLogger('syncmanager')
# log_manager.config_stdio([('syncmanager', 10)])
if TYPE_CHECKING:
from neo.Network.nodemanager import NodeManager
from neo.Network.payloads import Block
class SyncManager(Singleton):
HEADER_MAX_LOOK_AHEAD = 6000
HEADER_REQUEST_TIMEOUT = 5
BLOCK_MAX_CACHE_SIZE = 500
BLOCK_NETWORK_REQ_LIMIT = 500
BLOCK_REQUEST_TIMEOUT = 5
from neo.Network.Message import Message
from neo.IO.MemoryStream import StreamManager
from neo.IO.Helper import Helper as IOHelper
from neo.Core.Helper import Helper
from .Payloads.GetBlocksPayload import GetBlocksPayload
from .Payloads.InvPayload import InvPayload
from .Payloads.NetworkAddressWithTime import NetworkAddressWithTime
from .Payloads.VersionPayload import VersionPayload
from .Payloads.HeadersPayload import HeadersPayload
from .Payloads.AddrPayload import AddrPayload
from .InventoryType import InventoryType
from neo.Settings import settings
from neo.logging import log_manager
from neo.Network.address import Address
logger = log_manager.getLogger('network')
logger_verbose = log_manager.getLogger('network.verbose')
MODE_MAINTAIN = 7
MODE_CATCHUP = 2
mode_to_name = {MODE_CATCHUP: 'CATCHUP', MODE_MAINTAIN: 'MAINTAIN'}
HEARTBEAT_BLOCKS = 'B'
HEARTBEAT_HEADERS = 'H'
class NeoNode(Protocol):
Version = None
leader = None
