mirror of
https://github.com/mynodebtc/mynode.git
synced 2024-11-15 09:59:16 +00:00
175 lines
6.9 KiB
Python
Executable File
175 lines
6.9 KiB
Python
Executable File
#!/usr/local/bin/python3
|
|
import os
|
|
import requests
|
|
import time
|
|
import subprocess
|
|
import random
|
|
import json
|
|
import logging
|
|
import argparse
|
|
from systemd import journal
|
|
from utilities import *
|
|
from drive_info import *
|
|
from device_info import *
|
|
|
|
CHECKIN_URL = "https://www.mynodebtc.com/device_api/check_in.php"
|
|
|
|
log = logging.getLogger('check_in')
|
|
log.addHandler(journal.JournaldLogHandler())
|
|
log.setLevel(logging.INFO)
|
|
set_logger(log)
|
|
|
|
latest_version_check_count = 0
|
|
|
|
# Helper functions
|
|
def clear_response_data():
|
|
os.system("rm -f /tmp/check_in_response.json")
|
|
def save_response_data(data):
|
|
try:
|
|
with open("/tmp/check_in_response.json", "w") as file:
|
|
json.dump(data, file, indent=4, sort_keys=True)
|
|
except Exception as e:
|
|
log_message("save_response_data exception: failed to save response - {}".format(str(e)))
|
|
|
|
def get_quicksync_enabled():
|
|
enabled = 1
|
|
if not is_mynode_drive_mounted():
|
|
return -3
|
|
if os.path.isfile("/mnt/hdd/mynode/settings/quicksync_disabled"):
|
|
enabled = 0
|
|
return enabled
|
|
|
|
def check_for_new_mynode_version():
|
|
global latest_version_check_count
|
|
# Chances of refreshing version
|
|
# Note: Hard limit forces day 5 to 100%
|
|
#
|
|
# A 30% chance per day is: A 35% chance per day is: A 40% chance per day is: A 45% chance per day is:
|
|
# 1 day(s): 30% 1 day(s): 35% 1 day(s): 40% 1 day(s): 45%
|
|
# 2 day(s): 51% 2 day(s): 57% 2 day(s): 64% 2 day(s): 69%
|
|
# 3 day(s): 65% 3 day(s): 72% 3 day(s): 78% 3 day(s): 83%
|
|
# 5 day(s): 83% 5 day(s): 88% 5 day(s): 92% 5 day(s): 94%
|
|
# 7 day(s): 91% 7 day(s): 95% 7 day(s): 97% 7 day(s): 98%
|
|
# A 50% chance per day is: A 55% chance per day is: A 60% chance per day is: A 65% chance per day is:
|
|
# 1 day(s): 50% 1 day(s): 55% 1 day(s): 60% 1 day(s): 65%
|
|
# 2 day(s): 75% 2 day(s): 79% 2 day(s): 84% 2 day(s): 87%
|
|
# 3 day(s): 87% 3 day(s): 90% 3 day(s): 93% 3 day(s): 95%
|
|
# 5 day(s): 96% 5 day(s): 98% 5 day(s): 99% 5 day(s): 99%
|
|
# 7 day(s): 99.2% 7 day(s): 99.6% 7 day(s): 99.8% 7 day(s): 99.9%
|
|
if latest_version_check_count % 5 == 0 or random.randint(1, 100) <= 40:
|
|
log_message("Version Check Count ({}) - Checking for new version!".format(latest_version_check_count))
|
|
os.system("/usr/bin/mynode_get_latest_version.sh &")
|
|
else:
|
|
log_message("Version Check Count ({}) - Skipping version check".format(latest_version_check_count))
|
|
latest_version_check_count = latest_version_check_count + 1
|
|
|
|
def on_check_in_error(msg):
|
|
clear_response_data()
|
|
log_message(msg)
|
|
data = {}
|
|
data["status"] = "ERROR"
|
|
data["message"] = msg
|
|
save_response_data(data)
|
|
|
|
# Checkin every 24 hours
|
|
def check_in(check_for_updates):
|
|
|
|
# Check in
|
|
product_key = get_product_key()
|
|
data = {
|
|
"serial": get_device_serial(),
|
|
"device_type": get_device_type(),
|
|
"device_arch": get_device_arch(),
|
|
"debian_version": get_debian_version(),
|
|
"version": get_current_version(),
|
|
"product_key": product_key,
|
|
"drive_size": get_mynode_drive_size(),
|
|
"quicksync_enabled": get_quicksync_enabled(),
|
|
"api_version": 2,
|
|
}
|
|
|
|
# Check for new version (not every time to spread out upgrades)
|
|
if check_for_updates:
|
|
check_for_new_mynode_version()
|
|
|
|
# Setup tor proxy
|
|
session = requests.session()
|
|
session.proxies = {}
|
|
session.proxies['http'] = 'socks5h://localhost:9050'
|
|
session.proxies['https'] = 'socks5h://localhost:9050'
|
|
|
|
# Check In
|
|
fail_count = 0
|
|
check_in_success = False
|
|
while not check_in_success:
|
|
try:
|
|
# Use tor for check in unless there have been several tor failures
|
|
r = None
|
|
if (fail_count+1) % 4 == 0:
|
|
r = requests.post(CHECKIN_URL, data=data, timeout=20)
|
|
else:
|
|
r = session.post(CHECKIN_URL, data=data, timeout=20)
|
|
|
|
if r == None:
|
|
on_check_in_error("Check In Failed: (retrying) None")
|
|
elif r.status_code != 200:
|
|
on_check_in_error("Check In Failed: (retrying) HTTP ERROR {}".format(r.status_code))
|
|
elif r.status_code == 200:
|
|
try:
|
|
info = json.loads(r.text)
|
|
save_response_data(info)
|
|
|
|
try:
|
|
if info["status"] == "OK":
|
|
# Check in was successful!
|
|
if product_key != "community_edition":
|
|
unset_skipped_product_key()
|
|
delete_product_key_error()
|
|
|
|
os.system("rm -f /tmp/check_in_error")
|
|
check_in_success = True
|
|
log_message("Check In Success: {}".format(r.text))
|
|
else:
|
|
mark_product_key_error()
|
|
on_check_in_error("Check In Returned Error: {} - {}".format(info["status"], r.text))
|
|
except Exception as e:
|
|
on_check_in_error("Check In Failed: Error Parsing Response - {} - {}".format(str(e), r.text))
|
|
except Exception as e:
|
|
on_check_in_error("Check In Failed: Error Parsing JSON - {}".format(str(e)))
|
|
else:
|
|
on_check_in_error("Check In Failed: Unknown")
|
|
except Exception as e:
|
|
on_check_in_error("Check In Failed: (retrying) Exception {}".format(e))
|
|
|
|
if not check_in_success:
|
|
# Check in failed, try again later
|
|
os.system("touch /tmp/check_in_error")
|
|
time.sleep(120)
|
|
fail_count = fail_count + 1
|
|
|
|
return True
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument("-d", "--delay", type=int, default=0,
|
|
help="Time in seconds to delay before opening connection")
|
|
parser.add_argument("-i", "--interval", type=int, default=0,
|
|
help="Time in hours to delay before opening connection")
|
|
parser.add_argument("-u", "--check-for-updates", action='store_true',
|
|
help="Time in hours to delay before opening connection")
|
|
args = parser.parse_args()
|
|
|
|
delay = args.delay
|
|
interval = 60*60*args.interval
|
|
while True:
|
|
print("Sleeping {} seconds...".format(delay))
|
|
time.sleep(delay)
|
|
|
|
check_in(args.check_for_updates)
|
|
|
|
if args.interval == 0:
|
|
break
|
|
else:
|
|
print("Sleeping {} seconds...".format(interval - delay))
|
|
time.sleep(interval - delay)
|