203 lines
6.2 KiB
Python
203 lines
6.2 KiB
Python
# standard imports
|
|
import datetime
|
|
|
|
# third-party imports
|
|
from sqlalchemy import Column, String, Integer, DateTime, Text, Boolean
|
|
from sqlalchemy.ext.hybrid import hybrid_property, hybrid_method
|
|
|
|
# local imports
|
|
from .base import SessionBase
|
|
|
|
|
|
class BlockchainSync(SessionBase):
|
|
"""Syncer control backend.
|
|
|
|
:param chain_str: Chain spec string representation
|
|
:type chain_str: str
|
|
:param block_start: Block number to start sync from
|
|
:type block_start: number
|
|
:param tx_start: Block transaction number to start sync from
|
|
:type tx_start: number
|
|
:param block_target: Block number to sync until, inclusive
|
|
:type block_target: number
|
|
"""
|
|
__tablename__ = 'chain_sync'
|
|
|
|
blockchain = Column(String)
|
|
"""Chainspec string specifying the blockchain the syncer is running against."""
|
|
block_start = Column(Integer)
|
|
"""The block height at the start of syncer."""
|
|
tx_start = Column(Integer)
|
|
"""The transaction index at the start of syncer."""
|
|
block_cursor = Column(Integer)
|
|
"""The block height for the current state of the syncer."""
|
|
tx_cursor = Column(Integer)
|
|
"""The transaction index for the current state of the syncer."""
|
|
block_target = Column(Integer)
|
|
"""The block height at which the syncer should terminate. Will be None for an open-ended syncer."""
|
|
date_created = Column(DateTime, default=datetime.datetime.utcnow)
|
|
"""Datetime when syncer was first created."""
|
|
date_updated = Column(DateTime)
|
|
"""Datetime of the latest update of the syncer state."""
|
|
|
|
def __init__(self, chain_str, block_start, tx_start, block_target=None):
|
|
self.blockchain = chain_str
|
|
self.block_start = block_start
|
|
self.tx_start = tx_start
|
|
self.block_cursor = block_start
|
|
self.tx_cursor = tx_start
|
|
self.block_target = block_target
|
|
self.date_created = datetime.datetime.utcnow()
|
|
self.date_updated = datetime.datetime.utcnow()
|
|
|
|
|
|
@staticmethod
|
|
def first(chain_str, session=None):
|
|
"""Check if a sync session for the specified chain already exists.
|
|
|
|
:param chain_str: Chain spec string representation
|
|
:type chain_str: str
|
|
:param session: Session to use. If not specified, a separate session will be created for this method only.
|
|
:type session: sqlalchemy.orm.session.Sessoin
|
|
:returns: Database primary key id of sync record, or None if insert failed
|
|
:rtype: number
|
|
"""
|
|
session = SessionBase.bind_session(session)
|
|
|
|
q = session.query(BlockchainSync.id)
|
|
q = q.filter(BlockchainSync.blockchain==chain_str)
|
|
o = q.first()
|
|
|
|
if o == None:
|
|
SessionBase.release_session(session)
|
|
return None
|
|
|
|
sync_id = o.id
|
|
|
|
SessionBase.release_session(session)
|
|
|
|
return sync_id
|
|
|
|
|
|
@staticmethod
|
|
def get_last(session=None, live=True):
|
|
"""Get the most recent syncer record.
|
|
|
|
If live is set, only the latest open-ended syncer will be returned.
|
|
|
|
:param session: Session to use. If not specified, a separate session will be created for this method only.
|
|
:type session: SqlAlchemy Session
|
|
:param live: Match only open-ended syncers
|
|
:type live: bool
|
|
:returns: Syncer database id
|
|
:rtype: int
|
|
"""
|
|
session = SessionBase.bind_session(session)
|
|
|
|
q = session.query(BlockchainSync.id)
|
|
if live:
|
|
q = q.filter(BlockchainSync.block_target==None)
|
|
else:
|
|
q = q.filter(BlockchainSync.block_target!=None)
|
|
q = q.order_by(BlockchainSync.date_created.desc())
|
|
object_id = q.first()
|
|
|
|
SessionBase.release_session(session)
|
|
|
|
if object_id == None:
|
|
return None
|
|
|
|
return object_id[0]
|
|
|
|
|
|
@staticmethod
|
|
def get_unsynced(session=None):
|
|
"""Get previous bounded sync sessions that did not complete.
|
|
|
|
:param session: Session to use. If not specified, a separate session will be created for this method only.
|
|
:type session: SqlAlchemy Session
|
|
:returns: Syncer database ids
|
|
:rtype: list
|
|
"""
|
|
unsynced = []
|
|
local_session = False
|
|
if session == None:
|
|
session = SessionBase.create_session()
|
|
local_session = True
|
|
q = session.query(BlockchainSync.id)
|
|
q = q.filter(BlockchainSync.block_target!=None)
|
|
q = q.filter(BlockchainSync.block_cursor<BlockchainSync.block_target)
|
|
q = q.order_by(BlockchainSync.date_created.asc())
|
|
for u in q.all():
|
|
unsynced.append(u[0])
|
|
if local_session:
|
|
session.close()
|
|
|
|
return unsynced
|
|
|
|
|
|
def set(self, block_height, tx_height):
|
|
"""Set the cursor height of the syncer instance.
|
|
|
|
Only manipulates object, does not transaction or commit to backend.
|
|
|
|
:param block_height: Block number
|
|
:type block_height: number
|
|
:param tx_height: Block transaction number
|
|
:type tx_height: number
|
|
:rtype: tuple
|
|
:returns: Stored block height, transaction index
|
|
"""
|
|
self.block_cursor = block_height
|
|
self.tx_cursor = tx_height
|
|
self.date_updated = datetime.datetime.utcnow()
|
|
return (self.block_cursor, self.tx_cursor,)
|
|
|
|
|
|
def cursor(self):
|
|
"""Get current state of cursor from cached instance.
|
|
|
|
:returns: Block height, transaction index
|
|
:rtype: tuple
|
|
"""
|
|
return (self.block_cursor, self.tx_cursor)
|
|
|
|
|
|
def start(self):
|
|
"""Get sync block start position from cached instance.
|
|
|
|
:returns: Block height, transaction index
|
|
:rtype: tuple
|
|
"""
|
|
return (self.block_start, self.tx_start)
|
|
|
|
|
|
def target(self):
|
|
"""Get sync block upper bound from cached instance.
|
|
|
|
:returns: Block number. Returns None if syncer is open-ended.
|
|
:rtype: int
|
|
"""
|
|
return self.block_target
|
|
|
|
|
|
def chain(self):
|
|
"""Get chain string representation for which the cached instance represents.
|
|
"""
|
|
return self.blockchain
|
|
|
|
|
|
def __str__(self):
|
|
return """object_id: {}
|
|
start: {}:{}
|
|
cursor: {}:{}
|
|
target: {}
|
|
""".format(
|
|
self.id,
|
|
self.block_start,
|
|
self.tx_start,
|
|
self.block_cursor,
|
|
self.tx_cursor,
|
|
self.block_target,
|
|
)
|