def get(self, section_name):
schema = _get_schema(self.schemas_dir, section_name, self.overrides)
path = _path(self.settings_dir, section_name, _file_extension)
raw = '{}'
settings = dict()
if os.path.exists(path):
with open(path) as fid:
# Attempt to load and parse the settings file.
try:
raw = fid.read() or raw
settings = json.loads(json_minify(raw))
except Exception as e:
message = 'Failed loading settings ({}): {}'
self.log.warn(message.format(section_name, str(e)))
# Validate the parsed data against the schema.
if len(settings):
validator = Validator(schema)
try:
validator.validate(settings)
except ValidationError as e:
message = 'Failed validating settings ({}): {}'
self.log.warn(message.format(section_name, str(e)))
raw = '{}'
# Send back the raw data to the client.
resp = dict(id=section_name, raw=raw, schema=schema)
self.finish(json.dumps(resp))
def _get_settings(settings_dir, schema_name, schema):
"""
Returns a tuple containing the raw user settings, the parsed user
settings, and a validation warning for a schema.
"""
path = _path(settings_dir, schema_name, False, SETTINGS_EXTENSION)
raw = '{}'
settings = dict()
warning = ''
validation_warning = 'Failed validating settings (%s): %s'
parse_error = 'Failed loading settings (%s): %s'
if os.path.exists(path):
with open(path) as fid:
try: # to load and parse the settings file.
raw = fid.read() or raw
settings = json5.loads(raw)
except Exception as e:
raise web.HTTPError(500, parse_error % (schema_name, str(e)))
# Validate the parsed data against the schema.
if len(settings):
validator = Validator(schema)
try:
validator.validate(settings)
except ValidationError as e:
warning = validation_warning % (schema_name, str(e))
raw = '{}'
return (raw, settings, warning)
def put(self, schema_name):
overrides = self.overrides
schemas_dir = self.schemas_dir
settings_dir = self.settings_dir
settings_error = 'No current settings directory'
validation_error = 'Failed validating input: %s'
if not settings_dir:
raise web.HTTPError(500, settings_error)
raw = self.request.body.strip().decode('utf-8')
# Validate the data against the schema.
schema, _ = _get_schema(schemas_dir,
schema_name,
overrides,
labextensions_path=self.labextensions_path)
validator = Validator(schema)
try:
validator.validate(json5.loads(raw))
except ValidationError as e:
raise web.HTTPError(400, validation_error % str(e))
# Write the raw data (comments included) to a file.
path = _path(settings_dir, schema_name, True, SETTINGS_EXTENSION)
with open(path, 'w', encoding='utf-8') as fid:
fid.write(raw)
self.set_status(204)
def _get_user_settings(settings_dir, schema_name, schema):
"""
Returns a dictionary containing the raw user settings, the parsed user
settings, a validation warning for a schema, and file times.
"""
path = _path(settings_dir, schema_name, False, SETTINGS_EXTENSION)
raw = '{}'
settings = {}
warning = ''
validation_warning = 'Failed validating settings (%s): %s'
parse_error = 'Failed loading settings (%s): %s'
last_modified = None
created = None
if os.path.exists(path):
stat = os.stat(path)
with open(path) as fid:
try: # to load and parse the settings file.
raw = fid.read() or raw
settings = json5.loads(raw)
except Exception as e:
raise web.HTTPError(500, parse_error % (schema_name, str(e)))
# Validate the parsed data against the schema.
if len(settings):
validator = Validator(schema)
try:
validator.validate(settings)
except ValidationError as e:
warning = validation_warning % (schema_name, str(e))
raw = '{}'
return dict(raw=raw, settings=settings, warning=warning)
def put(self, schema_name):
overrides = self.overrides
schemas_dir = self.schemas_dir
settings_dir = self.settings_dir
settings_error = 'No current settings directory'
invalid_json_error = 'Failed parsing JSON payload: %s'
invalid_payload_format_error = 'Invalid format for JSON payload. Must be in the form {\'raw\': ...}'
validation_error = 'Failed validating input: %s'
if not settings_dir:
raise web.HTTPError(500, settings_error)
raw_payload = self.request.body.strip().decode(u'utf-8')
try:
raw_settings = json.loads(raw_payload)['raw']
payload = json5.loads(raw_settings)
except json.decoder.JSONDecodeError as e:
raise web.HTTPError(400, invalid_json_error % str(e))
except KeyError as e:
raise web.HTTPError(400, invalid_payload_format_error)
# Validate the data against the schema.
schema = _get_schema(schemas_dir, schema_name, overrides)
validator = Validator(schema)
try:
validator.validate(payload)
except ValidationError as e:
raise web.HTTPError(400, validation_error % str(e))
# Write the raw data (comments included) to a file.
path = _path(settings_dir, schema_name, True, SETTINGS_EXTENSION)
with open(path, 'w') as fid:
fid.write(raw_settings)
self.set_status(204)
def patch(self, section_name):
if not self.settings_dir:
raise web.HTTPError(404, "No current settings directory")
path = os.path.join(self.schemas_dir, section_name + '.json')
if not os.path.exists(path):
raise web.HTTPError(404, "Schema not found for: %r" % section_name)
data = self.get_json_body() # Will raise 400 if content is not valid JSON
# Validate the data against the schema.
if Validator is not None:
with open(path) as fid:
schema = json.load(fid)
validator = Validator(schema)
try:
validator.validate(data)
except ValidationError as e:
raise web.HTTPError(400, str(e))
# Create the settings dir as needed.
if not os.path.exists(self.settings_dir):
os.makedirs(self.settings_dir)
path = os.path.join(self.settings_dir, section_name + '.json')
with open(path, 'w') as fid:
json.dump(data, fid)
self.set_status(204)
def get(self, section_name):
self.set_header("Content-Type", "application/json")
schema = _get_schema(self.schemas_dir, section_name, self.overrides)
path = _path(self.settings_dir, section_name, _file_extension)
raw = "{}"
settings = dict()
if os.path.exists(path):
with open(path) as fid:
# Attempt to load and parse the settings file.
try:
raw = fid.read() or raw
settings = json.loads(json_minify(raw))
except Exception as e:
self.log.warn(str(e))
# Validate the parsed data against the schema.
if len(settings):
validator = Validator(schema)
try:
validator.validate(settings)
except ValidationError as e:
self.log.warn(str(e))
raw = "{}"
# Send back the raw data to the client.
resp = dict(id=section_name, raw=raw, schema=schema)
self.finish(json.dumps(resp))
def _validate_data(self, data: dict,
validator: jsonschema.Draft4Validator):
try:
validator.validate(data)
except jsonschema.ValidationError as e:
raise BadArguments(validation_error=e.message,
provider=self.provider_name,
data=data)
def put(self, section_name):
if not self.settings_dir:
raise web.HTTPError(404, 'No current settings directory')
raw = self.request.body.strip().decode(u'utf-8')
# Validate the data against the schema.
schema = _get_schema(self.schemas_dir, section_name, self.overrides)
validator = Validator(schema)
try:
validator.validate(json.loads(json_minify(raw)))
except ValidationError as e:
raise web.HTTPError(400, str(e))
# Write the raw data (comments included) to a file.
path = _path(self.settings_dir, section_name, _file_extension, True)
with open(path, 'w') as fid:
fid.write(raw)
self.set_status(204)
def save_settings(
schemas_dir,
settings_dir,
schema_name,
raw_settings,
overrides,
labextensions_path=None,
):
"""
Save ``raw_settings`` settings for ``schema_name``.
Parameters
----------
schemas_dir: str
Path to schemas.
settings_dir: str
Path to settings.
schema_name str
Schema name.
raw_settings: str
Raw serialized settings dictionary
overrides: dict
Settings overrides.
labextensions_path: list, optional
List of paths to federated labextensions containing their own schema files.
"""
payload = json5.loads(raw_settings)
# Validate the data against the schema.
schema, _ = _get_schema(schemas_dir,
schema_name,
overrides,
labextensions_path=labextensions_path)
validator = Validator(schema)
validator.validate(payload)
# Write the raw data (comments included) to a file.
path = _path(settings_dir, schema_name, True, SETTINGS_EXTENSION)
with open(path, "w", encoding="utf-8") as fid:
fid.write(raw_settings)
def get(self, section_name):
self.set_header('Content-Type', "application/json")
path = os.path.join(self.schemas_dir, section_name + ".json")
if not os.path.exists(path):
raise web.HTTPError(404, "Schema not found: %r" % section_name)
with open(path) as fid:
# Attempt to load the schema file.
try:
schema = json.load(fid)
except Exception as e:
name = section_name
message = "Failed parsing schema ({}): {}".format(name, str(e))
raise web.HTTPError(500, message)
path = os.path.join(self.settings_dir, section_name + '.json')
settings = dict()
if os.path.exists(path):
with open(path) as fid:
# Attempt to load the settings file.
try:
settings = json.load(fid)
except Exception as e:
self.log.warn(str(e))
# Validate the data against the schema.
if Validator is not None and len(settings):
validator = Validator(schema)
try:
validator.validate(settings)
except ValidationError as e:
self.log.warn(str(e))
settings = dict()
resp = dict(id=section_name, data=dict(user=settings), schema=schema)
self.finish(json.dumps(resp))
