diff options
Diffstat (limited to 'opendc/models')
30 files changed, 1556 insertions, 0 deletions
diff --git a/opendc/models/__init__.py b/opendc/models/__init__.py new file mode 100644 index 00000000..e69de29b --- /dev/null +++ b/opendc/models/__init__.py diff --git a/opendc/models/allowed_object.py b/opendc/models/allowed_object.py new file mode 100644 index 00000000..acd58e94 --- /dev/null +++ b/opendc/models/allowed_object.py @@ -0,0 +1,27 @@ +from opendc.models.model import Model + +class AllowedObject(Model): + + JSON_TO_PYTHON_DICT = { + 'AllowedObject': { + 'roomType': 'room_type', + 'objectType': 'object_type' + } + } + + TABLE_NAME = 'allowed_objects' + COLUMNS = ['room_type', 'object_type'] + COLUMNS_PRIMARY_KEY = ['room_type', 'object_type'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this AllowedObject.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True + + def to_JSON(self): + """Return a JSON representation of this AllowedObject.""" + + return self.object_type diff --git a/opendc/models/authorization.py b/opendc/models/authorization.py new file mode 100644 index 00000000..90c7d399 --- /dev/null +++ b/opendc/models/authorization.py @@ -0,0 +1,53 @@ +import json + +from opendc.models.model import Model +from opendc.models.user import User + +class Authorization(Model): + + JSON_TO_PYTHON_DICT = { + 'Authorization': { + 'userId': 'user_id', + 'simulationId': 'simulation_id', + 'authorizationLevel': 'authorization_level' + } + } + + TABLE_NAME = 'authorizations' + COLUMNS = ['user_id', 'simulation_id', 'authorization_level'] + COLUMNS_PRIMARY_KEY = ['user_id', 'simulation_id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this Authorization.""" + + authorization = Authorization.from_primary_key( + ( + User.from_google_id(google_id).id, + self.simulation_id + ) + ) + + if authorization is None: + return False + + return authorization.has_at_least(authorization_level) + + def has_at_least(self, required_level): + """Return True if this Authorization has at least the required level.""" + + if not self.exists(): + return False + + authorization_levels = ['VIEW', 'EDIT', 'OWN'] + + try: + index_actual = authorization_levels.index(self.authorization_level) + index_required = authorization_levels.index(required_level) + except: + return False + + if index_actual >= index_required: + return True + else: + return False + diff --git a/opendc/models/cpu.py b/opendc/models/cpu.py new file mode 100644 index 00000000..a2a0e79f --- /dev/null +++ b/opendc/models/cpu.py @@ -0,0 +1,41 @@ +from opendc.models.model import Model + +class CPU(Model): + + JSON_TO_PYTHON_DICT = { + 'CPU': { + 'id': 'id', + 'manufacturer': 'manufacturer', + 'family': 'family', + 'generation': 'generation', + 'model': 'model', + 'clockRateMhz': 'clock_rate_mhz', + 'numberOfCores': 'number_of_cores', + 'energyConsumptionW': 'energy_consumption_w', + 'failureModelId': 'failure_model_id' + } + } + + TABLE_NAME = 'cpus' + + COLUMNS = [ + 'id', + 'manufacturer', + 'family', + 'generation', + 'model', + 'clock_rate_mhz', + 'number_of_cores', + 'energy_consumption_w', + 'failure_model_id' + ] + + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this CPU.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/datacenter.py b/opendc/models/datacenter.py new file mode 100644 index 00000000..32ce1d49 --- /dev/null +++ b/opendc/models/datacenter.py @@ -0,0 +1,36 @@ +import json + +from opendc.models.model import Model +from opendc.models.section import Section +from opendc.util import database, exceptions + +class Datacenter(Model): + + JSON_TO_PYTHON_DICT = { + 'datacenter': { + 'id': 'id', + 'starred': 'starred', + 'simulationId': 'simulation_id' + } + } + + PATH = '/v1/simulations/{simulationId}/datacenters' + + TABLE_NAME = 'datacenters' + COLUMNS = ['id', 'simulation_id', 'starred'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Datacenter.""" + + # Get a Section that contains this Datacenter. It doesn't matter which one, since all Sections that have this + # Datacenter belong to the same Simulation, so the User's Authorization is the same for each one. + + try: + section = Section.query('datacenter_id', self.id)[0] + except Exception as e: + return False + + # Check the Section's Authorization + + return section.google_id_has_at_least(google_id, authorization_level) diff --git a/opendc/models/experiment.py b/opendc/models/experiment.py new file mode 100644 index 00000000..35056d0f --- /dev/null +++ b/opendc/models/experiment.py @@ -0,0 +1,51 @@ +from opendc.models.model import Model +from opendc.models.simulation import Simulation +from opendc.util import database, exceptions + +class Experiment(Model): + + JSON_TO_PYTHON_DICT = { + 'Experiment': { + 'id': 'id', + 'simulationId': 'simulation_id', + 'pathId': 'path_id', + 'traceId': 'trace_id', + 'schedulerName': 'scheduler_name', + 'name': 'name' + } + } + + TABLE_NAME = 'experiments' + COLUMNS = ['id', 'simulation_id', 'path_id', 'trace_id', 'scheduler_name', 'name'] + COLUMNS_PRIMARY_KEY = ['id'] + + def get_last_simulated_tick(self): + """Get this Experiment's last simulated tick.""" + + statement = ''' + SELECT tick + FROM task_states + WHERE experiment_id = ? + ORDER BY tick DESC + LIMIT 1 + ''' + result = database.fetchone(statement, (self.id,)) + + if result is not None: + return result[0] + + return -1 + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Experiment.""" + + # Get the Simulation + + try: + simulation = Simulation.from_primary_key((self.simulation_id,)) + except exceptions.RowNotFoundError: + return False + + # Check the Simulation's Authorization + + return simulation.google_id_has_at_least(google_id, authorization_level) diff --git a/opendc/models/failure_model.py b/opendc/models/failure_model.py new file mode 100644 index 00000000..8dd16d6c --- /dev/null +++ b/opendc/models/failure_model.py @@ -0,0 +1,23 @@ +from opendc.models.model import Model + +class FailureModel(Model): + + JSON_TO_PYTHON_DICT = { + 'FailureModel': { + 'id': 'id', + 'name': 'name', + 'rate': 'rate' + } + } + + TABLE_NAME = 'failure_models' + COLUMNS = ['id', 'name', 'rate'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this FailureModel.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/gpu.py b/opendc/models/gpu.py new file mode 100644 index 00000000..d9978ec7 --- /dev/null +++ b/opendc/models/gpu.py @@ -0,0 +1,41 @@ +from opendc.models.model import Model + +class GPU(Model): + + JSON_TO_PYTHON_DICT = { + 'GPU': { + 'id': 'id', + 'manufacturer': 'manufacturer', + 'family': 'family', + 'generation': 'generation', + 'model': 'model', + 'clockRateMhz': 'clock_rate_mhz', + 'numberOfCores': 'number_of_cores', + 'energyConsumptionW': 'energy_consumption_w', + 'failureModelId': 'failure_model_id' + } + } + + TABLE_NAME = 'gpus' + + COLUMNS = [ + 'id', + 'manufacturer', + 'family', + 'generation', + 'model', + 'clock_rate_mhz', + 'number_of_cores', + 'energy_consumption_w', + 'failure_model_id' + ] + + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this GPU.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/machine.py b/opendc/models/machine.py new file mode 100644 index 00000000..52cf221b --- /dev/null +++ b/opendc/models/machine.py @@ -0,0 +1,129 @@ +import copy + +from opendc.models.model import Model +from opendc.models.rack import Rack +from opendc.util import database, exceptions + +class Machine(Model): + + JSON_TO_PYTHON_DICT = { + 'machine': { + 'id': 'id', + 'rackId': 'rack_id', + 'position': 'position', + 'tags': 'tags', + 'cpuIds': 'cpu_ids', + 'gpuIds': 'gpu_ids', + 'memoryIds': 'memory_ids', + 'storageIds': 'storage_ids' + } + } + + PATH = '/v1/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack/machines' + + TABLE_NAME = 'machines' + COLUMNS = ['id', 'rack_id', 'position'] + COLUMNS_PRIMARY_KEY = ['id'] + + device_table_to_attribute = { + 'cpus': 'cpu_ids', + 'gpus': 'gpu_ids', + 'memories': 'memory_ids', + 'storages': 'storage_ids' + } + + def _update_devices(self, before_insert): + """Update this Machine's devices in the database.""" + + for device_table in self.device_table_to_attribute.keys(): + + # First, create the statements to execute + + statements = [] + values = [] + + # First, delete current machine-device links + + statement = 'DELETE FROM machine_{} WHERE machine_id = ?'.format(device_table) + database.execute(statement, (before_insert.id,)) + + # Then, add current ones + + for device_id in getattr(before_insert, before_insert.device_table_to_attribute[device_table]): + + statement = 'INSERT INTO machine_{} (machine_id, {}) VALUES (?, ?)'.format( + device_table, + before_insert.device_table_to_attribute[device_table][:-1] + ) + + database.execute(statement, (before_insert.id, device_id)) + + @classmethod + def from_tile_id_and_rack_position(cls, tile_id, position): + """Get a Rack from the ID of the tile its Rack is on, and its position in the Rack.""" + + try: + rack = Rack.from_tile_id(tile_id) + except: + return cls(id = -1) + + try: + statement = 'SELECT id FROM machines WHERE rack_id = ? AND position = ?' + machine_id = database.fetchone(statement, (rack.id, position))[0] + except: + return cls(id = -1) + + return cls.from_primary_key((machine_id,)) + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Machine.""" + + # Get the Rack + + try: + rack = Rack.from_primary_key((self.rack_id,)) + except exceptions.RowNotFoundError: + return False + + # Check the Rack's Authorization + + return rack.google_id_has_at_least(google_id, authorization_level) + + def insert(self): + """Insert this Machine by also updating its devices.""" + + before_insert = copy.deepcopy(self) + + super(Machine, self).insert() + + before_insert.id = self.id + self._update_devices(before_insert) + + def read(self): + """Read this Machine by also getting its CPU, GPU, Memory and Storage IDs.""" + + super(Machine, self).read() + + for device_table in self.device_table_to_attribute.keys(): + + statement = 'SELECT * FROM machine_{} WHERE machine_id = ?'.format(device_table) + results = database.fetchall(statement, (self.id,)) + + device_ids = [] + + for row in results: + device_ids.append(row[2]) + + setattr(self, self.device_table_to_attribute[device_table], device_ids) + + setattr(self, 'tags', []) + + def update(self): + """Update this Machine by also updating its devices.""" + + before_update = copy.deepcopy(self) + + super(Machine, self).update() + + before_update.id = self.id + self._update_devices(before_update) diff --git a/opendc/models/machine_state.py b/opendc/models/machine_state.py new file mode 100644 index 00000000..44bc6746 --- /dev/null +++ b/opendc/models/machine_state.py @@ -0,0 +1,79 @@ +from opendc.models.model import Model +from opendc.util import database + +class MachineState(Model): + + JSON_TO_PYTHON_DICT = { + 'MachineState': { + 'taskId': 'task_id', + 'machineId': 'machine_id', + 'temperatureC': 'temperature_c', + 'inUseMemoryMb': 'in_use_memory_mb', + 'loadFraction': 'load_fraction', + 'tick': 'tick' + } + } + + TABLE_NAME = 'machine_states' + COLUMNS = ['id', 'task_id', 'machine_id', 'experiment_id', 'tick', 'temperature_c', 'in_use_memory_mb', 'load_fraction'] + + COLUMNS_PRIMARY_KEY= ['id'] + + @classmethod + def _from_database_row(cls, row): + """Instantiate a MachineState from a database row (including tick from the TaskState).""" + + return cls( + task_id = row[1], + machine_id = row[2], + temperature_c = row[5], + in_use_memory_mb = row[6], + load_fraction = row[7], + tick = row[4] + ) + + @classmethod + def from_experiment_id(cls, experiment_id): + """Query MachineStates by their Experiment id.""" + + machine_states = [] + + statement = 'SELECT * FROM machine_states WHERE experiment_id = ?' + results = database.fetchall(statement, (experiment_id,)) + + for row in results: + machine_states.append(cls._from_database_row(row)) + + return machine_states + + @classmethod + def from_experiment_id_and_tick(cls, experiment_id, tick): + """Query MachineStates by their Experiment id and tick.""" + + machine_states = [] + + statement = 'SELECT * FROM machine_states WHERE experiment_id = ? AND machine_states.tick = ?' + results = database.fetchall(statement, (experiment_id, tick)) + + for row in results: + machine_states.append(cls._from_database_row(row)) + + return machine_states + + def read(self): + """Read this MachineState by also getting its tick.""" + + super(MachineState, self).read() + + statement = 'SELECT tick FROM task_states WHERE id = ?' + result = database.fetchone(statement, (self.task_state_id,)) + + self.tick = result[0] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this MachineState.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/memory.py b/opendc/models/memory.py new file mode 100644 index 00000000..56497bd4 --- /dev/null +++ b/opendc/models/memory.py @@ -0,0 +1,41 @@ +from opendc.models.model import Model + +class Memory(Model): + + JSON_TO_PYTHON_DICT = { + 'Memory': { + 'id': 'id', + 'manufacturer': 'manufacturer', + 'family': 'family', + 'generation': 'generation', + 'model': 'model', + 'speedMbPerS': 'speed_mb_per_s', + 'sizeMb': 'size_mb', + 'energyConsumptionW': 'energy_consumption_w', + 'failureModelId': 'failure_model_id' + } + } + + TABLE_NAME = 'memories' + + COLUMNS = [ + 'id', + 'manufacturer', + 'family', + 'generation', + 'model', + 'speed_mb_per_s', + 'size_mb', + 'energy_consumption_w', + 'failure_model_id' + ] + + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this Memory.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/model.py b/opendc/models/model.py new file mode 100644 index 00000000..e8a14e76 --- /dev/null +++ b/opendc/models/model.py @@ -0,0 +1,328 @@ +from opendc.util import database, exceptions + +class Model(object): + + # MUST OVERRIDE IN DERIVED CLASS + + JSON_TO_PYTHON_DICT = { + 'Model': { + 'jsonParameterName': 'python_parameter_name' + } + } + + PATH = '' + PATH_PARAMETERS = {} + + TABLE_NAME = '' + COLUMNS = [] + COLUMNS_PRIMARY_KEY = [] + + # INITIALIZATION + + def __init__(self, **kwargs): + """Initialize a model from its keyword arguments.""" + + for name, value in kwargs.items(): + setattr(self, name, value) + + def __repr__(self): + """Return a string representation of this object.""" + + identifiers = [] + + for attribute in self.COLUMNS_PRIMARY_KEY: + identifiers.append('{} = {}'.format(attribute, getattr(self, attribute))) + + return '{} ({})'.format( + self.TABLE_NAME[:-1].title().replace('_', ''), + '; '.join(identifiers) + ) + + # JSON CONVERSION METHODS + + @classmethod + def from_JSON(cls, json_object): + """Initialize a Model from its JSON object representation.""" + + parameters = {} + parameter_map = cls.JSON_TO_PYTHON_DICT.values()[0] + + for json_name in parameter_map: + + python_name = parameter_map[json_name] + + if json_name in json_object: + parameters[python_name] = json_object.get(json_name) + + else: + parameters[python_name] = None + + return cls(**parameters) + + def to_JSON(self): + """Return a JSON-serializable object representation of this Model.""" + + parameters = {} + parameter_map = self.JSON_TO_PYTHON_DICT.values()[0] + + for json_name in parameter_map: + + python_name = parameter_map[json_name] + + if hasattr(self, python_name): + parameters[json_name] = getattr(self, python_name) + + else: + parameters[json_name] = None + + return parameters + + + # API CALL GENERATION + + def generate_api_call(self, path_parameters, token): + """Return a message that can be executed by a Request to recreate this object.""" + + return { + 'id': 0, + 'path': self.PATH, + 'method': 'POST', + 'parameters': { + 'body': { + self.JSON_TO_PYTHON_DICT.keys()[0]: self.to_JSON() + }, + 'path': path_parameters, + 'query': {} + }, + 'token': token + } + + # SQL STATEMENT GENERATION METHODS + + @classmethod + def _generate_insert_columns_string(cls): + """Generate a SQLite insertion columns string for this Model""" + + return ', '.join(cls.COLUMNS) + + @classmethod + def _generate_insert_placeholders_string(cls): + """Generate a SQLite insertion placeholders string for this Model.""" + + return ', '.join(['?'] * len(cls.COLUMNS)) + + @classmethod + def _generate_primary_key_string(cls): + """Generate the SQLite primary key string for this Model.""" + + return ' AND '.join(['{} = ?'.format(x) for x in cls.COLUMNS_PRIMARY_KEY]) + + @classmethod + def _generate_update_columns_string(cls): + """Generate a SQLite updatable columns string for this Model.""" + + return ', '.join( + ['{} = ?'.format(x) for x in cls.COLUMNS if not x in cls.COLUMNS_PRIMARY_KEY] + ) + + # SQL TUPLE GENERATION METHODS + + def _generate_insert_columns_tuple(self): + """Generate the tuple of insertion column values for this object.""" + + value_list = [] + + for column in self.COLUMNS: + value_list.append(getattr(self, column, None)) + + return tuple(value_list) + + def _generate_primary_key_tuple(self): + """Generate the tuple of primary key values for this object.""" + + primary_key_list = [] + + for column in self.COLUMNS_PRIMARY_KEY: + primary_key_list.append(getattr(self, column, None)) + + return tuple(primary_key_list) + + def _generate_update_columns_tuple(self): + """Generate the tuple of updatable column values for this object.""" + + value_list = [] + + for column in [x for x in self.COLUMNS if not x in self.COLUMNS_PRIMARY_KEY]: + value_list.append(getattr(self, column, None)) + + return tuple(value_list) + + # DATABASE HELPER METHODS + + @classmethod + def _from_database(cls, statement, values): + """Initialize a Model by fetching it from the database.""" + + parameters = {} + model_from_database = database.fetchone(statement, values) + + if model_from_database is None: + return None + + for i in range(len(cls.COLUMNS)): + parameters[cls.COLUMNS[i]] = model_from_database[i] + + return cls(**parameters) + + # PUBLIC DATABASE INTERACTION METHODS + + @classmethod + def from_primary_key(cls, primary_key_tuple): + """Initialize a Model by fetching it by its primary key tuple. + + If the primary key does not exist in the database, return a stub. + """ + + query = 'SELECT * FROM {} WHERE {}'.format( + cls.TABLE_NAME, + cls._generate_primary_key_string() + ) + + # Return an instantiation of the Model with values from the row if it exists + + model = cls._from_database(query, primary_key_tuple) + if model is not None: + return model + + # Return a stub instantiation of the Model with just the primary key if it does not + + parameters = {} + for i, column in enumerate(cls.COLUMNS_PRIMARY_KEY): + parameters[column] = primary_key_tuple[i] + + return cls(**parameters) + + @classmethod + def query(cls, column_name=None, value=None): + """Return all instances of the Model in the database where column_name = value.""" + + if column_name is not None and value is not None: + statement = 'SELECT * FROM {} WHERE {} = ?'.format(cls.TABLE_NAME, column_name) + database_models = database.fetchall(statement, (value,)) + + else: + statement = 'SELECT * FROM {}'.format(cls.TABLE_NAME) + database_models = database.fetchall(statement) + + models = [] + + for database_model in database_models: + + parameters = {} + for i, parameter in enumerate(cls.COLUMNS): + parameters[parameter] = database_model[i] + + models.append(cls(**parameters)) + + return models + + def delete(self): + """Delete this Model from the database.""" + + self.read() + + statement = 'DELETE FROM {} WHERE {}'.format( + self.TABLE_NAME, + self._generate_primary_key_string() + ) + + values = self._generate_primary_key_tuple() + + database.execute(statement, values) + + def exists(self, column=None): + """Return True if this Model exists in the database. + + Check the primary key by default, or a column if one is specified. + """ + + query = """ + SELECT EXISTS ( + SELECT 1 FROM {} + WHERE {} + LIMIT 1 + ) + """ + + if column is None: + query = query.format( + self.TABLE_NAME, + self._generate_primary_key_string() + ) + values = self._generate_primary_key_tuple() + + else: + query = query.format( + self.TABLE_NAME, + '{} = ?'.format(column) + ) + values = (getattr(self, column),) + + return database.fetchone(query, values)[0] == 1 + + def insert(self): + """Insert this Model into the database.""" + + if hasattr(self, 'id'): + self.id = None + + self.insert_with_id() + + def insert_with_id(self): + """Insert this Model into the database without removing its id.""" + + statement = 'INSERT INTO {} ({}) VALUES ({})'.format( + self.TABLE_NAME, + self._generate_insert_columns_string(), + self._generate_insert_placeholders_string() + ) + + values = self._generate_insert_columns_tuple() + + try: + last_row_id = database.execute(statement, values) + except Exception as e: + raise exceptions.ForeignKeyError(e.message) + + if 'id' in self.COLUMNS_PRIMARY_KEY: + setattr(self, 'id', last_row_id) + self.read() + + def read(self): + """Read this Model's non-primary key attributes from the database.""" + + if not self.exists(): + raise exceptions.RowNotFoundError(self.TABLE_NAME) + + database_model = self.from_primary_key(self._generate_primary_key_tuple()) + + for attribute in self.COLUMNS: + setattr(self, attribute, getattr(database_model, attribute)) + + return self + + def update(self): + """Update this Model's non-primary key attributes in the database.""" + + statement = 'UPDATE {} SET {} WHERE {}'.format( + self.TABLE_NAME, + self._generate_update_columns_string(), + self._generate_primary_key_string() + ) + + values = self._generate_update_columns_tuple() + self._generate_primary_key_tuple() + + try: + database.execute(statement, values) + except Exception as e: + raise exceptions.ForeignKeyError(e.message) diff --git a/opendc/models/object.py b/opendc/models/object.py new file mode 100644 index 00000000..4103107a --- /dev/null +++ b/opendc/models/object.py @@ -0,0 +1,20 @@ +from opendc.models.model import Model +from opendc.util import database, exceptions + +class Object(Model): + + JSON_TO_PYTHON_DICT = { + 'Object': { + 'id': 'id', + 'type': 'type' + } + } + + TABLE_NAME = 'objects' + COLUMNS = ['id', 'type'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Tile.""" + + return True diff --git a/opendc/models/path.py b/opendc/models/path.py new file mode 100644 index 00000000..6ce29b9b --- /dev/null +++ b/opendc/models/path.py @@ -0,0 +1,35 @@ +from opendc.models.authorization import Authorization +from opendc.models.model import Model +from opendc.models.user import User +from opendc.util import database, exceptions + +class Path(Model): + + JSON_TO_PYTHON_DICT = { + 'Path': { + 'id': 'id', + 'simulationId': 'simulation_id', + 'name': 'name', + 'datetimeCreated': 'datetime_created' + } + } + + TABLE_NAME = 'paths' + COLUMNS = ['id', 'simulation_id', 'name', 'datetime_created'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Path.""" + + # Get the User id + + try: + user_id = User.from_google_id(google_id).read().id + except exceptions.RowNotFoundError: + return False + + # Check the Authorization + + authorization = Authorization.from_primary_key((user_id, self.simulation_id)) + + return authorization.has_at_least(authorization_level) diff --git a/opendc/models/queued_experiment.py b/opendc/models/queued_experiment.py new file mode 100644 index 00000000..fbaed9cb --- /dev/null +++ b/opendc/models/queued_experiment.py @@ -0,0 +1,15 @@ +from opendc.models.model import Model +from opendc.models.experiment import Experiment +from opendc.util import database, exceptions + +class QueuedExperiment(Model): + + JSON_TO_PYTHON_DICT = { + 'QueuedExperiment': { + 'experimentId': 'experiment_id' + } + } + + TABLE_NAME = 'queued_experiments' + COLUMNS = ['experiment_id'] + COLUMNS_PRIMARY_KEY = ['experiment_id'] diff --git a/opendc/models/rack.py b/opendc/models/rack.py new file mode 100644 index 00000000..a9aeeff9 --- /dev/null +++ b/opendc/models/rack.py @@ -0,0 +1,61 @@ +from opendc.models.model import Model +from opendc.models.tile import Tile +from opendc.models.object import Object +from opendc.util import database, exceptions + +class Rack(Model): + + JSON_TO_PYTHON_DICT = { + 'rack': { + 'id': 'id', + 'name': 'name', + 'capacity': 'capacity', + 'powerCapacityW': 'power_capacity_w' + } + } + + PATH = '/v1/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles/{tileId}/rack' + + TABLE_NAME = 'racks' + COLUMNS = ['id', 'name', 'capacity', 'power_capacity_w'] + COLUMNS_PRIMARY_KEY = ['id'] + + @classmethod + def from_tile_id(cls, tile_id): + """Get a Rack from the ID of the Tile it's on.""" + + tile = Tile.from_primary_key((tile_id,)) + + if not tile.exists(): + return Rack(id = -1) + + return cls.from_primary_key((tile.object_id,)) + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Rack.""" + + # Get the Tile + + try: + tile = Tile.query('object_id', self.id)[0] + except: + return False + + # Check the Tile's Authorization + + return tile.google_id_has_at_least(google_id, authorization_level) + + def insert(self): + """Insert a Rack by first inserting an object.""" + + obj = Object(type = 'RACK') + obj.insert() + + self.id = obj.id + self.insert_with_id() + + def delete(self): + """Delete a Rack by deleting its associated object.""" + + obj = Object.from_primary_key((self.id,)) + obj.delete() diff --git a/opendc/models/rack_state.py b/opendc/models/rack_state.py new file mode 100644 index 00000000..77cafd95 --- /dev/null +++ b/opendc/models/rack_state.py @@ -0,0 +1,74 @@ +from opendc.models.model import Model +from opendc.util import database + +class RackState(Model): + + JSON_TO_PYTHON_DICT = { + 'RackState': { + 'rackId': 'rack_id', + 'loadFraction': 'load_fraction', + 'tick': 'tick' + } + } + + @classmethod + def _from_database_row(cls, row): + """Instantiate a RackState from a database row.""" + + return cls( + rack_id = row[0], + load_fraction = row[1], + tick = row[2] + ) + + @classmethod + def from_experiment_id(cls, experiment_id): + """Query RackStates by their Experiment id.""" + + rack_states = [] + + statement = ''' + SELECT racks.id, avg(machine_states.load_fraction), machine_states.tick + FROM racks + JOIN machines ON racks.id = machines.rack_id + JOIN machine_states ON machines.id = machine_states.machine_id + WHERE machine_states.experiment_id = ? + GROUP BY machine_states.tick, racks.id + ''' + results = database.fetchall(statement, (experiment_id,)) + + for row in results: + rack_states.append(cls._from_database_row(row)) + + return rack_states + + @classmethod + def from_experiment_id_and_tick(cls, experiment_id, tick): + """Query RackStates by their Experiment id.""" + + rack_states = [] + + statement = ''' + SELECT racks.id, avg(machine_states.load_fraction), machine_states.tick + FROM racks + JOIN machines ON racks.id = machines.rack_id + JOIN machine_states ON machines.id = machine_states.machine_id + WHERE machine_states.experiment_id = ? + AND machine_states.tick = ? + GROUP BY machine_states.tick, racks.id + ''' + results = database.fetchall(statement, (experiment_id, tick)) + + for row in results: + rack_states.append(cls._from_database_row(row)) + + return rack_states + + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this RackState.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/room.py b/opendc/models/room.py new file mode 100644 index 00000000..b8be88f9 --- /dev/null +++ b/opendc/models/room.py @@ -0,0 +1,34 @@ +from opendc.models.model import Model +from opendc.models.datacenter import Datacenter +from opendc.util import database, exceptions + +class Room(Model): + + JSON_TO_PYTHON_DICT = { + 'room': { + 'id': 'id', + 'datacenterId': 'datacenter_id', + 'name': 'name', + 'roomType': 'type' + } + } + + PATH = '/v1/simulations/{simulationId}/datacenters/{datacenterId}/rooms' + + TABLE_NAME = 'rooms' + COLUMNS = ['id', 'name', 'datacenter_id', 'type'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Room.""" + + # Get the Datacenter + + try: + datacenter = Datacenter.from_primary_key((self.datacenter_id,)) + except exceptions.RowNotFoundError: + return False + + # Check the Datacenter's Authorization + + return datacenter.google_id_has_at_least(google_id, authorization_level) diff --git a/opendc/models/room_state.py b/opendc/models/room_state.py new file mode 100644 index 00000000..7dd151e6 --- /dev/null +++ b/opendc/models/room_state.py @@ -0,0 +1,82 @@ +from opendc.models.model import Model +from opendc.util import database + +class RoomState(Model): + + JSON_TO_PYTHON_DICT = { + 'RoomState': { + 'roomId': 'room_id', + 'loadFraction': 'load_fraction', + 'tick': 'tick' + } + } + + @classmethod + def _from_database_row(cls, row): + """Instantiate a RoomState from a database row.""" + + return cls( + room_id = row[0], + load_fraction = row[1], + tick = row[2] + ) + + @classmethod + def from_experiment_id(cls, experiment_id): + """Query RoomStates by their Experiment id.""" + + room_states = [] + + statement = ''' + SELECT rooms.id, avg(machine_states.load_fraction), machine_states.tick + FROM rooms + JOIN tiles ON rooms.id = tiles.room_id + JOIN objects ON tiles.object_id = objects.id + JOIN racks ON objects.id = racks.id + JOIN machines ON racks.id = machines.rack_id + JOIN machine_states ON machines.id = machine_states.machine_id + WHERE objects.type = "RACK" + AND machine_states.experiment_id = ? + GROUP BY machine_states.tick, rooms.id + ''' + results = database.fetchall(statement, (experiment_id,)) + + for row in results: + room_states.append(cls._from_database_row(row)) + + return room_states + + @classmethod + def from_experiment_id_and_tick(cls, experiment_id, tick): + """Query RoomStates by their Experiment id.""" + + room_states = [] + + statement = ''' + SELECT rooms.id, avg(machine_states.load_fraction), machine_states.tick + FROM rooms + JOIN tiles ON rooms.id = tiles.room_id + JOIN objects ON tiles.object_id = objects.id + JOIN racks ON objects.id = racks.id + JOIN machines ON racks.id = machines.rack_id + JOIN machine_states ON machines.id = machine_states.machine_id + WHERE objects.type = "RACK" + AND machine_states.experiment_id = ? + AND machine_states.tick = ? + GROUP BY rooms.id + ''' + results = database.fetchall(statement, (experiment_id, tick)) + + for row in results: + room_states.append(cls._from_database_row(row)) + + return room_states + + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this RackState.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/room_type.py b/opendc/models/room_type.py new file mode 100644 index 00000000..73b06cc1 --- /dev/null +++ b/opendc/models/room_type.py @@ -0,0 +1,21 @@ +from opendc.models.model import Model + +class RoomType(Model): + + JSON_TO_PYTHON_DICT = { + 'RoomType': { + 'name': 'name' + } + } + + TABLE_NAME = 'room_types' + COLUMNS = ['name'] + COLUMNS_PRIMARY_KEY = ['name'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this RoomType.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/scheduler.py b/opendc/models/scheduler.py new file mode 100644 index 00000000..9d78ec6f --- /dev/null +++ b/opendc/models/scheduler.py @@ -0,0 +1,18 @@ +from opendc.models.model import Model + +class Scheduler(Model): + + JSON_TO_PYTHON_DICT = { + 'Scheduler': { + 'name': 'name' + } + } + + TABLE_NAME = 'schedulers' + COLUMNS = ['name'] + COLUMNS_PRIMARY_KEY = ['name'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Scheduler.""" + + return authorization_level not in ['EDIT', 'OWN'] diff --git a/opendc/models/section.py b/opendc/models/section.py new file mode 100644 index 00000000..5434cdfb --- /dev/null +++ b/opendc/models/section.py @@ -0,0 +1,32 @@ +from opendc.models.model import Model +from opendc.models.path import Path +from opendc.util import database, exceptions + +class Section(Model): + + JSON_TO_PYTHON_DICT = { + 'Section': { + 'id': 'id', + 'pathId': 'path_id', + 'datacenterId': 'datacenter_id', + 'startTick': 'start_tick' + } + } + + TABLE_NAME = 'sections' + COLUMNS = ['id', 'path_id', 'datacenter_id', 'start_tick'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Section.""" + + # Get the Path + + try: + path = Path.from_primary_key((self.path_id,)) + except exceptions.RowNotFoundError: + return False + + # Check the Path's Authorization + + return path.google_id_has_at_least(google_id, authorization_level) diff --git a/opendc/models/simulation.py b/opendc/models/simulation.py new file mode 100644 index 00000000..b698867c --- /dev/null +++ b/opendc/models/simulation.py @@ -0,0 +1,41 @@ +import json + +from opendc.models.authorization import Authorization +from opendc.models.model import Model +from opendc.models.user import User +from opendc.util import database, exceptions + +class Simulation(Model): + + JSON_TO_PYTHON_DICT = { + 'Simulation': { + 'id': 'id', + 'name': 'name', + 'datetimeCreated': 'datetime_created', + 'datetimeLastEdited': 'datetime_last_edited' + } + } + + TABLE_NAME = 'simulations' + COLUMNS = ['id', 'datetime_created', 'datetime_last_edited', 'name'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Simulation.""" + + # Get the User id + + try: + user_id = User.from_google_id(google_id).read().id + except exceptions.RowNotFoundError: + return False + + # Get the Simulation id + + simulation_id = self.id + + # Check the Authorization + + authorization = Authorization.from_primary_key((user_id, simulation_id)) + + return authorization.has_at_least(authorization_level) diff --git a/opendc/models/storage.py b/opendc/models/storage.py new file mode 100644 index 00000000..e82fa0b3 --- /dev/null +++ b/opendc/models/storage.py @@ -0,0 +1,41 @@ +from opendc.models.model import Model + +class Storage(Model): + + JSON_TO_PYTHON_DICT = { + 'Storage': { + 'id': 'id', + 'manufacturer': 'manufacturer', + 'family': 'family', + 'generation': 'generation', + 'model': 'model', + 'speedMbPerS': 'speed_mb_per_s', + 'sizeMb': 'size_mb', + 'energyConsumptionW': 'energy_consumption_w', + 'failureModelId': 'failure_model_id' + } + } + + TABLE_NAME = 'storages' + + COLUMNS = [ + 'id', + 'manufacturer', + 'family', + 'generation', + 'model', + 'speed_mb_per_s', + 'size_mb', + 'energy_consumption_w', + 'failure_model_id' + ] + + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this Storage.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/task.py b/opendc/models/task.py new file mode 100644 index 00000000..8ec03568 --- /dev/null +++ b/opendc/models/task.py @@ -0,0 +1,22 @@ +from opendc.models.model import Model + +class Task(Model): + + JSON_TO_PYTHON_DICT = { + 'Task': { + 'id': 'id', + 'startTick': 'start_tick', + 'totalFlopCount': 'total_flop_count', + 'traceId': 'trace_id', + 'taskDependencyId': 'task_dependency_id' + } + } + + TABLE_NAME = 'tasks' + COLUMNS = ['id', 'start_tick', 'total_flop_count', 'trace_id', 'task_dependency_id'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Task.""" + + return authorization_level not in ['EDIT', 'OWN'] diff --git a/opendc/models/task_duration.py b/opendc/models/task_duration.py new file mode 100644 index 00000000..31334040 --- /dev/null +++ b/opendc/models/task_duration.py @@ -0,0 +1,47 @@ +from opendc.models.model import Model +from opendc.util import database + +class TaskDuration(Model): + + JSON_TO_PYTHON_DICT = { + 'TaskDuration': { + 'taskId': 'task_id', + 'duration': 'duration' + } + } + + @classmethod + def _from_database_row(cls, row): + """Instantiate a RoomState from a database row.""" + + return cls( + task_id = row[0], + duration = row[1] + ) + + @classmethod + def from_experiment_id(cls, experiment_id): + """Query RoomStates by their Experiment id.""" + + room_states = [] + + statement = ''' + SELECT task_id, MAX(tick) - MIN(tick) as duration FROM task_states + WHERE experiment_id = ? + GROUP BY task_id + ''' + + results = database.fetchall(statement, (experiment_id,)) + + for row in results: + room_states.append(cls._from_database_row(row)) + + return room_states + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this TaskDuration.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/task_state.py b/opendc/models/task_state.py new file mode 100644 index 00000000..6569ec79 --- /dev/null +++ b/opendc/models/task_state.py @@ -0,0 +1,49 @@ +from opendc.models.model import Model +from opendc.util import database + +class TaskState(Model): + + JSON_TO_PYTHON_DICT = { + 'TaskState': { + 'id': 'id', + 'taskId': 'task_id', + 'experimentId': 'experiment_id', + 'tick': 'tick', + 'flopsLeft': 'flops_left' + } + } + + TABLE_NAME = 'task_states' + + COLUMNS = ['id', 'task_id', 'experiment_id', 'tick', 'flops_left'] + COLUMNS_PRIMARY_KEY = ['id'] + + @classmethod + def from_experiment_id_and_tick(cls, experiment_id, tick): + """Query Task States by their Experiment id and tick.""" + + task_states = [] + + statement = 'SELECT * FROM task_states WHERE experiment_id = ? AND tick = ?' + results = database.fetchall(statement, (experiment_id, tick)) + + for row in results: + task_states.append( + cls( + id = row[0], + task_id = row[1], + experiment_id = row[2], + tick = row[3], + flops_left = row[4] + ) + ) + + return task_states + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the Use rhas at least the given auth level over this TaskState.""" + + if authorization_level in ['EDIT', 'OWN']: + return False + + return True diff --git a/opendc/models/tile.py b/opendc/models/tile.py new file mode 100644 index 00000000..95445419 --- /dev/null +++ b/opendc/models/tile.py @@ -0,0 +1,47 @@ +from opendc.models.model import Model +from opendc.models.room import Room +from opendc.models.object import Object +from opendc.util import database, exceptions + +class Tile(Model): + + JSON_TO_PYTHON_DICT = { + 'tile': { + 'id': 'id', + 'roomId': 'room_id', + 'objectId': 'object_id', + 'objectType': 'object_type', + 'positionX': 'position_x', + 'positionY': 'position_y' + } + } + + PATH = '/v1/simulations/{simulationId}/datacenters/{datacenterId}/rooms/{roomId}/tiles' + + TABLE_NAME = 'tiles' + COLUMNS = ['id', 'position_x', 'position_y', 'room_id', 'object_id'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Tile.""" + + # Get the Room + + try: + room = Room.from_primary_key((self.room_id,)) + except exceptions.RowNotFoundError: + return False + + # Check the Room's Authorization + + return room.google_id_has_at_least(google_id, authorization_level) + + def read(self): + """Read this Tile by also getting its associated object type.""" + + super(Tile, self).read() + + if self.object_id is not None: + + obj = Object.from_primary_key((self.object_id,)) + self.object_type = obj.type diff --git a/opendc/models/trace.py b/opendc/models/trace.py new file mode 100644 index 00000000..ce8d4923 --- /dev/null +++ b/opendc/models/trace.py @@ -0,0 +1,19 @@ +from opendc.models.model import Model + +class Trace(Model): + + JSON_TO_PYTHON_DICT = { + 'Trace': { + 'id': 'id', + 'name': 'name' + } + } + + TABLE_NAME = 'traces' + COLUMNS = ['id', 'name'] + COLUMNS_PRIMARY_KEY = ['id'] + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the user has at least the given auth level over this Trace.""" + + return authorization_level not in ['EDIT', 'OWN'] diff --git a/opendc/models/user.py b/opendc/models/user.py new file mode 100644 index 00000000..9c716470 --- /dev/null +++ b/opendc/models/user.py @@ -0,0 +1,49 @@ +import json + +from opendc.models.model import Model + +class User(Model): + + JSON_TO_PYTHON_DICT = { + 'User': { + 'id': 'id', + 'googleId': 'google_id', + 'email': 'email', + 'givenName': 'given_name', + 'familyName': 'family_name' + } + } + + TABLE_NAME = 'users' + COLUMNS = ['id', 'google_id', 'email', 'given_name', 'family_name'] + COLUMNS_PRIMARY_KEY = ['id'] + + @classmethod + def from_google_id(cls, google_id): + """Initialize a User by fetching them by their google id.""" + + user = cls._from_database('SELECT * FROM users WHERE google_id = ?', (google_id,)) + + if user is not None: + return user + + return User() + + @classmethod + def from_email(cls, email): + """Initialize a User by fetching them by their email.""" + + user = cls._from_database('SELECT * FROM users WHERE email = ?', (email,)) + + if user is not None: + return user + + return User() + + def google_id_has_at_least(self, google_id, authorization_level): + """Return True if the User has at least the given auth level over this User.""" + + if authorization_level in ['EDIT', 'OWN']: + return google_id == self.google_id + + return True |