def process_data(self, data):
try:
json_txs = data
result = []
for json_tx in json_txs:
dict_tx = self.__json_tx_to_dict_tx__(json_tx)
tx = RawTransaction(
txid=dict_tx.get(ATTRIBUTE_TXID),
value=dict_tx.get(ATTRIBUTE_VALUE),
has_multisig=dict_tx.get(ATTRIBUTE_HAS_MULTISIG),
has_nulldata=dict_tx.get(ATTRIBUTE_HAS_NULLDATA),
has_pubkey=dict_tx.get(ATTRIBUTE_HAS_PUBKEY),
has_pubkeyhash=dict_tx.get(ATTRIBUTE_HAS_PUBKEYHASH),
has_scripthash=dict_tx.get(ATTRIBUTE_HAS_SCRIPTHASH),
pushed_from=get_hostname_or_die())
result.append(tx)
tx_info = RawTransactionInfo(
txid=dict_tx.get(ATTRIBUTE_TXID),
relayed_from=dict_tx.get(ATTRIBUTE_RELAYED_FROM),
received_at=dict_tx.get(ATTRIBUTE_RECEIVED_AT),
json_string=json_tx,
pushed_from=get_hostname_or_die())
result.append(tx_info)
except Exception, e:
print "Error on process_data:", e
def __txs_to_transaction_input_and_output_objects__(
self, txs, block_height, block_hash):
tx_inputs = []
tx_outputs = []
if txs:
for _, tx in enumerate(txs):
txid = tx.get(ATTRIBUTE_TXID)
is_from_coinbase = False
#1. Get transaction inputs
for offset, vin in enumerate(tx.get(ATTRIBUTE_VIN)):
output_txid = vin.get(ATTRIBUTE_TXID, "coinbase")
if vin.get(ATTRIBUTE_COINBASE): is_from_coinbase = True
vout_offset = vin.get(ATTRIBUTE_VOUT, -1)
tx_input = TransactionInput(
txid=txid,
offset=offset,
block_height=block_height,
block_hash=block_hash,
output_txid=output_txid,
vout_offset=vout_offset,
pushed_from=get_hostname_or_die())
tx_inputs.append(tx_input)
#2. Get transaction outputs
for vout in tx.get(ATTRIBUTE_VOUT):
value = vout.get(ATTRIBUTE_VALUE)
offset = vout.get(ATTRIBUTE_N)
script_pub_key = vout.get(ATTRIBUTE_SCRIPT_PUB_KEY)
address = None
if script_pub_key.get(
ATTRIBUTE_TYPE) == ATTRIBUTE_NULLDATA:
address = ATTRIBUTE_NULLDATA
tx_output = TransactionOutput(
txid=txid,
offset=offset,
address=address,
block_hash=block_hash,
block_height=block_height,
value=value,
is_from_coinbase=is_from_coinbase,
pushed_from=get_hostname_or_die())
tx_outputs.append(tx_output)
else:
if vout.get(ATTRIBUTE_SCRIPT_PUB_KEY).get(
ATTRIBUTE_ADDRESSES):
addresses = vout.get(ATTRIBUTE_SCRIPT_PUB_KEY).get(
ATTRIBUTE_ADDRESSES)
for address in addresses:
tx_output = TransactionOutput(
txid=txid,
offset=offset,
address=address,
block_hash=block_hash,
block_height=block_height,
value=value,
is_from_coinbase=is_from_coinbase,
pushed_from=get_hostname_or_die())
tx_outputs.append(tx_output)
return (tx_inputs, tx_outputs)
def __update_db_with_activities__(self):
if self.activities:
print "\n\n================================[Update db]:", len(
self.activities)
try:
add_count = 0
for activity in self.activities:
address = "%s:%s" % (activity.ip_address, activity.port)
#1. Get last status
last_activity = self.__get_last_node_activity_record__(
address=address)
if not last_activity or not activity.status == last_activity.get(
ATTRIBUTE_STATUS):
print "Add: ", activity.ip_address, activity.status
node_activity = NodeActivity(
address=address,
status=activity.status,
pushed_from=get_hostname_or_die())
# Add to DB
self.session.add(node_activity)
self.session.commit()
add_count = add_count + 1
print "Added activities:", add_count
except Exception, e:
print "Error on __update_db_with_activities__:", e
traceback.print_exc(file=sys.stdout)
self.session.rollback()
finally:
def __load_missing_address_info_to_dict__(self, all_addresses,
address_info_dict):
missing_addresses = list(
set(all_addresses) - set(address_info_dict.keys()))
print "ALL:", all_addresses
print "MIS:", missing_addresses
to_add_address_infos = self.query_session.query(
TransactionAddressInfo).filter(
TransactionAddressInfo.address.in_(missing_addresses)).all()
# Set existing address_infos
for address_info in to_add_address_infos:
address_info_dict[address_info.address] = address_info
# Add new address_infos
for address in all_addresses:
if not address in address_info_dict:
new_address_info = TransactionAddressInfo(
address=address,
received_value=0,
spent_value=0,
balance=0,
vin_count=0,
vout_count=0,
coinbase=0,
pushed_from=get_hostname_or_die())
address_info_dict[address] = new_address_info
self.query_session.close()
def __finish_update_at_height__(self, block_height, address_info_dict):
update_obj = TransactionAddressInfoUpdate(
block_height=block_height, pushed_from=get_hostname_or_die())
try:
for _, address_info in address_info_dict.iteritems():
self.update_session.merge(address_info)
self.update_session.merge(update_obj)
self.update_session.commit()
except Exception, e:
print "Exception on __finish_update_at_height__", e
self.update_session.rollback()
def __create_node__(self, timed_node_ip):
node_data = timed_node_ip.get(ATTRIBUTE_NODE_DATA, {})
result = Node(address=timed_node_ip.get(ATTRIBUTE_NODE),
ip_address=timed_node_ip.get(ATTRIBUTE_IP_ADDRESS),
port=timed_node_ip.get(ATTRIBUTE_PORT),
timestamp=timed_node_ip.get(ATTRIBUTE_TIME),
asn=node_data.get(ATTRIBUTE_ASN),
city=node_data.get(ATTRIBUTE_CITY),
country=node_data.get(ATTRIBUTE_COUNTRY),
hostname=node_data.get(ATTRIBUTE_HOSTNAME),
latitude=node_data.get(ATTRIBUTE_LATITUDE),
longitude=node_data.get(ATTRIBUTE_LONGITUDE),
org=node_data.get(ATTRIBUTE_ORG),
start_height=node_data.get(ATTRIBUTE_START_HEIGHT),
time_zone=node_data.get(ATTRIBUTE_TIME_ZONE),
user_agent=node_data.get(ATTRIBUTE_USER_AGENT),
version=node_data.get(ATTRIBUTE_VERSION),
pushed_from=get_hostname_or_die())
return result