def __init__(self):
self.host = config.get_host()
self.port = config.get_port()
self.username = config.get_username()
self.password = config.get_password(self.host, self.port, self.username)
self.remember = True
if all((self.host, self.port, self.username, self.password)):
if connect(self.host, self.port, self.username, self.password):
sys.exit()
self.construct()
if self.host is not None:
self.host_entry.set_text(self.host)
if self.port is not None:
self.port_entry.set_text(str(self.port))
if self.username is not None:
self.username_entry.set_text(self.username)
if self.password is not None:
self.password_entry.set_text(self.password)
self.remember_checkbox.set_active(self.remember)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.setWindowIcon(QIcon(os.path.join(ProgramPath.program_path(), "brickv-icon.png")))
signal.signal(signal.SIGINT, self.exit_brickv)
signal.signal(signal.SIGTERM, self.exit_brickv)
self.async_thread = async_start_thread(self)
self.setWindowTitle("Brick Viewer " + config.BRICKV_VERSION)
self.tree_view_model_labels = ['Name', 'UID', 'FW Version']
self.tree_view_model = QStandardItemModel()
self.tree_view.setModel(self.tree_view_model)
self.set_tree_view_defaults()
# Remove dummy tab
self.tab_widget.removeTab(1)
self.last_tab = 0
self.name = '<unknown>'
self.uid = '<unknown>'
self.version = (0, 0, 0)
self.disconnect_times = []
self.qtcb_enumerate.connect(self.cb_enumerate)
self.qtcb_connected.connect(self.cb_connected)
self.qtcb_disconnected.connect(self.cb_disconnected)
self.ipcon = IPConnection()
self.ipcon.register_callback(IPConnection.CALLBACK_ENUMERATE,
self.qtcb_enumerate.emit)
self.ipcon.register_callback(IPConnection.CALLBACK_CONNECTED,
self.qtcb_connected.emit)
self.ipcon.register_callback(IPConnection.CALLBACK_DISCONNECTED,
self.qtcb_disconnected.emit)
self.flashing_window = None
self.advanced_window = None
self.delayed_refresh_updates_timer = QTimer()
self.delayed_refresh_updates_timer.timeout.connect(self.delayed_refresh_updates)
self.delayed_refresh_updates_timer.setInterval(500)
self.reset_view()
self.button_advanced.setDisabled(True)
self.tab_widget.currentChanged.connect(self.tab_changed)
self.connect.pressed.connect(self.connect_pressed)
self.button_flashing.pressed.connect(self.flashing_pressed)
self.button_advanced.pressed.connect(self.advanced_pressed)
self.plugin_manager = PluginManager()
self.combo_host.addItem(config.get_host())
self.combo_host.addItems(config.get_host_history(HOST_HISTORY_SIZE - 1))
self.spinbox_port.setValue(config.get_port())
self.last_host = self.combo_host.currentText()
self.last_port = self.spinbox_port.value()
ContentStore(mongo_url=mongo_url,
mongo_db=mongo_db,
collection_name="content"),
}
# create flask app
app = Flask(__name__)
# register endpoints
static_api.register_endpoints(app)
# register endpoints for authentication and user management
register_user_endpoints(app, stores["user"], stores["user_tokens"])
# register endpoints for data management and retrieval
register_data_endpoints(
app,
stores["data"],
{
"manage_permission":
"data", # permission required to manage content
"login_check_function":
check_login_state, # this function ties the authentication module into this one
})
# register endpoints for content management
register_content_endpoints(
app, stores["content"], {
"manage_permission": "content",
"login_check_function": check_login_state,
})
# start flask app
app.run(host='0.0.0.0', port=get_port(), debug=is_debug())
import eventlet
from eventlet.green import BaseHTTPServer as HTTPServer
import config as config_parser
import os
HOSTNAME=config_parser.get_hostname()
PORT=config_parser.get_port()
number=0
class ServerHandler(HTTPServer.BaseHTTPRequestHandler):
def do_HEAD(s):
s.send_response(200)
s.send_header("Content-type","text/html")
s.end_headers()
def do_GET(s):
try:
to_write=open(os.getcwd()+s.path,'r').read()
s.send_response(200)
except:
s.send_response(404)
to_write="Page not found"
s.send_header("Content-type","text/html")
s.end_headers()
s.wfile.write(to_write)
if __name__=="__main__":
server=HTTPServer.HTTPServer
httpd=server((HOSTNAME,PORT),ServerHandler)
print "Server started at",HOSTNAME,PORT
try:
httpd.serve_forever()
except KeyboardInterrupt:
httpd.server_close()
import logging
import os
import random
import sys
import time
from threading import Timer
import tornado.log
from flask import Flask, render_template, jsonify, request
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.wsgi import WSGIContainer
import config
port = config.get_port()
secret = config.get_secret()
wait_timeout = config.get_wait_timeout()
base_path = config.get_base_path()
cert_file = config.get_cert_file()
key_file = config.get_key_file()
app = Flask(__name__, static_folder='', static_url_path='')
app.jinja_env.variable_start_string = '[['
app.jinja_env.variable_end_string = ']]'
app.secret_key = os.urandom(24)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 6307200
cur_version = config.get_current_version()
__statuses = {}
logger.info("==========================================")
# create flask app
app = Flask(__name__)
# load from config, if required
auth_token = get_auth_token()
# declare API handler for incoming log messages
@app.route("/api/log", methods=["POST"])
def log_message():
if auth_token is not None and auth_token != extract_auth_token():
logger.warn("Incoming request with invalid authentication")
abort(401)
message = JSON(request.get_json())
msg = message.msg
if "trace" in message and message.trace is not None and isinstance(message.trace, list):
trace = "\n".join(message.trace)
msg = f"{msg}\n{trace}"
lr = LogRecord(message.name, message.levelno, message.pathname, message.lineno,
msg, message.args, None)
logger.handle(lr)
return jsonify({"status": True})
# start flask app
app.run(host='0.0.0.0', port=get_port(), debug=False)
