def premount_device(dev): """ dev example: /dev/sda1 """ dev_info_dict = get_device_info_data(dev) premount_path = "/media/pre_" + dev_info_dict['label'] if not os.path.exists(premount_path): module_printer("mount point not exists - create: " + str(premount_path)) cmd = "sudo mkdir -p " + str(premount_path) exitcode, stdout, stderr = LocalMachine.run_command(cmd) check_exitcode(cmd, exitcode, stderr) if not device_is_mounted(premount_path): module_printer("premount device " + str(dev_info_dict['path'])) cmd = "sudo mount -t {} {} {}".format(dev_info_dict['filesystem'], dev_info_dict['path'], premount_path) exitcode, stdout, stderr = LocalMachine.run_command(cmd) if exitcode != 0: # retry without explicit filesystem parameter cmd = "sudo mount {} {}".format(dev_info_dict['path'], premount_path) exitcode, stdout, stderr = LocalMachine.run_command(cmd) check_exitcode(cmd, exitcode, stderr) else: module_printer("already mounted " + str(dev_info_dict['path'])) return premount_path
def get_rpitools_services(color=Colors.CYAN): global rpitools_services, linux_services services = rpitools_services data = color + " RPITOOLS SERVICES:\n" + Colors.NC for service in services: is_active = LocalMachine.run_command("systemctl is-active " + str(service))[1] is_enabled = LocalMachine.run_command("systemctl is-enabled " + str(service))[1] is_active, is_enabled = service_state_coloring(isactive=is_active, isenabled=is_enabled, service_name=service) data += "\t" + color + str( service) + Colors.NC + " active status: " + str(is_active) + "\n" data += "\t" + str(service) + " enabled status: " + str( is_enabled) + "\n" services = linux_services data += color + " LINUX SERVICES:\n" + Colors.NC for service in services: is_active = LocalMachine.run_command("systemctl is-active " + str(service))[1] is_enabled = LocalMachine.run_command("systemctl is-enabled " + str(service))[1] is_active, is_enabled = service_state_coloring(isactive=is_active, isenabled=is_enabled, service_name=service) data += "\t" + color + str( service) + Colors.NC + " active status: " + str(is_active) + "\n" data += "\t" + str(service) + " enabled status: " + str( is_enabled) + "\n" return data
def hum_readable_list_devices(full_info=False): if full_info: cmd="lsblk" exit_code, stdout, stderr = LocalMachine.run_command(cmd) if exit_code == 0: print("[CMD] " + str(cmd)) print(stdout) print("\n") cmd="blkid" exit_code, stdout, stderr = LocalMachine.run_command(cmd) if exit_code == 0: print("[CMD] " + str(cmd)) print(stdout) print("\n") cmd="sudo fdisk -l | grep -v grep | grep /dev/sd" exit_code, stdout, stderr = LocalMachine.run_command(cmd) if exit_code == 0: print("[CMD] " + str(cmd)) print(stdout) devices_list = BlockDeviceHandler.list_connected_devices() for device in devices_list: device_info = BlockDeviceHandler.get_device_info_data(device) for key, value in device_info.items(): sep_len = 12 - len(key) sep = " "*sep_len print("\t{}:{}{}".format(key, sep, value))
def restore_diskconf_file(path, confname="diskconf.json"): json_path = str(path) + "/" + str(confname) save_path = "/tmp/" + str(confname) cmd = "sudo cp {} {}".format(save_path, json_path) exitcode, stdout, stderr = LocalMachine.run_command(cmd) BlockDeviceHandler.check_exitcode(cmd, exitcode, stderr) cmd = "sudo rm -f {}".format(save_path) exitcode, stdout, stderr = LocalMachine.run_command(cmd) BlockDeviceHandler.check_exitcode(cmd, exitcode, stderr)
def get_disk_usage(): device_is_connected = LocalMachine.run_command_safe("echo /dev/sd*") if "/dev/sd*" not in device_is_connected: data_tmp = LocalMachine.run_command_safe("df -h / /dev/sd* | grep -v devtmpfs") else: data_tmp = LocalMachine.run_command_safe("df -h /") data_list = data_tmp.split("\n") data = "" for index, line in enumerate(data_list): data += " " + line + "\n" return data
def get_internal_ip(): data = LocalMachine.run_command_safe("hostname -I") data_list = data.split(" ") ip_printout = "" for index, ip in enumerate(data_list): ip_printout += "IP[{}]: {} ".format(index, ip) return ip_printout
def get_logged_in_users(): data_tmp = LocalMachine.run_command_safe("ps -ef | grep [s]shd | grep -v ^root") data_list = data_tmp.split("\n") data = "" for index, line in enumerate(data_list): data += " " + line + "\n" return data
def get_mem_usage(): mem_total = LocalMachine.run_command_safe( "sudo cat /proc/meminfo | grep 'MemTotal' | tr -dc '0-9'") mem_available = LocalMachine.run_command_safe( "sudo cat /proc/meminfo | grep 'MemAvailable' | tr -dc '0-9'") mem_free = LocalMachine.run_command_safe( "sudo cat /proc/meminfo | grep 'MemFree' | tr -dc '0-9'") available_percent = (float(int(mem_total) - int(mem_available)) / float(mem_total)) * 100 available_percent = '%.1f' % available_percent free_percent = (float(int(mem_total) - int(mem_free)) / float(mem_total)) * 100 free_percent = '%.1f' % free_percent return float(available_percent), float( free_percent), mem_total, mem_available, mem_free
def device_is_mounted(device): """ device example: /dev/sda1 or mount point example: /media/device """ cmd = "grep -qs '{} ' /proc/mounts".format(device) exitcode, stdout, stderr = LocalMachine.run_command(cmd) if exitcode == 0: return True else: return False
def unmount_device(dev): """ device example: /dev/sda1 or mount point example: /media/device """ cmd = "sudo umount " + str(dev) exitcode, stdout, stderr = LocalMachine.run_command(cmd) check_exitcode(cmd, exitcode, stderr) time.sleep(1) if device_is_mounted(dev): time.sleep(1) unmount_device(dev)
def get_mac_addresses(): output = "" devices = LocalMachine.run_command_safe("ls -1 /sys/class/net") devices_list = devices.split("\n") for index, device in enumerate(devices_list): if device != "lo": cmd = "ifconfig " + device + " | grep 'HWaddr'" mac_line = LocalMachine.run_command_safe(cmd, check_exitcode=False) substring_index = -17 if mac_line == "": cmd = "ifconfig " + device + " | grep 'ether'" mac_line = LocalMachine.run_command_safe(cmd, check_exitcode=False) substring_index = 13 if str(mac_line) != "" and mac_line is not None: output += " \t" + device + "\t\t" + str(mac_line)[substring_index:] if index < len(devices_list) - 1: output += "\n" return output
def get_top_processes(char_width, topx=3): output = "" cmd = "ps aux | head -n 1; ps aux --sort -rss | sort -nrk 3,3 | head -n " + str( topx) data = LocalMachine.run_command_safe(cmd) data_list = data.split("\n") for line in data_list: output += " " + line[0:char_width] + "\n" return output
def mount_all_devices(): media_dirs = [] for dirname, dirnames, filenames in os.walk('/media/'): media_dirs = dirnames break for actualdir in media_dirs: is_mounted_cmd = "grep -qs '/media/{}' /proc/mounts".format(actualdir) exitcode, stdout, stderr = LocalMachine.run_command(is_mounted_cmd) if exitcode == 0: print("/media/{} is already mounted".format(actualdir)) elif exitcode == 1: exitcode, stdout, stderr = LocalMachine.run_command( "cat /etc/fstab") if exitcode == 0 and actualdir not in stdout: print(actualdir + " not in /etc/fstab") print("\tSkipping mount...") return print("/media/{} mount".format(actualdir)) mount_cmd = "mount /media/" + str(actualdir) exitcode, stdout, stderr = LocalMachine.run_command(mount_cmd) if exitcode == 0: is_mounted_cmd = "grep -qs '/media/{}' /proc/mounts".format( actualdir) exitcode, stdout, stderr = LocalMachine.run_command( is_mounted_cmd) if exitcode == 0: print("Successfully mounted") elif exitcode == 1: print("Fail to mount - may device is not found") else: module_printer( "EXITCODE: {}\nSTDOUT: {}\nSTDERR:{}".format( exitcode, stdout, stderr)) else: module_printer("Mount failed!") module_printer("Command: {} return with error code: {}".format( mount_cmd, exitcode)) module_printer("STDOUT: {}\nSTDERR:{}".format(stdout, stderr)) else: module_printer("Unexpected error!") module_printer("Command: {} return with error code: {}".format( is_mounted_cmd, exitcode)) module_printer("STDOUT: {}\nSTDERR:{}".format(stdout, stderr))
def get_rpienv_status(color=Colors.CYAN): rpienv_log = LocalMachine.run_command( "if [ -f /var/log/rpienv ]; then cat /var/log/rpienv; else echo ''; fi" )[1] print(rpienv_log) if "[ ENV ERROR ]" in rpienv_log: rpienv_status = 'warning' else: rpienv_status = 'ok' return process_state_coloring(rpienv_status, "rpienv_log")
def reset_dumped_database_and_restart_service(): global dumped_dotdictbackup_json_path cmd = "rm -f " + str(dumped_dotdictbackup_json_path) exit_code, stdout, stderr = LocalMachine.run_command(cmd, wait_for_done=True) if exit_code == 0: cmd = "sudo systemctl restart memDictCore" exit_code, stdout, stderr = LocalMachine.run_command(cmd, wait_for_done=True) if exit_code == 0: cmd = "sudo systemctl is-active memDictCore" exit_code, stdout, stderr = LocalMachine.run_command(cmd, wait_for_done=True) if stdout == "active": print("Reset memDictCore databse was SUCCESSFUL") else: print("Reset memDictCore databse FAILED: " + str(stdout)) else: print("Reset memDictCore databse FAILED: " + str(stderr)) else: print("Reset memDictCore databse FAILED: " + str(stderr)) return exit_code
def unmount_all_premounted_devices(): """ serach under /media/ with pre_ prefix and unmount """ premounted_devices_list = [] cmd = "ls -1 /media/" exitcode, stdout, stderr = LocalMachine.run_command(cmd) check_exitcode(cmd, exitcode, stderr) devices_list = stdout.split('\n') for dev in devices_list: dev = "/media/" + str(dev) if "pre_" in dev: premounted_devices_list.append(dev) module_printer("premounted devices: " + str(premounted_devices_list)) for dev in premounted_devices_list: if device_is_mounted(dev): unmount_device(dev) else: module_printer("{} not mounted".format(dev)) cmd = "rm -rf " + str(dev) exitcode, stdout, stderr = LocalMachine.run_command(cmd) check_exitcode(cmd, exitcode, stderr)
def format_ex4(device, label): """ format disk to ext4 linux file format """ cmd = "sudo mkfs.ext4 {} -L {}".format(device, label) exit_code, stdout, stderr = LocalMachine.run_command(cmd) if exit_code == 0: module_printer("[CMD] " + str(cmd)) module_printer(stdout) module_printer("\n") else: module_printer("EXITCODE:{}\nSTDOUT:{}\nSTDERR:{}\n".format( exit_code, stdout, stderr))
def set_get_device_name(device, name=None): if os.path.exists(device): if name is None: exitcode, stdout, stderr = LocalMachine.run_command( "sudo e2label " + str(device)) #device=/dev/sda1 if exitcode == 0 and stderr == "" and stdout != "": print("Device {} name: {}".format(device, stdout)) return stdout else: print("exitcode:{}\nstdout:{}\nstderr:{}".format( exitcode, stdout, stderr)) else: exitcode, stdout, stderr = LocalMachine.run_command( "sudo e2label " + str(device) + " " + str(name)) if exitcode == 0 and stderr == "": set_get_device_name(device) else: print("exitcode:{}\nstdout:{}\nstderr:{}".format( exitcode, stdout, stderr)) else: error_msg("Device is not found " + str(device))
def unmount_all_devices(del_mount_point=False): """ unmount all mounted devices """ mounted_devices_list = [] cmd = "ls -1 /media/" exitcode, stdout, stderr = LocalMachine.run_command(cmd) check_exitcode(cmd, exitcode, stderr) devices_list = stdout.split('\n') for dev in devices_list: if device_is_mounted(dev): dev = "/media/" + str(dev) mounted_devices_list.append(dev) module_printer("mounted devices: " + str(mounted_devices_list)) for dev in mounted_devices_list: if device_is_mounted(dev): unmount_device(dev) else: module_printer("{} not mounted".format(dev)) if del_mount_point: cmd = "rm -rf " + str(dev) exitcode, stdout, stderr = LocalMachine.run_command(cmd) check_exitcode(cmd, exitcode, stderr)
def is_any_device_avaible(): """ search under /dev with sd prefix for any available devices """ cmd = "ls /dev/sd*" textmatrix = "" devices = [] exitcode, stdout, stderr = LocalMachine.run_command(cmd) msg = "STDOUT: {} STDERR: {}".format(stdout, stderr) if exitcode == 0: return True, msg else: return False, msg
def edit_fstab_create_mount_point(device_info_dict, fstab_path="/etc/fstab"): global USER uuid = device_info_dict["uuid"] label = device_info_dict["label"] cmd = "UUID={} /media/{} auto defaults,auto,noatime,nofail,users,rw, 0 1".format( uuid, label) # ext4 mount - done # check device is already added to the system, and make override protection enable = False uuid_is_exists = "cat {} | grep -v grep | grep '{}'".format( fstab_path, uuid + " ") print(uuid_is_exists) label_is_exists = "cat {} | grep -v grep | grep '{}'".format( fstab_path, label + " ") exitcode, stdout, stderr = LocalMachine.run_command(uuid_is_exists) if exitcode != 0 and stderr == "" and stdout == "": print("\tnew device unique id {}".format(uuid)) exitcode, stdout, stderr = LocalMachine.run_command(label_is_exists) if exitcode != 0 and stderr == "" and stdout == "": print("\tnew device name {}".format(label)) enable = True else: print("\tdevice name is already exists in fstab {} !!!".format( label)) else: print("\tdevice unique id is already exists in fstab {} !!!".format( uuid)) if enable: print("+++> ADDING NEW DEVICE IS ENABLE") check_cmd = "cat {} | grep -v grep | grep '{}'".format(fstab_path, cmd) exitcode, stdout, stderr = LocalMachine.run_command(check_cmd) if exitcode != 0 and stdout == "": print("line not exists: {}".format(cmd)) print("ADD TO " + str(fstab_path)) # edit fstab file add_cmd = "sudo echo '{}' >> {}".format(cmd, fstab_path) exitcode, stdout, stderr = LocalMachine.run_command(add_cmd) if exitcode == 0: print("{} added succesfully!".format(cmd)) else: error_msg("Command: {} return with error code: {}".format( cmd, exitcode)) error_msg("STDOUT: {}\nSTDERR:{}".format(stdout, stderr)) else: print("line exists: {}".format(cmd)) # create mount point if not os.path.isdir("/media/" + str(label)): print("Create /media/" + str(label)) os.makedirs("/media/" + str(label)) print("chmod 0765 /media/" + str(label)) os.chmod("/media/" + str(label), 0765) print("chmod " + str(USER)) LocalMachine.run_command("chown " + USER + " /media/" + str(label)) else: print("/media/" + str(label) + " already exists")
def map_wlan_devices(): devices = [] host_address_list = SearchDevices.online_device_scanner() for device in host_address_list: devip = device macaddr = "n/a" try: exitcode, stdout, stderr = LocalMachine.run_command('arp -n {}'.format(device), shell=True) if exitcode == 0: macaddr = stdout.split(' ')[3] except Exception: pass devices.append([devip, macaddr]) return devices
def list_connected_devices(): """ get block devices from /dev """ cmd = "ls /dev/sd*" textmatrix = "" devices = [] exitcode, stdout, stderr = LocalMachine.run_command(cmd) if exitcode != 0 and "No such file or directory" in stderr: module_printer("\tNO DEVICES WAS FOUND.") return [] if exitcode == 0: textmatrix = LocalMachine.text_to_matrix_converter(stdout) for line in textmatrix: digit = line[0][ -1] # check if didgit is the last character ex. /dev/sda1 if digit.isdigit(): devices.append(line[0]) else: module_printer("Command: {} return with error code: {}".format( cmd, exitcode)) module_printer("STDOUT: {}\nSTDERR:{}".format(stdout, stderr)) sys.exit(1) return devices
def get_other_monitored_processes(color=Colors.CYAN): process_name_list = ["Xorg", "vncserver", "kodi"] data = color + " MONITORED PROCESSES:\n" + Colors.NC for process in process_name_list: exitcode, process_state, stderr = LocalMachine.run_command( "ps aux | grep -v grep | grep '" + str(process) + "'") if process_state == "": process_state = "inactive" else: process_state = "active" process_state, is_enabled = service_state_coloring( isactive=process_state, service_name=process) data += "\t" + color + str(process) + Colors.NC + " state: " + str( process_state) + "\n" return data
def create_base_strucure(storage_root_path, path_list): cmd = "mkdir -p " for path in path_list: full_cmd = cmd + path if not os.path.exists(path) and not os.path.islink(path): console_out("CMD: " + str(full_cmd)) exit_code, stdout, stderr = LocalMachine.run_command(full_cmd) if exit_code == 0: console_out("\tCREATE DIR DONE") else: console_out("\tCREATE DIR FAIL" + str(stderr)) else: console_out("Already exists: " + str(path)) for index, path in enumerate(path_list): if get_user_and_group(path)[1] != str(storage_folders_groups[index]): cmd_grp = "sudo chgrp " + str( storage_folders_groups[index]) + " " + str(path) console_out("CMD: " + str(cmd_grp)) exit_code, stdout, stderr = LocalMachine.run_command(cmd_grp) if exit_code == 0: console_out("\tSET GROUP DONE") else: console_out("\tSET GROUP FAIL" + str(stderr))
def migrate_from_internal_to_external_storage(default_storage_root, external_storage_root, default_storage_folders): if not os.path.exists(default_storage_root): return False default_storage_folder_content = os.listdir(default_storage_root) linking_is_required = False for content in default_storage_folder_content: abs_path = default_storage_root + os.sep + content if os.path.isdir(abs_path) and not os.path.islink(abs_path): cmd = "mv " + str(abs_path) + " " + str(external_storage_root) console_out("Migrate storage from {} to {}".format( default_storage_root, external_storage_root)) exit_code, stdout, stderr = LocalMachine.run_command(cmd) if exit_code != 0: console_out("\tFAIL") linking_is_required = True if linking_is_required: console_out("Create symlinks for backward compatibility") for folder in default_storage_folders: from_ = str(external_storage_root) + os.sep + str(folder) to_ = str(default_storage_root) + os.sep + str(folder) cmd = "ln -sf {} {}".format(from_, to_) exit_code, stdout, stderr = LocalMachine.run_command(cmd) return True
def network_mapper_raw(self, debug_print=False): print("[ClusterMemberDiscover] [arp-scan] get raw local network data") exitcode, stdout, stderr = LocalMachine.run_command("sudo arp-scan -l") local_machines_info_list = stdout.split("\n") for local_machines_info in local_machines_info_list: values = local_machines_info.split("\t") if self.validate_ip(values[0]): try: self.devices_on_network_raw[str(values[0]).strip()] = [str(values[1]).strip(),\ str(values[2]).strip(), "hostname"] except: pass if debug_print: for key, value in self.devices_on_network_raw.items(): print("IP: {}\n\tDATA: {}".format(key, value))
def set_value_MemDict(key, value, namespace="system", field=None): global clientMemDict_path if field is not None: cmd = "{} -md -n {} -f {} -k {} -v {} -s True".format( clientMemDict_path, namespace, field, key, value) else: cmd = "{} -md -n {} -k {} -v {} -s True".format( clientMemDict_path, namespace, key, value) __debug_print(cmd) exitcode, stdout, stderr = LocalMachine.run_command(cmd, wait_for_done=True) if exitcode == 0: state = stdout else: print("Get data from memdict failed: {}\n{}".format(cmd, stderr)) state = None return state
def map_wlan_devices(service_port=9008): devices = [] print("[NWSCN] Get online host list on port {}".format(service_port)) host_address_list = SearchDevices.online_device_scanner( service_port=service_port) print("[NWSCN] Get macaddress by ip ...") for device in host_address_list: devip = device macaddr = "n/a" try: exitcode, stdout, stderr = LocalMachine.run_command( 'arp -n {}'.format(device), shell=True, debug=False) if exitcode == 0: macaddr = stdout.split(' ')[3] except Exception: pass devices.append([devip, macaddr]) return devices
def device_mapper_inject_hostname_data(self, debug_print=True): print("[ClusterMemberDiscover] [nbtscan] get hostname by ip, create compact network data") for key, value in self.devices_on_network_raw.items(): exitcode, stdout, stderr = LocalMachine.run_command("nbtscan " + str(key)) stdout_lines = stdout.split("\n") cnt = 0 for index, line in enumerate(stdout_lines): line_worlds = re.split('\s+', line) if key in line_worlds[0]: hostname = line_worlds[1] self.devices_on_network[hostname] = {"ip": str(key), "mac": str(value[0]), "device": str(value[1])} else: hostname = "UNKNOWN-" + str(cnt) cnt+=1 self.devices_on_network[hostname] = {"ip": str(key), "mac": str(value[0]), "device": str(value[1])} if debug_print: for key, value in self.devices_on_network.items(): print("{}\n\t{}".format(key, value))