def main(args): def load_format_file(format_file): if format_file.endswith('.py'): format_file = format_file[:-3].replace("/", ".") config = __import__(format_file, globals(), locals(), ["*"]) return config if args.format_file is not None: format_def = load_format_file(args.format_file) else: format_def = object() dp_trace = None if args.dp_trace_path is not None: dp_trace = Trace(args.dp_trace_path).dataplane_trace if hasattr(format_def, "fields"): fields = format_def.fields else: fields = default_fields for field in fields: if field not in field_formatters: raise ValueError("unknown field %s" % field) if hasattr(format_def, "filtered_classes"): filtered_classes = format_def.filtered_classes else: filtered_classes = default_filtered_classes stats = Stats() # all events are printed with a fixed number of lines, and (optionally) # separated by delimiter lines of the form: # ---------------------------------- with open(args.input) as input_file: trace = parse(input_file) for event in trace: if type(event) not in filtered_classes: if dp_trace is not None and type( event) == replay_events.TrafficInjection: event.dp_event = dp_trace.pop(0) for field in fields: field_formatters[field](event) stats.update(event) if check_for_violation_signature(trace, args.violation_signature): print "Violation occurs at end of trace: %s" % args.violation_signature elif args.violation_signature is not None: print("Violation does not occur at end of trace: %s", args.violation_signature) print if args.stats: print "Stats: %s" % stats
def main(args): def load_format_file(format_file): if format_file.endswith('.py'): format_file = format_file[:-3].replace("/", ".") config = __import__(format_file, globals(), locals(), ["*"]) return config if args.format_file is not None: format_def = load_format_file(args.format_file) else: format_def = object() dp_trace = None if args.dp_trace_path is not None: dp_trace = Trace(args.dp_trace_path).dataplane_trace if hasattr(format_def, "fields"): fields = format_def.fields else: fields = default_fields for field in fields: if field not in field_formatters: raise ValueError("unknown field %s" % field) if hasattr(format_def, "filtered_classes"): filtered_classes = format_def.filtered_classes else: filtered_classes = default_filtered_classes stats = Stats() # all events are printed with a fixed number of lines, and (optionally) # separated by delimiter lines of the form: # ---------------------------------- with open(args.input) as input_file: trace = parse(input_file) for event in trace: if type(event) not in filtered_classes: if dp_trace is not None and type(event) == replay_events.TrafficInjection: event.dp_event = dp_trace.pop(0) for field in fields: field_formatters[field](event) stats.update(event) if check_for_violation_signature(trace, args.violation_signature): print "Violation occurs at end of trace: %s" % args.violation_signature elif args.violation_signature is not None: print ("Violation does not occur at end of trace: %s", args.violation_signature) print if args.stats: print "Stats: %s" % stats
def main(args): if args.dp_trace_path is None: args.dp_trace_path = os.path.dirname(args.input) + "/dataplane.trace" dp_trace = Trace(args.dp_trace_path).dataplane_trace event_logger = InputLogger() event_logger.open(results_dir="/tmp/events.trace") with open(args.input) as input_file: trace = parse(input_file) for event in trace: if type(event) == replay_events.TrafficInjection: event.dp_event = dp_trace.pop(0) event_logger.log_input_event(event) event_logger.output.close()
def bootstrap(self, sync_callback, boot_controllers=default_boot_controllers): '''Return a simulation object encapsulating the state of the system in its initial starting point: - boots controllers - connects switches to controllers May be invoked multiple times! ''' def remove_monkey_patch(): if hasattr(select, "_old_select"): # Revert the previous monkeypatch to allow the new true_sockets to # connect select.select = select._old_select socket.socket = socket._old_socket def initialize_io_loop(): ''' boot the IOLoop (needed for the controllers) ''' _io_master = IOMaster() # monkey patch time.sleep for all our friends _io_master.monkey_time_sleep() # tell sts.console to use our io_master msg.set_io_master(_io_master) return _io_master def wire_controller_patch_panel(controller_manager, create_io_worker): patch_panel = None if not self.interpose_on_controllers: return patch_panel # N.B. includes local controllers in network namespaces or VMs. remote_controllers = controller_manager.remote_controllers if len(remote_controllers) != 0: patch_panel = self.controller_patch_panel_class( create_io_worker) for c in remote_controllers: patch_panel.register_controller(c.cid, c.guest_eth_addr, c.host_device) return patch_panel def instantiate_topology(create_io_worker): '''construct a clean topology object from topology_class and topology_params''' log.info("Creating topology...") # If you want to shoot yourself in the foot, feel free :) comma = "" if self._topology_params == "" else "," topology = eval( "%s(%s%screate_io_worker=create_io_worker)" % (self._topology_class.__name__, self._topology_params, comma)) return topology # Instantiate the pieces needed for Simulation's constructor remove_monkey_patch() io_master = initialize_io_loop() sync_connection_manager = STSSyncConnectionManager( io_master, sync_callback) controller_manager = boot_controllers(self.controller_configs, self.snapshot_service, sync_connection_manager) controller_patch_panel = wire_controller_patch_panel( controller_manager, io_master.create_worker_for_socket) topology = instantiate_topology(io_master.create_worker_for_socket) patch_panel = self._patch_panel_class(topology.switches, topology.hosts, topology.get_connected_port) openflow_buffer = OpenFlowBuffer() dataplane_trace = None if self._dataplane_trace_path is not None: dataplane_trace = Trace(self._dataplane_trace_path, topology) if self._violation_persistence_threshold is not None: violation_tracker = ViolationTracker( self._violation_persistence_threshold) else: violation_tracker = ViolationTracker() simulation = Simulation(topology, controller_manager, dataplane_trace, openflow_buffer, io_master, controller_patch_panel, patch_panel, sync_callback, self.multiplex_sockets, violation_tracker, self._kill_controllers_on_exit) self.current_simulation = simulation return simulation
def bootstrap(self, sync_callback): '''Return a simulation object encapsulating the state of the system in its initial starting point: - boots controllers - connects switches to controllers May be invoked multiple times! Optional parameter: - switch_init_sleep_seconds: an integer, sleep time in seconds, to wait for switches to initialize their TCP connections with the controller(s). Defaults to False ''' def initialize_io_loop(): ''' boot the IOLoop (needed for the controllers) ''' _io_master = IOMaster() # monkey patch time.sleep for all our friends _io_master.monkey_time_sleep() # tell sts.console to use our io_master msg.set_io_master(_io_master) return _io_master def boot_controllers(sync_connection_manager): # Boot the controllers controllers = [] for c in self.controller_configs: controller = Controller(c, sync_connection_manager, self.snapshot_service) controller.start() log.info("Launched controller c%s: %s [PID %d]" % (str( c.uuid), " ".join(c.expanded_cmdline), controller.pid)) controllers.append(controller) return ControllerManager(controllers) def instantiate_topology(): '''construct a clean topology object from topology_class and topology_params''' # If you want to shoot yourself in the foot, feel free :) topology = eval( "%s(%s)" % (self._topology_class.__name__, self._topology_params)) return topology # Instantiate the pieces needed for Simulation's constructor io_master = initialize_io_loop() sync_connection_manager = STSSyncConnectionManager( io_master, sync_callback) controller_manager = boot_controllers(sync_connection_manager) topology = instantiate_topology() patch_panel = self._patch_panel_class(topology.switches, topology.hosts, topology.get_connected_port) god_scheduler = GodScheduler() dataplane_trace = None if self._dataplane_trace_path is not None: dataplane_trace = Trace(self._dataplane_trace_path, topology) simulation = Simulation(topology, controller_manager, dataplane_trace, god_scheduler, io_master, patch_panel, sync_callback) self.current_simulation = simulation # Connect to controllers # TODO(cs): somewhat hacky that we do this after instantiating Simulation def create_connection(controller_info, switch): ''' Connect switches to controllers. May raise a TimeoutError ''' # TODO(cs): move this into a ConnectionFactory class socket = connect_socket_with_backoff(controller_info.address, controller_info.port, max_backoff_seconds=8) # Set non-blocking socket.setblocking(0) io_worker = DeferredIOWorker( io_master.create_worker_for_socket(socket)) return DeferredOFConnection(io_worker, switch.dpid, god_scheduler) if self.switch_init_sleep_seconds: simulation.set_pass_through() # TODO(cs): this should block until all switches have finished # initializing with the controller topology.connect_to_controllers(self.controller_configs, create_connection=create_connection) if self.switch_init_sleep_seconds: log.debug("Waiting %f seconds for switch initialization" % self.switch_init_sleep_seconds) time.sleep(self.switch_init_sleep_seconds) # Now unset pass-through mode if self.switch_init_sleep_seconds: simulation.unset_pass_through() return simulation
def bootstrap(self, sync_callback=None, boot_controllers=default_boot_controllers): '''Return a simulation object encapsulating the state of the system in its initial starting point: - boots controllers - connects switches to controllers May be invoked multiple times! ''' if sync_callback is None: sync_callback = ReplaySyncCallback(None) def initialize_io_loop(): ''' boot the IOLoop (needed for the controllers) ''' _io_master = IOMaster() # monkey patch time.sleep for all our friends _io_master.monkey_time_sleep() # tell sts.console to use our io_master msg.set_io_master(_io_master) return _io_master def wire_controller_patch_panel(controller_manager, create_io_worker): patch_panel = None if not self.interpose_on_controllers: return patch_panel # N.B. includes local controllers in network namespaces or VMs. remote_controllers = controller_manager.remote_controllers if len(remote_controllers) != 0: patch_panel = self.controller_patch_panel_class(create_io_worker) for c in remote_controllers: patch_panel.register_controller(c.cid, c.guest_eth_addr, c.host_device) return patch_panel def instantiate_topology(create_io_worker): '''construct a clean topology object from topology_class and topology_params''' log.info("Creating topology...") # If you want to shoot yourself in the foot, feel free :) comma = "" if self._topology_params == "" else "," topology = eval("%s(%s%screate_io_worker=create_io_worker)" % (self._topology_class.__name__, self._topology_params, comma)) return topology def monkeypatch_select(multiplex_sockets, controller_manager): mux_select = None demuxers = [] if multiplex_sockets: log.debug("Monkeypatching STS select") revert_select_monkeypatch() # Monkey patch select to use our deterministic version mux_select = MultiplexedSelect() for c in controller_manager.controller_configs: # Connect the true sockets true_socket = connect_socket_with_backoff(address=c.address, port=c.port) true_socket.setblocking(0) io_worker = mux_select.create_worker_for_socket(true_socket) demux = STSSocketDemultiplexer(io_worker, c.server_info) demuxers.append(demux) # Monkey patch select.select select._old_select = select.select select.select = mux_select.select return (mux_select, demuxers) # Instantiate the pieces needed for Simulation's constructor revert_select_monkeypatch() io_master = initialize_io_loop() sync_connection_manager = STSSyncConnectionManager(io_master, sync_callback) controller_manager = boot_controllers(self.controller_configs, self.snapshot_service, sync_connection_manager, multiplex_sockets=self.multiplex_sockets) controller_patch_panel = wire_controller_patch_panel(controller_manager, io_master.create_worker_for_socket) topology = instantiate_topology(io_master.create_worker_for_socket) patch_panel = self._patch_panel_class(topology.switches, topology.hosts, topology.get_connected_port) openflow_buffer = OpenFlowBuffer() dataplane_trace = None if self._dataplane_trace_path is not None: dataplane_trace = Trace(self._dataplane_trace_path, topology) if self._violation_persistence_threshold is not None: violation_tracker = ViolationTracker(self._violation_persistence_threshold) else: violation_tracker = ViolationTracker() # Connect up MuxSelect if enabled (mux_select, demuxers) = monkeypatch_select(self.multiplex_sockets, controller_manager) simulation = Simulation(topology, controller_manager, dataplane_trace, openflow_buffer, io_master, controller_patch_panel, patch_panel, sync_callback, mux_select, demuxers, violation_tracker, self._kill_controllers_on_exit) if self.ignore_interposition: simulation.set_pass_through() self.current_simulation = simulation return simulation