def ecome_to_life(self, mbox, life_of_universe, thermobox, heaterbox, envirotomotdet, lit_bubtoenviro, clockboxes, berkeley_or_lamport): if berkeley_or_lamport == "berkeley": neighbors = create_edges("enviro",6,clockboxes) parent, children, status = find_MST("enviro", neighbors) self.time=berkeley_clock_synch("enviro", self.offset, parent, children, status) mbox.wait_on_mail("enviro") time_until_we_all_die = 0 while time_until_we_all_die < life_of_universe: self.temperature_change(time_until_we_all_die) temp = message("thermo","enviro", "", self.temperature, thermobox.timestamp(self.offset)) thermobox.deliver_mail(self.offset,temp) x = heaterbox.wait_on_mail(self.offset) if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = heaterbox.timestamp(self.offset) #recieves a new message it compares it's own clock time to that of the if x.time > current_time : #timestamp in the message; if the time in the timestamp is larger than the self.offset = x.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and if x.data == "on": #it must add the difference between (plus 1) to its current offset self.is_heater_on = "yes" else: self.is_heater_on = "no" time_until_we_all_die = time_until_we_all_die + 1 self.intruder_change(time_until_we_all_die) isthereintruder = message("mot_det","enviro", "", self.intruder, envirotomotdet.timestamp(self.offset)) envirotomotdet.deliver_mail(self.offset,isthereintruder) x = lit_bubtoenviro.wait_on_mail(self.offset) if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = lit_bubtoenviro.timestamp(self.offset) #recieves a new message it compares it's own clock time to that of the if x.time > current_time : #timestamp in the message; if the time in the timestamp is larger than the self.offset = x.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and if x.data == "on": #it must add the difference between (plus 1) to its current offset self.is_light_on = "yes" else: self.is_light_on = "no" if berkeley_or_lamport == "berkeley": self.time=berkeley_clock_synch("enviro", self.offset, parent, children, status)
def tcome_to_life(self, rbox, life_of_universe, envirobox, pipeboxes, clockboxes, berkeley_or_lamport): if berkeley_or_lamport == "berkeley": neighbors = create_edges("thermo", 7, clockboxes) parent, children, status = find_MST("thermo", neighbors) self.time = berkeley_clock_synch("thermo", self.offset, parent, children, status) time_until_we_all_die = 0 self.register_self(rbox) while time_until_we_all_die < life_of_universe: x = pipeboxes[self.idnum].wait_on_query(self.offset, self.idnum) if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = pipeboxes[self.idnum].timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if x.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = x.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and if x.command == "query": #it must add the difference between (plus 1) to its current offset self.query_response(pipeboxes) temp = envirobox.wait_on_mail(self.offset) if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = envirobox.timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if temp.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = temp.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and self.state = temp.data #it must add the difference between (plus 1) to its current offset time_until_we_all_die = time_until_we_all_die + 1 if berkeley_or_lamport == "berkeley": self.time = berkeley_clock_synch("thermo", self.offset, parent, children, status)
def dcome_to_life(self, rbox, life_of_universe, pipeboxes, usertodoortdet, clockboxes, berkeley_or_lamport): if berkeley_or_lamport == "berkeley": neighbors = create_edges("doorboy", 9, clockboxes) parent, children, status = find_MST("doorboy", neighbors) self.time = berkeley_clock_synch("doorboy", self.offset, parent, children, status) time_until_we_all_die = 0 self.register_self(rbox) while time_until_we_all_die < life_of_universe: isdooropen = usertodoortdet.wait_on_mail(self.offset) if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = usertodoortdet.timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if isdooropen.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = isdooropen.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and self.state = isdooropen.command #it must add the difference between (plus 1) to its current offset time_until_we_all_die = time_until_we_all_die + 1 self.report_state(pipeboxes) if berkeley_or_lamport == "berkeley": self.time = berkeley_clock_synch("doorboy", self.offset, parent, children, status)
def ucome_to_life(self, mbox, life_of_universe, usertogate, usertodoor, clockboxes, berkeley_or_lamport): if berkeley_or_lamport == "berkeley": neighbors = create_edges("user", 4, clockboxes) parent, children, status = find_MST("user", neighbors) self.time = berkeley_clock_synch("user", self.offset, parent, children, status) mbox.wait_on_mail("user") time_until_we_all_die = 0 self.name = "home" while time_until_we_all_die < life_of_universe: x = usertogate.wait_on_query(self.offset, "user") if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = usertogate.timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if x.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = x.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and time_until_we_all_die = time_until_we_all_die + 1 #it must add the difference between (plus 1) to its current offset if x.data == "yes" and self.name == "away": print( " A L EEEEEEEEEEE RRRRRRRR TTTTTTTTTTTTT" ) print( " A A L E R R T " ) print( " A A L E R R T " ) print( " AAAAAAA L EEEEEEEEEEE R RRRRRR T " ) print( " A A L E R R T " ) print( " A A L E R R T " ) print( "A A LLLLLLLLLLL EEEEEEEEEEE R R T " ) else: pass prevstate = self.name home_or_not = input('') if home_or_not == "away": self.name = "away" elif home_or_not == "home": self.name = "home" report = message("gate", "user", "", self.name, usertogate.timestamp(self.offset)) usertogate.deliver_mail(self.offset, report) if self.name != prevstate: door = message("door", "user", "statechange", self.name, usertodoor.timestamp(self.offset)) usertodoor.deliver_mail(self.offset, door) else: door = message("door", "user", "nochange", "", usertodoor.timestamp(self.offset)) usertodoor.deliver_mail(self.offset, door) if berkeley_or_lamport == "berkeley": self.time = berkeley_clock_synch("user", self.offset, parent, children, status)
def bcome_to_life(self, rbox, life_of_universe, gatetobackend, clockboxes, berkeley_or_lamport): if berkeley_or_lamport == "berkeley": neighbors = create_edges("backend", 3, clockboxes) parent, children, status = find_MST("backend", neighbors) self.time = berkeley_clock_synch("backend", self.offset, parent, children, status) addressbook = rbox.wait_on_mail("backend") self.registry = addressbook.data for j, x in enumerate(self.registry): if x[1] == "sensor" and x[2] == "temperature": self.thermoidnum = j elif x[1] == "device" and x[2] == "temperature": self.heateridnum = j elif x[1] == "sensor" and x[2] == "motion": self.mot_detidnum = j elif x[1] == "device" and x[2] == "motion": self.lit_bubidnum = j elif x[1] == "sensor" and x[2] == "door": self.door_detidnum = j security_beacon = ["", "sensor", "security"] self.sec_beaconidnum = len(self.registry) self.registry.append(security_beacon) time_until_we_all_die = 0 while time_until_we_all_die < life_of_universe - 2: time_until_we_all_die = time_until_we_all_die + 1 for q in range(6): christmastime = gatetobackend.wait_on_mail(self.offset) if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = gatetobackend.timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if christmastime.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = christmastime.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and if christmastime.command == "no_change": #it must add the difference between (plus 1) to its current offset pass else: if christmastime.command == "temp_change": if self.registry[ self.thermoidnum][0] != christmastime.data: self.database.append(christmastime) self.registry[ self.thermoidnum][0] = christmastime.data elif christmastime.command == "heater_change": self.database.append(christmastime) self.registry[self.heateridnum][0] = christmastime.data elif christmastime.command == "motion_change": self.database.append(christmastime) self.registry[ self.mot_detidnum][0] = christmastime.data elif christmastime.command == "bulb_change": self.database.append(christmastime) self.registry[ self.lit_bubidnum][0] = christmastime.data elif christmastime.command == "door_change": self.database.append(christmastime) self.registry[ self.door_detidnum][0] = christmastime.data elif christmastime.command == "presence_change": self.database.append(christmastime) self.registry[ self.sec_beaconidnum][0] = christmastime.data if berkeley_or_lamport == "berkeley": self.time = berkeley_clock_synch("backend", self.offset, parent, children, status) if berkeley_or_lamport == "berkeley": self.time = berkeley_clock_synch("backend", self.offset, parent, children, status) self.time = berkeley_clock_synch("backend", self.offset, parent, children, status) for q in range(8): christmastime = gatetobackend.wait_on_mail(self.offset) if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = gatetobackend.timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if christmastime.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = christmastime.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and if christmastime.command == "no_change": #it must add the difference between (plus 1) to its current offset pass else: if christmastime.command == "temp_change": if self.registry[ self.thermoidnum][0] != christmastime.data: self.database.append(christmastime) self.registry[self.thermoidnum][0] = christmastime.data elif christmastime.command == "heater_change": self.database.append(christmastime) self.registry[self.heateridnum][0] = christmastime.data elif christmastime.command == "motion_change": self.database.append(christmastime) self.registry[self.mot_detidnum][0] = christmastime.data elif christmastime.command == "bulb_change": self.database.append(christmastime) self.registry[self.lit_bubidnum][0] = christmastime.data elif christmastime.command == "door_change": self.database.append(christmastime) self.registry[self.door_detidnum][0] = christmastime.data elif christmastime.command == "presence_change": self.database.append(christmastime) self.registry[self.sec_beaconidnum][0] = christmastime.data for q in self.registry: print(q) for z in self.database: z.printmessage(self.offset, "reader")
def gcome_to_life(self, rbox, life_of_universe, num_of_devices, pipeboxes, usertogate, gatetobackend, clockboxes, berkeley_or_lamport): if berkeley_or_lamport == "berkeley": neighbors = create_edges("gate", 2, clockboxes) parent, children, status = find_MST("gate", neighbors) self.time = berkeley_clock_synch("gate", self.offset, parent, children, status) self.activate_devices(rbox, num_of_devices) activate_enviroment = message("enviro", "gate", "activate", "", rbox.timestamp(self.offset)) rbox.deliver_mail(activate_enviroment) activate_user_interface = message("user", "gate", "activate", "", rbox.timestamp(self.offset)) rbox.deliver_mail(activate_user_interface) activate_backend = message("backend", "gate", "activate", self.registry, rbox.timestamp(self.offset)) rbox.deliver_mail(activate_backend) time_until_we_all_die = 0 oldmotdetdata = "no" while time_until_we_all_die < life_of_universe: time_until_we_all_die = time_until_we_all_die + 1 self.change_state(self.heateridnum, self.alertheater, pipeboxes) self.query_state(self.thermoidnum, pipeboxes, time_until_we_all_die, life_of_universe, gatetobackend, berkeley_or_lamport) isthere_intruder = pipeboxes[self.mot_detidnum].wait_on_query( self.offset, "gate") if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = pipeboxes[self.mot_detidnum].timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if isthere_intruder.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = isthere_intruder.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and oldbulbstatus = self.should_i_turn_on_bulb #it must add the difference between (plus 1) to its current offset if oldmotdetdata != isthere_intruder.data: newmotdetbstatus = message( "backend", "gate", "motion_change", isthere_intruder.data, gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, newmotdetbstatus) else: oldstatus = message("backend", "gate", "no_change", "", gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, oldstatus) oldmotdetdata = isthere_intruder.data if self.mode == "home": if isthere_intruder.data == "yes": self.should_i_turn_on_bulb = "on" self.time_since_last_intruder = 0 else: self.time_since_last_intruder = self.time_since_last_intruder + 1 if self.time_since_last_intruder == 5: self.should_i_turn_on_bulb = "off" hola = message("user", "gate", "", "", usertogate.timestamp(self.offset)) usertogate.deliver_mail(self.offset, hola) elif self.mode == "away": self.should_i_turn_on_bulb = "off" intruder_alert = message("user", "gate", "", isthere_intruder.data, usertogate.timestamp(self.offset)) usertogate.deliver_mail(self.offset, intruder_alert) self.change_state(self.lit_bubidnum, self.should_i_turn_on_bulb, pipeboxes) if oldbulbstatus != self.should_i_turn_on_bulb: newbulbstatus = message("backend", "gate", "bulb_change", self.should_i_turn_on_bulb, gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, newbulbstatus) else: oldstatus = message("backend", "gate", "no_change", "", gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, oldstatus) userstatus = usertogate.wait_on_query(self.offset, "gate") if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = usertogate.timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if userstatus.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = userstatus.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and oldpresencestatus = self.mode #it must add the difference between (plus 1) to its current offset if userstatus.data == "home": self.mode = "home" elif userstatus.data == "away": self.mode = "away" if oldpresencestatus != self.mode: newpresencestatus = message( "backend", "gate", "presence_change", self.mode, gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, newpresencestatus) else: oldstatus = message("backend", "gate", "no_change", "", gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, oldstatus) doorstatus = pipeboxes[self.door_detidnum].wait_on_query( self.offset, "gate") if berkeley_or_lamport == "lamport": #This performs the Lamport logical clocks algorithm: everytime the process current_time = pipeboxes[self.door_detidnum].timestamp( self.offset ) #recieves a new message it compares it's own clock time to that of the if doorstatus.time > current_time: #timestamp in the message; if the time in the timestamp is larger than the self.offset = doorstatus.time - current_time + 1 #time in its own logical clock then it knows that it is a contradicton and if doorstatus.data == "statechange": #it must add the difference between (plus 1) to its current offset newdoorstatus = message("backend", "gate", "door_change", self.mode, gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, newdoorstatus) else: oldstatus = message("backend", "gate", "no_change", "", gatetobackend.timestamp(self.offset)) gatetobackend.deliver_mail(self.offset, oldstatus) if berkeley_or_lamport == "berkeley": self.time = berkeley_clock_synch("gate", self.offset, parent, children, status)