def _download_and_install_update(self, latest_version, ssid, password):
networking.connect(ssid, password)
self.download_all_files(
self.github_repo + '/contents/' + self.main_dir, latest_version)
self.rmtree(self.modulepath(self.main_dir))
os.rename(self.modulepath('next/.version_on_reboot'),
self.modulepath('next/.version'))
os.rename(self.modulepath('next'), self.modulepath(self.main_dir))
print('Update installed (', latest_version, '), will reboot now')
machine.reset()
def run_user_interface() -> None:
'Starts the network version of connectfour'
game_state = connectfour.new_game()
connection = networking.connect('woodhouse.ics.uci.edu', 4444)
if (networking.start(connection) == True):
print("Columns should be selected by typing a number between 1 and 7")
print("Specify a move in the format of DROP col# or POP col#")
print("replace col# with the column's number that you want selected")
shared_functions.print_game_board(game_state)
while (connectfour.winner(game_state) == connectfour.NONE):
response = networking.read_line(connection)
if (response == 'READY'):
while True:
user_input = input('input your move: ')
if (shared_functions.is_valid_input(user_input)):
break
print('Your move was invalid.. please re-enter')
networking.write_line(connection, user_input)
response = networking.read_line(connection)
if (response == 'OKAY'):
game_state = shared_functions.process_user_input(
game_state, user_input)
shared_functions.print_game_board(game_state)
response = networking.read_line(connection)
print("server's response: " + response)
if shared_functions.is_valid_input(response):
game_state = shared_functions.process_user_input(
game_state, response)
shared_functions.print_game_board(game_state)
if connectfour.winner(
game_state) == connectfour.YELLOW:
print('Congrats WINNER_YELLOW')
networking.close(connection)
else:
networking.close(connection)
elif (response == 'INVALID'):
print('Your move was invalid... please re-enter')
elif response == 'WINNER_RED':
print('Congrats ' + response)
networking.close(connection)
break
def connect(data):
data.mode = "connect"
if input_text(data):
address = data.current_input
networking.connect(address)
def main(brainwallet, pubkey_flag=False):
DB=custom.DB
tools.log('custom.current_loc: ' +str(custom.current_loc))
print('starting truthcoin')
if not pubkey_flag:
privkey=tools.det_hash(brainwallet)
pubkey=tools.privtopub(privkey)
else:
pubkey=brainwallet
a=tools.empty_peer()
a['port']=custom.port
b=custom.peers
my_ip=tools.getPublicIp()
b[my_ip+':'+str(custom.port)]=a
processes= [
{'target': blockchain.main,
'args': (DB,),
'name': 'blockchain'},
{'target': truthcoin_api.main,
'args': (DB, DB['heart_queue']),
'name': 'truthcoin_api'},
{'target': peers_check.main,
'args': (b, DB),
'name': 'peers_check'},
{'target': miner.main,
'args': (pubkey, DB),
'name': 'miner'},
{'target': networking.serve_forever,
'args': (peer_recieve_func, custom.port, DB['heart_queue'], True),
'name': 'peer_recieve'}
]
cmds=[database.DatabaseProcess(
DB['heart_queue'],
custom.database_name,
tools.log,
custom.database_port)]
try:
cmds[0].start()
except Exception as exc:
tools.log(exc)
tools.log('starting ' + cmds[0].name)
time.sleep(4)
tools.db_put('test', 'TEST')
tools.db_get('test')
tools.db_put('test', 'undefined')
b=tools.db_existence(0)
if not b:
tools.db_put('ip', my_ip)
tools.db_put('length', -1)
tools.db_put('memoized_votes', {})
tools.db_put('txs', [])
tools.db_put('peers', {})
tools.db_put('targets', {})
tools.db_put('times', {})
tools.db_put('mine', False)
tools.db_put('diffLength', '0')
tools.db_put('stop', False)
tools.log('stop: ' +str(tools.db_get('stop')))
for process in processes:
cmd=multiprocessing.Process(**process)
cmd.start()
cmds.append(cmd)
tools.log('starting '+cmd.name)
if not pubkey_flag:
tools.db_put('privkey', privkey)
else:
tools.db_put('privkey', 'Default')
tools.db_put('address', tools.make_address([pubkey], 1))
tools.log('stop: ' +str(tools.db_get('stop')))
while not tools.db_get('stop'):
time.sleep(0.5)
tools.log('about to stop threads')
DB['heart_queue'].put('stop')
for p in [[custom.port, '127.0.0.1'],
[custom.api_port, '127.0.0.1']]:
networking.connect('stop', p[0], p[1])
cmds.reverse()
for cmd in cmds[:-1]:
cmd.join()
tools.log('stopped a thread: '+str(cmd))
time.sleep(2)
networking.connect('stop', custom.database_port, '127.0.0.1')
cmds[-1].join()
tools.log('stopped a thread: '+str(cmds[-1]))
tools.log('all threads stopped')
sys.exit(0)
def start():
# Connect to WiFi
networking.connect(ssid, password)
import neopixel
import sys
import utime
import vl6180
import DRV8836
import networking
from ina219 import INA219
# from configureVL6180 import configureVL6180 #archived.
############ Initiazation Settings - Don't Change ######################
print("\nInitializing devices. The red LED on the robot should light up.\n")
# WiFi Connections
try:
wlan = networking.connect('brushbotarium', 'brushbotrules')
socket = networking.connect_socket('192.168.1.2')
except:
print("\033[91m{}\033[00m".format("Failed") + " to connect to hotspot.")
# Default Reset Pin Definition. Don't Change.
repl_button = machine.Pin(0, machine.Pin.IN, machine.Pin.PULL_UP)
# Sensor-enable Initialization
sensor_en = machine.Pin(19, machine.Pin.OUT)
sensor_en.value(0)
def main(brainwallet, pubkey_flag=False):
DB = custom.DB
tools.log('custom.current_loc: ' + str(custom.current_loc))
print('starting full node')
if not pubkey_flag:
privkey = tools.det_hash(brainwallet)
pubkey = tools.privtopub(privkey)
else:
pubkey = brainwallet
a = tools.empty_peer()
b = custom.peers
#b[tools.getPublicIp()+':'+str(custom.port)]=a
processes = [
{
'target':
db.main,
'args': (DB['heart_queue'], custom.database_name, tools.log,
custom.database_port),
'name':
'db'
},
{
'target': auto_signer.mainloop,
'args': (),
'name': 'auto_signer'
},
{
'target': reward_collector.doit,
'args': (),
'name': 'auto_signer'
},
#{'target':tools.heart_monitor,
# 'args':(DB['heart_queue'], ),
# 'name':'heart_monitor'},
{
'target': blockchain.main,
'args': (DB, ),
'name': 'blockchain'
},
{
'target': api.main,
'args': (DB, DB['heart_queue']),
'name': 'api'
},
{
'target': peers_check.main,
'args': (b, DB),
'name': 'peers_check'
},
{
'target': networking.serve_forever,
'args': (peer_recieve_func, custom.port, DB['heart_queue'], True),
'name': 'peer_recieve'
}
]
cmds = []
cmd = multiprocessing.Process(**processes[0])
cmd.start()
cmds.append(cmd)
tools.log('starting ' + cmd.name)
time.sleep(4)
b = tools.db_existence(0)
#def empty_memoized(): return({'blockcount':-3000})
if not b:
tools.local_put('length', -1)
tools.local_put('height', -1)
tools.local_put('memoized_votes', {})
tools.local_put('txs', [])
tools.local_put('peers', {})
tools.local_put('targets', {})
tools.local_put('times', {})
tools.local_put('mine', False)
tools.local_put('my_sign_txs', {}) #empty_memoized())
tools.local_put('secrets', {})
money = db.default_entry()
money['amount'] += custom.all_money
tools.db_put(custom.creator, money)
tools.local_put('stop', False)
tools.log('stop: ' + str(tools.local_get('stop')))
for process in processes[1:]:
cmd = multiprocessing.Process(**process)
cmd.start()
cmds.append(cmd)
tools.log('starting ' + cmd.name)
if not pubkey_flag:
tools.local_put('privkey', privkey)
else:
tools.local_put('privkey', 'Default')
Address = tools.make_address([pubkey], 1)
tools.local_put('address', Address)
a = tools.db_proof(Address)
tools.local_put('balance_proofs-1', a)
tools.log('stop: ' + str(tools.local_get('stop')))
while not tools.local_get('stop'):
time.sleep(0.5)
tools.log('about to stop threads')
DB['heart_queue'].put('stop')
for p in [[custom.port, '127.0.0.1'], [custom.api_port, '127.0.0.1']]:
networking.connect('stop', p[0], p[1])
cmds.reverse()
for cmd in cmds[:-1]:
cmd.join()
tools.log('stopped a thread: ' + str(cmd))
time.sleep(2)
networking.connect('stop', custom.database_port, '127.0.0.1')
cmds[-1].join()
tools.log('stopped a thread: ' + str(cmds[-1]))
tools.log('all threads stopped')
sys.exit(0)
def main(brainwallet, pubkey_flag=False):
DB=custom.DB
tools.log('custom.current_loc: ' +str(custom.current_loc))
print('starting full node')
if not pubkey_flag:
privkey=tools.det_hash(brainwallet)
pubkey=tools.privtopub(privkey)
else:
pubkey=brainwallet
a=tools.empty_peer()
b=custom.peers
#b[tools.getPublicIp()+':'+str(custom.port)]=a
processes= [
{'target': db.main,
'args': (DB['heart_queue'], custom.database_name, tools.log, custom.database_port),
'name': 'db'},
{'target': auto_signer.mainloop,
'args': (),
'name': 'auto_signer'},
{'target': reward_collector.doit,
'args': (),
'name': 'auto_signer'},
#{'target':tools.heart_monitor,
# 'args':(DB['heart_queue'], ),
# 'name':'heart_monitor'},
{'target': blockchain.main,
'args': (DB,),
'name': 'blockchain'},
{'target': api.main,
'args': (DB, DB['heart_queue']),
'name': 'api'},
{'target': peers_check.main,
'args': (b, DB),
'name': 'peers_check'},
{'target': networking.serve_forever,
'args': (peer_recieve_func, custom.port, DB['heart_queue'], True),
'name': 'peer_recieve'}
]
cmds=[]
cmd=multiprocessing.Process(**processes[0])
cmd.start()
cmds.append(cmd)
tools.log('starting '+cmd.name)
time.sleep(4)
b=tools.db_existence(0)
#def empty_memoized(): return({'blockcount':-3000})
if not b:
tools.local_put('length', -1)
tools.local_put('height', -1)
tools.local_put('memoized_votes', {})
tools.local_put('txs', [])
tools.local_put('peers', {})
tools.local_put('targets', {})
tools.local_put('times', {})
tools.local_put('mine', False)
tools.local_put('my_sign_txs', {})#empty_memoized())
tools.local_put('secrets', {})
money=db.default_entry()
money['amount']+=custom.all_money
tools.db_put(custom.creator, money)
tools.local_put('stop', False)
tools.log('stop: ' +str(tools.local_get('stop')))
for process in processes[1:]:
cmd=multiprocessing.Process(**process)
cmd.start()
cmds.append(cmd)
tools.log('starting '+cmd.name)
if not pubkey_flag:
tools.local_put('privkey', privkey)
else:
tools.local_put('privkey', 'Default')
Address=tools.make_address([pubkey], 1)
tools.local_put('address', Address)
a=tools.db_proof(Address)
tools.local_put('balance_proofs-1', a)
tools.log('stop: ' +str(tools.local_get('stop')))
while not tools.local_get('stop'):
time.sleep(0.5)
tools.log('about to stop threads')
DB['heart_queue'].put('stop')
for p in [[custom.port, '127.0.0.1'],
[custom.api_port, '127.0.0.1']]:
networking.connect('stop', p[0], p[1])
cmds.reverse()
for cmd in cmds[:-1]:
cmd.join()
tools.log('stopped a thread: '+str(cmd))
time.sleep(2)
networking.connect('stop', custom.database_port, '127.0.0.1')
cmds[-1].join()
tools.log('stopped a thread: '+str(cmds[-1]))
tools.log('all threads stopped')
sys.exit(0)
def main(wallet_name='', key=''):
tools.log('custom.current_loc: ' + str(custom.current_loc))
print('Starting Coinami Client ...')
b = tools.db_existence('length')
# Initialize the db
if not b:
tools.db_put('length', -1)
tools.db_put('memoized_votes', {})
tools.db_put('txs', [])
tools.db_put('peers_ranked', [])
tools.db_put('times', {})
tools.db_put('mine', False)
tools.db_put('peers', [])
tools.db_put('authorities', [])
tools.db_put('miner_status', 'Uninitialized')
tools.db_put('miner_id', -1)
tools.db_put('default_wallet', False)
tools.db_put('stop', False)
tools.log('stop: ' + str(tools.db_get('stop')))
wallet = {}
if key == '':
wallet['valid'] = False
wallet['message'] = 'Please define a passphrase to open the wallet'
if wallet_name == '':
wallet_name = tools.db_get('default_wallet')
if not tools.db_get('default_wallet'):
wallet['valid'] = False
wallet[
'message'] = 'There is no defined default wallet. You need to specify one.'
else:
wallet = tools.read_wallet(wallet_name, key)
elif wallet_name != '':
wallet = tools.read_wallet(wallet_name, key)
if not wallet['valid']:
print wallet['message']
sys.exit(0)
# Take the initial peer and authority list over here. Also a download link for executable.
# Download can be started when miner is opened for the first time.
# Peers and authorities must be set immediately.
seed = str(wallet['seed'])
try:
info = json.loads(urllib2.urlopen(custom.info_address).read())
except:
print 'Could not read info file'
sys.exit(0)
peers = []
for authority in info['authorities']:
peers.append([authority['ip'], authority['port']])
authorities = []
for authority in info['authorities']:
authorities.append(authority['pubkey'])
tools.db_put('seed', seed)
tools.db_put('info', info)
tools.db_put('peers', peers)
tools.db_put('authorities', authorities)
tools.db_put('default_wallet', wallet_name)
privkey = tools.det_hash(wallet['seed'])
pubkey = tools.privtopub(privkey)
tools.db_put('privkey', privkey)
tools.db_put('pubkey', pubkey)
processes = [{
'target': tools.heart_monitor,
'name': 'heart_monitor'
}, {
'target': blockchain.main,
'name': 'blockchain'
}, {
'target': api.main,
'name': 'api'
}, {
'target': peers_check.main,
'args': (tools.db_get('peers'), ),
'name': 'peers_check'
}, {
'target':
networking.serve_forever,
'args':
(peer_recieve_func, custom.port, custom.queues['heart_queue'], True),
'name':
'peer_recieve'
}, {
'target': miner.main,
'args': (pubkey, ),
'name': 'miner'
}]
running_processes = []
for process in processes[1:]:
cmd = multiprocessing.Process(**process)
cmd.start()
running_processes.append(cmd)
tools.log('starting ' + cmd.name)
tools.db_put('address', tools.make_address([pubkey], 1))
tools.log('stop: ' + str(tools.db_get('stop')))
# until stop command puts into db, threads module will stay in this loop
while not tools.db_get('stop'):
time.sleep(0.5)
# start the stopping
custom.queues['heart_queue'].put('stop')
for p in [[custom.port, '127.0.0.1'], [custom.api_port, '127.0.0.1']]:
networking.connect('stop', p[0], p[1])
running_processes.reverse()
# process = psutil.Process(os.getpid())
# for proc in process.get_children(recursive=True):
# print proc.pid
# proc.kill()
time.sleep(2)
for cmd in running_processes[:-1]:
print 'im waiting for %s' % str(cmd)
cmd.terminate()
cmd.join()
print('all processes stopped')
sys.exit(0)
def main(wallet_name='', key=''):
tools.log('custom.current_loc: ' + str(custom.current_loc))
print('Starting Coinami Client ...')
b = tools.db_existence('length')
# Initialize the db
if not b:
tools.db_put('length', -1)
tools.db_put('memoized_votes', {})
tools.db_put('txs', [])
tools.db_put('peers_ranked', [])
tools.db_put('times', {})
tools.db_put('mine', False)
tools.db_put('peers', [])
tools.db_put('authorities', [])
tools.db_put('miner_status', 'Uninitialized')
tools.db_put('miner_id', -1)
tools.db_put('default_wallet', False)
tools.db_put('stop', False)
tools.log('stop: ' + str(tools.db_get('stop')))
wallet = {}
if key == '':
wallet['valid'] = False
wallet['message'] = 'Please define a passphrase to open the wallet'
if wallet_name == '':
wallet_name = tools.db_get('default_wallet')
if not tools.db_get('default_wallet'):
wallet['valid'] = False
wallet['message'] = 'There is no defined default wallet. You need to specify one.'
else:
wallet = tools.read_wallet(wallet_name, key)
elif wallet_name != '':
wallet = tools.read_wallet(wallet_name, key)
if not wallet['valid']:
print wallet['message']
sys.exit(0)
# Take the initial peer and authority list over here. Also a download link for executable.
# Download can be started when miner is opened for the first time.
# Peers and authorities must be set immediately.
seed = str(wallet['seed'])
try:
info = json.loads(urllib2.urlopen(custom.info_address).read())
except:
print 'Could not read info file'
sys.exit(0)
peers = []
for authority in info['authorities']:
peers.append([authority['ip'], authority['port']])
authorities = []
for authority in info['authorities']:
authorities.append(authority['pubkey'])
tools.db_put('seed', seed)
tools.db_put('info', info)
tools.db_put('peers', peers)
tools.db_put('authorities', authorities)
tools.db_put('default_wallet', wallet_name)
privkey = tools.det_hash(wallet['seed'])
pubkey = tools.privtopub(privkey)
tools.db_put('privkey', privkey)
tools.db_put('pubkey', pubkey)
processes = [
{'target': tools.heart_monitor,
'name': 'heart_monitor'},
{'target': blockchain.main,
'name': 'blockchain'},
{'target': api.main,
'name': 'api'},
{'target': peers_check.main,
'args': (tools.db_get('peers'),),
'name': 'peers_check'},
{'target': networking.serve_forever,
'args': (peer_recieve_func, custom.port, custom.queues['heart_queue'], True),
'name': 'peer_recieve'},
{'target': miner.main,
'args': (pubkey, ),
'name': 'miner'}
]
running_processes = []
for process in processes[1:]:
cmd = multiprocessing.Process(**process)
cmd.start()
running_processes.append(cmd)
tools.log('starting ' + cmd.name)
tools.db_put('address', tools.make_address([pubkey], 1))
tools.log('stop: ' + str(tools.db_get('stop')))
# until stop command puts into db, threads module will stay in this loop
while not tools.db_get('stop'):
time.sleep(0.5)
# start the stopping
custom.queues['heart_queue'].put('stop')
for p in [[custom.port, '127.0.0.1'],
[custom.api_port, '127.0.0.1']]:
networking.connect('stop', p[0], p[1])
running_processes.reverse()
# process = psutil.Process(os.getpid())
# for proc in process.get_children(recursive=True):
# print proc.pid
# proc.kill()
time.sleep(2)
for cmd in running_processes[:-1]:
print 'im waiting for %s' % str(cmd)
cmd.terminate()
cmd.join()
print('all processes stopped')
sys.exit(0)
