def main():
host = ''
port = 7777
server = None
board = PyMata3(5)
shoulder = Actuator(board, 9)
arm = Actuator(board, 10)
elbow = Actuator(board, 11, min_angle=-90, max_angle=90, offset=-90)
global mech_arm
mech_arm = MechanicalArm(
[shoulder, arm, elbow],
Fabrik(
joint_positions=[Vector2(0, 0), Vector2(53, 0), Vector2(100, 0)],
link_lengths=[53, 47],
tolerance=0.1
)
)
sleep(2)
while server is None:
try:
server = TCPServer((host, port), ConnectionHandler)
except OSError:
port += 1
continue
print("Serving on: {}".format(port))
server.serve_forever()
server.server_close()
def server_close(self):
"""
Closes the socket server and any associated resources.
"""
self.log.debug("Closing the socket server connection.")
TCPServer.server_close(self)
self.queue_manager.close()
self.topic_manager.close()
if hasattr(self.authenticator, 'close'):
self.authenticator.close()
self.shutdown()
class HTTPServerThread(threading.Thread):
def __init__(self):
super().__init__()
self.host = 'localhost'
self.httpd = TCPServer((self.host, 0), HTTPRequestHandler)
self.port = self.httpd.socket.getsockname()[1]
self.url = 'http://%s:%d' % (self.host, self.port)
def run(self):
self.httpd.serve_forever()
def shutdown(self):
self.httpd.shutdown()
self.httpd.server_close()
def main(*args):
""" Function invoked when the server is run as a script"""
import argparse
desc = "nframe server"
parser = argparse.ArgumentParser(description=desc)
parser.add_argument("-i", "--ip", default="0.0.0.0",
help="IP address of server")
parser.add_argument("-p", "--port", default=7645,
help="Port of server")
parser.add_argument("--import", action="store",
default=False, dest="import_file",
help="Import data before starting server")
parser.add_argument("--export", action="store",
default=False, dest="export_file",
help="Export data then exits")
parser.add_argument("--force-unlock", action="store_true", default=False,
help="Remove lock file without discretion",
dest="force_unlock")
parser.add_argument("--exit", action="store_true", default=False,
help="perform action then exit (don't run server)",
dest="exit")
pargs = parser.parse_args(args) if args else parser.parse_args()
if pargs.force_unlock:
Lock().force_release()
if pargs.import_file:
with Data(timeout=5) as import_data:
import_data.import_data(pargs.import_file)
if pargs.export_file:
with Data(timeout=5) as export_data:
export_data.export_data(pargs.export_file)
return
server = TCPServer((pargs.ip, pargs.port), Server)
if pargs.exit:
return pargs
with Lock(timeout=5):
try:
server.serve_forever()
except (SystemError, SystemExit, KeyboardInterrupt):
server.server_close()
file_size = os.path.getsize('/home/pi/motion/lastsnap.jpg')
print(file_size)
self.request.sendall(bytes(str(file_size), 'utf8'))
with open('/home/pi/motion/lastsnap.jpg', 'rb')as fin:
r = fin.read(block_size)
while r:
self.request.send(r)
r = fin.read(block_size)
elif oper:
my_car.exec_operation(int(oper))
else:
pass
except TimeoutError:
print("a client quited")
break
if __name__ == '__main__':
server = None
my_car = None
try:
cf = read_config()
my_car = Car(cf)
cam = CamMotion(cf['cam_server_ip']['control_port'])
cam.check()
server = TCPServer(('', 8001), ResponseHandler)
server.serve_forever()
except KeyboardInterrupt:
my_car.disconnect()
server.server_close()
def server_close(self):
TCPServer.server_close(self)
class MyTCPHandler(SRH):
def handle(self):
addr_1 = ' ' + str(self.client_address[0])
addr_2 = ' ' + str(self.client_address[1])
print('Connected client:' + addr_1 + addr_2)
self.data = self.rfile.readline().strip()
if not self.data:
print(addr_1 + ':' + addr_2 + ' - disconnected')
self.wfile.write(self.data)
# :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
if __name__ == "__main__":
if len(sys.argv) < 3 or type(int(sys.argv[2])).__name__ != 'int':
print('Usage: python ex_serv.py hostname port')
sys.exit()
else:
ADDR = (sys.argv[1], int(sys.argv[2]))
server = TCP(ADDR, MyTCPHandler)
try:
print('Waiting for connection...')
server.serve_forever()
except KeyboardInterrupt:
print('\nServer stoped.')
server.server_close()
class BrowserRobot(object):
''' bring up a server with a custom robot
Defaults
==========
pause_time: time to wait between browser commands
port: a random choice between 8000 and 9999
'''
def __init__(self, **kwargs):
self.Handler = BrowserServer
if "port" in kwargs:
self.port = kwargs['port']
else:
self.port = choice(range(8000,9999))
print('Selected port is %s' %self.port)
self.httpd = TCPServer(("", self.port), self.Handler)
self.server = Thread(target=self.httpd.serve_forever)
self.server.setDaemon(True)
self.server.start()
self.started = True
self.pause_time = 100
self.browser = None
self.headless = False
self.display = None
self.driver = "Chrome"
if "browser" in kwargs:
self.driver = kwargs['browser']
def get_and_wait(self, url, sleep_seconds=0):
'''a helper function to get a browser and wait a randomly
selected number of seconds between 0 and 2'''
self.get_browser()
wait_time = choice([0, 0.25, 0.5, 0.75, 1, 1.5, 2])
self.browser.implicitly_wait(wait_time) # if error, will wait 3 seconds and retry
self.browser.set_page_load_timeout(10)
self.get_page(url)
sleep(sleep_seconds)
def get_browser(self, name=None):
'''get_browser
return a browser if it hasn't been initialized yet
'''
if name is None:
name=self.driver
log_path = "%s-driver.log" % name.lower()
if self.browser is None:
options = self.get_options()
if name.lower() == "Firefox":
self.browser = webdriver.Firefox(service_log_path=log_path)
else:
self.browser = webdriver.Chrome(service_log_path=log_path,
options=options)
return self.browser
def get_options(self, width=1200, height=800):
'''return options for headless, no-sandbox, and custom width/height
'''
options = webdriver.ChromeOptions()
options.add_argument("headless")
options.add_argument("no-sandbox")
options.add_argument("window-size=%sx%s" %(width, height))
return options
def get_page(self, url, name='Chrome'):
'''get_page
open a particular url, checking for Timeout
'''
if self.browser is None:
self.browser = self.get_browser(name)
try:
return self.browser.get(url)
except TimeoutException:
print('Browser request timeout. Are you connected to the internet?')
self.browser.close()
sys.exit(1)
def stop(self):
'''close any running browser or server, and shut down the robot
'''
if self.browser is not None:
self.browser.close()
self.httpd.server_close()
if self.display is not None:
self.display.close()
def run_javascript(browser,code):
if self.browser is not None:
return browser.execute_script(code)
def shutdown(self):
TCPServer.shutdown(self)
TCPServer.server_close(self)
self.trd.join()
del self.trd
class BrowserRobot(object):
''' bring up a server with a custom robot
Defaults
==========
pause_time: time to wait between browser commands
port: a random choice between 8000 and 9999
'''
def __init__(self, **kwargs):
self.Handler = BrowserServer
if "port" in kwargs:
self.port = kwargs['port']
else:
self.port = choice(range(8000,9999))
print('Selected port is %s' %self.port)
self.httpd = TCPServer(("", self.port), self.Handler)
self.server = Thread(target=self.httpd.serve_forever)
self.server.setDaemon(True)
self.server.start()
self.started = True
self.pause_time = 100
self.browser = None
self.headless = False
self.display = None
self.driver = "Chrome"
if "browser" in kwargs:
self.driver = kwargs['browser']
def validate(self, folder):
'''validate is the first entrypoint function for running an experiment
or survey robot. It ensures that the content is valid,
and then calls _validate (should be defined in subclass)'''
validator = ExperimentValidator()
valid = validator.validate(folder)
if valid is True:
# IF missing favicon, add
self._check_favicon(folder)
valid = self._validate(folder)
print("[done] stopping web server...")
self.httpd.server_close()
else:
print('%s is not valid, skipping robot testing.' %folder)
def check_errors(self):
if self.browser is not None:
# Look at log from last call
log = self.browser.get_log("browser")
for log_entry in log:
assert_equal(log_entry["level"] in ["WARNING","INFO"],True)
def get_and_wait(self, url, sleep_seconds=0):
'''a helper function to get a browser and wait a randomly
selected number of seconds between 0 and 2'''
self.get_browser()
wait_time = choice([0, 0.25, 0.5, 0.75, 1, 1.5, 2])
self.browser.implicitly_wait(wait_time) # if error, will wait 3 seconds and retry
self.browser.set_page_load_timeout(10)
self.get_page(url)
sleep(sleep_seconds)
def get_browser(self, name=None):
'''get_browser
return a browser if it hasn't been initialized yet
'''
if name is None:
name=self.driver
log_path = "%s-driver.log" % name.lower()
if self.browser is None:
options = self.get_options()
if name.lower() == "Firefox":
self.browser = webdriver.Firefox(service_log_path=log_path)
else:
self.browser = webdriver.Chrome(service_log_path=log_path,
options=options)
return self.browser
def get_options(self, width=1200, height=800):
'''return options for headless, no-sandbox, and custom width/height
'''
options = webdriver.ChromeOptions()
options.add_argument("headless")
options.add_argument("no-sandbox")
options.add_argument("window-size=%sx%s" %(width, height))
return options
def get_page(self, url, name='Chrome'):
'''get_page
open a particular url, checking for Timeout
'''
if self.browser is None:
self.browser = self.get_browser(name)
try:
return self.browser.get(url)
except TimeoutException:
print('Browser request timeout. Are you connected to the internet?')
self.browser.close()
sys.exit(1)
def stop(self):
'''close any running browser or server, and shut down the robot
'''
if self.browser is not None:
self.browser.close()
self.httpd.server_close()
if self.display is not None:
self.display.close()
def run_javascript(browser,code):
if self.browser is not None:
return browser.execute_script(code)
content = json.dumps(data).encode("utf-8")
return content.strip()
def do_HEAD(self):
self._headers()
def do_GET(self):
self._headers()
self.wfile.write(self._content())
def do_POST(self):
length = int(self.headers.get("Content-Length"))
data = self.rfile.read(length)
self._headers()
self.wfile.write(self._content(data.decode("utf-8")).encode("utf-8"))
if __name__ == "__main__":
HOST, PORT = "localhost", 8001
try:
httpd = TCPServer((HOST, PORT), RequestHandler)
print("Serving HTTP at port", PORT)
httpd.serve_forever()
except KeyboardInterrupt:
print("Shutting down HTTP server")
httpd.shutdown()
httpd.server_close()
print()
class PannellumTester(object):
"""Bring up a server with a testing robot.
"""
def __init__(self, port=None, browser="Chrome", headless=False):
self.handler = PannellumServer
if port:
self.port = port
else:
self.port = choice(range(8000, 9999))
print("Selected port is %s" % self.port)
self.httpd = TCPServer(("", self.port), self.handler)
self.server = Thread(target=self.httpd.serve_forever)
self.server.setDaemon(True)
self.server.start()
self.started = True
self.pause_time = 100
self.browser = None
self.headless = headless
self.display = None
self.driver = browser
def take_screenshot(self, element_id, filename=None):
"""Take a screenshot of an element with a given ID.
"""
element = self.browser.find_element(By.ID, element_id)
img = Image.open(io.BytesIO(element.screenshot_as_png)).convert("RGB")
if filename is not None:
img.save(filename)
return img
def equal_images(self, reference, comparator, name, threshold=5):
"""Compare two images, both loaded with PIL, based on pixel differences."""
diff = np.mean(np.array(ImageChops.difference(reference, comparator)))
print("%s difference: %s" % (name, diff))
if diff >= threshold:
comparator.save("tests/" + name + "-comparison.png")
raise ValueError("Screenshot difference is above threshold!")
def run_tests(self, create_ref=False):
"""Run tests for Pannellum."""
print("Loading page...")
self.get_page("http://localhost:%s/tests/tests.html" % self.port)
print("Running tests...")
time.sleep(5)
assert self.browser.execute_script("return viewer.isLoaded()") is True
# Check equirectangular
assert self.browser.execute_script(
"return viewer.getScene() == 'equirectangular'")
if create_ref:
self.take_screenshot("panorama", "tests/equirectangular.png")
subprocess.call([
"optipng", "-o7", "-strip", "all", "tests/equirectangular.png"
])
else:
reference = Image.open("tests/equirectangular.png")
comparator = self.take_screenshot("panorama")
self.equal_images(reference, comparator, "equirectangular")
print("PASS: equirectangular")
# Check movement
self.browser.execute_script(
"viewer.setPitch(30).setYaw(-20).setHfov(90)")
time.sleep(2)
assert self.browser.execute_script(
"return viewer.getPitch() == 30 && viewer.getYaw() == -20 && viewer.getHfov() == 90"
)
self.browser.find_element(By.CLASS_NAME, "pnlm-zoom-in").click()
time.sleep(1)
assert self.browser.execute_script("return viewer.getHfov() == 85")
self.browser.find_element(By.CLASS_NAME, "pnlm-zoom-out").click()
time.sleep(1)
assert self.browser.execute_script("return viewer.getHfov() == 90")
print("PASS: movement")
# Check look at
self.browser.execute_script("viewer.lookAt(-10, 90, 100)")
time.sleep(2)
assert self.browser.execute_script(
"return viewer.getPitch() == -10 && viewer.getYaw() == 90 && viewer.getHfov() == 100"
)
print("PASS: look at")
# Check cube
self.browser.execute_script("viewer.loadScene('cube')")
time.sleep(5)
assert self.browser.execute_script(
"return viewer.getScene() == 'cube'")
if create_ref:
self.take_screenshot("panorama", "tests/cube.png")
subprocess.call(
["optipng", "-o7", "-strip", "all", "tests/cube.png"])
else:
reference = Image.open("tests/cube.png")
comparator = self.take_screenshot("panorama")
self.equal_images(reference, comparator, "cube")
# Check to make sure hotspots are below controls
self.browser.execute_script("viewer.setPitch(-35)")
self.browser.execute_script("viewer.setYaw(32)")
time.sleep(2)
action = ActionChains(self.browser)
elem = self.browser.find_element(By.CLASS_NAME, "pnlm-zoom-in")
action.move_to_element(elem).move_by_offset(1, 1).click().perform()
assert self.browser.execute_script("return viewer.getHfov() == 95")
print("PASS: hot spots below UI")
# Check hot spot
self.browser.find_element(By.CLASS_NAME, "pnlm-scene").click()
time.sleep(5)
assert self.browser.execute_script(
"return viewer.getScene() == 'multires'")
print("PASS: hot spot")
# Check multires
if create_ref:
self.take_screenshot("panorama", "tests/multires.png")
subprocess.call(
["optipng", "-o7", "-strip", "all", "tests/multires.png"])
else:
reference = Image.open("tests/multires.png")
comparator = self.take_screenshot("panorama")
self.equal_images(reference, comparator, "multires")
# Check hotspot dragging - move from (20, 20) to (0, 0)
action = ActionChains(self.browser)
action.drag_and_drop(
self.browser.find_element(By.CLASS_NAME, "pnlm-hotspot"),
self.browser.find_element(
By.CLASS_NAME,
"pnlm-render-container"), # drops in the middle of the element
)
action.perform()
time.sleep(1)
assert self.browser.execute_script(
"var hs = viewer.getConfig().hotSpots[0]; return Math.abs(hs.yaw) < 0.001 && Math.abs(hs.pitch) < 0.001"
)
print("PASS: hot spot dragging")
self.httpd.server_close()
def get_browser(self, name=None):
"""Return a browser if it hasn't been initialized yet.
"""
if name is None:
name = self.driver
log_path = "tests/%s-driver.log" % name.lower()
if self.browser is None:
if name.lower() == "firefox":
fp = webdriver.FirefoxProfile()
fp.set_preference("layout.css.devPixelsPerPx", "1.0")
self.browser = webdriver.Firefox(service_log_path=log_path,
firefox_profile=fp)
self.browser.set_window_size(800, 600)
else:
options = webdriver.ChromeOptions()
options.add_argument("headless")
options.add_argument("no-sandbox")
options.add_argument("window-size=800x600")
self.browser = webdriver.Chrome(service_log_path=log_path,
options=options)
return self.browser
def get_page(self, url):
"""Open a particular URL, checking for timeout.
"""
if self.browser is None:
self.browser = self.get_browser()
try:
return self.browser.get(url)
except TimeoutException:
print(
"Browser request timeout. Are you connected to the internet?")
self.browser.close()
sys.exit(1)
def stop(self):
"""Close any running browser or server and shut down the robot.
"""
if self.browser is not None:
self.browser.close()
self.httpd.server_close()
if self.display is not None:
self.display.close()
class ExpfactoryRobot(object):
''' bring up a server with a custom robot
Defaults
==========
pause_time: time to wait between browser commands
port: a random choice between 8000 and 9999
'''
def __init__(self, **kwargs):
self.Handler = ExpfactoryServer
if "port" in kwargs:
self.port = kwargs['port']
else:
self.port = choice(range(8000,9999))
bot.debug('Selected port is %s' %self.port)
self.httpd = TCPServer(("", self.port), self.Handler)
self.server = Thread(target=self.httpd.serve_forever)
self.server.setDaemon(True)
self.server.start()
self.started = True
self.pause_time = 100
self.browser = None
self.headless = False
self.display = None
self.driver = "Chrome"
if "browser" in kwargs:
self.driver = kwargs['browser']
def validate(self, folder):
'''validate is the first entrypoint function for running an experiment
or survey robot. It ensures that the content is valid,
and then calls _validate (should be defined in subclass)'''
validator = ExperimentValidator()
valid = validator.validate(folder)
if valid is True:
# IF missing favicon, add
self._check_favicon(folder)
valid = self._validate(folder)
bot.log("[done] stopping web server...")
self.httpd.server_close()
else:
bot.warning('%s is not valid, skipping robot testing.' %folder)
def _validate(self, folder=None):
'''_validate is required to be implemented in the subclass
'''
raise NotImplementedError
def _check_favicon(self, folder):
'''add the expfactory favicon if the user doesn't already have one.
'''
here = "%s/favicon.ico" %os.path.abspath(os.path.dirname(__file__))
there = '%s/favicon.ico' %folder
if not os.path.exists(there):
shutil.copyfile(here, there)
def check_errors(self):
if self.browser is not None:
# Look at log from last call
log = self.browser.get_log("browser")
for log_entry in log:
assert_equal(log_entry["level"] in ["WARNING","INFO"],True)
def get_browser(self,name=None):
'''get_browser
return a browser if it hasn't been initialized yet
'''
if name is None:
name=self.driver
service_log_path = "%s-driver.log" %name.lower()
if self.browser is None:
if name.lower() == "Firefox":
self.browser = webdriver.Firefox(service_log_path=service_log_path)
else:
self.browser = webdriver.Chrome(service_log_path=service_log_path)
return self.browser
def get_page(self, url, name='Chrome'):
'''get_page
open a particular url, checking for Timeout
'''
if self.browser is None:
self.browser = self.get_browser(name)
try:
return self.browser.get(url)
except TimeoutException:
bot.error('Browser request timeout. Are you connected to the internet?')
self.browser.close()
sys.exit(1)
def stop(self):
'''close any running browser or server, and shut down the robot
'''
if self.browser is not None:
self.browser.close()
self.httpd.server_close()
if self.display is not None:
self.display.close()
# Run javascript and get output
def run_javascript(browser,code):
if self.browser is not None:
return browser.execute_script(code)
def shutdown(self):
TCPServer.shutdown(self)
TCPServer.server_close(self)
self.trd.join()
del self.trd
def server_close(self):
if self.time_updater:
self.time_updater.stop()
TCPServer.server_close(self)
self.aquaero.close()
account = parse_qs(parsedResult.query)['account']
try:
with open(fileToDownload) as file:
invitation = load(file)
link = invitation['link-invitation']
logger.info(
'New link invitation for account {}'.format(account))
logger.info('Generated nonce {}'.format(link['nonce']))
logger.info('Signed invitation with signature {}'.format(
invitation['sig']))
logger.info('Invitation downloaded successful')
except IOError as ex:
logger.info('IOError occurred {}'.format(ex))
return super().do_GET()
# There is some issue with enclosing below statement inside `with`
httpd = TCPServer(('', PORT), BulldogServer)
print('serving at port', PORT)
try:
httpd.serve_forever()
except KeyboardInterrupt:
httpd.server_close()
print('Goodbye! Stopped bulldog server.')
# sample command to run
# $ python -m bulldogServer.py
# switch to another directory where we need to download invitation file
# if we fire wget command in same sample directory, then we would have
# two invitations with name as -1 or -2 appended
