def manufacturerPackage(self, data ,sendMessage): manPackage = manufacturerPkgManager() result = {} if data: if "parameter" in data: if data['parameter'] == "strings": lang = "en" if "language" in data: lang = data['language'] # Get strings from passed keys if "keys" in data: keys = data["keys"] for k in keys: result[k]= manPackage.getString(k,lang) # Get all the strings if no keys passed else: strings = manPackage.data.get("strings") for s in strings: result[s]= manPackage.getString(s,lang) else: result = manPackage.data.get(data["parameter"]) else: result = manPackage.data sendMessage(result)
def _constructSrcChain(self): self.__videoSourceElement = Gst.ElementFactory.make('v4l2src', 'video_source') self.__videoSourceElement.set_property("device", self._device) self.__videoSourceCaps = Gst.ElementFactory.make("capsfilter", "caps_filter") self.__videoSourceCaps.set_property("caps", Gst.Caps.from_string(self._getVideoSourceCaps())) #Add Elements to the pipeline self._bin.add(self.__videoSourceElement) self._bin.add(self.__videoSourceCaps) self.__videoSourceElement.link(self.__videoSourceCaps) width, height = self._size #check if we need to rotate the video if self._rotation == 0: lastLink = self.__videoSourceCaps else: if self._rotation in [1,3]: #dimentions are flipped height, width = self._size self.__videoflipElement = Gst.ElementFactory.make('videoflip', 'videoflip') self.__videoflipElement.set_property("method", self._rotation) self._bin.add(self.__videoflipElement) self.__videoSourceCaps.link(self.__videoflipElement) lastLink = self.__videoflipElement mfWatermark = manufacturerPkgManager().video_watermark if mfWatermark is False: #There is no watermark return lastLink else: # We need to setup a watermark logoHeight = round(height * self.LOGO_HEIGHT_PERCENT) logoWidth = round(logoHeight / self.LOGO_ASPECT_RATIO) # ASTROPRINT'S LOGO FROM DOWN RIGHT CORNER self.__videoLogoElement = Gst.ElementFactory.make('gdkpixbufoverlay', 'logo_overlay') if mfWatermark is None: # Use AstroPrint's default self.__videoLogoElement.set_property('location', '/AstroBox/src/astroprint/static/img/astroprint_logo.png') else: self.__videoLogoElement.set_property('location', '/AstroBox/src/astroprint/static/img/variant/%s' % mfWatermark) self.__videoLogoElement.set_property('overlay-width', logoWidth) self.__videoLogoElement.set_property('overlay-height', logoHeight) self.__videoLogoElement.set_property('offset-x', width - ( logoWidth + 10 ) ) self.__videoLogoElement.set_property('offset-y', height - ( logoHeight + 5 ) ) self._bin.add(self.__videoLogoElement) lastLink.link(self.__videoLogoElement) return self.__videoLogoElement
def savedBaudrate(self): mf = manufacturerPkgManager() baudrate = None if mf.variant['printer_profile_edit']: baudrate = settings().getInt(["serial", "baudrate"]) if baudrate is None: baudrate = mf.printerConnection['baudrate'] return baudrate
def savedPort(self): mf = manufacturerPkgManager() port = None if mf.variant['printer_profile_edit']: port = settings().get(["serial", "port"]) if port is None: port = mf.printerConnection['port'] return port
def savedBaudrate(self): mf = manufacturerPkgManager() baudrate = None if mf.variant['printer_profile_edit']: baudrate = settings().getInt(["serial", "baudrate"]) if baudrate is None: baudrate = mf.printerConnection['baudrate'] return baudrate
def savedPort(self): mf = manufacturerPkgManager() port = None if mf.variant['printer_profile_edit']: port = settings().get(["serial", "port"]) if port is None: port = mf.printerConnection['port'] return port
def __init__(self): self._eventManager = eventManager() self.logger = logging.getLogger(__name__) self.mfDefinition = manufacturerPkgManager() self.softwareMgr = softwareManager() # upnp/ssdp self._ssdp_monitor_active = False self._ssdp_monitor_thread = None self._ssdp_notify_timeout = 10 self._ssdp_last_notify = 0 self._ssdp_last_unregister = 0 # SSDP if networkManager().isOnline(): self._ssdp_register() self._eventManager.subscribe(Events.NETWORK_STATUS, self._onNetworkStateChanged)
def __init__(self): self._eventManager = eventManager() self.logger = logging.getLogger(__name__) self.mfDefinition = manufacturerPkgManager() self.softwareMgr = softwareManager() # upnp/ssdp self._ssdp_monitor_active = False self._ssdp_monitor_thread = None self._ssdp_notify_timeout = 10 self._ssdp_last_notify = 0 self._ssdp_last_unregister = 0 # SSDP if networkManager().isOnline(): self._ssdp_register() self._eventManager.subscribe(Events.NETWORK_STATUS, self._onNetworkStateChanged)
def __init__(self): self._settings = settings() configDir = self._settings.getConfigFolder() self._infoFile = "%s/printer-profile.yaml" % configDir self._logger = logging.getLogger(__name__) self.data = { 'driver': "marlin", 'plugin': None, 'extruder_count': 1, 'max_nozzle_temp': 280, 'max_bed_temp': 140, 'heated_bed': True, 'cancel_gcode': ['G28 X0 Y0'], 'invert_z': False, 'invert_x': False, 'invert_y': False, 'printer_model': { 'id': None, 'name': None }, 'temp_presets' : [ { 'id' : "3e0fc9b398234f2f871310c1998aa000", 'name' : "PLA", 'nozzle_temp' : 220, 'bed_temp' : 40}, {'id' : "2cc9df599f3e4292b379913f4940c000s", 'name': "ABS", 'nozzle_temp': 230, 'bed_temp' : 80} ], 'last_presets_used' : [ ] } config = None if not os.path.isfile(self._infoFile): factoryFile = "%s/printer-profile.factory" % configDir if os.path.isfile(factoryFile): with open(factoryFile, "r") as f: config = yaml.safe_load(f) #overlay manufactuer definition of printer profile if not config: config = {} mfDefinition = manufacturerPkgManager().printerProfile for k in mfDefinition.keys(): v = mfDefinition[k] if v is not None: config[k] = v if config: merge_dict(self.data, config) self.save() else: with open(self._infoFile, "r") as f: config = yaml.safe_load(f) if config: merge_dict(self.data, config)
def __init__(self): self._settings = settings() configDir = self._settings.getConfigFolder() self._infoFile = "%s/printer-profile.yaml" % configDir self._logger = logging.getLogger(__name__) self.data = { 'last_definition_version': None, 'driver': "marlin", 'plugin': None, 'extruder_count': 1, 'check_clear_bed': True, 'max_nozzle_temp': 280, 'max_bed_temp': 140, 'heated_bed': True, 'cancel_gcode': ['G28 X0 Y0'], 'invert_z': False, 'invert_x': False, 'invert_y': False, 'manufacturer_id': None, 'printer_model': { 'id': None, 'name': None }, 'filament': { 'color': None, 'name': None }, 'temp_presets': { '3e0fc9b398234f2f871310c1998aa000': { 'name': "PLA", 'nozzle_temp': 220, 'bed_temp': 40 }, '2cc9df599f3e4292b379913f4940c000': { 'name': "ABS", 'nozzle_temp': 230, 'bed_temp': 80 }, }, 'last_presets_used': {} } config = None if not os.path.isfile(self._infoFile): factoryFile = "%s/printer-profile.factory" % configDir if os.path.isfile(factoryFile): with open(factoryFile, "r") as f: config = yaml.safe_load(f) if not config: config = {} if config: merge_dict(self.data, config) self.save() else: with open(self._infoFile, "r") as f: config = yaml.safe_load(f) if config: # remove old array formats if 'temp_presets' in config and isinstance( config['temp_presets'], list) == True: del config['temp_presets'] if 'last_presets_used' in config and isinstance( config['last_presets_used'], list) == True: del config['last_presets_used'] merge_dict(self.data, config) # check manufacturer definition update version = manufacturerPkgManager().version mfDefProfile = manufacturerPkgManager().printerProfile mfConfig = {} if version != self.data['last_definition_version']: self._logger.info( "A New update for manufacturer package has been found: %s" % (version)) mfDefVariant = manufacturerPkgManager().variant for k in mfDefProfile.keys(): v = mfDefProfile[k] if v is not None: mfConfig[k] = v if k == "temp_presets": for mfPresetID in v.keys(): p = mfConfig[k][mfPresetID] if self.data[k] is not None: dKey = self._checkPresetExisted(k, mfPresetID) if dKey: # if manufacturer updates its preset and user it's not allowed to edit => REPLACE if mfPresetID and mfDefVariant[ 'temperature_presets_edit'] is False: mfConfig[k][dKey] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } del mfConfig[k][mfPresetID] # if manfufacturer updates its preset and user it's allowed to edit => check if different ID. This way is user has edited a preset, and manufacturer update it after using same ID, it wont be overwritten but ignored it. else: matchedId = "" for i in self.data['temp_presets']: if "manufacturer_id" in self.data[ 'temp_presets'][i]: if self.data['temp_presets'][i][ 'manufacturer_id'] == mfPresetID: matchedId = mfPresetID if not matchedId: mfConfig[k][dKey] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } else: del mfConfig[k][mfPresetID] else: # Add new attribute object with correct format mfConfig[k][uuid.uuid4().hex] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } del mfConfig[k][mfPresetID] else: mfConfig[k][uuid.uuid4().hex] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } del mfConfig[k][mfPresetID] # update version number self.data['last_definition_version'] = version if version or mfConfig: if "temp_presets" in mfConfig.keys() or version: self._removeDefaultTempPresets() merge_dict(self.data, mfConfig) self.save()
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 __init__(self): self._settings = settings() configDir = self._settings.getConfigFolder() self._infoFile = "%s/printer-profile.yaml" % configDir self._logger = logging.getLogger(__name__) self.data = { 'last_definition_version': None, 'driver': "marlin", 'plugin': None, 'extruder_count': 1, 'max_nozzle_temp': 280, 'max_bed_temp': 140, 'heated_bed': True, 'cancel_gcode': ['G28 X0 Y0'], 'invert_z': False, 'invert_x': False, 'invert_y': False, 'printer_model': { 'id': None, 'name': None }, 'filament': { 'color': None, 'name': None }, 'temp_presets' : { '3e0fc9b398234f2f871310c1998aa000': { 'name' : "PLA", 'nozzle_temp' : 220, 'bed_temp' : 40 }, '2cc9df599f3e4292b379913f4940c000': { 'name' : "ABS", 'nozzle_temp' : 230, 'bed_temp' : 80 }, }, 'last_presets_used' : {} } config = None if not os.path.isfile(self._infoFile): factoryFile = "%s/printer-profile.factory" % configDir if os.path.isfile(factoryFile): with open(factoryFile, "r") as f: config = yaml.safe_load(f) if not config: config = {} if config: merge_dict(self.data, config) self.save() else: with open(self._infoFile, "r") as f: config = yaml.safe_load(f) if config: # remove old array formats if 'temp_presets' in config and isinstance(config['temp_presets'], list) == True: del config['temp_presets'] if 'last_presets_used'in config and isinstance(config['last_presets_used'], list) == True: del config['last_presets_used'] merge_dict(self.data, config) # check manufacturer definition update version = manufacturerPkgManager().version mfDefProfile = manufacturerPkgManager().printerProfile mfConfig = {} if version != self.data['last_definition_version']: self._logger.info("A New update for manufacturer package has been found: %s" % (version)) mfDefVariant = manufacturerPkgManager().variant for k in mfDefProfile.keys(): v = mfDefProfile[k] if v is not None: mfConfig[k] = v if k == "temp_presets": for mfPresetID in v.keys(): p = mfConfig[k][mfPresetID] if self.data[k] is not None: dKey = self._checkPresetExisted(k, mfPresetID) if dKey: # if manufacturer updates its preset and user it's not allowed to edit => REPLACE if mfPresetID and mfDefVariant['temperature_presets_edit'] is False: mfConfig[k][dKey] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } del mfConfig[k][mfPresetID] # if manfufacturer updates its preset and user it's allowed to edit => check if different ID. This way is user has edited a preset, and manufacturer update it after using same ID, it wont be overwritten but ignored it. else: matchedId = "" for i in self.data['temp_presets']: if "manufacturer_id" in self.data['temp_presets'][i]: if self.data['temp_presets'][i]['manufacturer_id'] == mfPresetID: matchedId = mfPresetID if not matchedId: mfConfig[k][dKey] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } else: del mfConfig[k][mfPresetID] else: # Add new attribute object with correct format mfConfig[k][uuid.uuid4().hex] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } del mfConfig[k][mfPresetID] else: mfConfig[k][uuid.uuid4().hex] = { "manufacturer_id": mfPresetID, "name": p['name'], "bed_temp": p['bed_temp'], "nozzle_temp": p['nozzle_temp'], } del mfConfig[k][mfPresetID] # update version number self.data['last_definition_version'] = version if version or mfConfig: if "temp_presets" in mfConfig.keys() or version: self._removeDefaultTempPresets() merge_dict(self.data, mfConfig) self.save()