def __init__(self) -> None: super().__init__(title="Process Manager") self.connect("destroy", Gtk.main_quit) self.set_border_width(5) self.expropiated_process: Process = None self.process_manager = ProcessManager() self.timeout_id = None self.init_components()
def pick_file_or_directory(self, multi=False): """ Pop-up a file selection window. :param multi: Boolean Allow selecting multiple elements. :returns: List of files that were selected with file browser. """ files = ProcessManager.pick_file_or_directory(self, multi) files = [f.replace("/", "\\") for f in files] # Qt returns files with / while the javascript code expects paths on Windows to use \ return files
def __init__(self, testmode=False): self.process_manager = ProcessManager(self) self.data_queue = Queue() self.state = SystemState['ACTIVE'] if testmode == False: self._i2c = i2c_handler(self) self._gps = gps_handler(self) else: daq_tester = DaqTester(self) print("Test mode engaged") self.mqtt = MqttHandler(DASHBOARD_NAME, MQTT_BROKER_IP, self)
def __init__(self): self.my_shell = Shell() self.my_file_manager = FileManager(Config.storage_block_size, Config.storage_track_num, Config.storage_sec_num) self.my_memory_manager = MemoryManager( mode=Config.memory_management_mode, page_size=Config.memory_page_size, page_number=Config.memory_page_number, physical_page=Config.memory_physical_page_number) self.my_process_manager = ProcessManager(self.my_memory_manager) self.is_monitoring = False # start process manager self.my_process_manager_run_thread = threading.Thread( target=self.my_process_manager.start_manager) self.my_process_manager_run_thread.start() # printer Threading self.IOdevice_thread = threading.Thread( target=self.my_process_manager.io_device_handler) self.IOdevice_thread.start()
def execute_task(proc_settings_manager, mon_settings_manager): active_monitor_name = get_active_monitor_name() process_manager = ProcessManager() interval_counter = 0 while True: proc_cache_refresh_rate = mon_settings_manager.get_process_cache_refresh_rate( ) interval_secs = mon_settings_manager.get_interval_setting() if (interval_counter >= proc_cache_refresh_rate): process_manager.refresh_cache() interval_counter = 0 time.sleep(interval_secs) proc_settings = proc_settings_manager.get_settings() prev_monitor_name = active_monitor_name active_monitor_name = get_active_monitor_name() if prev_monitor_name != active_monitor_name: handle_active_monitor_change( prev_monitor_name, active_monitor_name, proc_settings, process_manager, ) interval_counter += 1
def worker(): logging.debug('Starting worker') while True: QueueManager.print_val() req = QueueManager.deque() time.sleep(10) to_message = req.args.get('to') if to_message == "COUNTER": ProcessManager.process_counter_request(req) elif to_message == "CUSTOMER": ProcessManager.process_customer_request(req) elif to_message == "COOK": ProcessManager.process_cook_request(req) elif to_message == "ANNOUNCER": ProcessManager.process_announcer_request(req) logging.debug('Exiting worker')
def worker(): logging.debug('Starting worker') while True: QueueManager.print_val() req = QueueManager.deque() time.sleep(10) to_message = req.args.get('to') if to_message == "COUNTER": ProcessManager.process_counter_request(req) elif to_message == "CUSTOMER": ProcessManager.process_customer_request(req) elif to_message == "COOK": ProcessManager.process_cook_request(req) elif to_message == "ANNOUNCER": ProcessManager.process_announcer_request(req) logging.debug('Exiting worker')
import requests from flask import Flask, request, jsonify from bot_request_manager import BotRequestManager from process_manager import ProcessManager app = Flask(__name__) process_manager = ProcessManager() @app.route('/webhook', methods=['POST']) def index(): req = request.get_json() request_manager = BotRequestManager(req) success = request_manager.get_result(process_manager) return jsonify(success = success) """ Initializes the webhook Args: url:str -> Provides the telegram server with a endpoint for webhook data """ def init_webhook(url): requests.get(url)
from template_processor import TemplateProcessor cwd = os.getcwd() args = parse() config = JsonConfigReader([JsonConfigValidator()]).read(file_name=args.config) terraform_directory = args.terraform_directory ansible_directory = args.ansible_directory mode = TerraformMode.APPLY.value if args.mode == 'apply' else TerraformMode.DESTROY.value output_parameters_path = os.path.join(terraform_directory, 'parameters.tfvars') template_processor = TemplateProcessor('utils/parameters.j2', output_parameters_path) template_processor.process(config) status_code = ProcessManager('terraform').with_cwd(args.terraform_directory)\ .with_args(mode, '-var-file="parameters.tfvars"', '-auto-approve')\ .start(lambda data: print(data)).wait() print(f'Terraform status code {status_code}') if status_code == 0 and mode == TerraformMode.APPLY.value: configuration = Configuration(config) tenant_id = configuration.azure.tenant_id client_id = configuration.azure.client_id client_secret = configuration.azure.client_secret inventory_creator = InventoryCreator(AzureHttpClient(), configuration) inventory = inventory_creator.create( AuthorizationDto(tenant_id, client_id, client_secret)) inventory_writer = InventoryWriter('swarm_inventory') inventory_writer.save(inventory) print('Inventory created')
from werkzeug.wrappers import Request, Response from jsonrpc import JSONRPCResponseManager, dispatcher from process_manager import ProcessManager @Request.application def application(request: Request): response = JSONRPCResponseManager.handle(request.data, dispatcher) return Response(response.json, mimetype='application/json') if __name__ == '__main__': from werkzeug.serving import run_simple process_manager = ProcessManager('processes.json') dispatcher['list_processes'] = process_manager.list_processes dispatcher['get_metrics'] = process_manager.get_metrics dispatcher['start_process'] = process_manager.start_process dispatcher['kill'] = process_manager.kill dispatcher['terminate'] = process_manager.terminate dispatcher['restart_process'] = process_manager.restart_process run_simple('localhost', 8000, application)
class Kernel: def __init__(self): self.my_shell = Shell() self.my_file_manager = FileManager(Config.storage_block_size, Config.storage_track_num, Config.storage_sec_num) self.my_memory_manager = MemoryManager( mode=Config.memory_management_mode, page_size=Config.memory_page_size, page_number=Config.memory_page_number, physical_page=Config.memory_physical_page_number) self.my_process_manager = ProcessManager(self.my_memory_manager) self.is_monitoring = False # start process manager self.my_process_manager_run_thread = threading.Thread( target=self.my_process_manager.start_manager) self.my_process_manager_run_thread.start() # printer Threading self.IOdevice_thread = threading.Thread( target=self.my_process_manager.io_device_handler) self.IOdevice_thread.start() # signal.signal(signal.SIGINT, self.my_shell.deblock) # monitoring all resources def monitoring(self, interval=1): self.is_monitoring = True self.my_file_manager.disk.disk_monitoring = True while self.is_monitoring: self.my_process_manager.resource_monitor() self.my_memory_manager.memory_watching() self.my_file_manager.draw_disk_speed() sleep(interval) def report_error(self, cmd, err_msg=''): print('[error %s] %s' % (cmd, err_msg)) if err_msg == '': self.display_command_description(cmd_list=[cmd]) # command: man [cmd1] [cmd2] ... def display_command_description(self, cmd_list): command_to_description = { 'man': 'manual page, format: man [command1] [command2] ...', 'ls': 'list directory contents, format: ls [-a|-l|-al] [path]', 'cd': 'change current working directory, format: cd [path]', 'rm': 'remove file or directory recursively, format: rm [-r|-f|-rf] path', 'mkdir': 'create directory, format: mkdir path', 'mkf': 'create common file, format: mkf path type size, e.g. mkf my_file crwx 300', 'dss': 'display storage status, format: dss', 'dms': 'display memory status, format: dms', 'exec': 'execute file, format: exec path, e.g. exec test', 'chmod': 'change mode of file, format: chmod path new_mode, e.g. chmod test erwx', 'ps': 'display process status, format: ps', 'rs': 'display resource status, format: rs', 'mon': 'start monitoring system resources, format: mon [-o], use -o to stop', 'td': 'tidy and defragment your disk, format: td', 'kill': 'kill process, format: kill pid', 'exit': 'exit MiniOS' } if len(cmd_list) == 0: cmd_list = command_to_description.keys() for cmd in cmd_list: if cmd in command_to_description.keys(): print(cmd, '-', command_to_description[cmd]) else: self.report_error(cmd=cmd, err_msg='no such command') def run(self): while True: # a list of commands split by space or tab current_file_list = self.my_file_manager.ls(method='get') command_split_list = self.my_shell.get_split_command( cwd=self.my_file_manager.current_working_path, file_list=current_file_list) # this indicates user push Enter directly, then nothing to happen if len(command_split_list) == 0: continue for command_split in command_split_list: if len(command_split) == 0: # an empty command continue tool = command_split[0] # tool name, e.g. ls, cd, ... argc = len(command_split) # argument count if tool == 'man': self.display_command_description( cmd_list=command_split[1:]) elif tool == 'ls': if argc >= 2: if command_split[1][0] == '-': mode = command_split[1] path_list = command_split[2:] if len(path_list) == 0: path_list = [''] else: mode = '' path_list = command_split[1:] for path in path_list: self.my_file_manager.ls(dir_path=path, mode=mode) else: self.my_file_manager.ls() elif tool == 'cd': if argc >= 2: self.my_file_manager.cd(dir_path=command_split[1]) else: self.my_file_manager.cd(dir_path=os.sep) elif tool == 'rm': if argc >= 2: if command_split[1][0] == '-': mode = command_split[1] path_list = command_split[2:] if len(path_list) == 0: self.report_error(cmd=tool) else: mode = '' path_list = command_split[1:] for path in path_list: self.my_file_manager.rm(file_path=path, mode=mode) else: self.report_error(cmd=tool) elif tool == 'chmod': if argc >= 3: self.my_file_manager.chmod(file_path=command_split[1], file_type=command_split[2]) else: self.report_error(cmd=tool) elif tool == 'mkf': if argc >= 4: self.my_file_manager.mkf(file_path=command_split[1], file_type=command_split[2], size=command_split[3]) else: self.report_error(cmd=tool) elif tool == 'mkdir': if argc >= 2: for path in command_split[1:]: self.my_file_manager.mkdir(dir_path=path) else: self.report_error(cmd=tool) elif tool == 'dss': self.my_file_manager.display_storage_status() elif tool == 'dms': self.my_memory_manager.display_memory_status() # self.my_shell.block(func=self.my_memory_manager.display_memory_status) elif tool == 'exec': if argc >= 2: path_list = command_split[1:] for path in path_list: my_file = self.my_file_manager.get_file( file_path=path, seek_algo=Config.seek_algo) if my_file: if my_file['type'][3] == 'x': self.my_process_manager.create( exefile=my_file) else: self.report_error( cmd=tool, err_msg='no execution permission') else: self.report_error(cmd=tool) else: self.report_error(cmd=tool) elif tool == 'ps': self.my_process_manager.print_process_status() # self.my_shell.block(func=self.my_process_manager.process_status) elif tool == 'rs': self.my_process_manager.print_resource_status() # self.my_shell.block(func=self.my_process_manager.resource_status) elif tool == 'mon': if argc >= 2 and command_split[1] == '-o': print('Stop monitoring') self.is_monitoring = False self.my_file_manager.disk.disk_monitoring = False else: # start monitoring print('Start monitoring') monitor_thread = threading.Thread( target=self.monitoring) monitor_thread.daemon = True monitor_thread.start() elif tool == 'td': self.my_file_manager.tidy_disk() elif tool == 'kill': if argc >= 2: for pid in command_split[1:]: pid_to_kill = int(pid) kill_res = self.my_process_manager.kill( pid=pid_to_kill) if kill_res: self.my_memory_manager.free(pid=pid_to_kill) else: self.report_error(cmd=tool) elif tool == 'exit': self.my_process_manager.is_running = False exit(0) else: self.report_error(cmd=tool, err_msg='no such command')
def start_thread(): ProcessManager.__init__() w = threading.Thread(name='worker', target=worker) w.start()
class ProcessManagerWindow(Gtk.Window): # __________________________________________________________________________ def __init__(self) -> None: super().__init__(title="Process Manager") self.connect("destroy", Gtk.main_quit) self.set_border_width(5) self.expropiated_process: Process = None self.process_manager = ProcessManager() self.timeout_id = None self.init_components() # __________________________________________________________________________ def init_components(self) -> None: grid = Gtk.Grid( row_homogeneous=True, column_homogeneous=True, row_spacing=5, column_spacing=5, ) # Simulate Switch ------------------------------------------------------ top_box = Gtk.Box(spacing=2) self.simulating_label = Gtk.Label(label="Start Simulating") self.simulating_switch = Gtk.Switch() self.simulating_switch.set_active(False) self.simulating_switch.connect("notify::active", self.execute_simulation) self.executing_spinner = Gtk.Spinner() self.quantum_rat_spin_button = Gtk.SpinButton( adjustment=Gtk.Adjustment(value=750, lower=125, upper=10000, step_increment=125, page_increment=0, page_size=0), climb_rate=1, digits=0, ) self.quantum_rat_spin_button.connect("value-changed", self.change_quantum_rat) # Inactive Processes List ---------------------------------------------- self.inactive_processes_list_box = Gtk.ListBox() self.inactive_processes_list_box.set_selection_mode( Gtk.SelectionMode.NONE) inactive_processes_scrolled_window = Gtk.ScrolledWindow() inactive_processes_scrolled_window.add( self.inactive_processes_list_box) for i in self.process_manager.inactive_processes: process_button = Gtk.Button(label=i.name) process_button.connect("clicked", self.prepare_process_action) self.inactive_processes_list_box.add(process_button) add_process_button = Gtk.Button(label="Add Process") add_process_button.connect("clicked", self.add_process_action) # Prepared Processes List ---------------------------------------------- self.prepared_processes_list_box = Gtk.ListBox() self.prepared_processes_list_box.set_selection_mode( Gtk.SelectionMode.NONE) prepared_processes_scrolled_window = Gtk.ScrolledWindow() prepared_processes_scrolled_window.add( self.prepared_processes_list_box) # Executed Process Progress Bar ---------------------------------------- self.executed_process_list_box = Gtk.ListBox() self.executed_process_list_box.set_selection_mode( Gtk.SelectionMode.NONE) executed_process_scrolled_window = Gtk.ScrolledWindow() executed_process_scrolled_window.add(self.executed_process_list_box) # Suspended Processes List --------------------------------------------- self.suspended_processes_list_box = Gtk.ListBox() self.suspended_processes_list_box.set_selection_mode( Gtk.SelectionMode.NONE) suspended_processes_scrolled_window = Gtk.ScrolledWindow() suspended_processes_scrolled_window.add( self.suspended_processes_list_box) # Add Components ------------------------------------------------------- top_box.add(Gtk.Label(label='Quantum Rat (ms):')) top_box.add(self.quantum_rat_spin_button) top_box.add(self.simulating_label) top_box.add(self.simulating_switch) top_box.add(self.executing_spinner) grid.attach(top_box, 0, 0, 3, 1) grid.attach(Gtk.Label(label="Inactive Processes"), 0, 1, 1, 1) grid.attach(inactive_processes_scrolled_window, 0, 2, 1, 15) grid.attach(add_process_button, 0, 17, 1, 1) grid.attach(Gtk.Label(label="Prepared Processes"), 1, 1, 3, 1) grid.attach(prepared_processes_scrolled_window, 1, 2, 3, 16) grid.attach(Gtk.Label(label="Executed Process"), 4, 1, 3, 1) grid.attach(executed_process_scrolled_window, 4, 2, 3, 1) grid.attach(Gtk.Label(label="Suspended Processes"), 4, 3, 3, 1) grid.attach(suspended_processes_scrolled_window, 4, 4, 3, 14) self.update_components() self.add(grid) # __________________________________________________________________________ def update_components(self) -> None: # Add Prepared Processes ----------------------------------------------- self.remove_list_box(self.process_manager.prepared_processes, self.prepared_processes_list_box) for i in self.process_manager.prepared_processes: process_progress_bar = ProcessProgressBar(i) flag = True for j in self.prepared_processes_list_box.get_children(): if j.process == i: flag = False break if flag: self.prepared_processes_list_box.add(Row(process_progress_bar)) # Add Executed Processes ----------------------------------------------- executed_process = self.process_manager.executed_process self.clear_list_box(self.executed_process_list_box) if executed_process: process_progress_bar = ProcessProgressBar(executed_process) self.executed_process_list_box.add(process_progress_bar) # Add Suspended Processes ---------------------------------------------- self.remove_list_box(self.process_manager.suspended_processes, self.suspended_processes_list_box) for i in self.process_manager.suspended_processes: process_progress_bar = ProcessProgressBar(i) flag = True for j in self.suspended_processes_list_box.get_children(): if j.process == i: flag = False break if flag: self.suspended_processes_list_box.add( Row(process_progress_bar)) # Update lists components ---------------------------------------------- self.inactive_processes_list_box.show_all() self.prepared_processes_list_box.show_all() self.executed_process_list_box.show_all() self.suspended_processes_list_box.show_all() # __________________________________________________________________________ def remove_list_box(self, processes_list, list_box): for i in list_box.get_children(): if i.process not in processes_list: i.destroy() # __________________________________________________________________________ def clear_list_box(self, list_box) -> None: for i in list_box.get_children(): i.destroy() # __________________________________________________________________________ def execute_simulation(self, switch, _): f = self.complete_execution if self.expropiated_process else self.iteration if self.timeout_id: GLib.source_remove(self.timeout_id) del self.timeout_id self.timeout_id = None if switch.get_active(): self.timeout_id = GLib.timeout_add( self.process_manager.quantum_rat * 1000, f, None) self.executing_spinner.start() self.simulating_label.set_label("Stop Simulating") else: self.executing_spinner.stop() self.simulating_label.set_label("Start Simulating") # __________________________________________________________________________ def change_quantum_rat(self, spin_button): quantum_rat = spin_button.get_value_as_int() self.process_manager.set_quantum_rat(quantum_rat / 1000) # __________________________________________________________________________ def add_process_action(self, _) -> None: add_process_message_dialog = Gtk.MessageDialog( parent=None, title="Add New Process", text="Process Name:", secondary_text="Empty name will not be added", buttons=Gtk.ButtonsType.OK_CANCEL, ) process_name_entry = Gtk.Entry() add_process_message_dialog.get_content_area().pack_end( process_name_entry, True, True, 0) add_process_message_dialog.show_all() response = add_process_message_dialog.run() process_name = process_name_entry.get_text() add_process_message_dialog.destroy() if process_name and response == Gtk.ResponseType.OK: self.process_manager.add_process(process_name) process_button = Gtk.Button(label=process_name) process_button.connect("clicked", self.prepare_process_action) self.inactive_processes_list_box.add(process_button) self.update_components() # __________________________________________________________________________ def prepare_process_action(self, button) -> None: process = self.process_manager.prepare_process(button.get_label()) if process: print("+ prepare:", process.__str__(True)) if (process.priority == Process.PRIORITIES[0] and not self.expropiated_process): self.expropiation(process) self.update_components() else: show_error_message_error = Gtk.MessageDialog( parent=None, title="Can not execute more processes", text="Error:", secondary_text="Can not execute more processes\n" "Processes Limit: 999", buttons=Gtk.ButtonsType.OK_CANCEL, ) show_error_message_error.run() show_error_message_error.destroy() # __________________________________________________________________________ def execute_process_action(self, process) -> None: if process: print("* execute:", process.__str__(True)) self.process_manager.execute_process(process) self.update_components() # __________________________________________________________________________ def deactivate_process_action(self) -> None: process = self.process_manager.deactivate_process() print("- deactivate:", process.__str__(True)) self.update_components() # __________________________________________________________________________ def suspend_process_action(self) -> None: process = self.process_manager.suspend_process() print("/ suspend:", process.__str__(True)) self.update_components() # __________________________________________________________________________ def iteration(self, _) -> bool: # Suspended to prepared i = 0 while i < len(self.process_manager.suspended_processes): process = self.process_manager.suspended_processes[0] if hasattr(process, 'next') and process.next: delattr(process, 'next') self.process_manager.suspended_processes.remove(process) self.process_manager.prepared_processes.append(process) elif process.interaction: process.next = True i += 1 else: self.process_manager.suspended_processes.remove(process) self.process_manager.prepared_processes.append(process) # Executed to suspended or deactivated executed_process = self.process_manager.executed_process if executed_process: executed_process.progress += executed_process.advance if executed_process.progress >= 1: self.deactivate_process_action() else: self.suspend_process_action() # Prepared to executed process_to_execute = self.process_manager.compete() self.execute_process_action(process_to_execute) return self.expropiated_process == None # __________________________________________________________________________ def expropiation(self, process: Process) -> None: executed = self.process_manager.executed_process if executed: self.process_manager.prepared_processes.append(executed) self.process_manager.execute_process(process) self.expropiated_process = process self.execute_simulation(self.simulating_switch, None) print("^ expropiate:", process.__str__(True)) self.process_manager.execute_process(process) self.expropiated_process = process self.execute_simulation(self.simulating_switch, None) # __________________________________________________________________________ def complete_execution(self, _) -> bool: # Execute until complete, then deactivate executed_process = self.process_manager.executed_process if executed_process: executed_process.progress += executed_process.advance print("* execute:", executed_process.__str__(True)) if executed_process.progress >= 1: self.deactivate_process_action() del self.expropiated_process self.expropiated_process = None self.execute_simulation(self.simulating_switch, None) self.update_components() return self.expropiated_process != None
def start_thread(): ProcessManager.__init__() w = threading.Thread(name='worker', target=worker) w.start()
def run_server(): ProcessManager.set_role("CUSTOMER") print 'make api call to get customer queue size' inbound_worker.start_thread() app.run()