def maintenanceMenu(self, data, sendMessage):
mmenu = maintenanceMenuManager()
result = mmenu.data
sendMessage(result)
return
def installMaintenanceMenu():
data = request.json
file = data.get('file', None)
if file:
mmenu = maintenanceMenuManager()
if mmenu.installFile(file):
return jsonify()
else:
return make_response('Unable to Install', 500)
return make_response('Invalid Request', 400)
def maintenanceMenuCreate():
if not "file" in request.files.keys():
return make_response("No file included", 400)
file = request.files["file"]
mmenu = maintenanceMenuManager()
r = mmenu.checkMenuFile(file)
if 'error' in r:
return make_response(r['error'], 500)
else:
return jsonify(r)
def deleteMaintenanceMenu():
data = request.json
tId = data.get('id', None)
if tId:
mmenu = maintenanceMenuManager()
r = mmenu.removeMenu(tId)
if 'error' in r:
error = r['error']
if error == 'not_found':
return make_response('Not Found', 404)
else:
return make_response(error, 500)
else:
return jsonify(r)
return make_response('Invalid Request', 400)
class Server():
def __init__(self,
configfile=None,
basedir=None,
host="0.0.0.0",
port=5000,
debug=False,
allowRoot=False,
logConf=None):
self._configfile = configfile
self._basedir = basedir
self._host = host
self._port = port
self._debug = debug
self._allowRoot = allowRoot
self._logConf = logConf
self._ioLoop = None
def stop(self):
if self._ioLoop:
self._ioLoop.stop()
self._ioLoop = None
def run(self):
if not self._allowRoot:
self._checkForRoot()
global userManager
global eventManager
global loginManager
global debug
global softwareManager
global discoveryManager
global VERSION
global UI_API_KEY
from tornado.wsgi import WSGIContainer
from tornado.httpserver import HTTPServer
from tornado.ioloop import IOLoop
from tornado.web import Application, FallbackHandler
from astroprint.printfiles.watchdogs import UploadCleanupWatchdogHandler
debug = self._debug
# first initialize the settings singleton and make sure it uses given configfile and basedir if available
self._initSettings(self._configfile, self._basedir)
s = settings()
if not s.getBoolean(['api', 'regenerate']) and s.getString(
['api', 'key']):
UI_API_KEY = s.getString(['api', 'key'])
else:
UI_API_KEY = ''.join('%02X' % ord(z) for z in uuid.uuid4().bytes)
# then initialize logging
self._initLogging(self._debug, self._logConf)
logger = logging.getLogger(__name__)
if s.getBoolean(["accessControl", "enabled"]):
userManagerName = s.get(["accessControl", "userManager"])
try:
clazz = util.getClass(userManagerName)
userManager = clazz()
except AttributeError, e:
logger.exception(
"Could not instantiate user manager %s, will run with accessControl disabled!"
% userManagerName)
softwareManager = swManager()
VERSION = softwareManager.versionString
logger.info("Starting AstroBox (%s) - Commit (%s)" %
(VERSION, softwareManager.commit))
from astroprint.migration import migrateSettings
migrateSettings()
manufacturerPkgManager()
ppm = printerProfileManager()
pluginManager().loadPlugins()
eventManager = events.eventManager()
printer = printerManager(ppm.data['driver'])
#Start some of the managers here to make sure there are no thread collisions
from astroprint.network.manager import networkManager
from astroprint.boxrouter import boxrouterManager
networkManager()
boxrouterManager()
# configure timelapse
#octoprint.timelapse.configureTimelapse()
app.wsgi_app = ReverseProxied(app.wsgi_app)
app.secret_key = boxrouterManager().boxId
loginManager = LoginManager()
loginManager.session_protection = "strong"
loginManager.user_callback = load_user
if userManager is None:
loginManager.anonymous_user = users.DummyUser
principals.identity_loaders.appendleft(users.dummy_identity_loader)
loginManager.init_app(app)
# setup command triggers
events.CommandTrigger(printer)
if self._debug:
events.DebugEventListener()
if networkManager().isOnline():
softwareManager.checkForcedUpdate()
if self._host is None:
self._host = s.get(["server", "host"])
if self._port is None:
self._port = s.getInt(["server", "port"])
app.debug = self._debug
from octoprint.server.api import api
app.register_blueprint(api, url_prefix="/api")
boxrouterManager(
) # Makes sure the singleton is created here. It doesn't need to be stored
self._router = SockJSRouter(self._createSocketConnection, "/sockjs")
discoveryManager = DiscoveryManager()
externalDriveManager()
def access_validation_factory(validator):
"""
Creates an access validation wrapper using the supplied validator.
:param validator: the access validator to use inside the validation wrapper
:return: an access validation wrapper taking a request as parameter and performing the request validation
"""
def f(request):
"""
Creates a custom wsgi and Flask request context in order to be able to process user information
stored in the current session.
:param request: The Tornado request for which to create the environment and context
"""
wsgi_environ = tornado.wsgi.WSGIContainer.environ(request)
with app.request_context(wsgi_environ):
app.session_interface.open_session(app, request)
loginManager.reload_user()
validator(request)
return f
self._tornado_app = Application(self._router.urls + [
#(r"/downloads/timelapse/([^/]*\.mpg)", LargeResponseHandler, {"path": s.getBaseFolder("timelapse"), "as_attachment": True}),
(r"/downloads/files/local/([^/]*\.(gco|gcode))",
LargeResponseHandler, {
"path": s.getBaseFolder("uploads"),
"as_attachment": True
}),
(r"/downloads/logs/([^/]*)", LargeResponseHandler, {
"path": s.getBaseFolder("logs"),
"as_attachment": True,
"access_validation": access_validation_factory(admin_validator)
}),
#(r"/downloads/camera/current", UrlForwardHandler, {"url": s.get(["webcam", "snapshot"]), "as_attachment": True, "access_validation": access_validation_factory(user_validator)}),
(r".*", FallbackHandler, {
"fallback": WSGIContainer(app.wsgi_app)
})
])
self._server = HTTPServer(self._tornado_app,
max_buffer_size=1048576 *
s.getInt(['server', 'maxUploadSize']))
self._server.listen(self._port, address=self._host)
logger.info("Listening on http://%s:%d" % (self._host, self._port))
eventManager.fire(events.Events.STARTUP)
if s.getBoolean(["serial", "autoconnect"]):
t = threading.Thread(target=printer.connect)
t.daemon = True
t.start()
# start up watchdogs
observer = Observer()
observer.daemon = True
observer.schedule(UploadCleanupWatchdogHandler(),
s.getBaseFolder("uploads"))
observer.start()
#Load additional Tasks
additionalTasksManager()
#Load maintenance menu
maintenanceMenuManager()
try:
self._ioLoop = IOLoop.instance()
self._ioLoop.start()
except SystemExit:
pass
except:
logger.fatal(
"Please report this including the stacktrace below in AstroPrint's bugtracker. Thanks!"
)
logger.exception("Stacktrace follows:")
finally:
observer.stop()
self.cleanup()
logger.info('Cleanup complete')
observer.join(1.0)
logger.info('Good Bye!')
def index():
s = settings()
loggedUsername = s.get(["cloudSlicer", "loggedUser"])
publicKey = None
if loggedUsername:
user = userManager.findUser(loggedUsername)
if user:
publicKey = user.publicKey
if (s.getBoolean(["server", "firstRun"])):
swm = swManager()
# we need to get the user to sign into their AstroPrint account
return render_template("setup.jinja2",
debug=debug,
uiApiKey=UI_API_KEY,
version=VERSION,
commit=swm.commit,
astroboxName=networkManager().getHostname(),
checkSoftware=swm.shouldCheckForNew,
settings=s,
wsToken=create_ws_token(publicKey),
mfDefinition=manufacturerPkgManager())
elif softwareManager.status != 'idle' or softwareManager.forceUpdateInfo:
return render_template(
"updating.jinja2",
uiApiKey=UI_API_KEY,
forceUpdateInfo=softwareManager.forceUpdateInfo,
releases=softwareManager.updatingReleases
or [softwareManager.forceUpdateInfo['id']],
lastCompletionPercent=softwareManager.lastCompletionPercent,
lastMessage=softwareManager.lastMessage,
astroboxName=networkManager().getHostname(),
wsToken=create_ws_token(publicKey),
status=softwareManager.status,
mfDefinition=manufacturerPkgManager())
elif loggedUsername and (current_user is None
or not current_user.is_authenticated
or current_user.get_id() != loggedUsername):
if current_user.is_authenticated:
logout_user()
return render_template("locked.jinja2",
username=loggedUsername,
uiApiKey=UI_API_KEY,
astroboxName=networkManager().getHostname(),
mfDefinition=manufacturerPkgManager())
else:
pm = printerManager()
nm = networkManager()
swm = swManager()
cm = cameraManager()
mmm = maintenanceMenuManager()
paused = pm.isPaused()
printing = pm.isPrinting()
online = nm.isOnline()
return render_template(
"app.jinja2",
user_email=loggedUsername,
show_bad_shutdown=swm.wasBadShutdown and not swm.badShutdownShown,
version=VERSION,
commit=swm.commit,
printing=printing,
paused=paused,
online=online,
print_capture=cm.timelapseInfo if printing or paused else None,
printer_profile=printerProfileManager().data,
uiApiKey=UI_API_KEY,
astroboxName=nm.getHostname(),
checkSoftware=swm.shouldCheckForNew,
serialLogActive=s.getBoolean(['serial', 'log']),
additionalTasks=True,
maintenanceMenu=True,
cameraManager=cm.name,
wsToken=create_ws_token(publicKey),
mfDefinition=manufacturerPkgManager())
def maintenanceMenu():
mmenu = maintenanceMenuManager()
result = mmenu.data
return jsonify(result)
