def put(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling put : Msg {} Peer {}".format(msg, peer))
chain_id = ID(msg.fields[Field.ChainID])
request_id = msg.fields[Field.RequestID]
container = msg.fields[Field.ContainerBytes]
container_id = ID(msg.fields[Field.ContainerID])
peer.net.router.Put(peer.id, chain_id, request_id, container_id, container)
def pull_query(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling pull_query : Msg {} Peer {}".format(msg, peer))
chain_id = ID(msg.fields[Field.ChainID])
request_id = msg.fields[Field.RequestID]
container_id = ID(msg.fields[Field.ContainerID])
deadline = msg.fields[Field.Deadline]
peer.net.router.PullQuery(chain_id, request_id, deadline, container_id)
def get_ancestors(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling get_ancestors : Msg {} Peer {}".format(msg, peer))
chain_id = ID(msg.fields[Field.ChainID])
request_id = msg.fields[Field.RequestID]
container_id = ID(msg.fields[Field.ContainerID])
deadline = msg.fields[Field.Deadline]
peer.net.router.GetAncestors(peer.id, chain_id, request_id, deadline, container_id)
def get_cert_key():
"""Retrieves a certificate and key file pair for the provided Config object"""
hdir = str(Path.home())
cert_file = op.join(hdir, avaxpython.config().get("staker_crt"))
key_file = op.join(hdir, avaxpython.config().get("staker_key"))
if not op.isfile(cert_file):
raise Exception(f"Unable to find certificate file at {cert_file}")
if not op.isfile(key_file):
raise Exception(f"Unable to find key file at {key_file}")
return (cert_file, key_file)
def handle_block(self, blk: Block):
"""Handle Block messages."""
_s = JSONPrinter.extract_struct(blk)
avaxpython.config().logger().debug("**********************")
avaxpython.config().logger().debug("*** BLOCK RECEIVED ***")
avaxpython.config().logger().debug("**********************")
avaxpython.config().logger().debug(json.dumps(_s))
def handle_vertex(self, vtx: Vertex):
"""Handle DAG vertex messages."""
_s = JSONPrinter.extract_struct(vtx)
avaxpython.config().logger().debug("***********************")
avaxpython.config().logger().debug("*** VERTEX RECEIVED ***")
avaxpython.config().logger().debug("***********************")
avaxpython.config().logger().debug(json.dumps(_s))
def context_singleton():
global __context
if __context == None:
__context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
__context.check_hostname = False
__context.verify_mode = ssl.CERT_NONE
__context.load_cert_chain(
certfile=avaxpython.config().get("staker_crt"),
keyfile=avaxpython.config().get("staker_key"))
return __context
def handle_msg(self, msg: bytes, peer: Peer):
now = time.time()
peer.lastReceived = int(now)
peer.net.lastMsgReceivedTime = int(now)
parsed_msg = Codec.Parse(msg)
self.Log.debug(parsed_msg)
oph = self.__op_handlers[parsed_msg.op]
if not oph:
err_str = f"No handler for op {parsed_msg.op} received from peer {peer}: Msg {parsed_msg}"
avaxpython.config().logger().error(err_str)
raise ValueError(err_str)
oph(parsed_msg, peer)
def Initialize(self, config):
self.Config = config
self.Version = avaxpython.config().get("version")
self.AgentVersion = avaxpython.config().get("agent_version")
self.Config.StakingCertFile = avaxpython.config().get("staker_crt")
self.Log = avaxpython.config().logger()
self.doneShuttingDown = False
self.Log.info(f"Node version is: {self.Version}")
self.Log.info(f"Agent version is: {self.AgentVersion}")
self.initNodeID()
self.initBeacons()
self.initNetworking()
self.initChainManager(self.Config.AvaxAssetID)
self.initAliases(self.Config.GenesisBytes)
self.initChains(self.Config.GenesisBytes)
def __init__(self):
self.Log = avaxpython.config().logger()
self.peer_state = PeerState()
self.__op_handlers = {
Op.GetVersion: self.get_version,
Op.Version: self.version,
Op.GetPeerList: self.get_peerlist,
Op.PeerList: self.peerlist,
Op.Ping: self.ping,
Op.Pong: self.pong,
Op.GetAcceptedFrontier: self.get_accepted_frontier,
Op.AcceptedFrontier: self.accepted_frontier,
Op.GetAccepted: self.get_accepted,
Op.Accepted: self.accepted,
Op.Get: self.get,
Op.GetAncestors: self.get_ancestors,
Op.Put: self.put,
Op.MultiPut: self.multi_put,
Op.PushQuery: self.push_query,
Op.PullQuery: self.pull_query,
Op.Chits: self.chits,
Op.SignedVersion: self.signed_version,
Op.SignedPeerList: self.signed_peerlist
}
def __init__(self):
self.Log = avaxpython.config().logger()
self.peer_state = PeerState()
if "AVAX_PYTHON_PATH" not in os.environ:
self.Log.error(
"Please set AVAX_PYTHON_PATH environment variable. Run . setenv.sh"
)
exit(1)
self.data_dir = "{}/sample-data".format(os.environ['AVAX_PYTHON_PATH'])
if not os.path.exists(self.data_dir):
self.Log.error(
"Directory {} does not exist. Create it first.".format(
self.data_dir))
exit(1)
self.__op_handlers = {
Op.GetVersion: self.get_version,
Op.Version: self.version,
Op.GetPeerList: self.get_peerlist,
Op.PeerList: self.peerlist,
Op.Ping: self.ping,
Op.Pong: self.pong,
Op.GetAcceptedFrontier: self.get_accepted_frontier,
Op.AcceptedFrontier: self.accepted_frontier,
Op.GetAccepted: self.get_accepted,
Op.Accepted: self.accepted,
Op.Get: self.get,
Op.GetAncestors: self.get_ancestors,
Op.Put: self.put,
Op.MultiPut: self.multi_put,
Op.PushQuery: self.push_query,
Op.PullQuery: self.pull_query,
Op.Chits: self.chits,
Op.SignedVersion: self.signed_version,
Op.SignedPeerList: self.signed_peerlist
}
def __init__(self,
id=None,
ip=None,
networkID=None,
version=None,
parser=None,
listener=None,
dialer=None,
serverUpgrader=None,
clientUpgrader=None,
vdrs=None,
beacons=None,
router=None,
nodeID=None,
initialReconnectDelay=None,
maxReconnectDelay=None,
maxMessageSize=None,
sendQueueSize=None,
maxNetworkPendingSendBytes=None,
networkPendingSendBytesToRateLimit=None,
maxClockDifference=None,
peerListGossipSpacing=None,
peerListGossipSize=None,
peerListStakerGossipFraction=None,
getVersionTimeout=None,
allowPrivateIPs=None,
gossipSize=None,
pingPongTimeout=None,
pingFrequency=None,
disconnectedIPs={},
connectedIPs={},
retryDelay=30,
myIPs={},
peers={},
readBufferSize=None,
readHandshakeTimeout=None,
connMeter=None,
connMeterMaxConns=None,
restartOnDisconnected=None,
connectedCheckerCloser=None,
disconnectedCheckFreq=None,
connectedMeter=None,
restarter=None,
apricotPhase0Time=None,
network_handler=None):
if network_handler is None:
if avaxpython.config().get("handler").network_handler:
self.network_handler = avaxpython.config().get(
"handler").network_handler
else:
self.network_handler = AVAXHandler()
else:
self.network_handler = network_handler
self.futures = [] # manage network futures
self.metrics = mt()
self.id = id
self.ip = ip
self.networkID = networkID
self.version = version
self.parser = parser
self.listener = listener
self.dialer: Dialer = dialer
self.serverUpgrader = serverUpgrader
self.clientUpgrader = clientUpgrader
self.vdrs = vdrs
self.beacons = beacons
self.router: ChainRouter = router
self.nodeID = nodeID
self.clock = None # TODO
self.lastHeartbeat = 0
self.initialReconnectDelay = initialReconnectDelay
self.maxReconnectDelay = maxReconnectDelay
self.maxMessageSize = maxMessageSize
self.sendQueueSize = sendQueueSize
self.maxNetworkPendingSendBytes = maxNetworkPendingSendBytes
self.networkPendingSendBytesToRateLimit = networkPendingSendBytesToRateLimit
self.maxClockDifference = maxClockDifference
self.peerListGossipSpacing = peerListGossipSpacing
self.peerListGossipSize = peerListGossipSize
self.peerListStakerGossipFraction = peerListStakerGossipFraction
self.getVersionTimeout = getVersionTimeout
self.allowPrivateIPs = allowPrivateIPs
self.gossipSize = gossipSize
self.pingPongTimeout = pingPongTimeout
self.pingFrequency = pingFrequency
self.readBufferSize = readBufferSize
self.readHandshakeTimeout = readHandshakeTimeout
self.connMeterMaxConns = connMeterMaxConns
self.connMeter = connectedMeter
self.executor = avaxpython.parallel().executor()()
self.b = Builder()
self.apricotPhase0Time = apricotPhase0Time
self.stateLock = None # TODO sync.RWMutex
self.pendingBytes = 0
self.closed = False
self.disconnectedIPs = disconnectedIPs
self.connectedIPs = connectedIPs
self.retryDelay = retryDelay
self.myIPs = myIPs
self.peers = peers
self.closeOnce = None
self.restartOnDisconnected = restartOnDisconnected
self.connectedCheckerCloser = connectedCheckerCloser
self.connectedMeter = connectedMeter
self.disconnectedCheckFreq = disconnectedCheckFreq
self.restarter = restarter
self.hasMasked = True
self.maskedValidators = {}
self.Log = avaxpython.config().logger()
self.num_peers = 0
def get_peerlist(self, msg: Msg, peer: Peer):
"""Returns a list of connected Peer objects."""
avaxpython.config().logger().debug("Handling get_peerlist : Msg {} Peer {}".format(msg, peer))
peers = self.peer_state.list_connected()
peer.PeerList(peers)
def signed_peerlist(self, msg: Msg, peer: Peer):
"""Handing signed_peerlist message"""
avaxpython.config().logger().debug("Handling signed_peerlist : Msg {} Peer {}".format(msg, peer))
self.peer_state.set_got_peerlist(peer.id)
def version(self, msg: Msg, peer: Peer):
"""If the versions are incompatible or the current times differ too much, the connection will be terminated."""
avaxpython.config().logger().debug("Handling version : Msg {} Peer {}".format(msg, peer))
self.peer_state.set_got_version(peer.id)
def signed_version(self, msg: Msg, peer: Peer):
"""Handled signed_version message."""
avaxpython.config().logger().debug("Handling signed_version : Msg {} Peer {}".format(msg, peer))
self.peer_state.set_got_version(peer.id)
def pong(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling pong : Msg {} Peer {}".format(msg, peer))
def get_version(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling get_version : Msg {} Peer {}".format(msg, peer))
peer.Version()
def peerlist(self, msg: Msg, peer: Peer):
"""On receiving a Peers message, a node should compare the nodes appearing in the message
to its own list of neighbors, and forge connections to any new nodes."""
avaxpython.config().logger().debug("Handling peerlist : Msg {} Peer {}".format(msg, peer))
self.peer_state.set_got_peerlist(peer.id)
def get_accepted_frontier(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling get_accepted_frontier : Msg {} Peer {}".format(msg, peer))
chain_id = ID(msg.fields[Field.ChainID])
request_id = msg.fields[Field.RequestID]
deadline = int(peer.net.clock.time() + msg.fields[Field.Deadline])
peer.net.router.GetAcceptedFrontier(peer.id, chain_id, request_id, deadline)
def accepted(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling accepted : Msg {} Peer {}".format(msg, peer))
chain_id = ID(msg.fields[Field.ChainID])
request_id = msg.fields[Field.RequestID]
container_ids = msg.fields[Field.ContainerIDs]
peer.net.router.Accepted(chain_id, request_id, container_ids)
def __init__(self):
self.Log = avaxpython.config().logger()
import signal
import sys
import avaxpython
from avaxpython.main import params
from avaxpython.Config import Config as AVAXConfig
from avaxpython.network import ip
from avaxpython.utils.ip import IPDesc
from avaxpython.node.node import Node
from avaxpython.node.Config import Config as NodeConfig
from avaxpython.network.handlers.MessageDumper import MessageDumper
params.parseCmdLine()
node_config = params.Config
hl = MessageDumper()
avaxpython.config().set("network_handler", hl)
logger = avaxpython.config().logger()
stk_ip = ip.get_internal_ip()
node_config.StakingIP = IPDesc(stk_ip.ip, NodeConfig.STAKING_PORT)
node = Node(config=node_config)
def signal_handler(sig, frame):
logger.info("Stopping the AVAX node.")
node.Shutdown()
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
_____ .__ .__
/ _ \___ _______ | | _____ ____ ____ | |__ ____ ,_ o
/ /_\ \ \/ /\__ \ | | \__ \ / \_/ ___\| | \_/ __ \ / //\,
/ | \ / / __ \| |__/ __ \| | \ \___| Y \ ___/ \>> |
\____|__ /\_/ (____ /____(____ /___| /\___ >___| /\___ > \\
\/ \/ \/ \/ \/ \/ \/
"""
print(header)
# --------------------------------------------------------------------------------
params.parseCmdLine()
node_config = params.Config
logger = avaxpython.config().logger()
avaxpython.config().set("handler", DefaultHandler())
stk_ip = ip.get_internal_ip()
node_config.StakingIP = IPDesc(stk_ip.ip, NodeConfig.STAKING_PORT)
node = Node(config=node_config)
def signal_handler(sig, frame):
logger.info("Stopping the AVAX node.")
node.Shutdown()
sys.exit(0)
def Put(self, vdr: ShortID, requestID: int, vtxID: ID, vtxBytes: bytes):
vtx = self.Manager.ParseVtx(vtxBytes)
handler = avaxpython.config().get("handler").consensus_handler
handler.handle_vertex(vtx)
def Put(self, vdr: ShortID, request_id: int, block_id: ID,
block_bytes: bytes):
blk = self.VM.ParseBlock(block_bytes)
handler = avaxpython.config().get("handler").consensus_handler
handler.handle_block(blk)
def chits(self, msg: Msg, peer: Peer):
avaxpython.config().logger().debug("Handling chits : Msg {} Peer {}".format(msg, peer))
chain_id = ID(msg.fields[Field.ChainID])
request_id = msg.fields[Field.RequestID]
votes = msg.fields[Field.ContainerIDs]
peer.net.router.Chits(chain_id, request_id, votes)
# --#--#--
import signal
import sys
import logging
import avaxpython
from avaxpython.Config import Config as AVAXConfig
from avaxpython.network import ip
from avaxpython.utils.ip import IPDesc
from avaxpython.node.node import Node
from avaxpython.node.Config import Config as NodeConfig
from avaxpython.network.handlers.HostLister import HostLister
node_config = NodeConfig()
avaxpython.config().set("log_level", logging.ERROR)
logger = avaxpython.config().logger()
hl = HostLister()
avaxpython.config().set("network_handler", hl)
stk_ip = ip.get_internal_ip()
node_config.StakingIP = IPDesc(stk_ip.ip, NodeConfig.STAKING_PORT)
node = Node()
def signal_handler(sig, frame):
logger.info("Stopping the AVAX node.")
node.Shutdown()
def __init__(self, net, conn, ip: IPDesc, tickerCloser=None, port=0, id=None, node=None, my_staking_ip = None):
# network this peer is part of
self.net = net
self.expiry = None
self.node = node
# if the version message has been received and is valid. is only modified
# on the connection's reader routine.
self.gotVersion = False # utils.AtomicBool
self.gotPeerList = False # utils.AtomicBool
self.connected = False # utils.AtomicBool
# only close the peer once
self.once = None # sync.Once
self.my_staking_ip = my_staking_ip
# if the close function has been called.
self.closed = False # utils.AtomicBool
# number of bytes currently in the send queue.
self.pendingBytes = 0 # int64
# lock to ensure that closing of the sender queue is handled safely
self.senderLock = None # sync.Mutex
# queue of messages this connection is attempting to send the peer. Is
# closed when the connection is closed.
self.sender = None # chan []byte
# ip may or may not be set when the peer is first started. is only modified
# on the connection's reader routine.
self.ip: IPDesc = ip
# ipLock must be held when accessing [ip].
self.ipLock = None # sync.RWMutex
# aliases is a list of IPs other than [ip] that we have connected to
# this peer at.
self.aliases = [] # []alias
# aliasTimer triggers the release of expired records from [aliases].
self.aliasTimer = None # *timer.Timer
# aliasLock must be held when accessing [aliases] or [aliasTimer].
self.aliasLock = None # sync.Mutex
# id should be set when the peer is first created.
self.id = id
# the connection object that is used to read/write messages from
self.conn = conn
# version that the peer reported during the handshake
self.versionStruct = None
self.versionStr = None # utils.AtomicInterface
# unix time of the last message sent and received respectively
# Must only be accessed atomically
self.lastSent = None
self.lastReceived = None
self.tickerCloser = tickerCloser
# ticker processes
self.tickerOnce = None # sync.Once
self.Log = avaxpython.config().logger()
