def test_can_show_status_as_paid(self):
frontend = Frontend(Frontend.TYPE_FRONTEND_INVISIBLE)
frontend.start()
frontend.show_paid()
active_div = frontend.get_active_div()
frontend.shutdown()
self.assertEqual(active_div, "#paid")
def test_can_show_invoice(self):
frontend = Frontend(Frontend.TYPE_FRONTEND_INVISIBLE)
frontend.start()
frontend.show_invoice('bitcoin:1asdf')
active_div = frontend.get_active_div()
frontend.shutdown()
self.assertEqual(active_div, "#invoice")
def test_can_switch_to_paid_and_back_to_idle(self):
frontend = Frontend(Frontend.TYPE_FRONTEND_INVISIBLE)
frontend.start()
frontend.show_paid()
active_div = frontend.get_active_div()
frontend.show_idle()
active_div2 = frontend.get_active_div()
frontend.shutdown()
self.assertEqual(active_div, "#paid")
self.assertEqual(active_div2, "#idle")
class GraphApp:
@staticmethod
def win_attributes(the_window):
the_window.update_idletasks()
w = the_window.winfo_screenwidth()
h = the_window.winfo_screenheight()
size = (410, 400)
x = w / 2 - size[0] / 2
y = h / 2 - size[1] / 2
the_window.geometry("%dx%d+%d+%d" % (size + (x, y)))
the_window.attributes('-topmost', 1)
the_window.attributes('-topmost', 0)
the_window.wm_title("Project 1: The Grapher")
the_window.config(cursor='cross', background='#197278')
the_window.overrideredirect(1)
def __init__(self):
self.win = Tk()
self.win.protocol("WM_DELETE_WINDOW", self.win.destroy)
self.win_attributes(self.win)
self.web_server = object()
self.server_is_running = False
for button_type in ['upload', 'readme', 'quit']:
ButtonCreator(self.win, button_type, self.fxn_mapper(button_type))
self.win.mainloop()
def run_front_end(self, graph_data):
self.web_server = Frontend(graph_data)
self.web_server.start()
self.server_is_running = True
def upload(self):
filename = askopenfilename()
if filename:
graph_data = file_import(filename)
self.run_front_end(graph_data)
def quit(self):
self.win.destroy()
if self.server_is_running:
self.web_server.stop()
def open_readme(self):
webbrowser.open("file://" + os.path.abspath("readme.txt"))
def fxn_mapper(self, typ):
if typ == 'upload':
return self.upload
if typ == 'readme':
return self.open_readme
if typ == 'quit':
return self.quit
def test_user_can_initiate_new_invoice(self):
q = Queue()
def request_received():
q.put(None)
frontend = Frontend(Frontend.TYPE_FRONTEND_INVISIBLE,
invoice_request_callback=request_received)
frontend.start()
frontend.exercise_javascript_bridge()
q.get()
frontend.shutdown()
class MainResource(object):
def __init__(self):
self._logger = logging.getLogger('gunicorn.error')
self._frontend = Frontend()
self._frontend.start()
def on_get(self, req, resp):
self._logger.debug(
f'Handling {req.method} request {req.url} with params {req.params}'
)
try:
top_phrases = self._frontend.top_phrases_for_prefix(
req.params['prefix'])
response_body = json.dumps({
"status": "success",
"data": {
"top_phrases": top_phrases
}
})
resp.status = falcon.HTTP_200
resp.body = response_body
except BackendNodesNotAvailable as err:
response_body = json.dumps({
"status":
"error",
"message":
"No backend nodes available to complete the request"
})
resp.status = falcon.HTTP_500
resp.body = response_body
except Exception as e:
self._logger.error('An error occurred when processing the request',
exc_info=e)
response_body = json.dumps({
"status":
"error",
"message":
"An error occurred when processing the request"
})
resp.status = falcon.HTTP_500
resp.body = response_body
from exploiter import Exploiter
from webservice import WebService
from submitter import Submitter
from frontend import Frontend
import signal
import logging.config
if __name__ == '__main__':
logging.config.fileConfig(fname='log.conf')
logger_exploiter = logging.getLogger('exploiter')
logger_submitter = logging.getLogger('submitter')
logger_webservice = logging.getLogger('webservice')
WebService.start(logger_webservice)
Exploiter.start(logger_exploiter)
Submitter.start(logger_submitter)
Frontend.start()
signal.pause()
import renderer
import theme_handler
from curses_handler import CursesHandler
from frontend import Frontend
__tag__ = 'main'
if __name__ == '__main__':
locale.setlocale(locale.LC_ALL, '')
code = locale.getpreferredencoding()
error = None
c_handler = CursesHandler()
try:
if c_handler.curses_init():
renderer.init_color()
theme_handler.init_theme()
renderer.draw_loading_screen()
frontend = Frontend(c_handler)
frontend.start()
input_handler.start_input_handler(frontend)
except BaseException as e:
error = e
finally:
c_handler.curses_deinit()
if error:
# print type(error)
print error.message
def test_can_be_started_and_stopped_and_defaults_to_idle(self):
frontend = Frontend(Frontend.TYPE_FRONTEND_INVISIBLE)
frontend.start()
active_div = frontend.get_active_div()
frontend.shutdown()
self.assertEqual(active_div, "#idle")
# parser.add_argument("--dns", help="dns address and port")
# parser.add_argument("--listen_ip", help="ip address to listen")
# parser.add_argument("--listen_port", help="port to listen")
parser.add_argument("--upstream", help="upstream addr and port")
parser.add_argument("--bind", help="bind addr and port")
parser.add_argument("--name", help="app name. can be 'dns', 'frontend', 'proxy', 'counter")
parser.add_argument("--dnslb", help="use client load balancer", action='store_true', default=False)
def channel_options(args):
return [('grpc.lb_policy_name', 'round_robin')] if args.dnslb else None
if __name__ == '__main__':
args = parser.parse_args()
name = args.name
if name == 'frontend':
f = Frontend(name, args.upstream, args.bind, channel_options(args))
f.start()
elif name == 'proxy':
p = Proxy(name, args.upstream, args.bind, channel_options(args))
p.start()
elif name == 'counter':
run_server(args.bind)
else:
raise RuntimeError("Invalid App name!!")
def init_backend(cmds):
program = Frontend()
return program.start(cmds)
def run_frontend_server(proxy_port, frontend_port):
f = Frontend('frontend', f'localhost:{proxy_port}',
f'localhost:{frontend_port}', dnslb)
f.start()
