def loginAPI():
global internal_storage, interruptQueue
pub_hex = request.values.get("pub_key")
pub_key = pub_hex
internal_storage["Public_key"] = pub_key
priv_hex = request.values.get("priv_key")
priv_key = priv_hex
internal_storage["Private_key"] = priv_key
if getNeighbours(self_address):
# not the first one
# request latest block as json
current_block = requestLatestBlock()
data = json.loads(current_block)
tx_list = []
for tx in data['Tx_list']:
tx_list.append(createTxFromDict(tx))
# build block
b = createBlockFromDict(tx_list, data)
# update state
bc = blockChain.Blockchain(_block=b)
internal_storage["Miner"] = miner.Miner(
_blockchain=bc,
_pub=pub_key,
_priv=priv_key
)
else:
# create first block
internal_storage["Miner"] = miner.Miner(_blockchain=None,
_pub=pub_key,
_priv=priv_key)
generator = internal_storage["Miner"].mineBlock()
try:
interruptQueue = next(generator)
block_data = next(generator)
internal_storage["Miner"].broadcastBlock(
_block_data=block_data,
_neighbours=internal_storage["Neighbour_nodes"],
_self_addr=self_address,
)
except StopIteration:
print("MinerApp Interrupted")
# re-routes back to homepage
return homePage()
def stat_from_memory(app, tlibpath="../tlib/", mempath="../memory/"):
if os.path.exists("/tmp/stat.txt"):
os.remove("/tmp/stat.txt")
mine = miner.Miner(None, None, None, tlibpath, True, app, None, None, None,
None, mempath, False)
mine.save_stat("/tmp/stat.txt")
return load_statfile("/tmp/stat.txt")
def test_part_two(self):
"Test part two example of Miner object"
# 1. Create Miner object from text
myobj = miner.Miner(part2=True, text=aoc_04.from_text(PART_TWO_TEXT))
# 2. Check the part two result
self.assertEqual(myobj.part_two(verbose=False), PART_TWO_RESULT)
def test_part_one(self):
"Test part one example of Miner object"
# 1. Create Miner object from text
myobj = miner.Miner(text=aoc_04.from_text(PART_ONE_TEXT))
# 2. Check the part one result
self.assertEqual(myobj.part_one(verbose=False), PART_ONE_RESULT)
def test_empty_init(self):
"Test the default Miner creation"
# 1. Create default Miner object
myobj = miner.Miner()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, None)
def __init__(self):
'''
Constructor function that creates a genesis block as soon as the
Blockchain class is created.
'''
self.main_chain_genesis = None
self.latest_block = None
self.__createGenesisBlock()
miner.Miner(-1).mine(self.main_chain_genesis)
def test_text_init(self):
"Test the Miner object creation from text"
# 1. Create Miner object from text
myobj = miner.Miner(text=aoc_04.from_text(EXAMPLE_TEXT))
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 1)
# 3. Check methods
self.assertTrue(myobj.md5_number(609043).startswith('000001dbbfa'))
def insertAnalyzedResult(self, stockId, targetAt, period):
stock = self.dbm.selectStockById(stockId)
stockName = stock.get('name')
print(stockName, 'is analyze', targetAt)
if self.dbm.isNotForecastTarget(stock, targetAt.date(), period):
return
mine = miner.Miner()
targetPlusCnt, targetMinusCnt, totalPlusCnt, totalMinusCnt, targetChartList, totalChartList, targetFinanceIdList, duration = mine.getAnalyzedCnt(
targetAt, period, stockName, stock.get('id'))
savedItemId = self.dbm.saveAnalyzedData(stockName, targetPlusCnt, targetMinusCnt, totalPlusCnt, totalMinusCnt,
targetAt, period, duration)
self.dbm.saveAnalyzedItemFinanceList(savedItemId, targetFinanceIdList)
self.dbm.updateAnalyzedResultItem(stock)
self.dbm.commit()
def initiate_miners():
the_miners_list = []
if blockchainPlacement == 1:
for i in range(NumOfFogNodes):
the_miners_list.append(
miner.Miner(i + 1, trans_delay, gossip_activated))
if blockchainPlacement == 2:
for i in range(NumOfMiners):
the_miners_list.append(
miner.Miner(i + 1, trans_delay, gossip_activated))
for entity in the_miners_list:
modification.write_file(
"temporary/" + entity.address + "_local_chain.json", {})
miner_wallets_log_py = modification.read_file(
"temporary/miner_wallets_log.json")
miner_wallets_log_py[str(
entity.address)] = data['miners_initial_wallet_value']
modification.rewrite_file("temporary/miner_wallets_log.json",
miner_wallets_log_py)
connect_miners(the_miners_list)
output.miners_are_up()
return the_miners_list
def initiate_miners():
the_miners_list = []
miner_wallets_log_py = {}
if blockchainPlacement == 1:
for i in range(NumOfFogNodes):
the_miners_list.append(
miner.Miner(i + 1, trans_delay, gossip_activated))
if blockchainPlacement == 2:
for i in range(NumOfMiners):
the_miners_list.append(
miner.Miner(i + 1, trans_delay, gossip_activated))
for entity in the_miners_list:
with open(str("temporary/" + entity.address + "_local_chain.json"),
"w") as f:
json.dump({}, f)
with open("temporary/miner_wallets_log.json",
'w') as miner_wallets_log:
miner_wallets_log_py[str(
entity.address)] = data['miners_initial_wallet_value']
json.dump(miner_wallets_log_py, miner_wallets_log, indent=4)
connect_miners(the_miners_list)
output.miners_are_up()
return the_miners_list
def part_two(args, input_lines):
"Process part two of the puzzle"
# 1. Create the puzzle solver
solver = miner.Miner(part2=True, text=input_lines)
# 2. Determine the solution for part two
solution = solver.part_two(verbose=args.verbose, limit=args.limit)
if solution is None:
print("There is no solution")
else:
print("The solution for part two is %s" % (solution))
# 3. Return result
return solution is not None
def __init__(self, repo_dir, src_dir_suffix, model, top_n,
retriever_score_weight):
print("Mining repository data")
self.top_n = top_n
self.retriever_score_weight = retriever_score_weight
self.repository_miner = miner.Miner(repo_dir, src_dir_suffix)
self.miner_data = self.repository_miner.mine()
self.prediction_data = [[f[0], [m[0] for m in f[1]]]
for f in self.miner_data]
self.result_transformer = SourceParagraphsTransformer(
self.repository_miner.files)
print("Fitting the pipeline")
self.cdqa_pipeline = QAPipeline(
reader=model,
min_df=0.0,
max_df=1.0,
top_n=self.top_n,
retriever_score_weight=retriever_score_weight)
def newUser():
global internal_storage, interruptQueue
priv, pub = keyPair.GenerateKeyPair()
internal_storage["Private_key"] = priv.to_string().hex()
internal_storage["Public_key"] = pub.to_string().hex()
newUser = open("Newuser.html").read()
info = "Public Key: {}<br>" \
"Private Key: {}<br>" \
"Please save these 2 (They are unrecoverable)".format(
pub.to_string().hex(),
priv.to_string().hex()
)
pub_key = internal_storage["Public_key"]
priv_key = internal_storage["Private_key"]
internal_storage["Miner"] = miner.Miner(_pub=pub_key, _priv=priv_key)
# announce yourself
getNeighbours(self_address)
generator = internal_storage["Miner"].mineBlock()
try:
interruptQueue = next(generator)
block_data = next(generator)
internal_storage["Miner"].broadcastBlock(
_block_data=block_data,
_neighbours=internal_storage["Neighbour_nodes"],
_self_addr=self_address,
)
except StopIteration:
print("MinerApp New Interrupted")
return info + newUser
def makeMiner(self, blockchain, txnMemoryPool):
self.miner = miner.Miner(blockchain, txnMemoryPool)
class VCM:
"""
This class is simple abstract class
just for showing responsibility of
VCM (Vote Casting Machine).
It just simulates VCMs' behavior.
"""
blockchain = blockchain.Blockchain()
miner = miner.Miner(100)
election_public_key = crypto.load_public_key_file(config.ELECTION_KEYS_FOLDER, "election")
def __init__(self, id):
self.id = id
self.private_key = crypto.load_private_key_file(config.VCM_KEYS_FOLDER, str(self.id))
self.genesis_block = self.blockchain.get_block(0)
"""
Start the machine.
:param self: self class
"""
def start(self):
while True:
os.system("clear")
print("Welcome to Voting Interface")
voter_id = raw_input("Please enter your ID: ")
print("Verifying election signature...")
self._verify_genesis_block()
print("Election signature verification is successful")
print("Fetching your electronic ballots...")
voter_decrypted_ballots = self._get_voter_ballots(voter_id)
print("Time to vote...")
# let user read output
self._wait_and_clear(2)
for ballot in voter_decrypted_ballots:
election_id_to_vote = ballot["election_id"]
election_to_vote = self.genesis_block["content"]["election"][str(election_id_to_vote)]
print("=" * 50)
print("Please make your choice for %s \n" % election_to_vote["name"])
print("Canditates are below: \n")
for index, candidate in enumerate(election_to_vote["candidates"], start=1):
print("%d) %s" % (index, candidate))
while True:
candidate_index = raw_input("\nPlease enter your choice: ")
candidate_index = int(candidate_index)
if candidate_index > 0 and candidate_index <= len(election_to_vote["candidates"]):
chosen_candidate = election_to_vote["candidates"][candidate_index - 1]
self.miner.add_vote(
self._cast_vote(chosen_candidate, ballot)
)
print("\nYou have chosen %s to vote" % (chosen_candidate))
print("=" * 50)
self._wait_and_clear(1)
break
else:
print("Please enter a value between 1 and %d \n" % (len(election_to_vote["candidates"])))
print("Thanks for voting!")
print("Restarting...")
self._wait_and_clear(3)
"""
Verify genesis block.
:param self: self class
"""
def _verify_genesis_block(self):
crypto.verify(self.genesis_block["header"]["signature"], json.dumps(self.genesis_block["content"], sort_keys=True), self.election_public_key)
"""
Get given voter's ballots.
:param self: self class
:param voter_id: voter_id
"""
def _get_voter_ballots(self, voter_id):
voter_decrypted_ballots = []
voter_private_key = crypto.load_private_key_file(config.VOTER_KEYS_FOLDER, voter_id)
voter_ballots = self.genesis_block["content"]["encrypted_ballots"][voter_id]
for ballot in voter_ballots:
decrypted_ballot = crypto.decrypt(ballot, voter_private_key)
voter_decrypted_ballots.append(json.loads(decrypted_ballot))
return voter_decrypted_ballots
"""
Cast a vote with given parameters and sign it.
:param self: self class
:param chosen_candidate: chosen candidate
:param proof: ballot content
"""
def _cast_vote(self, chosen_candidate, proof):
content = {
"proof": proof,
"vote": crypto.encrypt(str(chosen_candidate), self.election_public_key)
}
return {
"content": content,
"header": {
"signature": crypto.sign(json.dumps(content, sort_keys=True), self.private_key),
"vcm_id": self.id
}
}
"""
Wait given seconds and clear terminal.
:param self: self class
:param wait: wait
"""
def _wait_and_clear(self, wait):
time.sleep(wait)
os.system("clear")
def main():
parser = argparse.ArgumentParser(description="Miner")
parser.add_argument('--tlibpath',
help="Test library path",
default="../tlib/")
parser.add_argument('--apkspath', help="Apps path", default="../apks/")
parser.add_argument('--parampath',
help="Param file path",
default="../etc/")
parser.add_argument('app', help="App name")
parser.add_argument('--mempath', help="memory path", default="../memory/")
parser.add_argument('--erase', help="erase memory of tests")
parser.add_argument('--query', help="query screen")
parser.add_argument('--reset', help="reset route")
args = parser.parse_args()
logging.basicConfig(level=logging.INFO)
tags.load(os.path.join(args.parampath, "tags.txt"))
value.init_params(args.parampath, args.app)
appdb.collect_apps(args.apkspath)
#appdb.load_urls(os.path.join(args.parampath, "urls.txt"))
mine = miner.Miner(None, None, None, args.tlibpath, True, args.app, None,
None, None, None, args.mempath, False)
if args.erase is not None:
if os.path.exists(args.erase):
keys = list(
filter(lambda x: x,
open(args.erase).read().strip().split('\n')))
else:
keys = args.erase.split('#')
if len(keys) == 0:
print("no case to erase!")
return
print("%d cases to erase" % len(keys))
for key in keys:
feature_name, test_name = key.split(':')
mine.erase_memory(feature_name, test_name)
#mine.print_stat(simple=True)
mine.save_memory()
print("%d cases erased" % len(keys))
return
if args.reset is not None:
route_no = int(args.reset)
mine.slib.reset_route(route_no)
mine.save_memory()
return
if args.query is not None:
attrs = {}
if ',' in args.query:
screen = args.query.split(',')[0]
for entry in args.query.split(',')[1:]:
if '=' in entry:
key, val = entry.split('=', 1)
attrs[key] = val
else:
if entry[0] == '-':
attrs[entry[1:]] = 'false'
else:
attrs[entry] = 'true'
else:
screen = args.query
if screen != '.':
attrs['screen'] = screen
mine.slib.query_screen(attrs)
return
mine.print_stat(simple=True)
def createMiner():
m = miner.Miner()
priv, pub = m.createNewAccount()
return m, priv, pub
def mine_coins():
clear_window()
ad = input("Enter your ID: ")
mn = miner.Miner(block_chain=bc, miner_address=ad)
print("Mining begun...")
mn.mine_pending_transactions()
n.addTransaction(t2)
n.showTransactions()
'''
t = AVLtree.AVL_Tree()
root = None
root = t.insert(root, 1)
root = t.insert(root, 2)
root = t.insert(root, 3)
print t.search(root, 2)
root = t.delete(root, 2)
print t.search(root, 2)
'''
user1 = user.User("rishik", "ajay")
user2 = user.User("rishik", "ajay")
n.addUser(user1)
n.addUser(user2)
m2 = miner.Miner(user2.getID())
m1 = miner.Miner(user1.getID())
m1.makeBlock(n)
print user1.getBalance()
print user2.getBalance()
n.showTransactions()
user1.processUpdates()
user1.showLedger()
import transaction
import blockchain
import txnMemoryPool
import miner
# Create blockchain and genesis block in the process
krisChain = blockchain.Blockchain()
print("Height: " + str(len(krisChain.blockChain)))
krisChain.blockChain[-1].printBlock()
# Add two sets of transactions as blocks
krisPool = txnMemoryPool.TxnMemoryPool()
krisMiner = miner.Miner(krisChain, krisPool)
while (len(krisPool.memoryPool)) > 0:
krisMiner.calculateNonce()
#print("Height: " + str(len(krisChain.blockChain)))
krisChain.blockChain[-1].printBlock()
#print("Height: " + str(len(krisChain.blockChain)))
elif hunt is not None:
hunt = hunt.on_event(current_screen)
else:
army = army.on_event(current_screen)
if not army:
army = checkarmy.CheckArmy()
winkey.send_key(winkey.VK_CODE['esc'])
time.sleep(1)
winkey.send_key(winkey.VK_CODE['esc'])
time.sleep(1)
if len(miners) is 0:
for p in players:
miners.append(
miner.Miner(
p,
screen.army_exists(current_screen,
p.base_area())))
else:
found = False
for i, p in enumerate(players):
if screen.army_exists(current_screen, p.base_area()):
p.player_waiting_reset()
miners[i].set_wait_status(p)
found = True
if not found:
if not BLOCK_HUNTING and is_hunting_available(hunter):
print("START HUNTING")
hunt = hunting.Hunting(hunter.reset())
time.sleep(0.1)
else:
def start_workers(self):
miner_thread = miner.Miner(self.blockchain, self.transactions)
network_thread = network.Network()
miner_thread.start()
network_thread.start()
return
def erase(feature_name, test_name, tlibpath, app, mempath):
mine = miner.Miner(None, None, None, tlibpath, True, app, None, None, None,
None, mempath, False)
mine.erase_memory(feature_name, test_name)
mine.save_memory()
