def __shutdown_listener(self):
display = Display.get_instance()
print("Shutting down...")
display.Lock.acquire()
display.show_on_line(1, "Shutting down")
display.show_loader(2)
time.sleep(3)
display.turn_off()
display.hide_loader()
def show():
hostname = socket.gethostname()
ip = get_lan_ip()
hostname_string = ""
if len(hostname) <= 11:
hostname_string += "Host:"
if len(hostname) <= 10:
hostname_string += " "
hostname_string += hostname
ip_string = ""
if len(ip) <= 15:
ip_string += "IP:"
if len(ip) <= 14:
ip_string += " "
ip_string += ip
print(hostname_string)
print(ip_string)
Display.get_instance().show(hostname_string, ip_string)
"""
###################################################################################################
# #
# Waits for a button press which lasts over a defined duration on GPIO pin 18 (pulling pin down). #
# The script then exits with a success or an error code accordingly. #
# Exit codes: #
# 0: button was pressed long enough and in time #
# 3: button wasn't pressed long enough #
# 4: button wasn't pressed in time #
# #
# Author: Jan Wennrich (PCSG) #
# #
###################################################################################################
"""
import RPi.GPIO as GPIO
import sys
from lib.display.Display import Display
try:
code = sys.argv[1]
except IndexError:
print("You need to specify a code to display.")
exit(1)
display = Display.get_instance()
display.Lock.acquire()
display.show("Code:", sys.argv[1])
exit(0)
class RebootListener(AbstractAutostart):
# How many seconds has the button to be pressed
BUTTON_HOLD_TIME_MIN = 30
# After how many seconds of button pressing the event should be ignored?
BUTTON_HOLD_TIME_MAX = 32
button = Button.get_instance()
display = Display.get_instance()
buzzer = Buzzer.get_instance()
has_beeped = False
has_locked_display = False
def run(self):
self.button.add_press_listener(self.button_press_listener)
def button_press_listener(self):
self.has_beeped = False
self.has_locked_display = False
self.button.add_hold_listener(self.button_hold_listener)
def button_hold_listener(self, seconds: float):
if not self.has_beeped and self.button_press_time_in_range(seconds):
self.has_beeped = True
self.button.add_release_listener(self.button_release_listener)
self.buzzer.beep(3, 0.1)
if not self.display.Lock.locked():
self.display.Lock.acquire()
self.has_locked_display = True
print("Release button to reboot")
self.display.show("Release button to", "reboot")
if seconds > self.BUTTON_HOLD_TIME_MAX:
self.cleanup()
def button_release_listener(self, seconds: float):
self.cleanup()
# Check if button was pressed long enough
if self.button_press_time_in_range(seconds):
self.display.show("Rebooting", "")
self.display.show_loader(2)
System.reboot()
def button_press_time_in_range(self, seconds):
return self.BUTTON_HOLD_TIME_MAX > seconds > self.BUTTON_HOLD_TIME_MIN
def cleanup(self):
self.button.remove_hold_listener(self.button_hold_listener)
self.button.remove_release_listener(self.button_release_listener)
if self.has_locked_display:
self.display.Lock.release()
class SetupListener(AbstractAutostart):
dir_quiqqer = '/var/www/html/'
config = configparser.ConfigParser()
config_file = dir_quiqqer + 'etc/plugins/sequry/passdora.ini.php'
config.read(config_file)
display = Display.get_instance()
def run(self):
if self.is_setup_requested():
self.display.Lock.acquire()
# TODO: Confirm setup with a button press
print("Executing system-setup...")
self.display.show("System setting up", "")
self.display.show_loader(2)
self.handle_hostname()
self.handle_ssh()
self.handle_dhcp()
self.handle_wifi()
# Set is_requested in config to zero and save the file
self.set_is_requested(0)
self.display.hide_loader()
print("Setup completed!")
self.display.show("Setup", "Complete!")
sleep(2)
print("Restarting the system...")
self.display.show("Restarting", "")
self.display.show_loader(2)
sleep(2)
self.display.turn_off()
os.system("sudo shutdown now -r")
def handle_hostname(self):
hostname = self.config.get('setup', 'hostname')
os.system(
'echo "{0}" | sudo tee /etc/hostname > /dev/null'.format(hostname))
os.system(
'sudo sed -i "s/127\.0\.1\.1.*passdora/127.0.1.1 {0}/g" /etc/hosts'
.format(hostname))
def handle_ssh(self):
if self.config.get('setup', 'isSshEnabled') == '"1"':
os.system('sudo update-rc.d -f ssh enable')
else:
os.system('sudo update-rc.d -f ssh disable')
def is_setup_requested(self):
# Remove '"' from the value and then convert to int
return int(self.config.get('setup', 'is_requested').replace('"',
'')) == 1
def handle_dhcp(self):
file_interfaces = open("/etc/network/interfaces.d/passdora.conf", "w")
file_interfaces.write("auto lo\n")
file_interfaces.write("iface lo inet loopback\n")
if self.config.get('setup', 'isDhcpEnabled') == '"1"':
file_interfaces.write("eth0 inet dhcp\n")
file_interfaces.write("wlan0 inet dhcp\n")
else:
ip = self.config.get('setup', 'ip').replace('"', '')
subnetmask = self.config.get('setup',
'subnetmask').replace('"', '')
file_interfaces.write("auto eth0:1\n")
file_interfaces.write("iface eth0:1 inet static\n")
file_interfaces.write("address " + ip + "\n")
file_interfaces.write("netmask " + subnetmask + "\n")
file_interfaces.write("auto wlan0:1\n")
file_interfaces.write("iface wlan0:1 inet static\n")
file_interfaces.write("address " + ip + "\n")
file_interfaces.write("netmask " + subnetmask + "\n")
file_interfaces.close()
def handle_wifi(self):
if self.config.get('setup', 'isWifiEnabled') == '"1"':
ssid = self.config.get('setup', 'wifiSsid').replace('"', '')
password = self.config.get('setup',
'wifiPassword').replace('"', '')
file_wifi = open("/etc/wpa_supplicant/wpa_supplicant.conf", "a")
file_wifi.write('\n')
file_wifi.write('network={\n')
file_wifi.write(' ssid="{0}"\n'.format(ssid))
file_wifi.write(' psk="{0}"\n'.format(password))
file_wifi.write('}\n')
file_wifi.close()
def set_is_requested(self, value):
self.config.set("setup", "is_requested", '"' + str(value) + '"')
with open(self.config_file, 'w') as configfile:
self.config.write(configfile)
class BackupButtonListener(AbstractAutostart):
# How many seconds has the button to be pressed
BUTTON_HOLD_TIME_MIN = 3
# After how many seconds of button pressing the event should be ignored?
BUTTON_HOLD_TIME_MAX = 5
# Instructions how to use this script
MESSAGE_INSTRUCTIONS = "Press and hold the button for {0} seconds to create a backup.".format(
BUTTON_HOLD_TIME_MIN)
button = Button.get_instance()
buzzer = Buzzer.get_instance()
display = Display.get_instance()
has_beeped = False
has_locked_display = False
def run(self):
self.button.add_press_listener(self.button_press_listener)
def button_press_listener(self):
if not System.is_activated():
return
self.has_beeped = False
self.button.add_hold_listener(self.button_hold_listener)
if not self.display.Lock.locked():
self.display.Lock.acquire()
self.has_locked_display = True
print("Button pressed. Hold for {0} seconds to create a backup...".
format(self.BUTTON_HOLD_TIME_MIN))
self.display.show("Hold button for", "3 seconds")
def button_hold_listener(self, seconds: float):
if self.BUTTON_HOLD_TIME_MAX > seconds > self.BUTTON_HOLD_TIME_MIN and not self.has_beeped:
self.has_beeped = True
self.button.add_release_listener(self.button_release_listener)
self.buzzer.beep()
print("Release button to start backup")
self.display.show("Release button to", "start backup")
if seconds > self.BUTTON_HOLD_TIME_MAX:
self.button.remove_hold_listener(self.button_hold_listener)
self.button.remove_release_listener(self.button_release_listener)
def button_release_listener(self, seconds: float):
# Check if button was pressed long enough
if self.BUTTON_HOLD_TIME_MAX > seconds > self.BUTTON_HOLD_TIME_MIN:
self.display.show("Creating Backup", "")
self.display.show_loader(2)
Backup.create()
print("Backup created!")
self.display.hide_loader()
self.display.show("Backup", "created")
sleep(2)
self.button.remove_hold_listener(self.button_hold_listener)
self.button.remove_release_listener(self.button_release_listener)
# Print that the button can be used again
print(self.MESSAGE_INSTRUCTIONS)
if self.has_locked_display:
self.display.Lock.release()
self.display.show_default()
class RestoreListener(AbstractAutostart):
dir_quiqqer = '/var/www/html/'
dir_restore = dir_quiqqer + 'var/package/sequry/passdora/restore/'
config = configparser.ConfigParser()
config_file = dir_quiqqer + 'etc/plugins/sequry/passdora.ini.php'
config.read(config_file)
display = Display.get_instance()
def run(self):
if self.is_restore_requested():
self.display.Lock.acquire()
# TODO: Confirm backup with a button press
print("Processing System-Restore...")
self.display.show("", "")
self.display.show_loader(2)
# Extract files
print("Extracting files...")
self.display.show_on_line(1, "Extracting files")
self.extract_files()
# Copy QUIQQER etc/ folder
print("Restoring QUIQQER settings...")
self.display.show_on_line(1, "Restoring QUIQQER")
self.restore_quiqqer_config()
# Copy system etc/ folder
print("Restoring system settings...")
self.display.show_on_line(1, "Restoring System")
self.restore_system_config()
# Restore MySQL backup
print("Restoring MySQL database...")
self.display.show_on_line(1, "Restoring Database")
self.restore_database()
# Set is_requested in config to zero and save the file
self.set_is_requested(0)
self.display.hide_loader()
print("Restore completed!")
self.display.show("Restore", "Complete!")
sleep(2)
print("Restarting the system...")
self.display.show("Restarting", "")
self.display.show_loader(2)
sleep(2)
self.display.turn_off()
os.system("sudo shutdown now -r")
def extract_files(self):
if os.path.isfile(self.dir_restore + "restore.tgz"):
os.system("sudo tar --same-owner -xpzf " + self.dir_restore +
"restore.tgz -C " + self.dir_restore)
return True
return False
def restore_quiqqer_config(self):
if os.path.isdir(self.dir_restore + "quiqqer_etc"):
os.system("sudo rsync --delete-after -a " + self.dir_restore +
"/quiqqer_etc/ " + self.dir_quiqqer + "etc")
return True
return False
def restore_system_config(self):
if os.path.isdir(self.dir_restore + "system_etc/"):
os.system("sudo rsync --delete-after -a " + self.dir_restore +
"system_etc/ /etc")
return True
return False
def restore_database(self):
if os.path.isfile(self.dir_restore + "database.sql"):
os.system("sudo mysql quiqqer < " + self.dir_restore +
"database.sql")
return True
return False
def is_restore_requested(self):
# Remove '"' from the value and then convert to int
return int(
self.config.get('restore', 'is_requested').replace('"', '')) == 1
def set_is_requested(self, value):
self.config.set("restore", "is_requested", '"' + str(value) + '"')
with open(self.config_file, 'w') as configfile:
self.config.write(configfile)
class InitSystem:
# How many seconds has the button to be pressed
BUTTON_HOLD_TIME = 3
# After how many seconds should the script timeout?
SCRIPT_TIMEOUT = 30
display = Display.get_instance()
button = Button.get_instance()
_exit = False
_exit_code = 0
def wait_for_authentication(self):
script_start_time = time.time()
self.button.add_press_listener(self.on_button_pressed)
self.button.add_release_listener(self.on_button_released)
while not self._exit:
if (time.time() - script_start_time) > self.SCRIPT_TIMEOUT:
print('No interaction')
self.display.show("Aborting", "no interaction")
self.request_exit(4)
time.sleep(0.5)
self.cleanup()
return self._exit_code
def cleanup(self):
if self.display.Lock.locked():
self.display.Lock.release()
if self.button.is_hold_observer_registered(self.on_button_held):
self.button.remove_hold_listener(self.on_button_held)
if self.button.is_press_observer_registered(self.on_button_pressed):
self.button.remove_press_listener(self.on_button_pressed)
if self.button.is_release_observer_registered(self.on_button_released):
self.button.remove_release_listener(self.on_button_released)
self.button.__del__()
def request_exit(self, exitcode):
self._exit = True
self._exit_code = exitcode
def on_button_pressed(self):
self.display.Lock.acquire()
self.button.add_hold_listener(self.on_button_held)
print("Button pressed. Hold for {0} seconds to authenticate...".format(
self.BUTTON_HOLD_TIME))
self.display.show_countdown(2, self.BUTTON_HOLD_TIME, "{0} seconds")
def on_button_held(self, seconds: float):
if seconds >= self.BUTTON_HOLD_TIME:
self.button.remove_hold_listener(self.on_button_held)
print("Release button to complete authentication")
self.display.show("Release button to", "finish auth")
def on_button_released(self, seconds: float):
self.display.hide_countdown()
if seconds >= self.BUTTON_HOLD_TIME:
print('Authentication successful')
self.display.show("Authentication", "successful")
exitcode = 0
else:
print('Button was not pressed long enough')
self.display.show("Button released", "too soon")
exitcode = 3
self.request_exit(exitcode)
class SshListener(AbstractAutostart):
# How many seconds has the button to be pressed
BUTTON_HOLD_TIME_MIN = 10
# After how many seconds of button pressing the event should be ignored?
BUTTON_HOLD_TIME_MAX = 12
# Instructions how to use this script
MESSAGE_INSTRUCTIONS = "Press and hold the button for {0} seconds to toggle SSH.".format(
BUTTON_HOLD_TIME_MIN)
button = Button.get_instance()
display = Display.get_instance()
buzzer = Buzzer.get_instance()
has_beeped = False
has_locked_display = False
def run(self):
self.button.add_press_listener(self.button_press_listener)
def button_press_listener(self):
if not System.is_activated():
return
self.has_beeped = False
self.has_locked_display = False
self.button.add_hold_listener(self.button_hold_listener)
print(self.MESSAGE_INSTRUCTIONS)
def button_hold_listener(self, seconds: float):
if self.button_press_time_in_range(seconds) and not self.has_beeped:
self.has_beeped = True
self.button.add_release_listener(self.button_release_listener)
self.buzzer.beep(2)
if not self.display.Lock.locked():
self.display.Lock.acquire()
self.has_locked_display = True
print("Release button to toggle SSH")
self.display.show("Release button to", "toggle SSH")
if self.has_locked_display:
self.display.Lock.release()
if seconds > self.BUTTON_HOLD_TIME_MAX:
self.button.remove_hold_listener(self.button_hold_listener)
self.button.remove_release_listener(self.button_release_listener)
def button_release_listener(self, seconds: float):
# Check if button was pressed long enough
if self.button_press_time_in_range(seconds):
self.display.show("Toggling SSH", "")
self.display.show_loader(2)
is_ssh_enabled_now = SSH.toggle()
self.display.hide_loader()
if is_ssh_enabled_now:
print("SSH is enabled now.")
self.display.show("SSH", "enabled")
else:
print("SSH is disabled now.")
self.display.show("SSH", "disabled")
sleep(2)
if self.has_locked_display:
self.display.Lock.release()
self.display.show_default()
self.button.remove_hold_listener(self.button_hold_listener)
self.button.remove_release_listener(self.button_release_listener)
def button_press_time_in_range(self, seconds):
return self.BUTTON_HOLD_TIME_MAX > seconds > self.BUTTON_HOLD_TIME_MIN
class UpdateListener(AbstractAutostart):
dir_quiqqer = '/var/www/html/'
dir_update = dir_quiqqer + 'var/package/sequry/passdora/update/'
dir_update_files = dir_update + 'files/'
file_update_archive = dir_update + "update.tgz"
file_version = dir_update + "VERSION"
file_update_script = dir_update + "update.sh"
config = configparser.ConfigParser()
config_file = dir_quiqqer + 'etc/plugins/sequry/passdora.ini.php'
config.read(config_file)
display = Display.get_instance()
def run(self):
if self.is_update_requested():
self.display.Lock.acquire()
# TODO: Confirm update with a button press
print("Processing System-Update...")
self.display.show("", "")
self.display.show_loader(2)
print("Extracting files...")
self.display.show_on_line(1, "Extracting files")
self.extract_files()
print("Moving files...")
self.display.show_on_line(1, "Moving files")
self.move_files()
print("Running update-script...")
self.display.show_on_line(1, "Executing scripts")
self.run_update_script()
print("Creating backup...")
Backup.create()
# Set is_requested in config to zero and save the file
self.set_is_requested(0)
self.display.hide_loader()
print("Update completed!")
self.display.show("Update", "Complete!")
sleep(2)
print("Restarting the system...")
self.display.show("Restarting", "")
self.display.show_loader(2)
sleep(2)
self.display.turn_off()
os.system("sudo shutdown now -r")
def extract_files(self):
if os.path.isfile(self.file_update_archive):
os.system("sudo tar --same-owner -xpzf " +
self.file_update_archive + " -C " + self.dir_update)
return True
return False
def move_files(self):
os.system("sudo rsync -a " + self.dir_update_files + " /")
def run_update_script(self):
os.system("sudo bash " + self.file_update_script)
def get_update_version(self):
with open(self.file_version) as file:
return file.read().strip()
def is_update_requested(self):
# Remove '"' from the value and then convert to int
return int(self.config.get('update', 'is_requested').replace('"',
'')) == 1
def set_is_requested(self, value):
self.config.set("update", "is_requested", '"' + str(value) + '"')
with open(self.config_file, 'w') as configfile:
self.config.write(configfile)