repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
blockstack/blockstack-core | blockstack/lib/nameset/db.py | namedb_get_name_from_name_hash128 | def namedb_get_name_from_name_hash128( cur, name_hash128, block_number ):
"""
Given the hexlified 128-bit hash of a name, get the name.
"""
unexpired_query, unexpired_args = namedb_select_where_unexpired_names( block_number )
select_query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + \
"WHERE name_hash128 = ? AND revoked = 0 AND " + unexpired_query + ";"
args = (name_hash128,) + unexpired_args
name_rows = namedb_query_execute( cur, select_query, args )
name_row = name_rows.fetchone()
if name_row is None:
# no such namespace
return None
return name_row['name'] | python | def namedb_get_name_from_name_hash128( cur, name_hash128, block_number ):
"""
Given the hexlified 128-bit hash of a name, get the name.
"""
unexpired_query, unexpired_args = namedb_select_where_unexpired_names( block_number )
select_query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + \
"WHERE name_hash128 = ? AND revoked = 0 AND " + unexpired_query + ";"
args = (name_hash128,) + unexpired_args
name_rows = namedb_query_execute( cur, select_query, args )
name_row = name_rows.fetchone()
if name_row is None:
# no such namespace
return None
return name_row['name'] | [
"def",
"namedb_get_name_from_name_hash128",
"(",
"cur",
",",
"name_hash128",
",",
"block_number",
")",
":",
"unexpired_query",
",",
"unexpired_args",
"=",
"namedb_select_where_unexpired_names",
"(",
"block_number",
")",
"select_query",
"=",
"\"SELECT name FROM name_records JO... | Given the hexlified 128-bit hash of a name, get the name. | [
"Given",
"the",
"hexlified",
"128",
"-",
"bit",
"hash",
"of",
"a",
"name",
"get",
"the",
"name",
"."
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/nameset/db.py#L2765-L2783 | train |
blockstack/blockstack-core | blockstack/lib/nameset/db.py | namedb_get_names_with_value_hash | def namedb_get_names_with_value_hash( cur, value_hash, block_number ):
"""
Get the names with the given value hash. Only includes current, non-revoked names.
Return None if there are no names.
"""
unexpired_query, unexpired_args = namedb_select_where_unexpired_names( block_number )
select_query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + \
"WHERE value_hash = ? AND revoked = 0 AND " + unexpired_query + ";"
args = (value_hash,) + unexpired_args
name_rows = namedb_query_execute( cur, select_query, args )
names = []
for name_row in name_rows:
names.append( name_row['name'] )
if len(names) == 0:
return None
else:
return names | python | def namedb_get_names_with_value_hash( cur, value_hash, block_number ):
"""
Get the names with the given value hash. Only includes current, non-revoked names.
Return None if there are no names.
"""
unexpired_query, unexpired_args = namedb_select_where_unexpired_names( block_number )
select_query = "SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id " + \
"WHERE value_hash = ? AND revoked = 0 AND " + unexpired_query + ";"
args = (value_hash,) + unexpired_args
name_rows = namedb_query_execute( cur, select_query, args )
names = []
for name_row in name_rows:
names.append( name_row['name'] )
if len(names) == 0:
return None
else:
return names | [
"def",
"namedb_get_names_with_value_hash",
"(",
"cur",
",",
"value_hash",
",",
"block_number",
")",
":",
"unexpired_query",
",",
"unexpired_args",
"=",
"namedb_select_where_unexpired_names",
"(",
"block_number",
")",
"select_query",
"=",
"\"SELECT name FROM name_records JOIN ... | Get the names with the given value hash. Only includes current, non-revoked names.
Return None if there are no names. | [
"Get",
"the",
"names",
"with",
"the",
"given",
"value",
"hash",
".",
"Only",
"includes",
"current",
"non",
"-",
"revoked",
"names",
".",
"Return",
"None",
"if",
"there",
"are",
"no",
"names",
"."
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/nameset/db.py#L2786-L2806 | train |
blockstack/blockstack-core | blockstack/lib/nameset/db.py | namedb_get_value_hash_txids | def namedb_get_value_hash_txids(cur, value_hash):
"""
Get the list of txs that sent this value hash, ordered by block and vtxindex
"""
query = 'SELECT txid FROM history WHERE value_hash = ? ORDER BY block_id,vtxindex;'
args = (value_hash,)
rows = namedb_query_execute(cur, query, args)
txids = []
for r in rows:
# present
txid = str(r['txid'])
txids.append(txid)
return txids | python | def namedb_get_value_hash_txids(cur, value_hash):
"""
Get the list of txs that sent this value hash, ordered by block and vtxindex
"""
query = 'SELECT txid FROM history WHERE value_hash = ? ORDER BY block_id,vtxindex;'
args = (value_hash,)
rows = namedb_query_execute(cur, query, args)
txids = []
for r in rows:
# present
txid = str(r['txid'])
txids.append(txid)
return txids | [
"def",
"namedb_get_value_hash_txids",
"(",
"cur",
",",
"value_hash",
")",
":",
"query",
"=",
"'SELECT txid FROM history WHERE value_hash = ? ORDER BY block_id,vtxindex;'",
"args",
"=",
"(",
"value_hash",
",",
")",
"rows",
"=",
"namedb_query_execute",
"(",
"cur",
",",
"q... | Get the list of txs that sent this value hash, ordered by block and vtxindex | [
"Get",
"the",
"list",
"of",
"txs",
"that",
"sent",
"this",
"value",
"hash",
"ordered",
"by",
"block",
"and",
"vtxindex"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/nameset/db.py#L2809-L2824 | train |
blockstack/blockstack-core | blockstack/lib/nameset/db.py | namedb_get_num_block_vtxs | def namedb_get_num_block_vtxs( cur, block_number ):
"""
How many virtual transactions were processed for this block?
"""
select_query = "SELECT vtxindex FROM history WHERE history_id = ?;"
args = (block_number,)
rows = namedb_query_execute( cur, select_query, args )
count = 0
for r in rows:
count += 1
return count | python | def namedb_get_num_block_vtxs( cur, block_number ):
"""
How many virtual transactions were processed for this block?
"""
select_query = "SELECT vtxindex FROM history WHERE history_id = ?;"
args = (block_number,)
rows = namedb_query_execute( cur, select_query, args )
count = 0
for r in rows:
count += 1
return count | [
"def",
"namedb_get_num_block_vtxs",
"(",
"cur",
",",
"block_number",
")",
":",
"select_query",
"=",
"\"SELECT vtxindex FROM history WHERE history_id = ?;\"",
"args",
"=",
"(",
"block_number",
",",
")",
"rows",
"=",
"namedb_query_execute",
"(",
"cur",
",",
"select_query"... | How many virtual transactions were processed for this block? | [
"How",
"many",
"virtual",
"transactions",
"were",
"processed",
"for",
"this",
"block?"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/nameset/db.py#L2827-L2839 | train |
blockstack/blockstack-core | blockstack/lib/nameset/db.py | namedb_is_name_zonefile_hash | def namedb_is_name_zonefile_hash(cur, name, zonefile_hash):
"""
Determine if a zone file hash was sent by a name.
Return True if so, false if not
"""
select_query = 'SELECT COUNT(value_hash) FROM history WHERE history_id = ? AND value_hash = ?'
select_args = (name,zonefile_hash)
rows = namedb_query_execute(cur, select_query, select_args)
count = None
for r in rows:
count = r['COUNT(value_hash)']
break
return count > 0 | python | def namedb_is_name_zonefile_hash(cur, name, zonefile_hash):
"""
Determine if a zone file hash was sent by a name.
Return True if so, false if not
"""
select_query = 'SELECT COUNT(value_hash) FROM history WHERE history_id = ? AND value_hash = ?'
select_args = (name,zonefile_hash)
rows = namedb_query_execute(cur, select_query, select_args)
count = None
for r in rows:
count = r['COUNT(value_hash)']
break
return count > 0 | [
"def",
"namedb_is_name_zonefile_hash",
"(",
"cur",
",",
"name",
",",
"zonefile_hash",
")",
":",
"select_query",
"=",
"'SELECT COUNT(value_hash) FROM history WHERE history_id = ? AND value_hash = ?'",
"select_args",
"=",
"(",
"name",
",",
"zonefile_hash",
")",
"rows",
"=",
... | Determine if a zone file hash was sent by a name.
Return True if so, false if not | [
"Determine",
"if",
"a",
"zone",
"file",
"hash",
"was",
"sent",
"by",
"a",
"name",
".",
"Return",
"True",
"if",
"so",
"false",
"if",
"not"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/nameset/db.py#L2842-L2857 | train |
blockstack/blockstack-core | blockstack/lib/operations/announce.py | process_announcement | def process_announcement( sender_namerec, op, working_dir ):
"""
If the announcement is valid, then immediately record it.
"""
node_config = get_blockstack_opts()
# valid announcement
announce_hash = op['message_hash']
announcer_id = op['announcer_id']
# verify that it came from this individual
name_history = sender_namerec['history']
allowed_value_hashes = []
for block_height in name_history.keys():
for historic_namerec in name_history[block_height]:
if historic_namerec.get('value_hash'):
allowed_value_hashes.append(historic_namerec['value_hash'])
if announce_hash not in allowed_value_hashes:
# this individual did not send this announcement
log.warning("Announce hash {} not found in name history for {}".format(announce_hash, announcer_id))
return
# go get it from Atlas
zonefiles_dir = node_config.get('zonefiles', None)
if not zonefiles_dir:
log.warning("This node does not store zone files, so no announcement can be found")
return
announce_text = get_atlas_zonefile_data(announce_hash, zonefiles_dir)
if announce_text is None:
log.warning("No zone file {} found".format(announce_hash))
return
# go append it
log.critical("ANNOUNCEMENT (from %s): %s\n------BEGIN MESSAGE------\n%s\n------END MESSAGE------\n" % (announcer_id, announce_hash, announce_text))
store_announcement( working_dir, announce_hash, announce_text ) | python | def process_announcement( sender_namerec, op, working_dir ):
"""
If the announcement is valid, then immediately record it.
"""
node_config = get_blockstack_opts()
# valid announcement
announce_hash = op['message_hash']
announcer_id = op['announcer_id']
# verify that it came from this individual
name_history = sender_namerec['history']
allowed_value_hashes = []
for block_height in name_history.keys():
for historic_namerec in name_history[block_height]:
if historic_namerec.get('value_hash'):
allowed_value_hashes.append(historic_namerec['value_hash'])
if announce_hash not in allowed_value_hashes:
# this individual did not send this announcement
log.warning("Announce hash {} not found in name history for {}".format(announce_hash, announcer_id))
return
# go get it from Atlas
zonefiles_dir = node_config.get('zonefiles', None)
if not zonefiles_dir:
log.warning("This node does not store zone files, so no announcement can be found")
return
announce_text = get_atlas_zonefile_data(announce_hash, zonefiles_dir)
if announce_text is None:
log.warning("No zone file {} found".format(announce_hash))
return
# go append it
log.critical("ANNOUNCEMENT (from %s): %s\n------BEGIN MESSAGE------\n%s\n------END MESSAGE------\n" % (announcer_id, announce_hash, announce_text))
store_announcement( working_dir, announce_hash, announce_text ) | [
"def",
"process_announcement",
"(",
"sender_namerec",
",",
"op",
",",
"working_dir",
")",
":",
"node_config",
"=",
"get_blockstack_opts",
"(",
")",
"announce_hash",
"=",
"op",
"[",
"'message_hash'",
"]",
"announcer_id",
"=",
"op",
"[",
"'announcer_id'",
"]",
"na... | If the announcement is valid, then immediately record it. | [
"If",
"the",
"announcement",
"is",
"valid",
"then",
"immediately",
"record",
"it",
"."
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/operations/announce.py#L39-L75 | train |
blockstack/blockstack-core | blockstack/lib/operations/announce.py | check | def check( state_engine, nameop, block_id, checked_ops ):
"""
Log an announcement from the blockstack developers,
but first verify that it is correct.
Return True if the announcement came from the announce IDs whitelist
Return False otherwise
"""
sender = nameop['sender']
sending_blockchain_id = None
found = False
blockchain_namerec = None
for blockchain_id in state_engine.get_announce_ids():
blockchain_namerec = state_engine.get_name( blockchain_id )
if blockchain_namerec is None:
# this name doesn't exist yet, or is expired or revoked
continue
if str(sender) == str(blockchain_namerec['sender']):
# yup!
found = True
sending_blockchain_id = blockchain_id
break
if not found:
log.warning("Announcement not sent from our whitelist of blockchain IDs")
return False
nameop['announcer_id'] = sending_blockchain_id
process_announcement( blockchain_namerec, nameop, state_engine.working_dir )
return True | python | def check( state_engine, nameop, block_id, checked_ops ):
"""
Log an announcement from the blockstack developers,
but first verify that it is correct.
Return True if the announcement came from the announce IDs whitelist
Return False otherwise
"""
sender = nameop['sender']
sending_blockchain_id = None
found = False
blockchain_namerec = None
for blockchain_id in state_engine.get_announce_ids():
blockchain_namerec = state_engine.get_name( blockchain_id )
if blockchain_namerec is None:
# this name doesn't exist yet, or is expired or revoked
continue
if str(sender) == str(blockchain_namerec['sender']):
# yup!
found = True
sending_blockchain_id = blockchain_id
break
if not found:
log.warning("Announcement not sent from our whitelist of blockchain IDs")
return False
nameop['announcer_id'] = sending_blockchain_id
process_announcement( blockchain_namerec, nameop, state_engine.working_dir )
return True | [
"def",
"check",
"(",
"state_engine",
",",
"nameop",
",",
"block_id",
",",
"checked_ops",
")",
":",
"sender",
"=",
"nameop",
"[",
"'sender'",
"]",
"sending_blockchain_id",
"=",
"None",
"found",
"=",
"False",
"blockchain_namerec",
"=",
"None",
"for",
"blockchain... | Log an announcement from the blockstack developers,
but first verify that it is correct.
Return True if the announcement came from the announce IDs whitelist
Return False otherwise | [
"Log",
"an",
"announcement",
"from",
"the",
"blockstack",
"developers",
"but",
"first",
"verify",
"that",
"it",
"is",
"correct",
".",
"Return",
"True",
"if",
"the",
"announcement",
"came",
"from",
"the",
"announce",
"IDs",
"whitelist",
"Return",
"False",
"othe... | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/operations/announce.py#L157-L188 | train |
blockstack/blockstack-core | blockstack/lib/snv.py | get_bitcoind_client | def get_bitcoind_client():
"""
Connect to the bitcoind node
"""
bitcoind_opts = get_bitcoin_opts()
bitcoind_host = bitcoind_opts['bitcoind_server']
bitcoind_port = bitcoind_opts['bitcoind_port']
bitcoind_user = bitcoind_opts['bitcoind_user']
bitcoind_passwd = bitcoind_opts['bitcoind_passwd']
return create_bitcoind_service_proxy(bitcoind_user, bitcoind_passwd, server=bitcoind_host, port=bitcoind_port) | python | def get_bitcoind_client():
"""
Connect to the bitcoind node
"""
bitcoind_opts = get_bitcoin_opts()
bitcoind_host = bitcoind_opts['bitcoind_server']
bitcoind_port = bitcoind_opts['bitcoind_port']
bitcoind_user = bitcoind_opts['bitcoind_user']
bitcoind_passwd = bitcoind_opts['bitcoind_passwd']
return create_bitcoind_service_proxy(bitcoind_user, bitcoind_passwd, server=bitcoind_host, port=bitcoind_port) | [
"def",
"get_bitcoind_client",
"(",
")",
":",
"bitcoind_opts",
"=",
"get_bitcoin_opts",
"(",
")",
"bitcoind_host",
"=",
"bitcoind_opts",
"[",
"'bitcoind_server'",
"]",
"bitcoind_port",
"=",
"bitcoind_opts",
"[",
"'bitcoind_port'",
"]",
"bitcoind_user",
"=",
"bitcoind_o... | Connect to the bitcoind node | [
"Connect",
"to",
"the",
"bitcoind",
"node"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/snv.py#L58-L68 | train |
blockstack/blockstack-core | blockstack/lib/snv.py | txid_to_block_data | def txid_to_block_data(txid, bitcoind_proxy, proxy=None):
"""
Given a txid, get its block's data.
Use SPV to verify the information we receive from the (untrusted)
bitcoind host.
@bitcoind_proxy must be a BitcoindConnection (from virtualchain.lib.session)
Return the (block hash, block data, txdata) on success
Return (None, None, None) on error
"""
proxy = get_default_proxy() if proxy is None else proxy
timeout = 1.0
while True:
try:
untrusted_tx_data = bitcoind_proxy.getrawtransaction(txid, 1)
untrusted_block_hash = untrusted_tx_data['blockhash']
untrusted_block_data = bitcoind_proxy.getblock(untrusted_block_hash)
break
except (OSError, IOError) as ie:
log.exception(ie)
log.error('Network error; retrying...')
timeout = timeout * 2 + random.randint(0, timeout)
continue
except Exception as e:
log.exception(e)
return None, None, None
bitcoind_opts = get_bitcoin_opts()
spv_headers_path = bitcoind_opts['bitcoind_spv_path']
# first, can we trust this block? is it in the SPV headers?
untrusted_block_header_hex = virtualchain.block_header_to_hex(
untrusted_block_data, untrusted_block_data['previousblockhash']
)
block_id = SPVClient.block_header_index(
spv_headers_path,
('{}00'.format(untrusted_block_header_hex)).decode('hex')
)
if block_id < 0:
# bad header
log.error('Block header "{}" is not in the SPV headers ({})'.format(
untrusted_block_header_hex, spv_headers_path
))
return None, None, None
# block header is trusted. Is the transaction data consistent with it?
verified_block_header = virtualchain.block_verify(untrusted_block_data)
if not verified_block_header:
msg = (
'Block transaction IDs are not consistent '
'with the Merkle root of the trusted header'
)
log.error(msg)
return None, None, None
# verify block hash
verified_block_hash = virtualchain.block_header_verify(
untrusted_block_data, untrusted_block_data['previousblockhash'], untrusted_block_hash
)
if not verified_block_hash:
log.error('Block hash is not consistent with block header')
return None, None, None
# we trust the block hash, block data, and txids
block_hash = untrusted_block_hash
block_data = untrusted_block_data
tx_data = untrusted_tx_data
return block_hash, block_data, tx_data | python | def txid_to_block_data(txid, bitcoind_proxy, proxy=None):
"""
Given a txid, get its block's data.
Use SPV to verify the information we receive from the (untrusted)
bitcoind host.
@bitcoind_proxy must be a BitcoindConnection (from virtualchain.lib.session)
Return the (block hash, block data, txdata) on success
Return (None, None, None) on error
"""
proxy = get_default_proxy() if proxy is None else proxy
timeout = 1.0
while True:
try:
untrusted_tx_data = bitcoind_proxy.getrawtransaction(txid, 1)
untrusted_block_hash = untrusted_tx_data['blockhash']
untrusted_block_data = bitcoind_proxy.getblock(untrusted_block_hash)
break
except (OSError, IOError) as ie:
log.exception(ie)
log.error('Network error; retrying...')
timeout = timeout * 2 + random.randint(0, timeout)
continue
except Exception as e:
log.exception(e)
return None, None, None
bitcoind_opts = get_bitcoin_opts()
spv_headers_path = bitcoind_opts['bitcoind_spv_path']
# first, can we trust this block? is it in the SPV headers?
untrusted_block_header_hex = virtualchain.block_header_to_hex(
untrusted_block_data, untrusted_block_data['previousblockhash']
)
block_id = SPVClient.block_header_index(
spv_headers_path,
('{}00'.format(untrusted_block_header_hex)).decode('hex')
)
if block_id < 0:
# bad header
log.error('Block header "{}" is not in the SPV headers ({})'.format(
untrusted_block_header_hex, spv_headers_path
))
return None, None, None
# block header is trusted. Is the transaction data consistent with it?
verified_block_header = virtualchain.block_verify(untrusted_block_data)
if not verified_block_header:
msg = (
'Block transaction IDs are not consistent '
'with the Merkle root of the trusted header'
)
log.error(msg)
return None, None, None
# verify block hash
verified_block_hash = virtualchain.block_header_verify(
untrusted_block_data, untrusted_block_data['previousblockhash'], untrusted_block_hash
)
if not verified_block_hash:
log.error('Block hash is not consistent with block header')
return None, None, None
# we trust the block hash, block data, and txids
block_hash = untrusted_block_hash
block_data = untrusted_block_data
tx_data = untrusted_tx_data
return block_hash, block_data, tx_data | [
"def",
"txid_to_block_data",
"(",
"txid",
",",
"bitcoind_proxy",
",",
"proxy",
"=",
"None",
")",
":",
"proxy",
"=",
"get_default_proxy",
"(",
")",
"if",
"proxy",
"is",
"None",
"else",
"proxy",
"timeout",
"=",
"1.0",
"while",
"True",
":",
"try",
":",
"unt... | Given a txid, get its block's data.
Use SPV to verify the information we receive from the (untrusted)
bitcoind host.
@bitcoind_proxy must be a BitcoindConnection (from virtualchain.lib.session)
Return the (block hash, block data, txdata) on success
Return (None, None, None) on error | [
"Given",
"a",
"txid",
"get",
"its",
"block",
"s",
"data",
"."
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/snv.py#L71-L150 | train |
blockstack/blockstack-core | blockstack/lib/snv.py | get_consensus_hash_from_tx | def get_consensus_hash_from_tx(tx):
"""
Given an SPV-verified transaction, extract its consensus hash.
Only works of the tx encodes a NAME_PREORDER, NAMESPACE_PREORDER,
or NAME_TRANSFER.
Return hex-encoded consensus hash on success.
Return None on error.
"""
opcode, payload = parse_tx_op_return(tx)
if opcode is None or payload is None:
return None
# only present in NAME_PREORDER, NAMESPACE_PREORDER, NAME_TRANSFER
if opcode in [NAME_PREORDER, NAMESPACE_PREORDER, NAME_TRANSFER]:
consensus_hash = payload[-16:].encode('hex')
return consensus_hash
msg = (
'Blockchain ID transaction is not a '
'NAME_PREORDER, NAMESPACE_PROERDER or NAME_TRANSFER'
)
log.error(msg)
return None | python | def get_consensus_hash_from_tx(tx):
"""
Given an SPV-verified transaction, extract its consensus hash.
Only works of the tx encodes a NAME_PREORDER, NAMESPACE_PREORDER,
or NAME_TRANSFER.
Return hex-encoded consensus hash on success.
Return None on error.
"""
opcode, payload = parse_tx_op_return(tx)
if opcode is None or payload is None:
return None
# only present in NAME_PREORDER, NAMESPACE_PREORDER, NAME_TRANSFER
if opcode in [NAME_PREORDER, NAMESPACE_PREORDER, NAME_TRANSFER]:
consensus_hash = payload[-16:].encode('hex')
return consensus_hash
msg = (
'Blockchain ID transaction is not a '
'NAME_PREORDER, NAMESPACE_PROERDER or NAME_TRANSFER'
)
log.error(msg)
return None | [
"def",
"get_consensus_hash_from_tx",
"(",
"tx",
")",
":",
"opcode",
",",
"payload",
"=",
"parse_tx_op_return",
"(",
"tx",
")",
"if",
"opcode",
"is",
"None",
"or",
"payload",
"is",
"None",
":",
"return",
"None",
"if",
"opcode",
"in",
"[",
"NAME_PREORDER",
"... | Given an SPV-verified transaction, extract its consensus hash.
Only works of the tx encodes a NAME_PREORDER, NAMESPACE_PREORDER,
or NAME_TRANSFER.
Return hex-encoded consensus hash on success.
Return None on error. | [
"Given",
"an",
"SPV",
"-",
"verified",
"transaction",
"extract",
"its",
"consensus",
"hash",
".",
"Only",
"works",
"of",
"the",
"tx",
"encodes",
"a",
"NAME_PREORDER",
"NAMESPACE_PREORDER",
"or",
"NAME_TRANSFER",
"."
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/snv.py#L278-L304 | train |
blockstack/blockstack-core | blockstack/lib/client.py | json_is_exception | def json_is_exception(resp):
"""
Is the given response object
an exception traceback?
Return True if so
Return False if not
"""
if not json_is_error(resp):
return False
if 'traceback' not in resp.keys() or 'error' not in resp.keys():
return False
return True | python | def json_is_exception(resp):
"""
Is the given response object
an exception traceback?
Return True if so
Return False if not
"""
if not json_is_error(resp):
return False
if 'traceback' not in resp.keys() or 'error' not in resp.keys():
return False
return True | [
"def",
"json_is_exception",
"(",
"resp",
")",
":",
"if",
"not",
"json_is_error",
"(",
"resp",
")",
":",
"return",
"False",
"if",
"'traceback'",
"not",
"in",
"resp",
".",
"keys",
"(",
")",
"or",
"'error'",
"not",
"in",
"resp",
".",
"keys",
"(",
")",
"... | Is the given response object
an exception traceback?
Return True if so
Return False if not | [
"Is",
"the",
"given",
"response",
"object",
"an",
"exception",
"traceback?"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L240-L254 | train |
blockstack/blockstack-core | blockstack/lib/client.py | put_zonefiles | def put_zonefiles(hostport, zonefile_data_list, timeout=30, my_hostport=None, proxy=None):
"""
Push one or more zonefiles to the given server.
Each zone file in the list must be base64-encoded
Return {'status': True, 'saved': [...]} on success
Return {'error': ...} on error
"""
assert hostport or proxy, 'need either hostport or proxy'
saved_schema = {
'type': 'object',
'properties': {
'saved': {
'type': 'array',
'items': {
'type': 'integer',
'minimum': 0,
'maximum': 1,
},
'minItems': len(zonefile_data_list),
'maxItems': len(zonefile_data_list)
},
},
'required': [
'saved'
]
}
schema = json_response_schema( saved_schema )
if proxy is None:
proxy = connect_hostport(hostport)
push_info = None
try:
push_info = proxy.put_zonefiles(zonefile_data_list)
push_info = json_validate(schema, push_info)
if json_is_error(push_info):
return push_info
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except ValidationError as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
return push_info | python | def put_zonefiles(hostport, zonefile_data_list, timeout=30, my_hostport=None, proxy=None):
"""
Push one or more zonefiles to the given server.
Each zone file in the list must be base64-encoded
Return {'status': True, 'saved': [...]} on success
Return {'error': ...} on error
"""
assert hostport or proxy, 'need either hostport or proxy'
saved_schema = {
'type': 'object',
'properties': {
'saved': {
'type': 'array',
'items': {
'type': 'integer',
'minimum': 0,
'maximum': 1,
},
'minItems': len(zonefile_data_list),
'maxItems': len(zonefile_data_list)
},
},
'required': [
'saved'
]
}
schema = json_response_schema( saved_schema )
if proxy is None:
proxy = connect_hostport(hostport)
push_info = None
try:
push_info = proxy.put_zonefiles(zonefile_data_list)
push_info = json_validate(schema, push_info)
if json_is_error(push_info):
return push_info
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except ValidationError as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
return push_info | [
"def",
"put_zonefiles",
"(",
"hostport",
",",
"zonefile_data_list",
",",
"timeout",
"=",
"30",
",",
"my_hostport",
"=",
"None",
",",
"proxy",
"=",
"None",
")",
":",
"assert",
"hostport",
"or",
"proxy",
",",
"'need either hostport or proxy'",
"saved_schema",
"=",... | Push one or more zonefiles to the given server.
Each zone file in the list must be base64-encoded
Return {'status': True, 'saved': [...]} on success
Return {'error': ...} on error | [
"Push",
"one",
"or",
"more",
"zonefiles",
"to",
"the",
"given",
"server",
".",
"Each",
"zone",
"file",
"in",
"the",
"list",
"must",
"be",
"base64",
"-",
"encoded"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L879-L945 | train |
blockstack/blockstack-core | blockstack/lib/client.py | get_zonefiles_by_block | def get_zonefiles_by_block(from_block, to_block, hostport=None, proxy=None):
"""
Get zonefile information for zonefiles announced in [@from_block, @to_block]
Returns { 'last_block' : server's last seen block,
'zonefile_info' : [ { 'zonefile_hash' : '...',
'txid' : '...',
'block_height' : '...' } ] }
"""
assert hostport or proxy, 'need either hostport or proxy'
if proxy is None:
proxy = connect_hostport(hostport)
zonefile_info_schema = {
'type' : 'array',
'items' : {
'type' : 'object',
'properties' : {
'name' : {'type' : 'string'},
'zonefile_hash' : { 'type' : 'string',
'pattern' : OP_ZONEFILE_HASH_PATTERN },
'txid' : {'type' : 'string',
'pattern' : OP_TXID_PATTERN},
'block_height' : {'type' : 'integer'}
},
'required' : [ 'zonefile_hash', 'txid', 'block_height' ]
}
}
response_schema = {
'type' : 'object',
'properties' : {
'lastblock' : {'type' : 'integer'},
'zonefile_info' : zonefile_info_schema
},
'required' : ['lastblock', 'zonefile_info']
}
offset = 0
output_zonefiles = []
last_server_block = 0
resp = {'zonefile_info': []}
while offset == 0 or len(resp['zonefile_info']) > 0:
resp = proxy.get_zonefiles_by_block(from_block, to_block, offset, 100)
if 'error' in resp:
return resp
resp = json_validate(response_schema, resp)
if json_is_error(resp):
return resp
output_zonefiles += resp['zonefile_info']
offset += 100
last_server_block = max(resp['lastblock'], last_server_block)
return { 'last_block' : last_server_block,
'zonefile_info' : output_zonefiles } | python | def get_zonefiles_by_block(from_block, to_block, hostport=None, proxy=None):
"""
Get zonefile information for zonefiles announced in [@from_block, @to_block]
Returns { 'last_block' : server's last seen block,
'zonefile_info' : [ { 'zonefile_hash' : '...',
'txid' : '...',
'block_height' : '...' } ] }
"""
assert hostport or proxy, 'need either hostport or proxy'
if proxy is None:
proxy = connect_hostport(hostport)
zonefile_info_schema = {
'type' : 'array',
'items' : {
'type' : 'object',
'properties' : {
'name' : {'type' : 'string'},
'zonefile_hash' : { 'type' : 'string',
'pattern' : OP_ZONEFILE_HASH_PATTERN },
'txid' : {'type' : 'string',
'pattern' : OP_TXID_PATTERN},
'block_height' : {'type' : 'integer'}
},
'required' : [ 'zonefile_hash', 'txid', 'block_height' ]
}
}
response_schema = {
'type' : 'object',
'properties' : {
'lastblock' : {'type' : 'integer'},
'zonefile_info' : zonefile_info_schema
},
'required' : ['lastblock', 'zonefile_info']
}
offset = 0
output_zonefiles = []
last_server_block = 0
resp = {'zonefile_info': []}
while offset == 0 or len(resp['zonefile_info']) > 0:
resp = proxy.get_zonefiles_by_block(from_block, to_block, offset, 100)
if 'error' in resp:
return resp
resp = json_validate(response_schema, resp)
if json_is_error(resp):
return resp
output_zonefiles += resp['zonefile_info']
offset += 100
last_server_block = max(resp['lastblock'], last_server_block)
return { 'last_block' : last_server_block,
'zonefile_info' : output_zonefiles } | [
"def",
"get_zonefiles_by_block",
"(",
"from_block",
",",
"to_block",
",",
"hostport",
"=",
"None",
",",
"proxy",
"=",
"None",
")",
":",
"assert",
"hostport",
"or",
"proxy",
",",
"'need either hostport or proxy'",
"if",
"proxy",
"is",
"None",
":",
"proxy",
"=",... | Get zonefile information for zonefiles announced in [@from_block, @to_block]
Returns { 'last_block' : server's last seen block,
'zonefile_info' : [ { 'zonefile_hash' : '...',
'txid' : '...',
'block_height' : '...' } ] } | [
"Get",
"zonefile",
"information",
"for",
"zonefiles",
"announced",
"in",
"["
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L948-L1005 | train |
blockstack/blockstack-core | blockstack/lib/client.py | get_account_tokens | def get_account_tokens(address, hostport=None, proxy=None):
"""
Get the types of tokens that an address owns
Returns a list of token types
"""
assert proxy or hostport, 'Need proxy or hostport'
if proxy is None:
proxy = connect_hostport(hostport)
tokens_schema = {
'type': 'object',
'properties': {
'token_types': {
'type': 'array',
'pattern': '^(.+){1,19}',
},
},
'required': [
'token_types',
]
}
schema = json_response_schema(tokens_schema)
try:
resp = proxy.get_account_tokens(address)
resp = json_validate(schema, resp)
if json_is_error(resp):
return resp
except ValidationError as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except AssertionError as ae:
if BLOCKSTACK_DEBUG:
log.exception(ae)
resp = json_traceback(resp.get('error'))
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
resp['token_types'].sort()
return resp['token_types'] | python | def get_account_tokens(address, hostport=None, proxy=None):
"""
Get the types of tokens that an address owns
Returns a list of token types
"""
assert proxy or hostport, 'Need proxy or hostport'
if proxy is None:
proxy = connect_hostport(hostport)
tokens_schema = {
'type': 'object',
'properties': {
'token_types': {
'type': 'array',
'pattern': '^(.+){1,19}',
},
},
'required': [
'token_types',
]
}
schema = json_response_schema(tokens_schema)
try:
resp = proxy.get_account_tokens(address)
resp = json_validate(schema, resp)
if json_is_error(resp):
return resp
except ValidationError as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except AssertionError as ae:
if BLOCKSTACK_DEBUG:
log.exception(ae)
resp = json_traceback(resp.get('error'))
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
resp['token_types'].sort()
return resp['token_types'] | [
"def",
"get_account_tokens",
"(",
"address",
",",
"hostport",
"=",
"None",
",",
"proxy",
"=",
"None",
")",
":",
"assert",
"proxy",
"or",
"hostport",
",",
"'Need proxy or hostport'",
"if",
"proxy",
"is",
"None",
":",
"proxy",
"=",
"connect_hostport",
"(",
"ho... | Get the types of tokens that an address owns
Returns a list of token types | [
"Get",
"the",
"types",
"of",
"tokens",
"that",
"an",
"address",
"owns",
"Returns",
"a",
"list",
"of",
"token",
"types"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L1378-L1441 | train |
blockstack/blockstack-core | blockstack/lib/client.py | get_account_balance | def get_account_balance(address, token_type, hostport=None, proxy=None):
"""
Get the balance of an account for a particular token
Returns an int
"""
assert proxy or hostport, 'Need proxy or hostport'
if proxy is None:
proxy = connect_hostport(hostport)
balance_schema = {
'type': 'object',
'properties': {
'balance': {
'type': 'integer',
},
},
'required': [
'balance',
],
}
schema = json_response_schema(balance_schema)
try:
resp = proxy.get_account_balance(address, token_type)
resp = json_validate(schema, resp)
if json_is_error(resp):
return resp
except ValidationError as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
return resp['balance'] | python | def get_account_balance(address, token_type, hostport=None, proxy=None):
"""
Get the balance of an account for a particular token
Returns an int
"""
assert proxy or hostport, 'Need proxy or hostport'
if proxy is None:
proxy = connect_hostport(hostport)
balance_schema = {
'type': 'object',
'properties': {
'balance': {
'type': 'integer',
},
},
'required': [
'balance',
],
}
schema = json_response_schema(balance_schema)
try:
resp = proxy.get_account_balance(address, token_type)
resp = json_validate(schema, resp)
if json_is_error(resp):
return resp
except ValidationError as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
return resp['balance'] | [
"def",
"get_account_balance",
"(",
"address",
",",
"token_type",
",",
"hostport",
"=",
"None",
",",
"proxy",
"=",
"None",
")",
":",
"assert",
"proxy",
"or",
"hostport",
",",
"'Need proxy or hostport'",
"if",
"proxy",
"is",
"None",
":",
"proxy",
"=",
"connect... | Get the balance of an account for a particular token
Returns an int | [
"Get",
"the",
"balance",
"of",
"an",
"account",
"for",
"a",
"particular",
"token",
"Returns",
"an",
"int"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L1504-L1558 | train |
blockstack/blockstack-core | blockstack/lib/client.py | get_name_DID | def get_name_DID(name, proxy=None, hostport=None):
"""
Get the DID for a name or subdomain
Return the DID string on success
Return None if not found
"""
assert proxy or hostport, 'Need proxy or hostport'
if proxy is None:
proxy = connect_hostport(hostport)
did_schema = {
'type': 'object',
'properties': {
'did': {
'type': 'string'
}
},
'required': [ 'did' ],
}
schema = json_response_schema(did_schema)
resp = {}
try:
resp = proxy.get_name_DID(name)
resp = json_validate(schema, resp)
if json_is_error(resp):
return resp
# DID must be well-formed
assert parse_DID(resp['did'])
except ValidationError as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except AssertionError as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
resp = {'error': 'Server replied an unparseable DID'}
return resp
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
return resp['did'] | python | def get_name_DID(name, proxy=None, hostport=None):
"""
Get the DID for a name or subdomain
Return the DID string on success
Return None if not found
"""
assert proxy or hostport, 'Need proxy or hostport'
if proxy is None:
proxy = connect_hostport(hostport)
did_schema = {
'type': 'object',
'properties': {
'did': {
'type': 'string'
}
},
'required': [ 'did' ],
}
schema = json_response_schema(did_schema)
resp = {}
try:
resp = proxy.get_name_DID(name)
resp = json_validate(schema, resp)
if json_is_error(resp):
return resp
# DID must be well-formed
assert parse_DID(resp['did'])
except ValidationError as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
resp = {'error': 'Server response did not match expected schema. You are likely communicating with an out-of-date Blockstack node.', 'http_status': 502}
return resp
except AssertionError as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
resp = {'error': 'Server replied an unparseable DID'}
return resp
except socket.timeout:
log.error("Connection timed out")
resp = {'error': 'Connection to remote host timed out.', 'http_status': 503}
return resp
except socket.error as se:
log.error("Connection error {}".format(se.errno))
resp = {'error': 'Connection to remote host failed.', 'http_status': 502}
return resp
except Exception as ee:
if BLOCKSTACK_DEBUG:
log.exception(ee)
log.error("Caught exception while connecting to Blockstack node: {}".format(ee))
resp = {'error': 'Failed to contact Blockstack node. Try again with `--debug`.', 'http_status': 500}
return resp
return resp['did'] | [
"def",
"get_name_DID",
"(",
"name",
",",
"proxy",
"=",
"None",
",",
"hostport",
"=",
"None",
")",
":",
"assert",
"proxy",
"or",
"hostport",
",",
"'Need proxy or hostport'",
"if",
"proxy",
"is",
"None",
":",
"proxy",
"=",
"connect_hostport",
"(",
"hostport",
... | Get the DID for a name or subdomain
Return the DID string on success
Return None if not found | [
"Get",
"the",
"DID",
"for",
"a",
"name",
"or",
"subdomain",
"Return",
"the",
"DID",
"string",
"on",
"success",
"Return",
"None",
"if",
"not",
"found"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L2473-L2536 | train |
blockstack/blockstack-core | blockstack/lib/client.py | get_JWT | def get_JWT(url, address=None):
"""
Given a URL, fetch and decode the JWT it points to.
If address is given, then authenticate the JWT with the address.
Return None if we could not fetch it, or unable to authenticate it.
NOTE: the URL must be usable by the requests library
"""
jwt_txt = None
jwt = None
log.debug("Try {}".format(url))
# special case: handle file://
urlinfo = urllib2.urlparse.urlparse(url)
if urlinfo.scheme == 'file':
# points to a path on disk
try:
with open(urlinfo.path, 'r') as f:
jwt_txt = f.read()
except Exception as e:
if BLOCKSTACK_TEST:
log.exception(e)
log.warning("Failed to read {}".format(url))
return None
else:
# http(s) URL or similar
try:
resp = requests.get(url)
assert resp.status_code == 200, 'Bad status code on {}: {}'.format(url, resp.status_code)
jwt_txt = resp.text
except Exception as e:
if BLOCKSTACK_TEST:
log.exception(e)
log.warning("Unable to resolve {}".format(url))
return None
try:
# one of two things are possible:
# * this is a JWT string
# * this is a serialized JSON string whose first item is a dict that has 'token' as key,
# and that key is a JWT string.
try:
jwt_txt = json.loads(jwt_txt)[0]['token']
except:
pass
jwt = jsontokens.decode_token(jwt_txt)
except Exception as e:
if BLOCKSTACK_TEST:
log.exception(e)
log.warning("Unable to decode token at {}".format(url))
return None
try:
# must be well-formed
assert isinstance(jwt, dict)
assert 'payload' in jwt, jwt
assert isinstance(jwt['payload'], dict)
assert 'issuer' in jwt['payload'], jwt
assert isinstance(jwt['payload']['issuer'], dict)
assert 'publicKey' in jwt['payload']['issuer'], jwt
assert virtualchain.ecdsalib.ecdsa_public_key(str(jwt['payload']['issuer']['publicKey']))
except AssertionError as ae:
if BLOCKSTACK_TEST or BLOCKSTACK_DEBUG:
log.exception(ae)
log.warning("JWT at {} is malformed".format(url))
return None
if address is not None:
public_key = str(jwt['payload']['issuer']['publicKey'])
addrs = [virtualchain.address_reencode(virtualchain.ecdsalib.ecdsa_public_key(keylib.key_formatting.decompress(public_key)).address()),
virtualchain.address_reencode(virtualchain.ecdsalib.ecdsa_public_key(keylib.key_formatting.compress(public_key)).address())]
if virtualchain.address_reencode(address) not in addrs:
# got a JWT, but it doesn't match the address
log.warning("Found JWT at {}, but its public key has addresses {} and {} (expected {})".format(url, addrs[0], addrs[1], address))
return None
verifier = jsontokens.TokenVerifier()
if not verifier.verify(jwt_txt, public_key):
# got a JWT, and the address matches, but the signature does not
log.warning("Found JWT at {}, but it was not signed by {} ({})".format(url, public_key, address))
return None
return jwt | python | def get_JWT(url, address=None):
"""
Given a URL, fetch and decode the JWT it points to.
If address is given, then authenticate the JWT with the address.
Return None if we could not fetch it, or unable to authenticate it.
NOTE: the URL must be usable by the requests library
"""
jwt_txt = None
jwt = None
log.debug("Try {}".format(url))
# special case: handle file://
urlinfo = urllib2.urlparse.urlparse(url)
if urlinfo.scheme == 'file':
# points to a path on disk
try:
with open(urlinfo.path, 'r') as f:
jwt_txt = f.read()
except Exception as e:
if BLOCKSTACK_TEST:
log.exception(e)
log.warning("Failed to read {}".format(url))
return None
else:
# http(s) URL or similar
try:
resp = requests.get(url)
assert resp.status_code == 200, 'Bad status code on {}: {}'.format(url, resp.status_code)
jwt_txt = resp.text
except Exception as e:
if BLOCKSTACK_TEST:
log.exception(e)
log.warning("Unable to resolve {}".format(url))
return None
try:
# one of two things are possible:
# * this is a JWT string
# * this is a serialized JSON string whose first item is a dict that has 'token' as key,
# and that key is a JWT string.
try:
jwt_txt = json.loads(jwt_txt)[0]['token']
except:
pass
jwt = jsontokens.decode_token(jwt_txt)
except Exception as e:
if BLOCKSTACK_TEST:
log.exception(e)
log.warning("Unable to decode token at {}".format(url))
return None
try:
# must be well-formed
assert isinstance(jwt, dict)
assert 'payload' in jwt, jwt
assert isinstance(jwt['payload'], dict)
assert 'issuer' in jwt['payload'], jwt
assert isinstance(jwt['payload']['issuer'], dict)
assert 'publicKey' in jwt['payload']['issuer'], jwt
assert virtualchain.ecdsalib.ecdsa_public_key(str(jwt['payload']['issuer']['publicKey']))
except AssertionError as ae:
if BLOCKSTACK_TEST or BLOCKSTACK_DEBUG:
log.exception(ae)
log.warning("JWT at {} is malformed".format(url))
return None
if address is not None:
public_key = str(jwt['payload']['issuer']['publicKey'])
addrs = [virtualchain.address_reencode(virtualchain.ecdsalib.ecdsa_public_key(keylib.key_formatting.decompress(public_key)).address()),
virtualchain.address_reencode(virtualchain.ecdsalib.ecdsa_public_key(keylib.key_formatting.compress(public_key)).address())]
if virtualchain.address_reencode(address) not in addrs:
# got a JWT, but it doesn't match the address
log.warning("Found JWT at {}, but its public key has addresses {} and {} (expected {})".format(url, addrs[0], addrs[1], address))
return None
verifier = jsontokens.TokenVerifier()
if not verifier.verify(jwt_txt, public_key):
# got a JWT, and the address matches, but the signature does not
log.warning("Found JWT at {}, but it was not signed by {} ({})".format(url, public_key, address))
return None
return jwt | [
"def",
"get_JWT",
"(",
"url",
",",
"address",
"=",
"None",
")",
":",
"jwt_txt",
"=",
"None",
"jwt",
"=",
"None",
"log",
".",
"debug",
"(",
"\"Try {}\"",
".",
"format",
"(",
"url",
")",
")",
"urlinfo",
"=",
"urllib2",
".",
"urlparse",
".",
"urlparse",... | Given a URL, fetch and decode the JWT it points to.
If address is given, then authenticate the JWT with the address.
Return None if we could not fetch it, or unable to authenticate it.
NOTE: the URL must be usable by the requests library | [
"Given",
"a",
"URL",
"fetch",
"and",
"decode",
"the",
"JWT",
"it",
"points",
"to",
".",
"If",
"address",
"is",
"given",
"then",
"authenticate",
"the",
"JWT",
"with",
"the",
"address",
"."
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L3460-L3554 | train |
blockstack/blockstack-core | blockstack/lib/client.py | decode_name_zonefile | def decode_name_zonefile(name, zonefile_txt):
"""
Decode a zone file for a name.
Must be either a well-formed DNS zone file, or a legacy Onename profile.
Return None on error
"""
user_zonefile = None
try:
# by default, it's a zonefile-formatted text file
user_zonefile_defaultdict = blockstack_zones.parse_zone_file(zonefile_txt)
# force dict
user_zonefile = dict(user_zonefile_defaultdict)
except (IndexError, ValueError, blockstack_zones.InvalidLineException):
# might be legacy profile
log.debug('WARN: failed to parse user zonefile; trying to import as legacy')
try:
user_zonefile = json.loads(zonefile_txt)
if not isinstance(user_zonefile, dict):
log.debug('Not a legacy user zonefile')
return None
except Exception as e:
log.error('Failed to parse non-standard zonefile')
return None
except Exception as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
log.error('Failed to parse zonefile')
return None
if user_zonefile is None:
return None
return user_zonefile | python | def decode_name_zonefile(name, zonefile_txt):
"""
Decode a zone file for a name.
Must be either a well-formed DNS zone file, or a legacy Onename profile.
Return None on error
"""
user_zonefile = None
try:
# by default, it's a zonefile-formatted text file
user_zonefile_defaultdict = blockstack_zones.parse_zone_file(zonefile_txt)
# force dict
user_zonefile = dict(user_zonefile_defaultdict)
except (IndexError, ValueError, blockstack_zones.InvalidLineException):
# might be legacy profile
log.debug('WARN: failed to parse user zonefile; trying to import as legacy')
try:
user_zonefile = json.loads(zonefile_txt)
if not isinstance(user_zonefile, dict):
log.debug('Not a legacy user zonefile')
return None
except Exception as e:
log.error('Failed to parse non-standard zonefile')
return None
except Exception as e:
if BLOCKSTACK_DEBUG:
log.exception(e)
log.error('Failed to parse zonefile')
return None
if user_zonefile is None:
return None
return user_zonefile | [
"def",
"decode_name_zonefile",
"(",
"name",
",",
"zonefile_txt",
")",
":",
"user_zonefile",
"=",
"None",
"try",
":",
"user_zonefile_defaultdict",
"=",
"blockstack_zones",
".",
"parse_zone_file",
"(",
"zonefile_txt",
")",
"user_zonefile",
"=",
"dict",
"(",
"user_zone... | Decode a zone file for a name.
Must be either a well-formed DNS zone file, or a legacy Onename profile.
Return None on error | [
"Decode",
"a",
"zone",
"file",
"for",
"a",
"name",
".",
"Must",
"be",
"either",
"a",
"well",
"-",
"formed",
"DNS",
"zone",
"file",
"or",
"a",
"legacy",
"Onename",
"profile",
".",
"Return",
"None",
"on",
"error"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/client.py#L3738-L3776 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler._send_headers | def _send_headers(self, status_code=200, content_type='application/json', more_headers={}):
"""
Generate and reply headers
"""
self.send_response(status_code)
self.send_header('content-type', content_type)
self.send_header('Access-Control-Allow-Origin', '*') # CORS
for (hdr, val) in more_headers.items():
self.send_header(hdr, val)
self.end_headers() | python | def _send_headers(self, status_code=200, content_type='application/json', more_headers={}):
"""
Generate and reply headers
"""
self.send_response(status_code)
self.send_header('content-type', content_type)
self.send_header('Access-Control-Allow-Origin', '*') # CORS
for (hdr, val) in more_headers.items():
self.send_header(hdr, val)
self.end_headers() | [
"def",
"_send_headers",
"(",
"self",
",",
"status_code",
"=",
"200",
",",
"content_type",
"=",
"'application/json'",
",",
"more_headers",
"=",
"{",
"}",
")",
":",
"self",
".",
"send_response",
"(",
"status_code",
")",
"self",
".",
"send_header",
"(",
"'conte... | Generate and reply headers | [
"Generate",
"and",
"reply",
"headers"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L124-L134 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler._reply_json | def _reply_json(self, json_payload, status_code=200):
"""
Return a JSON-serializable data structure
"""
self._send_headers(status_code=status_code)
json_str = json.dumps(json_payload)
self.wfile.write(json_str) | python | def _reply_json(self, json_payload, status_code=200):
"""
Return a JSON-serializable data structure
"""
self._send_headers(status_code=status_code)
json_str = json.dumps(json_payload)
self.wfile.write(json_str) | [
"def",
"_reply_json",
"(",
"self",
",",
"json_payload",
",",
"status_code",
"=",
"200",
")",
":",
"self",
".",
"_send_headers",
"(",
"status_code",
"=",
"status_code",
")",
"json_str",
"=",
"json",
".",
"dumps",
"(",
"json_payload",
")",
"self",
".",
"wfil... | Return a JSON-serializable data structure | [
"Return",
"a",
"JSON",
"-",
"serializable",
"data",
"structure"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L137-L143 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler._read_json | def _read_json(self, schema=None, maxlen=JSONRPC_MAX_SIZE):
"""
Read a JSON payload from the requester
Return the parsed payload on success
Return None on error
"""
# JSON post?
request_type = self.headers.get('content-type', None)
client_address_str = "{}:{}".format(self.client_address[0], self.client_address[1])
if request_type != 'application/json':
log.error("Invalid request of type {} from {}".format(request_type, client_address_str))
return None
request_str = self._read_payload(maxlen=maxlen)
if request_str is None:
log.error("Failed to read request")
return None
# parse the payload
request = None
try:
request = json.loads( request_str )
if schema is not None:
jsonschema.validate( request, schema )
except ValidationError as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
log.error("Validation error on request {}...".format(request_str[:15]))
if ve.validator == "maxLength":
return {"error" : "maxLength"}
except (TypeError, ValueError) as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
return None
return request | python | def _read_json(self, schema=None, maxlen=JSONRPC_MAX_SIZE):
"""
Read a JSON payload from the requester
Return the parsed payload on success
Return None on error
"""
# JSON post?
request_type = self.headers.get('content-type', None)
client_address_str = "{}:{}".format(self.client_address[0], self.client_address[1])
if request_type != 'application/json':
log.error("Invalid request of type {} from {}".format(request_type, client_address_str))
return None
request_str = self._read_payload(maxlen=maxlen)
if request_str is None:
log.error("Failed to read request")
return None
# parse the payload
request = None
try:
request = json.loads( request_str )
if schema is not None:
jsonschema.validate( request, schema )
except ValidationError as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
log.error("Validation error on request {}...".format(request_str[:15]))
if ve.validator == "maxLength":
return {"error" : "maxLength"}
except (TypeError, ValueError) as ve:
if BLOCKSTACK_DEBUG:
log.exception(ve)
return None
return request | [
"def",
"_read_json",
"(",
"self",
",",
"schema",
"=",
"None",
",",
"maxlen",
"=",
"JSONRPC_MAX_SIZE",
")",
":",
"request_type",
"=",
"self",
".",
"headers",
".",
"get",
"(",
"'content-type'",
",",
"None",
")",
"client_address_str",
"=",
"\"{}:{}\"",
".",
"... | Read a JSON payload from the requester
Return the parsed payload on success
Return None on error | [
"Read",
"a",
"JSON",
"payload",
"from",
"the",
"requester",
"Return",
"the",
"parsed",
"payload",
"on",
"success",
"Return",
"None",
"on",
"error"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L176-L217 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.parse_qs | def parse_qs(self, qs):
"""
Parse query string, but enforce one instance of each variable.
Return a dict with the variables on success
Return None on parse error
"""
qs_state = urllib2.urlparse.parse_qs(qs)
ret = {}
for qs_var, qs_value_list in qs_state.items():
if len(qs_value_list) > 1:
return None
ret[qs_var] = qs_value_list[0]
return ret | python | def parse_qs(self, qs):
"""
Parse query string, but enforce one instance of each variable.
Return a dict with the variables on success
Return None on parse error
"""
qs_state = urllib2.urlparse.parse_qs(qs)
ret = {}
for qs_var, qs_value_list in qs_state.items():
if len(qs_value_list) > 1:
return None
ret[qs_var] = qs_value_list[0]
return ret | [
"def",
"parse_qs",
"(",
"self",
",",
"qs",
")",
":",
"qs_state",
"=",
"urllib2",
".",
"urlparse",
".",
"parse_qs",
"(",
"qs",
")",
"ret",
"=",
"{",
"}",
"for",
"qs_var",
",",
"qs_value_list",
"in",
"qs_state",
".",
"items",
"(",
")",
":",
"if",
"le... | Parse query string, but enforce one instance of each variable.
Return a dict with the variables on success
Return None on parse error | [
"Parse",
"query",
"string",
"but",
"enforce",
"one",
"instance",
"of",
"each",
"variable",
".",
"Return",
"a",
"dict",
"with",
"the",
"variables",
"on",
"success",
"Return",
"None",
"on",
"parse",
"error"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L220-L234 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.get_path_and_qs | def get_path_and_qs(self):
"""
Parse and obtain the path and query values.
We don't care about fragments.
Return {'path': ..., 'qs_values': ...} on success
Return {'error': ...} on error
"""
path_parts = self.path.split("?", 1)
if len(path_parts) > 1:
qs = path_parts[1].split("#", 1)[0]
else:
qs = ""
path = path_parts[0].split("#", 1)[0]
path = posixpath.normpath(urllib.unquote(path))
qs_values = self.parse_qs( qs )
if qs_values is None:
return {'error': 'Failed to parse query string'}
parts = path.strip('/').split('/')
return {'path': path, 'qs_values': qs_values, 'parts': parts} | python | def get_path_and_qs(self):
"""
Parse and obtain the path and query values.
We don't care about fragments.
Return {'path': ..., 'qs_values': ...} on success
Return {'error': ...} on error
"""
path_parts = self.path.split("?", 1)
if len(path_parts) > 1:
qs = path_parts[1].split("#", 1)[0]
else:
qs = ""
path = path_parts[0].split("#", 1)[0]
path = posixpath.normpath(urllib.unquote(path))
qs_values = self.parse_qs( qs )
if qs_values is None:
return {'error': 'Failed to parse query string'}
parts = path.strip('/').split('/')
return {'path': path, 'qs_values': qs_values, 'parts': parts} | [
"def",
"get_path_and_qs",
"(",
"self",
")",
":",
"path_parts",
"=",
"self",
".",
"path",
".",
"split",
"(",
"\"?\"",
",",
"1",
")",
"if",
"len",
"(",
"path_parts",
")",
">",
"1",
":",
"qs",
"=",
"path_parts",
"[",
"1",
"]",
".",
"split",
"(",
"\"... | Parse and obtain the path and query values.
We don't care about fragments.
Return {'path': ..., 'qs_values': ...} on success
Return {'error': ...} on error | [
"Parse",
"and",
"obtain",
"the",
"path",
"and",
"query",
"values",
".",
"We",
"don",
"t",
"care",
"about",
"fragments",
"."
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L237-L261 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.OPTIONS_preflight | def OPTIONS_preflight( self, path_info ):
"""
Give back CORS preflight check headers
"""
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*') # CORS
self.send_header('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE')
self.send_header('Access-Control-Allow-Headers', 'content-type, authorization, range')
self.send_header('Access-Control-Expose-Headers', 'content-length, content-range')
self.send_header('Access-Control-Max-Age', 21600)
self.end_headers()
return | python | def OPTIONS_preflight( self, path_info ):
"""
Give back CORS preflight check headers
"""
self.send_response(200)
self.send_header('Access-Control-Allow-Origin', '*') # CORS
self.send_header('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE')
self.send_header('Access-Control-Allow-Headers', 'content-type, authorization, range')
self.send_header('Access-Control-Expose-Headers', 'content-length, content-range')
self.send_header('Access-Control-Max-Age', 21600)
self.end_headers()
return | [
"def",
"OPTIONS_preflight",
"(",
"self",
",",
"path_info",
")",
":",
"self",
".",
"send_response",
"(",
"200",
")",
"self",
".",
"send_header",
"(",
"'Access-Control-Allow-Origin'",
",",
"'*'",
")",
"self",
".",
"send_header",
"(",
"'Access-Control-Allow-Methods'"... | Give back CORS preflight check headers | [
"Give",
"back",
"CORS",
"preflight",
"check",
"headers"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L290-L301 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_names_owned_by_address | def GET_names_owned_by_address( self, path_info, blockchain, address ):
"""
Get all names owned by an address
Returns the list on success
Return 404 on unsupported blockchain
Return 502 on failure to get names for any non-specified reason
"""
if not check_address(address):
return self._reply_json({'error': 'Invalid address'}, status_code=400)
if blockchain != 'bitcoin':
return self._reply_json({'error': 'Unsupported blockchain'}, status_code=404)
blockstackd_url = get_blockstackd_url()
address = str(address)
subdomain_names = blockstackd_client.get_subdomains_owned_by_address(address, hostport=blockstackd_url)
if json_is_error(subdomain_names):
log.error("Failed to fetch subdomains owned by address")
log.error(subdomain_names)
subdomain_names = []
# make sure we have the right encoding
new_addr = virtualchain.address_reencode(address)
if new_addr != address:
log.debug("Re-encode {} to {}".format(new_addr, address))
address = new_addr
res = blockstackd_client.get_names_owned_by_address(address, hostport=blockstackd_url)
if json_is_error(res):
log.error("Failed to get names owned by address")
self._reply_json({'error': 'Failed to list names by address'}, status_code=res.get('http_status', 502))
return
self._reply_json({'names': res + subdomain_names})
return | python | def GET_names_owned_by_address( self, path_info, blockchain, address ):
"""
Get all names owned by an address
Returns the list on success
Return 404 on unsupported blockchain
Return 502 on failure to get names for any non-specified reason
"""
if not check_address(address):
return self._reply_json({'error': 'Invalid address'}, status_code=400)
if blockchain != 'bitcoin':
return self._reply_json({'error': 'Unsupported blockchain'}, status_code=404)
blockstackd_url = get_blockstackd_url()
address = str(address)
subdomain_names = blockstackd_client.get_subdomains_owned_by_address(address, hostport=blockstackd_url)
if json_is_error(subdomain_names):
log.error("Failed to fetch subdomains owned by address")
log.error(subdomain_names)
subdomain_names = []
# make sure we have the right encoding
new_addr = virtualchain.address_reencode(address)
if new_addr != address:
log.debug("Re-encode {} to {}".format(new_addr, address))
address = new_addr
res = blockstackd_client.get_names_owned_by_address(address, hostport=blockstackd_url)
if json_is_error(res):
log.error("Failed to get names owned by address")
self._reply_json({'error': 'Failed to list names by address'}, status_code=res.get('http_status', 502))
return
self._reply_json({'names': res + subdomain_names})
return | [
"def",
"GET_names_owned_by_address",
"(",
"self",
",",
"path_info",
",",
"blockchain",
",",
"address",
")",
":",
"if",
"not",
"check_address",
"(",
"address",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",
"{",
"'error'",
":",
"'Invalid address'",
"}",
... | Get all names owned by an address
Returns the list on success
Return 404 on unsupported blockchain
Return 502 on failure to get names for any non-specified reason | [
"Get",
"all",
"names",
"owned",
"by",
"an",
"address",
"Returns",
"the",
"list",
"on",
"success",
"Return",
"404",
"on",
"unsupported",
"blockchain",
"Return",
"502",
"on",
"failure",
"to",
"get",
"names",
"for",
"any",
"non",
"-",
"specified",
"reason"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L304-L339 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_account_record | def GET_account_record(self, path_info, account_addr, token_type):
"""
Get the state of a particular token account
Returns the account
"""
if not check_account_address(account_addr):
return self._reply_json({'error': 'Invalid address'}, status_code=400)
if not check_token_type(token_type):
return self._reply_json({'error': 'Invalid token type'}, status_code=400)
blockstackd_url = get_blockstackd_url()
res = blockstackd_client.get_account_record(account_addr, token_type, hostport=blockstackd_url)
if json_is_error(res):
log.error("Failed to get account state for {} {}: {}".format(account_addr, token_type, res['error']))
return self._reply_json({'error': 'Failed to get account record for {} {}: {}'.format(token_type, account_addr, res['error'])}, status_code=res.get('http_status', 500))
self._reply_json(res)
return | python | def GET_account_record(self, path_info, account_addr, token_type):
"""
Get the state of a particular token account
Returns the account
"""
if not check_account_address(account_addr):
return self._reply_json({'error': 'Invalid address'}, status_code=400)
if not check_token_type(token_type):
return self._reply_json({'error': 'Invalid token type'}, status_code=400)
blockstackd_url = get_blockstackd_url()
res = blockstackd_client.get_account_record(account_addr, token_type, hostport=blockstackd_url)
if json_is_error(res):
log.error("Failed to get account state for {} {}: {}".format(account_addr, token_type, res['error']))
return self._reply_json({'error': 'Failed to get account record for {} {}: {}'.format(token_type, account_addr, res['error'])}, status_code=res.get('http_status', 500))
self._reply_json(res)
return | [
"def",
"GET_account_record",
"(",
"self",
",",
"path_info",
",",
"account_addr",
",",
"token_type",
")",
":",
"if",
"not",
"check_account_address",
"(",
"account_addr",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",
"{",
"'error'",
":",
"'Invalid address'"... | Get the state of a particular token account
Returns the account | [
"Get",
"the",
"state",
"of",
"a",
"particular",
"token",
"account",
"Returns",
"the",
"account"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L360-L378 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_names | def GET_names( self, path_info ):
"""
Get all names in existence
If `all=true` is set, then include expired names.
Returns the list on success
Returns 400 on invalid arguments
Returns 502 on failure to get names
"""
include_expired = False
qs_values = path_info['qs_values']
page = qs_values.get('page', None)
if page is None:
log.error("Page required")
return self._reply_json({'error': 'page= argument required'}, status_code=400)
try:
page = int(page)
if page < 0:
raise ValueError("Page is negative")
except ValueError:
log.error("Invalid page")
return self._reply_json({'error': 'Invalid page= value'}, status_code=400)
if qs_values.get('all', '').lower() in ['1', 'true']:
include_expired = True
offset = page * 100
count = 100
blockstackd_url = get_blockstackd_url()
res = blockstackd_client.get_all_names(offset, count, include_expired=include_expired, hostport=blockstackd_url)
if json_is_error(res):
log.error("Failed to list all names (offset={}, count={}): {}".format(offset, count, res['error']))
return self._reply_json({'error': 'Failed to list all names'}, status_code=res.get('http_status', 502))
return self._reply_json(res) | python | def GET_names( self, path_info ):
"""
Get all names in existence
If `all=true` is set, then include expired names.
Returns the list on success
Returns 400 on invalid arguments
Returns 502 on failure to get names
"""
include_expired = False
qs_values = path_info['qs_values']
page = qs_values.get('page', None)
if page is None:
log.error("Page required")
return self._reply_json({'error': 'page= argument required'}, status_code=400)
try:
page = int(page)
if page < 0:
raise ValueError("Page is negative")
except ValueError:
log.error("Invalid page")
return self._reply_json({'error': 'Invalid page= value'}, status_code=400)
if qs_values.get('all', '').lower() in ['1', 'true']:
include_expired = True
offset = page * 100
count = 100
blockstackd_url = get_blockstackd_url()
res = blockstackd_client.get_all_names(offset, count, include_expired=include_expired, hostport=blockstackd_url)
if json_is_error(res):
log.error("Failed to list all names (offset={}, count={}): {}".format(offset, count, res['error']))
return self._reply_json({'error': 'Failed to list all names'}, status_code=res.get('http_status', 502))
return self._reply_json(res) | [
"def",
"GET_names",
"(",
"self",
",",
"path_info",
")",
":",
"include_expired",
"=",
"False",
"qs_values",
"=",
"path_info",
"[",
"'qs_values'",
"]",
"page",
"=",
"qs_values",
".",
"get",
"(",
"'page'",
",",
"None",
")",
"if",
"page",
"is",
"None",
":",
... | Get all names in existence
If `all=true` is set, then include expired names.
Returns the list on success
Returns 400 on invalid arguments
Returns 502 on failure to get names | [
"Get",
"all",
"names",
"in",
"existence",
"If",
"all",
"=",
"true",
"is",
"set",
"then",
"include",
"expired",
"names",
".",
"Returns",
"the",
"list",
"on",
"success",
"Returns",
"400",
"on",
"invalid",
"arguments",
"Returns",
"502",
"on",
"failure",
"to",... | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L458-L496 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_name_history | def GET_name_history(self, path_info, name):
"""
Get the history of a name or subdomain.
Requires 'page' in the query string
return the history on success
return 400 on invalid start_block or end_block
return 502 on failure to query blockstack server
"""
if not check_name(name) and not check_subdomain(name):
return self._reply_json({'error': 'Invalid name or subdomain'}, status_code=400)
qs_values = path_info['qs_values']
page = qs_values.get('page', None)
if page is None:
page = "0" # compatibility
try:
assert len(page) < 10
page = int(page)
assert page >= 0
assert page <= 2**32 - 1
except:
log.error("Invalid page")
self._reply_json({'error': 'Invalid page'}, status_code=400)
return
blockstackd_url = get_blockstackd_url()
res = blockstackd_client.get_name_history_page(name, page, hostport=blockstackd_url)
if json_is_error(res):
log.error('Failed to get name history for {}: {}'.format(name, res['error']))
return self._reply_json({'error': res['error']}, status_code=res.get('http_status', 502))
return self._reply_json(res['history']) | python | def GET_name_history(self, path_info, name):
"""
Get the history of a name or subdomain.
Requires 'page' in the query string
return the history on success
return 400 on invalid start_block or end_block
return 502 on failure to query blockstack server
"""
if not check_name(name) and not check_subdomain(name):
return self._reply_json({'error': 'Invalid name or subdomain'}, status_code=400)
qs_values = path_info['qs_values']
page = qs_values.get('page', None)
if page is None:
page = "0" # compatibility
try:
assert len(page) < 10
page = int(page)
assert page >= 0
assert page <= 2**32 - 1
except:
log.error("Invalid page")
self._reply_json({'error': 'Invalid page'}, status_code=400)
return
blockstackd_url = get_blockstackd_url()
res = blockstackd_client.get_name_history_page(name, page, hostport=blockstackd_url)
if json_is_error(res):
log.error('Failed to get name history for {}: {}'.format(name, res['error']))
return self._reply_json({'error': res['error']}, status_code=res.get('http_status', 502))
return self._reply_json(res['history']) | [
"def",
"GET_name_history",
"(",
"self",
",",
"path_info",
",",
"name",
")",
":",
"if",
"not",
"check_name",
"(",
"name",
")",
"and",
"not",
"check_subdomain",
"(",
"name",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",
"{",
"'error'",
":",
"'Invali... | Get the history of a name or subdomain.
Requires 'page' in the query string
return the history on success
return 400 on invalid start_block or end_block
return 502 on failure to query blockstack server | [
"Get",
"the",
"history",
"of",
"a",
"name",
"or",
"subdomain",
".",
"Requires",
"page",
"in",
"the",
"query",
"string",
"return",
"the",
"history",
"on",
"success",
"return",
"400",
"on",
"invalid",
"start_block",
"or",
"end_block",
"return",
"502",
"on",
... | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L650-L683 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_name_zonefile_by_hash | def GET_name_zonefile_by_hash( self, path_info, name, zonefile_hash ):
"""
Get a historic zonefile for a name
With `raw=1` on the query string, return the raw zone file
Reply 200 with {'zonefile': zonefile} on success
Reply 204 with {'error': ...} if the zone file is non-standard
Reply 404 on not found
Reply 502 on failure to fetch data
"""
if not check_name(name) and not check_subdomain(name):
return self._reply_json({'error': 'Invalid name or subdomain'}, status_code=400)
if not check_string(zonefile_hash, pattern=OP_ZONEFILE_HASH_PATTERN):
return self._reply_json({'error': 'Invalid zone file hash'}, status_code=400)
raw = path_info['qs_values'].get('raw', '')
raw = (raw.lower() in ['1', 'true'])
blockstack_hostport = get_blockstackd_url()
was_set = blockstackd_client.is_name_zonefile_hash(name, zonefile_hash, hostport=blockstack_hostport)
if json_is_error(was_set):
return self._reply_json({'error': was_set['error']}, status_code=was_set.get('http_status', 502))
if not was_set['result']:
self._reply_json({'error': 'No such zonefile'}, status_code=404)
return
resp = blockstackd_client.get_zonefiles(blockstack_hostport, [str(zonefile_hash)])
if json_is_error(resp):
self._reply_json({'error': resp['error']}, status_code=resp.get('http_status', 502))
return
if str(zonefile_hash) not in resp['zonefiles']:
return self._reply_json({'error': 'Blockstack does not have this zonefile. Try again later.'}, status_code=404)
if raw:
self._send_headers(status_code=200, content_type='application/octet-stream')
self.wfile.write(resp['zonefiles'][str(zonefile_hash)])
else:
# make sure it's valid
if str(zonefile_hash) not in resp['zonefiles']:
log.debug('Failed to find zonefile hash {}, possess {}'.format(
str(zonefile_hash), resp['zonefiles'].keys()))
return self._reply_json({'error': 'No such zonefile'}, status_code=404)
zonefile_txt = resp['zonefiles'][str(zonefile_hash)]
res = decode_name_zonefile(name, zonefile_txt)
if res is None:
log.error("Failed to parse zone file for {}".format(name))
self._reply_json({'error': 'Non-standard zone file for {}'.format(name)}, status_code=204)
return
self._reply_json({'zonefile': zonefile_txt})
return | python | def GET_name_zonefile_by_hash( self, path_info, name, zonefile_hash ):
"""
Get a historic zonefile for a name
With `raw=1` on the query string, return the raw zone file
Reply 200 with {'zonefile': zonefile} on success
Reply 204 with {'error': ...} if the zone file is non-standard
Reply 404 on not found
Reply 502 on failure to fetch data
"""
if not check_name(name) and not check_subdomain(name):
return self._reply_json({'error': 'Invalid name or subdomain'}, status_code=400)
if not check_string(zonefile_hash, pattern=OP_ZONEFILE_HASH_PATTERN):
return self._reply_json({'error': 'Invalid zone file hash'}, status_code=400)
raw = path_info['qs_values'].get('raw', '')
raw = (raw.lower() in ['1', 'true'])
blockstack_hostport = get_blockstackd_url()
was_set = blockstackd_client.is_name_zonefile_hash(name, zonefile_hash, hostport=blockstack_hostport)
if json_is_error(was_set):
return self._reply_json({'error': was_set['error']}, status_code=was_set.get('http_status', 502))
if not was_set['result']:
self._reply_json({'error': 'No such zonefile'}, status_code=404)
return
resp = blockstackd_client.get_zonefiles(blockstack_hostport, [str(zonefile_hash)])
if json_is_error(resp):
self._reply_json({'error': resp['error']}, status_code=resp.get('http_status', 502))
return
if str(zonefile_hash) not in resp['zonefiles']:
return self._reply_json({'error': 'Blockstack does not have this zonefile. Try again later.'}, status_code=404)
if raw:
self._send_headers(status_code=200, content_type='application/octet-stream')
self.wfile.write(resp['zonefiles'][str(zonefile_hash)])
else:
# make sure it's valid
if str(zonefile_hash) not in resp['zonefiles']:
log.debug('Failed to find zonefile hash {}, possess {}'.format(
str(zonefile_hash), resp['zonefiles'].keys()))
return self._reply_json({'error': 'No such zonefile'}, status_code=404)
zonefile_txt = resp['zonefiles'][str(zonefile_hash)]
res = decode_name_zonefile(name, zonefile_txt)
if res is None:
log.error("Failed to parse zone file for {}".format(name))
self._reply_json({'error': 'Non-standard zone file for {}'.format(name)}, status_code=204)
return
self._reply_json({'zonefile': zonefile_txt})
return | [
"def",
"GET_name_zonefile_by_hash",
"(",
"self",
",",
"path_info",
",",
"name",
",",
"zonefile_hash",
")",
":",
"if",
"not",
"check_name",
"(",
"name",
")",
"and",
"not",
"check_subdomain",
"(",
"name",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",
... | Get a historic zonefile for a name
With `raw=1` on the query string, return the raw zone file
Reply 200 with {'zonefile': zonefile} on success
Reply 204 with {'error': ...} if the zone file is non-standard
Reply 404 on not found
Reply 502 on failure to fetch data | [
"Get",
"a",
"historic",
"zonefile",
"for",
"a",
"name",
"With",
"raw",
"=",
"1",
"on",
"the",
"query",
"string",
"return",
"the",
"raw",
"zone",
"file"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L823-L879 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_namespaces | def GET_namespaces( self, path_info ):
"""
Get the list of all namespaces
Reply all existing namespaces
Reply 502 if we can't reach the server for whatever reason
"""
qs_values = path_info['qs_values']
offset = qs_values.get('offset', None)
count = qs_values.get('count', None)
blockstackd_url = get_blockstackd_url()
namespaces = blockstackd_client.get_all_namespaces(offset=offset, count=count, hostport=blockstackd_url)
if json_is_error(namespaces):
# error
status_code = namespaces.get('http_status', 502)
return self._reply_json({'error': namespaces['error']}, status_code=status_code)
self._reply_json(namespaces)
return | python | def GET_namespaces( self, path_info ):
"""
Get the list of all namespaces
Reply all existing namespaces
Reply 502 if we can't reach the server for whatever reason
"""
qs_values = path_info['qs_values']
offset = qs_values.get('offset', None)
count = qs_values.get('count', None)
blockstackd_url = get_blockstackd_url()
namespaces = blockstackd_client.get_all_namespaces(offset=offset, count=count, hostport=blockstackd_url)
if json_is_error(namespaces):
# error
status_code = namespaces.get('http_status', 502)
return self._reply_json({'error': namespaces['error']}, status_code=status_code)
self._reply_json(namespaces)
return | [
"def",
"GET_namespaces",
"(",
"self",
",",
"path_info",
")",
":",
"qs_values",
"=",
"path_info",
"[",
"'qs_values'",
"]",
"offset",
"=",
"qs_values",
".",
"get",
"(",
"'offset'",
",",
"None",
")",
"count",
"=",
"qs_values",
".",
"get",
"(",
"'count'",
",... | Get the list of all namespaces
Reply all existing namespaces
Reply 502 if we can't reach the server for whatever reason | [
"Get",
"the",
"list",
"of",
"all",
"namespaces",
"Reply",
"all",
"existing",
"namespaces",
"Reply",
"502",
"if",
"we",
"can",
"t",
"reach",
"the",
"server",
"for",
"whatever",
"reason"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L980-L998 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_namespace_info | def GET_namespace_info( self, path_info, namespace_id ):
"""
Look up a namespace's info
Reply information about a namespace
Reply 404 if the namespace doesn't exist
Reply 502 for any error in talking to the blocksatck server
"""
if not check_namespace(namespace_id):
return self._reply_json({'error': 'Invalid namespace'}, status_code=400)
blockstackd_url = get_blockstackd_url()
namespace_rec = blockstackd_client.get_namespace_record(namespace_id, hostport=blockstackd_url)
if json_is_error(namespace_rec):
# error
status_code = namespace_rec.get('http_status', 502)
return self._reply_json({'error': namespace_rec['error']}, status_code=status_code)
self._reply_json(namespace_rec)
return | python | def GET_namespace_info( self, path_info, namespace_id ):
"""
Look up a namespace's info
Reply information about a namespace
Reply 404 if the namespace doesn't exist
Reply 502 for any error in talking to the blocksatck server
"""
if not check_namespace(namespace_id):
return self._reply_json({'error': 'Invalid namespace'}, status_code=400)
blockstackd_url = get_blockstackd_url()
namespace_rec = blockstackd_client.get_namespace_record(namespace_id, hostport=blockstackd_url)
if json_is_error(namespace_rec):
# error
status_code = namespace_rec.get('http_status', 502)
return self._reply_json({'error': namespace_rec['error']}, status_code=status_code)
self._reply_json(namespace_rec)
return | [
"def",
"GET_namespace_info",
"(",
"self",
",",
"path_info",
",",
"namespace_id",
")",
":",
"if",
"not",
"check_namespace",
"(",
"namespace_id",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",
"{",
"'error'",
":",
"'Invalid namespace'",
"}",
",",
"status_c... | Look up a namespace's info
Reply information about a namespace
Reply 404 if the namespace doesn't exist
Reply 502 for any error in talking to the blocksatck server | [
"Look",
"up",
"a",
"namespace",
"s",
"info",
"Reply",
"information",
"about",
"a",
"namespace",
"Reply",
"404",
"if",
"the",
"namespace",
"doesn",
"t",
"exist",
"Reply",
"502",
"for",
"any",
"error",
"in",
"talking",
"to",
"the",
"blocksatck",
"server"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1001-L1019 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_namespace_num_names | def GET_namespace_num_names(self, path_info, namespace_id):
"""
Get the number of names in a namespace
Reply the number on success
Reply 404 if the namespace does not exist
Reply 502 on failure to talk to the blockstack server
"""
if not check_namespace(namespace_id):
return self._reply_json({'error': 'Invalid namespace'}, status_code=400)
blockstackd_url = get_blockstackd_url()
name_count = blockstackd_client.get_num_names_in_namespace(namespace_id, hostport=blockstackd_url)
if json_is_error(name_count):
log.error("Failed to load namespace count for {}: {}".format(namespace_id, name_count['error']))
return self._reply_json({'error': 'Failed to load namespace count: {}'.format(name_count['error'])}, status_code=404)
self._reply_json({'names_count': name_count}) | python | def GET_namespace_num_names(self, path_info, namespace_id):
"""
Get the number of names in a namespace
Reply the number on success
Reply 404 if the namespace does not exist
Reply 502 on failure to talk to the blockstack server
"""
if not check_namespace(namespace_id):
return self._reply_json({'error': 'Invalid namespace'}, status_code=400)
blockstackd_url = get_blockstackd_url()
name_count = blockstackd_client.get_num_names_in_namespace(namespace_id, hostport=blockstackd_url)
if json_is_error(name_count):
log.error("Failed to load namespace count for {}: {}".format(namespace_id, name_count['error']))
return self._reply_json({'error': 'Failed to load namespace count: {}'.format(name_count['error'])}, status_code=404)
self._reply_json({'names_count': name_count}) | [
"def",
"GET_namespace_num_names",
"(",
"self",
",",
"path_info",
",",
"namespace_id",
")",
":",
"if",
"not",
"check_namespace",
"(",
"namespace_id",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",
"{",
"'error'",
":",
"'Invalid namespace'",
"}",
",",
"sta... | Get the number of names in a namespace
Reply the number on success
Reply 404 if the namespace does not exist
Reply 502 on failure to talk to the blockstack server | [
"Get",
"the",
"number",
"of",
"names",
"in",
"a",
"namespace",
"Reply",
"the",
"number",
"on",
"success",
"Reply",
"404",
"if",
"the",
"namespace",
"does",
"not",
"exist",
"Reply",
"502",
"on",
"failure",
"to",
"talk",
"to",
"the",
"blockstack",
"server"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1022-L1038 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_namespace_names | def GET_namespace_names( self, path_info, namespace_id ):
"""
Get the list of names in a namespace
Reply the list of names in a namespace
Reply 404 if the namespace doesn't exist
Reply 502 for any error in talking to the blockstack server
"""
if not check_namespace(namespace_id):
return self._reply_json({'error': 'Invalid namespace'}, status_code=400)
qs_values = path_info['qs_values']
page = qs_values.get('page', None)
if page is None:
log.error("Page required")
return self._reply_json({'error': 'page= argument required'}, status_code=400)
try:
page = int(page)
if page < 0:
raise ValueError()
except ValueError:
log.error("Invalid page")
return self._reply_json({'error': 'Invalid page= value'}, status_code=400)
offset = page * 100
count = 100
blockstackd_url = get_blockstackd_url()
namespace_names = blockstackd_client.get_names_in_namespace(namespace_id, offset=offset, count=count, hostport=blockstackd_url)
if json_is_error(namespace_names):
# error
status_code = namespace_names.get('http_status', 502)
return self._reply_json({'error': namespace_names['error']}, status_code=status_code)
self._reply_json(namespace_names)
return | python | def GET_namespace_names( self, path_info, namespace_id ):
"""
Get the list of names in a namespace
Reply the list of names in a namespace
Reply 404 if the namespace doesn't exist
Reply 502 for any error in talking to the blockstack server
"""
if not check_namespace(namespace_id):
return self._reply_json({'error': 'Invalid namespace'}, status_code=400)
qs_values = path_info['qs_values']
page = qs_values.get('page', None)
if page is None:
log.error("Page required")
return self._reply_json({'error': 'page= argument required'}, status_code=400)
try:
page = int(page)
if page < 0:
raise ValueError()
except ValueError:
log.error("Invalid page")
return self._reply_json({'error': 'Invalid page= value'}, status_code=400)
offset = page * 100
count = 100
blockstackd_url = get_blockstackd_url()
namespace_names = blockstackd_client.get_names_in_namespace(namespace_id, offset=offset, count=count, hostport=blockstackd_url)
if json_is_error(namespace_names):
# error
status_code = namespace_names.get('http_status', 502)
return self._reply_json({'error': namespace_names['error']}, status_code=status_code)
self._reply_json(namespace_names)
return | [
"def",
"GET_namespace_names",
"(",
"self",
",",
"path_info",
",",
"namespace_id",
")",
":",
"if",
"not",
"check_namespace",
"(",
"namespace_id",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",
"{",
"'error'",
":",
"'Invalid namespace'",
"}",
",",
"status_... | Get the list of names in a namespace
Reply the list of names in a namespace
Reply 404 if the namespace doesn't exist
Reply 502 for any error in talking to the blockstack server | [
"Get",
"the",
"list",
"of",
"names",
"in",
"a",
"namespace",
"Reply",
"the",
"list",
"of",
"names",
"in",
"a",
"namespace",
"Reply",
"404",
"if",
"the",
"namespace",
"doesn",
"t",
"exist",
"Reply",
"502",
"for",
"any",
"error",
"in",
"talking",
"to",
"... | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1041-L1077 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_blockchain_ops | def GET_blockchain_ops( self, path_info, blockchain_name, blockheight ):
"""
Get the name's historic name operations
Reply the list of nameops at the given block height
Reply 404 for blockchains other than those supported
Reply 502 for any error we have in talking to the blockstack server
"""
try:
blockheight = int(blockheight)
assert check_block(blockheight)
except:
return self._reply_json({'error': 'Invalid block'}, status_code=400)
if blockchain_name != 'bitcoin':
# not supported
return self._reply_json({'error': 'Unsupported blockchain'}, status_code=404)
blockstackd_url = get_blockstackd_url()
nameops = blockstackd_client.get_blockstack_transactions_at(int(blockheight), hostport=blockstackd_url)
if json_is_error(nameops):
# error
status_code = nameops.get('http_status', 502)
return self._reply_json({'error': nameops['error']}, status_code=status_code)
self._reply_json(nameops)
return | python | def GET_blockchain_ops( self, path_info, blockchain_name, blockheight ):
"""
Get the name's historic name operations
Reply the list of nameops at the given block height
Reply 404 for blockchains other than those supported
Reply 502 for any error we have in talking to the blockstack server
"""
try:
blockheight = int(blockheight)
assert check_block(blockheight)
except:
return self._reply_json({'error': 'Invalid block'}, status_code=400)
if blockchain_name != 'bitcoin':
# not supported
return self._reply_json({'error': 'Unsupported blockchain'}, status_code=404)
blockstackd_url = get_blockstackd_url()
nameops = blockstackd_client.get_blockstack_transactions_at(int(blockheight), hostport=blockstackd_url)
if json_is_error(nameops):
# error
status_code = nameops.get('http_status', 502)
return self._reply_json({'error': nameops['error']}, status_code=status_code)
self._reply_json(nameops)
return | [
"def",
"GET_blockchain_ops",
"(",
"self",
",",
"path_info",
",",
"blockchain_name",
",",
"blockheight",
")",
":",
"try",
":",
"blockheight",
"=",
"int",
"(",
"blockheight",
")",
"assert",
"check_block",
"(",
"blockheight",
")",
"except",
":",
"return",
"self",... | Get the name's historic name operations
Reply the list of nameops at the given block height
Reply 404 for blockchains other than those supported
Reply 502 for any error we have in talking to the blockstack server | [
"Get",
"the",
"name",
"s",
"historic",
"name",
"operations",
"Reply",
"the",
"list",
"of",
"nameops",
"at",
"the",
"given",
"block",
"height",
"Reply",
"404",
"for",
"blockchains",
"other",
"than",
"those",
"supported",
"Reply",
"502",
"for",
"any",
"error",... | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1080-L1105 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler.GET_blockchain_name_record | def GET_blockchain_name_record( self, path_info, blockchain_name, name ):
"""
Get the name's blockchain record in full
Reply the raw blockchain record on success
Reply 404 if the name is not found
Reply 502 if we have an error talking to the server
"""
if not check_name(name) and not check_subdomain(name):
return self._reply_json({'error': 'Invalid name or subdomain'}, status_code=400)
if blockchain_name != 'bitcoin':
# not supported
self._reply_json({'error': 'Unsupported blockchain'}, status_code=404)
return
blockstackd_url = get_blockstackd_url()
name_rec = blockstackd_client.get_name_record(name, include_history=False, hostport=blockstackd_url)
if json_is_error(name_rec):
# error
status_code = name_rec.get('http_status', 502)
return self._reply_json({'error': name_rec['error']}, status_code=status_code)
return self._reply_json(name_rec) | python | def GET_blockchain_name_record( self, path_info, blockchain_name, name ):
"""
Get the name's blockchain record in full
Reply the raw blockchain record on success
Reply 404 if the name is not found
Reply 502 if we have an error talking to the server
"""
if not check_name(name) and not check_subdomain(name):
return self._reply_json({'error': 'Invalid name or subdomain'}, status_code=400)
if blockchain_name != 'bitcoin':
# not supported
self._reply_json({'error': 'Unsupported blockchain'}, status_code=404)
return
blockstackd_url = get_blockstackd_url()
name_rec = blockstackd_client.get_name_record(name, include_history=False, hostport=blockstackd_url)
if json_is_error(name_rec):
# error
status_code = name_rec.get('http_status', 502)
return self._reply_json({'error': name_rec['error']}, status_code=status_code)
return self._reply_json(name_rec) | [
"def",
"GET_blockchain_name_record",
"(",
"self",
",",
"path_info",
",",
"blockchain_name",
",",
"name",
")",
":",
"if",
"not",
"check_name",
"(",
"name",
")",
"and",
"not",
"check_subdomain",
"(",
"name",
")",
":",
"return",
"self",
".",
"_reply_json",
"(",... | Get the name's blockchain record in full
Reply the raw blockchain record on success
Reply 404 if the name is not found
Reply 502 if we have an error talking to the server | [
"Get",
"the",
"name",
"s",
"blockchain",
"record",
"in",
"full",
"Reply",
"the",
"raw",
"blockchain",
"record",
"on",
"success",
"Reply",
"404",
"if",
"the",
"name",
"is",
"not",
"found",
"Reply",
"502",
"if",
"we",
"have",
"an",
"error",
"talking",
"to"... | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1108-L1130 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpointHandler._get_balance | def _get_balance( self, get_address, min_confs ):
"""
Works only in test mode!
Get the confirmed balance for an address
"""
bitcoind_opts = get_bitcoin_opts()
bitcoind_host = bitcoind_opts['bitcoind_server']
bitcoind_port = bitcoind_opts['bitcoind_port']
bitcoind_user = bitcoind_opts['bitcoind_user']
bitcoind_passwd = bitcoind_opts['bitcoind_passwd']
bitcoind = create_bitcoind_service_proxy(bitcoind_user, bitcoind_passwd, server=bitcoind_host, port=bitcoind_port)
address = virtualchain.address_reencode(get_address)
try:
unspents = get_unspents(address, bitcoind)
except Exception as e:
log.exception(e)
return {'error': 'Failed to get unspents for {}'.format(get_address)}
satoshis_confirmed = sum(confirmed_utxo['value'] for confirmed_utxo in
filter(lambda utxo: utxo['confirmations'] >= min_confs, unspents))
return {'balance': satoshis_confirmed} | python | def _get_balance( self, get_address, min_confs ):
"""
Works only in test mode!
Get the confirmed balance for an address
"""
bitcoind_opts = get_bitcoin_opts()
bitcoind_host = bitcoind_opts['bitcoind_server']
bitcoind_port = bitcoind_opts['bitcoind_port']
bitcoind_user = bitcoind_opts['bitcoind_user']
bitcoind_passwd = bitcoind_opts['bitcoind_passwd']
bitcoind = create_bitcoind_service_proxy(bitcoind_user, bitcoind_passwd, server=bitcoind_host, port=bitcoind_port)
address = virtualchain.address_reencode(get_address)
try:
unspents = get_unspents(address, bitcoind)
except Exception as e:
log.exception(e)
return {'error': 'Failed to get unspents for {}'.format(get_address)}
satoshis_confirmed = sum(confirmed_utxo['value'] for confirmed_utxo in
filter(lambda utxo: utxo['confirmations'] >= min_confs, unspents))
return {'balance': satoshis_confirmed} | [
"def",
"_get_balance",
"(",
"self",
",",
"get_address",
",",
"min_confs",
")",
":",
"bitcoind_opts",
"=",
"get_bitcoin_opts",
"(",
")",
"bitcoind_host",
"=",
"bitcoind_opts",
"[",
"'bitcoind_server'",
"]",
"bitcoind_port",
"=",
"bitcoind_opts",
"[",
"'bitcoind_port'... | Works only in test mode!
Get the confirmed balance for an address | [
"Works",
"only",
"in",
"test",
"mode!",
"Get",
"the",
"confirmed",
"balance",
"for",
"an",
"address"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1210-L1233 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpoint.bind | def bind(self):
"""
Bind to our port
"""
log.debug("Set SO_REUSADDR")
self.socket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1 )
# we want daemon threads, so we join on abrupt shutdown (applies if multithreaded)
self.daemon_threads = True
self.server_bind()
self.server_activate() | python | def bind(self):
"""
Bind to our port
"""
log.debug("Set SO_REUSADDR")
self.socket.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1 )
# we want daemon threads, so we join on abrupt shutdown (applies if multithreaded)
self.daemon_threads = True
self.server_bind()
self.server_activate() | [
"def",
"bind",
"(",
"self",
")",
":",
"log",
".",
"debug",
"(",
"\"Set SO_REUSADDR\"",
")",
"self",
".",
"socket",
".",
"setsockopt",
"(",
"socket",
".",
"SOL_SOCKET",
",",
"socket",
".",
"SO_REUSEADDR",
",",
"1",
")",
"self",
".",
"daemon_threads",
"=",... | Bind to our port | [
"Bind",
"to",
"our",
"port"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1624-L1635 | train |
blockstack/blockstack-core | blockstack/lib/rpc.py | BlockstackAPIEndpoint.overloaded | def overloaded(self, client_addr):
"""
Deflect if we have too many inbound requests
"""
overloaded_txt = 'HTTP/1.0 429 Too Many Requests\r\nServer: BaseHTTP/0.3 Python/2.7.14+\r\nContent-type: text/plain\r\nContent-length: 17\r\n\r\nToo many requests'
if BLOCKSTACK_TEST:
log.warn('Too many requests; deflecting {}'.format(client_addr))
return overloaded_txt | python | def overloaded(self, client_addr):
"""
Deflect if we have too many inbound requests
"""
overloaded_txt = 'HTTP/1.0 429 Too Many Requests\r\nServer: BaseHTTP/0.3 Python/2.7.14+\r\nContent-type: text/plain\r\nContent-length: 17\r\n\r\nToo many requests'
if BLOCKSTACK_TEST:
log.warn('Too many requests; deflecting {}'.format(client_addr))
return overloaded_txt | [
"def",
"overloaded",
"(",
"self",
",",
"client_addr",
")",
":",
"overloaded_txt",
"=",
"'HTTP/1.0 429 Too Many Requests\\r\\nServer: BaseHTTP/0.3 Python/2.7.14+\\r\\nContent-type: text/plain\\r\\nContent-length: 17\\r\\n\\r\\nToo many requests'",
"if",
"BLOCKSTACK_TEST",
":",
"log",
".... | Deflect if we have too many inbound requests | [
"Deflect",
"if",
"we",
"have",
"too",
"many",
"inbound",
"requests"
] | 1dcfdd39b152d29ce13e736a6a1a0981401a0505 | https://github.com/blockstack/blockstack-core/blob/1dcfdd39b152d29ce13e736a6a1a0981401a0505/blockstack/lib/rpc.py#L1638-L1646 | train |
ansible/ansible-container | container/utils/_text.py | to_bytes | def to_bytes(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
"""Make sure that a string is a byte string
:arg obj: An object to make sure is a byte string. In most cases this
will be either a text string or a byte string. However, with
``nonstring='simplerepr'``, this can be used as a traceback-free
version of ``str(obj)``.
:kwarg encoding: The encoding to use to transform from a text string to
a byte string. Defaults to using 'utf-8'.
:kwarg errors: The error handler to use if the text string is not
encodable using the specified encoding. Any valid `codecs error
handler <https://docs.python.org/2/library/codecs.html#codec-base-classes>`_
may be specified. There are three additional error strategies
specifically aimed at helping people to port code. The first two are:
:surrogate_or_strict: Will use ``surrogateescape`` if it is a valid
handler, otherwise it will use ``strict``
:surrogate_or_replace: Will use ``surrogateescape`` if it is a valid
handler, otherwise it will use ``replace``.
Because ``surrogateescape`` was added in Python3 this usually means that
Python3 will use ``surrogateescape`` and Python2 will use the fallback
error handler. Note that the code checks for ``surrogateescape`` when the
module is imported. If you have a backport of ``surrogateescape`` for
Python2, be sure to register the error handler prior to importing this
module.
The last error handler is:
:surrogate_then_replace: Will use ``surrogateescape`` if it is a valid
handler. If encoding with ``surrogateescape`` would traceback,
surrogates are first replaced with a replacement characters
and then the string is encoded using ``replace`` (which replaces
the rest of the nonencodable bytes). If ``surrogateescape`` is
not present it will simply use ``replace``. (Added in Ansible 2.3)
This strategy is designed to never traceback when it attempts
to encode a string.
The default until Ansible-2.2 was ``surrogate_or_replace``
From Ansible-2.3 onwards, the default is ``surrogate_then_replace``.
:kwarg nonstring: The strategy to use if a nonstring is specified in
``obj``. Default is 'simplerepr'. Valid values are:
:simplerepr: The default. This takes the ``str`` of the object and
then returns the bytes version of that string.
:empty: Return an empty byte string
:passthru: Return the object passed in
:strict: Raise a :exc:`TypeError`
:returns: Typically this returns a byte string. If a nonstring object is
passed in this may be a different type depending on the strategy
specified by nonstring. This will never return a text string.
.. note:: If passed a byte string, this function does not check that the
string is valid in the specified encoding. If it's important that the
byte string is in the specified encoding do::
encoded_string = to_bytes(to_text(input_string, 'latin-1'), 'utf-8')
.. version_changed:: 2.3
Added the ``surrogate_then_replace`` error handler and made it the default error handler.
"""
if isinstance(obj, binary_type):
return obj
# We're given a text string
# If it has surrogates, we know because it will decode
original_errors = errors
if errors in _COMPOSED_ERROR_HANDLERS:
if HAS_SURROGATEESCAPE:
errors = 'surrogateescape'
elif errors == 'surrogate_or_strict':
errors = 'strict'
else:
errors = 'replace'
if isinstance(obj, text_type):
try:
# Try this first as it's the fastest
return obj.encode(encoding, errors)
except UnicodeEncodeError:
if original_errors in (None, 'surrogate_then_replace'):
# Slow but works
return_string = obj.encode('utf-8', 'surrogateescape')
return_string = return_string.decode('utf-8', 'replace')
return return_string.encode(encoding, 'replace')
raise
# Note: We do these last even though we have to call to_bytes again on the
# value because we're optimizing the common case
if nonstring == 'simplerepr':
try:
value = str(obj)
except UnicodeError:
try:
value = repr(obj)
except UnicodeError:
# Giving up
return to_bytes('')
elif nonstring == 'passthru':
return obj
elif nonstring == 'empty':
# python2.4 doesn't have b''
return to_bytes('')
elif nonstring == 'strict':
raise TypeError('obj must be a string type')
else:
raise TypeError('Invalid value %s for to_bytes\' nonstring parameter' % nonstring)
return to_bytes(value, encoding, errors) | python | def to_bytes(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
"""Make sure that a string is a byte string
:arg obj: An object to make sure is a byte string. In most cases this
will be either a text string or a byte string. However, with
``nonstring='simplerepr'``, this can be used as a traceback-free
version of ``str(obj)``.
:kwarg encoding: The encoding to use to transform from a text string to
a byte string. Defaults to using 'utf-8'.
:kwarg errors: The error handler to use if the text string is not
encodable using the specified encoding. Any valid `codecs error
handler <https://docs.python.org/2/library/codecs.html#codec-base-classes>`_
may be specified. There are three additional error strategies
specifically aimed at helping people to port code. The first two are:
:surrogate_or_strict: Will use ``surrogateescape`` if it is a valid
handler, otherwise it will use ``strict``
:surrogate_or_replace: Will use ``surrogateescape`` if it is a valid
handler, otherwise it will use ``replace``.
Because ``surrogateescape`` was added in Python3 this usually means that
Python3 will use ``surrogateescape`` and Python2 will use the fallback
error handler. Note that the code checks for ``surrogateescape`` when the
module is imported. If you have a backport of ``surrogateescape`` for
Python2, be sure to register the error handler prior to importing this
module.
The last error handler is:
:surrogate_then_replace: Will use ``surrogateescape`` if it is a valid
handler. If encoding with ``surrogateescape`` would traceback,
surrogates are first replaced with a replacement characters
and then the string is encoded using ``replace`` (which replaces
the rest of the nonencodable bytes). If ``surrogateescape`` is
not present it will simply use ``replace``. (Added in Ansible 2.3)
This strategy is designed to never traceback when it attempts
to encode a string.
The default until Ansible-2.2 was ``surrogate_or_replace``
From Ansible-2.3 onwards, the default is ``surrogate_then_replace``.
:kwarg nonstring: The strategy to use if a nonstring is specified in
``obj``. Default is 'simplerepr'. Valid values are:
:simplerepr: The default. This takes the ``str`` of the object and
then returns the bytes version of that string.
:empty: Return an empty byte string
:passthru: Return the object passed in
:strict: Raise a :exc:`TypeError`
:returns: Typically this returns a byte string. If a nonstring object is
passed in this may be a different type depending on the strategy
specified by nonstring. This will never return a text string.
.. note:: If passed a byte string, this function does not check that the
string is valid in the specified encoding. If it's important that the
byte string is in the specified encoding do::
encoded_string = to_bytes(to_text(input_string, 'latin-1'), 'utf-8')
.. version_changed:: 2.3
Added the ``surrogate_then_replace`` error handler and made it the default error handler.
"""
if isinstance(obj, binary_type):
return obj
# We're given a text string
# If it has surrogates, we know because it will decode
original_errors = errors
if errors in _COMPOSED_ERROR_HANDLERS:
if HAS_SURROGATEESCAPE:
errors = 'surrogateescape'
elif errors == 'surrogate_or_strict':
errors = 'strict'
else:
errors = 'replace'
if isinstance(obj, text_type):
try:
# Try this first as it's the fastest
return obj.encode(encoding, errors)
except UnicodeEncodeError:
if original_errors in (None, 'surrogate_then_replace'):
# Slow but works
return_string = obj.encode('utf-8', 'surrogateescape')
return_string = return_string.decode('utf-8', 'replace')
return return_string.encode(encoding, 'replace')
raise
# Note: We do these last even though we have to call to_bytes again on the
# value because we're optimizing the common case
if nonstring == 'simplerepr':
try:
value = str(obj)
except UnicodeError:
try:
value = repr(obj)
except UnicodeError:
# Giving up
return to_bytes('')
elif nonstring == 'passthru':
return obj
elif nonstring == 'empty':
# python2.4 doesn't have b''
return to_bytes('')
elif nonstring == 'strict':
raise TypeError('obj must be a string type')
else:
raise TypeError('Invalid value %s for to_bytes\' nonstring parameter' % nonstring)
return to_bytes(value, encoding, errors) | [
"def",
"to_bytes",
"(",
"obj",
",",
"encoding",
"=",
"'utf-8'",
",",
"errors",
"=",
"None",
",",
"nonstring",
"=",
"'simplerepr'",
")",
":",
"if",
"isinstance",
"(",
"obj",
",",
"binary_type",
")",
":",
"return",
"obj",
"original_errors",
"=",
"errors",
... | Make sure that a string is a byte string
:arg obj: An object to make sure is a byte string. In most cases this
will be either a text string or a byte string. However, with
``nonstring='simplerepr'``, this can be used as a traceback-free
version of ``str(obj)``.
:kwarg encoding: The encoding to use to transform from a text string to
a byte string. Defaults to using 'utf-8'.
:kwarg errors: The error handler to use if the text string is not
encodable using the specified encoding. Any valid `codecs error
handler <https://docs.python.org/2/library/codecs.html#codec-base-classes>`_
may be specified. There are three additional error strategies
specifically aimed at helping people to port code. The first two are:
:surrogate_or_strict: Will use ``surrogateescape`` if it is a valid
handler, otherwise it will use ``strict``
:surrogate_or_replace: Will use ``surrogateescape`` if it is a valid
handler, otherwise it will use ``replace``.
Because ``surrogateescape`` was added in Python3 this usually means that
Python3 will use ``surrogateescape`` and Python2 will use the fallback
error handler. Note that the code checks for ``surrogateescape`` when the
module is imported. If you have a backport of ``surrogateescape`` for
Python2, be sure to register the error handler prior to importing this
module.
The last error handler is:
:surrogate_then_replace: Will use ``surrogateescape`` if it is a valid
handler. If encoding with ``surrogateescape`` would traceback,
surrogates are first replaced with a replacement characters
and then the string is encoded using ``replace`` (which replaces
the rest of the nonencodable bytes). If ``surrogateescape`` is
not present it will simply use ``replace``. (Added in Ansible 2.3)
This strategy is designed to never traceback when it attempts
to encode a string.
The default until Ansible-2.2 was ``surrogate_or_replace``
From Ansible-2.3 onwards, the default is ``surrogate_then_replace``.
:kwarg nonstring: The strategy to use if a nonstring is specified in
``obj``. Default is 'simplerepr'. Valid values are:
:simplerepr: The default. This takes the ``str`` of the object and
then returns the bytes version of that string.
:empty: Return an empty byte string
:passthru: Return the object passed in
:strict: Raise a :exc:`TypeError`
:returns: Typically this returns a byte string. If a nonstring object is
passed in this may be a different type depending on the strategy
specified by nonstring. This will never return a text string.
.. note:: If passed a byte string, this function does not check that the
string is valid in the specified encoding. If it's important that the
byte string is in the specified encoding do::
encoded_string = to_bytes(to_text(input_string, 'latin-1'), 'utf-8')
.. version_changed:: 2.3
Added the ``surrogate_then_replace`` error handler and made it the default error handler. | [
"Make",
"sure",
"that",
"a",
"string",
"is",
"a",
"byte",
"string"
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/utils/_text.py#L52-L163 | train |
ansible/ansible-container | container/utils/_text.py | to_text | def to_text(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
"""Make sure that a string is a text string
:arg obj: An object to make sure is a text string. In most cases this
will be either a text string or a byte string. However, with
``nonstring='simplerepr'``, this can be used as a traceback-free
version of ``str(obj)``.
:kwarg encoding: The encoding to use to transform from a byte string to
a text string. Defaults to using 'utf-8'.
:kwarg errors: The error handler to use if the byte string is not
decodable using the specified encoding. Any valid `codecs error
handler <https://docs.python.org/2/library/codecs.html#codec-base-classes>`_
may be specified. We support three additional error strategies
specifically aimed at helping people to port code:
:surrogate_or_strict: Will use surrogateescape if it is a valid
handler, otherwise it will use strict
:surrogate_or_replace: Will use surrogateescape if it is a valid
handler, otherwise it will use replace.
:surrogate_then_replace: Does the same as surrogate_or_replace but
`was added for symmetry with the error handlers in
:func:`ansible.module_utils._text.to_bytes` (Added in Ansible 2.3)
Because surrogateescape was added in Python3 this usually means that
Python3 will use `surrogateescape` and Python2 will use the fallback
error handler. Note that the code checks for surrogateescape when the
module is imported. If you have a backport of `surrogateescape` for
python2, be sure to register the error handler prior to importing this
module.
The default until Ansible-2.2 was `surrogate_or_replace`
In Ansible-2.3 this defaults to `surrogate_then_replace` for symmetry
with :func:`ansible.module_utils._text.to_bytes` .
:kwarg nonstring: The strategy to use if a nonstring is specified in
``obj``. Default is 'simplerepr'. Valid values are:
:simplerepr: The default. This takes the ``str`` of the object and
then returns the text version of that string.
:empty: Return an empty text string
:passthru: Return the object passed in
:strict: Raise a :exc:`TypeError`
:returns: Typically this returns a text string. If a nonstring object is
passed in this may be a different type depending on the strategy
specified by nonstring. This will never return a byte string.
From Ansible-2.3 onwards, the default is `surrogate_then_replace`.
.. version_changed:: 2.3
Added the surrogate_then_replace error handler and made it the default error handler.
"""
if isinstance(obj, text_type):
return obj
if errors in _COMPOSED_ERROR_HANDLERS:
if HAS_SURROGATEESCAPE:
errors = 'surrogateescape'
elif errors == 'surrogate_or_strict':
errors = 'strict'
else:
errors = 'replace'
if isinstance(obj, binary_type):
# Note: We don't need special handling for surrogate_then_replace
# because all bytes will either be made into surrogates or are valid
# to decode.
return obj.decode(encoding, errors)
# Note: We do these last even though we have to call to_text again on the
# value because we're optimizing the common case
if nonstring == 'simplerepr':
try:
value = str(obj)
except UnicodeError:
try:
value = repr(obj)
except UnicodeError:
# Giving up
return u''
elif nonstring == 'passthru':
return obj
elif nonstring == 'empty':
return u''
elif nonstring == 'strict':
raise TypeError('obj must be a string type')
else:
raise TypeError('Invalid value %s for to_text\'s nonstring parameter' % nonstring)
return to_text(value, encoding, errors) | python | def to_text(obj, encoding='utf-8', errors=None, nonstring='simplerepr'):
"""Make sure that a string is a text string
:arg obj: An object to make sure is a text string. In most cases this
will be either a text string or a byte string. However, with
``nonstring='simplerepr'``, this can be used as a traceback-free
version of ``str(obj)``.
:kwarg encoding: The encoding to use to transform from a byte string to
a text string. Defaults to using 'utf-8'.
:kwarg errors: The error handler to use if the byte string is not
decodable using the specified encoding. Any valid `codecs error
handler <https://docs.python.org/2/library/codecs.html#codec-base-classes>`_
may be specified. We support three additional error strategies
specifically aimed at helping people to port code:
:surrogate_or_strict: Will use surrogateescape if it is a valid
handler, otherwise it will use strict
:surrogate_or_replace: Will use surrogateescape if it is a valid
handler, otherwise it will use replace.
:surrogate_then_replace: Does the same as surrogate_or_replace but
`was added for symmetry with the error handlers in
:func:`ansible.module_utils._text.to_bytes` (Added in Ansible 2.3)
Because surrogateescape was added in Python3 this usually means that
Python3 will use `surrogateescape` and Python2 will use the fallback
error handler. Note that the code checks for surrogateescape when the
module is imported. If you have a backport of `surrogateescape` for
python2, be sure to register the error handler prior to importing this
module.
The default until Ansible-2.2 was `surrogate_or_replace`
In Ansible-2.3 this defaults to `surrogate_then_replace` for symmetry
with :func:`ansible.module_utils._text.to_bytes` .
:kwarg nonstring: The strategy to use if a nonstring is specified in
``obj``. Default is 'simplerepr'. Valid values are:
:simplerepr: The default. This takes the ``str`` of the object and
then returns the text version of that string.
:empty: Return an empty text string
:passthru: Return the object passed in
:strict: Raise a :exc:`TypeError`
:returns: Typically this returns a text string. If a nonstring object is
passed in this may be a different type depending on the strategy
specified by nonstring. This will never return a byte string.
From Ansible-2.3 onwards, the default is `surrogate_then_replace`.
.. version_changed:: 2.3
Added the surrogate_then_replace error handler and made it the default error handler.
"""
if isinstance(obj, text_type):
return obj
if errors in _COMPOSED_ERROR_HANDLERS:
if HAS_SURROGATEESCAPE:
errors = 'surrogateescape'
elif errors == 'surrogate_or_strict':
errors = 'strict'
else:
errors = 'replace'
if isinstance(obj, binary_type):
# Note: We don't need special handling for surrogate_then_replace
# because all bytes will either be made into surrogates or are valid
# to decode.
return obj.decode(encoding, errors)
# Note: We do these last even though we have to call to_text again on the
# value because we're optimizing the common case
if nonstring == 'simplerepr':
try:
value = str(obj)
except UnicodeError:
try:
value = repr(obj)
except UnicodeError:
# Giving up
return u''
elif nonstring == 'passthru':
return obj
elif nonstring == 'empty':
return u''
elif nonstring == 'strict':
raise TypeError('obj must be a string type')
else:
raise TypeError('Invalid value %s for to_text\'s nonstring parameter' % nonstring)
return to_text(value, encoding, errors) | [
"def",
"to_text",
"(",
"obj",
",",
"encoding",
"=",
"'utf-8'",
",",
"errors",
"=",
"None",
",",
"nonstring",
"=",
"'simplerepr'",
")",
":",
"if",
"isinstance",
"(",
"obj",
",",
"text_type",
")",
":",
"return",
"obj",
"if",
"errors",
"in",
"_COMPOSED_ERRO... | Make sure that a string is a text string
:arg obj: An object to make sure is a text string. In most cases this
will be either a text string or a byte string. However, with
``nonstring='simplerepr'``, this can be used as a traceback-free
version of ``str(obj)``.
:kwarg encoding: The encoding to use to transform from a byte string to
a text string. Defaults to using 'utf-8'.
:kwarg errors: The error handler to use if the byte string is not
decodable using the specified encoding. Any valid `codecs error
handler <https://docs.python.org/2/library/codecs.html#codec-base-classes>`_
may be specified. We support three additional error strategies
specifically aimed at helping people to port code:
:surrogate_or_strict: Will use surrogateescape if it is a valid
handler, otherwise it will use strict
:surrogate_or_replace: Will use surrogateescape if it is a valid
handler, otherwise it will use replace.
:surrogate_then_replace: Does the same as surrogate_or_replace but
`was added for symmetry with the error handlers in
:func:`ansible.module_utils._text.to_bytes` (Added in Ansible 2.3)
Because surrogateescape was added in Python3 this usually means that
Python3 will use `surrogateescape` and Python2 will use the fallback
error handler. Note that the code checks for surrogateescape when the
module is imported. If you have a backport of `surrogateescape` for
python2, be sure to register the error handler prior to importing this
module.
The default until Ansible-2.2 was `surrogate_or_replace`
In Ansible-2.3 this defaults to `surrogate_then_replace` for symmetry
with :func:`ansible.module_utils._text.to_bytes` .
:kwarg nonstring: The strategy to use if a nonstring is specified in
``obj``. Default is 'simplerepr'. Valid values are:
:simplerepr: The default. This takes the ``str`` of the object and
then returns the text version of that string.
:empty: Return an empty text string
:passthru: Return the object passed in
:strict: Raise a :exc:`TypeError`
:returns: Typically this returns a text string. If a nonstring object is
passed in this may be a different type depending on the strategy
specified by nonstring. This will never return a byte string.
From Ansible-2.3 onwards, the default is `surrogate_then_replace`.
.. version_changed:: 2.3
Added the surrogate_then_replace error handler and made it the default error handler. | [
"Make",
"sure",
"that",
"a",
"string",
"is",
"a",
"text",
"string"
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/utils/_text.py#L166-L254 | train |
ansible/ansible-container | container/core.py | push_images | def push_images(base_path, image_namespace, engine_obj, config, **kwargs):
""" Pushes images to a Docker registry. Returns dict containing attributes used to push images. """
config_path = kwargs.get('config_path', engine_obj.auth_config_path)
username = kwargs.get('username')
password = kwargs.get('password')
push_to = kwargs.get('push_to')
url = engine_obj.default_registry_url
registry_name = engine_obj.default_registry_name
namespace = image_namespace
save_conductor = config.save_conductor
repository_prefix = None
pull_from_url = None
if push_to:
if config.get('registries', dict()).get(push_to):
url = config['registries'][push_to].get('url')
namespace = config['registries'][push_to].get('namespace', namespace)
repository_prefix = config['registries'][push_to].get('repository_prefix')
pull_from_url = config['registries'][push_to].get('pull_from_url')
if not url:
raise AnsibleContainerRegistryAttributeException(
u"Registry {} missing required attribute 'url'".format(push_to)
)
else:
url, namespace = resolve_push_to(push_to, engine_obj.default_registry_url, namespace)
if username and not password:
# If a username was supplied without a password, prompt for it
if url != engine_obj.default_registry_url:
registry_name = url
while not password:
password = getpass.getpass(u"Enter password for {0} at {1}: ".format(username, registry_name))
if config_path:
# Make sure the config_path exists
# - gives us a chance to create the file with correct permissions, if it does not exists
# - makes sure we mount a path to the conductor for a specific file
config_path = os.path.normpath(os.path.expanduser(config_path))
if os.path.exists(config_path) and os.path.isdir(config_path):
raise AnsibleContainerException(
u"Expecting --config-path to be a path to a file, not a directory"
)
elif not os.path.exists(config_path):
# Make sure the directory path exists
if not os.path.exists(os.path.dirname(config_path)):
try:
os.makedirs(os.path.dirname(config_path), 0o750)
except OSError:
raise AnsibleContainerException(
u"Failed to create the requested the path {}".format(os.path.dirname(config_path))
)
# Touch the file
open(config_path, 'w').close()
# If you ran build with --save-build-container, then you're broken without first removing
# the old build container.
remove_existing_container(engine_obj, 'conductor', remove_volumes=True)
push_params = {}
push_params.update(kwargs)
push_params['config_path'] = config_path
push_params['password'] = password
push_params['url'] = url
push_params['namespace'] = namespace
push_params['repository_prefix'] = repository_prefix
push_params['pull_from_url'] = pull_from_url
# Push
engine_obj.await_conductor_command('push', dict(config), base_path, push_params, save_container=save_conductor)
return {'url': url,
'namespace': namespace,
'repository_prefix': repository_prefix,
'pull_from_url': pull_from_url } | python | def push_images(base_path, image_namespace, engine_obj, config, **kwargs):
""" Pushes images to a Docker registry. Returns dict containing attributes used to push images. """
config_path = kwargs.get('config_path', engine_obj.auth_config_path)
username = kwargs.get('username')
password = kwargs.get('password')
push_to = kwargs.get('push_to')
url = engine_obj.default_registry_url
registry_name = engine_obj.default_registry_name
namespace = image_namespace
save_conductor = config.save_conductor
repository_prefix = None
pull_from_url = None
if push_to:
if config.get('registries', dict()).get(push_to):
url = config['registries'][push_to].get('url')
namespace = config['registries'][push_to].get('namespace', namespace)
repository_prefix = config['registries'][push_to].get('repository_prefix')
pull_from_url = config['registries'][push_to].get('pull_from_url')
if not url:
raise AnsibleContainerRegistryAttributeException(
u"Registry {} missing required attribute 'url'".format(push_to)
)
else:
url, namespace = resolve_push_to(push_to, engine_obj.default_registry_url, namespace)
if username and not password:
# If a username was supplied without a password, prompt for it
if url != engine_obj.default_registry_url:
registry_name = url
while not password:
password = getpass.getpass(u"Enter password for {0} at {1}: ".format(username, registry_name))
if config_path:
# Make sure the config_path exists
# - gives us a chance to create the file with correct permissions, if it does not exists
# - makes sure we mount a path to the conductor for a specific file
config_path = os.path.normpath(os.path.expanduser(config_path))
if os.path.exists(config_path) and os.path.isdir(config_path):
raise AnsibleContainerException(
u"Expecting --config-path to be a path to a file, not a directory"
)
elif not os.path.exists(config_path):
# Make sure the directory path exists
if not os.path.exists(os.path.dirname(config_path)):
try:
os.makedirs(os.path.dirname(config_path), 0o750)
except OSError:
raise AnsibleContainerException(
u"Failed to create the requested the path {}".format(os.path.dirname(config_path))
)
# Touch the file
open(config_path, 'w').close()
# If you ran build with --save-build-container, then you're broken without first removing
# the old build container.
remove_existing_container(engine_obj, 'conductor', remove_volumes=True)
push_params = {}
push_params.update(kwargs)
push_params['config_path'] = config_path
push_params['password'] = password
push_params['url'] = url
push_params['namespace'] = namespace
push_params['repository_prefix'] = repository_prefix
push_params['pull_from_url'] = pull_from_url
# Push
engine_obj.await_conductor_command('push', dict(config), base_path, push_params, save_container=save_conductor)
return {'url': url,
'namespace': namespace,
'repository_prefix': repository_prefix,
'pull_from_url': pull_from_url } | [
"def",
"push_images",
"(",
"base_path",
",",
"image_namespace",
",",
"engine_obj",
",",
"config",
",",
"**",
"kwargs",
")",
":",
"config_path",
"=",
"kwargs",
".",
"get",
"(",
"'config_path'",
",",
"engine_obj",
".",
"auth_config_path",
")",
"username",
"=",
... | Pushes images to a Docker registry. Returns dict containing attributes used to push images. | [
"Pushes",
"images",
"to",
"a",
"Docker",
"registry",
".",
"Returns",
"dict",
"containing",
"attributes",
"used",
"to",
"push",
"images",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/core.py#L394-L467 | train |
ansible/ansible-container | container/core.py | remove_existing_container | def remove_existing_container(engine_obj, service_name, remove_volumes=False):
"""
Remove a container for an existing service. Handy for removing an existing conductor.
"""
conductor_container_id = engine_obj.get_container_id_for_service(service_name)
if engine_obj.service_is_running(service_name):
engine_obj.stop_container(conductor_container_id, forcefully=True)
if conductor_container_id:
engine_obj.delete_container(conductor_container_id, remove_volumes=remove_volumes) | python | def remove_existing_container(engine_obj, service_name, remove_volumes=False):
"""
Remove a container for an existing service. Handy for removing an existing conductor.
"""
conductor_container_id = engine_obj.get_container_id_for_service(service_name)
if engine_obj.service_is_running(service_name):
engine_obj.stop_container(conductor_container_id, forcefully=True)
if conductor_container_id:
engine_obj.delete_container(conductor_container_id, remove_volumes=remove_volumes) | [
"def",
"remove_existing_container",
"(",
"engine_obj",
",",
"service_name",
",",
"remove_volumes",
"=",
"False",
")",
":",
"conductor_container_id",
"=",
"engine_obj",
".",
"get_container_id_for_service",
"(",
"service_name",
")",
"if",
"engine_obj",
".",
"service_is_ru... | Remove a container for an existing service. Handy for removing an existing conductor. | [
"Remove",
"a",
"container",
"for",
"an",
"existing",
"service",
".",
"Handy",
"for",
"removing",
"an",
"existing",
"conductor",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/core.py#L510-L518 | train |
ansible/ansible-container | container/core.py | resolve_push_to | def resolve_push_to(push_to, default_url, default_namespace):
'''
Given a push-to value, return the registry and namespace.
:param push_to: string: User supplied --push-to value.
:param default_url: string: Container engine's default_index value (e.g. docker.io).
:return: tuple: registry_url, namespace
'''
protocol = 'http://' if push_to.startswith('http://') else 'https://'
url = push_to = REMOVE_HTTP.sub('', push_to)
namespace = default_namespace
parts = url.split('/', 1)
special_set = {'.', ':'}
char_set = set([c for c in parts[0]])
if len(parts) == 1:
if not special_set.intersection(char_set) and parts[0] != 'localhost':
registry_url = default_url
namespace = push_to
else:
registry_url = protocol + parts[0]
else:
registry_url = protocol + parts[0]
namespace = parts[1]
return registry_url, namespace | python | def resolve_push_to(push_to, default_url, default_namespace):
'''
Given a push-to value, return the registry and namespace.
:param push_to: string: User supplied --push-to value.
:param default_url: string: Container engine's default_index value (e.g. docker.io).
:return: tuple: registry_url, namespace
'''
protocol = 'http://' if push_to.startswith('http://') else 'https://'
url = push_to = REMOVE_HTTP.sub('', push_to)
namespace = default_namespace
parts = url.split('/', 1)
special_set = {'.', ':'}
char_set = set([c for c in parts[0]])
if len(parts) == 1:
if not special_set.intersection(char_set) and parts[0] != 'localhost':
registry_url = default_url
namespace = push_to
else:
registry_url = protocol + parts[0]
else:
registry_url = protocol + parts[0]
namespace = parts[1]
return registry_url, namespace | [
"def",
"resolve_push_to",
"(",
"push_to",
",",
"default_url",
",",
"default_namespace",
")",
":",
"protocol",
"=",
"'http://'",
"if",
"push_to",
".",
"startswith",
"(",
"'http://'",
")",
"else",
"'https://'",
"url",
"=",
"push_to",
"=",
"REMOVE_HTTP",
".",
"su... | Given a push-to value, return the registry and namespace.
:param push_to: string: User supplied --push-to value.
:param default_url: string: Container engine's default_index value (e.g. docker.io).
:return: tuple: registry_url, namespace | [
"Given",
"a",
"push",
"-",
"to",
"value",
"return",
"the",
"registry",
"and",
"namespace",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/core.py#L522-L546 | train |
ansible/ansible-container | container/core.py | conductorcmd_push | def conductorcmd_push(engine_name, project_name, services, **kwargs):
""" Push images to a registry """
username = kwargs.pop('username')
password = kwargs.pop('password')
email = kwargs.pop('email')
url = kwargs.pop('url')
namespace = kwargs.pop('namespace')
tag = kwargs.pop('tag')
config_path = kwargs.pop('config_path')
repository_prefix =kwargs.pop('repository_prefix')
engine = load_engine(['PUSH', 'LOGIN'], engine_name, project_name, services)
logger.info(u'Engine integration loaded. Preparing push.',
engine=engine.display_name)
# Verify that we can authenticate with the registry
username, password = engine.login(username, password, email, url, config_path)
# Push each image that has been built using Ansible roles
for name, service in iteritems(services):
if service.get('containers'):
for c in service['containers']:
if 'roles' in c:
cname = '%s-%s' % (name, c['container_name'])
image_id = engine.get_latest_image_id_for_service(cname)
engine.push(image_id, cname, url=url, tag=tag, namespace=namespace, username=username,
password=password, repository_prefix=repository_prefix)
elif 'roles' in service:
# if the service has roles, it's an image we should push
image_id = engine.get_latest_image_id_for_service(name)
engine.push(image_id, name, url=url, tag=tag, namespace=namespace, username=username,
password=password, repository_prefix=repository_prefix) | python | def conductorcmd_push(engine_name, project_name, services, **kwargs):
""" Push images to a registry """
username = kwargs.pop('username')
password = kwargs.pop('password')
email = kwargs.pop('email')
url = kwargs.pop('url')
namespace = kwargs.pop('namespace')
tag = kwargs.pop('tag')
config_path = kwargs.pop('config_path')
repository_prefix =kwargs.pop('repository_prefix')
engine = load_engine(['PUSH', 'LOGIN'], engine_name, project_name, services)
logger.info(u'Engine integration loaded. Preparing push.',
engine=engine.display_name)
# Verify that we can authenticate with the registry
username, password = engine.login(username, password, email, url, config_path)
# Push each image that has been built using Ansible roles
for name, service in iteritems(services):
if service.get('containers'):
for c in service['containers']:
if 'roles' in c:
cname = '%s-%s' % (name, c['container_name'])
image_id = engine.get_latest_image_id_for_service(cname)
engine.push(image_id, cname, url=url, tag=tag, namespace=namespace, username=username,
password=password, repository_prefix=repository_prefix)
elif 'roles' in service:
# if the service has roles, it's an image we should push
image_id = engine.get_latest_image_id_for_service(name)
engine.push(image_id, name, url=url, tag=tag, namespace=namespace, username=username,
password=password, repository_prefix=repository_prefix) | [
"def",
"conductorcmd_push",
"(",
"engine_name",
",",
"project_name",
",",
"services",
",",
"**",
"kwargs",
")",
":",
"username",
"=",
"kwargs",
".",
"pop",
"(",
"'username'",
")",
"password",
"=",
"kwargs",
".",
"pop",
"(",
"'password'",
")",
"email",
"=",... | Push images to a registry | [
"Push",
"images",
"to",
"a",
"registry"
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/core.py#L1038-L1069 | train |
ansible/ansible-container | container/openshift/deploy.py | Deploy.get_route_templates | def get_route_templates(self):
"""
Generate Openshift route templates or playbook tasks. Each port on a service definition found in container.yml
represents an externally exposed port.
"""
def _get_published_ports(service_config):
result = []
for port in service_config.get('ports', []):
protocol = 'TCP'
if isinstance(port, string_types) and '/' in port:
port, protocol = port.split('/')
if isinstance(port, string_types) and ':' in port:
host, container = port.split(':')
else:
host = port
result.append({'port': host, 'protocol': protocol.lower()})
return result
templates = []
for name, service_config in self._services.items():
state = service_config.get(self.CONFIG_KEY, {}).get('state', 'present')
force = service_config.get(self.CONFIG_KEY, {}).get('force', False)
published_ports = _get_published_ports(service_config)
if state != 'present':
continue
for port in published_ports:
route_name = "%s-%s" % (name, port['port'])
labels = dict(
app=self._namespace_name,
service=name
)
template = CommentedMap()
template['apiVersion'] = self.DEFAULT_API_VERSION
template['kind'] = 'Route'
template['force'] = force
template['metadata'] = CommentedMap([
('name', route_name),
('namespace', self._namespace_name),
('labels', labels.copy())
])
template['spec'] = CommentedMap([
('to', CommentedMap([
('kind', 'Service'),
('name', name)
])),
('port', CommentedMap([
('targetPort', 'port-{}-{}'.format(port['port'], port['protocol']))
]))
])
if service_config.get(self.CONFIG_KEY, {}).get('routes'):
for route in service_config[self.CONFIG_KEY]['routes']:
if str(route.get('port')) == str(port['port']):
for key, value in route.items():
if key not in ('force', 'port'):
self.copy_attribute(template['spec'], key, value)
templates.append(template)
return templates | python | def get_route_templates(self):
"""
Generate Openshift route templates or playbook tasks. Each port on a service definition found in container.yml
represents an externally exposed port.
"""
def _get_published_ports(service_config):
result = []
for port in service_config.get('ports', []):
protocol = 'TCP'
if isinstance(port, string_types) and '/' in port:
port, protocol = port.split('/')
if isinstance(port, string_types) and ':' in port:
host, container = port.split(':')
else:
host = port
result.append({'port': host, 'protocol': protocol.lower()})
return result
templates = []
for name, service_config in self._services.items():
state = service_config.get(self.CONFIG_KEY, {}).get('state', 'present')
force = service_config.get(self.CONFIG_KEY, {}).get('force', False)
published_ports = _get_published_ports(service_config)
if state != 'present':
continue
for port in published_ports:
route_name = "%s-%s" % (name, port['port'])
labels = dict(
app=self._namespace_name,
service=name
)
template = CommentedMap()
template['apiVersion'] = self.DEFAULT_API_VERSION
template['kind'] = 'Route'
template['force'] = force
template['metadata'] = CommentedMap([
('name', route_name),
('namespace', self._namespace_name),
('labels', labels.copy())
])
template['spec'] = CommentedMap([
('to', CommentedMap([
('kind', 'Service'),
('name', name)
])),
('port', CommentedMap([
('targetPort', 'port-{}-{}'.format(port['port'], port['protocol']))
]))
])
if service_config.get(self.CONFIG_KEY, {}).get('routes'):
for route in service_config[self.CONFIG_KEY]['routes']:
if str(route.get('port')) == str(port['port']):
for key, value in route.items():
if key not in ('force', 'port'):
self.copy_attribute(template['spec'], key, value)
templates.append(template)
return templates | [
"def",
"get_route_templates",
"(",
"self",
")",
":",
"def",
"_get_published_ports",
"(",
"service_config",
")",
":",
"result",
"=",
"[",
"]",
"for",
"port",
"in",
"service_config",
".",
"get",
"(",
"'ports'",
",",
"[",
"]",
")",
":",
"protocol",
"=",
"'T... | Generate Openshift route templates or playbook tasks. Each port on a service definition found in container.yml
represents an externally exposed port. | [
"Generate",
"Openshift",
"route",
"templates",
"or",
"playbook",
"tasks",
".",
"Each",
"port",
"on",
"a",
"service",
"definition",
"found",
"in",
"container",
".",
"yml",
"represents",
"an",
"externally",
"exposed",
"port",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/openshift/deploy.py#L56-L117 | train |
ansible/ansible-container | container/docker/importer.py | DockerfileParser.preparse_iter | def preparse_iter(self):
"""
Comments can be anywhere. So break apart the Dockerfile into significant
lines and any comments that precede them. And if a line is a carryover
from the previous via an escaped-newline, bring the directive with it.
"""
to_yield = {}
last_directive = None
lines_processed = 0
for line in self.lines_iter():
if not line:
continue
if line.startswith(u'#'):
comment = line.lstrip('#').strip()
# Directives have to precede any instructions
if lines_processed == 1:
if comment.startswith(u'escape='):
self.escape_char = comment.split(u'=', 1)[1]
continue
to_yield.setdefault('comments', []).append(comment)
else:
# last_directive being set means the previous line ended with a
# newline escape
if last_directive:
directive, payload = last_directive, line
else:
directive, payload = line.split(u' ', 1)
if line.endswith(self.escape_char):
payload = payload.rstrip(self.escape_char)
last_directive = directive
else:
last_directive = None
to_yield['directive'] = directive
to_yield['payload'] = payload.strip()
yield to_yield
to_yield = {} | python | def preparse_iter(self):
"""
Comments can be anywhere. So break apart the Dockerfile into significant
lines and any comments that precede them. And if a line is a carryover
from the previous via an escaped-newline, bring the directive with it.
"""
to_yield = {}
last_directive = None
lines_processed = 0
for line in self.lines_iter():
if not line:
continue
if line.startswith(u'#'):
comment = line.lstrip('#').strip()
# Directives have to precede any instructions
if lines_processed == 1:
if comment.startswith(u'escape='):
self.escape_char = comment.split(u'=', 1)[1]
continue
to_yield.setdefault('comments', []).append(comment)
else:
# last_directive being set means the previous line ended with a
# newline escape
if last_directive:
directive, payload = last_directive, line
else:
directive, payload = line.split(u' ', 1)
if line.endswith(self.escape_char):
payload = payload.rstrip(self.escape_char)
last_directive = directive
else:
last_directive = None
to_yield['directive'] = directive
to_yield['payload'] = payload.strip()
yield to_yield
to_yield = {} | [
"def",
"preparse_iter",
"(",
"self",
")",
":",
"to_yield",
"=",
"{",
"}",
"last_directive",
"=",
"None",
"lines_processed",
"=",
"0",
"for",
"line",
"in",
"self",
".",
"lines_iter",
"(",
")",
":",
"if",
"not",
"line",
":",
"continue",
"if",
"line",
"."... | Comments can be anywhere. So break apart the Dockerfile into significant
lines and any comments that precede them. And if a line is a carryover
from the previous via an escaped-newline, bring the directive with it. | [
"Comments",
"can",
"be",
"anywhere",
".",
"So",
"break",
"apart",
"the",
"Dockerfile",
"into",
"significant",
"lines",
"and",
"any",
"comments",
"that",
"precede",
"them",
".",
"And",
"if",
"a",
"line",
"is",
"a",
"carryover",
"from",
"the",
"previous",
"v... | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/docker/importer.py#L120-L155 | train |
ansible/ansible-container | container/docker/engine.py | Engine.run_container | def run_container(self, image_id, service_name, **kwargs):
"""Run a particular container. The kwargs argument contains individual
parameter overrides from the service definition."""
run_kwargs = self.run_kwargs_for_service(service_name)
run_kwargs.update(kwargs, relax=True)
logger.debug('Running container in docker', image=image_id, params=run_kwargs)
container_obj = self.client.containers.run(
image=image_id,
detach=True,
**run_kwargs
)
log_iter = container_obj.logs(stdout=True, stderr=True, stream=True)
mux = logmux.LogMultiplexer()
mux.add_iterator(log_iter, plainLogger)
return container_obj.id | python | def run_container(self, image_id, service_name, **kwargs):
"""Run a particular container. The kwargs argument contains individual
parameter overrides from the service definition."""
run_kwargs = self.run_kwargs_for_service(service_name)
run_kwargs.update(kwargs, relax=True)
logger.debug('Running container in docker', image=image_id, params=run_kwargs)
container_obj = self.client.containers.run(
image=image_id,
detach=True,
**run_kwargs
)
log_iter = container_obj.logs(stdout=True, stderr=True, stream=True)
mux = logmux.LogMultiplexer()
mux.add_iterator(log_iter, plainLogger)
return container_obj.id | [
"def",
"run_container",
"(",
"self",
",",
"image_id",
",",
"service_name",
",",
"**",
"kwargs",
")",
":",
"run_kwargs",
"=",
"self",
".",
"run_kwargs_for_service",
"(",
"service_name",
")",
"run_kwargs",
".",
"update",
"(",
"kwargs",
",",
"relax",
"=",
"True... | Run a particular container. The kwargs argument contains individual
parameter overrides from the service definition. | [
"Run",
"a",
"particular",
"container",
".",
"The",
"kwargs",
"argument",
"contains",
"individual",
"parameter",
"overrides",
"from",
"the",
"service",
"definition",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/docker/engine.py#L265-L281 | train |
ansible/ansible-container | container/docker/engine.py | Engine.push | def push(self, image_id, service_name, tag=None, namespace=None, url=None, username=None, password=None,
repository_prefix=None, **kwargs):
"""
Push an image to a remote registry.
"""
auth_config = {
'username': username,
'password': password
}
build_stamp = self.get_build_stamp_for_image(image_id)
tag = tag or build_stamp
if repository_prefix:
image_name = "{}-{}".format(repository_prefix, service_name)
elif repository_prefix is None:
image_name = "{}-{}".format(self.project_name, service_name)
elif repository_prefix == '':
image_name = service_name
repository = "{}/{}".format(namespace, image_name)
if url != self.default_registry_url:
url = REMOVE_HTTP.sub('', url)
repository = "%s/%s" % (url.rstrip('/'), repository)
logger.info('Tagging %s' % repository)
self.client.api.tag(image_id, repository, tag=tag)
logger.info('Pushing %s:%s...' % (repository, tag))
stream = self.client.api.push(repository, tag=tag, stream=True, auth_config=auth_config)
last_status = None
for data in stream:
data = data.splitlines()
for line in data:
line = json.loads(line)
if type(line) is dict and 'error' in line:
plainLogger.error(line['error'])
raise exceptions.AnsibleContainerException(
"Failed to push image. {}".format(line['error'])
)
elif type(line) is dict and 'status' in line:
if line['status'] != last_status:
plainLogger.info(line['status'])
last_status = line['status']
else:
plainLogger.debug(line) | python | def push(self, image_id, service_name, tag=None, namespace=None, url=None, username=None, password=None,
repository_prefix=None, **kwargs):
"""
Push an image to a remote registry.
"""
auth_config = {
'username': username,
'password': password
}
build_stamp = self.get_build_stamp_for_image(image_id)
tag = tag or build_stamp
if repository_prefix:
image_name = "{}-{}".format(repository_prefix, service_name)
elif repository_prefix is None:
image_name = "{}-{}".format(self.project_name, service_name)
elif repository_prefix == '':
image_name = service_name
repository = "{}/{}".format(namespace, image_name)
if url != self.default_registry_url:
url = REMOVE_HTTP.sub('', url)
repository = "%s/%s" % (url.rstrip('/'), repository)
logger.info('Tagging %s' % repository)
self.client.api.tag(image_id, repository, tag=tag)
logger.info('Pushing %s:%s...' % (repository, tag))
stream = self.client.api.push(repository, tag=tag, stream=True, auth_config=auth_config)
last_status = None
for data in stream:
data = data.splitlines()
for line in data:
line = json.loads(line)
if type(line) is dict and 'error' in line:
plainLogger.error(line['error'])
raise exceptions.AnsibleContainerException(
"Failed to push image. {}".format(line['error'])
)
elif type(line) is dict and 'status' in line:
if line['status'] != last_status:
plainLogger.info(line['status'])
last_status = line['status']
else:
plainLogger.debug(line) | [
"def",
"push",
"(",
"self",
",",
"image_id",
",",
"service_name",
",",
"tag",
"=",
"None",
",",
"namespace",
"=",
"None",
",",
"url",
"=",
"None",
",",
"username",
"=",
"None",
",",
"password",
"=",
"None",
",",
"repository_prefix",
"=",
"None",
",",
... | Push an image to a remote registry. | [
"Push",
"an",
"image",
"to",
"a",
"remote",
"registry",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/docker/engine.py#L895-L941 | train |
ansible/ansible-container | container/docker/engine.py | Engine.login | def login(self, username, password, email, url, config_path):
"""
If username and password are provided, authenticate with the registry.
Otherwise, check the config file for existing authentication data.
"""
if username and password:
try:
self.client.login(username=username, password=password, email=email,
registry=url, reauth=True)
except docker_errors.APIError as exc:
raise exceptions.AnsibleContainerConductorException(
u"Error logging into registry: {}".format(exc)
)
except Exception:
raise
self._update_config_file(username, password, email, url, config_path)
username, password = self._get_registry_auth(url, config_path)
if not username:
raise exceptions.AnsibleContainerConductorException(
u'Please provide login credentials for registry {}.'.format(url))
return username, password | python | def login(self, username, password, email, url, config_path):
"""
If username and password are provided, authenticate with the registry.
Otherwise, check the config file for existing authentication data.
"""
if username and password:
try:
self.client.login(username=username, password=password, email=email,
registry=url, reauth=True)
except docker_errors.APIError as exc:
raise exceptions.AnsibleContainerConductorException(
u"Error logging into registry: {}".format(exc)
)
except Exception:
raise
self._update_config_file(username, password, email, url, config_path)
username, password = self._get_registry_auth(url, config_path)
if not username:
raise exceptions.AnsibleContainerConductorException(
u'Please provide login credentials for registry {}.'.format(url))
return username, password | [
"def",
"login",
"(",
"self",
",",
"username",
",",
"password",
",",
"email",
",",
"url",
",",
"config_path",
")",
":",
"if",
"username",
"and",
"password",
":",
"try",
":",
"self",
".",
"client",
".",
"login",
"(",
"username",
"=",
"username",
",",
"... | If username and password are provided, authenticate with the registry.
Otherwise, check the config file for existing authentication data. | [
"If",
"username",
"and",
"password",
"are",
"provided",
"authenticate",
"with",
"the",
"registry",
".",
"Otherwise",
"check",
"the",
"config",
"file",
"for",
"existing",
"authentication",
"data",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/docker/engine.py#L1186-L1208 | train |
ansible/ansible-container | container/docker/engine.py | Engine._update_config_file | def _update_config_file(username, password, email, url, config_path):
"""Update the config file with the authorization."""
try:
# read the existing config
config = json.load(open(config_path, "r"))
except ValueError:
config = dict()
if not config.get('auths'):
config['auths'] = dict()
if not config['auths'].get(url):
config['auths'][url] = dict()
encoded_credentials = dict(
auth=base64.b64encode(username + b':' + password),
email=email
)
config['auths'][url] = encoded_credentials
try:
json.dump(config, open(config_path, "w"), indent=5, sort_keys=True)
except Exception as exc:
raise exceptions.AnsibleContainerConductorException(
u"Failed to write registry config to {0} - {1}".format(config_path, exc)
) | python | def _update_config_file(username, password, email, url, config_path):
"""Update the config file with the authorization."""
try:
# read the existing config
config = json.load(open(config_path, "r"))
except ValueError:
config = dict()
if not config.get('auths'):
config['auths'] = dict()
if not config['auths'].get(url):
config['auths'][url] = dict()
encoded_credentials = dict(
auth=base64.b64encode(username + b':' + password),
email=email
)
config['auths'][url] = encoded_credentials
try:
json.dump(config, open(config_path, "w"), indent=5, sort_keys=True)
except Exception as exc:
raise exceptions.AnsibleContainerConductorException(
u"Failed to write registry config to {0} - {1}".format(config_path, exc)
) | [
"def",
"_update_config_file",
"(",
"username",
",",
"password",
",",
"email",
",",
"url",
",",
"config_path",
")",
":",
"try",
":",
"config",
"=",
"json",
".",
"load",
"(",
"open",
"(",
"config_path",
",",
"\"r\"",
")",
")",
"except",
"ValueError",
":",
... | Update the config file with the authorization. | [
"Update",
"the",
"config",
"file",
"with",
"the",
"authorization",
"."
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/docker/engine.py#L1212-L1235 | train |
ansible/ansible-container | container/docker/engine.py | Engine._get_registry_auth | def _get_registry_auth(registry_url, config_path):
"""
Retrieve from the config file the current authentication for a given URL, and
return the username, password
"""
username = None
password = None
try:
docker_config = json.load(open(config_path))
except ValueError:
# The configuration file is empty
return username, password
if docker_config.get('auths'):
docker_config = docker_config['auths']
auth_key = docker_config.get(registry_url, {}).get('auth', None)
if auth_key:
username, password = base64.b64decode(auth_key).split(':', 1)
return username, password | python | def _get_registry_auth(registry_url, config_path):
"""
Retrieve from the config file the current authentication for a given URL, and
return the username, password
"""
username = None
password = None
try:
docker_config = json.load(open(config_path))
except ValueError:
# The configuration file is empty
return username, password
if docker_config.get('auths'):
docker_config = docker_config['auths']
auth_key = docker_config.get(registry_url, {}).get('auth', None)
if auth_key:
username, password = base64.b64decode(auth_key).split(':', 1)
return username, password | [
"def",
"_get_registry_auth",
"(",
"registry_url",
",",
"config_path",
")",
":",
"username",
"=",
"None",
"password",
"=",
"None",
"try",
":",
"docker_config",
"=",
"json",
".",
"load",
"(",
"open",
"(",
"config_path",
")",
")",
"except",
"ValueError",
":",
... | Retrieve from the config file the current authentication for a given URL, and
return the username, password | [
"Retrieve",
"from",
"the",
"config",
"file",
"the",
"current",
"authentication",
"for",
"a",
"given",
"URL",
"and",
"return",
"the",
"username",
"password"
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/docker/engine.py#L1239-L1256 | train |
ansible/ansible-container | container/utils/__init__.py | resolve_role_to_path | def resolve_role_to_path(role):
"""
Given a role definition from a service's list of roles, returns the file path to the role
"""
loader = DataLoader()
try:
variable_manager = VariableManager(loader=loader)
except TypeError:
# If Ansible prior to ansible/ansible@8f97aef1a365
variable_manager = VariableManager()
role_obj = RoleInclude.load(data=role, play=None,
variable_manager=variable_manager,
loader=loader)
return role_obj._role_path | python | def resolve_role_to_path(role):
"""
Given a role definition from a service's list of roles, returns the file path to the role
"""
loader = DataLoader()
try:
variable_manager = VariableManager(loader=loader)
except TypeError:
# If Ansible prior to ansible/ansible@8f97aef1a365
variable_manager = VariableManager()
role_obj = RoleInclude.load(data=role, play=None,
variable_manager=variable_manager,
loader=loader)
return role_obj._role_path | [
"def",
"resolve_role_to_path",
"(",
"role",
")",
":",
"loader",
"=",
"DataLoader",
"(",
")",
"try",
":",
"variable_manager",
"=",
"VariableManager",
"(",
"loader",
"=",
"loader",
")",
"except",
"TypeError",
":",
"variable_manager",
"=",
"VariableManager",
"(",
... | Given a role definition from a service's list of roles, returns the file path to the role | [
"Given",
"a",
"role",
"definition",
"from",
"a",
"service",
"s",
"list",
"of",
"roles",
"returns",
"the",
"file",
"path",
"to",
"the",
"role"
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/utils/__init__.py#L225-L238 | train |
ansible/ansible-container | container/utils/__init__.py | get_role_fingerprint | def get_role_fingerprint(role, service_name, config_vars):
"""
Given a role definition from a service's list of roles, returns a hexdigest based on the role definition,
the role contents, and the hexdigest of each dependency
"""
def hash_file(hash_obj, file_path):
blocksize = 64 * 1024
with open(file_path, 'rb') as ifs:
while True:
data = ifs.read(blocksize)
if not data:
break
hash_obj.update(data)
hash_obj.update('::')
def hash_dir(hash_obj, dir_path):
for root, dirs, files in os.walk(dir_path, topdown=True):
for file_path in files:
abs_file_path = os.path.join(root, file_path)
hash_obj.update(abs_file_path.encode('utf-8'))
hash_obj.update('::')
hash_file(hash_obj, abs_file_path)
def hash_role(hash_obj, role_path):
# Role content is easy to hash - the hash of the role content with the
# hash of any role dependencies it has
hash_dir(hash_obj, role_path)
for dependency in get_dependencies_for_role(role_path):
if dependency:
dependency_path = resolve_role_to_path(dependency)
hash_role(hash_obj, dependency_path)
# However tasks within that role might reference files outside of the
# role, like source code
loader = DataLoader()
var_man = VariableManager(loader=loader)
play = Play.load(generate_playbook_for_role(service_name, config_vars, role)[0],
variable_manager=var_man, loader=loader)
play_context = PlayContext(play=play)
inv_man = InventoryManager(loader, sources=['%s,' % service_name])
host = Host(service_name)
iterator = PlayIterator(inv_man, play, play_context, var_man, config_vars)
while True:
_, task = iterator.get_next_task_for_host(host)
if task is None: break
if task.action in FILE_COPY_MODULES:
src = task.args.get('src')
if src is not None:
if not os.path.exists(src) or not src.startswith(('/', '..')): continue
src = os.path.realpath(src)
if os.path.isfile(src):
hash_file(hash_obj, src)
else:
hash_dir(hash_obj, src)
def get_dependencies_for_role(role_path):
meta_main_path = os.path.join(role_path, 'meta', 'main.yml')
if os.path.exists(meta_main_path):
meta_main = yaml.safe_load(open(meta_main_path))
if meta_main:
for dependency in meta_main.get('dependencies', []):
yield dependency.get('role', None)
hash_obj = hashlib.sha256()
# Account for variables passed to the role by including the invocation string
hash_obj.update((json.dumps(role) if not isinstance(role, string_types) else role) + '::')
# Add each of the role's files and directories
hash_role(hash_obj, resolve_role_to_path(role))
return hash_obj.hexdigest() | python | def get_role_fingerprint(role, service_name, config_vars):
"""
Given a role definition from a service's list of roles, returns a hexdigest based on the role definition,
the role contents, and the hexdigest of each dependency
"""
def hash_file(hash_obj, file_path):
blocksize = 64 * 1024
with open(file_path, 'rb') as ifs:
while True:
data = ifs.read(blocksize)
if not data:
break
hash_obj.update(data)
hash_obj.update('::')
def hash_dir(hash_obj, dir_path):
for root, dirs, files in os.walk(dir_path, topdown=True):
for file_path in files:
abs_file_path = os.path.join(root, file_path)
hash_obj.update(abs_file_path.encode('utf-8'))
hash_obj.update('::')
hash_file(hash_obj, abs_file_path)
def hash_role(hash_obj, role_path):
# Role content is easy to hash - the hash of the role content with the
# hash of any role dependencies it has
hash_dir(hash_obj, role_path)
for dependency in get_dependencies_for_role(role_path):
if dependency:
dependency_path = resolve_role_to_path(dependency)
hash_role(hash_obj, dependency_path)
# However tasks within that role might reference files outside of the
# role, like source code
loader = DataLoader()
var_man = VariableManager(loader=loader)
play = Play.load(generate_playbook_for_role(service_name, config_vars, role)[0],
variable_manager=var_man, loader=loader)
play_context = PlayContext(play=play)
inv_man = InventoryManager(loader, sources=['%s,' % service_name])
host = Host(service_name)
iterator = PlayIterator(inv_man, play, play_context, var_man, config_vars)
while True:
_, task = iterator.get_next_task_for_host(host)
if task is None: break
if task.action in FILE_COPY_MODULES:
src = task.args.get('src')
if src is not None:
if not os.path.exists(src) or not src.startswith(('/', '..')): continue
src = os.path.realpath(src)
if os.path.isfile(src):
hash_file(hash_obj, src)
else:
hash_dir(hash_obj, src)
def get_dependencies_for_role(role_path):
meta_main_path = os.path.join(role_path, 'meta', 'main.yml')
if os.path.exists(meta_main_path):
meta_main = yaml.safe_load(open(meta_main_path))
if meta_main:
for dependency in meta_main.get('dependencies', []):
yield dependency.get('role', None)
hash_obj = hashlib.sha256()
# Account for variables passed to the role by including the invocation string
hash_obj.update((json.dumps(role) if not isinstance(role, string_types) else role) + '::')
# Add each of the role's files and directories
hash_role(hash_obj, resolve_role_to_path(role))
return hash_obj.hexdigest() | [
"def",
"get_role_fingerprint",
"(",
"role",
",",
"service_name",
",",
"config_vars",
")",
":",
"def",
"hash_file",
"(",
"hash_obj",
",",
"file_path",
")",
":",
"blocksize",
"=",
"64",
"*",
"1024",
"with",
"open",
"(",
"file_path",
",",
"'rb'",
")",
"as",
... | Given a role definition from a service's list of roles, returns a hexdigest based on the role definition,
the role contents, and the hexdigest of each dependency | [
"Given",
"a",
"role",
"definition",
"from",
"a",
"service",
"s",
"list",
"of",
"roles",
"returns",
"a",
"hexdigest",
"based",
"on",
"the",
"role",
"definition",
"the",
"role",
"contents",
"and",
"the",
"hexdigest",
"of",
"each",
"dependency"
] | d031c1a6133d5482a5d054fcbdbecafb923f8b4b | https://github.com/ansible/ansible-container/blob/d031c1a6133d5482a5d054fcbdbecafb923f8b4b/container/utils/__init__.py#L256-L323 | train |
litl/backoff | backoff/_decorator.py | on_predicate | def on_predicate(wait_gen,
predicate=operator.not_,
max_tries=None,
max_time=None,
jitter=full_jitter,
on_success=None,
on_backoff=None,
on_giveup=None,
logger='backoff',
**wait_gen_kwargs):
"""Returns decorator for backoff and retry triggered by predicate.
Args:
wait_gen: A generator yielding successive wait times in
seconds.
predicate: A function which when called on the return value of
the target function will trigger backoff when considered
truthily. If not specified, the default behavior is to
backoff on falsey return values.
max_tries: The maximum number of attempts to make before giving
up. In the case of failure, the result of the last attempt
will be returned. The default value of None means there
is no limit to the number of tries. If a callable is passed,
it will be evaluated at runtime and its return value used.
max_time: The maximum total amount of time to try for before
giving up. If this time expires, the result of the last
attempt will be returned. If a callable is passed, it will
be evaluated at runtime and its return value used.
jitter: A function of the value yielded by wait_gen returning
the actual time to wait. This distributes wait times
stochastically in order to avoid timing collisions across
concurrent clients. Wait times are jittered by default
using the full_jitter function. Jittering may be disabled
altogether by passing jitter=None.
on_success: Callable (or iterable of callables) with a unary
signature to be called in the event of success. The
parameter is a dict containing details about the invocation.
on_backoff: Callable (or iterable of callables) with a unary
signature to be called in the event of a backoff. The
parameter is a dict containing details about the invocation.
on_giveup: Callable (or iterable of callables) with a unary
signature to be called in the event that max_tries
is exceeded. The parameter is a dict containing details
about the invocation.
logger: Name of logger or Logger object to log to. Defaults to
'backoff'.
**wait_gen_kwargs: Any additional keyword args specified will be
passed to wait_gen when it is initialized. Any callable
args will first be evaluated and their return values passed.
This is useful for runtime configuration.
"""
def decorate(target):
# change names because python 2.x doesn't have nonlocal
logger_ = logger
if isinstance(logger_, basestring):
logger_ = logging.getLogger(logger_)
on_success_ = _config_handlers(on_success)
on_backoff_ = _config_handlers(on_backoff, _log_backoff, logger_)
on_giveup_ = _config_handlers(on_giveup, _log_giveup, logger_)
retry = None
if sys.version_info >= (3, 5): # pragma: python=3.5
import asyncio
if asyncio.iscoroutinefunction(target):
import backoff._async
retry = backoff._async.retry_predicate
elif _is_event_loop() and _is_current_task():
# Verify that sync version is not being run from coroutine
# (that would lead to event loop hiccups).
raise TypeError(
"backoff.on_predicate applied to a regular function "
"inside coroutine, this will lead to event loop "
"hiccups. Use backoff.on_predicate on coroutines in "
"asynchronous code.")
if retry is None:
retry = _sync.retry_predicate
return retry(target, wait_gen, predicate,
max_tries, max_time, jitter,
on_success_, on_backoff_, on_giveup_,
wait_gen_kwargs)
# Return a function which decorates a target with a retry loop.
return decorate | python | def on_predicate(wait_gen,
predicate=operator.not_,
max_tries=None,
max_time=None,
jitter=full_jitter,
on_success=None,
on_backoff=None,
on_giveup=None,
logger='backoff',
**wait_gen_kwargs):
"""Returns decorator for backoff and retry triggered by predicate.
Args:
wait_gen: A generator yielding successive wait times in
seconds.
predicate: A function which when called on the return value of
the target function will trigger backoff when considered
truthily. If not specified, the default behavior is to
backoff on falsey return values.
max_tries: The maximum number of attempts to make before giving
up. In the case of failure, the result of the last attempt
will be returned. The default value of None means there
is no limit to the number of tries. If a callable is passed,
it will be evaluated at runtime and its return value used.
max_time: The maximum total amount of time to try for before
giving up. If this time expires, the result of the last
attempt will be returned. If a callable is passed, it will
be evaluated at runtime and its return value used.
jitter: A function of the value yielded by wait_gen returning
the actual time to wait. This distributes wait times
stochastically in order to avoid timing collisions across
concurrent clients. Wait times are jittered by default
using the full_jitter function. Jittering may be disabled
altogether by passing jitter=None.
on_success: Callable (or iterable of callables) with a unary
signature to be called in the event of success. The
parameter is a dict containing details about the invocation.
on_backoff: Callable (or iterable of callables) with a unary
signature to be called in the event of a backoff. The
parameter is a dict containing details about the invocation.
on_giveup: Callable (or iterable of callables) with a unary
signature to be called in the event that max_tries
is exceeded. The parameter is a dict containing details
about the invocation.
logger: Name of logger or Logger object to log to. Defaults to
'backoff'.
**wait_gen_kwargs: Any additional keyword args specified will be
passed to wait_gen when it is initialized. Any callable
args will first be evaluated and their return values passed.
This is useful for runtime configuration.
"""
def decorate(target):
# change names because python 2.x doesn't have nonlocal
logger_ = logger
if isinstance(logger_, basestring):
logger_ = logging.getLogger(logger_)
on_success_ = _config_handlers(on_success)
on_backoff_ = _config_handlers(on_backoff, _log_backoff, logger_)
on_giveup_ = _config_handlers(on_giveup, _log_giveup, logger_)
retry = None
if sys.version_info >= (3, 5): # pragma: python=3.5
import asyncio
if asyncio.iscoroutinefunction(target):
import backoff._async
retry = backoff._async.retry_predicate
elif _is_event_loop() and _is_current_task():
# Verify that sync version is not being run from coroutine
# (that would lead to event loop hiccups).
raise TypeError(
"backoff.on_predicate applied to a regular function "
"inside coroutine, this will lead to event loop "
"hiccups. Use backoff.on_predicate on coroutines in "
"asynchronous code.")
if retry is None:
retry = _sync.retry_predicate
return retry(target, wait_gen, predicate,
max_tries, max_time, jitter,
on_success_, on_backoff_, on_giveup_,
wait_gen_kwargs)
# Return a function which decorates a target with a retry loop.
return decorate | [
"def",
"on_predicate",
"(",
"wait_gen",
",",
"predicate",
"=",
"operator",
".",
"not_",
",",
"max_tries",
"=",
"None",
",",
"max_time",
"=",
"None",
",",
"jitter",
"=",
"full_jitter",
",",
"on_success",
"=",
"None",
",",
"on_backoff",
"=",
"None",
",",
"... | Returns decorator for backoff and retry triggered by predicate.
Args:
wait_gen: A generator yielding successive wait times in
seconds.
predicate: A function which when called on the return value of
the target function will trigger backoff when considered
truthily. If not specified, the default behavior is to
backoff on falsey return values.
max_tries: The maximum number of attempts to make before giving
up. In the case of failure, the result of the last attempt
will be returned. The default value of None means there
is no limit to the number of tries. If a callable is passed,
it will be evaluated at runtime and its return value used.
max_time: The maximum total amount of time to try for before
giving up. If this time expires, the result of the last
attempt will be returned. If a callable is passed, it will
be evaluated at runtime and its return value used.
jitter: A function of the value yielded by wait_gen returning
the actual time to wait. This distributes wait times
stochastically in order to avoid timing collisions across
concurrent clients. Wait times are jittered by default
using the full_jitter function. Jittering may be disabled
altogether by passing jitter=None.
on_success: Callable (or iterable of callables) with a unary
signature to be called in the event of success. The
parameter is a dict containing details about the invocation.
on_backoff: Callable (or iterable of callables) with a unary
signature to be called in the event of a backoff. The
parameter is a dict containing details about the invocation.
on_giveup: Callable (or iterable of callables) with a unary
signature to be called in the event that max_tries
is exceeded. The parameter is a dict containing details
about the invocation.
logger: Name of logger or Logger object to log to. Defaults to
'backoff'.
**wait_gen_kwargs: Any additional keyword args specified will be
passed to wait_gen when it is initialized. Any callable
args will first be evaluated and their return values passed.
This is useful for runtime configuration. | [
"Returns",
"decorator",
"for",
"backoff",
"and",
"retry",
"triggered",
"by",
"predicate",
"."
] | 229d30adce4128f093550a1761c49594c78df4b4 | https://github.com/litl/backoff/blob/229d30adce4128f093550a1761c49594c78df4b4/backoff/_decorator.py#L20-L106 | train |
litl/backoff | backoff/_wait_gen.py | expo | def expo(base=2, factor=1, max_value=None):
"""Generator for exponential decay.
Args:
base: The mathematical base of the exponentiation operation
factor: Factor to multiply the exponentation by.
max_value: The maximum value to yield. Once the value in the
true exponential sequence exceeds this, the value
of max_value will forever after be yielded.
"""
n = 0
while True:
a = factor * base ** n
if max_value is None or a < max_value:
yield a
n += 1
else:
yield max_value | python | def expo(base=2, factor=1, max_value=None):
"""Generator for exponential decay.
Args:
base: The mathematical base of the exponentiation operation
factor: Factor to multiply the exponentation by.
max_value: The maximum value to yield. Once the value in the
true exponential sequence exceeds this, the value
of max_value will forever after be yielded.
"""
n = 0
while True:
a = factor * base ** n
if max_value is None or a < max_value:
yield a
n += 1
else:
yield max_value | [
"def",
"expo",
"(",
"base",
"=",
"2",
",",
"factor",
"=",
"1",
",",
"max_value",
"=",
"None",
")",
":",
"n",
"=",
"0",
"while",
"True",
":",
"a",
"=",
"factor",
"*",
"base",
"**",
"n",
"if",
"max_value",
"is",
"None",
"or",
"a",
"<",
"max_value... | Generator for exponential decay.
Args:
base: The mathematical base of the exponentiation operation
factor: Factor to multiply the exponentation by.
max_value: The maximum value to yield. Once the value in the
true exponential sequence exceeds this, the value
of max_value will forever after be yielded. | [
"Generator",
"for",
"exponential",
"decay",
"."
] | 229d30adce4128f093550a1761c49594c78df4b4 | https://github.com/litl/backoff/blob/229d30adce4128f093550a1761c49594c78df4b4/backoff/_wait_gen.py#L6-L23 | train |
litl/backoff | backoff/_wait_gen.py | fibo | def fibo(max_value=None):
"""Generator for fibonaccial decay.
Args:
max_value: The maximum value to yield. Once the value in the
true fibonacci sequence exceeds this, the value
of max_value will forever after be yielded.
"""
a = 1
b = 1
while True:
if max_value is None or a < max_value:
yield a
a, b = b, a + b
else:
yield max_value | python | def fibo(max_value=None):
"""Generator for fibonaccial decay.
Args:
max_value: The maximum value to yield. Once the value in the
true fibonacci sequence exceeds this, the value
of max_value will forever after be yielded.
"""
a = 1
b = 1
while True:
if max_value is None or a < max_value:
yield a
a, b = b, a + b
else:
yield max_value | [
"def",
"fibo",
"(",
"max_value",
"=",
"None",
")",
":",
"a",
"=",
"1",
"b",
"=",
"1",
"while",
"True",
":",
"if",
"max_value",
"is",
"None",
"or",
"a",
"<",
"max_value",
":",
"yield",
"a",
"a",
",",
"b",
"=",
"b",
",",
"a",
"+",
"b",
"else",
... | Generator for fibonaccial decay.
Args:
max_value: The maximum value to yield. Once the value in the
true fibonacci sequence exceeds this, the value
of max_value will forever after be yielded. | [
"Generator",
"for",
"fibonaccial",
"decay",
"."
] | 229d30adce4128f093550a1761c49594c78df4b4 | https://github.com/litl/backoff/blob/229d30adce4128f093550a1761c49594c78df4b4/backoff/_wait_gen.py#L26-L41 | train |
litl/backoff | backoff/_wait_gen.py | constant | def constant(interval=1):
"""Generator for constant intervals.
Args:
interval: A constant value to yield or an iterable of such values.
"""
try:
itr = iter(interval)
except TypeError:
itr = itertools.repeat(interval)
for val in itr:
yield val | python | def constant(interval=1):
"""Generator for constant intervals.
Args:
interval: A constant value to yield or an iterable of such values.
"""
try:
itr = iter(interval)
except TypeError:
itr = itertools.repeat(interval)
for val in itr:
yield val | [
"def",
"constant",
"(",
"interval",
"=",
"1",
")",
":",
"try",
":",
"itr",
"=",
"iter",
"(",
"interval",
")",
"except",
"TypeError",
":",
"itr",
"=",
"itertools",
".",
"repeat",
"(",
"interval",
")",
"for",
"val",
"in",
"itr",
":",
"yield",
"val"
] | Generator for constant intervals.
Args:
interval: A constant value to yield or an iterable of such values. | [
"Generator",
"for",
"constant",
"intervals",
"."
] | 229d30adce4128f093550a1761c49594c78df4b4 | https://github.com/litl/backoff/blob/229d30adce4128f093550a1761c49594c78df4b4/backoff/_wait_gen.py#L44-L56 | train |
crytic/slither | slither/detectors/erc20/incorrect_interface.py | IncorrectERC20InterfaceDetection.detect_incorrect_erc20_interface | def detect_incorrect_erc20_interface(contract):
""" Detect incorrect ERC20 interface
Returns:
list(str) : list of incorrect function signatures
"""
functions = [f for f in contract.functions if f.contract == contract and \
IncorrectERC20InterfaceDetection.incorrect_erc20_interface(f.signature)]
return functions | python | def detect_incorrect_erc20_interface(contract):
""" Detect incorrect ERC20 interface
Returns:
list(str) : list of incorrect function signatures
"""
functions = [f for f in contract.functions if f.contract == contract and \
IncorrectERC20InterfaceDetection.incorrect_erc20_interface(f.signature)]
return functions | [
"def",
"detect_incorrect_erc20_interface",
"(",
"contract",
")",
":",
"functions",
"=",
"[",
"f",
"for",
"f",
"in",
"contract",
".",
"functions",
"if",
"f",
".",
"contract",
"==",
"contract",
"and",
"IncorrectERC20InterfaceDetection",
".",
"incorrect_erc20_interface... | Detect incorrect ERC20 interface
Returns:
list(str) : list of incorrect function signatures | [
"Detect",
"incorrect",
"ERC20",
"interface"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/erc20/incorrect_interface.py#L49-L57 | train |
crytic/slither | slither/detectors/erc20/incorrect_interface.py | IncorrectERC20InterfaceDetection._detect | def _detect(self):
""" Detect incorrect erc20 interface
Returns:
dict: [contrat name] = set(str) events
"""
results = []
for c in self.contracts:
functions = IncorrectERC20InterfaceDetection.detect_incorrect_erc20_interface(c)
if functions:
info = "{} ({}) has incorrect ERC20 function interface(s):\n"
info = info.format(c.name,
c.source_mapping_str)
for function in functions:
info += "\t-{} ({})\n".format(function.name, function.source_mapping_str)
json = self.generate_json_result(info)
self.add_functions_to_json(functions, json)
results.append(json)
return results | python | def _detect(self):
""" Detect incorrect erc20 interface
Returns:
dict: [contrat name] = set(str) events
"""
results = []
for c in self.contracts:
functions = IncorrectERC20InterfaceDetection.detect_incorrect_erc20_interface(c)
if functions:
info = "{} ({}) has incorrect ERC20 function interface(s):\n"
info = info.format(c.name,
c.source_mapping_str)
for function in functions:
info += "\t-{} ({})\n".format(function.name, function.source_mapping_str)
json = self.generate_json_result(info)
self.add_functions_to_json(functions, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"self",
".",
"contracts",
":",
"functions",
"=",
"IncorrectERC20InterfaceDetection",
".",
"detect_incorrect_erc20_interface",
"(",
"c",
")",
"if",
"functions",
":",
"info",
... | Detect incorrect erc20 interface
Returns:
dict: [contrat name] = set(str) events | [
"Detect",
"incorrect",
"erc20",
"interface"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/erc20/incorrect_interface.py#L59-L78 | train |
crytic/slither | slither/detectors/shadowing/local.py | LocalShadowing.detect_shadowing_definitions | def detect_shadowing_definitions(self, contract):
""" Detects if functions, access modifiers, events, state variables, and local variables are named after
reserved keywords. Any such definitions are returned in a list.
Returns:
list of tuple: (type, contract name, definition)"""
result = []
# Loop through all functions + modifiers in this contract.
for function in contract.functions + contract.modifiers:
# We should only look for functions declared directly in this contract (not in a base contract).
if function.contract != contract:
continue
# This function was declared in this contract, we check what its local variables might shadow.
for variable in function.variables:
overshadowed = []
for scope_contract in [contract] + contract.inheritance:
# Check functions
for scope_function in scope_contract.functions:
if variable.name == scope_function.name and scope_function.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_FUNCTION, scope_contract.name, scope_function))
# Check modifiers
for scope_modifier in scope_contract.modifiers:
if variable.name == scope_modifier.name and scope_modifier.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_MODIFIER, scope_contract.name, scope_modifier))
# Check events
for scope_event in scope_contract.events:
if variable.name == scope_event.name and scope_event.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_EVENT, scope_contract.name, scope_event))
# Check state variables
for scope_state_variable in scope_contract.variables:
if variable.name == scope_state_variable.name and scope_state_variable.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_STATE_VARIABLE, scope_contract.name, scope_state_variable))
# If we have found any overshadowed objects, we'll want to add it to our result list.
if overshadowed:
result.append((contract.name, function.name, variable, overshadowed))
return result | python | def detect_shadowing_definitions(self, contract):
""" Detects if functions, access modifiers, events, state variables, and local variables are named after
reserved keywords. Any such definitions are returned in a list.
Returns:
list of tuple: (type, contract name, definition)"""
result = []
# Loop through all functions + modifiers in this contract.
for function in contract.functions + contract.modifiers:
# We should only look for functions declared directly in this contract (not in a base contract).
if function.contract != contract:
continue
# This function was declared in this contract, we check what its local variables might shadow.
for variable in function.variables:
overshadowed = []
for scope_contract in [contract] + contract.inheritance:
# Check functions
for scope_function in scope_contract.functions:
if variable.name == scope_function.name and scope_function.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_FUNCTION, scope_contract.name, scope_function))
# Check modifiers
for scope_modifier in scope_contract.modifiers:
if variable.name == scope_modifier.name and scope_modifier.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_MODIFIER, scope_contract.name, scope_modifier))
# Check events
for scope_event in scope_contract.events:
if variable.name == scope_event.name and scope_event.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_EVENT, scope_contract.name, scope_event))
# Check state variables
for scope_state_variable in scope_contract.variables:
if variable.name == scope_state_variable.name and scope_state_variable.contract == scope_contract:
overshadowed.append((self.OVERSHADOWED_STATE_VARIABLE, scope_contract.name, scope_state_variable))
# If we have found any overshadowed objects, we'll want to add it to our result list.
if overshadowed:
result.append((contract.name, function.name, variable, overshadowed))
return result | [
"def",
"detect_shadowing_definitions",
"(",
"self",
",",
"contract",
")",
":",
"result",
"=",
"[",
"]",
"for",
"function",
"in",
"contract",
".",
"functions",
"+",
"contract",
".",
"modifiers",
":",
"if",
"function",
".",
"contract",
"!=",
"contract",
":",
... | Detects if functions, access modifiers, events, state variables, and local variables are named after
reserved keywords. Any such definitions are returned in a list.
Returns:
list of tuple: (type, contract name, definition) | [
"Detects",
"if",
"functions",
"access",
"modifiers",
"events",
"state",
"variables",
"and",
"local",
"variables",
"are",
"named",
"after",
"reserved",
"keywords",
".",
"Any",
"such",
"definitions",
"are",
"returned",
"in",
"a",
"list",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/shadowing/local.py#L51-L90 | train |
crytic/slither | slither/detectors/shadowing/local.py | LocalShadowing._detect | def _detect(self):
""" Detect shadowing local variables
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func', 'shadow'}
"""
results = []
for contract in self.contracts:
shadows = self.detect_shadowing_definitions(contract)
if shadows:
for shadow in shadows:
local_parent_name = shadow[1]
local_variable = shadow[2]
overshadowed = shadow[3]
info = '{}.{}.{} (local variable @ {}) shadows:\n'.format(contract.name,
local_parent_name,
local_variable.name,
local_variable.source_mapping_str)
for overshadowed_entry in overshadowed:
info += "\t- {}.{} ({} @ {})\n".format(overshadowed_entry[1],
overshadowed_entry[2],
overshadowed_entry[0],
overshadowed_entry[2].source_mapping_str)
# Generate relevant JSON data for this shadowing definition.
json = self.generate_json_result(info)
self.add_variable_to_json(local_variable, json)
for overshadowed_entry in overshadowed:
if overshadowed_entry[0] in [self.OVERSHADOWED_FUNCTION, self.OVERSHADOWED_MODIFIER,
self.OVERSHADOWED_EVENT]:
self.add_function_to_json(overshadowed_entry[2], json)
elif overshadowed_entry[0] == self.OVERSHADOWED_STATE_VARIABLE:
self.add_variable_to_json(overshadowed_entry[2], json)
results.append(json)
return results | python | def _detect(self):
""" Detect shadowing local variables
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func', 'shadow'}
"""
results = []
for contract in self.contracts:
shadows = self.detect_shadowing_definitions(contract)
if shadows:
for shadow in shadows:
local_parent_name = shadow[1]
local_variable = shadow[2]
overshadowed = shadow[3]
info = '{}.{}.{} (local variable @ {}) shadows:\n'.format(contract.name,
local_parent_name,
local_variable.name,
local_variable.source_mapping_str)
for overshadowed_entry in overshadowed:
info += "\t- {}.{} ({} @ {})\n".format(overshadowed_entry[1],
overshadowed_entry[2],
overshadowed_entry[0],
overshadowed_entry[2].source_mapping_str)
# Generate relevant JSON data for this shadowing definition.
json = self.generate_json_result(info)
self.add_variable_to_json(local_variable, json)
for overshadowed_entry in overshadowed:
if overshadowed_entry[0] in [self.OVERSHADOWED_FUNCTION, self.OVERSHADOWED_MODIFIER,
self.OVERSHADOWED_EVENT]:
self.add_function_to_json(overshadowed_entry[2], json)
elif overshadowed_entry[0] == self.OVERSHADOWED_STATE_VARIABLE:
self.add_variable_to_json(overshadowed_entry[2], json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"contract",
"in",
"self",
".",
"contracts",
":",
"shadows",
"=",
"self",
".",
"detect_shadowing_definitions",
"(",
"contract",
")",
"if",
"shadows",
":",
"for",
"shadow",
"in",
"sh... | Detect shadowing local variables
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func', 'shadow'} | [
"Detect",
"shadowing",
"local",
"variables"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/shadowing/local.py#L92-L131 | train |
crytic/slither | slither/detectors/variables/possible_const_state_variables.py | ConstCandidateStateVars._detect | def _detect(self):
""" Detect state variables that could be const
"""
results = []
all_info = ''
all_variables = [c.state_variables for c in self.slither.contracts]
all_variables = set([item for sublist in all_variables for item in sublist])
all_non_constant_elementary_variables = set([v for v in all_variables
if self._valid_candidate(v)])
all_functions = [c.all_functions_called for c in self.slither.contracts]
all_functions = list(set([item for sublist in all_functions for item in sublist]))
all_variables_written = [f.state_variables_written for f in all_functions]
all_variables_written = set([item for sublist in all_variables_written for item in sublist])
constable_variables = [v for v in all_non_constant_elementary_variables
if (not v in all_variables_written) and self._constant_initial_expression(v)]
# Order for deterministic results
constable_variables = sorted(constable_variables, key=lambda x: x.canonical_name)
for v in constable_variables:
info = "{}.{} should be constant ({})\n".format(v.contract.name,
v.name,
v.source_mapping_str)
all_info += info
if all_info != '':
json = self.generate_json_result(all_info)
self.add_variables_to_json(constable_variables, json)
results.append(json)
return results | python | def _detect(self):
""" Detect state variables that could be const
"""
results = []
all_info = ''
all_variables = [c.state_variables for c in self.slither.contracts]
all_variables = set([item for sublist in all_variables for item in sublist])
all_non_constant_elementary_variables = set([v for v in all_variables
if self._valid_candidate(v)])
all_functions = [c.all_functions_called for c in self.slither.contracts]
all_functions = list(set([item for sublist in all_functions for item in sublist]))
all_variables_written = [f.state_variables_written for f in all_functions]
all_variables_written = set([item for sublist in all_variables_written for item in sublist])
constable_variables = [v for v in all_non_constant_elementary_variables
if (not v in all_variables_written) and self._constant_initial_expression(v)]
# Order for deterministic results
constable_variables = sorted(constable_variables, key=lambda x: x.canonical_name)
for v in constable_variables:
info = "{}.{} should be constant ({})\n".format(v.contract.name,
v.name,
v.source_mapping_str)
all_info += info
if all_info != '':
json = self.generate_json_result(all_info)
self.add_variables_to_json(constable_variables, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"all_info",
"=",
"''",
"all_variables",
"=",
"[",
"c",
".",
"state_variables",
"for",
"c",
"in",
"self",
".",
"slither",
".",
"contracts",
"]",
"all_variables",
"=",
"set",
"(",
"[",
... | Detect state variables that could be const | [
"Detect",
"state",
"variables",
"that",
"could",
"be",
"const"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/variables/possible_const_state_variables.py#L66-L96 | train |
crytic/slither | slither/detectors/functions/suicidal.py | Suicidal.detect_suicidal_func | def detect_suicidal_func(func):
""" Detect if the function is suicidal
Detect the public functions calling suicide/selfdestruct without protection
Returns:
(bool): True if the function is suicidal
"""
if func.is_constructor:
return False
if func.visibility != 'public':
return False
calls = [c.name for c in func.internal_calls]
if not ('suicide(address)' in calls or 'selfdestruct(address)' in calls):
return False
if func.is_protected():
return False
return True | python | def detect_suicidal_func(func):
""" Detect if the function is suicidal
Detect the public functions calling suicide/selfdestruct without protection
Returns:
(bool): True if the function is suicidal
"""
if func.is_constructor:
return False
if func.visibility != 'public':
return False
calls = [c.name for c in func.internal_calls]
if not ('suicide(address)' in calls or 'selfdestruct(address)' in calls):
return False
if func.is_protected():
return False
return True | [
"def",
"detect_suicidal_func",
"(",
"func",
")",
":",
"if",
"func",
".",
"is_constructor",
":",
"return",
"False",
"if",
"func",
".",
"visibility",
"!=",
"'public'",
":",
"return",
"False",
"calls",
"=",
"[",
"c",
".",
"name",
"for",
"c",
"in",
"func",
... | Detect if the function is suicidal
Detect the public functions calling suicide/selfdestruct without protection
Returns:
(bool): True if the function is suicidal | [
"Detect",
"if",
"the",
"function",
"is",
"suicidal"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/functions/suicidal.py#L37-L58 | train |
crytic/slither | slither/detectors/functions/suicidal.py | Suicidal._detect | def _detect(self):
""" Detect the suicidal functions
"""
results = []
for c in self.contracts:
functions = self.detect_suicidal(c)
for func in functions:
txt = "{}.{} ({}) allows anyone to destruct the contract\n"
info = txt.format(func.contract.name,
func.name,
func.source_mapping_str)
json = self.generate_json_result(info)
self.add_function_to_json(func, json)
results.append(json)
return results | python | def _detect(self):
""" Detect the suicidal functions
"""
results = []
for c in self.contracts:
functions = self.detect_suicidal(c)
for func in functions:
txt = "{}.{} ({}) allows anyone to destruct the contract\n"
info = txt.format(func.contract.name,
func.name,
func.source_mapping_str)
json = self.generate_json_result(info)
self.add_function_to_json(func, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"self",
".",
"contracts",
":",
"functions",
"=",
"self",
".",
"detect_suicidal",
"(",
"c",
")",
"for",
"func",
"in",
"functions",
":",
"txt",
"=",
"\"{}.{} ({}) allows... | Detect the suicidal functions | [
"Detect",
"the",
"suicidal",
"functions"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/functions/suicidal.py#L67-L84 | train |
crytic/slither | slither/detectors/operations/unused_return_values.py | UnusedReturnValues._detect | def _detect(self):
""" Detect high level calls which return a value that are never used
"""
results = []
for c in self.slither.contracts:
for f in c.functions + c.modifiers:
if f.contract != c:
continue
unused_return = self.detect_unused_return_values(f)
if unused_return:
info = "{}.{} ({}) does not use the value returned by external calls:\n"
info = info.format(f.contract.name,
f.name,
f.source_mapping_str)
for node in unused_return:
info += "\t-{} ({})\n".format(node.expression, node.source_mapping_str)
json = self.generate_json_result(info)
self.add_function_to_json(f, json)
self.add_nodes_to_json(unused_return, json)
results.append(json)
return results | python | def _detect(self):
""" Detect high level calls which return a value that are never used
"""
results = []
for c in self.slither.contracts:
for f in c.functions + c.modifiers:
if f.contract != c:
continue
unused_return = self.detect_unused_return_values(f)
if unused_return:
info = "{}.{} ({}) does not use the value returned by external calls:\n"
info = info.format(f.contract.name,
f.name,
f.source_mapping_str)
for node in unused_return:
info += "\t-{} ({})\n".format(node.expression, node.source_mapping_str)
json = self.generate_json_result(info)
self.add_function_to_json(f, json)
self.add_nodes_to_json(unused_return, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"self",
".",
"slither",
".",
"contracts",
":",
"for",
"f",
"in",
"c",
".",
"functions",
"+",
"c",
".",
"modifiers",
":",
"if",
"f",
".",
"contract",
"!=",
"c",
... | Detect high level calls which return a value that are never used | [
"Detect",
"high",
"level",
"calls",
"which",
"return",
"a",
"value",
"that",
"are",
"never",
"used"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/operations/unused_return_values.py#L61-L83 | train |
crytic/slither | slither/printers/inheritance/inheritance_graph.py | PrinterInheritanceGraph._summary | def _summary(self, contract):
"""
Build summary using HTML
"""
ret = ''
# Add arrows (number them if there is more than one path so we know order of declaration for inheritance).
if len(contract.immediate_inheritance) == 1:
ret += '%s -> %s;\n' % (contract.name, contract.immediate_inheritance[0])
else:
for i in range(0, len(contract.immediate_inheritance)):
ret += '%s -> %s [ label="%s" ];\n' % (contract.name, contract.immediate_inheritance[i], i + 1)
# Functions
visibilities = ['public', 'external']
public_functions = [self._get_pattern_func(f, contract) for f in contract.functions if
not f.is_constructor and f.contract == contract and f.visibility in visibilities]
public_functions = ''.join(public_functions)
private_functions = [self._get_pattern_func(f, contract) for f in contract.functions if
not f.is_constructor and f.contract == contract and f.visibility not in visibilities]
private_functions = ''.join(private_functions)
# Modifiers
modifiers = [self._get_pattern_func(m, contract) for m in contract.modifiers if m.contract == contract]
modifiers = ''.join(modifiers)
# Public variables
public_variables = [self._get_pattern_var(v, contract) for v in contract.variables if
v.contract == contract and v.visibility in visibilities]
public_variables = ''.join(public_variables)
private_variables = [self._get_pattern_var(v, contract) for v in contract.variables if
v.contract == contract and v.visibility not in visibilities]
private_variables = ''.join(private_variables)
# Obtain any indirect shadowing information for this node.
indirect_shadowing_information = self._get_indirect_shadowing_information(contract)
# Build the node label
ret += '%s[shape="box"' % contract.name
ret += 'label=< <TABLE border="0">'
ret += '<TR><TD align="center"><B>%s</B></TD></TR>' % contract.name
if public_functions:
ret += '<TR><TD align="left"><I>Public Functions:</I></TD></TR>'
ret += '%s' % public_functions
if private_functions:
ret += '<TR><TD align="left"><I>Private Functions:</I></TD></TR>'
ret += '%s' % private_functions
if modifiers:
ret += '<TR><TD align="left"><I>Modifiers:</I></TD></TR>'
ret += '%s' % modifiers
if public_variables:
ret += '<TR><TD align="left"><I>Public Variables:</I></TD></TR>'
ret += '%s' % public_variables
if private_variables:
ret += '<TR><TD align="left"><I>Private Variables:</I></TD></TR>'
ret += '%s' % private_variables
if indirect_shadowing_information:
ret += '<TR><TD><BR/></TD></TR><TR><TD align="left" border="1"><font color="#777777" point-size="10">%s</font></TD></TR>' % indirect_shadowing_information.replace('\n', '<BR/>')
ret += '</TABLE> >];\n'
return ret | python | def _summary(self, contract):
"""
Build summary using HTML
"""
ret = ''
# Add arrows (number them if there is more than one path so we know order of declaration for inheritance).
if len(contract.immediate_inheritance) == 1:
ret += '%s -> %s;\n' % (contract.name, contract.immediate_inheritance[0])
else:
for i in range(0, len(contract.immediate_inheritance)):
ret += '%s -> %s [ label="%s" ];\n' % (contract.name, contract.immediate_inheritance[i], i + 1)
# Functions
visibilities = ['public', 'external']
public_functions = [self._get_pattern_func(f, contract) for f in contract.functions if
not f.is_constructor and f.contract == contract and f.visibility in visibilities]
public_functions = ''.join(public_functions)
private_functions = [self._get_pattern_func(f, contract) for f in contract.functions if
not f.is_constructor and f.contract == contract and f.visibility not in visibilities]
private_functions = ''.join(private_functions)
# Modifiers
modifiers = [self._get_pattern_func(m, contract) for m in contract.modifiers if m.contract == contract]
modifiers = ''.join(modifiers)
# Public variables
public_variables = [self._get_pattern_var(v, contract) for v in contract.variables if
v.contract == contract and v.visibility in visibilities]
public_variables = ''.join(public_variables)
private_variables = [self._get_pattern_var(v, contract) for v in contract.variables if
v.contract == contract and v.visibility not in visibilities]
private_variables = ''.join(private_variables)
# Obtain any indirect shadowing information for this node.
indirect_shadowing_information = self._get_indirect_shadowing_information(contract)
# Build the node label
ret += '%s[shape="box"' % contract.name
ret += 'label=< <TABLE border="0">'
ret += '<TR><TD align="center"><B>%s</B></TD></TR>' % contract.name
if public_functions:
ret += '<TR><TD align="left"><I>Public Functions:</I></TD></TR>'
ret += '%s' % public_functions
if private_functions:
ret += '<TR><TD align="left"><I>Private Functions:</I></TD></TR>'
ret += '%s' % private_functions
if modifiers:
ret += '<TR><TD align="left"><I>Modifiers:</I></TD></TR>'
ret += '%s' % modifiers
if public_variables:
ret += '<TR><TD align="left"><I>Public Variables:</I></TD></TR>'
ret += '%s' % public_variables
if private_variables:
ret += '<TR><TD align="left"><I>Private Variables:</I></TD></TR>'
ret += '%s' % private_variables
if indirect_shadowing_information:
ret += '<TR><TD><BR/></TD></TR><TR><TD align="left" border="1"><font color="#777777" point-size="10">%s</font></TD></TR>' % indirect_shadowing_information.replace('\n', '<BR/>')
ret += '</TABLE> >];\n'
return ret | [
"def",
"_summary",
"(",
"self",
",",
"contract",
")",
":",
"ret",
"=",
"''",
"if",
"len",
"(",
"contract",
".",
"immediate_inheritance",
")",
"==",
"1",
":",
"ret",
"+=",
"'%s -> %s;\\n'",
"%",
"(",
"contract",
".",
"name",
",",
"contract",
".",
"immed... | Build summary using HTML | [
"Build",
"summary",
"using",
"HTML"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/printers/inheritance/inheritance_graph.py#L103-L165 | train |
crytic/slither | slither/detectors/shadowing/builtin_symbols.py | BuiltinSymbolShadowing.detect_builtin_shadowing_definitions | def detect_builtin_shadowing_definitions(self, contract):
""" Detects if functions, access modifiers, events, state variables, or local variables are named after built-in
symbols. Any such definitions are returned in a list.
Returns:
list of tuple: (type, definition, [local variable parent])"""
result = []
# Loop through all functions, modifiers, variables (state and local) to detect any built-in symbol keywords.
for function in contract.functions:
if function.contract == contract:
if self.is_builtin_symbol(function.name):
result.append((self.SHADOWING_FUNCTION, function, None))
result += self.detect_builtin_shadowing_locals(function)
for modifier in contract.modifiers:
if modifier.contract == contract:
if self.is_builtin_symbol(modifier.name):
result.append((self.SHADOWING_MODIFIER, modifier, None))
result += self.detect_builtin_shadowing_locals(modifier)
for variable in contract.variables:
if variable.contract == contract:
if self.is_builtin_symbol(variable.name):
result.append((self.SHADOWING_STATE_VARIABLE, variable, None))
for event in contract.events:
if event.contract == contract:
if self.is_builtin_symbol(event.name):
result.append((self.SHADOWING_EVENT, event, None))
return result | python | def detect_builtin_shadowing_definitions(self, contract):
""" Detects if functions, access modifiers, events, state variables, or local variables are named after built-in
symbols. Any such definitions are returned in a list.
Returns:
list of tuple: (type, definition, [local variable parent])"""
result = []
# Loop through all functions, modifiers, variables (state and local) to detect any built-in symbol keywords.
for function in contract.functions:
if function.contract == contract:
if self.is_builtin_symbol(function.name):
result.append((self.SHADOWING_FUNCTION, function, None))
result += self.detect_builtin_shadowing_locals(function)
for modifier in contract.modifiers:
if modifier.contract == contract:
if self.is_builtin_symbol(modifier.name):
result.append((self.SHADOWING_MODIFIER, modifier, None))
result += self.detect_builtin_shadowing_locals(modifier)
for variable in contract.variables:
if variable.contract == contract:
if self.is_builtin_symbol(variable.name):
result.append((self.SHADOWING_STATE_VARIABLE, variable, None))
for event in contract.events:
if event.contract == contract:
if self.is_builtin_symbol(event.name):
result.append((self.SHADOWING_EVENT, event, None))
return result | [
"def",
"detect_builtin_shadowing_definitions",
"(",
"self",
",",
"contract",
")",
":",
"result",
"=",
"[",
"]",
"for",
"function",
"in",
"contract",
".",
"functions",
":",
"if",
"function",
".",
"contract",
"==",
"contract",
":",
"if",
"self",
".",
"is_built... | Detects if functions, access modifiers, events, state variables, or local variables are named after built-in
symbols. Any such definitions are returned in a list.
Returns:
list of tuple: (type, definition, [local variable parent]) | [
"Detects",
"if",
"functions",
"access",
"modifiers",
"events",
"state",
"variables",
"or",
"local",
"variables",
"are",
"named",
"after",
"built",
"-",
"in",
"symbols",
".",
"Any",
"such",
"definitions",
"are",
"returned",
"in",
"a",
"list",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/shadowing/builtin_symbols.py#L83-L112 | train |
crytic/slither | slither/detectors/shadowing/builtin_symbols.py | BuiltinSymbolShadowing._detect | def _detect(self):
""" Detect shadowing of built-in symbols
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func', 'shadow'}
"""
results = []
for contract in self.contracts:
shadows = self.detect_builtin_shadowing_definitions(contract)
if shadows:
for shadow in shadows:
# Obtain components
shadow_type = shadow[0]
shadow_object = shadow[1]
local_variable_parent = shadow[2]
# Build the path for our info string
local_variable_path = contract.name + "."
if local_variable_parent is not None:
local_variable_path += local_variable_parent.name + "."
local_variable_path += shadow_object.name
info = '{} ({} @ {}) shadows built-in symbol \"{}"\n'.format(local_variable_path,
shadow_type,
shadow_object.source_mapping_str,
shadow_object.name)
# Generate relevant JSON data for this shadowing definition.
json = self.generate_json_result(info)
if shadow_type in [self.SHADOWING_FUNCTION, self.SHADOWING_MODIFIER, self.SHADOWING_EVENT]:
self.add_function_to_json(shadow_object, json)
elif shadow_type in [self.SHADOWING_STATE_VARIABLE, self.SHADOWING_LOCAL_VARIABLE]:
self.add_variable_to_json(shadow_object, json)
results.append(json)
return results | python | def _detect(self):
""" Detect shadowing of built-in symbols
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func', 'shadow'}
"""
results = []
for contract in self.contracts:
shadows = self.detect_builtin_shadowing_definitions(contract)
if shadows:
for shadow in shadows:
# Obtain components
shadow_type = shadow[0]
shadow_object = shadow[1]
local_variable_parent = shadow[2]
# Build the path for our info string
local_variable_path = contract.name + "."
if local_variable_parent is not None:
local_variable_path += local_variable_parent.name + "."
local_variable_path += shadow_object.name
info = '{} ({} @ {}) shadows built-in symbol \"{}"\n'.format(local_variable_path,
shadow_type,
shadow_object.source_mapping_str,
shadow_object.name)
# Generate relevant JSON data for this shadowing definition.
json = self.generate_json_result(info)
if shadow_type in [self.SHADOWING_FUNCTION, self.SHADOWING_MODIFIER, self.SHADOWING_EVENT]:
self.add_function_to_json(shadow_object, json)
elif shadow_type in [self.SHADOWING_STATE_VARIABLE, self.SHADOWING_LOCAL_VARIABLE]:
self.add_variable_to_json(shadow_object, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"contract",
"in",
"self",
".",
"contracts",
":",
"shadows",
"=",
"self",
".",
"detect_builtin_shadowing_definitions",
"(",
"contract",
")",
"if",
"shadows",
":",
"for",
"shadow",
"in... | Detect shadowing of built-in symbols
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func', 'shadow'} | [
"Detect",
"shadowing",
"of",
"built",
"-",
"in",
"symbols"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/shadowing/builtin_symbols.py#L114-L152 | train |
crytic/slither | slither/utils/inheritance_analysis.py | detect_c3_function_shadowing | def detect_c3_function_shadowing(contract):
"""
Detects and obtains functions which are indirectly shadowed via multiple inheritance by C3 linearization
properties, despite not directly inheriting from each other.
:param contract: The contract to check for potential C3 linearization shadowing within.
:return: A list of list of tuples: (contract, function), where each inner list describes colliding functions.
The later elements in the inner list overshadow the earlier ones. The contract-function pair's function does not
need to be defined in its paired contract, it may have been inherited within it.
"""
# Loop through all contracts, and all underlying functions.
results = {}
for i in range(0, len(contract.immediate_inheritance) - 1):
inherited_contract1 = contract.immediate_inheritance[i]
for function1 in inherited_contract1.functions_and_modifiers:
# If this function has already be handled or is unimplemented, we skip it
if function1.full_name in results or function1.is_constructor or not function1.is_implemented:
continue
# Define our list of function instances which overshadow each other.
functions_matching = [(inherited_contract1, function1)]
already_processed = set([function1])
# Loop again through other contracts and functions to compare to.
for x in range(i + 1, len(contract.immediate_inheritance)):
inherited_contract2 = contract.immediate_inheritance[x]
# Loop for each function in this contract
for function2 in inherited_contract2.functions_and_modifiers:
# Skip this function if it is the last function that was shadowed.
if function2 in already_processed or function2.is_constructor or not function2.is_implemented:
continue
# If this function does have the same full name, it is shadowing through C3 linearization.
if function1.full_name == function2.full_name:
functions_matching.append((inherited_contract2, function2))
already_processed.add(function2)
# If we have more than one definition matching the same signature, we add it to the results.
if len(functions_matching) > 1:
results[function1.full_name] = functions_matching
return list(results.values()) | python | def detect_c3_function_shadowing(contract):
"""
Detects and obtains functions which are indirectly shadowed via multiple inheritance by C3 linearization
properties, despite not directly inheriting from each other.
:param contract: The contract to check for potential C3 linearization shadowing within.
:return: A list of list of tuples: (contract, function), where each inner list describes colliding functions.
The later elements in the inner list overshadow the earlier ones. The contract-function pair's function does not
need to be defined in its paired contract, it may have been inherited within it.
"""
# Loop through all contracts, and all underlying functions.
results = {}
for i in range(0, len(contract.immediate_inheritance) - 1):
inherited_contract1 = contract.immediate_inheritance[i]
for function1 in inherited_contract1.functions_and_modifiers:
# If this function has already be handled or is unimplemented, we skip it
if function1.full_name in results or function1.is_constructor or not function1.is_implemented:
continue
# Define our list of function instances which overshadow each other.
functions_matching = [(inherited_contract1, function1)]
already_processed = set([function1])
# Loop again through other contracts and functions to compare to.
for x in range(i + 1, len(contract.immediate_inheritance)):
inherited_contract2 = contract.immediate_inheritance[x]
# Loop for each function in this contract
for function2 in inherited_contract2.functions_and_modifiers:
# Skip this function if it is the last function that was shadowed.
if function2 in already_processed or function2.is_constructor or not function2.is_implemented:
continue
# If this function does have the same full name, it is shadowing through C3 linearization.
if function1.full_name == function2.full_name:
functions_matching.append((inherited_contract2, function2))
already_processed.add(function2)
# If we have more than one definition matching the same signature, we add it to the results.
if len(functions_matching) > 1:
results[function1.full_name] = functions_matching
return list(results.values()) | [
"def",
"detect_c3_function_shadowing",
"(",
"contract",
")",
":",
"results",
"=",
"{",
"}",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"contract",
".",
"immediate_inheritance",
")",
"-",
"1",
")",
":",
"inherited_contract1",
"=",
"contract",
"."... | Detects and obtains functions which are indirectly shadowed via multiple inheritance by C3 linearization
properties, despite not directly inheriting from each other.
:param contract: The contract to check for potential C3 linearization shadowing within.
:return: A list of list of tuples: (contract, function), where each inner list describes colliding functions.
The later elements in the inner list overshadow the earlier ones. The contract-function pair's function does not
need to be defined in its paired contract, it may have been inherited within it. | [
"Detects",
"and",
"obtains",
"functions",
"which",
"are",
"indirectly",
"shadowed",
"via",
"multiple",
"inheritance",
"by",
"C3",
"linearization",
"properties",
"despite",
"not",
"directly",
"inheriting",
"from",
"each",
"other",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/utils/inheritance_analysis.py#L6-L50 | train |
crytic/slither | slither/detectors/variables/uninitialized_state_variables.py | UninitializedStateVarsDetection._detect | def _detect(self):
""" Detect uninitialized state variables
Recursively visit the calls
Returns:
dict: [contract name] = set(state variable uninitialized)
"""
results = []
for c in self.slither.contracts_derived:
ret = self.detect_uninitialized(c)
for variable, functions in ret:
info = "{}.{} ({}) is never initialized. It is used in:\n"
info = info.format(variable.contract.name,
variable.name,
variable.source_mapping_str)
for f in functions:
info += "\t- {} ({})\n".format(f.name, f.source_mapping_str)
source = [variable.source_mapping]
source += [f.source_mapping for f in functions]
json = self.generate_json_result(info)
self.add_variable_to_json(variable, json)
self.add_functions_to_json(functions, json)
results.append(json)
return results | python | def _detect(self):
""" Detect uninitialized state variables
Recursively visit the calls
Returns:
dict: [contract name] = set(state variable uninitialized)
"""
results = []
for c in self.slither.contracts_derived:
ret = self.detect_uninitialized(c)
for variable, functions in ret:
info = "{}.{} ({}) is never initialized. It is used in:\n"
info = info.format(variable.contract.name,
variable.name,
variable.source_mapping_str)
for f in functions:
info += "\t- {} ({})\n".format(f.name, f.source_mapping_str)
source = [variable.source_mapping]
source += [f.source_mapping for f in functions]
json = self.generate_json_result(info)
self.add_variable_to_json(variable, json)
self.add_functions_to_json(functions, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"self",
".",
"slither",
".",
"contracts_derived",
":",
"ret",
"=",
"self",
".",
"detect_uninitialized",
"(",
"c",
")",
"for",
"variable",
",",
"functions",
"in",
"ret"... | Detect uninitialized state variables
Recursively visit the calls
Returns:
dict: [contract name] = set(state variable uninitialized) | [
"Detect",
"uninitialized",
"state",
"variables"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/variables/uninitialized_state_variables.py#L84-L110 | train |
crytic/slither | slither/detectors/functions/external_function.py | ExternalFunction.detect_functions_called | def detect_functions_called(contract):
""" Returns a list of InternallCall, SolidityCall
calls made in a function
Returns:
(list): List of all InternallCall, SolidityCall
"""
result = []
# Obtain all functions reachable by this contract.
for func in contract.all_functions_called:
# Loop through all nodes in the function, add all calls to a list.
for node in func.nodes:
for ir in node.irs:
if isinstance(ir, (InternalCall, SolidityCall)):
result.append(ir.function)
return result | python | def detect_functions_called(contract):
""" Returns a list of InternallCall, SolidityCall
calls made in a function
Returns:
(list): List of all InternallCall, SolidityCall
"""
result = []
# Obtain all functions reachable by this contract.
for func in contract.all_functions_called:
# Loop through all nodes in the function, add all calls to a list.
for node in func.nodes:
for ir in node.irs:
if isinstance(ir, (InternalCall, SolidityCall)):
result.append(ir.function)
return result | [
"def",
"detect_functions_called",
"(",
"contract",
")",
":",
"result",
"=",
"[",
"]",
"for",
"func",
"in",
"contract",
".",
"all_functions_called",
":",
"for",
"node",
"in",
"func",
".",
"nodes",
":",
"for",
"ir",
"in",
"node",
".",
"irs",
":",
"if",
"... | Returns a list of InternallCall, SolidityCall
calls made in a function
Returns:
(list): List of all InternallCall, SolidityCall | [
"Returns",
"a",
"list",
"of",
"InternallCall",
"SolidityCall",
"calls",
"made",
"in",
"a",
"function"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/functions/external_function.py#L27-L43 | train |
crytic/slither | slither/detectors/functions/external_function.py | ExternalFunction._contains_internal_dynamic_call | def _contains_internal_dynamic_call(contract):
"""
Checks if a contract contains a dynamic call either in a direct definition, or through inheritance.
Returns:
(boolean): True if this contract contains a dynamic call (including through inheritance).
"""
for func in contract.all_functions_called:
for node in func.nodes:
for ir in node.irs:
if isinstance(ir, (InternalDynamicCall)):
return True
return False | python | def _contains_internal_dynamic_call(contract):
"""
Checks if a contract contains a dynamic call either in a direct definition, or through inheritance.
Returns:
(boolean): True if this contract contains a dynamic call (including through inheritance).
"""
for func in contract.all_functions_called:
for node in func.nodes:
for ir in node.irs:
if isinstance(ir, (InternalDynamicCall)):
return True
return False | [
"def",
"_contains_internal_dynamic_call",
"(",
"contract",
")",
":",
"for",
"func",
"in",
"contract",
".",
"all_functions_called",
":",
"for",
"node",
"in",
"func",
".",
"nodes",
":",
"for",
"ir",
"in",
"node",
".",
"irs",
":",
"if",
"isinstance",
"(",
"ir... | Checks if a contract contains a dynamic call either in a direct definition, or through inheritance.
Returns:
(boolean): True if this contract contains a dynamic call (including through inheritance). | [
"Checks",
"if",
"a",
"contract",
"contains",
"a",
"dynamic",
"call",
"either",
"in",
"a",
"direct",
"definition",
"or",
"through",
"inheritance",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/functions/external_function.py#L46-L58 | train |
crytic/slither | slither/detectors/functions/external_function.py | ExternalFunction.get_base_most_function | def get_base_most_function(function):
"""
Obtains the base function definition for the provided function. This could be used to obtain the original
definition of a function, if the provided function is an override.
Returns:
(function): Returns the base-most function of a provided function. (The original definition).
"""
# Loop through the list of inherited contracts and this contract, to find the first function instance which
# matches this function's signature. Note here that `inheritance` is in order from most basic to most extended.
for contract in function.contract.inheritance + [function.contract]:
# Loop through the functions not inherited (explicitly defined in this contract).
for f in contract.functions_not_inherited:
# If it matches names, this is the base most function.
if f.full_name == function.full_name:
return f
# Somehow we couldn't resolve it, which shouldn't happen, as the provided function should be found if we could
# not find some any more basic.
raise Exception("Could not resolve the base-most function for the provided function.") | python | def get_base_most_function(function):
"""
Obtains the base function definition for the provided function. This could be used to obtain the original
definition of a function, if the provided function is an override.
Returns:
(function): Returns the base-most function of a provided function. (The original definition).
"""
# Loop through the list of inherited contracts and this contract, to find the first function instance which
# matches this function's signature. Note here that `inheritance` is in order from most basic to most extended.
for contract in function.contract.inheritance + [function.contract]:
# Loop through the functions not inherited (explicitly defined in this contract).
for f in contract.functions_not_inherited:
# If it matches names, this is the base most function.
if f.full_name == function.full_name:
return f
# Somehow we couldn't resolve it, which shouldn't happen, as the provided function should be found if we could
# not find some any more basic.
raise Exception("Could not resolve the base-most function for the provided function.") | [
"def",
"get_base_most_function",
"(",
"function",
")",
":",
"for",
"contract",
"in",
"function",
".",
"contract",
".",
"inheritance",
"+",
"[",
"function",
".",
"contract",
"]",
":",
"for",
"f",
"in",
"contract",
".",
"functions_not_inherited",
":",
"if",
"f... | Obtains the base function definition for the provided function. This could be used to obtain the original
definition of a function, if the provided function is an override.
Returns:
(function): Returns the base-most function of a provided function. (The original definition). | [
"Obtains",
"the",
"base",
"function",
"definition",
"for",
"the",
"provided",
"function",
".",
"This",
"could",
"be",
"used",
"to",
"obtain",
"the",
"original",
"definition",
"of",
"a",
"function",
"if",
"the",
"provided",
"function",
"is",
"an",
"override",
... | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/functions/external_function.py#L61-L82 | train |
crytic/slither | slither/detectors/functions/external_function.py | ExternalFunction.get_all_function_definitions | def get_all_function_definitions(base_most_function):
"""
Obtains all function definitions given a base-most function. This includes the provided function, plus any
overrides of that function.
Returns:
(list): Returns any the provided function and any overriding functions defined for it.
"""
# We assume the provided function is the base-most function, so we check all derived contracts
# for a redefinition
return [base_most_function] + [function for derived_contract in base_most_function.contract.derived_contracts
for function in derived_contract.functions
if function.full_name == base_most_function.full_name] | python | def get_all_function_definitions(base_most_function):
"""
Obtains all function definitions given a base-most function. This includes the provided function, plus any
overrides of that function.
Returns:
(list): Returns any the provided function and any overriding functions defined for it.
"""
# We assume the provided function is the base-most function, so we check all derived contracts
# for a redefinition
return [base_most_function] + [function for derived_contract in base_most_function.contract.derived_contracts
for function in derived_contract.functions
if function.full_name == base_most_function.full_name] | [
"def",
"get_all_function_definitions",
"(",
"base_most_function",
")",
":",
"return",
"[",
"base_most_function",
"]",
"+",
"[",
"function",
"for",
"derived_contract",
"in",
"base_most_function",
".",
"contract",
".",
"derived_contracts",
"for",
"function",
"in",
"deri... | Obtains all function definitions given a base-most function. This includes the provided function, plus any
overrides of that function.
Returns:
(list): Returns any the provided function and any overriding functions defined for it. | [
"Obtains",
"all",
"function",
"definitions",
"given",
"a",
"base",
"-",
"most",
"function",
".",
"This",
"includes",
"the",
"provided",
"function",
"plus",
"any",
"overrides",
"of",
"that",
"function",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/functions/external_function.py#L85-L97 | train |
crytic/slither | slither/detectors/functions/complex_function.py | ComplexFunction.detect_complex_func | def detect_complex_func(func):
"""Detect the cyclomatic complexity of the contract functions
shouldn't be greater than 7
"""
result = []
code_complexity = compute_cyclomatic_complexity(func)
if code_complexity > ComplexFunction.MAX_CYCLOMATIC_COMPLEXITY:
result.append({
"func": func,
"cause": ComplexFunction.CAUSE_CYCLOMATIC
})
"""Detect the number of external calls in the func
shouldn't be greater than 5
"""
count = 0
for node in func.nodes:
for ir in node.irs:
if isinstance(ir, (HighLevelCall, LowLevelCall, LibraryCall)):
count += 1
if count > ComplexFunction.MAX_EXTERNAL_CALLS:
result.append({
"func": func,
"cause": ComplexFunction.CAUSE_EXTERNAL_CALL
})
"""Checks the number of the state variables written
shouldn't be greater than 10
"""
if len(func.state_variables_written) > ComplexFunction.MAX_STATE_VARIABLES:
result.append({
"func": func,
"cause": ComplexFunction.CAUSE_STATE_VARS
})
return result | python | def detect_complex_func(func):
"""Detect the cyclomatic complexity of the contract functions
shouldn't be greater than 7
"""
result = []
code_complexity = compute_cyclomatic_complexity(func)
if code_complexity > ComplexFunction.MAX_CYCLOMATIC_COMPLEXITY:
result.append({
"func": func,
"cause": ComplexFunction.CAUSE_CYCLOMATIC
})
"""Detect the number of external calls in the func
shouldn't be greater than 5
"""
count = 0
for node in func.nodes:
for ir in node.irs:
if isinstance(ir, (HighLevelCall, LowLevelCall, LibraryCall)):
count += 1
if count > ComplexFunction.MAX_EXTERNAL_CALLS:
result.append({
"func": func,
"cause": ComplexFunction.CAUSE_EXTERNAL_CALL
})
"""Checks the number of the state variables written
shouldn't be greater than 10
"""
if len(func.state_variables_written) > ComplexFunction.MAX_STATE_VARIABLES:
result.append({
"func": func,
"cause": ComplexFunction.CAUSE_STATE_VARS
})
return result | [
"def",
"detect_complex_func",
"(",
"func",
")",
":",
"result",
"=",
"[",
"]",
"code_complexity",
"=",
"compute_cyclomatic_complexity",
"(",
"func",
")",
"if",
"code_complexity",
">",
"ComplexFunction",
".",
"MAX_CYCLOMATIC_COMPLEXITY",
":",
"result",
".",
"append",
... | Detect the cyclomatic complexity of the contract functions
shouldn't be greater than 7 | [
"Detect",
"the",
"cyclomatic",
"complexity",
"of",
"the",
"contract",
"functions",
"shouldn",
"t",
"be",
"greater",
"than",
"7"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/functions/complex_function.py#L36-L73 | train |
crytic/slither | slither/detectors/variables/unused_state_variables.py | UnusedStateVars._detect | def _detect(self):
""" Detect unused state variables
"""
results = []
for c in self.slither.contracts_derived:
unusedVars = self.detect_unused(c)
if unusedVars:
info = ''
for var in unusedVars:
info += "{}.{} ({}) is never used in {}\n".format(var.contract.name,
var.name,
var.source_mapping_str,
c.name)
json = self.generate_json_result(info)
self.add_variables_to_json(unusedVars, json)
results.append(json)
return results | python | def _detect(self):
""" Detect unused state variables
"""
results = []
for c in self.slither.contracts_derived:
unusedVars = self.detect_unused(c)
if unusedVars:
info = ''
for var in unusedVars:
info += "{}.{} ({}) is never used in {}\n".format(var.contract.name,
var.name,
var.source_mapping_str,
c.name)
json = self.generate_json_result(info)
self.add_variables_to_json(unusedVars, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"self",
".",
"slither",
".",
"contracts_derived",
":",
"unusedVars",
"=",
"self",
".",
"detect_unused",
"(",
"c",
")",
"if",
"unusedVars",
":",
"info",
"=",
"''",
"f... | Detect unused state variables | [
"Detect",
"unused",
"state",
"variables"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/variables/unused_state_variables.py#L51-L70 | train |
crytic/slither | slither/detectors/variables/uninitialized_local_variables.py | UninitializedLocalVars._detect | def _detect(self):
""" Detect uninitialized local variables
Recursively visit the calls
Returns:
dict: [contract name] = set(local variable uninitialized)
"""
results = []
self.results = []
self.visited_all_paths = {}
for contract in self.slither.contracts:
for function in contract.functions:
if function.is_implemented and function.contract == contract:
if function.contains_assembly:
continue
# dont consider storage variable, as they are detected by another detector
uninitialized_local_variables = [v for v in function.local_variables if not v.is_storage and v.uninitialized]
function.entry_point.context[self.key] = uninitialized_local_variables
self._detect_uninitialized(function, function.entry_point, [])
all_results = list(set(self.results))
for(function, uninitialized_local_variable) in all_results:
var_name = uninitialized_local_variable.name
info = "{} in {}.{} ({}) is a local variable never initialiazed\n"
info = info.format(var_name,
function.contract.name,
function.name,
uninitialized_local_variable.source_mapping_str)
json = self.generate_json_result(info)
self.add_variable_to_json(uninitialized_local_variable, json)
self.add_function_to_json(function, json)
results.append(json)
return results | python | def _detect(self):
""" Detect uninitialized local variables
Recursively visit the calls
Returns:
dict: [contract name] = set(local variable uninitialized)
"""
results = []
self.results = []
self.visited_all_paths = {}
for contract in self.slither.contracts:
for function in contract.functions:
if function.is_implemented and function.contract == contract:
if function.contains_assembly:
continue
# dont consider storage variable, as they are detected by another detector
uninitialized_local_variables = [v for v in function.local_variables if not v.is_storage and v.uninitialized]
function.entry_point.context[self.key] = uninitialized_local_variables
self._detect_uninitialized(function, function.entry_point, [])
all_results = list(set(self.results))
for(function, uninitialized_local_variable) in all_results:
var_name = uninitialized_local_variable.name
info = "{} in {}.{} ({}) is a local variable never initialiazed\n"
info = info.format(var_name,
function.contract.name,
function.name,
uninitialized_local_variable.source_mapping_str)
json = self.generate_json_result(info)
self.add_variable_to_json(uninitialized_local_variable, json)
self.add_function_to_json(function, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"self",
".",
"results",
"=",
"[",
"]",
"self",
".",
"visited_all_paths",
"=",
"{",
"}",
"for",
"contract",
"in",
"self",
".",
"slither",
".",
"contracts",
":",
"for",
"function",
"in"... | Detect uninitialized local variables
Recursively visit the calls
Returns:
dict: [contract name] = set(local variable uninitialized) | [
"Detect",
"uninitialized",
"local",
"variables"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/variables/uninitialized_local_variables.py#L79-L116 | train |
crytic/slither | slither/detectors/erc20/unindexed_event_parameters.py | UnindexedERC20EventParameters._detect | def _detect(self):
"""
Detect un-indexed ERC20 event parameters in all contracts.
"""
results = []
for c in self.contracts:
unindexed_params = self.detect_erc20_unindexed_event_params(c)
if unindexed_params:
info = "{} ({}) does not mark important ERC20 parameters as 'indexed':\n"
info = info.format(c.name, c.source_mapping_str)
for (event, parameter) in unindexed_params:
info += "\t-{} ({}) does not index parameter '{}'\n".format(event.name, event.source_mapping_str, parameter.name)
# Add the events to the JSON (note: we do not add the params/vars as they have no source mapping).
json = self.generate_json_result(info)
self.add_functions_to_json([event for event, _ in unindexed_params], json)
results.append(json)
return results | python | def _detect(self):
"""
Detect un-indexed ERC20 event parameters in all contracts.
"""
results = []
for c in self.contracts:
unindexed_params = self.detect_erc20_unindexed_event_params(c)
if unindexed_params:
info = "{} ({}) does not mark important ERC20 parameters as 'indexed':\n"
info = info.format(c.name, c.source_mapping_str)
for (event, parameter) in unindexed_params:
info += "\t-{} ({}) does not index parameter '{}'\n".format(event.name, event.source_mapping_str, parameter.name)
# Add the events to the JSON (note: we do not add the params/vars as they have no source mapping).
json = self.generate_json_result(info)
self.add_functions_to_json([event for event, _ in unindexed_params], json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"self",
".",
"contracts",
":",
"unindexed_params",
"=",
"self",
".",
"detect_erc20_unindexed_event_params",
"(",
"c",
")",
"if",
"unindexed_params",
":",
"info",
"=",
"\"{... | Detect un-indexed ERC20 event parameters in all contracts. | [
"Detect",
"un",
"-",
"indexed",
"ERC20",
"event",
"parameters",
"in",
"all",
"contracts",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/erc20/unindexed_event_parameters.py#L67-L85 | train |
crytic/slither | slither/core/slither_core.py | Slither.print_functions | def print_functions(self, d):
"""
Export all the functions to dot files
"""
for c in self.contracts:
for f in c.functions:
f.cfg_to_dot(os.path.join(d, '{}.{}.dot'.format(c.name, f.name))) | python | def print_functions(self, d):
"""
Export all the functions to dot files
"""
for c in self.contracts:
for f in c.functions:
f.cfg_to_dot(os.path.join(d, '{}.{}.dot'.format(c.name, f.name))) | [
"def",
"print_functions",
"(",
"self",
",",
"d",
")",
":",
"for",
"c",
"in",
"self",
".",
"contracts",
":",
"for",
"f",
"in",
"c",
".",
"functions",
":",
"f",
".",
"cfg_to_dot",
"(",
"os",
".",
"path",
".",
"join",
"(",
"d",
",",
"'{}.{}.dot'",
"... | Export all the functions to dot files | [
"Export",
"all",
"the",
"functions",
"to",
"dot",
"files"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/slither_core.py#L155-L161 | train |
crytic/slither | slither/printers/inheritance/inheritance.py | PrinterInheritance.output | def output(self, filename):
"""
Output the inheritance relation
_filename is not used
Args:
_filename(string)
"""
info = 'Inheritance\n'
if not self.contracts:
return
info += blue('Child_Contract -> ') + green('Immediate_Base_Contracts')
info += green(' [Not_Immediate_Base_Contracts]')
for child in self.contracts:
info += blue(f'\n+ {child.name}')
if child.inheritance:
immediate = child.immediate_inheritance
not_immediate = [i for i in child.inheritance if i not in immediate]
info += ' -> ' + green(", ".join(map(str, immediate)))
if not_immediate:
info += ", ["+ green(", ".join(map(str, not_immediate))) + "]"
info += green('\n\nBase_Contract -> ') + blue('Immediate_Child_Contracts')
info += blue(' [Not_Immediate_Child_Contracts]')
for base in self.contracts:
info += green(f'\n+ {base.name}')
children = list(self._get_child_contracts(base))
if children:
immediate = [child for child in children if base in child.immediate_inheritance]
not_immediate = [child for child in children if not child in immediate]
info += ' -> ' + blue(", ".join(map(str, immediate)))
if not_immediate:
info += ', [' + blue(", ".join(map(str, not_immediate))) + ']'
self.info(info) | python | def output(self, filename):
"""
Output the inheritance relation
_filename is not used
Args:
_filename(string)
"""
info = 'Inheritance\n'
if not self.contracts:
return
info += blue('Child_Contract -> ') + green('Immediate_Base_Contracts')
info += green(' [Not_Immediate_Base_Contracts]')
for child in self.contracts:
info += blue(f'\n+ {child.name}')
if child.inheritance:
immediate = child.immediate_inheritance
not_immediate = [i for i in child.inheritance if i not in immediate]
info += ' -> ' + green(", ".join(map(str, immediate)))
if not_immediate:
info += ", ["+ green(", ".join(map(str, not_immediate))) + "]"
info += green('\n\nBase_Contract -> ') + blue('Immediate_Child_Contracts')
info += blue(' [Not_Immediate_Child_Contracts]')
for base in self.contracts:
info += green(f'\n+ {base.name}')
children = list(self._get_child_contracts(base))
if children:
immediate = [child for child in children if base in child.immediate_inheritance]
not_immediate = [child for child in children if not child in immediate]
info += ' -> ' + blue(", ".join(map(str, immediate)))
if not_immediate:
info += ', [' + blue(", ".join(map(str, not_immediate))) + ']'
self.info(info) | [
"def",
"output",
"(",
"self",
",",
"filename",
")",
":",
"info",
"=",
"'Inheritance\\n'",
"if",
"not",
"self",
".",
"contracts",
":",
"return",
"info",
"+=",
"blue",
"(",
"'Child_Contract -> '",
")",
"+",
"green",
"(",
"'Immediate_Base_Contracts'",
")",
"inf... | Output the inheritance relation
_filename is not used
Args:
_filename(string) | [
"Output",
"the",
"inheritance",
"relation"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/printers/inheritance/inheritance.py#L23-L58 | train |
crytic/slither | slither/detectors/variables/uninitialized_storage_variables.py | UninitializedStorageVars._detect | def _detect(self):
""" Detect uninitialized storage variables
Recursively visit the calls
Returns:
dict: [contract name] = set(storage variable uninitialized)
"""
results = []
self.results = []
self.visited_all_paths = {}
for contract in self.slither.contracts:
for function in contract.functions:
if function.is_implemented:
uninitialized_storage_variables = [v for v in function.local_variables if v.is_storage and v.uninitialized]
function.entry_point.context[self.key] = uninitialized_storage_variables
self._detect_uninitialized(function, function.entry_point, [])
for(function, uninitialized_storage_variable) in self.results:
var_name = uninitialized_storage_variable.name
info = "{} in {}.{} ({}) is a storage variable never initialiazed\n"
info = info.format(var_name, function.contract.name, function.name, uninitialized_storage_variable.source_mapping_str)
json = self.generate_json_result(info)
self.add_variable_to_json(uninitialized_storage_variable, json)
self.add_function_to_json(function, json)
results.append(json)
return results | python | def _detect(self):
""" Detect uninitialized storage variables
Recursively visit the calls
Returns:
dict: [contract name] = set(storage variable uninitialized)
"""
results = []
self.results = []
self.visited_all_paths = {}
for contract in self.slither.contracts:
for function in contract.functions:
if function.is_implemented:
uninitialized_storage_variables = [v for v in function.local_variables if v.is_storage and v.uninitialized]
function.entry_point.context[self.key] = uninitialized_storage_variables
self._detect_uninitialized(function, function.entry_point, [])
for(function, uninitialized_storage_variable) in self.results:
var_name = uninitialized_storage_variable.name
info = "{} in {}.{} ({}) is a storage variable never initialiazed\n"
info = info.format(var_name, function.contract.name, function.name, uninitialized_storage_variable.source_mapping_str)
json = self.generate_json_result(info)
self.add_variable_to_json(uninitialized_storage_variable, json)
self.add_function_to_json(function, json)
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"self",
".",
"results",
"=",
"[",
"]",
"self",
".",
"visited_all_paths",
"=",
"{",
"}",
"for",
"contract",
"in",
"self",
".",
"slither",
".",
"contracts",
":",
"for",
"function",
"in"... | Detect uninitialized storage variables
Recursively visit the calls
Returns:
dict: [contract name] = set(storage variable uninitialized) | [
"Detect",
"uninitialized",
"storage",
"variables"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/variables/uninitialized_storage_variables.py#L86-L117 | train |
crytic/slither | slither/detectors/reentrancy/reentrancy.py | Reentrancy._can_callback | def _can_callback(self, irs):
"""
Detect if the node contains a call that can
be used to re-entrance
Consider as valid target:
- low level call
- high level call
Do not consider Send/Transfer as there is not enough gas
"""
for ir in irs:
if isinstance(ir, LowLevelCall):
return True
if isinstance(ir, HighLevelCall) and not isinstance(ir, LibraryCall):
# If solidity >0.5, STATICCALL is used
if self.slither.solc_version and self.slither.solc_version.startswith('0.5.'):
if isinstance(ir.function, Function) and (ir.function.view or ir.function.pure):
continue
if isinstance(ir.function, Variable):
continue
# If there is a call to itself
# We can check that the function called is
# reentrancy-safe
if ir.destination == SolidityVariable('this'):
if isinstance(ir.function, Variable):
continue
if not ir.function.all_high_level_calls():
if not ir.function.all_low_level_calls():
continue
return True
return False | python | def _can_callback(self, irs):
"""
Detect if the node contains a call that can
be used to re-entrance
Consider as valid target:
- low level call
- high level call
Do not consider Send/Transfer as there is not enough gas
"""
for ir in irs:
if isinstance(ir, LowLevelCall):
return True
if isinstance(ir, HighLevelCall) and not isinstance(ir, LibraryCall):
# If solidity >0.5, STATICCALL is used
if self.slither.solc_version and self.slither.solc_version.startswith('0.5.'):
if isinstance(ir.function, Function) and (ir.function.view or ir.function.pure):
continue
if isinstance(ir.function, Variable):
continue
# If there is a call to itself
# We can check that the function called is
# reentrancy-safe
if ir.destination == SolidityVariable('this'):
if isinstance(ir.function, Variable):
continue
if not ir.function.all_high_level_calls():
if not ir.function.all_low_level_calls():
continue
return True
return False | [
"def",
"_can_callback",
"(",
"self",
",",
"irs",
")",
":",
"for",
"ir",
"in",
"irs",
":",
"if",
"isinstance",
"(",
"ir",
",",
"LowLevelCall",
")",
":",
"return",
"True",
"if",
"isinstance",
"(",
"ir",
",",
"HighLevelCall",
")",
"and",
"not",
"isinstanc... | Detect if the node contains a call that can
be used to re-entrance
Consider as valid target:
- low level call
- high level call
Do not consider Send/Transfer as there is not enough gas | [
"Detect",
"if",
"the",
"node",
"contains",
"a",
"call",
"that",
"can",
"be",
"used",
"to",
"re",
"-",
"entrance"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/reentrancy/reentrancy.py#L37-L68 | train |
crytic/slither | slither/detectors/reentrancy/reentrancy.py | Reentrancy._can_send_eth | def _can_send_eth(irs):
"""
Detect if the node can send eth
"""
for ir in irs:
if isinstance(ir, (HighLevelCall, LowLevelCall, Transfer, Send)):
if ir.call_value:
return True
return False | python | def _can_send_eth(irs):
"""
Detect if the node can send eth
"""
for ir in irs:
if isinstance(ir, (HighLevelCall, LowLevelCall, Transfer, Send)):
if ir.call_value:
return True
return False | [
"def",
"_can_send_eth",
"(",
"irs",
")",
":",
"for",
"ir",
"in",
"irs",
":",
"if",
"isinstance",
"(",
"ir",
",",
"(",
"HighLevelCall",
",",
"LowLevelCall",
",",
"Transfer",
",",
"Send",
")",
")",
":",
"if",
"ir",
".",
"call_value",
":",
"return",
"Tr... | Detect if the node can send eth | [
"Detect",
"if",
"the",
"node",
"can",
"send",
"eth"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/reentrancy/reentrancy.py#L71-L79 | train |
crytic/slither | slither/core/cfg/node.py | Node.remove_father | def remove_father(self, father):
""" Remove the father node. Do nothing if the node is not a father
Args:
fathers: list of fathers to add
"""
self._fathers = [x for x in self._fathers if x.node_id != father.node_id] | python | def remove_father(self, father):
""" Remove the father node. Do nothing if the node is not a father
Args:
fathers: list of fathers to add
"""
self._fathers = [x for x in self._fathers if x.node_id != father.node_id] | [
"def",
"remove_father",
"(",
"self",
",",
"father",
")",
":",
"self",
".",
"_fathers",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"_fathers",
"if",
"x",
".",
"node_id",
"!=",
"father",
".",
"node_id",
"]"
] | Remove the father node. Do nothing if the node is not a father
Args:
fathers: list of fathers to add | [
"Remove",
"the",
"father",
"node",
".",
"Do",
"nothing",
"if",
"the",
"node",
"is",
"not",
"a",
"father"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/cfg/node.py#L485-L491 | train |
crytic/slither | slither/core/cfg/node.py | Node.remove_son | def remove_son(self, son):
""" Remove the son node. Do nothing if the node is not a son
Args:
fathers: list of fathers to add
"""
self._sons = [x for x in self._sons if x.node_id != son.node_id] | python | def remove_son(self, son):
""" Remove the son node. Do nothing if the node is not a son
Args:
fathers: list of fathers to add
"""
self._sons = [x for x in self._sons if x.node_id != son.node_id] | [
"def",
"remove_son",
"(",
"self",
",",
"son",
")",
":",
"self",
".",
"_sons",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"_sons",
"if",
"x",
".",
"node_id",
"!=",
"son",
".",
"node_id",
"]"
] | Remove the son node. Do nothing if the node is not a son
Args:
fathers: list of fathers to add | [
"Remove",
"the",
"son",
"node",
".",
"Do",
"nothing",
"if",
"the",
"node",
"is",
"not",
"a",
"son"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/cfg/node.py#L493-L499 | train |
crytic/slither | slither/detectors/statements/deprecated_calls.py | DeprecatedStandards.detect_deprecated_references_in_node | def detect_deprecated_references_in_node(self, node):
""" Detects if a node makes use of any deprecated standards.
Returns:
list of tuple: (detecting_signature, original_text, recommended_text)"""
# Define our results list
results = []
# If this node has an expression, we check the underlying expression.
if node.expression:
results += self.detect_deprecation_in_expression(node.expression)
# Check if there is usage of any deprecated solidity variables or functions
for dep_node in self.DEPRECATED_NODE_TYPES:
if node.type == dep_node[0]:
results.append(dep_node)
return results | python | def detect_deprecated_references_in_node(self, node):
""" Detects if a node makes use of any deprecated standards.
Returns:
list of tuple: (detecting_signature, original_text, recommended_text)"""
# Define our results list
results = []
# If this node has an expression, we check the underlying expression.
if node.expression:
results += self.detect_deprecation_in_expression(node.expression)
# Check if there is usage of any deprecated solidity variables or functions
for dep_node in self.DEPRECATED_NODE_TYPES:
if node.type == dep_node[0]:
results.append(dep_node)
return results | [
"def",
"detect_deprecated_references_in_node",
"(",
"self",
",",
"node",
")",
":",
"results",
"=",
"[",
"]",
"if",
"node",
".",
"expression",
":",
"results",
"+=",
"self",
".",
"detect_deprecation_in_expression",
"(",
"node",
".",
"expression",
")",
"for",
"de... | Detects if a node makes use of any deprecated standards.
Returns:
list of tuple: (detecting_signature, original_text, recommended_text) | [
"Detects",
"if",
"a",
"node",
"makes",
"use",
"of",
"any",
"deprecated",
"standards",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/statements/deprecated_calls.py#L88-L105 | train |
crytic/slither | slither/detectors/statements/deprecated_calls.py | DeprecatedStandards.detect_deprecated_references_in_contract | def detect_deprecated_references_in_contract(self, contract):
""" Detects the usage of any deprecated built-in symbols.
Returns:
list of tuple: (state_variable | node, (detecting_signature, original_text, recommended_text))"""
results = []
for state_variable in contract.variables:
if state_variable.contract != contract:
continue
if state_variable.expression:
deprecated_results = self.detect_deprecation_in_expression(state_variable.expression)
if deprecated_results:
results.append((state_variable, deprecated_results))
# Loop through all functions + modifiers in this contract.
for function in contract.functions + contract.modifiers:
# We should only look for functions declared directly in this contract (not in a base contract).
if function.contract != contract:
continue
# Loop through each node in this function.
for node in function.nodes:
# Detect deprecated references in the node.
deprecated_results = self.detect_deprecated_references_in_node(node)
# Detect additional deprecated low-level-calls.
for ir in node.irs:
if isinstance(ir, LowLevelCall):
for dep_llc in self.DEPRECATED_LOW_LEVEL_CALLS:
if ir.function_name == dep_llc[0]:
deprecated_results.append(dep_llc)
# If we have any results from this iteration, add them to our results list.
if deprecated_results:
results.append((node, deprecated_results))
return results | python | def detect_deprecated_references_in_contract(self, contract):
""" Detects the usage of any deprecated built-in symbols.
Returns:
list of tuple: (state_variable | node, (detecting_signature, original_text, recommended_text))"""
results = []
for state_variable in contract.variables:
if state_variable.contract != contract:
continue
if state_variable.expression:
deprecated_results = self.detect_deprecation_in_expression(state_variable.expression)
if deprecated_results:
results.append((state_variable, deprecated_results))
# Loop through all functions + modifiers in this contract.
for function in contract.functions + contract.modifiers:
# We should only look for functions declared directly in this contract (not in a base contract).
if function.contract != contract:
continue
# Loop through each node in this function.
for node in function.nodes:
# Detect deprecated references in the node.
deprecated_results = self.detect_deprecated_references_in_node(node)
# Detect additional deprecated low-level-calls.
for ir in node.irs:
if isinstance(ir, LowLevelCall):
for dep_llc in self.DEPRECATED_LOW_LEVEL_CALLS:
if ir.function_name == dep_llc[0]:
deprecated_results.append(dep_llc)
# If we have any results from this iteration, add them to our results list.
if deprecated_results:
results.append((node, deprecated_results))
return results | [
"def",
"detect_deprecated_references_in_contract",
"(",
"self",
",",
"contract",
")",
":",
"results",
"=",
"[",
"]",
"for",
"state_variable",
"in",
"contract",
".",
"variables",
":",
"if",
"state_variable",
".",
"contract",
"!=",
"contract",
":",
"continue",
"if... | Detects the usage of any deprecated built-in symbols.
Returns:
list of tuple: (state_variable | node, (detecting_signature, original_text, recommended_text)) | [
"Detects",
"the",
"usage",
"of",
"any",
"deprecated",
"built",
"-",
"in",
"symbols",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/statements/deprecated_calls.py#L107-L144 | train |
crytic/slither | slither/__main__.py | process | def process(filename, args, detector_classes, printer_classes):
"""
The core high-level code for running Slither static analysis.
Returns:
list(result), int: Result list and number of contracts analyzed
"""
ast = '--ast-compact-json'
if args.legacy_ast:
ast = '--ast-json'
args.filter_paths = parse_filter_paths(args)
slither = Slither(filename,
ast_format=ast,
**vars(args))
return _process(slither, detector_classes, printer_classes) | python | def process(filename, args, detector_classes, printer_classes):
"""
The core high-level code for running Slither static analysis.
Returns:
list(result), int: Result list and number of contracts analyzed
"""
ast = '--ast-compact-json'
if args.legacy_ast:
ast = '--ast-json'
args.filter_paths = parse_filter_paths(args)
slither = Slither(filename,
ast_format=ast,
**vars(args))
return _process(slither, detector_classes, printer_classes) | [
"def",
"process",
"(",
"filename",
",",
"args",
",",
"detector_classes",
",",
"printer_classes",
")",
":",
"ast",
"=",
"'--ast-compact-json'",
"if",
"args",
".",
"legacy_ast",
":",
"ast",
"=",
"'--ast-json'",
"args",
".",
"filter_paths",
"=",
"parse_filter_paths... | The core high-level code for running Slither static analysis.
Returns:
list(result), int: Result list and number of contracts analyzed | [
"The",
"core",
"high",
"-",
"level",
"code",
"for",
"running",
"Slither",
"static",
"analysis",
"."
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/__main__.py#L38-L53 | train |
crytic/slither | slither/detectors/attributes/const_functions.py | ConstantFunctions._detect | def _detect(self):
""" Detect the constant function changing the state
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func','#varsWritten'}
"""
results = []
for c in self.contracts:
for f in c.functions:
if f.contract != c:
continue
if f.view or f.pure:
if f.contains_assembly:
attr = 'view' if f.view else 'pure'
info = '{}.{} ({}) is declared {} but contains assembly code\n'
info = info.format(f.contract.name, f.name, f.source_mapping_str, attr)
json = self.generate_json_result(info)
self.add_function_to_json(f, json)
json['elements'].append({'type': 'info',
'contains_assembly' : True})
results.append(json)
variables_written = f.all_state_variables_written()
if variables_written:
attr = 'view' if f.view else 'pure'
info = '{}.{} ({}) is declared {} but changes state variables:\n'
info = info.format(f.contract.name, f.name, f.source_mapping_str, attr)
for variable_written in variables_written:
info += '\t- {}.{}\n'.format(variable_written.contract.name,
variable_written.name)
json = self.generate_json_result(info)
self.add_function_to_json(f, json)
self.add_variables_to_json(variables_written, json)
json['elements'].append({'type': 'info',
'contains_assembly' : False})
results.append(json)
return results | python | def _detect(self):
""" Detect the constant function changing the state
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func','#varsWritten'}
"""
results = []
for c in self.contracts:
for f in c.functions:
if f.contract != c:
continue
if f.view or f.pure:
if f.contains_assembly:
attr = 'view' if f.view else 'pure'
info = '{}.{} ({}) is declared {} but contains assembly code\n'
info = info.format(f.contract.name, f.name, f.source_mapping_str, attr)
json = self.generate_json_result(info)
self.add_function_to_json(f, json)
json['elements'].append({'type': 'info',
'contains_assembly' : True})
results.append(json)
variables_written = f.all_state_variables_written()
if variables_written:
attr = 'view' if f.view else 'pure'
info = '{}.{} ({}) is declared {} but changes state variables:\n'
info = info.format(f.contract.name, f.name, f.source_mapping_str, attr)
for variable_written in variables_written:
info += '\t- {}.{}\n'.format(variable_written.contract.name,
variable_written.name)
json = self.generate_json_result(info)
self.add_function_to_json(f, json)
self.add_variables_to_json(variables_written, json)
json['elements'].append({'type': 'info',
'contains_assembly' : False})
results.append(json)
return results | [
"def",
"_detect",
"(",
"self",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"self",
".",
"contracts",
":",
"for",
"f",
"in",
"c",
".",
"functions",
":",
"if",
"f",
".",
"contract",
"!=",
"c",
":",
"continue",
"if",
"f",
".",
"view",
"o... | Detect the constant function changing the state
Recursively visit the calls
Returns:
list: {'vuln', 'filename,'contract','func','#varsWritten'} | [
"Detect",
"the",
"constant",
"function",
"changing",
"the",
"state"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/detectors/attributes/const_functions.py#L44-L84 | train |
crytic/slither | slither/core/declarations/contract.py | Contract.constructor | def constructor(self):
'''
Return the contract's immediate constructor.
If there is no immediate constructor, returns the first constructor
executed, following the c3 linearization
Return None if there is no constructor.
'''
cst = self.constructor_not_inherited
if cst:
return cst
for inherited_contract in self.inheritance:
cst = inherited_contract.constructor_not_inherited
if cst:
return cst
return None | python | def constructor(self):
'''
Return the contract's immediate constructor.
If there is no immediate constructor, returns the first constructor
executed, following the c3 linearization
Return None if there is no constructor.
'''
cst = self.constructor_not_inherited
if cst:
return cst
for inherited_contract in self.inheritance:
cst = inherited_contract.constructor_not_inherited
if cst:
return cst
return None | [
"def",
"constructor",
"(",
"self",
")",
":",
"cst",
"=",
"self",
".",
"constructor_not_inherited",
"if",
"cst",
":",
"return",
"cst",
"for",
"inherited_contract",
"in",
"self",
".",
"inheritance",
":",
"cst",
"=",
"inherited_contract",
".",
"constructor_not_inhe... | Return the contract's immediate constructor.
If there is no immediate constructor, returns the first constructor
executed, following the c3 linearization
Return None if there is no constructor. | [
"Return",
"the",
"contract",
"s",
"immediate",
"constructor",
".",
"If",
"there",
"is",
"no",
"immediate",
"constructor",
"returns",
"the",
"first",
"constructor",
"executed",
"following",
"the",
"c3",
"linearization",
"Return",
"None",
"if",
"there",
"is",
"no"... | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/declarations/contract.py#L168-L182 | train |
crytic/slither | slither/core/declarations/contract.py | Contract.get_functions_reading_from_variable | def get_functions_reading_from_variable(self, variable):
'''
Return the functions reading the variable
'''
return [f for f in self.functions if f.is_reading(variable)] | python | def get_functions_reading_from_variable(self, variable):
'''
Return the functions reading the variable
'''
return [f for f in self.functions if f.is_reading(variable)] | [
"def",
"get_functions_reading_from_variable",
"(",
"self",
",",
"variable",
")",
":",
"return",
"[",
"f",
"for",
"f",
"in",
"self",
".",
"functions",
"if",
"f",
".",
"is_reading",
"(",
"variable",
")",
"]"
] | Return the functions reading the variable | [
"Return",
"the",
"functions",
"reading",
"the",
"variable"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/declarations/contract.py#L339-L343 | train |
crytic/slither | slither/core/declarations/contract.py | Contract.get_functions_writing_to_variable | def get_functions_writing_to_variable(self, variable):
'''
Return the functions writting the variable
'''
return [f for f in self.functions if f.is_writing(variable)] | python | def get_functions_writing_to_variable(self, variable):
'''
Return the functions writting the variable
'''
return [f for f in self.functions if f.is_writing(variable)] | [
"def",
"get_functions_writing_to_variable",
"(",
"self",
",",
"variable",
")",
":",
"return",
"[",
"f",
"for",
"f",
"in",
"self",
".",
"functions",
"if",
"f",
".",
"is_writing",
"(",
"variable",
")",
"]"
] | Return the functions writting the variable | [
"Return",
"the",
"functions",
"writting",
"the",
"variable"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/declarations/contract.py#L345-L349 | train |
crytic/slither | slither/core/declarations/contract.py | Contract.get_source_var_declaration | def get_source_var_declaration(self, var):
""" Return the source mapping where the variable is declared
Args:
var (str): variable name
Returns:
(dict): sourceMapping
"""
return next((x.source_mapping for x in self.variables if x.name == var)) | python | def get_source_var_declaration(self, var):
""" Return the source mapping where the variable is declared
Args:
var (str): variable name
Returns:
(dict): sourceMapping
"""
return next((x.source_mapping for x in self.variables if x.name == var)) | [
"def",
"get_source_var_declaration",
"(",
"self",
",",
"var",
")",
":",
"return",
"next",
"(",
"(",
"x",
".",
"source_mapping",
"for",
"x",
"in",
"self",
".",
"variables",
"if",
"x",
".",
"name",
"==",
"var",
")",
")"
] | Return the source mapping where the variable is declared
Args:
var (str): variable name
Returns:
(dict): sourceMapping | [
"Return",
"the",
"source",
"mapping",
"where",
"the",
"variable",
"is",
"declared"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/declarations/contract.py#L351-L359 | train |
crytic/slither | slither/core/declarations/contract.py | Contract.get_source_event_declaration | def get_source_event_declaration(self, event):
""" Return the source mapping where the event is declared
Args:
event (str): event name
Returns:
(dict): sourceMapping
"""
return next((x.source_mapping for x in self.events if x.name == event)) | python | def get_source_event_declaration(self, event):
""" Return the source mapping where the event is declared
Args:
event (str): event name
Returns:
(dict): sourceMapping
"""
return next((x.source_mapping for x in self.events if x.name == event)) | [
"def",
"get_source_event_declaration",
"(",
"self",
",",
"event",
")",
":",
"return",
"next",
"(",
"(",
"x",
".",
"source_mapping",
"for",
"x",
"in",
"self",
".",
"events",
"if",
"x",
".",
"name",
"==",
"event",
")",
")"
] | Return the source mapping where the event is declared
Args:
event (str): event name
Returns:
(dict): sourceMapping | [
"Return",
"the",
"source",
"mapping",
"where",
"the",
"event",
"is",
"declared"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/declarations/contract.py#L361-L369 | train |
crytic/slither | slither/core/declarations/contract.py | Contract.get_summary | def get_summary(self):
""" Return the function summary
Returns:
(str, list, list, list, list): (name, inheritance, variables, fuction summaries, modifier summaries)
"""
func_summaries = [f.get_summary() for f in self.functions]
modif_summaries = [f.get_summary() for f in self.modifiers]
return (self.name, [str(x) for x in self.inheritance], [str(x) for x in self.variables], func_summaries, modif_summaries) | python | def get_summary(self):
""" Return the function summary
Returns:
(str, list, list, list, list): (name, inheritance, variables, fuction summaries, modifier summaries)
"""
func_summaries = [f.get_summary() for f in self.functions]
modif_summaries = [f.get_summary() for f in self.modifiers]
return (self.name, [str(x) for x in self.inheritance], [str(x) for x in self.variables], func_summaries, modif_summaries) | [
"def",
"get_summary",
"(",
"self",
")",
":",
"func_summaries",
"=",
"[",
"f",
".",
"get_summary",
"(",
")",
"for",
"f",
"in",
"self",
".",
"functions",
"]",
"modif_summaries",
"=",
"[",
"f",
".",
"get_summary",
"(",
")",
"for",
"f",
"in",
"self",
"."... | Return the function summary
Returns:
(str, list, list, list, list): (name, inheritance, variables, fuction summaries, modifier summaries) | [
"Return",
"the",
"function",
"summary"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/declarations/contract.py#L512-L520 | train |
crytic/slither | slither/core/declarations/contract.py | Contract.is_erc20 | def is_erc20(self):
"""
Check if the contract is an erc20 token
Note: it does not check for correct return values
Returns:
bool
"""
full_names = [f.full_name for f in self.functions]
return 'transfer(address,uint256)' in full_names and\
'transferFrom(address,address,uint256)' in full_names and\
'approve(address,uint256)' in full_names | python | def is_erc20(self):
"""
Check if the contract is an erc20 token
Note: it does not check for correct return values
Returns:
bool
"""
full_names = [f.full_name for f in self.functions]
return 'transfer(address,uint256)' in full_names and\
'transferFrom(address,address,uint256)' in full_names and\
'approve(address,uint256)' in full_names | [
"def",
"is_erc20",
"(",
"self",
")",
":",
"full_names",
"=",
"[",
"f",
".",
"full_name",
"for",
"f",
"in",
"self",
".",
"functions",
"]",
"return",
"'transfer(address,uint256)'",
"in",
"full_names",
"and",
"'transferFrom(address,address,uint256)'",
"in",
"full_nam... | Check if the contract is an erc20 token
Note: it does not check for correct return values
Returns:
bool | [
"Check",
"if",
"the",
"contract",
"is",
"an",
"erc20",
"token"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/core/declarations/contract.py#L530-L541 | train |
crytic/slither | slither/slithir/convert.py | integrate_value_gas | def integrate_value_gas(result):
'''
Integrate value and gas temporary arguments to call instruction
'''
was_changed = True
calls = []
while was_changed:
# We loop until we do not find any call to value or gas
was_changed = False
# Find all the assignments
assigments = {}
for i in result:
if isinstance(i, OperationWithLValue):
assigments[i.lvalue.name] = i
if isinstance(i, TmpCall):
if isinstance(i.called, Variable) and i.called.name in assigments:
ins_ori = assigments[i.called.name]
i.set_ori(ins_ori)
to_remove = []
variable_to_replace = {}
# Replace call to value, gas to an argument of the real call
for idx in range(len(result)):
ins = result[idx]
# value can be shadowed, so we check that the prev ins
# is an Argument
if is_value(ins) and isinstance(result[idx-1], Argument):
was_changed = True
result[idx-1].set_type(ArgumentType.VALUE)
result[idx-1].call_id = ins.ori.variable_left.name
calls.append(ins.ori.variable_left)
to_remove.append(ins)
variable_to_replace[ins.lvalue.name] = ins.ori.variable_left
elif is_gas(ins) and isinstance(result[idx-1], Argument):
was_changed = True
result[idx-1].set_type(ArgumentType.GAS)
result[idx-1].call_id = ins.ori.variable_left.name
calls.append(ins.ori.variable_left)
to_remove.append(ins)
variable_to_replace[ins.lvalue.name] = ins.ori.variable_left
# Remove the call to value/gas instruction
result = [i for i in result if not i in to_remove]
# update the real call
for ins in result:
if isinstance(ins, TmpCall):
# use of while if there redirections
while ins.called.name in variable_to_replace:
was_changed = True
ins.call_id = variable_to_replace[ins.called.name].name
calls.append(ins.called)
ins.called = variable_to_replace[ins.called.name]
if isinstance(ins, Argument):
while ins.call_id in variable_to_replace:
was_changed = True
ins.call_id = variable_to_replace[ins.call_id].name
calls = list(set([str(c) for c in calls]))
idx = 0
calls_d = {}
for call in calls:
calls_d[str(call)] = idx
idx = idx+1
return result | python | def integrate_value_gas(result):
'''
Integrate value and gas temporary arguments to call instruction
'''
was_changed = True
calls = []
while was_changed:
# We loop until we do not find any call to value or gas
was_changed = False
# Find all the assignments
assigments = {}
for i in result:
if isinstance(i, OperationWithLValue):
assigments[i.lvalue.name] = i
if isinstance(i, TmpCall):
if isinstance(i.called, Variable) and i.called.name in assigments:
ins_ori = assigments[i.called.name]
i.set_ori(ins_ori)
to_remove = []
variable_to_replace = {}
# Replace call to value, gas to an argument of the real call
for idx in range(len(result)):
ins = result[idx]
# value can be shadowed, so we check that the prev ins
# is an Argument
if is_value(ins) and isinstance(result[idx-1], Argument):
was_changed = True
result[idx-1].set_type(ArgumentType.VALUE)
result[idx-1].call_id = ins.ori.variable_left.name
calls.append(ins.ori.variable_left)
to_remove.append(ins)
variable_to_replace[ins.lvalue.name] = ins.ori.variable_left
elif is_gas(ins) and isinstance(result[idx-1], Argument):
was_changed = True
result[idx-1].set_type(ArgumentType.GAS)
result[idx-1].call_id = ins.ori.variable_left.name
calls.append(ins.ori.variable_left)
to_remove.append(ins)
variable_to_replace[ins.lvalue.name] = ins.ori.variable_left
# Remove the call to value/gas instruction
result = [i for i in result if not i in to_remove]
# update the real call
for ins in result:
if isinstance(ins, TmpCall):
# use of while if there redirections
while ins.called.name in variable_to_replace:
was_changed = True
ins.call_id = variable_to_replace[ins.called.name].name
calls.append(ins.called)
ins.called = variable_to_replace[ins.called.name]
if isinstance(ins, Argument):
while ins.call_id in variable_to_replace:
was_changed = True
ins.call_id = variable_to_replace[ins.call_id].name
calls = list(set([str(c) for c in calls]))
idx = 0
calls_d = {}
for call in calls:
calls_d[str(call)] = idx
idx = idx+1
return result | [
"def",
"integrate_value_gas",
"(",
"result",
")",
":",
"was_changed",
"=",
"True",
"calls",
"=",
"[",
"]",
"while",
"was_changed",
":",
"was_changed",
"=",
"False",
"assigments",
"=",
"{",
"}",
"for",
"i",
"in",
"result",
":",
"if",
"isinstance",
"(",
"i... | Integrate value and gas temporary arguments to call instruction | [
"Integrate",
"value",
"and",
"gas",
"temporary",
"arguments",
"to",
"call",
"instruction"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/slithir/convert.py#L144-L213 | train |
crytic/slither | slither/slithir/convert.py | propagate_type_and_convert_call | def propagate_type_and_convert_call(result, node):
'''
Propagate the types variables and convert tmp call to real call operation
'''
calls_value = {}
calls_gas = {}
call_data = []
idx = 0
# use of while len() as result can be modified during the iteration
while idx < len(result):
ins = result[idx]
if isinstance(ins, TmpCall):
new_ins = extract_tmp_call(ins, node.function.contract)
if new_ins:
new_ins.set_node(ins.node)
ins = new_ins
result[idx] = ins
if isinstance(ins, Argument):
if ins.get_type() in [ArgumentType.GAS]:
assert not ins.call_id in calls_gas
calls_gas[ins.call_id] = ins.argument
elif ins.get_type() in [ArgumentType.VALUE]:
assert not ins.call_id in calls_value
calls_value[ins.call_id] = ins.argument
else:
assert ins.get_type() == ArgumentType.CALL
call_data.append(ins.argument)
if isinstance(ins, (HighLevelCall, NewContract, InternalDynamicCall)):
if ins.call_id in calls_value:
ins.call_value = calls_value[ins.call_id]
if ins.call_id in calls_gas:
ins.call_gas = calls_gas[ins.call_id]
if isinstance(ins, (Call, NewContract, NewStructure)):
ins.arguments = call_data
call_data = []
if is_temporary(ins):
del result[idx]
continue
new_ins = propagate_types(ins, node)
if new_ins:
if isinstance(new_ins, (list,)):
if len(new_ins) == 2:
new_ins[0].set_node(ins.node)
new_ins[1].set_node(ins.node)
del result[idx]
result.insert(idx, new_ins[0])
result.insert(idx+1, new_ins[1])
idx = idx + 1
else:
assert len(new_ins) == 3
new_ins[0].set_node(ins.node)
new_ins[1].set_node(ins.node)
new_ins[2].set_node(ins.node)
del result[idx]
result.insert(idx, new_ins[0])
result.insert(idx+1, new_ins[1])
result.insert(idx+2, new_ins[2])
idx = idx + 2
else:
new_ins.set_node(ins.node)
result[idx] = new_ins
idx = idx +1
return result | python | def propagate_type_and_convert_call(result, node):
'''
Propagate the types variables and convert tmp call to real call operation
'''
calls_value = {}
calls_gas = {}
call_data = []
idx = 0
# use of while len() as result can be modified during the iteration
while idx < len(result):
ins = result[idx]
if isinstance(ins, TmpCall):
new_ins = extract_tmp_call(ins, node.function.contract)
if new_ins:
new_ins.set_node(ins.node)
ins = new_ins
result[idx] = ins
if isinstance(ins, Argument):
if ins.get_type() in [ArgumentType.GAS]:
assert not ins.call_id in calls_gas
calls_gas[ins.call_id] = ins.argument
elif ins.get_type() in [ArgumentType.VALUE]:
assert not ins.call_id in calls_value
calls_value[ins.call_id] = ins.argument
else:
assert ins.get_type() == ArgumentType.CALL
call_data.append(ins.argument)
if isinstance(ins, (HighLevelCall, NewContract, InternalDynamicCall)):
if ins.call_id in calls_value:
ins.call_value = calls_value[ins.call_id]
if ins.call_id in calls_gas:
ins.call_gas = calls_gas[ins.call_id]
if isinstance(ins, (Call, NewContract, NewStructure)):
ins.arguments = call_data
call_data = []
if is_temporary(ins):
del result[idx]
continue
new_ins = propagate_types(ins, node)
if new_ins:
if isinstance(new_ins, (list,)):
if len(new_ins) == 2:
new_ins[0].set_node(ins.node)
new_ins[1].set_node(ins.node)
del result[idx]
result.insert(idx, new_ins[0])
result.insert(idx+1, new_ins[1])
idx = idx + 1
else:
assert len(new_ins) == 3
new_ins[0].set_node(ins.node)
new_ins[1].set_node(ins.node)
new_ins[2].set_node(ins.node)
del result[idx]
result.insert(idx, new_ins[0])
result.insert(idx+1, new_ins[1])
result.insert(idx+2, new_ins[2])
idx = idx + 2
else:
new_ins.set_node(ins.node)
result[idx] = new_ins
idx = idx +1
return result | [
"def",
"propagate_type_and_convert_call",
"(",
"result",
",",
"node",
")",
":",
"calls_value",
"=",
"{",
"}",
"calls_gas",
"=",
"{",
"}",
"call_data",
"=",
"[",
"]",
"idx",
"=",
"0",
"while",
"idx",
"<",
"len",
"(",
"result",
")",
":",
"ins",
"=",
"r... | Propagate the types variables and convert tmp call to real call operation | [
"Propagate",
"the",
"types",
"variables",
"and",
"convert",
"tmp",
"call",
"to",
"real",
"call",
"operation"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/slithir/convert.py#L222-L292 | train |
crytic/slither | slither/slithir/convert.py | convert_to_push | def convert_to_push(ir, node):
"""
Convert a call to a PUSH operaiton
The funciton assume to receive a correct IR
The checks must be done by the caller
May necessitate to create an intermediate operation (InitArray)
Necessitate to return the lenght (see push documentation)
As a result, the function return may return a list
"""
lvalue = ir.lvalue
if isinstance(ir.arguments[0], list):
ret = []
val = TemporaryVariable(node)
operation = InitArray(ir.arguments[0], val)
ret.append(operation)
ir = Push(ir.destination, val)
length = Literal(len(operation.init_values))
t = operation.init_values[0].type
ir.lvalue.set_type(ArrayType(t, length))
ret.append(ir)
if lvalue:
length = Length(ir.array, lvalue)
length.lvalue.points_to = ir.lvalue
ret.append(length)
return ret
ir = Push(ir.destination, ir.arguments[0])
if lvalue:
ret = []
ret.append(ir)
length = Length(ir.array, lvalue)
length.lvalue.points_to = ir.lvalue
ret.append(length)
return ret
return ir | python | def convert_to_push(ir, node):
"""
Convert a call to a PUSH operaiton
The funciton assume to receive a correct IR
The checks must be done by the caller
May necessitate to create an intermediate operation (InitArray)
Necessitate to return the lenght (see push documentation)
As a result, the function return may return a list
"""
lvalue = ir.lvalue
if isinstance(ir.arguments[0], list):
ret = []
val = TemporaryVariable(node)
operation = InitArray(ir.arguments[0], val)
ret.append(operation)
ir = Push(ir.destination, val)
length = Literal(len(operation.init_values))
t = operation.init_values[0].type
ir.lvalue.set_type(ArrayType(t, length))
ret.append(ir)
if lvalue:
length = Length(ir.array, lvalue)
length.lvalue.points_to = ir.lvalue
ret.append(length)
return ret
ir = Push(ir.destination, ir.arguments[0])
if lvalue:
ret = []
ret.append(ir)
length = Length(ir.array, lvalue)
length.lvalue.points_to = ir.lvalue
ret.append(length)
return ret
return ir | [
"def",
"convert_to_push",
"(",
"ir",
",",
"node",
")",
":",
"lvalue",
"=",
"ir",
".",
"lvalue",
"if",
"isinstance",
"(",
"ir",
".",
"arguments",
"[",
"0",
"]",
",",
"list",
")",
":",
"ret",
"=",
"[",
"]",
"val",
"=",
"TemporaryVariable",
"(",
"node... | Convert a call to a PUSH operaiton
The funciton assume to receive a correct IR
The checks must be done by the caller
May necessitate to create an intermediate operation (InitArray)
Necessitate to return the lenght (see push documentation)
As a result, the function return may return a list | [
"Convert",
"a",
"call",
"to",
"a",
"PUSH",
"operaiton"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/slithir/convert.py#L579-L626 | train |
crytic/slither | slither/slithir/convert.py | get_type | def get_type(t):
"""
Convert a type to a str
If the instance is a Contract, return 'address' instead
"""
if isinstance(t, UserDefinedType):
if isinstance(t.type, Contract):
return 'address'
return str(t) | python | def get_type(t):
"""
Convert a type to a str
If the instance is a Contract, return 'address' instead
"""
if isinstance(t, UserDefinedType):
if isinstance(t.type, Contract):
return 'address'
return str(t) | [
"def",
"get_type",
"(",
"t",
")",
":",
"if",
"isinstance",
"(",
"t",
",",
"UserDefinedType",
")",
":",
"if",
"isinstance",
"(",
"t",
".",
"type",
",",
"Contract",
")",
":",
"return",
"'address'",
"return",
"str",
"(",
"t",
")"
] | Convert a type to a str
If the instance is a Contract, return 'address' instead | [
"Convert",
"a",
"type",
"to",
"a",
"str",
"If",
"the",
"instance",
"is",
"a",
"Contract",
"return",
"address",
"instead"
] | 04c147f7e50223c6af458ca430befae747ccd259 | https://github.com/crytic/slither/blob/04c147f7e50223c6af458ca430befae747ccd259/slither/slithir/convert.py#L661-L669 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.