def build(self,
cleanup=False,
rebuild=False,
set_height_interval=common.DEFAULT_SET_HEIGHT_INTERVAL):
"""TODO doc string"""
self._init_messanger()
def _on_generate_shard(height, seed, file_hash):
first = height == 1
set_height = (height % int(set_height_interval)) == 0
last = (int(self.max_size / common.SHARD_SIZE) + 1) == height
if first or set_height or last:
self.messanger.height(height)
bldr = builder.Builder(self.cfg["payout_address"],
common.SHARD_SIZE,
self.max_size,
debug=self.debug,
on_generate_shard=_on_generate_shard)
generated = bldr.build(self.store_path,
cleanup=cleanup,
rebuild=rebuild)
height = len(generated)
self.messanger.height(height)
return generated
def build(self, cleanup=False):
"""TODO doc string"""
self._ensure_address_given()
bldr = builder.Builder(self.address, common.SHARD_SIZE, self.max_size)
hashes = bldr.build(self.store_path, debug=self.debug, cleanup=cleanup)
self._querry('/api/height/{0}/{1}'.format(self.address, len(hashes)))
return hashes
def build(self,
workers=1,
cleanup=False,
rebuild=False,
repair=False,
set_height_interval=common.DEFAULT_SET_HEIGHT_INTERVAL):
"""Generate test files deterministically based on address.
:param workers: Number of Number of threadpool workers.
:param cleanup: Remove files in shard directory.
:param rebuild: Re-generate any file shards.
:param set_height_interval: Number of shards to generate before
notifying the server.
"""
workers = deserialize.positive_nonzero_integer(workers)
set_height_interval = deserialize.positive_nonzero_integer(
set_height_interval)
cleanup = deserialize.flag(cleanup)
rebuild = deserialize.flag(rebuild)
repair = deserialize.flag(repair)
self._init_messenger()
logger.info("Starting build")
def _on_generate_shard(cur_height, last):
"""
Because URL requests are slow, only update the server when we are
at the first height, at some height_interval, or the last height.
:param cur_height: Current height in the building process.
"""
first = cur_height == 1
set_height = (cur_height % int(set_height_interval)) == 0
if first or set_height or last:
self.messenger.height(cur_height)
logger.info("Current height at {0}.".format(cur_height))
# Initialize builder and generate/re-generate shards
bldr = builder.Builder(address=self.cfg["payout_address"],
shard_size=common.SHARD_SIZE,
max_size=self.max_size,
min_free_size=self.min_free_size,
on_generate_shard=_on_generate_shard,
use_folder_tree=self.use_folder_tree)
generated = bldr.build(self.store_path,
workers=workers,
cleanup=cleanup,
rebuild=rebuild,
repair=repair)
logger.info("Build finished")
return generated
def build(self, cleanup=False, rebuild=False):
"""TODO doc string"""
self._ensure_address_given()
def on_generate_shard(height, seed, file_hash):
self._url_query('/api/height/{0}/{1}'.format(self.address, height))
bldr = builder.Builder(self.address, common.SHARD_SIZE, self.max_size,
on_generate_shard=on_generate_shard)
generated = bldr.build(self.store_path, debug=self.debug,
cleanup=cleanup, rebuild=rebuild)
height = len(generated)
self._url_query('/api/height/{0}/{1}'.format(self.address, height))
return generated
def audit(self, delay=common.DEFAULT_AUDIT_DELAY, limit=None):
self._init_messenger()
# Initialize builder and audit shards
bldr = builder.Builder(address=self.cfg["payout_address"],
shard_size=common.SHARD_SIZE,
max_size=self.max_size,
min_free_size=self.min_free_size,
use_folder_tree=self.use_folder_tree)
delay = deserialize.positive_integer(delay)
stop_time = None
if limit is not None:
stop_time = datetime.now() + timedelta(seconds=int(limit))
btc_index = 0
while True:
btc_block = bldr.btc_last_confirmed_block(
min_confirmations=common.DEFAULT_MIN_CONFIRMATIONS
)
if btc_block['block_no'] != btc_index:
btc_hash = btc_block['blockhash']
btc_index = btc_block['block_no']
logger.debug("Using bitcoin block {0} hash {1}.".format(
btc_index, btc_hash))
wif = self.btctxstore.get_key(self.cfg["wallet"])
address = self.btctxstore.get_address(wif)
response_data = address + btc_hash + str(bldr.audit(
self.store_path,
btc_block['block_no'],
btc_block['blockhash']))
response = hashlib.sha256(
response_data.encode('utf-8')
).hexdigest()
# New Dataserv Server version is needed
self.messenger.audit(btc_block['block_no'], response)
else:
msg = "Bitcoin block {0} already used. Waiting for new block."
logger.debug(msg.format(btc_index))
if stop_time and datetime.now() >= stop_time:
return True
time.sleep(int(delay))