1.txt

gistfile1.txt

[SUKURTA] Primary VM #1 (Ant fizinio #1) | 24 Core, 128GB RAM, 100TB HDD

--- DABARTINĖ SISTEMOS BŪSENA ---
Fizinis Serveris #1 (Sunaudota 24/40 Core):
  VM ID: 1 | Tipas: Primary    | Būsena: Running  | Cores: 24
---------------------------------

[SHUTDOWN] Klientas išjungė Primary VM #1. Fiziniai resursai atlaisvinti!

--- DABARTINĖ SISTEMOS BŪSENA ---
Fizinis Serveris #1 (Sunaudota 0/40 Core):
  VM ID: 1 | Tipas: Primary    | Būsena: Stopped  | Cores: 24
---------------------------------

[VEIKSMAS] Sistemos administratorius prikuria pigių Ephemeral VM į laisvą vietą:
[SUKURTA] Ephemeral VM #2 (Ant fizinio #1) | 4 Core, 16GB RAM, 10TB HDD
[SUKURTA] Ephemeral VM #3 (Ant fizinio #1) | 4 Core, 16GB RAM, 10TB HDD
[SUKURTA] Ephemeral VM #4 (Ant fizinio #1) | 4 Core, 16GB RAM, 10TB HDD

--- DABARTINĖ SISTEMOS BŪSENA ---
Fizinis Serveris #1 (Sunaudota 12/40 Core):
  VM ID: 1 | Tipas: Primary    | Būsena: Stopped  | Cores: 24
  VM ID: 2 | Tipas: Ephemeral  | Būsena: Running  | Cores: 4
  VM ID: 3 | Tipas: Ephemeral  | Būsena: Running  | Cores: 4
  VM ID: 4 | Tipas: Ephemeral  | Būsena: Running  | Cores: 4
---------------------------------

[START] Klientas bando įjungti Primary VM #1 (24 Core)...
  -> [EVICTION] Nukilinta Ephemeral VM #2, kad atlaisvintų vietą!
  -> [EVICTION] Nukilinta Ephemeral VM #3, kad atlaisvintų vietą!
  -> [EVICTION] Nukilinta Ephemeral VM #4, kad atlaisvintų vietą!
  -> [SĖKMĖ] Primary VM #1 sėkmingai įjungta!

--- DABARTINĖ SISTEMOS BŪSENA ---
Fizinis Serveris #1 (Sunaudota 24/40 Core):
  VM ID: 1 | Tipas: Primary    | Būsena: Running  | Cores: 24
  VM ID: 2 | Tipas: Ephemeral  | Būsena: Killed   | Cores: 4
  VM ID: 3 | Tipas: Ephemeral  | Būsena: Killed   | Cores: 4
  VM ID: 4 | Tipas: Ephemeral  | Būsena: Killed   | Cores: 4
---------------------------------

main.go

package main

import (
	"fmt"
)

// PhysicalServer atstoja fizinę "geležį"
type PhysicalServer struct {
	ID    int
	Cores int
	RAM   int // GB
	HDD   int // TB
}

// VM atstoja virtualią mašiną (tiek kliento, tiek ephemeral)
type VM struct {
	ID       int
	ParentID int    // Kuriame fiziniame serveryje ji gyvena
	Type     string // "Primary" (Garantuotas klientas) arba "Ephemeral" (Laikinas)
	State    string // "Running", "Stopped", arba "Killed"
	Cores    int
	RAM      int
	HDD      int
}

type Inventory struct {
	PhysicalServers []PhysicalServer
	VMs             []*VM
	NextVMID        int
}

// Pridedame fizinį serverį į duomenų centrą
func (inv *Inventory) AddPhysical(cores, ram, hdd int) {
	id := len(inv.PhysicalServers) + 1
	inv.PhysicalServers = append(inv.PhysicalServers, PhysicalServer{ID: id, Cores: cores, RAM: ram, HDD: hdd})
}

// Pagalbinė funkcija: suskaičiuoja, kiek resursų FIZIŠKAI sunaudota (tik VEIKIANČIŲ VM)
func (inv *Inventory) getUsedResources(physID int) (usedCores, usedRAM, usedHDD int) {
	for _, vm := range inv.VMs {
		if vm.ParentID == physID && vm.State == "Running" {
			usedCores += vm.Cores
			usedRAM += vm.RAM
			usedHDD += vm.HDD
		}
	}
	return
}

// Sukuria naują VM. Jei Type == "Primary", ji iškart rezervuoja vietą.
func (inv *Inventory) CreateVM(vmType string, reqCores, reqRAM, reqHDD int) {
	for _, phys := range inv.PhysicalServers {
		uCores, uRAM, uHDD := inv.getUsedResources(phys.ID)

		freeCores := phys.Cores - uCores
		freeRAM := phys.RAM - uRAM
		freeHDD := phys.HDD - uHDD

		if freeCores >= reqCores && freeRAM >= reqRAM && freeHDD >= reqHDD {
			vm := &VM{
				ID:       inv.NextVMID,
				ParentID: phys.ID,
				Type:     vmType,
				State:    "Running",
				Cores:    reqCores,
				RAM:      reqRAM,
				HDD:      reqHDD,
			}
			inv.VMs = append(inv.VMs, vm)
			inv.NextVMID++
			fmt.Printf("[SUKURTA] %s VM #%d (Ant fizinio #%d) | %d Core, %dGB RAM, %dTB HDD\n", vmType, vm.ID, phys.ID, reqCores, reqRAM, reqHDD)
			return
		}
	}
	fmt.Printf("[KLAIDA] Nepavyko sukurti %s VM (%d Core) - nėra laisvos fizinės vietos!\n", vmType, reqCores)
}

// Klientas išjungia savo Primary VM (resursai fiziškai atsilaisvina)
func (inv *Inventory) StopPrimaryVM(vmID int) {
	for _, vm := range inv.VMs {
		if vm.ID == vmID && vm.Type == "Primary" {
			vm.State = "Stopped"
			fmt.Printf("\n[SHUTDOWN] Klientas išjungė Primary VM #%d. Fiziniai resursai atlaisvinti!\n", vmID)
			return
		}
	}
}

// Klientas ryte įjungia savo Primary VM. Reikia atlaisvinti vietą, jei jos trūksta.
func (inv *Inventory) StartPrimaryVM(vmID int) {
	var targetVM *VM
	for _, vm := range inv.VMs {
		if vm.ID == vmID && vm.Type == "Primary" {
			targetVM = vm
			break
		}
	}

	if targetVM == nil {
		return
	}

	fmt.Printf("\n[START] Klientas bando įjungti Primary VM #%d (%d Core)...\n", targetVM.ID, targetVM.Cores)

	// Randame fizinį serverį, kuriame gyvena ši VM
	physID := targetVM.ParentID
	var phys *PhysicalServer
	for _, p := range inv.PhysicalServers {
		if p.ID == physID {
			phys = &p
			break
		}
	}

	// Tikriname, ar užtenka fizinės vietos
	uCores, uRAM, uHDD := inv.getUsedResources(phys.ID)
	freeCores := phys.Cores - uCores
	freeRAM := phys.RAM - uRAM
	freeHDD := phys.HDD - uHDD

	// Kol neužtenka vietos Primary mašinai, killiname Ephemeral mašinas
	for freeCores < targetVM.Cores || freeRAM < targetVM.RAM || freeHDD < targetVM.HDD {
		killed := false
		for _, vm := range inv.VMs {
			if vm.ParentID == phys.ID && vm.Type == "Ephemeral" && vm.State == "Running" {
				vm.State = "Killed"
				fmt.Printf("  -> [EVICTION] Nukilinta Ephemeral VM #%d, kad atlaisvintų vietą!\n", vm.ID)

				// Perskaičiuojame laisvą vietą po killinimo
				uCores, uRAM, uHDD = inv.getUsedResources(phys.ID)
				freeCores = phys.Cores - uCores
				freeRAM = phys.RAM - uRAM
				freeHDD = phys.HDD - uHDD
				killed = true
				break // Pradedame ciklą iš naujo su naujais resursų likučiais
			}
		}
		if !killed {
			// Jei nėra ką killinti, o vietos vis tiek trūksta (teoriškai neturėtų nutikti, jei neperpardavinėjate Primary mašinų)
			fmt.Printf("  -> [KLAIDA] Nepavyko atlaisvinti pakankamai vietos Primary mašinai!\n")
			return
		}
	}

	targetVM.State = "Running"
	fmt.Printf("  -> [SĖKMĖ] Primary VM #%d sėkmingai įjungta!\n", targetVM.ID)
}

func (inv *Inventory) PrintState() {
	fmt.Println("\n--- DABARTINĖ SISTEMOS BŪSENA ---")
	for _, phys := range inv.PhysicalServers {
		uCores, _, _ := inv.getUsedResources(phys.ID)
		fmt.Printf("Fizinis Serveris #%d (Sunaudota %d/%d Core):\n", phys.ID, uCores, phys.Cores)
		for _, vm := range inv.VMs {
			if vm.ParentID == phys.ID {
				fmt.Printf("  VM ID: %d | Tipas: %-10s | Būsena: %-8s | Cores: %d\n", vm.ID, vm.Type, vm.State, vm.Cores)
			}
		}
	}
	fmt.Println("---------------------------------")
}

func main() {
	inv := Inventory{NextVMID: 1}

	// 1. Turime vieną didelį fizinį mazgą
	inv.AddPhysical(40, 256, 100)

	// 2. Ateina pagrindinis klientas ir nusiperka didelę mašiną
	inv.CreateVM("Primary", 24, 128, 100)
	inv.PrintState()

	// 3. Klientas baigia darbą ir išjungia savo VM
	inv.StopPrimaryVM(1)
	inv.PrintState()

	// 4. Jūs išnaudojate atsiradusią Laisvą fizinę vietą ir prikuriate laikinų (Ephemeral) VM
	fmt.Println("\n[VEIKSMAS] Sistemos administratorius prikuria pigių Ephemeral VM į laisvą vietą:")
	inv.CreateVM("Ephemeral", 4, 16, 10)
	inv.CreateVM("Ephemeral", 4, 16, 10)
	inv.CreateVM("Ephemeral", 4, 16, 10)
	inv.PrintState()

	// 5. Rytas. Ateina Primary klientas ir vėl įjungia savo garantuotą mašiną.
	inv.StartPrimaryVM(1)
	inv.PrintState()
}