class TestKernel(unittest.TestCase):
def setUp(self):
self.memory = Memory(50)
self.scheduler = Scheduler()
self.scheduler.set_as_fifo()
self.a_kernel = Kernel(None)
self.pcb_table = PCBTable()
self.a_kernel.set_pcb_table(self.pcb_table)
interruption_manager = InterruptionHandler(self.a_kernel.cpu)
self.a_kernel.set_interruption_handler(interruption_manager)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(self, interruption_manager)
def write_program(self,program,memory):
pos = 0
for instruction in program.obtain_instructions():
memory.put(pos,instruction)
def load_a_instruction_in_a_program(self):
program = Program("SIN-IO")
instruction = Instruction("Texto")
program.addInstruction(instruction)
program.addInstruction(instruction)
self.write_program(program,self.memory)
self.setup_load_of_a_program_in_memory(2,program,2)
def load_a_io_instruction_in_a_program(self):
program = Program("IO")
self.a_kernel.set_scheduler(self.scheduler)
instruction = InstructionIO()
program.addInstruction(instruction)
program.addInstruction(instruction)
self.write_program(program, self.memory)
self.setup_load_of_a_program_in_memory(2,program,2)
def setup_load_of_a_program_in_memory(self, amount_instructions, program, pcb_id):
block_holder = BlockHolder(program)
block_holder.set_representation([0,1])
pcb = PCB(amount_instructions, pcb_id, block_holder)
self.pcb_table.add(pcb)
self.scheduler.policy.add_pcb(pcb)
memory_admin = ToyMemoryAdmin(self.memory)
self.a_kernel.cpu.set_actual_pcb(pcb)
self.a_kernel.cpu.set_memory_manager(memory_admin)
def test_given_pcb_when_cpu_complete_instruction_cycle_then_increments_pc(self):
'''
Compare the initial state of PCB's PC with final state
'''
self.load_a_instruction_in_a_program()
self.assertEqual(0, self.a_kernel.cpu.actual_pcb.get_pc())
self.a_kernel.cpu.complete_instruction_cycle()
self.assertEqual(1, self.a_kernel.cpu.actual_pcb.get_pc())
def test_given_pcb_when_cpu_complete_instruction_cycle_then_IO_Manager_captures_interruption_and_increments_pc(self):
self.load_a_io_instruction_in_a_program()
self.assertEqual(0, self.a_kernel.cpu.actual_pcb.get_pc())
self.a_kernel.cpu.complete_instruction_cycle()
self.assertEqual(1, self.a_kernel.cpu.actual_pcb.get_pc())
class TestScheduler(unittest.TestCase):
def setUp(self):
program1 = Program('D')
program2 = Program('E')
program3 = Program('H')
program4 = Program('S')
self.pcb1 = PCB(1, 20, PageHolder(program1))
self.pcb1.set_priority(PCBPriorities.HIGH)
self.pcb2 = PCB(2, 25, PageHolder(program2))
self.pcb2.set_priority(PCBPriorities.MEDIUM)
self.pcb3 = PCB(3, 15, PageHolder(program3))
self.pcb3.set_priority(PCBPriorities.LOW)
self.pcb4 = PCB(4, 6, PageHolder(program4))
self.pcb4.set_priority(PCBPriorities.LOW)
self.scheduler = Scheduler()
def test_scheduler_with_fifo(self):
self.fifo = FifoPolicy(self.scheduler)
self.fifo.add_pcb(self.pcb1)
self.fifo.add_pcb(self.pcb2)
self.fifo.add_pcb(self.pcb3)
self.fifo.add_pcb(self.pcb4)
result = self.scheduler.next_process()
self.assertEquals(self.pcb1.get_pid, result.get_pid)
def test_scheduler_with_round_robin(self):
quantum = 1
self.round_robin = RoundRobinPolicy(self.scheduler, quantum)
self.round_robin.add_pcb(self.pcb1)
self.round_robin.add_pcb(self.pcb2)
self.round_robin.add_pcb(self.pcb3)
self.round_robin.add_pcb(self.pcb4)
expected_elements = [self.pcb1, self.pcb2, self.pcb3, self.pcb4]
for expected_element in expected_elements:
self.assertEqual(expected_element.get_pid, self.round_robin.next_process().get_pid)
def test_scheduler_with_priority(self):
self.priority_policy = PriorityPolicy(self.scheduler)
self.priority_policy.add_pcb(self.pcb1)
self.priority_policy.add_pcb(self.pcb2)
self.priority_policy.add_pcb(self.pcb3)
self.priority_policy.add_pcb(self.pcb4)
expected_elems = [self.pcb1, self.pcb2, self.pcb3, self.pcb4]
for expected_elem in expected_elems:
self.assertEqual(expected_elem.get_pid, self.scheduler.next_process().get_pid)
class TestCPUWithClock(unittest.TestCase):
def setUp(self):
self.memory = Memory(50)
self.a_kernel = Kernel(None)
self.cpu = Cpu(self.a_kernel)
self.scheduler = Scheduler()
self.scheduler.set_as_fifo()
self.clock = Clock(self.cpu)
self.a_kernel.clock = self.clock
self.pcb_table = PCBTable()
def test_the_clock_makes_a_tick_and_the_cpu_fetch_a_single_instruction_to_decode(self):
CpuArrangements().load_a_instruction_in_a_program(self.a_kernel,self.scheduler,self.pcb_table,self.cpu,self.memory)
self.a_kernel.clock.tick()
self.assertTrue(self.cpu.get_actual_pcb().get_pc() == 1)
def main0():
instruction1 = BasicInstruction()
instruction2 = IO_Instruction()
instruction3 = Priority_Instruction()
program = Program('a')
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
programb = Program('b')
programb.addInstruction(instruction3)
programc = Program('c')
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
timer = Timer(2)
memory = Memory()
memory.buildMemory(9)
frame1 = Frame(memory,0,9)
mmu = MMU()
mmu.addEmptyFrame(frame1)
cpu = CPU(None,mmu,None,timer)
scheduler = Scheduler(PFIFO())
ioqueue = IOQueue(scheduler)
disk = Disk(None)
kernel = Kernel(cpu,ioqueue,scheduler,mmu,disk)
disk.setKernel(kernel)
cpu.setKernel(kernel)
kernel.saveProgram(program)
kernel.saveProgram(programb)
kernel.saveProgram(programc)
kernel.start()
cpu.start()
ioqueue.start()
def main1():
instruction1 = BasicInstruction()
instruction3 = Priority_Instruction()
logger = Logger("../resource/log.txt")
program = Program('a')
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
programb = Program('b')
programb.addInstruction(instruction3)
programc = Program('c')
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
timer = Timer(2)
memory = Memory()
memory.buildMemory(9)
frame1 = Frame(memory,0,9)
mmu = MMU()
mmu.addEmptyFrame(frame1)
cpu = CPU(None,mmu,None,timer,logger)
scheduler = Scheduler(PFIFO())
ioqueue = IOQueue(scheduler,logger)
disk = Disk(None)
kernel = Kernel(cpu,ioqueue,scheduler,mmu,disk,logger)
disk.setKernel(kernel)
disk.save(program)
disk.save(programb)
disk.save(programc)
cpu.setKernel(kernel)
kernel.executeProgram('a')
def setUp(self):
self.pcb1 = PCB(5, 20, 4)
self.pcb2 = PCB(4, 21, 3)
self.a_kernel = Kernel(None)
self.scheduler = Scheduler(None)
self.a_kernel.set_scheduler(self.scheduler)
self.cpu = Cpu(self.a_kernel)
def setUp(self):
self.memory = Memory(50)
self.a_kernel = Kernel(None)
self.cpu = Cpu(self.a_kernel)
self.scheduler = Scheduler()
self.scheduler.set_as_fifo()
self.clock = Clock(self.cpu)
self.a_kernel.clock = self.clock
self.pcb_table = PCBTable()
def test__start_scheduler(self, mock_start):
mock_start.return_value = True
expected = True
# act
actual = Scheduler.start(operations={'do_mutate_fasta': True}, path_input=TPLS.MC_TESTS_INPUT.value,
path_output=TPLS.MC_TESTS_OUTPUT, pdb_list=['RepairPDB_1.pdb'],
fastafile_list=['1_A.fasta'], amino_acids=['A'], use_multithread=False,
write_1_fasta_only=True, write_fasta_per_mut=True)
# assert
self.assertEqual(expected, actual)
def setUp(self):
self.memory = Memory(50)
self.scheduler = Scheduler()
self.scheduler.set_as_fifo()
self.a_kernel = Kernel(None)
self.pcb_table = PCBTable()
self.a_kernel.set_pcb_table(self.pcb_table)
interruption_manager = InterruptionHandler(self.a_kernel.cpu)
self.a_kernel.set_interruption_handler(interruption_manager)
load_in_interruption_manager = Handle_Loaders()
load_in_interruption_manager.load_handlers(self, interruption_manager)
def __init__(self, operations: dict, use_multithread: bool,
path_input: str, path_output: str, path_pdbfiles: list,
path_fastafiles: list, specific_fxmutants: list,
amino_acids: list,
write_to_csv_dumpfile_after_each_mutant: bool):
"""
All algorithmic analyses start from here. IdentifyProtein.py which runs Blast analyses is the only program that
currently runs independently.
:param write_to_csv_dumpfile_after_each_mutant:
:param operations: Operations flagged True to run, False to not run.
:param use_multithread: True if program(s) should be spawned on separate threads/processes.
:param path_input: Abs path to input root dir
:param path_output: Abs path to output root dir
:param path_pdbfiles: Abs path to repo of pdbfiles.
:param path_fastafiles: Abs path to repo of fastafiles.
:param amino_acids: All amino acids that mutation operations will mutate residues to.
:param write_to_csv_dumpfile_after_each_mutant: True to extract desired values to write to a single csv file (for
database dump).
"""
if operations == {} or Main._all_ops_are_false(operations):
raise ValueError(
"All options in 'operations' were either set to FALSE or some typographical error. "
"Check /config/global_options/global_options.txt was written correctly"
)
elif operations[Str.OPER_RUN_MUT_FSTA.value] or operations[Str.OPER_RUN_AGDR.value] or \
operations[Str.OPER_RUN_FX_RPR.value] or operations[Str.OPER_RUN_FX_BM.value] or \
operations[Str.OPER_RUN_FX_STAB.value] or operations[Str.OPER_RUN_FX_AC.value]:
Scheduler.start(operations,
use_multithread,
path_input,
path_output,
path_pdbfiles,
path_fastafiles,
specific_fxmutants,
amino_acids,
write_1_fasta_only=True,
write_fasta_per_mut=False,
write_to_csv_dumpfile_after_each_mutant=
write_to_csv_dumpfile_after_each_mutant)
def main():
args = parse_arguments()
translation = TranslationFactory.get_translation(args.lang)
scheduler = Scheduler(args.path)
app = wx.App()
# Fix datetime.strptime issue
locale.setlocale(locale.LC_ALL, 'C')
_ = WhatsAppAutomationFrame(translation, scheduler)
app.MainLoop()
def setUp(self):
program1 = Program('D')
program2 = Program('E')
program3 = Program('H')
program4 = Program('S')
self.pcb1 = PCB(1, 20, PageHolder(program1))
self.pcb1.set_priority(PCBPriorities.HIGH)
self.pcb2 = PCB(2, 25, PageHolder(program2))
self.pcb2.set_priority(PCBPriorities.MEDIUM)
self.pcb3 = PCB(3, 15, PageHolder(program3))
self.pcb3.set_priority(PCBPriorities.LOW)
self.pcb4 = PCB(4, 6, PageHolder(program4))
self.pcb4.set_priority(PCBPriorities.LOW)
self.scheduler = Scheduler()
def main3():
if(1==1):
instruction1 = BasicInstruction()
instruction2 = BasicInstruction()
memory = Memory()
memory.buildMemory(5)
frame1 = Frame(memory,0,1)
frame2 = Frame(memory,1,2)
frame3 = Frame(memory,3,1)
frame4 = Frame(memory,4,1)
mmu = MMU()
mmu.fullFrames.append(frame1)
mmu.fullFrames.append(frame3)
mmu.emptyFrames.append(frame2)
mmu.emptyFrames.append(frame4)
program = Program('a')
program.addInstruction(instruction1)
pcbA = PCB('a',0,0,1)
programb = Program('b')
pcbB = PCB('b',0,3,1)
programb.addInstruction(instruction1)
frame1.load(pcbA,program)
frame3.load(pcbB,programb)
programc = Program('c')
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
programd = Program('d')
programd.addInstruction(instruction2)
programd.addInstruction(instruction2)
programd.addInstruction(instruction2)
scheduler = Scheduler(PFIFO())
disk = Disk(None)
kernel = Kernel (None,None,scheduler,mmu,disk)
disk.setKernel(kernel)
memory.printMemory()
kernel.saveProgram(programc)
print( " ")
memory.printMemory()
kernel.saveProgram(programd)
print( " ")
memory.printMemory()
print(len(disk.programList))
def main():
instruction1 = BasicInstruction()
instruction2 = IO_Instruction()
instruction3 = Priority_Instruction()
program = Program('a')
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
program.addInstruction(instruction1)
programd = Program('d')
programd.addInstruction(instruction1)
programd.addInstruction(instruction1)
programd.addInstruction(instruction1)
programd.addInstruction(instruction1)
programd.addInstruction(instruction1)
programb = Program('b')
programb.addInstruction(instruction3)
programc = Program('c')
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
programc.addInstruction(instruction1)
timer = Timer(2)
memory = Memory()
memory.buildMemory(9)
frame1 = Frame(memory,0,9)
logger = Logger("/home/matlock/Escritorio/Sistemas Operativos/OSProyect/resource/log.txt")
mmu = MMU(logger)
mmu.addEmptyFrame(frame1)
cpu = CPU(None,mmu,None,timer,logger)
scheduler = Scheduler(PFIFO())
ioqueue = IOQueue(scheduler,logger)
disk = Disk(None)
kernel = Kernel(cpu,ioqueue,scheduler,mmu,disk,logger)
disk.setKernel(kernel)
cpu.setKernel(kernel)
x = []
x.append(program)
x.append(programb)
x.append(programc)
x.append(programd)
kernel.saveOnDisk(x)
kernel.executeProgram('a')
#!/usr/bin/env python3
import os
from src.Scheduler import Scheduler
import logging
logging.basicConfig(level=os.environ.get("LOGLEVEL", "INFO"))
logger = logging.getLogger(__name__)
if __name__ == '__main__':
scheduler = Scheduler()
scheduler.main()
class TestSchedulerInteractions(unittest.TestCase):
'''
Testing Scheduler and CPU interactions...
'''
def setUp(self):
self.pcb1 = PCB(5, 20, 4)
self.pcb2 = PCB(4, 21, 3)
self.a_kernel = Kernel(None)
self.scheduler = Scheduler(None)
self.a_kernel.set_scheduler(self.scheduler)
self.cpu = Cpu(self.a_kernel)
def test_when_given_scheduler_with_priority_and_cpu_then_scheduler_sends_next_process_to_cpu(self):
queue = PriorityQueue()
scheduler_priority = Scheduler(None, ready_queue=queue)
self.a_kernel.set_scheduler(scheduler_priority)
scheduler_priority.set_cpu(self.cpu)
scheduler_priority.set_as_priority()
self.pcb1.set_priority(1)
scheduler_priority.push_to_queue(self.pcb1)
self.pcb2.set_priority(2)
scheduler_priority.push_to_queue(self.pcb2)
expected_pcb = scheduler_priority.next_process()
scheduler_priority.send_next_to_cpu()
self.assertEqual(self.pcb2, self.cpu.get_actual_pcb())
def test_when_given_scheduler_with_round_robin_and_a_cpu_then_scheduler_sends_next_process_to_cpu(self):
self.scheduler.set_cpu(self.cpu)
quantum = 1
self.scheduler.set_as_round_robin(quantum)
self.scheduler.push_to_queue(self.pcb1)
self.scheduler.send_next_to_cpu()
self.assertEqual(self.pcb1, self.cpu.get_actual_pcb())
def test_when_given_scheduler_with_fifo_and_a_cpu_then_scheduler_sends_next_process_to_cpu(self):
self.scheduler.set_cpu(self.cpu)
self.scheduler.set_as_fifo()
self.scheduler.push_to_queue(self.pcb1)
self.scheduler.send_next_to_cpu()
self.assertEqual(self.pcb1, self.cpu.get_actual_pcb())
class ENA():
HOME = expanduser("~")
# Booleans
running = False
# Objects
edit_users = Edit_Users()
commands = Commands()
deploy = Deploy()
scheduler = Scheduler()
main_user = None
ena = None
# edit_users = None
# commands = None
# deploy = None
# scheduler = None
id = None
# Strings
conn_string = "host='localhost' dbname='enabrain' user='******' password='******'"
# Array for users
users = []
#constructor
def ena(self, ena):
self.running = True
self.ena = ena
#Creates the commands
self.edit_users.Edit_Users(ena)
self.commands.commands(self.ena, self.deploy, self.scheduler)
try:
#Checks if there is a table, if so, it loads the users
self.id = self.edit_users.load_users()
except:
#Creates tables then loads empty users and sets the user id to 0
Create_Tables = create_tables()
Create_Tables.create_tables(ena)
self.id = self.edit_users.load_users()
self.ena.run()
#this command is used in Commands.py
def ena_help(self):
print("=======================================")
if (self.main_user == None):
for command in self.commands.commands_array:
print(command)
else:
for command in self.commands.commands_array:
print(command)
print("=======================================")
#Admin function
def show_users(self):
for user in self.users:
print("=======================================")
user.show_info()
print("=======================================")
def change_user_level(self):
selected_user = input(
"please enter the user you want to change their level: ")
real_user = False
for user in self.users:
if (user.username == selected_user):
real_user = True
check = input("Are you sure you want to change " +
selected_user + "'s level: ")
level = int(input("please enter the user's new level: "))
if (check.lower() == "yes" or check.lower() == "y"):
user.level = level
print(user.username + " is now a level " + str(user.level))
else:
print("Authorization cancled")
if (not real_user):
print("There is no user with that username.")
def login(self):
testing_username = input("username: "******"Password: "******"----ADMIN----")
print(self.main_user.username + ", You are now logged in")
#this lets the user know that their password or username is incorrect
else:
if (not authenticate):
false_pass = getpass.getpass("Password: "******"username or password is incorrect")
def logout(self):
#this logs them out, as the functions name implies
for user in self.users:
user.logged_in = False
self.main_user = None
self.commands.load_commands_abstract_user()
print("You are now logged out")
def clear(self):
#check if the user is using windows
if os.name == 'nt':
os.system('cls')
#else it uses linux termianls 'clear'
else:
os.system('clear')
def run(self):
self.clear()
#gets commands
command = input("Hello, my name is Ena, how may I assist you today: ")
#main running loop
while (self.running):
self.commands.test_commands(command)
command = input("How may I assist you today: ")
def main():
scheduler = Scheduler()
scheduler.run()
import sys
from src.Scheduler import Scheduler
if __name__ == '__main__':
scheduler = Scheduler(sys.argv[1:2]) # chrome path as an argument.
scheduler.schedule("22/05/2020-23:48:40", "test", "Selenium-Test") # TODO - change it.
# try to cancel the scheduled task.
scheduler.cancel_scheduled_msg("22/05/2020-23:48:40", "Selenium-Test")
def test_when_given_scheduler_with_priority_and_cpu_then_scheduler_sends_next_process_to_cpu(self):
queue = PriorityQueue()
scheduler_priority = Scheduler(None, ready_queue=queue)
self.a_kernel.set_scheduler(scheduler_priority)
scheduler_priority.set_cpu(self.cpu)
scheduler_priority.set_as_priority()
self.pcb1.set_priority(1)
scheduler_priority.push_to_queue(self.pcb1)
self.pcb2.set_priority(2)
scheduler_priority.push_to_queue(self.pcb2)
expected_pcb = scheduler_priority.next_process()
scheduler_priority.send_next_to_cpu()
self.assertEqual(self.pcb2, self.cpu.get_actual_pcb())
