def loop(self): if self.steps: end_time = self.logical_time + self.steps else: end_time = sys.maxint exit_code = 0 self.interrupted = False old_interrupt = None def interrupt(sgn, frame): msg.interactive("Interrupting fuzzer, dropping to console (press ^C again to terminate)") signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None self.interrupted = True raise KeyboardInterrupt() self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: # Always connect to controllers explicitly self.simulation.connect_to_controllers() self._log_input_event(ConnectToControllers()) if self.delay_startup: # Wait until the first OpenFlow message is received log.info("Waiting until first OpenfFlow message received..") while self.simulation.god_scheduler.pending_receives() == []: self.simulation.io_master.select(self.delay) while self.logical_time < end_time: self.logical_time += 1 try: self.trigger_events() msg.event("Round %d completed." % self.logical_time) halt = self.maybe_check_invariant() if halt: exit_code = 5 break self.maybe_inject_trace_event() time.sleep(self.delay) except KeyboardInterrupt as e: if self.interrupted: interactive = Interactive(self.simulation_cfg, self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('fuzzer', self), )) self.old_interrupt = signal.signal(signal.SIGINT, interrupt) else: raise e log.info("Terminating fuzzing after %d rounds" % self.logical_time) if self.print_buffers: self._print_buffers() finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) if self._input_logger is not None: self._input_logger.close(self, self.simulation_cfg) return exit_code
def run_simulation_forward(self, dag, post_bootstrap_hook=None): event_scheduler = self.create_event_scheduler(self.simulation) self.event_scheduler_stats = event_scheduler.stats if post_bootstrap_hook is not None: post_bootstrap_hook() self.interrupted = False old_interrupt = None def interrupt(sgn, frame): msg.interactive("Interrupting replayer, dropping to console (press ^C again to terminate)") signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None self.interrupted = True raise KeyboardInterrupt() self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: for i, event in enumerate(dag.events): try: self.logical_time += 1 self.compute_interpolated_time(event) if isinstance(event, InputEvent): self._check_early_state_changes(dag, i, event) self._check_new_state_changes(dag, i) # TODO(cs): quasi race-condition here. If unexpected state change # happens *while* we're waiting for event, we basically have a # deadlock (if controller logging is set to blocking) until the # timeout occurs event_scheduler.schedule(event) if self.auto_permit_dp_events: self._permit_dp_events() self.increment_round() except KeyboardInterrupt as e: if self.interrupted: interactive = Interactive(self.simulation_cfg) interactive.simulate(self.simulation, bound_objects=( ('replayer', self), )) self.old_interrupt = signal.signal(signal.SIGINT, interrupt) else: raise e finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) msg.event(color.B_BLUE+"Event Stats: %s" % str(event_scheduler.stats))
def run_simulation_forward(self, dag, post_bootstrap_hook=None): event_scheduler = self.create_event_scheduler(self.simulation) event_scheduler.set_input_logger(self._input_logger) self.event_scheduler_stats = event_scheduler.stats if post_bootstrap_hook is not None: post_bootstrap_hook() def interrupt(sgn, frame): msg.interactive("Interrupting replayer, dropping to console (press ^C again to terminate)") signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None raise KeyboardInterrupt() self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: for i, event in enumerate(dag.events): try: self.compute_interpolated_time(event) if self.default_dp_permit: self.dp_checker.check_dataplane(i, self.simulation) if isinstance(event, InputEvent): self._check_early_state_changes(dag, i, event) self._check_new_state_changes(dag, i) self._check_unexpected_cp_messages(dag, i) # TODO(cs): quasi race-condition here. If unexpected state change # happens *while* we're waiting for event, we basically have a # deadlock (if controller logging is set to blocking) until the # timeout occurs # TODO(cs): we don't actually allow new internal message events # through.. we only let new state changes through. Should experiment # with whether we would get better fidelity if we let them through. event_scheduler.schedule(event) if self.logical_time != event.round: self.logical_time = event.round self.increment_round() except KeyboardInterrupt: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('replayer', self), )) self.old_interrupt = signal.signal(signal.SIGINT, interrupt) finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) msg.event(color.B_BLUE+"Event Stats: %s" % str(event_scheduler.stats)) if self.default_dp_permit: msg.event(color.B_BLUE+"DataplaneDrop Stats: %s" % str(self.dp_checker.stats)) if self.end_in_interactive: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('replayer', self), ))
def run_simulation_forward(self, dag, post_bootstrap_hook=None): event_scheduler = self.create_event_scheduler(self.simulation) event_scheduler.set_input_logger(self._input_logger) self.event_scheduler_stats = event_scheduler.stats if post_bootstrap_hook is not None: post_bootstrap_hook() def interrupt(sgn, frame): msg.interactive("Interrupting replayer, dropping to console (press ^C again to terminate)") signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None raise KeyboardInterrupt() self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: for i, event in enumerate(dag.events): try: self.compute_interpolated_time(event) if self.default_dp_permit: self.dp_checker.check_dataplane(i, self.simulation) if isinstance(event, InputEvent): self._check_early_state_changes(dag, i, event) self._check_new_state_changes(dag, i) self._check_unexpected_dp_messages(dag, i) # TODO(cs): quasi race-condition here. If unexpected state change # happens *while* we're waiting for event, we basically have a # deadlock (if controller logging is set to blocking) until the # timeout occurs # TODO(cs): we don't actually allow new internal message events # through.. we only let new state changes through. Should experiment # with whether we would get better fidelity if we let them through. event_scheduler.schedule(event) if self.logical_time != event.round: self.logical_time = event.round self.increment_round() except KeyboardInterrupt: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('replayer', self), )) self.old_interrupt = signal.signal(signal.SIGINT, interrupt) finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) msg.event(color.B_BLUE+"Event Stats: %s" % str(event_scheduler.stats)) if self.default_dp_permit: msg.event(color.B_BLUE+"DataplaneDrop Stats: %s" % str(self.dp_checker.stats)) if self.end_in_interactive: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('replayer', self), ))
def loop(self): if self.steps: end_time = self.logical_time + self.steps else: end_time = sys.maxint self.interrupted = False self.old_interrupt = None def interrupt(sgn, frame): msg.interactive( "Interrupting fuzzer, dropping to console (press ^C again to terminate)" ) signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None self.interrupted = True raise KeyboardInterrupt() self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: # Always connect to controllers explicitly self.simulation.connect_to_controllers() self._log_input_event(ConnectToControllers()) if self.delay_startup: # Wait until the first OpenFlow message is received log.info("Waiting until first OpenFlow message received..") while self.simulation.openflow_buffer.pending_receives() == []: self.simulation.io_master.select(self.delay) sent_self_packets = False while self.logical_time < end_time: self.logical_time += 1 try: if not self._initializing(): self.trigger_events() halt = self.maybe_check_invariant() if halt: self.simulation.set_exit_code(5) break self.maybe_inject_trace_event() else: # Initializing self.check_pending_messages(pass_through=True) if not sent_self_packets and ( self.logical_time % self._all_to_all_interval) == 0: # Only need to send self packets once self._send_initialization_packets( send_to_self=True) sent_self_packets = True elif self.logical_time > self.initialization_rounds: # All-to-all mode if (self.logical_time % self._all_to_all_interval) == 0: self._send_initialization_packets( send_to_self=False) self._all_to_all_iterations += 1 if self._all_to_all_iterations > len( self.simulation.topology.hosts): log.info("Done initializing") self._pending_all_to_all = False self.check_dataplane(pass_through=True) msg.event("Round %d completed." % self.logical_time) time.sleep(self.delay) except KeyboardInterrupt as e: if self.interrupted: interactive = Interactive(self.simulation_cfg, self._input_logger) interactive.simulate(self.simulation, bound_objects=(('fuzzer', self), )) self.old_interrupt = signal.signal( signal.SIGINT, interrupt) else: raise e log.info("Terminating fuzzing after %d rounds" % self.logical_time) if self.print_buffers: self._print_buffers() finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) if self._input_logger is not None: self._input_logger.close(self, self.simulation_cfg) return self.simulation
def run_simulation_forward(self, post_bootstrap_hook=None): event_scheduler = self.create_event_scheduler(self.simulation) event_scheduler.set_input_logger(self._input_logger) self.event_scheduler_stats = event_scheduler.stats if post_bootstrap_hook is not None: post_bootstrap_hook() def interrupt(sgn, frame): msg.interactive( "Interrupting replayer, dropping to console (press ^C again to terminate)" ) signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None raise KeyboardInterrupt() self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: for i, event in enumerate(self.dag.events): try: self.compute_interpolated_time(event) if self.default_dp_permit: self.dp_checker.check_dataplane(i, self.simulation) if isinstance(event, InputEvent): self._check_early_state_changes(self.dag, i, event) self._check_new_state_changes(self.dag, i) self._check_unexpected_cp_messages(self.dag, i) # TODO(cs): quasi race-condition here. If unexpected state change # happens *while* we're waiting for event, we basically have a # deadlock (if controller logging is set to blocking) until the # timeout occurs # TODO(cs): we don't actually allow new internal message events # through.. we only let new state changes through. Should experiment # with whether we would get better fidelity if we let them through. if self.fail_fast and (i % self.check_interval ) == 0 and self._check_violation(): return event_scheduler.schedule(event) if self.logical_time != event.round: self.logical_time = event.round self.increment_round() except KeyboardInterrupt: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=(('replayer', self), )) # If Interactive terminated due to ^D, return to our fuzzing loop, # prepared again to drop into Interactive on ^C. self.old_interrupt = signal.signal(signal.SIGINT, interrupt) except Exception: log.critical( "Exception raised while scheduling event %s, replay %s" % (str(event), self.replay_id)) raise if self.invariant_check: # Wait a bit in case the bug takes awhile to happen # TODO(cs): may be redundant with WaitTime events at the end of the # trace. log.debug("Sleeping %d seconds after run" % self.end_wait_seconds) if self.default_dp_permit: self._sleep_with_dataplane_passthrough( self.end_wait_seconds) else: time.sleep(self.end_wait_seconds) self._check_violation() finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) msg.event(color.B_BLUE + "Event Stats: %s" % str(event_scheduler.stats)) if self.default_dp_permit: msg.event(color.B_BLUE + "DataplaneDrop Stats: %s" % str(self.dp_checker.stats)) if self.end_in_interactive: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=(('replayer', self), ))
from config.experiment_config_lib import ControllerConfig from sts.topology import MeshTopology, BufferedPatchPanel from sts.control_flow.interactive import Interactive from sts.input_traces.input_logger import InputLogger from sts.simulation_state import SimulationConfig # Use POX as our controller start_cmd = "./pox.py --verbose openflow.of_01 --address=__address__ --port=__port__ openflow.discovery forwarding.l2_multi" controllers = [ControllerConfig(start_cmd, cwd="pox", address="127.0.0.1", port=8888)] topology_class = MeshTopology topology_params = "num_switches=4" simulation_config = SimulationConfig(controller_configs=controllers, topology_class=topology_class, topology_params=topology_params) control_flow = Interactive(simulation_config, input_logger=InputLogger())
def loop(self): if self.steps: end_time = self.logical_time + self.steps else: end_time = sys.maxint self.interrupted = False self.old_interrupt = None def interrupt(sgn, frame): msg.interactive("Interrupting fuzzer, dropping to console (press ^C again to terminate)") # If ^C is triggered twice in a row, invoke the original handler. signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None self.interrupted = True raise KeyboardInterrupt() # signal.signal returns the previous interrupt handler. self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: # Always connect to controllers explicitly self.simulation.connect_to_controllers() self._log_input_event(ConnectToControllers()) if self.delay_startup: # Wait until the first OpenFlow message is received log.info("Waiting until first OpenFlow message received..") while self.simulation.openflow_buffer.pending_receives() == []: self.simulation.io_master.select(self.delay) sent_self_packets = False while self.logical_time < end_time: self.logical_time += 1 try: if not self._initializing(): self.trigger_events() halt = self.maybe_check_invariant() if halt: self.simulation.set_exit_code(5) break self.maybe_inject_trace_event() else: # Initializing self.check_pending_messages(pass_through=True) if not sent_self_packets and (self.logical_time % self._all_to_all_interval) == 0: # Only need to send self packets once self._send_initialization_packets(send_to_self=True) sent_self_packets = True elif self.logical_time > self.initialization_rounds: # All-to-all mode if (self.logical_time % self._all_to_all_interval) == 0: self._send_initialization_packets(send_to_self=False) self._all_to_all_iterations += 1 if self._all_to_all_iterations > len(self.simulation.topology.hosts): log.info("Done initializing") self._pending_all_to_all = False self.check_dataplane(pass_through=True) msg.event("Round %d completed." % self.logical_time) # Note that time.sleep triggers a round of select.select() time.sleep(self.delay) except KeyboardInterrupt as e: if self.interrupted: interactive = Interactive(self.simulation_cfg, self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('fuzzer', self), )) # If Interactive terminated due to ^D, return to our replaying loop, # prepared again to drop into Interactive on ^C. self.old_interrupt = signal.signal(signal.SIGINT, interrupt) else: raise e log.info("Terminating fuzzing after %d rounds" % self.logical_time) if self.print_buffers: self._print_buffers() finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) if self._input_logger is not None: self._input_logger.close(self, self.simulation_cfg) return self.simulation
def run_simulation_forward(self, post_bootstrap_hook=None): event_scheduler = self.create_event_scheduler(self.simulation) event_scheduler.set_input_logger(self._input_logger) self.event_scheduler_stats = event_scheduler.stats if post_bootstrap_hook is not None: post_bootstrap_hook() def interrupt(sgn, frame): msg.interactive("Interrupting replayer, dropping to console (press ^C again to terminate)") signal.signal(signal.SIGINT, self.old_interrupt) self.old_interrupt = None raise KeyboardInterrupt() self.old_interrupt = signal.signal(signal.SIGINT, interrupt) try: for i, event in enumerate(self.dag.events): try: self.compute_interpolated_time(event) if self.default_dp_permit: self.dp_checker.check_dataplane(i, self.simulation) if isinstance(event, InputEvent): self._check_early_state_changes(self.dag, i, event) self._check_new_state_changes(self.dag, i) self._check_unexpected_cp_messages(self.dag, i) # TODO(cs): quasi race-condition here. If unexpected state change # happens *while* we're waiting for event, we basically have a # deadlock (if controller logging is set to blocking) until the # timeout occurs # TODO(cs): we don't actually allow new internal message events # through.. we only let new state changes through. Should experiment # with whether we would get better fidelity if we let them through. if self.fail_fast and (i % self.check_interval) == 0 and self._check_violation(): return event_scheduler.schedule(event) if self.logical_time != event.round: self.logical_time = event.round self.increment_round() except KeyboardInterrupt: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('replayer', self), )) # If Interactive terminated due to ^D, return to our fuzzing loop, # prepared again to drop into Interactive on ^C. self.old_interrupt = signal.signal(signal.SIGINT, interrupt) except Exception: log.critical("Exception raised while scheduling event %s, replay %s" % (str(event), self.replay_id)) raise if self.invariant_check: # Wait a bit in case the bug takes awhile to happen # TODO(cs): may be redundant with WaitTime events at the end of the # trace. log.debug("Sleeping %d seconds after run" % self.end_wait_seconds) if self.default_dp_permit: self._sleep_with_dataplane_passthrough(self.end_wait_seconds) else: time.sleep(self.end_wait_seconds) self._check_violation() finally: if self.old_interrupt: signal.signal(signal.SIGINT, self.old_interrupt) msg.event(color.B_BLUE+"Event Stats: %s" % str(event_scheduler.stats)) if self.default_dp_permit: msg.event(color.B_BLUE+"DataplaneDrop Stats: %s" % str(self.dp_checker.stats)) if self.end_in_interactive: interactive = Interactive(self.simulation_cfg, input_logger=self._input_logger) interactive.simulate(self.simulation, bound_objects=( ('replayer', self), ))