build: Migrate to flat project structure

This change updates the project structure to become flattened.
Previously, the simulator, frontend and API each lived into their own
directory.

With this change, all modules of the project live in the top-level
directory of the repository. This should improve discoverability of
modules of the project.

1 files changed, 0 insertions, 229 deletions

diff --git a/frontend/src/sagas/objects.js b/frontend/src/sagas/objects.js
deleted file mode 100644
index 313d9976..00000000
--- a/frontend/src/sagas/objects.js
+++ /dev/null
@@ -1,229 +0,0 @@
-import { call, put, select } from 'redux-saga/effects'
-import { addToStore } from '../actions/objects'
-import { getAllSchedulers } from '../api/routes/schedulers'
-import { getProject } from '../api/routes/projects'
-import { getAllTraces } from '../api/routes/traces'
-import { getUser } from '../api/routes/users'
-import { getTopology, updateTopology } from '../api/routes/topologies'
-import { uuid } from 'uuidv4'
-
-export const OBJECT_SELECTORS = {
-    project: (state) => state.objects.project,
-    user: (state) => state.objects.user,
-    authorization: (state) => state.objects.authorization,
-    portfolio: (state) => state.objects.portfolio,
-    scenario: (state) => state.objects.scenario,
-    cpu: (state) => state.objects.cpu,
-    gpu: (state) => state.objects.gpu,
-    memory: (state) => state.objects.memory,
-    storage: (state) => state.objects.storage,
-    machine: (state) => state.objects.machine,
-    rack: (state) => state.objects.rack,
-    tile: (state) => state.objects.tile,
-    room: (state) => state.objects.room,
-    topology: (state) => state.objects.topology,
-}
-
-function* fetchAndStoreObject(objectType, id, apiCall) {
-    const objectStore = yield select(OBJECT_SELECTORS[objectType])
-    let object = objectStore[id]
-    if (!object) {
-        object = yield apiCall
-        yield put(addToStore(objectType, object))
-    }
-    return object
-}
-
-function* fetchAndStoreObjects(objectType, apiCall) {
-    const objects = yield apiCall
-    for (let object of objects) {
-        yield put(addToStore(objectType, object))
-    }
-    return objects
-}
-
-export const fetchAndStoreProject = (id) => fetchAndStoreObject('project', id, call(getProject, id))
-
-export const fetchAndStoreUser = (id) => fetchAndStoreObject('user', id, call(getUser, id))
-
-export const fetchAndStoreTopology = function* (id) {
-    const topologyStore = yield select(OBJECT_SELECTORS['topology'])
-    const roomStore = yield select(OBJECT_SELECTORS['room'])
-    const tileStore = yield select(OBJECT_SELECTORS['tile'])
-    const rackStore = yield select(OBJECT_SELECTORS['rack'])
-    const machineStore = yield select(OBJECT_SELECTORS['machine'])
-
-    let topology = topologyStore[id]
-    if (!topology) {
-        const fullTopology = yield call(getTopology, id)
-
-        for (let roomIdx in fullTopology.rooms) {
-            const fullRoom = fullTopology.rooms[roomIdx]
-
-            generateIdIfNotPresent(fullRoom)
-
-            if (!roomStore[fullRoom._id]) {
-                for (let tileIdx in fullRoom.tiles) {
-                    const fullTile = fullRoom.tiles[tileIdx]
-
-                    generateIdIfNotPresent(fullTile)
-
-                    if (!tileStore[fullTile._id]) {
-                        if (fullTile.rack) {
-                            const fullRack = fullTile.rack
-
-                            generateIdIfNotPresent(fullRack)
-
-                            if (!rackStore[fullRack._id]) {
-                                for (let machineIdx in fullRack.machines) {
-                                    const fullMachine = fullRack.machines[machineIdx]
-
-                                    generateIdIfNotPresent(fullMachine)
-
-                                    if (!machineStore[fullMachine._id]) {
-                                        let machine = (({ _id, position, cpus, gpus, memories, storages }) => ({
-                                            _id,
-                                            rackId: fullRack._id,
-                                            position,
-                                            cpuIds: cpus.map((u) => u._id),
-                                            gpuIds: gpus.map((u) => u._id),
-                                            memoryIds: memories.map((u) => u._id),
-                                            storageIds: storages.map((u) => u._id),
-                                        }))(fullMachine)
-                                        yield put(addToStore('machine', machine))
-                                    }
-                                }
-
-                                const filledSlots = new Array(fullRack.capacity).fill(null)
-                                fullRack.machines.forEach(
-                                    (machine) => (filledSlots[machine.position - 1] = machine._id)
-                                )
-                                let rack = (({ _id, name, capacity, powerCapacityW }) => ({
-                                    _id,
-                                    name,
-                                    capacity,
-                                    powerCapacityW,
-                                    machineIds: filledSlots,
-                                }))(fullRack)
-                                yield put(addToStore('rack', rack))
-                            }
-                        }
-
-                        let tile = (({ _id, positionX, positionY, rack }) => ({
-                            _id,
-                            roomId: fullRoom._id,
-                            positionX,
-                            positionY,
-                            rackId: rack ? rack._id : undefined,
-                        }))(fullTile)
-                        yield put(addToStore('tile', tile))
-                    }
-                }
-
-                let room = (({ _id, name, tiles }) => ({ _id, name, tileIds: tiles.map((t) => t._id) }))(fullRoom)
-                yield put(addToStore('room', room))
-            }
-        }
-
-        topology = (({ _id, name, rooms }) => ({ _id, name, roomIds: rooms.map((r) => r._id) }))(fullTopology)
-        yield put(addToStore('topology', topology))
-
-        // TODO consider pushing the IDs
-    }
-
-    return topology
-}
-
-const generateIdIfNotPresent = (obj) => {
-    if (!obj._id) {
-        obj._id = uuid()
-    }
-}
-
-export const updateTopologyOnServer = function* (id) {
-    const topology = yield getTopologyAsObject(id, true)
-
-    yield call(updateTopology, topology)
-}
-
-export const getTopologyAsObject = function* (id, keepIds) {
-    const topologyStore = yield select(OBJECT_SELECTORS['topology'])
-    const rooms = yield getAllRooms(topologyStore[id].roomIds, keepIds)
-    return {
-        _id: keepIds ? id : undefined,
-        name: topologyStore[id].name,
-        rooms: rooms,
-    }
-}
-
-export const getAllRooms = function* (roomIds, keepIds) {
-    const roomStore = yield select(OBJECT_SELECTORS['room'])
-
-    let rooms = []
-
-    for (let id of roomIds) {
-        let tiles = yield getAllRoomTiles(roomStore[id], keepIds)
-        rooms.push({
-            _id: keepIds ? id : undefined,
-            name: roomStore[id].name,
-            tiles: tiles,
-        })
-    }
-    return rooms
-}
-
-export const getAllRoomTiles = function* (roomStore, keepIds) {
-    let tiles = []
-
-    for (let id of roomStore.tileIds) {
-        tiles.push(yield getTileById(id, keepIds))
-    }
-    return tiles
-}
-
-export const getTileById = function* (id, keepIds) {
-    const tileStore = yield select(OBJECT_SELECTORS['tile'])
-    return {
-        _id: keepIds ? id : undefined,
-        positionX: tileStore[id].positionX,
-        positionY: tileStore[id].positionY,
-        rack: !tileStore[id].rackId ? undefined : yield getRackById(tileStore[id].rackId, keepIds),
-    }
-}
-
-export const getRackById = function* (id, keepIds) {
-    const rackStore = yield select(OBJECT_SELECTORS['rack'])
-    const machineStore = yield select(OBJECT_SELECTORS['machine'])
-    const cpuStore = yield select(OBJECT_SELECTORS['cpu'])
-    const gpuStore = yield select(OBJECT_SELECTORS['gpu'])
-    const memoryStore = yield select(OBJECT_SELECTORS['memory'])
-    const storageStore = yield select(OBJECT_SELECTORS['storage'])
-
-    return {
-        _id: keepIds ? rackStore[id]._id : undefined,
-        name: rackStore[id].name,
-        capacity: rackStore[id].capacity,
-        powerCapacityW: rackStore[id].powerCapacityW,
-        machines: rackStore[id].machineIds
-            .filter((m) => m !== null)
-            .map((machineId) => ({
-                _id: keepIds ? machineId : undefined,
-                position: machineStore[machineId].position,
-                cpus: machineStore[machineId].cpuIds.map((id) => cpuStore[id]),
-                gpus: machineStore[machineId].gpuIds.map((id) => gpuStore[id]),
-                memories: machineStore[machineId].memoryIds.map((id) => memoryStore[id]),
-                storages: machineStore[machineId].storageIds.map((id) => storageStore[id]),
-            })),
-    }
-}
-
-export const fetchAndStoreAllTraces = () => fetchAndStoreObjects('trace', call(getAllTraces))
-
-export const fetchAndStoreAllSchedulers = function* () {
-    const objects = yield call(getAllSchedulers)
-    for (let object of objects) {
-        object._id = object.name
-        yield put(addToStore('scheduler', object))
-    }
-    return objects
-}