def free_memory(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
amount = (10**9) * randint(1, 16)
if amount > new_record.get_field("Memory"):
amount = new_record.get_field("Memory")
new_record.set_field("Memory", new_record.get_field("Memory") - amount)
return new_record
def free_storage(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
amount = (10**9) * randint(5, 1000)
if amount > new_record.get_field("StorageUsage"):
amount = new_record.get_field("StorageUsage")
new_record.set_field("StorageUsage",
int(new_record.get_field("StorageUsage")) - amount)
return new_record
def allocate_memory(vm: CloudRecord, event_time: int):
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
new_record.set_field(
"Memory",
new_record.get_field("Memory") + (10**9) * randint(1, 16))
return new_record
def allocate_storage(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
amount = (10**9) * randint(5, 1000)
new_record.set_field("StorageUsage",
new_record.get_field("StorageUsage") + amount)
return new_record
def _simulate_cloud_life(self, vm: CloudRecord, events, intervals):
i, j = 0, 0
for i in range(len(events) - 1):
memory = vm.get_field("Memory")
cpu = vm.get_field("CpuCount")
status = vm.get_field("Status")
ip = vm.get_field("PublicIPCount")
disk = vm.get_field("StorageUsage")
while j < len(intervals) and events[i +
1] > intervals[j] > events[i]:
cloud_record = CloudRecord()
cloud_record.load_from_msg(vm.get_msg())
j += 1
start_prob = 19
suspend_prob = 10
if status == "suspended":
suspend_prob = 0
if status == "started":
start_prob = 0
event = choices([
start_machine, suspend_machine, allocate_ip, free_ip,
allocate_memory, free_memory, allocate_cpu, free_cpu,
allocate_storage, free_storage
],
k=1,
weights=[
start_prob, suspend_prob, 19, 19, 19, 19, 19,
19, 19, 19
])[0]
if memory == 0 and event == free_memory:
event = allocate_memory
if cpu == 0 and event == free_cpu:
event = allocate_cpu
if ip == 0 and event == free_ip:
event = allocate_ip
if disk == 0 and event == free_storage:
event = allocate_storage
if status is None and (event == finish_machine
or event == suspend_machine):
event = start_machine
vm = event(vm, events[i])
if randint(0, 1):
finish_machine(vm, self.end_time)
def generate_vms(self, vm_count):
for i in range(vm_count):
cr = CloudRecord()
cr.set_all({
"VMUUID":
"user-" + self.id + "-machine-" + str(len(self.vms) + 1),
"SiteName":
self.site_name,
"MachineName":
"machine" + str(len(self.vms) + 1),
"LocalUserId":
self.id,
"LocalGroupId":
self.group_id,
"GlobalUserName":
self.global_name,
"CloudComputeService":
self.cloud_compute_service,
"CloudType":
self.cloud_type,
"FQAN":
"/Group" + self.group_id + "/Role=NULL/Capability=NULL",
"Disk": (2**30) * randint(50, 200),
"Memory": (2**30) * randint(1, 16),
"PublicIPCount":
randint(0, 2),
"IPv4Count":
0,
"IPv6Count":
0,
"SuspendDuration":
0,
"CpuDuration":
0,
"WallDuration":
0,
"CpuCount":
randint(1, 8),
"StorageUsage":
0
})
self.vms.append(cr)
def free_ip(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
amount = randint(1, 5)
version = choice(["4", "6"])
if amount > new_record.get_field("IPv" + version + "Count"):
amount = new_record.get_field("IPv" + version + "Count")
new_record.set_field(
"IPv" + version + "Count",
new_record.get_field("IPv" + version + "Count") - amount)
new_record.set_field(
"PublicIPCount",
new_record.get_field("IPv4Count") + new_record.get_field("IPv6Count"))
return new_record
def allocate_ip(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
version = choice(["4", "6"])
new_record.set_field(
"IPv" + version + "Count",
new_record.get_field("IPv" + version + "Count") + randint(1, 5))
new_record.set_field(
"PublicIPCount",
new_record.get_field("IPv4Count") + new_record.get_field("IPv6Count"))
return new_record
def suspend_machine(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
new_record.set_field("Status", "suspended")
new_record.set_field("SuspendTime", event_time)
if new_record.get_field("StartTime") is not None:
new_record.set_field("WallDuration",
(event_time - new_record.get_field("CpuChange")))
new_record.set_field(
"CpuDuration",
new_record.get_field("CpuDuration") +
new_record.get_field("WallDuration") *
new_record.get_field("CpuCount"))
return new_record
def start_machine(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
if new_record.get_field("Status") == "suspended":
new_record.set_field(
"SuspendDuration",
new_record.get_field("SuspendDuration") +
(event_time - new_record.get_field("SuspendTime")))
new_record.set_field("Status", "started")
if new_record.get_field("StartTime") is None:
new_record.set_field("StartTime", event_time)
new_record.set_field("CpuChange", event_time)
return new_record
def finish_machine(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
if new_record.get_field("Status") == "started":
new_record.set_field(
"WallDuration",
new_record.get_field("WallDuration") +
(event_time - new_record.get_field("CpuChange")))
new_record.set_field(
"CpuDuration",
new_record.get_field("CpuDuration") +
new_record.get_field("CpuCount") *
(event_time - new_record.get_field("CpuChange")))
if new_record.get_field("Status") == "suspended":
new_record.set_field(
"SuspendDuration",
new_record.get_field("SuspendDuration") +
(event_time - new_record.get_field("SuspendTime")))
new_record.set_field("Status", "completed")
new_record.set_field("EndTime", event_time)
return new_record
def free_cpu(vm: CloudRecord, event_time: int) -> CloudRecord:
new_record = CloudRecord()
new_record.load_from_msg(vm.get_msg())
amount = randint(1, 32)
if amount > new_record.get_field("CpuCount"):
amount = new_record.get_field("CpuCount")
if new_record.get_field("Status") == "started":
new_record.set_field(
"WallDuration",
new_record.get_field("WallDuration") +
(event_time - new_record.get_field("StartTime")))
new_record.set_field(
"CpuDuration",
new_record.get_field("CpuDuration") +
(event_time - new_record.get_field("CpuChange")) *
new_record.get_field("CpuCount"))
new_record.set_field("CpuChange", event_time)
new_record.set_field("CpuCount", vm.get_field("CpuCount") - amount)
return new_record