def put(self, event):
"""Store a given configuration"""
self.log("Configuration put request ", event.user)
try:
component = model_factory(Schema).find_one({"uuid": event.data["uuid"]})
component.update(event.data)
component.save()
response = {
"component": "isomer.ui.configurator",
"action": "put",
"data": True,
}
self.log("Updated component configuration:", component.name)
self.fireEvent(reload_configuration(component.name))
except (KeyError, ValueError, ValidationError, PermissionError) as e:
response = {
"component": "isomer.ui.configurator",
"action": "put",
"data": False,
}
self.log(
"Storing component configuration failed: ",
type(e),
e,
exc=True,
lvl=error,
)
self.fireEvent(send(event.client.uuid, response))
return
def setUp(self):
"""Set up the test scaffolding"""
self.schema = {
"name": "Country",
"id": "#Country",
"properties": {
"name": {"type": "string"},
"abbreviation": {"type": "string"},
"languages": {"type": "array", "items": {"type": "string"}},
},
"additionalProperties": False,
}
# Connect to formal_test - hopefully it doesn't exist
formal.connect("formal_test")
self.Country = formal.model_factory(self.schema)
# Drop all the data in it
self.Country.collection().delete_many({})
# Create some defaults
sweden = self.Country(
{"name": "Sweden", "abbreviation": "SE", "languages": ["swedish"]}
)
sweden.save()
usa = self.Country(
{
"name": "United States of America",
"abbreviation": "US",
"languages": ["english"],
}
)
usa.save()
def _build_model_factories(store):
"""Generate factories to construct objects from schemata"""
result = {}
for schemaname in store:
schema = None
try:
schema = store[schemaname]["schema"]
except KeyError:
db_log("No schema found for ", schemaname, lvl=critical, exc=True)
try:
result[schemaname] = formal.model_factory(schema, IsomerBaseModel)
except Exception as e:
db_log(
"Could not create factory for schema ",
schemaname,
schema,
lvl=critical,
exc=True,
)
return result
def clean_test_components():
"""Removes test-generated component data"""
print("Removing test components...")
for item in model_factory(ComponentConfigSchemaTemplate).find(
{'componentclass': 'TestComponent'}):
item.delete()
def config(ctx):
"""[GROUP] Configuration management operations"""
from isomer import database
database.initialize(ctx.obj["dbhost"], ctx.obj["dbname"])
from isomer.schemata.component import ComponentConfigSchemaTemplate
ctx.obj["col"] = model_factory(ComponentConfigSchemaTemplate)
def testValidateInteger(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {"field": {"type": "integer"}},
}
model = formal.model_factory(schema)
self.assertRaises(ValidationError, model, {"field": "hi"})
def testValidateString(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {"field": {"type": "string"}},
}
model = formal.model_factory(schema)
m = model({"field": "asdf"})
self.assertEqual("asdf", m.field)
self.assertRaises(ValidationError, model, {"field": 5})
def testValidateBool(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {"field": {"type": "boolean"}},
}
model = formal.model_factory(schema)
m = model({"field": False})
self.assertEqual(False, m.field)
self.assertRaises(ValidationError, model, {"field": "hi"})
def testValidateArray(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {"field": {"type": "array", "items": {"type": "string"}}},
}
model = formal.model_factory(schema)
m = model({"field": ["asdf", "hello"]})
self.assertEqual(2, len(m.field))
self.assertEqual("asdf", m.field[0])
self.assertRaises(ValidationError, model, {"field": "hi"})
def test_schemata():
"""Validates all registered schemata"""
objects = {}
for schemaname in schemastore.keys():
objects[schemaname] = formal.model_factory(
schemastore[schemaname]["schema"])
try:
testobject = objects[schemaname]()
testobject.validate()
except Exception as e:
schemata_log("Blank schema did not validate:",
schemaname,
exc=True)
def testCastWithArray(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {"field": {"type": "array", "items": {"type": "integer"}}},
}
model = formal.model_factory(schema)
m = model()
old_fields = {"field": [5.2, 7]}
fields = m.cast(old_fields)
self.assertEqual(5, fields["field"][0])
self.assertEqual(7, fields["field"][1])
def testValidateNumber(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {"field": {"type": "number"}},
}
model = formal.model_factory(schema)
m = model({"field": 5.5})
self.assertEqual(5.5, m.field)
self.assertRaises(ValidationError, model, {"field": "hi"})
# using an int should still work
m = model({"field": 5})
self.assertEqual(5, m.field)
def testBasicCast(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {
"field": {"type": "integer"},
"other_field": {"type": "string"},
},
}
model = formal.model_factory(schema)
m = model()
old_fields = {"field": 5.2, "other_field": "5"}
fields = m.cast(old_fields)
self.assertEqual(5, fields["field"])
self.assertEqual("5", fields["other_field"])
def testValidateObjectId(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {
"_id": {
"type": "string",
"pattern": r"^(?=[a-f\d]{24}$)(\d+[a-f]|[a-f]+\d)",
"additionalProperties": False,
}
},
}
model = formal.model_factory(schema)
m = model({"_id": str(ObjectId("45cbc4a0e4123f6920000002"))})
self.assertEqual(ObjectId("45cbc4a0e4123f6920000002"), ObjectId(m._id))
self.assertRaises(ValidationError, model, {"_id": "hi"})
def testCastWithObject(self):
schema = {
"name": "Model",
"id": "#Model",
"properties": {
"field": {
"type": "object",
"properties": {"subfield": {"type": "integer"}},
}
},
}
model = formal.model_factory(schema)
m = model()
old_fields = {"field": {"subfield": 5.2}}
fields = m.cast(old_fields)
self.assertEqual(5, fields["field"]["subfield"])
def get(self, event):
"""Get a stored configuration"""
try:
comp = event.data["uuid"]
except KeyError:
comp = None
if not comp:
self.log("Invalid get request without schema or component", lvl=error)
return
self.log("Config data get request for ", event.data, "from", event.user)
component = model_factory(Schema).find_one({"uuid": comp})
response = {
"component": "isomer.ui.configurator",
"action": "get",
"data": component.serializablefields(),
}
self.fireEvent(send(event.client.uuid, response))
def setUp(self):
"""Set up the test scaffolding"""
self.schema = {
"name": "Country",
"sql": True,
"id": "#Country",
"properties": {
"name": {
"type": "string"
},
"abbreviation": {
"type": "string",
"primary": True
},
"dialcode": {
"type": "integer"
},
},
"additionalProperties": False,
}
formal.connect_sql(":memory:", "sqlite", "", "", "", 0)
self.Country = formal.model_factory(self.schema)
# Drop all the data in it
# self.Country.clear()
# Create some defaults
self.Country({
"name": "Sweden",
"abbreviation": "SE",
"dialcode": 46
}).save()
self.Country({
"name": "United States of America",
"abbreviation": "US",
"dialcode": 1
}).save()
def getlist(self, event):
"""Processes configuration list requests
:param event:
"""
try:
componentlist = model_factory(Schema).find({})
data = []
for comp in componentlist:
try:
data.append(
{
"name": comp.name,
"uuid": comp.uuid,
"class": comp.componentclass,
"active": comp.active,
"present": comp.name in self.names
}
)
except AttributeError:
self.log(
"Bad component without component class encountered:", lvl=warn
)
self.log(comp.serializablefields(), pretty=True, lvl=warn)
data = sorted(data, key=lambda x: x["name"])
response = {
"component": "isomer.ui.configurator",
"action": "getlist",
"data": data,
}
self.fireEvent(send(event.client.uuid, response))
return
except Exception as e:
self.log("List error: ", e, type(e), lvl=error, exc=True)
def profile(schemaname="sensordata", profiletype="pjs"):
"""Profiles object model handling with a very simple benchmarking test"""
db_log("Profiling ", schemaname)
schema = schemastore[schemaname]["schema"]
db_log("Schema: ", schema, lvl=debug)
testclass = None
if profiletype == "formal":
db_log("Running formal benchmark")
testclass = formal.model_factory(schema)
elif profiletype == "pjs":
db_log("Running PJS benchmark")
try:
import python_jsonschema_objects as pjs
except ImportError:
db_log("PJS benchmark selected but not available. Install "
"python_jsonschema_objects (PJS)")
return
db_log()
builder = pjs.ObjectBuilder(schema)
ns = builder.build_classes()
pprint(ns)
testclass = ns[schemaname]
db_log("ns: ", ns, lvl=warn)
if testclass is not None:
db_log("Instantiating elements...")
for i in range(100):
testclass()
else:
db_log("No Profiletype available!")
db_log("Profiling done")
def __init__(self):
super(GIFMaster, self).__init__("GIFMASTER")
self.players = {}
self.player_model = formal.model_factory(
self.configprops['channels']['items'])
def __init__(self, uniquename, no_db=False, *args, **kwargs):
"""Check for configuration issues and instantiate a component"""
LoggingMeta.__init__(self, uniquename, *args, **kwargs)
if no_db is True:
self.no_db = True
self.log("Not using database!")
return
else:
self.no_db = False
self.configschema = deepcopy(ComponentBaseConfigSchema)
self.configschema["schema"]["properties"].update(self.configprops)
if len(self.configform) > 0:
self.configschema["form"] += self.configform
else:
self.configschema["form"] = ["*"]
# self.log("[UNIQUECOMPONENT] Config Schema: ", self.configschema,
# lvl=critical)
# pprint(self.configschema)
# self.configschema['name'] = self.uniquename
# self.configschema['id'] = "#" + self.uniquename
# schemastore[self.uniquename] = {'schema': self.configschema,
# 'form': self.configform}
self.componentmodel = model_factory(self.configschema["schema"])
# self.log("Component model: ", lvl=critical)
# pprint(self.componentmodel._schema)
self._read_config()
if not self.config:
self.log("Creating initial default configuration.")
try:
self._set_config()
self._write_config()
except ValidationError as e:
self.log("Error during configuration reading: ",
e,
type(e),
exc=True)
environment_identifier = 'ISOMER_COMPONENT_' + self.uniquename
overrides = [
key for key, item in os.environ.items()
if key.startswith(environment_identifier)
]
if len(overrides) > 0:
self.log('Environment overrides found:', overrides)
for item in overrides:
path = item.lstrip(environment_identifier).lower().split("_")
nested_map_update(self.config._fields, os.environ[item], path)
self.config.save()
if self.config.active is False:
self.log("Component disabled.", lvl=warn)
