everything random simulation done

src/bucketresources.py

@@ -7,10 +7,10 @@ class BucketResourceType(Enum):
 
 
 class BucketResource:
-    def __init__(self):
-        self.type: BucketResourceType = BucketResourceType.NetworkLink
+    def __init__(self, capacity: int = 0, resourcetype: BucketResourceType = BucketResourceType.NetworkLink):
+        self.type: BucketResourceType = resourcetype
         self.currentUsage: int = 0
-        self.capacity: int = 0
+        self.capacity: int = capacity
 
     def reserve(self, resource: int) -> bool:
         if self.capacity == self.currentUsage or resource > self.capacity - self.currentUsage:

src/clients.py

@@ -8,5 +8,10 @@ class Client:
         self.lengthOfTransmission: int = 0
         self.application: Application = Application()
 
-    def firerequest(self, edge:Datacentre, cloud: Datacentre):
-        pass
+    def firerequest(self, edge: Datacentre, cloud: Datacentre, currentSlice: int) -> bool:
+        for i in self.startSlices:
+            if i <= currentSlice <= i+self.lengthOfTransmission:
+                return edge.fireapplicationmodule(
+                    applicationmodule=self.application.modules[0]) and cloud.fireapplicationmodule(
+                    applicationmodule=self.application.modules[1])
+        return True

src/datacentre.py

@@ -1,7 +1,16 @@
 from bucketresources import BucketResource
+from apps import ApplicationModule
 
 
 class Datacentre:
     def __init__(self):
         self.processingpower: BucketResource = BucketResource()
         self.uplink: BucketResource = BucketResource()
+
+    def fireapplicationmodule(self, applicationmodule: ApplicationModule) -> bool:
+        return self.processingpower.reserve(applicationmodule.cpuRequirement) and self.uplink.reserve(
+            applicationmodule.bwRequirement)
+
+    def releaseall(self) -> None:
+        self.processingpower.releaseall()
+        self.uplink.releaseall()

src/main.py

@@ -1,6 +1,7 @@
 import copy
-
+from pprint import pprint
 from datacentre import Datacentre
+from bucketresources import BucketResource, BucketResourceType
 from scenarioplanner import Scenarioplanner
 from scheduler import Scheduler
 
@@ -18,13 +19,13 @@ def preparesimulation() -> Scenarioplanner:
 def preparesimulationrunner(currscenarioplanner: Scenarioplanner) -> Scheduler:
     currentscheduler = Scheduler()
     currentscheduler.simulationLength = currscenarioplanner.simulationLength
-    currscenarioplanner.clients = copy.deepcopy(currscenarioplanner.clients)
+    currentscheduler.clients = copy.deepcopy(currscenarioplanner.clients)
     clouddatacentre = Datacentre()
-    clouddatacentre.processingpower = 10000000
-    clouddatacentre.uplink = 10000000
+    clouddatacentre.processingpower = BucketResource(100000000000, BucketResourceType.CpuResource)
+    clouddatacentre.uplink = BucketResource(100000000000)
     edgedatacentre = Datacentre()
-    edgedatacentre.processingpower = 10000
-    edgedatacentre.uplink = 10000
+    edgedatacentre.processingpower = BucketResource(100000, BucketResourceType.CpuResource)
+    edgedatacentre.uplink = BucketResource(100000)
     currentscheduler.edge = edgedatacentre
     currentscheduler.cloud = clouddatacentre
     currentscheduler.statsModule = currscenarioplanner.statsModule
@@ -34,3 +35,5 @@ def preparesimulationrunner(currscenarioplanner: Scenarioplanner) -> Scheduler:
 if __name__ == '__main__':
     scenarioplanner = preparesimulation()
     currscheduler = preparesimulationrunner(scenarioplanner)
+    currscheduler.runsimulation()
+    pprint(currscheduler.statsModule.failedDetails)

src/scheduler.py

@@ -1,6 +1,4 @@
 from clients import Client
-from apps import Application, ApplicationModule
-from bucketresources import BucketResource, BucketResource
 from stats import Stats
 from datacentre import Datacentre
 
@@ -17,4 +15,15 @@ class Scheduler:
     def runsimulation(self):
         for i in range(self.simulationLength):
             for currclient in self.clients:
-                pass
+                print(f"Edge status: CPU used: {self.edge.processingpower.currentUsage}\
+                     BW used: {self.edge.uplink.currentUsage}")
+                print(f"Cloud status: CPU used: {self.cloud.processingpower.currentUsage}\
+                     BW used: {self.cloud.uplink.currentUsage}")
+                if not currclient.firerequest(self.edge, self.cloud, i):
+                    self.failedClients.append(currclient)
+                    if i not in self.statsModule.failedDetails:
+                        self.statsModule.failedDetails[i] = 1
+                    else:
+                        self.statsModule.failedDetails[i] += 1
+            self.cloud.releaseall()
+            self.edge.releaseall()