def validate(self, config): schema = load_schema(str(self.VERSION)) jsonschema.validate(config, schema) if have_parameter_reference_pattern(config): raise jsonschema.SchemaError( 'Do not support parameter reference in config version <= 2')
def http_get_schema(scid): """Retrieve schema via HTTP.""" validate_scid(scid) url = SCHEMA_URL_FORMAT % scid try: schema = json.loads(http_get(url)) except (ValueError, EnvironmentError) as ex: raise jsonschema.SchemaError('Schema fetch failure: %s' % ex) jsonschema.Draft3Validator.check_schema(schema) return schema
def http_get_schema(scid): """Retrieve schema via HTTP.""" url = RAW_SCHEMA_URL_FORMAT % scid try: content = urlopen(url).read().decode('utf-8') schema = json.loads(content) except (ValueError, EnvironmentError) as ex: raise jsonschema.SchemaError('Schema fetch failure: %s' % ex) jsonschema.Draft3Validator.check_schema(schema) return schema
def load(self, schemafile=None): """Load and process the schema file""" if schemafile is not None: self._schemafile = schemafile try: self.data = json.load(open(self._schemafile)) except (IOError, ValueError), e: msg = "Could not load schema file '" + self._schemafile + "': '" + str( e) + "'" raise jsonschema.SchemaError(msg)
def schema_val(self, messages=None): "Perform validation with processed YAML and Schema" self._ymlproc = YAMLProcessor(self._ymlfile) self._schemaproc = SchemaProcessor(self._schemafile) valid = True log.debug( "BEGIN: Schema-based validation for YAML '%s' with schema '%s'", self._ymlfile, self._schemafile, ) # Make sure the yml and schema have been loaded if self._ymlproc.loaded and self._schemaproc.loaded: # Load all of the yaml documents. Could be more than one in the same YAML file. for docnum, data in enumerate( yaml.load_all(self._ymlproc.data, Loader=yaml.Loader)): # Since YAML allows integer keys but JSON does not, we need to first # dump the data as a JSON string to encode all of the potential integers # as strings, and then read it back out into the YAML format. Kind of # a clunky workaround but it works as expected. data = yaml.load(json.dumps(data), Loader=yaml.Loader) # Now we want to get a validator ready v = jsonschema.Draft4Validator(self._schemaproc.data) # Loop through the errors (if any) and set valid = False if any are found # Display the error message for error in v.iter_errors(data): msg = ("Schema-based validation failed for YAML file '" + self._ymlfile + "'") self.ehandler.process(docnum, self._ymlproc.doclines, error, messages) valid = False if not valid: log.error(msg) elif not self._ymlproc.loaded: raise util.YAMLError("YAML must be loaded in order to validate.") elif not self._schemaproc.loaded: raise jsonschema.SchemaError( "Schema must be loaded in order to validate.") log.debug("END: Schema-based validation complete for '%s'", self._ymlfile) return valid
def test_validate_invalid_data(self, jschema_m): jschema_m.ValidationError = jsonschema.ValidationError jschema_m.SchemaError = jsonschema.SchemaError paths = [(("a", 0), "\['a'\]\[0\]"), ((), "")] for path, details in paths: msg = "Invalid data: error." if details: msg += "\nField: {0}".format(details) with self.assertRaisesRegexp(ValueError, msg): jschema_m.validate.side_effect = jsonschema.ValidationError( "error", path=path) self.api._validate_data([], {}) jschema_m.validate.assert_called_with([], {}) jschema_m.validate.reset_mock() msg = "Invalid schema: error." if details: msg += "\nField: {0}".format(details) with self.assertRaisesRegexp(ValueError, msg): jschema_m.validate.side_effect = jsonschema.SchemaError( "error", schema_path=path) self.api._validate_data([], {}) jschema_m.validate.assert_called_with([], {})
def init_base_logging(directory="./log", verbose=0, silent=False, color=False, no_file=False, truncate=True, config_location=None): """ Initialize the Icetea logging by creating a directory to store logs for this run and initialize the console logger for Icetea itself. :param directory: Directory where to store the resulting logs :param verbose: Log level as integer :param silent: Log level warning :param no_file: Log to file :param color: Log coloring :param truncate: Log truncating :param config_location: Location of config file. :raises IOError if unable to read configuration file. :raises OSError if log path already exists. :raises ImportError if colored logging was requested but coloredlogs module is not installed. """ global LOGPATHDIR global STANDALONE_LOGGING global TRUNCATE_LOG global COLOR_ON global SILENT_ON global VERBOSE_LEVEL if config_location: try: _read_config(config_location) except IOError as error: raise IOError( "Unable to read from configuration file {}: {}".format( config_location, error)) except jsonschema.SchemaError as error: raise jsonschema.SchemaError("Logging configuration schema " "file malformed: {}".format(error)) LOGPATHDIR = os.path.join( directory, datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S.%f").rstrip("0")) # Initialize the simple console logger for IceteaManager icetealogger = logging.getLogger("icetea") icetealogger.propagate = False icetealogger.setLevel(logging.DEBUG) stream_handler = logging.StreamHandler() formatter = BenchFormatter( LOGGING_CONFIG.get("IceteaManager").get("format"), LOGGING_CONFIG.get("IceteaManager").get("dateformat")) if not color: stream_handler.setFormatter(formatter) elif color and not COLORS: raise ImportError("Missing coloredlogs module. Please install with " "pip to use colors in logging.") else: class ColoredBenchFormatter(coloredlogs.ColoredFormatter): """ This is defined as an internal class here because coloredlogs is and optional dependency. """ converter = datetime.datetime.fromtimestamp def formatTime(self, record, datefmt=None): date_and_time = self.converter(record.created, tz=pytz.utc) if "%F" in datefmt: msec = "%03d" % record.msecs datefmt = datefmt.replace("%F", msec) str_time = date_and_time.strftime(datefmt) return str_time COLOR_ON = color stream_handler.setFormatter( ColoredBenchFormatter( LOGGING_CONFIG.get("IceteaManager").get("format"), LOGGING_CONFIG.get("IceteaManager").get("dateformat"), LEVEL_FORMATS, FIELD_STYLES)) SILENT_ON = silent VERBOSE_LEVEL = verbose if not no_file: try: os.makedirs(LOGPATHDIR) except OSError: raise OSError("Log path %s already exists." % LOGPATHDIR) filename = LOGGING_CONFIG.get("IceteaManager").get("file").get( "name", "icetea.log") icetealogger = _add_filehandler(icetealogger, get_base_logfilename(filename), formatter, "IceteaManager") if verbose and not silent: stream_handler.setLevel(logging.DEBUG) elif silent: stream_handler.setLevel(logging.WARN) else: stream_handler.setLevel( getattr(logging, LOGGING_CONFIG.get("IceteaManager").get("level"))) icetealogger.addHandler(stream_handler) TRUNCATE_LOG = truncate if TRUNCATE_LOG: icetealogger.addFilter(ContextFilter()) STANDALONE_LOGGING = False