def __init__(self, malloc_strategy, scheduling_policy_class, round_robin_policy_on=True, round_robin_quantum=5):
self.__mutex = RLock()
self.__scheduling_policy_class = scheduling_policy_class
self.__round_robin_policy_on = round_robin_policy_on
self.__malloc_strategy = malloc_strategy
self.__pcb_table = PcbTable()
self.__quantum = round_robin_quantum
self.g_mode = False
class Kernel(object):
def __init__(self, malloc_strategy, scheduling_policy_class, round_robin_policy_on=True, round_robin_quantum=5):
self.__mutex = RLock()
self.__scheduling_policy_class = scheduling_policy_class
self.__round_robin_policy_on = round_robin_policy_on
self.__malloc_strategy = malloc_strategy
self.__pcb_table = PcbTable()
self.__quantum = round_robin_quantum
self.g_mode = False
def set_cpu(self, a_cpu):
a_cpu.set_kernel(self)
if self.__round_robin_policy_on:
a_cpu.enable_round_robin(self.__quantum)
self.__cpu = a_cpu
def set_memory(self, a_memory_ram):
self.__memory_ram = a_memory_ram
def set_hard_drive(self, a_hard_drive):
self.__hard_drive = a_hard_drive
def file_exists(self, path):
return self.__filesystem.file_exists( path )
def install_program(self, path, program):
program.append_instruction(Instruction("Close the program on memory.", "KILL"))
self.__filesystem.put_file('/bin/' + path, program)
def get_process_list(self):
result = {}
for id, pcb in self.__pcb_table.get_pcb_list().iteritems():
result[id] = { 'name': pcb.get_program_name() , 'state': pcb.get_state() }
return result
def boot(self):
self.__validate_kernel_setup()
self.__setup_components()
# self.get_cpu().start()
self.__clock.start()
def fork_execve(self, path):
with self.__cpu.pcb_not_set():
with self.__mutex:
program = self.__filesystem.get_file(path)
pcb = self.__loader.load(program)
self.get_irq_manager().handle( Irq(NEW_INTERRUPT, pcb) )
self.__cpu.pcb_not_set().notify()
def get_mem_manager(self):
return self.__mem_manager
def get_filesystem_module(self):
return self.__fs_module
def get_partitions(self):
return self.__hard_drive.partitions()
def __validate_kernel_setup(self):
if self.__cpu == None:
raise NoDeviceException("CPU")
if self.__hard_drive == None:
raise NoDeviceException("Hard Drive")
if self.__memory_ram == None:
raise NoDeviceException("Memory")
def __setup_components(self):
self.__setup_memory()
self.__setup_scheduling()
self.__setup_irq_manager()
self.__setup_clock()
self.__setup_filesystems()
self.__setup_program_loader()
self.__setup_authentication()
def __setup_memory(self):
self.__mem_manager = MemoryManager(self.__memory_ram, self.__malloc_strategy)
def __setup_filesystems(self):
self.__mount_root()
self.__filesystem = Filesystem(self.__fs_module) # For backwards compatibility only
def __mount_root(self):
self.__fs_module = FilesystemModule()
self.__fs_module.mount('/', self.__hard_drive.partition(0)) # we assume root partition is the first partition
def __setup_authentication(self):
self.__authentication = UsersAccountService(self.__filesystem)
def __setup_scheduling(self):
self.set_scheduler(self.__scheduling_policy_class())
def __setup_clock(self):
self.__clock = Clock()
self.__clock.add_listener( self.get_cpu() )
def __setup_program_loader(self):
self.__loader = ProgramLoader(self.__mem_manager, self.__pcb_table)
def get_cpu(self):
return self.__cpu
def set_scheduler(self, a_scheduler):
self.scheduler = a_scheduler
def get_scheduler(self):
return self.scheduler
def get_memory_ram(self):
return self.__memory_ram
def get_hard_drive(self):
return self.__hard_drive
def set_irq_manager(self, a_irq_manager):
self.irq_manager = a_irq_manager
def get_irq_manager(self):
return self.irq_manager
def set_ready_queue(self, a_queue):
self.ready_queue = a_queue
def get_ready_queue(self):
return self.ready_queue
def get_fileSystem(self):
return self.__filesystem
def get_authentication(self):
return self.__authentication
def __setup_irq_manager(self):
self.irq_manager = IrqManager()
self.__setup_new_handler()
self.__setup_io_handler()
self.__setup_io_end_handler()
self.__setup_kill_handler()
self.__setup_timeout_handler()
def __setup_timeout_handler(self):
timeout_handler = TimeoutInterruptionHandler(self.get_scheduler(), self.get_cpu())
self.get_irq_manager().reference_interruption_to_handler(TIMEOUT_INTERRUPT, timeout_handler)
def __setup_kill_handler(self):
kill_int_handler = KillInterruptionHandler(self.get_scheduler(), self.get_cpu(), self.__pcb_table, self.__mem_manager)
self.get_irq_manager().reference_interruption_to_handler(KILL_INTERRUPT, kill_int_handler)
def __setup_io_end_handler(self):
io_end_interruption_handler = IOEndInterruptionHandler(self.get_scheduler(), self.get_cpu(), self.get_mem_manager())
self.get_irq_manager().reference_interruption_to_handler(IO_END_INTERRUPT, io_end_interruption_handler)
def __setup_io_handler(self):
io_int_handler = IOInterruptionHandler(self.get_scheduler(), self.get_cpu(), IOManager(self), self.get_mem_manager())
self.get_irq_manager().reference_interruption_to_handler(IO_INTERRUPT, io_int_handler)
def __setup_new_handler(self):
new_int_handler = NewInterruptionHandler(self.get_scheduler(), self.get_cpu())
self.get_irq_manager().reference_interruption_to_handler(NEW_INTERRUPT, new_int_handler)
def login(self):
answer = raw_input('enable operative system with graphical environment? (yes or no)\n')
if (answer == 'yes') | (answer =='y'):
self.__log_with_graphical_environment()
elif (answer == 'no') | (answer =='n'):
self.__log_with_bash_environment()
else:
self.login()
def __log_with_graphical_environment(self):
self.g_mode = True
self.get_authentication().graphical_login()
def __log_with_bash_environment(self):
self.get_authentication().login()
