def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
return False
return self.schema.validate(pre + " > " + self.name, value_of_key)
def jinja_read(tpl, store):
try:
path, filename = os.path.split(tpl)
from_file = jinja2.FileSystemLoader(path)
env = jinja2.Environment(loader=from_file,
undefined=jinja2.StrictUndefined)
yml = env.get_template(filename).render(store.values())
return yaml.load(yml)
except IOError:
raise error.ConnError("Could not open definition: "
"No such file or directory")
except yaml.YAMLError as err:
raise error.ValidatorError("error parsing definition, {}".format(err))
except jinja2.exceptions.UndefinedError as err:
raise error.ValidatorError("error parsing definition, {}".format(err))
def validate(self):
type_spec = len(filter(lambda a: a.pool_type, self.attributes()))
if type_spec != 1:
raise error.ValidatorError("{} component must have exactly one "
"attribute specifing its type (has {} "
"needs 1)"
.format(self.entity(), type_spec))
return Component.validate(self)
def yaml_read(path):
try:
with open(path, 'r') as stream:
return yaml.load(stream)
except IOError:
raise error.ConnError("Could not open definition: "
"No such file or directory")
except yaml.YAMLError as err:
raise error.ValidatorError("Error parsing definition: {}".format(err))
def validate(self, pre, structure):
if not isinstance(structure, dict):
raise error.ValidatorError("{} needs to be a dict".format(pre))
def _validate_each(pair):
(name, next_structure) = pair
return self.schema.validate(pre + " > " + name, next_structure)
return sum(map(_validate_each, structure.items())) >= 1
def validate(self, pre, structure):
TypeCheck.validate(self, pre, structure)
try:
socket.inet_pton(socket.AF_INET, structure)
return True
except socket.error:
try:
socket.inet_pton(socket.AF_INET6, structure)
return True
except socket.error:
pass
raise error.ValidatorError("{} is not a valid IP address".format(pre))
def get_components(defn):
for name, component in defn.items():
# skip xii global header
if name == "xii":
continue
# skip global namespace
if name == "xii":
continue
if "type" not in component:
raise error.ValidatorError("{} has no type. Check your "
"definition file".format(name))
ctype = component["type"]
component["basename"] = name
if "count" in component and component["count"] > 1:
tmp = dict(component)
del tmp["count"]
for i in range(1, component["count"]+1):
yield (ctype, "{}-{}".format(name, i), tmp)
else:
yield (ctype, name, component)
def validate(self, pre, structure):
errors = []
def _validate_each(schema):
try:
return schema.validate(pre, structure)
except error.ValidatorError as err:
errors.append(err)
return False
state = sum(map(_validate_each, self.schemas))
if self.exclusive and (state > 1 or state == 0):
def _error_lines():
it = iter(errors)
yield " ".join(next(it).error())
for err in it:
yield "or"
yield " ".join(err.error())
raise error.ValidatorError(["{} is ambigous:".format(pre)] +
list(_error_lines()))
return True
def validate(self, pre, structure):
if isinstance(structure, self.want_type):
return True
raise error.ValidatorError("{} needs to be {}".format(pre, self.want))
return False
def validate(self, pre, structure):
value_of_key = util.safe_get(self.name, structure)
if not value_of_key:
raise error.ValidatorError("{} must have {} "
"defined".format(pre, self.name))
return self.schema.validate(pre + " > " + self.name, value_of_key)