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()