V0.8.0 Arroyo Toad

Fixed problems related to concurrency and segmentation faults

Sources/IoT-Simulator-Core/Classes/Devices/EdgeDevice.swift

@@ -3,22 +3,23 @@ import DataAcquisition
 import Foundation
 import MessageUtils
 
-public class EdgeDevice: EdgeDeviceP, @unchecked Sendable {
+public actor EdgeDevice:  @preconcurrency EdgeDeviceP {
+    
+
    
     public let deviceID: UInt128
     public let deviceType: DeviceType
     public let dataType: DataType
-    public var disconnected: Bool 
+    public private(set) var disconnected: Bool 
-    public var compromised: Bool
+    public private(set) var compromised: Bool
-    public var location: Location
+    public private(set) var location: Location
-    public var dutyCicle: UInt
+    public private(set) var dutyCicle: UInt
-    public var sensors: [Int: Sensor]
+    public private(set) var sensors: [Int: Sensor]
-    public var privateKey: P256.Signing.PrivateKey
+    public private(set) var privateKey: P256.Signing.PrivateKey
     public var publicKey: P256.Signing.PublicKey {
         return self.privateKey.publicKey
     }
 
-    private let lock: NSLock
     private var numberOfSensors: Int {
         return sensors.count
     }
@@ -41,24 +42,54 @@ public class EdgeDevice: EdgeDeviceP, @unchecked Sendable {
         self.dutyCicle = dutyCicle
         self.sensors = sensors
         self.privateKey = privateKey
-        self.lock = NSLock()
+        
     }
 
-    public func addSensor(sensor: Sensor) {
+    public func addSensor(sensor: Sensor) async {
-        self.lock.lock()
         self.sensors[numberOfSensors + 1] = sensor
-        self.lock.unlock()
     }
 
-    public func removeSensor(id: Int) {
+    public func removeSensor(id: Int) async {
-        self.lock.lock()
         self.sensors.removeValue(forKey: id)
-        self.lock.unlock()
     }
 
-    public func work(envrionment: PhysicalEnvironment) throws -> Data {
+    public func setSensorFaulty(id: Int) async {
+        if id > self.numberOfSensors {
+            // UGLY: Do nothing
+        }
+
+        let sensor = self.sensors[id]!
+        
+        await sensor.toggleFaulty()
+    }
+
+     public func setDisconnected(disconnected: Bool) async {
+        self.disconnected = disconnected
+    }
+
+    public func setCompromised(compromised: Bool) async {
+        self.compromised = compromised
+    }
+
+    public func setLocation(location: Location) async {
+        self.location = location
+    }
+
+    public func dutyCycle(time: UInt) async {
+        self.dutyCicle = time
+    }
+
+    private func getSensor(id: Int) async -> Sensor {
+       if id > self.numberOfSensors {
+            // UGLY: Do nothing
+        }
+
+        return self.sensors[id]!
+    }
+
+    public func work(envrionment: PhysicalEnvironment) async throws -> Data {
+
         
-        self.lock.lock()
 
         // UGLY: Declaring here some variables manually, remove them if you want to offere flexibility
         let numberOfSamples: Int = 10
@@ -75,7 +106,7 @@ public class EdgeDevice: EdgeDeviceP, @unchecked Sendable {
 
         for rowI in 0..<numberOfSamples {
             for colI in 0..<self.sensors.count {
-                rowPointer[rowI]![colI] = self.sensors[colI]!.read(envrionment).value
+                rowPointer[rowI]![colI] = await self.getSensor(id: colI).read(envrionment).value
             }
         }
 
@@ -105,7 +136,7 @@ public class EdgeDevice: EdgeDeviceP, @unchecked Sendable {
 
         msgData.append(Data(signature))
 
-        self.lock.unlock()
+        
 
         return msgData
     }

Sources/IoT-Simulator-Core/Classes/Devices/Sensors.swift

@@ -1,10 +1,22 @@
 import RandomCpp
 
-public class Sensor {
+public protocol Sensor : Sendable {
+    var sensorID: Int { get }
+    var sensorType: DataType { get }
+    var faulty: Bool { get }
+
+    func setFaulty(value: Bool) async
+
+    func toggleFaulty() async
+
+    func read(_ environment: PhysicalEnvironment) async -> PhysicalData
+}
+
+public actor IdealSensor: @preconcurrency Sensor {
 
     public let sensorID: Int
     public let sensorType: DataType
-    public var faulty: Bool
+    public private(set) var faulty: Bool
 
     public init(id: Int, sensorType: DataType, faulty: Bool) {
         self.sensorID = id
@@ -18,25 +30,25 @@ public class Sensor {
         self.faulty = false
     }
 
-    public func read(_ environment: PhysicalEnvironment) -> PhysicalData {
+    public func read(_ environment: PhysicalEnvironment) async -> PhysicalData {
 
-        let datum = self._read(environment)
+        let datum = await self._read(environment)
 
         return !self.faulty ? datum : datum + Float.random(in: 1E2...1E10)
 
     }
 
-    internal func _read(_ environment: PhysicalEnvironment) -> PhysicalData{
+    internal func _read(_ environment: PhysicalEnvironment) async -> PhysicalData {
-        let datum : PhysicalData
+        let datum: PhysicalData
 
         do {
-            datum = try environment.getPhysicalData(self.sensorType)
+            datum = try await environment.getPhysicalData(self.sensorType)
         } catch CoreError.NoPhysicalDataAvailable {
-           datum = self._defaultReadValue()
+            datum = self._defaultReadValue()
         } catch {
             print(
-                "This is really a weird problem, to be investigated, but here we are...\n" +
+                "This is really a weird problem, to be investigated, but here we are...\n"
-                "nonetheless, the error will be handled silently, sowwy :3"
+                    + "nonetheless, the error will be handled silently, sowwy :3"
             )
             datum = self._defaultReadValue()
         }
@@ -44,19 +56,28 @@ public class Sensor {
         return datum
     }
 
-    internal func _defaultReadValue() -> PhysicalData{
+    internal func _defaultReadValue() -> PhysicalData {
         return PhysicalData(self.sensorType, 0)
     }
 
+    public func setFaulty(value: Bool) async {
+        self.faulty = value
+    }
 
+    public func toggleFaulty() async {
+        self.faulty = !self.faulty
+    }
 
 }
 
-public class RealSensor: Sensor {
+public actor RealSensor: @preconcurrency Sensor {
+    public let sensorID: Int
+    public let sensorType: DataType
+    public private(set) var faulty: Bool
 
-    public var meanNoise: Float { get{ return _meanNoise}}
+    public var meanNoise: Float { return _meanNoise }
-    public var stdNoise: Float { get{ return _stdNoise}}
+    public var stdNoise: Float { return _stdNoise }
-    public var quantizationBits: Int { get{ return _quantizationBits}}
+    public var quantizationBits: Int { return _quantizationBits }
 
     private var _meanNoise: Float
     private var _stdNoise: Float
@@ -72,14 +93,16 @@ public class RealSensor: Sensor {
         stdNoise: Float,
         quantizationBits: Int
     ) {
+        self.sensorID = sensorID
+        self.sensorType = sensorType
+        self.faulty = faulty
         self._meanNoise = meanNoise
         self._stdNoise = stdNoise
         self._quantizationBits = quantizationBits
         self._gaussianNoise = GaussianRNG(self._meanNoise, self._stdNoise)
-        super.init(id: sensorID, sensorType: sensorType, faulty: faulty)
     }
 
-    convenience public init(
+    public init(
         sensorID: Int,
         sensorType: DataType,
         meanNoise: Float,
@@ -96,9 +119,44 @@ public class RealSensor: Sensor {
         )
     }
 
-    override public func read(_ environment: PhysicalEnvironment) -> PhysicalData {
+    public func read(_ environment: PhysicalEnvironment) async -> PhysicalData {
-        let value: PhysicalData = super.read(environment)
+
+        let datum = await self._read(environment)
+
+        let value = !self.faulty ? datum : datum + Float.random(in: 1E2...1E10)
+
         return value + self._gaussianNoise.generate()
+
+    }
+
+    internal func _read(_ environment: PhysicalEnvironment) async -> PhysicalData {
+        let datum: PhysicalData
+
+        do {
+            datum = try await environment.getPhysicalData(self.sensorType)
+        } catch CoreError.NoPhysicalDataAvailable {
+            datum = self._defaultReadValue()
+        } catch {
+            print(
+                "This is really a weird problem, to be investigated, but here we are...\n"
+                    + "nonetheless, the error will be handled silently, sowwy :3"
+            )
+            datum = self._defaultReadValue()
+        }
+
+        return datum
+    }
+
+    internal func _defaultReadValue() -> PhysicalData {
+        return PhysicalData(self.sensorType, 0)
+    }
+
+    public func setFaulty(value: Bool) async {
+        self.faulty = value
+    }
+
+    public func toggleFaulty() async {
+        self.faulty = !self.faulty
     }
 
 }

Sources/IoT-Simulator-Core/Classes/Environment/PhysicalEnvironment.swift

@@ -1,6 +1,6 @@
 import Foundation
 
-public class PhysicalEnvironment: @unchecked Sendable {
+public actor PhysicalEnvironment {
 
     private var physicalEnvironment: [DataType: PhysicalData]
     public let location: String

Sources/IoT-Simulator-Core/Classes/Utils/PhysicalData.swift

@@ -1,6 +1,6 @@
 
 
-public class PhysicalData {
+public final class PhysicalData: Sendable {
 
     public let type: DataType
     public let value: Float 

Sources/IoT-Simulator-Core/Enums/DataType.swift

@@ -1,4 +1,4 @@
-public enum DataType : String {
+public enum DataType : String, Sendable {
     case Temperature
     case Humidity
     case Scan

Sources/IoT-Simulator-Core/Factories/DeviceFactories.swift

@@ -7,11 +7,10 @@ public actor DeviceFactory {
     // TODO: Make it possible to set this
     private static var availableIDs: Set<UInt128> = Set(0..<999)
 
-    @MainActor
     public static func createEdgeDevice(
-        deviceID: UInt128,
+        deviceID: sending UInt128,
-        dataType: DataType,
+        dataType: sending DataType,
-        privateKey: P256.Signing.PrivateKey
+        privateKey: sending P256.Signing.PrivateKey
     ) throws -> EdgeDevice {
         return try DeviceFactory.createEdgeDevice(
             deviceID: deviceID,
@@ -21,12 +20,11 @@ public actor DeviceFactory {
         )
     }
 
-    @MainActor
     public static func createEdgeDevice(
-        deviceID: UInt128,
+        deviceID: sending UInt128,
-        dataType: DataType,
+        dataType: sending DataType,
-        privateKey: P256.Signing.PrivateKey,
+        privateKey: sending P256.Signing.PrivateKey,
-        realSensor: Bool
+        realSensor: sending Bool
     ) throws -> EdgeDevice {
 
         return try DeviceFactory.createEdgeDevice(
@@ -43,14 +41,13 @@ public actor DeviceFactory {
         )
     }
 
-    @MainActor
     public static func createEdgeDevice(
-        deviceID: UInt128,
+        deviceID: sending UInt128,
-        dataType: DataType,
+        dataType: sending DataType,
-        location: Location,
+        location: sending Location,
-        dutyCicle: UInt,
+        dutyCicle: sending UInt,
-        privateKey: P256.Signing.PrivateKey,
+        privateKey: sending P256.Signing.PrivateKey,
-        realSensor: Bool
+        realSensor: sending Bool
     ) throws -> EdgeDevice {
 
         if !DeviceFactory.availableIDs.contains(deviceID) {
@@ -64,9 +61,9 @@ public actor DeviceFactory {
 
         if !realSensor {
             sensors = [
-                0: Sensor(id: 0, sensorType: dataType),
+                0: IdealSensor(id: 0, sensorType: dataType),
-                1: Sensor(id: 1, sensorType: dataType),
+                1: IdealSensor(id: 1, sensorType: dataType),
-                2: Sensor(id: 2, sensorType: dataType),
+                2: IdealSensor(id: 2, sensorType: dataType),
             ]
         } else {
             sensors = [
@@ -89,7 +86,8 @@ public actor DeviceFactory {
             location: location,
             dutyCicle: dutyCicle,
             sensors: sensors,
-            privateKey: privateKey)
+            privateKey: privateKey
+        )
     }
 
     public static func getUnusedID() throws -> UInt128 {

Sources/IoT-Simulator-Core/IoT_Simulator_Core.swift

@@ -3,12 +3,13 @@
 
 import Foundation
 
-public actor IoTSimulatorCore {
+@MainActor
+public class IoTSimulatorCore {
 
-    internal static var enviroments: [String: PhysicalEnvironment] = Dictionary()
+    @MainActor internal static var enviroments: [String: PhysicalEnvironment] = Dictionary()
-    internal static var devices: [String: EdgeDeviceP] = Dictionary()
+    @MainActor internal static var devices: [String: EdgeDeviceP] = Dictionary()
-    internal static var env_dev: [String: Set<String>] = Dictionary()
+    @MainActor internal static var env_dev: [String: Set<String>] = Dictionary()
-    internal static var dev_tasks: [String: Task<(), Never>] = Dictionary()
+    @MainActor internal static var dev_tasks: [String: Task<(), Never>] = Dictionary()
 
     public static func addEnv(environment: PhysicalEnvironment) {
         IoTSimulatorCore.enviroments[environment.location] = environment
@@ -31,7 +32,7 @@ public actor IoTSimulatorCore {
 
             // schedule work
             let task = IoTSimulatorCore.schedule(
-                envID: environment.location, deviceID: device.deviceID, success: success,
+                environment: environment, device: device as! EdgeDevice, success: success,
                 failure: failure)
             IoTSimulatorCore.dev_tasks["\(device.deviceID)"] = task
 
@@ -45,12 +46,6 @@ public actor IoTSimulatorCore {
         return IoTSimulatorCore.enviroments[name]
     }
 
-    public static func addPhysicalData(environmentName: String, physicalData: PhysicalData) {
-        if let environment = getEnv(name: environmentName) {
-            environment.setPhysicalData(physicalData.type, physicalData)
-        }
-    }
-
     public static func getDev(devID: UInt128) -> EdgeDeviceP? {
         return IoTSimulatorCore.devices["\(devID)"]
     }
@@ -73,49 +68,44 @@ public actor IoTSimulatorCore {
         return false
     }
 
-    @MainActor
+    public static func toggleSensor(devID: UInt, sensorID: Int) async -> Bool {
-    public static func toggleSensor(devID: UInt128, sensorID: Int) -> Bool {
         
-        // UGLY: Should throw
+        let a = IoTSimulatorCore.getDev(devID: UInt128(devID))!
-        if IoTSimulatorCore.getDev(devID: devID) == nil {
-            return false 
-        }
         
-        // FIXME: Should it throw?
-        if IoTSimulatorCore.getDev(devID: devID)!.deviceType != .EDGE_SENSOR {
-            return false
-        }
 
-        let device = IoTSimulatorCore.getDev(devID: devID)! as! EdgeDevice
+        let device = IoTSimulatorCore.getDev(devID: UInt128(devID))! as! EdgeDevice
 
-        // UGLY: It should throw
+        await device.setSensorFaulty(id: sensorID)
-        if device.sensors.count <= sensorID {
-            return false 
-        }
-
-        device.sensors[sensorID]!.faulty = !device.sensors[sensorID]!.faulty
 
         return true
     }
 
+    public static func addPhysicalData(environmentName: String, physicalData: PhysicalData)
+        async throws
+    {
+        guard let environment = getEnv(name: environmentName) else {
+            throw CoreError.NoEnvironment
+        }
+
+        await environment.setPhysicalData(physicalData.type, physicalData)
+    }
+
     private static func schedule(
-        envID: sending String,
+        environment:  PhysicalEnvironment,
-        deviceID: UInt128,
+        device:  EdgeDevice,
         success: sending @escaping (_ msg: Data) async throws -> Void,
         failure: sending @escaping () -> Void
-    ) -> Task<(), Never>{
+    ) -> Task<(), Never> {
-        let _devID: String = "\(deviceID)"
+
         return Task {
 
             var notCancelled: Bool = true
 
-            let dev = IoTSimulatorCore.getDev(devID: _devID)!
-            let env = IoTSimulatorCore.getEnv(name:envID)!
 
             while notCancelled {
                 // print("Device: \(dev.deviceID)")
                 do {
-                    let message = try dev.work(envrionment: env)
+                    let message = try await device.work(envrionment: environment)
 
                     try await success(message)
                 } catch {
@@ -123,14 +113,14 @@ public actor IoTSimulatorCore {
                 }
 
                 do {
-                    try await Task.sleep(nanoseconds: UInt64(dev.dutyCicle) * UInt64(1E6))
+                    try await Task.sleep(nanoseconds: UInt64(device.dutyCicle) * UInt64(1E6))
                 } catch {
                     notCancelled = false
                 }
 
             }
 
-            print("Bye, Bye, \(dev.deviceID)\n\n")
+            print("Bye, Bye, \(device.deviceID)\n\n")
 
         }
     }

Sources/IoT-Simulator-Core/Protocols/EdgeDeviceProtocol.swift

@@ -7,13 +7,19 @@ public protocol EdgeDeviceP : Sendable{
     var deviceID : UInt128 {get}
     var deviceType : DeviceType {get}
     var dataType : DataType {get}
-    var location: Location{get set}
+    var location: Location{get }
-    var disconnected : Bool {get set}
+    var disconnected : Bool {get }
-    var compromised : Bool {get set}
+    var compromised : Bool {get }
-    var dutyCicle : UInt {get set}
+    var dutyCicle : UInt {get }
     var privateKey: P256.Signing.PrivateKey {get}
     var publicKey: P256.Signing.PublicKey {get}
 
-    func work(envrionment: PhysicalEnvironment) throws ->  Data
+    func work(envrionment: PhysicalEnvironment) async throws ->  Data
+
+    func setDisconnected(disconnected: Bool) async
+    func setCompromised(compromised: Bool) async
+    func dutyCycle(time: UInt) async
+    func setLocation(location: Location) async 
+
 
 }

Tests/IoT-Simulator-CoreTests/Devices-Tests.swift

@@ -11,10 +11,10 @@ import MessageUtils
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
-    let sensor : Sensor = Sensor(id: 1, sensorType: .Temperature)
+    let sensor : IdealSensor = IdealSensor(id: 1, sensorType: .Temperature)
-    let data = sensor.read(env)
+    let data =   await sensor.read(env)
 
 
     #expect(data.value == truth.value, "If values match, we are cool")
@@ -27,10 +27,10 @@ import MessageUtils
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
-    let sensor : Sensor = Sensor(id: 1, sensorType: .Temperature, faulty: true)
+    let sensor : IdealSensor = IdealSensor(id: 1, sensorType: .Temperature, faulty: true)
-    let data = sensor.read(env)
+    let data = await sensor.read(env)
 
 
     #expect(data.value != truth.value, "If these match, something is not working")
@@ -43,10 +43,10 @@ import MessageUtils
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
     let sensor : Sensor = RealSensor(sensorID: 1, sensorType: .Temperature, faulty: false, meanNoise: 0.5, stdNoise: 0.25, quantizationBits: 3)
-    let data = sensor.read(env)
+    let data = await sensor.read(env)
 
 
     #expect(data.value - truth.value < 10, "If these match, we are cool")
@@ -61,10 +61,10 @@ import MessageUtils
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
     let sensor : Sensor = RealSensor(sensorID: 1, sensorType: .Temperature, faulty: true, meanNoise: 0.5, stdNoise: 0.25, quantizationBits: 3)
-    let data = sensor.read(env)
+    let data = await sensor.read(env)
 
 
     #expect(data.value - truth.value > 10, "If these match, something is not working")
@@ -79,22 +79,22 @@ import MessageUtils
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
     let signKeyPath = "./Private/privateKey.pem"
 
     let privateKey = try pem2_P256key(filePath: signKeyPath)
 
-    let dev: EdgeDevice = await EdgeDevice(
+    let dev: EdgeDevice =  EdgeDevice(
         deviceID: 1, 
         dataType: .Temperature, 
         disconnected: false, 
         location: Location(x: 20, y: 10, z: 0), 
         dutyCicle: 100098, 
         sensors: [
-            0: Sensor(id: 0, sensorType: DataType.Temperature),
+            0: IdealSensor(id: 0, sensorType: DataType.Temperature),
-            1: Sensor(id: 0, sensorType: DataType.Temperature),
+            1: IdealSensor(id: 0, sensorType: DataType.Temperature),
-            2: Sensor(id: 0, sensorType: DataType.Temperature, faulty: true)
+            2: IdealSensor(id: 0, sensorType: DataType.Temperature, faulty: true)
         ], 
         privateKey: try pem2_P256key(filePath: signKeyPath)
     )
@@ -121,13 +121,13 @@ import MessageUtils
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
     let signKeyPath = "./Private/privateKey.pem"
 
     let privateKey = try pem2_P256key(filePath: signKeyPath)
 
-    let dev: EdgeDevice = await EdgeDevice(
+    let dev: EdgeDevice =  EdgeDevice(
         deviceID: 1, 
         dataType: .Temperature, 
         disconnected: false, 

Tests/IoT-Simulator-CoreTests/IoTCore-Tests.swift

@@ -10,9 +10,9 @@ import MessageUtils
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
-    IoTSimulatorCore.addEnv(environment: env)
+    await IoTSimulatorCore.addEnv(environment: env)
 
     let signKeyPath = "./Private/privateKey.pem"
 
@@ -36,7 +36,7 @@ import MessageUtils
         privateKey: try pem2_P256key(filePath: signKeyPath)
     )
 
-    let dev2: EdgeDevice = await EdgeDevice(
+    let dev2: EdgeDevice =  EdgeDevice(
         deviceID: 2,
         dataType: .Temperature,
         disconnected: false,
@@ -56,7 +56,7 @@ import MessageUtils
         privateKey: try pem2_P256key(filePath: signKeyPath)
     )
 
-    try IoTSimulatorCore.addDevice(location: "Delta", device: dev, success: { msg in 
+    try await IoTSimulatorCore.addDevice(location: "Delta", device: dev, success: { msg in 
                 print(msg)
                 let _signedMessage = try! deserializeV1(serializedData: msg)
                 print(_signedMessage.toString())
@@ -64,7 +64,7 @@ import MessageUtils
             failure: {
                 print("Something went wrong")
             })
-    try IoTSimulatorCore.addDevice(location: "Delta", device: dev2, success: { msg in 
+    try await IoTSimulatorCore.addDevice(location: "Delta", device: dev2, success: { msg in 
                 print(msg)
                 let _signedMessage = try! deserializeV1(serializedData: msg)
                 print(_signedMessage.toString())
@@ -79,14 +79,14 @@ import MessageUtils
 
 @Test func stressLoop1() async throws {
 
-    let devices: UInt128 = 5000
+    let devices: UInt128 = 1000000
 
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
-    IoTSimulatorCore.addEnv(environment: env)
+    await IoTSimulatorCore.addEnv(environment: env)
 
     let signKeyPath = "./Private/privateKey.pem"
 
@@ -94,6 +94,8 @@ import MessageUtils
 
     for i: UInt128 in 0..<devices {
 
+        print("\n\nCreating dev \(i)\n\n")
+
         let dev: EdgeDevice =  EdgeDevice(
             deviceID: i,
             dataType: .Temperature,
@@ -114,7 +116,7 @@ import MessageUtils
             privateKey: try pem2_P256key(filePath: signKeyPath)
         )
 
-        try IoTSimulatorCore.addDevice(
+        try await IoTSimulatorCore.addDevice(
             location: "Delta", 
             device: dev,
             success: { msg in 
@@ -136,21 +138,21 @@ import MessageUtils
         sleep(1)
     }
     print("NUKE EM ALLLLLLLLLL!!!!!\n\n")
-    IoTSimulatorCore.nukeAll()
+    await IoTSimulatorCore.nukeAll()
     
 
 }
 
 @Test func stressLoop2() async throws {
 
-    let devices: UInt128 = 1
+    let devices: UInt128 = 10
 
     let env = PhysicalEnvironment("Delta")
     let truth = PhysicalData(.Temperature, 22)
 
-    env.setPhysicalData(DataType.Temperature, truth)
+    await env.setPhysicalData(DataType.Temperature, truth)
 
-    IoTSimulatorCore.addEnv(environment: env)
+    await IoTSimulatorCore.addEnv(environment: env)
 
     let signKeyPath = "./Private/privateKey.pem"
 
@@ -178,7 +180,7 @@ import MessageUtils
             privateKey: try pem2_P256key(filePath: signKeyPath)
         )
 
-        try IoTSimulatorCore.addDevice(location: "Delta", device: dev, success: { msg in 
+        try await IoTSimulatorCore.addDevice(location: "Delta", device: dev, success: { msg in 
                 print(msg)
                 let _signedMessage = try deserializeV1(serializedData: msg)
                 print(_signedMessage.toString())
@@ -193,12 +195,11 @@ import MessageUtils
     for i in 0..<_sleep {
         print("Hi, at \(i)s\n\n")
         sleep(1)
-
+        await IoTSimulatorCore.toggleSensor(devID: UInt.random(in: 0..<UInt(devices)), sensorID: 0)
-        await IoTSimulatorCore.toggleSensor(devID: 0, sensorID: 0)
 
     }
     print("NUKE EM ALLLLLLLLLL!!!!!\n\n")
-    IoTSimulatorCore.nukeAll()
+    await IoTSimulatorCore.nukeAll()
     
 
 }