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))
