def __init__(self, run_name, name): self.__run_name = run_name self.__name = name my_ip = subprocess.check_output(["hostname", "-I"]).decode().strip() self.__logger = Logger(group=run_name, log_name=name, label="TattleTail " + my_ip) self.__benchmarker = Benchmarker(name)
def __init__(self, request): self.request = request self.guard = None self.current_user = None self.requested_page = None self.bench = Benchmarker() self.output = ''
def __init__(self, run_name, name, server_host=None, server_port=None): my_ip = subprocess.check_output(["hostname", "-I"]).decode().strip() if name is None: name = my_ip self.__logger = Logger( group=run_name, log_name=name, label="VideoClient" ) if server_host is None: raise Exception("Need to specify server host") self.__server_host = server_host if server_port is None: server_port = self.__default_server_port self.__server_port = server_port self.__benchmarker = Benchmarker(name)
def __init__(self, run_name=None, name=None, server_host=None, server_port=None): self.__run_name = run_name self.__name = name my_ip = subprocess.check_output(["hostname", "-I"]).decode().strip() self.__logger = Logger(group=run_name, log_name=name, label="FileClient " + my_ip) if server_host is None: raise Exception("Please provide a hostname to connect to") self.__server_host = server_host if server_port is None: server_port = self.__default_server_port self.__server_port = server_port self.__benchmarker = Benchmarker(name)
def iterrows_function(df): for index, row in df.iterrows(): pass def itertuples_function(df): for row in df.itertuples(): pass def df_values(df): for row in df.values: pass params = { "df_generator": 'pd.DataFrame(np.random.randint(1, df_size, (df_size, 4)), columns=list("ABCD"))', "functions_to_evaluate": [df_values, itertuples_function, iterrows_function], "title": "Benchmark for iterating over all rows", "user_df_size_powers": [2, 3, 4, 5, 6], "user_loop_size_powers": [2, 2, 1, 1, 1], } benchmark = Benchmarker(**params) benchmark.benchmark_all() benchmark.print_results() benchmark.plot_results()
class TattleTail: def __init__(self, run_name, name): self.__run_name = run_name self.__name = name my_ip = subprocess.check_output(["hostname", "-I"]).decode().strip() self.__logger = Logger(group=run_name, log_name=name, label="TattleTail " + my_ip) self.__benchmarker = Benchmarker(name) def __str__(self): s = "" s += "TattleTail Instance" # s += "; MAC = " + self.__host.MAC() # s += "; IP = " + self.__host.IP() return s def __del__(self): log = self.__logger.get() log.info("Oh noes! They're deleting meeeeeeee !") log.info(self.__benchmarker) def run(self): log = self.__logger.get() log.info("Running!") self.snoop_a_loop() log.info("Done running") def snoop_a_loop(self): # Lil help from various sites. Pasting the most recent # https://code-examples.net/en/q/5c94cd # Create a promiscuous socket log = self.__logger.get() log.info("Creating promiscuous socket") # sock = socket.socket(socket.AF_PACKET, socket.SOCK_DGRAM) sock = socket.socket(socket.AF_NETLINK, socket.SOCK_DGRAM) # Attempt to receive any data, indefinitely log.info("Begin snooping!") self.__benchmarker.start() while True: received, sender = sock.recv(1048576) self.__benchmarker.increased_bytes_received(len(received)) log.debug("Received " + str(len(received)) + " bytes from" + str(sender) + "; Total = " + str(self.__benchmarker.get_bytes_received()))
class Spiff(object): def __init__(self, request): self.request = request self.guard = None self.current_user = None self.requested_page = None self.bench = Benchmarker() self.output = '' #self.db.echo = 1 def get_guard(self): if self.guard is None: db = create_engine(config.cfg.get('database', 'dbn')) self.guard = SpiffGuard.DB(db) return self.guard def get_env(self, name): #FIXME: Probably shouldn't be here. return self.request.get_env(name) def set_requested_page(self, page): self.requested_page = page def get_requested_page(self): return self.requested_page def get_requested_uri(self, **kwargs): return self.request.get_current_url(**kwargs).get_string() def _get_permission_hash(self, user): """ This function returns a string that identifies all permissions of the given user on the current group. FIXME: this sounds like a hack, and should not be here anyway. """ page = self.get_requested_page() string = page.get_attribute('private') and 'p' or 'np' if user is None: return string acls = self.guard.get_permission_list_with_inheritance(actor = user, resource = page) for acl in acls: string += str(acl) return sha.new(string).hexdigest() def login(self, username, password): """ Attempts to login the user with the given name/password. """ if username is None or password is None: return None user = self.guard.get_resource(handle = username, type = User) if user is None: return None if user.is_inactive(): return None if not user.has_password(password): return None permission_key = self._get_permission_hash(user) self.request.get_session().data().set('user_id', user.get_id()) self.request.get_session().data().set('permission_key', permission_key) self.current_user = user return user def logout(self): self.request.get_session().destroy() self.current_user = None def get_current_user(self): if self.current_user is not None: return self.current_user session = self.request.get_session() if session is None: return None sid = session.get_id() assert sid is not None user_id = session.data().get('user_id') if user_id is None: return None user = self.guard.get_resource(id = user_id, type = User) if user is None: return None self.current_user = user return self.current_user def current_user_may(self, action_handle, page = None): if page is None: page = self.get_requested_page() # If the page is publicly available there's no need to ask the DB. private = page.get_attribute('private') or False if action_handle == 'view' and not private: return True # Get the currently logged in user. user = self.get_current_user() if user is None: return False # Ask the DB whether permission shall be granted. action = self.guard.get_action(type = PageAction, handle = action_handle) if self.guard.has_permission(user, action, page): return True return False def _render_text_template(self, filename, **kwargs): loader = TemplateLoader(['web']) tmpl = loader.load(filename, None, TextTemplate) self.output += tmpl.generate(web_dir = '/web', current_user = self.get_current_user(), txt = gettext, **kwargs).render('text') def _render_xhtml_template(self, filename, **kwargs): loader = TemplateLoader(['web']) tmpl = loader.load(filename, None, MarkupTemplate) self.output += tmpl.generate(web_dir = '/web', uri = self.get_requested_uri, request_uri = self.get_requested_uri, current_user = self.get_current_user(), txt = gettext, **kwargs).render('xhtml') def _render_head(self): self._render_text_template('header.tmpl', styles = []) if self.current_user_may('edit'): self._render_xhtml_template('admin_header.tmpl', may_edit_page = True) self._render_xhtml_template('header2.tmpl') def _render_footer(self): self._render_text_template('footer.tmpl', version = 'Spiff %s' % config.__version__, adapter = self.request.get_name()) self.bench.snapshot('render_footer', 'Footer rendered in %ss.') self.bench.snapshot_total('total', 'Total rendering time is %ss.') self.request.write(self.output) self.request.write(self.bench.get_html()) def _check_configured(self): if os.path.exists(config.cfg_file): return True self.request.write('Configuration file (%s) not found.' % config.cfg_file) self.request.write(' Please configure Spiff before accessing this') self.request.write(' site.<br/>') self.request.write('The INSTALL file shipped with the Spiff') self.request.write(' installation contains instructions on how this') self.request.write(' is done.') return False def _check_installer_deleted(self): if config.cfg.has_option('debug', 'ignore_installer_directory'): return True if not os.path.exists(config.installer_dir): return True self.request.write('Out of security reasons, please delete the') self.request.write(' installer directory (%s).' % config.installer_dir) return False def refer_to(self, url): self.request.set_status(301) self.request.add_header('Location', url.get_string()) def run(self): if not self._check_configured(): return if not self._check_installer_deleted(): return # Set up the session and database adapters. self.request.start_session() page_db = PageDB(self.get_guard()) user_db = UserDB(self.get_guard()) cache = CacheDB(self, self.get_guard()) self.bench.snapshot('set_up', 'Set-up time is %ss.') # Can not open some pages by addressing them directly. page_handle = self.request.get_data().get_str('page') if page_db.is_system_page_handle(page_handle): self.request.set_status(403) self.request.write('%s is a system page.' % repr(page_handle)) return # Find the current page using the given cgi variables. # If the specific site is not found, attempt to find a parent that # handles content recursively. page = page_db.get_responsible_page(page_handle) self.bench.snapshot('page_find', 'Looked up the page in %ss.') # If we still have no page, give 404. if page is None: self.request.set_status(404) self.request.write('Default page not found.') return self.set_requested_page(page) self.bench.snapshot('page_open', 'Opened the page in %ss.') # If the output of ALL extensions is cached (combined), there is no need # to redraw the page, including headers and footer. # Note that the cache only returns pages corresponding to the permissions # of the current user, so this is safe. if not self.request.has_post_data(): output = cache.get_page() self.bench.snapshot('cache_check', 'Spent %ss checking the cache.') if output is not None: self.request.write(output) self._render_footer() return self.bench.snapshot('cache_check', 'Spent %ss checking the cache.') # Set up the plugin manager (Integrator). Note that the constructor # of PackageManager also associates the api with a reference to the # PackageManager instance. api = ExtensionApi(self, guard = self.get_guard(), page_db = page_db, cache = cache, request = self.request) pm = PackageManager(self.get_guard(), api, package = SpiffPackage) pm.set_package_dir(config.package_dir) self.bench.snapshot('package_load', 'Package manager loaded in %ss.') # Ending up here the entire page was not cached. # Make sure that the caller has permission to retrieve this page. if page.get_attribute('private') and not self.current_user_may('view'): url = self.request.get_url(page = 'admin/login', refer_to = self.get_requested_uri()) return self.refer_to(url) self.bench.snapshot('permission_check', 'Permission checked in %ss.') # Render the HTML headers. self._render_head() self.bench.snapshot('render_header', 'Headers rendered in %ss.') # Render the layout. This also invokes the plugins. self.output += page.get_output(api) self.bench.snapshot('render_plugins', 'Plugins rendered in %ss.') # Cache the page (if it is cacheable). if page.is_cacheable() and len(self.request.get_headers()) == 0: cache.add_page(self.output) self.bench.snapshot('cache_add', 'Added to cache in %ss.') # Yippie. self.request.write(self.output) self._render_footer()
def __init__(self, main): if not self.gui: benchmark = Benchmarker() benchmark.run() main.destroy() return self.image = Image.open("Resources/lena.png") self.photo = ImageTk.PhotoImage(self.image) self.canvas_width = 1000 self.canvas_height = 650 self.canvas = Tk.Canvas(main, width=self.canvas_width, height=self.canvas_height) self.image_on_canvas = self.canvas.create_image(0, 0, anchor=Tk.NW, image=self.photo) # mouse click on canvas event self.canvas.bind("<Button 1>", self.getorigin) # self.map = np.random.randn(10, 10) self.visibility_map = None self.path = None self.path_history = [] self.algorithm = None self.sensor_range = 10 self.steps_per_cycle = self.sensor_range // 2 self.menu = Tk.Menu(main) self.menu.add_command(label="Read file", command=self.ask_for_file) self.menu.add_command(label="Write to file", command=self.save_map) self.menu.add_command(label="Custom Map", command=self.empty_map) self.toolbar = Tk.Frame(main, relief=RAISED) # bd=1, self.slider_bar = Tk.Frame(main, relief=RAISED) self.metrics_bar = Tk.Frame(main, relief=RAISED) self.run_menu = Tk.Menu(self.menu, tearoff=0) self.run_menu.add_command(label="D*", command=self.run_algorithm_dstar) self.run_menu.add_command(label="RRT", command=self.run_algorithm_rrt) self.menu.add_cascade(label="Run Menu", menu=self.run_menu) # self.menu.add_command(label="Run current", command=self.run_algorithm) self.menu.add_command(label="Go to destination", command=self.go_to_destination) self.step_button = Tk.Button(self.toolbar, text="Step", relief=FLAT, command=self.step) self.step_button.pack(side=LEFT, padx=2, pady=2) self.clear_path_button = Tk.Button(self.toolbar, text="Clear path", relief=FLAT, command=self.clear_path) self.clear_path_button.pack(side=LEFT, padx=2, pady=2) self.change_start_position_button = Tk.Button(self.toolbar, text="Change start", relief=FLAT, command=self.change_start_position) self.change_start_position_button.pack(side=LEFT, padx=2, pady=2) self.change_goal_position_button = Tk.Button(self.toolbar, text="Change goal", relief=FLAT, command=self.change_goal_position) self.change_goal_position_button.pack(side=LEFT, padx=2, pady=2) self.use_full_map = Tk.IntVar(value=1) self.is_full_map_box = Tk.Checkbutton(self.toolbar, text="Full map", variable=self.use_full_map, command=self.update_color_map) self.is_full_map_box.pack(side=LEFT, padx=2, pady=2) self.use_dynamic_mode = Tk.IntVar(value=0) self.use_dynamic_mode_box = Tk.Checkbutton(self.toolbar, text="Dynamic mode", variable=self.use_dynamic_mode) self.use_dynamic_mode_box.pack(side=LEFT, padx=2, pady=2) self.sensor_range_button = Tk.Button(self.toolbar, text="Sensor range", relief=FLAT, command=self.change_sensor_range) self.sensor_range_label_var = Tk.StringVar() self.sensor_range_label_var.set(self.sensor_range) self.sensor_range_button.pack(side=LEFT, padx=2, pady=2) self.sensor_range_label = Tk.Label(self.toolbar, textvariable=self.sensor_range_label_var) self.sensor_range_label.pack(side=LEFT, padx=2, pady=2) self.heuristic = 20 self.heuristic_label = Tk.Label(self.slider_bar, text="Heuristic value :") self.heuristic_label.pack(side=LEFT, padx=2, pady=2) self.heuristic_slider = Tk.Scale(self.slider_bar, from_=0, to=120, orient=Tk.HORIZONTAL, command=self.broadcast_heuristic_value) self.heuristic_slider.set(self.heuristic) self.heuristic_slider.pack(side=LEFT, padx=2, pady=2) self.simulation_speed = 10 self.simulation_speed_label = Tk.Label(self.slider_bar, text="Simulation speed :") self.simulation_speed_label.pack(side=LEFT, padx=2, pady=2) self.simulation_speed_slider = Tk.Scale(self.slider_bar, from_=1, to=300, orient=Tk.HORIZONTAL, command=self.broadcast_simulation_speed) self.simulation_speed_slider.set(self.simulation_speed) self.simulation_speed_slider.pack(side=LEFT, padx=2, pady=2) self.path_length_label = Tk.Label(self.metrics_bar, text="Path length :") self.path_length_var = Tk.StringVar() self.path_length_var.set("{:.2f}".format(0)) self.path_length_label_value = Tk.Label(self.metrics_bar, textvariable=self.path_length_var) self.path_length_label.pack(side=LEFT, padx=2, pady=2) self.path_length_label_value.pack(side=LEFT, padx=2, pady=2) self.execution_time_label = Tk.Label(self.metrics_bar, text="Execution time :") self.execution_time_var = Tk.StringVar() self.execution_time_var.set(0.0) self.execution_time_label_value = Tk.Label(self.metrics_bar, textvariable=self.execution_time_var) self.execution_time_label.pack(side=LEFT, padx=2, pady=2) self.execution_time_label_value.pack(side=LEFT, padx=2, pady=2) self.path_profile_width = self.canvas_width self.path_profile_height = 120 self.path_profile = Tk.Canvas(main, bg="white", width=self.path_profile_width, height=self.path_profile_height) self.toolbar.pack(side=TOP, fill=X) self.slider_bar.pack(side=TOP, fill=X) self.metrics_bar.pack(side=TOP, fill=X) self.canvas.pack(side=TOP) self.path_profile.pack(side=TOP) self.map = np.loadtxt("my_file2.csv", delimiter=',') self.init_map() self.reinit_canvas() self.start = (1, 1) self.end = (self.map_width - 2, self.map_height - 3) self.current_position = self.start self.is_simulation_running = False self.algorithm = DStar(self, self.map, self.start, self.end) main.config(menu=self.menu) print(self.canvas.winfo_width(), self.canvas.winfo_screenwidth(), self.canvas.winfo_vrootwidth())
class VideoClient: # Sorry not sorry __default_server_port = 8013 # __server_host = None __server_port = None # __socket = None __listener_thread = None __beg_string = "Gimme!".encode() def __init__(self, run_name, name, server_host=None, server_port=None): my_ip = subprocess.check_output(["hostname", "-I"]).decode().strip() if name is None: name = my_ip self.__logger = Logger( group=run_name, log_name=name, label="VideoClient" ) if server_host is None: raise Exception("Need to specify server host") self.__server_host = server_host if server_port is None: server_port = self.__default_server_port self.__server_port = server_port self.__benchmarker = Benchmarker(name) # self.__logger.set_verbose(True) def __del__(self): if threading.current_thread == threading.main_thread() and self.__listener_thread: self.__listener_thread.join() self.__listener_thread = None def run(self): log = self.__logger.get() log.info("Running ...") self.init_socket() self.receive_from_server() log.info("Finished running") def init_socket(self): self.__socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # self.__socket.bind((self.__server_host, self.__server_port)) def init_data_receiver(self): self.__listener_thread = threading.Thread(target=self.data_receiver) self.__listener_thread.start() def data_receiver(self): log = self.__logger.get() while self.__benchmarker.is_running(): log.debug("Data receiver iteration") if self.socket_has_data(): # log.info("Receiving ... ") received, sender = self.__socket.recvfrom(1048576) self.__benchmarker.increased_bytes_received(len(received)) log.info( "Received " + str(len(received)) + " bytes from" + str(sender) + "; Total = " + str(self.__benchmarker.get_bytes_received()) ) else: time.sleep(.0001) def kickstart_server(self): log = self.__logger.get() log.info("Begin kickstart_server") # Send 1024 of pleas for data for i in range(1024): log.info("Asking server to start sending data") self.ask_server_for_data() log.info("End kickstart_server") def receive_from_server(self): log = self.__logger.get() log.info("Begin wait_for_server_finished") self.kickstart_server() self.__benchmarker.start() self.init_data_receiver() # Must happen after benchmark starts no_data_count = 0 while no_data_count < 15: # log.info("Iteration of loop: wait_for_server_finished") if self.socket_has_data(): no_data_count = 0 log.info("Got some data from server; Total %s megabytes", self.__benchmarker.get_megabytes_received()) else: no_data_count += 1 log.info("wait_for_server_finished() - No incoming data; Count is: " + str(no_data_count)) time.sleep(1) self.__benchmarker.stop() self.__benchmarker.adjust_end_time(no_data_count) # For the 10 second timeout log.info(self.__benchmarker) log.info("End leech loops") def ask_server_for_data(self): log = self.__logger.get() log.info("Asking server for data: " + str(self.__server_host) + "::" + str(self.__server_port)) self.__socket.sendto(self.__beg_string, (self.__server_host, self.__server_port)) # log.info("Done asking server for data") def socket_has_data(self): # log = self.__logger.get() # log.info("Checking socket for data") if self.__socket: read_sockets, write_sockets, error_sockets = select.select([self.__socket], [], [], 0) for sock in read_sockets: if sock == self.__socket: # log.debug("Socket has data") return True # log.info("Socket has no data") return False def stop_listening(self): self.__logger.get().info("Making sure we're not listening") if self.__socket is not None: self.__logger.get().info("We were listening; Shutting down") self.__socket.close() self.__socket = None
class FileClient: # Sorry not sorry __default_server_port = 8012 # __default_request_timeout = 2 __default_request_retries = 100 # __downloads_count = 1 def __init__(self, run_name=None, name=None, server_host=None, server_port=None): self.__run_name = run_name self.__name = name my_ip = subprocess.check_output(["hostname", "-I"]).decode().strip() self.__logger = Logger(group=run_name, log_name=name, label="FileClient " + my_ip) if server_host is None: raise Exception("Please provide a hostname to connect to") self.__server_host = server_host if server_port is None: server_port = self.__default_server_port self.__server_port = server_port self.__benchmarker = Benchmarker(name) def run(self): log = self.__logger.get() log.info("Running!") self.__benchmarker.start() for i in range(self.__downloads_count): self.do_one_download(i + 1) self.__benchmarker.stop() log.info(self.__benchmarker) log.info(self.__benchmarker) log.info("Done!") def do_one_download(self, run_number): log = self.__logger.get() log.info("do_one_download() - Run #" + str(run_number)) url = "http://" + self.__server_host + ":" + str( self.__server_port) + "/random-data.dat" success = False any_fails = False r = None for j in range(self.__default_request_retries): if any_fails: log.info("Trying again, I guess; Attempt #" + str(j + 1) + " ...") try: log.info("Trying to download url: " + url) r = requests.get(url, timeout=self.__default_request_timeout) log.info("Successfully downloaded url") success = True break except (requests.exceptions.ConnectionError, requests.exceptions.ReadTimeout, TypeError): log.error("Error trying to download url: " + url) any_fails = True if success is True: response_data = r.content else: log.info("Failed to download url: " + url) response_data = "" self.__benchmarker.increased_bytes_received(len(response_data))