def getFolderContents(self, folder, sendResponse):
if folder == '/':
sendResponse( { 'folderContents': externalDriveManager().getRemovableDrives() })
else:
folderSearchStr = "%s/*" % folder
sendResponse( { 'folderContents': externalDriveManager().getFolderContents(folderSearchStr.replace('//','/')) })
def getFolderContents(self, folder, sendResponse):
if folder == '/':
sendResponse( { 'folderContents': externalDriveManager().getRemovableDrives() })
else:
folderSearchStr = "%s/*" % folder
sendResponse( { 'folderContents': externalDriveManager().getFolderContents(folderSearchStr.replace('//','/')) })
def getFolderContents(self, folder, sendResponse):
if folder == '/':
sendResponse({
'folderContents':
externalDriveManager().getRemovableDrives()
})
else:
sendResponse({
'folderContents':
externalDriveManager().getFolderContents("%s/*" % folder)
})
def cleanup(self):
global discoveryManager
pluginManager().shutdown()
downloadManager().shutdown()
printerManager().rampdown()
discoveryManager.shutdown()
discoveryManager = None
boxrouterManager().shutdown()
cameraManager().shutdown()
externalDriveManager().shutdown()
from astroprint.network.manager import networkManagerShutdown
networkManagerShutdown()
def copyFileToLocal(self, data, sendResponse):
copiedFilename = externalDriveManager().copyFileToLocal(data['origin'],data['destination'],data['observerId'])
if copiedFilename:
sendResponse({'target_filename': copiedFilename})
else:
sendResponse({'error': 'copy print file to local folder failed' },True)
def copyFileToLocal(self, data, sendResponse):
copiedFilename = externalDriveManager().copyFileToLocal(data['origin'],data['destination'],data['observerId'])
if copiedFilename:
sendResponse({'target_filename': copiedFilename})
else:
sendResponse({'error': 'copy print file to local folder failed' },True)
def eject(self, data, sendResponse):
ejection = externalDriveManager().eject(data['drive'])
if ejection['result']:
sendResponse({'success':'no error'})
else:
sendResponse(ejection['error'],True)
def eject(self, data, sendResponse):
ejection = externalDriveManager().eject(data['drive'])
if ejection['result']:
sendResponse({'success':'no error'})
else:
sendResponse(ejection['error'],True)
def copyFileToLocal(self, data, sendResponse):
if externalDriveManager().copyFileToLocal(data['origin'],
data['destination'],
data['observerId']):
sendResponse({'success': 'no_error'})
else:
sendResponse({'error': 'copy print file to local folder failed'},
True)
def folderContents():
location = request.args.get('location')
externalDriveMgr = externalDriveManager()
if location == '/':
return jsonify(externalDriveMgr.getRemovableDrives())
else:
return jsonify(externalDriveMgr.getFolderContents("%s/*" % location))
def copyFileToLocal():
externalDriveMgr = externalDriveManager()
return jsonify({
'filename':
externalDriveMgr.copyFileToLocal(
request.values.get('file'),
externalDriveMgr.getBaseFolder('uploads'),
request.values.get('observerId'))
})
def folderContents():
location = request.args.get('location')
externalDriveMgr = externalDriveManager()
if location == '/':
return jsonify(externalDriveMgr.getRemovableDrives())
else:
return jsonify(externalDriveMgr.getFolderContents("%s/*" % location))
def getFolderExploration(self, folder, sendResponse):
try:
sendResponse({
'folderExp':
externalDriveManager().getFolderContents(folder)
})
except Exception as e:
self._logger.error("exploration folders can not be obtained",
exc_info=True)
sendResponse('no_folders_obtained', True)
def localFileExists(filename):
return jsonify(
{'response': externalDriveManager().localFileExists(filename)})
def eject():
return jsonify(externalDriveManager().eject(request.values.get('drive')))
def getRemovableDrives():
return jsonify(
[d["name"] for d in externalDriveManager().getRemovableDrives()])
def getFileBrowsingExtensions():
return jsonify(externalDriveManager().getFileBrowsingExtensions())
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()
pluginManager().loadPlugins()
eventManager = events.eventManager()
printer = printerManager(printerProfileManager().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"]):
(port, baudrate) = s.get(["serial", "port"
]), s.getInt(["serial", "baudrate"])
connectionOptions = printer.getConnectionOptions()
if port in connectionOptions["ports"]:
t = threading.Thread(target=printer.connect,
args=(port, baudrate))
t.daemon = True
t.start()
# start up watchdogs
observer = Observer()
observer.daemon = True
observer.schedule(UploadCleanupWatchdogHandler(),
s.getBaseFolder("uploads"))
observer.start()
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 localFileExists(self, data, sendResponse):
if not externalDriveManager().localFileExists(data['filename']):
sendResponse({'success': 'no_error'})
else:
sendResponse({'error': 'local file already exists' },True)
def getFileBrowsingExtensions(self, sendResponse):
sendResponse({ 'fileBrowsingExtensions' : externalDriveManager().getFileBrowsingExtensions() })
def localFileExists(self, data, sendResponse):
if not externalDriveManager().localFileExists(data['filename']):
sendResponse({'success': 'no_error'})
else:
sendResponse({'error': 'local file already exists' },True)
def localFileExists(filename):
return jsonify({'response': externalDriveManager().localFileExists(filename)})
def getBaseFolder(self, key, sendResponse):
sendResponse({ 'baseFolder' : externalDriveManager().getBaseFolder(key) })
def getBaseFolder(self, key, sendResponse):
sendResponse({ 'baseFolder' : externalDriveManager().getBaseFolder(key) })
def eject():
return jsonify(externalDriveManager().eject(request.values.get('drive')))
def getRemovableDrives(): return jsonify([d["name"] for d in externalDriveManager().getRemovableDrives()])
def getFileBrowsingExtensions(self, sendResponse):
sendResponse({ 'fileBrowsingExtensions' : externalDriveManager().getFileBrowsingExtensions() })
def copyFileToLocal():
externalDriveMgr = externalDriveManager()
return jsonify({'filename': externalDriveMgr.copyFileToLocal(request.values.get('file'),externalDriveMgr.getBaseFolder('uploads'),request.values.get('observerId'))})
def getBaseFolder(self, key, sendResponse):
sendResponse({
'baseFolder':
externalDriveManager()._cleanFileLocation(
settings().getBaseFolder(key))
})
def getFileBrowsingExtensions(): return jsonify(externalDriveManager().getFileBrowsingExtensions())
