Réorganisation globale

cmd/monitor/events/qemu.go

@@ -21,7 +21,9 @@ type Qemu struct {
 	NodeID       string
 	CompanyID    string
 	DatacenterID string
+	Config       []byte
 	DomainID     string
+	State        int
 	Event        *libvirt.DomainQemuMonitorEvent
 }
 
@@ -33,7 +35,8 @@ func QemuEvents(c *libvirt.Connect, d *libvirt.Domain, event *libvirt.DomainQemu
 	defer cancel()
 
 	domainID, _ := d.GetUUIDString()
-	xmlDesc, _ := d.GetXMLDesc(0)
+	xmlDesc, _ := d.GetXMLDesc(libvirt.DOMAIN_XML_INACTIVE)
+	state, _, _ := d.GetState()
 	err := xml.Unmarshal([]byte(xmlDesc), &desc)
 	if err != nil {
 		log.Fatalln(err)
@@ -43,7 +46,9 @@ func QemuEvents(c *libvirt.Connect, d *libvirt.Domain, event *libvirt.DomainQemu
 		NodeID:       config.NodeID,
 		CompanyID:    desc.Metadata.DeevirtInstance.DeevirtCompanyID,
 		DatacenterID: desc.Metadata.DeevirtInstance.DeevirtDatacenterID,
+		Config:       []byte(xmlDesc),
 		DomainID:     domainID,
+		State:        int(state),
 		Event:        event,
 	})
 

cmd/monitor/metrics/compute.go

@@ -1,8 +1,6 @@
 package metrics
 
 import (
-	"strconv"
-
 	"github.com/prometheus/client_golang/prometheus"
 	"libvirt.org/go/libvirt"
 )
@@ -24,7 +22,13 @@ var (
 	libvirtNodeMemoryUsageBytes = prometheus.NewDesc(
 		prometheus.BuildFQName("libvirt", "node", "memory_usage_bytes"),
 		"Memory usage of the node, in bytes.",
-		[]string{"hostname", "total"},
+		[]string{"hostname"},
+		nil)
+
+	libvirtNodeMemoryAvailableBytes = prometheus.NewDesc(
+		prometheus.BuildFQName("libvirt", "node", "memory_available_bytes"),
+		"Memory available of the node, in bytes.",
+		[]string{"hostname"},
 		nil)
 
 	libvirtNodeMemoryTotalBytes = prometheus.NewDesc(
@@ -74,12 +78,18 @@ func CollectNode(conn *libvirt.Connect, ch chan<- prometheus.Metric, hostname st
 		hostname,
 	)
 
+	ch <- prometheus.MustNewConstMetric(
+		libvirtNodeMemoryAvailableBytes,
+		prometheus.GaugeValue,
+		float64(nodeMemory.Buffers+nodeMemory.Free+nodeMemory.Cached)*1024,
+		hostname,
+	)
+
 	ch <- prometheus.MustNewConstMetric(
 		libvirtNodeMemoryUsageBytes,
 		prometheus.GaugeValue,
 		float64(nodeMemory.Total-(nodeMemory.Buffers+nodeMemory.Free+nodeMemory.Cached))*1024,
 		hostname,
-		strconv.FormatInt(int64(nodeMemory.Total*1024), 10),
 	)
 
 	ch <- prometheus.MustNewConstMetric(
@@ -96,5 +106,6 @@ func (e *LibvirtExporter) DescribeNode(ch chan<- *prometheus.Desc) {
 	ch <- libvirtNodeCPUUsage
 	ch <- libvirtNodeCPUTotal
 	ch <- libvirtNodeMemoryUsageBytes
+	ch <- libvirtNodeMemoryAvailableBytes
 	ch <- libvirtNodeMemoryTotalBytes
 }

pkg/api/domain.go

@@ -1,102 +0,0 @@
-package api
-
-import (
-	"context"
-
-	"deevirt.fr/compute/pkg/api/proto"
-	"deevirt.fr/compute/pkg/config"
-	"deevirt.fr/compute/pkg/raft"
-)
-
-type Domain struct {
-	Config *config.Config
-	Store  *raft.Store
-	proto.UnimplementedDomainServer
-}
-
-func (d *Domain) List(ctx context.Context, in *proto.DomainListAllRequest) (*proto.DomainListAllResponse, error) {
-	test, _ := d.Store.Get("test")
-	print(test)
-	return &proto.DomainListAllResponse{}, nil
-}
-
-func (d *Domain) Get(ctx context.Context, in *proto.DomainListRequest) (*proto.DomainListResponse, error) {
-	d.Store.Set(in.DomainId, "test")
-	return &proto.DomainListResponse{}, nil
-}
-
-/*func (d *Domain) List(ctx context.Context, in *proto.DomainListAllRequest) (*proto.DomainListAllResponse, error) {
-	var domains = []*proto.DomainListResponse{}
-
-	ctx_etcd, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	resp, _ := d.Etcd.Get(ctx_etcd, "/cluster/"+d.Config.ClusterID+"/domain", clientv3.WithPrefix(), clientv3.WithKeysOnly())
-	cancel()
-
-	re := regexp.MustCompile(`domain/(?P<domainID>[a-zA-Z1-9-]+)$`)
-
-	for _, data := range resp.Kvs {
-		key := string(data.Key[:])
-
-		if re.MatchString(key) {
-			matches := re.FindStringSubmatch(key)
-			index := re.SubexpIndex("domainID")
-
-			domain, _ := d.Get(context.Background(), &proto.DomainListRequest{
-				DomainId: matches[index],
-			})
-
-			domains = append(domains, domain)
-		}
-	}
-
-	return &proto.DomainListAllResponse{
-		Domains: domains,
-	}, nil
-}
-
-func (d *Domain) Get(ctx context.Context, in *proto.DomainListRequest) (*proto.DomainListResponse, error) {
-	ctx_etcd, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	resp_config, _ := d.Etcd.Get(ctx_etcd, "/cluster/"+d.Config.ClusterID+"/domain/"+in.DomainId)
-	resp_state, _ := d.Etcd.Get(ctx_etcd, "/cluster/"+d.Config.ClusterID+"/domain/"+in.DomainId+"/state")
-	cancel()
-
-	state, _ := strconv.ParseInt(string(resp_state.Kvs[0].Value), 10, 64)
-
-	return &proto.DomainListResponse{
-		DomainId: in.DomainId,
-		Config:   string(resp_config.Kvs[0].Value),
-		State:    state,
-	}, nil
-}
-
-func (d *Domain) Create(ctx context.Context, in *proto.DomainCreateRequest) (*proto.DomainCreateResponse, error) {
-	ctx_etcd, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	resp_config, _ := d.Etcd.Get(ctx_etcd, "/cluster/"+d.Config.ClusterID)
-	cancel()
-
-	println(string(resp_config.Kvs[0].Value))
-
-	/*if d.Config.LibvirtTLS {
-		libvirt_uri := "qemu+tls://"++"/system"
-	}
-	conn, err := libvirt.NewConnect("qemu:///system")
-	if err != nil {
-		log.Println("Connexion Error")
-	}
-	defer conn.Close()*/
-
-/*
-
-		async def Create(self, request, context):
-	        yield domain_pb2.DomainCreateResponse(progress=40)
-	        async with Libvirt() as libvirt:
-	            if await libvirt.define(request.config.decode()):
-	                yield domain_pb2.DomainCreateResponse(progress=100)
-	            else:
-	                context.set_code(grpc.StatusCode.ALREADY_EXISTS)
-
-*/
-
-/*return &proto.DomainCreateResponse{}, nil
-}
-*/

pkg/api/domain/domain.go

@@ -0,0 +1,181 @@
+package domain
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"regexp"
+
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+	"libvirt.org/go/libvirt"
+
+	"deevirt.fr/compute/pkg/api/proto"
+	"deevirt.fr/compute/pkg/api/raft"
+	"deevirt.fr/compute/pkg/config"
+	"deevirt.fr/compute/pkg/scheduler"
+)
+
+type Domain struct {
+	Config *config.Config
+	Store  *raft.Store
+	proto.UnimplementedDomainServer
+}
+
+func (d *Domain) connectNode(NodeId string) (*libvirt.Connect, error) {
+	var jCluster raft.NodeStore
+	cluster, _ := d.Store.Get("/etc/libvirt/cluster")
+	json.Unmarshal(cluster, &jCluster)
+
+	var libvirt_uri string
+	if d.Config.LibvirtTLS {
+		libvirt_uri = fmt.Sprintf("qemu+tls://%s/system", jCluster[NodeId].IpManagement)
+	} else {
+		libvirt_uri = fmt.Sprintf("qemu+tcp://%s/system", jCluster[NodeId].IpManagement)
+	}
+
+	c, err := libvirt.NewConnect(libvirt_uri)
+	if err != nil {
+		log.Fatalf("Erreur %v", err)
+	}
+
+	return c, nil
+}
+
+func (d *Domain) connectDomain(ctx context.Context, domainID string) (*libvirt.Connect, error) {
+	dom, _ := d.Get(ctx, &proto.DomainListRequest{
+		DomainId: domainID,
+	})
+
+	var jCluster raft.NodeStore
+	cluster, _ := d.Store.Get("/etc/libvirt/cluster")
+	json.Unmarshal(cluster, &jCluster)
+
+	return d.connectNode(dom.NodeId)
+}
+
+func (d *Domain) List(ctx context.Context, in *proto.DomainListAllRequest) (*proto.DomainListAllResponse, error) {
+	test, _ := d.Store.Ls("/etc/libvirt/qemu", raft.LsOptions{
+		Recursive: true,
+		Data:      true,
+	})
+
+	domains := []*proto.DomainListResponse{}
+
+	for k, v := range test {
+		re := regexp.MustCompile("([^/]+)/([^/]+)")
+		matches := re.FindStringSubmatch(k)
+		if matches != nil {
+			var dStore raft.DomainStore
+			json.Unmarshal(v, &dStore)
+
+			domains = append(domains, &proto.DomainListResponse{
+				NodeId:   matches[1],
+				DomainId: matches[2],
+				Config:   dStore.Config,
+				State:    int64(dStore.State),
+			})
+		}
+	}
+
+	return &proto.DomainListAllResponse{
+		Domains: domains,
+	}, nil
+}
+
+func (d *Domain) Get(ctx context.Context, in *proto.DomainListRequest) (*proto.DomainListResponse, error) {
+	dom, _ := d.Store.Ls("/etc/libvirt/qemu", raft.LsOptions{
+		Recursive: true,
+		Data:      false,
+	})
+
+	for k := range dom {
+		re := regexp.MustCompile("([^/]+)/([^/]+)")
+		matches := re.FindStringSubmatch(k)
+		if matches != nil && matches[2] == in.DomainId {
+			var dStore raft.DomainStore
+			data, _ := d.Store.Get(fmt.Sprintf("/etc/libvirt/qemu/%s/%s", matches[1], matches[2]))
+			json.Unmarshal(data, &dStore)
+
+			return &proto.DomainListResponse{
+				NodeId:   matches[1],
+				DomainId: matches[2],
+				Config:   dStore.Config,
+				State:    int64(dStore.State),
+			}, nil
+		}
+	}
+
+	return &proto.DomainListResponse{}, nil
+}
+
+func (d *Domain) Migrate(in *proto.DomainMigrateRequest, stream proto.Domain_MigrateServer) error {
+	libvirt.EventRegisterDefaultImpl()
+	ctx := context.Background()
+
+	c, err := d.connectDomain(ctx, in.DomainId)
+	if err != nil {
+		return status.Errorf(codes.Internal, "Connexion error to libvirt")
+	}
+	defer c.Close()
+
+	dom, err := c.LookupDomainByUUIDString(in.DomainId)
+	if err != nil {
+		return status.Errorf(codes.Internal, "Domain unknown")
+	}
+
+	s, err := scheduler.New()
+	if err != nil {
+		return status.Errorf(codes.Internal, "Connexion error to libvirt %v", err)
+	}
+	res, err := s.GetTopNode(1)
+	if err != nil {
+		return status.Errorf(codes.Internal, "Connexion error to libvirt %v", err)
+	}
+
+	eventCallback := func(cc *libvirt.Connect, dd *libvirt.Domain, ee *libvirt.DomainEventMigrationIteration) {
+		// Créer et envoyer le message de progression de la migration
+		stream.Send(&proto.DomainMigrateResponse{
+			Percentage: int32(ee.Iteration),
+		})
+
+		t, _ := dd.QemuMonitorCommand("{\"execute\": \"query-migrate\"}", libvirt.DOMAIN_QEMU_MONITOR_COMMAND_DEFAULT)
+		fmt.Printf("%v\n", t)
+	}
+
+	// Enregistrer l'événement de migration
+	c.DomainEventMigrationIterationRegister(dom, eventCallback)
+
+	ctx1, cancel := context.WithCancel(context.Background())
+
+	migrate := func() error {
+		c_new, err := d.connectNode(res[0].NodeID)
+		if err != nil {
+			cancel()
+			return status.Errorf(codes.Internal, "Connexion error to libvirt %v", err)
+		}
+		defer c_new.Close()
+
+		_, err = dom.Migrate(c_new, libvirt.MIGRATE_LIVE|libvirt.MIGRATE_PERSIST_DEST|libvirt.MIGRATE_UNDEFINE_SOURCE, "", "", 0)
+		if err != nil {
+			cancel()
+			return status.Errorf(codes.Internal, "Migration error %v", err)
+		}
+
+		cancel()
+
+		return nil
+	}
+
+	go migrate()
+
+	for {
+		select {
+		case <-ctx1.Done():
+			return nil
+		default:
+			libvirt.EventRunDefaultImpl()
+		}
+	}
+}

pkg/api/domain/events.go

@@ -0,0 +1,88 @@
+package domain
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"deevirt.fr/compute/pkg/api/proto"
+	"deevirt.fr/compute/pkg/api/raft"
+	"libvirt.org/go/libvirt"
+)
+
+type Events struct {
+	NodeID       string
+	CompanyID    string
+	DatacenterID string
+	Config       []byte
+	DomainID     string
+	State        int
+	Event        *libvirt.DomainQemuMonitorEvent
+}
+
+type EventsDetail map[string]string
+
+func (d *Domain) Event(ctx context.Context, req *proto.DomainEventRequest) (*proto.DomainEventResponse, error) {
+	var events Events
+
+	err := json.Unmarshal(req.Event, &events)
+	if err != nil {
+		fmt.Println("Erreur lors du décodage JSON:", err)
+	}
+
+	var edetail EventsDetail
+
+	if events.Event.Event == "MIGRATION" {
+		err = json.Unmarshal([]byte(events.Event.Details), &edetail)
+		if err != nil {
+			fmt.Println("Erreur lors du décodage JSON:", err)
+		}
+
+		if edetail["status"] == "setup" {
+			r, _ := d.Store.Get(fmt.Sprintf("/etc/libvirt/qemu/%s/%s", events.NodeID, events.DomainID))
+
+			if r != nil {
+				var j raft.DomainStore
+				json.Unmarshal(r, &j)
+				j.Migrate = true
+
+				new, _ := json.Marshal(j)
+				d.Store.Set(fmt.Sprintf("/etc/libvirt/qemu/%s/%s", events.NodeID, events.DomainID), new)
+			} else {
+				new, _ := json.Marshal(raft.DomainStore{
+					Config:  string(events.Config),
+					State:   events.State,
+					Migrate: false,
+				})
+				d.Store.Set(fmt.Sprintf("/etc/libvirt/qemu/%s/%s", events.NodeID, events.DomainID), new)
+			}
+
+			fmt.Printf("%s => %v\n", events.NodeID, edetail)
+		} else if edetail["status"] == "completed" {
+			r, _ := d.Store.Get(fmt.Sprintf("/etc/libvirt/qemu/%s/%s", events.NodeID, events.DomainID))
+
+			if r != nil {
+				var j raft.DomainStore
+				json.Unmarshal(r, &j)
+
+				if j.Migrate {
+					d.Store.Delete(fmt.Sprintf("/etc/libvirt/qemu/%s/%s", events.NodeID, events.DomainID))
+				}
+			}
+
+			fmt.Printf("%s => %v\n", events.NodeID, edetail)
+		}
+	}
+
+	// AMQP - On envoi l'évènement brut
+	/*e, _ := json.Marshal(events.Event)
+	a, _ := amqp.NewAMQP()
+	a.Publisher("vmcenter",
+		"events."+events.CompanyID+
+			"."+events.DatacenterID+
+			"."+events.DomainID,
+		e)
+	defer a.Close()*/
+
+	return &proto.DomainEventResponse{}, nil
+}

pkg/api/events.go

@@ -1,44 +0,0 @@
-package api
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-
-	"deevirt.fr/compute/pkg/amqp"
-	"deevirt.fr/compute/pkg/api/proto"
-	"libvirt.org/go/libvirt"
-)
-
-type Events struct {
-	NodeID       string
-	CompanyID    string
-	DatacenterID string
-	DomainID     string
-	Event        *libvirt.DomainQemuMonitorEvent
-}
-
-func (d *Domain) Event(ctx context.Context, req *proto.DomainEventRequest) (*proto.DomainEventResponse, error) {
-	var events Events
-
-	err := json.Unmarshal(req.Event, &events)
-	if err != nil {
-		fmt.Println("Erreur lors du décodage JSON:", err)
-	}
-
-	// AMQP - On envoi l'évènement brut
-	e, _ := json.Marshal(events.Event)
-	a, _ := amqp.NewAMQP()
-	a.Publisher("vmcenter",
-		"events."+events.CompanyID+
-			"."+events.DatacenterID+
-			"."+events.DomainID,
-		e)
-	defer a.Close()
-
-	t, _ := json.Marshal(events)
-
-	fmt.Printf("%v\n", string(t))
-
-	return &proto.DomainEventResponse{}, nil
-}

pkg/api/node.go

@@ -0,0 +1,44 @@
+package api
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"google.golang.org/protobuf/types/known/emptypb"
+
+	"deevirt.fr/compute/pkg/api/proto"
+	"deevirt.fr/compute/pkg/api/raft"
+	"deevirt.fr/compute/pkg/config"
+)
+
+type Node struct {
+	Config *config.Config
+	Store  *raft.Store
+	proto.UnimplementedNodeServer
+}
+
+func (d *Node) LibvirtQemu(ctx context.Context, in *proto.NodeLibvirtQemuRequest) (*emptypb.Empty, error) {
+	node := []struct {
+		Uuid    string `json:"uuid"`
+		Config  string `json:"config"`
+		State   int    `json:"state"`
+		Migrate bool   `json:"migrate"`
+	}{}
+
+	err := json.Unmarshal(in.Domains, &node)
+	if err != nil {
+		fmt.Println("Erreur:", err)
+	}
+
+	/*for _, n := range node {
+		fmt.Printf("%v", n)
+	}*/
+
+	d.Store.Set(fmt.Sprintf("/etc/libvirt/qemu/%s/", d.Config.NodeID), in.Domains)
+
+	t, _ := d.Store.Get(fmt.Sprintf("/etc/libvirt/qemu/%s/", d.Config.NodeID))
+	fmt.Printf("%v", t)
+
+	return &emptypb.Empty{}, nil
+}

pkg/api/proto/domain.pb.go

@@ -306,9 +306,10 @@ type DomainListResponse struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields
 
-	DomainId string `protobuf:"bytes,1,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
+	NodeId   string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
-	Config   string `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
+	DomainId string `protobuf:"bytes,2,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
-	State    int64  `protobuf:"varint,3,opt,name=state,proto3" json:"state,omitempty"`
+	Config   string `protobuf:"bytes,3,opt,name=config,proto3" json:"config,omitempty"`
+	State    int64  `protobuf:"varint,4,opt,name=state,proto3" json:"state,omitempty"`
 }
 
 func (x *DomainListResponse) Reset() {
@@ -343,6 +344,13 @@ func (*DomainListResponse) Descriptor() ([]byte, []int) {
 	return file_proto_domain_proto_rawDescGZIP(), []int{5}
 }
 
+func (x *DomainListResponse) GetNodeId() string {
+	if x != nil {
+		return x.NodeId
+	}
+	return ""
+}
+
 func (x *DomainListResponse) GetDomainId() string {
 	if x != nil {
 		return x.DomainId
@@ -636,6 +644,109 @@ func (*DomainDeleteResponse) Descriptor() ([]byte, []int) {
 	return file_proto_domain_proto_rawDescGZIP(), []int{11}
 }
 
+// Migrate
+type DomainMigrateRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	DomainId string `protobuf:"bytes,1,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
+}
+
+func (x *DomainMigrateRequest) Reset() {
+	*x = DomainMigrateRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_domain_proto_msgTypes[12]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DomainMigrateRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DomainMigrateRequest) ProtoMessage() {}
+
+func (x *DomainMigrateRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_domain_proto_msgTypes[12]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DomainMigrateRequest.ProtoReflect.Descriptor instead.
+func (*DomainMigrateRequest) Descriptor() ([]byte, []int) {
+	return file_proto_domain_proto_rawDescGZIP(), []int{12}
+}
+
+func (x *DomainMigrateRequest) GetDomainId() string {
+	if x != nil {
+		return x.DomainId
+	}
+	return ""
+}
+
+type DomainMigrateResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Percentage int32  `protobuf:"varint,1,opt,name=percentage,proto3" json:"percentage,omitempty"`
+	Message    string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+}
+
+func (x *DomainMigrateResponse) Reset() {
+	*x = DomainMigrateResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_domain_proto_msgTypes[13]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *DomainMigrateResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*DomainMigrateResponse) ProtoMessage() {}
+
+func (x *DomainMigrateResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_domain_proto_msgTypes[13]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use DomainMigrateResponse.ProtoReflect.Descriptor instead.
+func (*DomainMigrateResponse) Descriptor() ([]byte, []int) {
+	return file_proto_domain_proto_rawDescGZIP(), []int{13}
+}
+
+func (x *DomainMigrateResponse) GetPercentage() int32 {
+	if x != nil {
+		return x.Percentage
+	}
+	return 0
+}
+
+func (x *DomainMigrateResponse) GetMessage() string {
+	if x != nil {
+		return x.Message
+	}
+	return ""
+}
+
 type DomainPowerRequest struct {
 	state         protoimpl.MessageState
 	sizeCache     protoimpl.SizeCache
@@ -648,7 +759,7 @@ type DomainPowerRequest struct {
 func (x *DomainPowerRequest) Reset() {
 	*x = DomainPowerRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_domain_proto_msgTypes[12]
+		mi := &file_proto_domain_proto_msgTypes[14]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -661,7 +772,7 @@ func (x *DomainPowerRequest) String() string {
 func (*DomainPowerRequest) ProtoMessage() {}
 
 func (x *DomainPowerRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_domain_proto_msgTypes[12]
+	mi := &file_proto_domain_proto_msgTypes[14]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -674,7 +785,7 @@ func (x *DomainPowerRequest) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DomainPowerRequest.ProtoReflect.Descriptor instead.
 func (*DomainPowerRequest) Descriptor() ([]byte, []int) {
-	return file_proto_domain_proto_rawDescGZIP(), []int{12}
+	return file_proto_domain_proto_rawDescGZIP(), []int{14}
 }
 
 func (x *DomainPowerRequest) GetVmId() []byte {
@@ -700,7 +811,7 @@ type DomainPowerResponse struct {
 func (x *DomainPowerResponse) Reset() {
 	*x = DomainPowerResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_domain_proto_msgTypes[13]
+		mi := &file_proto_domain_proto_msgTypes[15]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -713,7 +824,7 @@ func (x *DomainPowerResponse) String() string {
 func (*DomainPowerResponse) ProtoMessage() {}
 
 func (x *DomainPowerResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_domain_proto_msgTypes[13]
+	mi := &file_proto_domain_proto_msgTypes[15]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -726,7 +837,7 @@ func (x *DomainPowerResponse) ProtoReflect() protoreflect.Message {
 
 // Deprecated: Use DomainPowerResponse.ProtoReflect.Descriptor instead.
 func (*DomainPowerResponse) Descriptor() ([]byte, []int) {
-	return file_proto_domain_proto_rawDescGZIP(), []int{13}
+	return file_proto_domain_proto_rawDescGZIP(), []int{15}
 }
 
 type DomainDevicesGraphicsConsoleRequest struct {
@@ -740,7 +851,7 @@ type DomainDevicesGraphicsConsoleRequest struct {
 func (x *DomainDevicesGraphicsConsoleRequest) Reset() {
 	*x = DomainDevicesGraphicsConsoleRequest{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_domain_proto_msgTypes[14]
+		mi := &file_proto_domain_proto_msgTypes[16]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -753,7 +864,7 @@ func (x *DomainDevicesGraphicsConsoleRequest) String() string {
 func (*DomainDevicesGraphicsConsoleRequest) ProtoMessage() {}
 
 func (x *DomainDevicesGraphicsConsoleRequest) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_domain_proto_msgTypes[14]
+	mi := &file_proto_domain_proto_msgTypes[16]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -766,7 +877,7 @@ func (x *DomainDevicesGraphicsConsoleRequest) ProtoReflect() protoreflect.Messag
 
 // Deprecated: Use DomainDevicesGraphicsConsoleRequest.ProtoReflect.Descriptor instead.
 func (*DomainDevicesGraphicsConsoleRequest) Descriptor() ([]byte, []int) {
-	return file_proto_domain_proto_rawDescGZIP(), []int{14}
+	return file_proto_domain_proto_rawDescGZIP(), []int{16}
 }
 
 func (x *DomainDevicesGraphicsConsoleRequest) GetVmId() []byte {
@@ -787,7 +898,7 @@ type DomainDevicesGraphicsConsoleResponse struct {
 func (x *DomainDevicesGraphicsConsoleResponse) Reset() {
 	*x = DomainDevicesGraphicsConsoleResponse{}
 	if protoimpl.UnsafeEnabled {
-		mi := &file_proto_domain_proto_msgTypes[15]
+		mi := &file_proto_domain_proto_msgTypes[17]
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		ms.StoreMessageInfo(mi)
 	}
@@ -800,7 +911,7 @@ func (x *DomainDevicesGraphicsConsoleResponse) String() string {
 func (*DomainDevicesGraphicsConsoleResponse) ProtoMessage() {}
 
 func (x *DomainDevicesGraphicsConsoleResponse) ProtoReflect() protoreflect.Message {
-	mi := &file_proto_domain_proto_msgTypes[15]
+	mi := &file_proto_domain_proto_msgTypes[17]
 	if protoimpl.UnsafeEnabled && x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 		if ms.LoadMessageInfo() == nil {
@@ -813,7 +924,7 @@ func (x *DomainDevicesGraphicsConsoleResponse) ProtoReflect() protoreflect.Messa
 
 // Deprecated: Use DomainDevicesGraphicsConsoleResponse.ProtoReflect.Descriptor instead.
 func (*DomainDevicesGraphicsConsoleResponse) Descriptor() ([]byte, []int) {
-	return file_proto_domain_proto_rawDescGZIP(), []int{15}
+	return file_proto_domain_proto_rawDescGZIP(), []int{17}
 }
 
 func (x *DomainDevicesGraphicsConsoleResponse) GetUri() string {
@@ -841,92 +952,107 @@ var file_proto_domain_proto_rawDesc = []byte{
 	0x07, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x22, 0x30, 0x0a, 0x11, 0x44, 0x6f, 0x6d, 0x61,
 	0x69, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1b, 0x0a,
 	0x09, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
-	0x52, 0x08, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x5f, 0x0a, 0x12, 0x44, 0x6f,
+	0x52, 0x08, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x78, 0x0a, 0x12, 0x44, 0x6f,
 	0x6d, 0x61, 0x69, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x1b, 0x0a, 0x09, 0x64, 0x6f, 0x6d,
+	0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x6f,
+	0x6d, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67,
+	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x14,
+	0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x73,
+	0x74, 0x61, 0x74, 0x65, 0x22, 0x46, 0x0a, 0x13, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72,
+	0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e,
+	0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f,
+	0x64, 0x65, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x32, 0x0a, 0x14,
+	0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x70, 0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73,
+	0x22, 0x2a, 0x0a, 0x13, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x13, 0x0a, 0x05, 0x76, 0x6d, 0x5f, 0x69, 0x64,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x76, 0x6d, 0x49, 0x64, 0x22, 0x16, 0x0a, 0x14,
+	0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70,
+	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0x0a, 0x13, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65,
+	0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x13, 0x0a, 0x05, 0x76,
+	0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x76, 0x6d, 0x49, 0x64,
+	0x22, 0x16, 0x0a, 0x14, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65,
+	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x33, 0x0a, 0x14, 0x44, 0x6f, 0x6d, 0x61,
+	0x69, 0x6e, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
 	0x12, 0x1b, 0x0a, 0x09, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x12, 0x16, 0x0a,
+	0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x51, 0x0a,
-	0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63,
+	0x15, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e,
-	0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x46, 0x0a, 0x13, 0x44,
+	0x74, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x70, 0x65, 0x72, 0x63,
-	0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
-	0x73, 0x74, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20,
+	0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65,
-	0x01, 0x28, 0x09, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x16, 0x0a, 0x06, 0x63,
+	0x22, 0x57, 0x0a, 0x12, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52,
-	0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63, 0x6f, 0x6e,
-	0x66, 0x69, 0x67, 0x22, 0x32, 0x0a, 0x14, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72, 0x65,
-	0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1a, 0x0a, 0x08, 0x70,
-	0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x70,
-	0x72, 0x6f, 0x67, 0x72, 0x65, 0x73, 0x73, 0x22, 0x2a, 0x0a, 0x13, 0x44, 0x6f, 0x6d, 0x61, 0x69,
-	0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x13,
-	0x0a, 0x05, 0x76, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x76,
-	0x6d, 0x49, 0x64, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x55, 0x70, 0x64,
-	0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x2a, 0x0a, 0x13, 0x44,
-	0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x12, 0x13, 0x0a, 0x05, 0x76, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x04, 0x76, 0x6d, 0x49, 0x64, 0x22, 0x16, 0x0a, 0x14, 0x44, 0x6f, 0x6d, 0x61, 0x69,
-	0x6e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x57, 0x0a, 0x12, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52, 0x65,
-	0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x13, 0x0a, 0x05, 0x76, 0x6d, 0x5f, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x76, 0x6d, 0x49, 0x64, 0x12, 0x2c, 0x0a, 0x06, 0x61, 0x63,
-	0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x64, 0x65, 0x65,
-	0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72,
-	0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x15, 0x0a, 0x13, 0x44, 0x6f, 0x6d, 0x61,
-	0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x3a, 0x0a, 0x23, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73,
-	0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x52,
 	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x13, 0x0a, 0x05, 0x76, 0x6d, 0x5f, 0x69, 0x64, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x76, 0x6d, 0x49, 0x64, 0x22, 0x38, 0x0a, 0x24, 0x44,
+	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x76, 0x6d, 0x49, 0x64, 0x12, 0x2c, 0x0a, 0x06, 0x61,
-	0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x47, 0x72, 0x61, 0x70,
+	0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x14, 0x2e, 0x64, 0x65,
-	0x68, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65,
-	0x6e, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09,
+	0x72, 0x52, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x15, 0x0a, 0x13, 0x44, 0x6f, 0x6d,
-	0x52, 0x03, 0x75, 0x72, 0x69, 0x2a, 0x70, 0x0a, 0x0b, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50,
+	0x61, 0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
-	0x6f, 0x77, 0x65, 0x72, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e, 0x45,
+	0x22, 0x3a, 0x0a, 0x23, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65,
-	0x44, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x54, 0x41, 0x52, 0x54, 0x10, 0x01, 0x12, 0x0a,
-	0x0a, 0x06, 0x52, 0x45, 0x42, 0x4f, 0x4f, 0x54, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x53, 0x48,
-	0x55, 0x54, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x03, 0x12, 0x09, 0x0a, 0x05, 0x50, 0x41, 0x55, 0x53,
-	0x45, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x52, 0x45, 0x53, 0x55, 0x4d, 0x45, 0x10, 0x05, 0x12,
-	0x09, 0x0a, 0x05, 0x52, 0x45, 0x53, 0x45, 0x54, 0x10, 0x06, 0x12, 0x0b, 0x0a, 0x07, 0x44, 0x45,
-	0x53, 0x54, 0x52, 0x4f, 0x59, 0x10, 0x07, 0x32, 0xfa, 0x03, 0x0a, 0x06, 0x44, 0x6f, 0x6d, 0x61,
-	0x69, 0x6e, 0x12, 0x44, 0x0a, 0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1b, 0x2e, 0x64, 0x65,
-	0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x45, 0x76, 0x65, 0x6e,
-	0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69,
-	0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x04, 0x4c, 0x69, 0x73, 0x74,
-	0x12, 0x1d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69,
-	0x6e, 0x4c, 0x69, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
-	0x1e, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e,
-	0x4c, 0x69, 0x73, 0x74, 0x41, 0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22,
-	0x00, 0x12, 0x40, 0x0a, 0x03, 0x47, 0x65, 0x74, 0x12, 0x1a, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69,
-	0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44,
-	0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
-	0x65, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x06, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x2e,
-	0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72,
-	0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x64, 0x65,
-	0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72, 0x65, 0x61,
-	0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x06,
-	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74,
-	0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44,
-	0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
-	0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12,
-	0x1c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e,
-	0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e,
-	0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65,
-	0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x44,
-	0x0a, 0x05, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x1b, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72,
-	0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52, 0x65, 0x71,
-	0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44,
-	0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x00, 0x32, 0x81, 0x01, 0x0a, 0x15, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44,
-	0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x12, 0x68,
-	0x0a, 0x07, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x12, 0x2c, 0x2e, 0x64, 0x65, 0x65, 0x76,
-	0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65,
 	0x73, 0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65,
-	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72,
+	0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x13, 0x0a, 0x05, 0x76, 0x6d, 0x5f, 0x69, 0x64,
-	0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x47,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x76, 0x6d, 0x49, 0x64, 0x22, 0x38, 0x0a, 0x24,
-	0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x52, 0x65,
+	0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x47, 0x72, 0x61,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x70, 0x72,
+	0x70, 0x68, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73, 0x70,
-	0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x6f, 0x6e, 0x73, 0x65, 0x12, 0x10, 0x0a, 0x03, 0x75, 0x72, 0x69, 0x18, 0x01, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x03, 0x75, 0x72, 0x69, 0x2a, 0x70, 0x0a, 0x0b, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e,
+	0x50, 0x6f, 0x77, 0x65, 0x72, 0x12, 0x0d, 0x0a, 0x09, 0x55, 0x4e, 0x44, 0x45, 0x46, 0x49, 0x4e,
+	0x45, 0x44, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x54, 0x41, 0x52, 0x54, 0x10, 0x01, 0x12,
+	0x0a, 0x0a, 0x06, 0x52, 0x45, 0x42, 0x4f, 0x4f, 0x54, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, 0x53,
+	0x48, 0x55, 0x54, 0x44, 0x4f, 0x57, 0x4e, 0x10, 0x03, 0x12, 0x09, 0x0a, 0x05, 0x50, 0x41, 0x55,
+	0x53, 0x45, 0x10, 0x04, 0x12, 0x0a, 0x0a, 0x06, 0x52, 0x45, 0x53, 0x55, 0x4d, 0x45, 0x10, 0x05,
+	0x12, 0x09, 0x0a, 0x05, 0x52, 0x45, 0x53, 0x45, 0x54, 0x10, 0x06, 0x12, 0x0b, 0x0a, 0x07, 0x44,
+	0x45, 0x53, 0x54, 0x52, 0x4f, 0x59, 0x10, 0x07, 0x32, 0xc8, 0x04, 0x0a, 0x06, 0x44, 0x6f, 0x6d,
+	0x61, 0x69, 0x6e, 0x12, 0x47, 0x0a, 0x04, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1d, 0x2e, 0x64, 0x65,
+	0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x4c, 0x69, 0x73, 0x74,
+	0x41, 0x6c, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x64, 0x65, 0x65,
+	0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x41,
+	0x6c, 0x6c, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x40, 0x0a, 0x03,
+	0x47, 0x65, 0x74, 0x12, 0x1a, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f,
+	0x6d, 0x61, 0x69, 0x6e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x1b, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e,
+	0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x47,
+	0x0a, 0x06, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69,
+	0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74,
+	0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x47, 0x0a, 0x06, 0x55, 0x70, 0x64, 0x61, 0x74,
+	0x65, 0x12, 0x1c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61,
+	0x69, 0x6e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x1d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e,
+	0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00,
+	0x12, 0x47, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x1c, 0x2e, 0x64, 0x65, 0x65,
+	0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x6c, 0x65, 0x74,
+	0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69,
+	0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4c, 0x0a, 0x07, 0x4d, 0x69, 0x67,
+	0x72, 0x61, 0x74, 0x65, 0x12, 0x1d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44,
+	0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f,
+	0x6d, 0x61, 0x69, 0x6e, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f,
+	0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x44, 0x0a, 0x05, 0x50, 0x6f, 0x77, 0x65, 0x72,
+	0x12, 0x1b, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69,
+	0x6e, 0x50, 0x6f, 0x77, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e,
+	0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x50, 0x6f,
+	0x77, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x44, 0x0a,
+	0x05, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x12, 0x1b, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74,
+	0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x1c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x44, 0x6f,
+	0x6d, 0x61, 0x69, 0x6e, 0x45, 0x76, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73,
+	0x65, 0x22, 0x00, 0x32, 0x81, 0x01, 0x0a, 0x15, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65,
+	0x76, 0x69, 0x63, 0x65, 0x73, 0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x12, 0x68, 0x0a,
+	0x07, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x12, 0x2c, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69,
+	0x72, 0x74, 0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73,
+	0x47, 0x72, 0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2d, 0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74,
+	0x2e, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x44, 0x65, 0x76, 0x69, 0x63, 0x65, 0x73, 0x47, 0x72,
+	0x61, 0x70, 0x68, 0x69, 0x63, 0x73, 0x43, 0x6f, 0x6e, 0x73, 0x6f, 0x6c, 0x65, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }
 
 var (
@@ -942,7 +1068,7 @@ func file_proto_domain_proto_rawDescGZIP() []byte {
 }
 
 var file_proto_domain_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
-var file_proto_domain_proto_msgTypes = make([]protoimpl.MessageInfo, 16)
+var file_proto_domain_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
 var file_proto_domain_proto_goTypes = []interface{}{
 	(DomainPower)(0),                             // 0: deevirt.DomainPower
 	(*DomainEventRequest)(nil),                   // 1: deevirt.DomainEventRequest
@@ -957,32 +1083,36 @@ var file_proto_domain_proto_goTypes = []interface{}{
 	(*DomainUpdateResponse)(nil),                 // 10: deevirt.DomainUpdateResponse
 	(*DomainDeleteRequest)(nil),                  // 11: deevirt.DomainDeleteRequest
 	(*DomainDeleteResponse)(nil),                 // 12: deevirt.DomainDeleteResponse
-	(*DomainPowerRequest)(nil),                   // 13: deevirt.DomainPowerRequest
+	(*DomainMigrateRequest)(nil),                 // 13: deevirt.DomainMigrateRequest
-	(*DomainPowerResponse)(nil),                  // 14: deevirt.DomainPowerResponse
+	(*DomainMigrateResponse)(nil),                // 14: deevirt.DomainMigrateResponse
-	(*DomainDevicesGraphicsConsoleRequest)(nil),  // 15: deevirt.DomainDevicesGraphicsConsoleRequest
+	(*DomainPowerRequest)(nil),                   // 15: deevirt.DomainPowerRequest
-	(*DomainDevicesGraphicsConsoleResponse)(nil), // 16: deevirt.DomainDevicesGraphicsConsoleResponse
+	(*DomainPowerResponse)(nil),                  // 16: deevirt.DomainPowerResponse
+	(*DomainDevicesGraphicsConsoleRequest)(nil),  // 17: deevirt.DomainDevicesGraphicsConsoleRequest
+	(*DomainDevicesGraphicsConsoleResponse)(nil), // 18: deevirt.DomainDevicesGraphicsConsoleResponse
 }
 var file_proto_domain_proto_depIdxs = []int32{
 	6,  // 0: deevirt.DomainListAllResponse.domains:type_name -> deevirt.DomainListResponse
 	0,  // 1: deevirt.DomainPowerRequest.action:type_name -> deevirt.DomainPower
-	1,  // 2: deevirt.Domain.Event:input_type -> deevirt.DomainEventRequest
+	3,  // 2: deevirt.Domain.List:input_type -> deevirt.DomainListAllRequest
-	3,  // 3: deevirt.Domain.List:input_type -> deevirt.DomainListAllRequest
+	5,  // 3: deevirt.Domain.Get:input_type -> deevirt.DomainListRequest
-	5,  // 4: deevirt.Domain.Get:input_type -> deevirt.DomainListRequest
+	7,  // 4: deevirt.Domain.Create:input_type -> deevirt.DomainCreateRequest
-	7,  // 5: deevirt.Domain.Create:input_type -> deevirt.DomainCreateRequest
+	9,  // 5: deevirt.Domain.Update:input_type -> deevirt.DomainUpdateRequest
-	9,  // 6: deevirt.Domain.Update:input_type -> deevirt.DomainUpdateRequest
+	11, // 6: deevirt.Domain.Delete:input_type -> deevirt.DomainDeleteRequest
-	11, // 7: deevirt.Domain.Delete:input_type -> deevirt.DomainDeleteRequest
+	13, // 7: deevirt.Domain.Migrate:input_type -> deevirt.DomainMigrateRequest
-	13, // 8: deevirt.Domain.Power:input_type -> deevirt.DomainPowerRequest
+	15, // 8: deevirt.Domain.Power:input_type -> deevirt.DomainPowerRequest
-	15, // 9: deevirt.DomainDevicesGraphics.Console:input_type -> deevirt.DomainDevicesGraphicsConsoleRequest
+	1,  // 9: deevirt.Domain.Event:input_type -> deevirt.DomainEventRequest
-	2,  // 10: deevirt.Domain.Event:output_type -> deevirt.DomainEventResponse
+	17, // 10: deevirt.DomainDevicesGraphics.Console:input_type -> deevirt.DomainDevicesGraphicsConsoleRequest
 	4,  // 11: deevirt.Domain.List:output_type -> deevirt.DomainListAllResponse
 	6,  // 12: deevirt.Domain.Get:output_type -> deevirt.DomainListResponse
 	8,  // 13: deevirt.Domain.Create:output_type -> deevirt.DomainCreateResponse
 	10, // 14: deevirt.Domain.Update:output_type -> deevirt.DomainUpdateResponse
 	12, // 15: deevirt.Domain.Delete:output_type -> deevirt.DomainDeleteResponse
-	14, // 16: deevirt.Domain.Power:output_type -> deevirt.DomainPowerResponse
+	14, // 16: deevirt.Domain.Migrate:output_type -> deevirt.DomainMigrateResponse
-	16, // 17: deevirt.DomainDevicesGraphics.Console:output_type -> deevirt.DomainDevicesGraphicsConsoleResponse
+	16, // 17: deevirt.Domain.Power:output_type -> deevirt.DomainPowerResponse
-	10, // [10:18] is the sub-list for method output_type
+	2,  // 18: deevirt.Domain.Event:output_type -> deevirt.DomainEventResponse
-	2,  // [2:10] is the sub-list for method input_type
+	18, // 19: deevirt.DomainDevicesGraphics.Console:output_type -> deevirt.DomainDevicesGraphicsConsoleResponse
+	11, // [11:20] is the sub-list for method output_type
+	2,  // [2:11] is the sub-list for method input_type
 	2,  // [2:2] is the sub-list for extension type_name
 	2,  // [2:2] is the sub-list for extension extendee
 	0,  // [0:2] is the sub-list for field type_name
@@ -1139,7 +1269,7 @@ func file_proto_domain_proto_init() {
 			}
 		}
 		file_proto_domain_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DomainPowerRequest); i {
+			switch v := v.(*DomainMigrateRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1151,7 +1281,7 @@ func file_proto_domain_proto_init() {
 			}
 		}
 		file_proto_domain_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DomainPowerResponse); i {
+			switch v := v.(*DomainMigrateResponse); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1163,7 +1293,7 @@ func file_proto_domain_proto_init() {
 			}
 		}
 		file_proto_domain_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} {
-			switch v := v.(*DomainDevicesGraphicsConsoleRequest); i {
+			switch v := v.(*DomainPowerRequest); i {
 			case 0:
 				return &v.state
 			case 1:
@@ -1175,6 +1305,30 @@ func file_proto_domain_proto_init() {
 			}
 		}
 		file_proto_domain_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DomainPowerResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_domain_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*DomainDevicesGraphicsConsoleRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_domain_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} {
 			switch v := v.(*DomainDevicesGraphicsConsoleResponse); i {
 			case 0:
 				return &v.state
@@ -1193,7 +1347,7 @@ func file_proto_domain_proto_init() {
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_proto_domain_proto_rawDesc,
 			NumEnums:      1,
-			NumMessages:   16,
+			NumMessages:   18,
 			NumExtensions: 0,
 			NumServices:   2,
 		},

pkg/api/proto/domain.proto

@@ -5,16 +5,17 @@ package deevirt;
 
 // The greeting service definition.
 service Domain {
-  rpc Event (DomainEventRequest) returns (DomainEventResponse) {}
-
   rpc List (DomainListAllRequest) returns (DomainListAllResponse) {}
   rpc Get (DomainListRequest) returns (DomainListResponse) {}
   rpc Create (DomainCreateRequest) returns (DomainCreateResponse) {}
   rpc Update (DomainUpdateRequest) returns (DomainUpdateResponse) {}
   rpc Delete (DomainDeleteRequest) returns (DomainDeleteResponse) {}
 
+  rpc Migrate (DomainMigrateRequest) returns (stream DomainMigrateResponse) {}
+
   rpc Power (DomainPowerRequest) returns (DomainPowerResponse) {}
 
+  rpc Event (DomainEventRequest) returns (DomainEventResponse) {}
 }
 
 message DomainEventRequest {
@@ -34,9 +35,10 @@ message DomainListRequest {
 }
 
 message DomainListResponse {
-  string domain_id = 1;
+  string node_id = 1;
-  string config = 2;
+  string domain_id = 2;
-  int64 state = 3;
+  string config = 3;
+  int64 state = 4;
 }
 
 message DomainCreateRequest {
@@ -68,6 +70,16 @@ message DomainDeleteRequest {
 message DomainDeleteResponse {
 }
 
+// Migrate
+message DomainMigrateRequest {
+  string domain_id = 1;
+}
+
+message DomainMigrateResponse {
+  int32 percentage = 1;
+  string message = 2;
+}
+
 enum DomainPower {
   UNDEFINED = 0;
   START = 1;

pkg/api/proto/domain_grpc.pb.go

@@ -19,13 +19,14 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	Domain_Event_FullMethodName  = "/deevirt.Domain/Event"
+	Domain_List_FullMethodName    = "/deevirt.Domain/List"
-	Domain_List_FullMethodName   = "/deevirt.Domain/List"
+	Domain_Get_FullMethodName     = "/deevirt.Domain/Get"
-	Domain_Get_FullMethodName    = "/deevirt.Domain/Get"
+	Domain_Create_FullMethodName  = "/deevirt.Domain/Create"
-	Domain_Create_FullMethodName = "/deevirt.Domain/Create"
+	Domain_Update_FullMethodName  = "/deevirt.Domain/Update"
-	Domain_Update_FullMethodName = "/deevirt.Domain/Update"
+	Domain_Delete_FullMethodName  = "/deevirt.Domain/Delete"
-	Domain_Delete_FullMethodName = "/deevirt.Domain/Delete"
+	Domain_Migrate_FullMethodName = "/deevirt.Domain/Migrate"
-	Domain_Power_FullMethodName  = "/deevirt.Domain/Power"
+	Domain_Power_FullMethodName   = "/deevirt.Domain/Power"
+	Domain_Event_FullMethodName   = "/deevirt.Domain/Event"
 )
 
 // DomainClient is the client API for Domain service.
@@ -34,13 +35,14 @@ const (
 //
 // The greeting service definition.
 type DomainClient interface {
-	Event(ctx context.Context, in *DomainEventRequest, opts ...grpc.CallOption) (*DomainEventResponse, error)
 	List(ctx context.Context, in *DomainListAllRequest, opts ...grpc.CallOption) (*DomainListAllResponse, error)
 	Get(ctx context.Context, in *DomainListRequest, opts ...grpc.CallOption) (*DomainListResponse, error)
 	Create(ctx context.Context, in *DomainCreateRequest, opts ...grpc.CallOption) (*DomainCreateResponse, error)
 	Update(ctx context.Context, in *DomainUpdateRequest, opts ...grpc.CallOption) (*DomainUpdateResponse, error)
 	Delete(ctx context.Context, in *DomainDeleteRequest, opts ...grpc.CallOption) (*DomainDeleteResponse, error)
+	Migrate(ctx context.Context, in *DomainMigrateRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[DomainMigrateResponse], error)
 	Power(ctx context.Context, in *DomainPowerRequest, opts ...grpc.CallOption) (*DomainPowerResponse, error)
+	Event(ctx context.Context, in *DomainEventRequest, opts ...grpc.CallOption) (*DomainEventResponse, error)
 }
 
 type domainClient struct {
@@ -51,16 +53,6 @@ func NewDomainClient(cc grpc.ClientConnInterface) DomainClient {
 	return &domainClient{cc}
 }
 
-func (c *domainClient) Event(ctx context.Context, in *DomainEventRequest, opts ...grpc.CallOption) (*DomainEventResponse, error) {
-	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(DomainEventResponse)
-	err := c.cc.Invoke(ctx, Domain_Event_FullMethodName, in, out, cOpts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *domainClient) List(ctx context.Context, in *DomainListAllRequest, opts ...grpc.CallOption) (*DomainListAllResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(DomainListAllResponse)
@@ -111,6 +103,25 @@ func (c *domainClient) Delete(ctx context.Context, in *DomainDeleteRequest, opts
 	return out, nil
 }
 
+func (c *domainClient) Migrate(ctx context.Context, in *DomainMigrateRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[DomainMigrateResponse], error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	stream, err := c.cc.NewStream(ctx, &Domain_ServiceDesc.Streams[0], Domain_Migrate_FullMethodName, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &grpc.GenericClientStream[DomainMigrateRequest, DomainMigrateResponse]{ClientStream: stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type Domain_MigrateClient = grpc.ServerStreamingClient[DomainMigrateResponse]
+
 func (c *domainClient) Power(ctx context.Context, in *DomainPowerRequest, opts ...grpc.CallOption) (*DomainPowerResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(DomainPowerResponse)
@@ -121,19 +132,30 @@ func (c *domainClient) Power(ctx context.Context, in *DomainPowerRequest, opts .
 	return out, nil
 }
 
+func (c *domainClient) Event(ctx context.Context, in *DomainEventRequest, opts ...grpc.CallOption) (*DomainEventResponse, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(DomainEventResponse)
+	err := c.cc.Invoke(ctx, Domain_Event_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // DomainServer is the server API for Domain service.
 // All implementations must embed UnimplementedDomainServer
 // for forward compatibility.
 //
 // The greeting service definition.
 type DomainServer interface {
-	Event(context.Context, *DomainEventRequest) (*DomainEventResponse, error)
 	List(context.Context, *DomainListAllRequest) (*DomainListAllResponse, error)
 	Get(context.Context, *DomainListRequest) (*DomainListResponse, error)
 	Create(context.Context, *DomainCreateRequest) (*DomainCreateResponse, error)
 	Update(context.Context, *DomainUpdateRequest) (*DomainUpdateResponse, error)
 	Delete(context.Context, *DomainDeleteRequest) (*DomainDeleteResponse, error)
+	Migrate(*DomainMigrateRequest, grpc.ServerStreamingServer[DomainMigrateResponse]) error
 	Power(context.Context, *DomainPowerRequest) (*DomainPowerResponse, error)
+	Event(context.Context, *DomainEventRequest) (*DomainEventResponse, error)
 	mustEmbedUnimplementedDomainServer()
 }
 
@@ -144,9 +166,6 @@ type DomainServer interface {
 // pointer dereference when methods are called.
 type UnimplementedDomainServer struct{}
 
-func (UnimplementedDomainServer) Event(context.Context, *DomainEventRequest) (*DomainEventResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method Event not implemented")
-}
 func (UnimplementedDomainServer) List(context.Context, *DomainListAllRequest) (*DomainListAllResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
 }
@@ -162,9 +181,15 @@ func (UnimplementedDomainServer) Update(context.Context, *DomainUpdateRequest) (
 func (UnimplementedDomainServer) Delete(context.Context, *DomainDeleteRequest) (*DomainDeleteResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
 }
+func (UnimplementedDomainServer) Migrate(*DomainMigrateRequest, grpc.ServerStreamingServer[DomainMigrateResponse]) error {
+	return status.Errorf(codes.Unimplemented, "method Migrate not implemented")
+}
 func (UnimplementedDomainServer) Power(context.Context, *DomainPowerRequest) (*DomainPowerResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Power not implemented")
 }
+func (UnimplementedDomainServer) Event(context.Context, *DomainEventRequest) (*DomainEventResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Event not implemented")
+}
 func (UnimplementedDomainServer) mustEmbedUnimplementedDomainServer() {}
 func (UnimplementedDomainServer) testEmbeddedByValue()                {}
 
@@ -186,24 +211,6 @@ func RegisterDomainServer(s grpc.ServiceRegistrar, srv DomainServer) {
 	s.RegisterService(&Domain_ServiceDesc, srv)
 }
 
-func _Domain_Event_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(DomainEventRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(DomainServer).Event(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: Domain_Event_FullMethodName,
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DomainServer).Event(ctx, req.(*DomainEventRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _Domain_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DomainListAllRequest)
 	if err := dec(in); err != nil {
@@ -294,6 +301,17 @@ func _Domain_Delete_Handler(srv interface{}, ctx context.Context, dec func(inter
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Domain_Migrate_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(DomainMigrateRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(DomainServer).Migrate(m, &grpc.GenericServerStream[DomainMigrateRequest, DomainMigrateResponse]{ServerStream: stream})
+}
+
+// This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
+type Domain_MigrateServer = grpc.ServerStreamingServer[DomainMigrateResponse]
+
 func _Domain_Power_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(DomainPowerRequest)
 	if err := dec(in); err != nil {
@@ -312,6 +330,24 @@ func _Domain_Power_Handler(srv interface{}, ctx context.Context, dec func(interf
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Domain_Event_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DomainEventRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(DomainServer).Event(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Domain_Event_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(DomainServer).Event(ctx, req.(*DomainEventRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // Domain_ServiceDesc is the grpc.ServiceDesc for Domain service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -319,10 +355,6 @@ var Domain_ServiceDesc = grpc.ServiceDesc{
 	ServiceName: "deevirt.Domain",
 	HandlerType: (*DomainServer)(nil),
 	Methods: []grpc.MethodDesc{
-		{
-			MethodName: "Event",
-			Handler:    _Domain_Event_Handler,
-		},
 		{
 			MethodName: "List",
 			Handler:    _Domain_List_Handler,
@@ -347,8 +379,18 @@ var Domain_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Power",
 			Handler:    _Domain_Power_Handler,
 		},
+		{
+			MethodName: "Event",
+			Handler:    _Domain_Event_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "Migrate",
+			Handler:       _Domain_Migrate_Handler,
+			ServerStreams: true,
+		},
 	},
-	Streams:  []grpc.StreamDesc{},
 	Metadata: "proto/domain.proto",
 }
 

pkg/api/proto/node.pb.go

@@ -0,0 +1,206 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// versions:
+// 	protoc-gen-go v1.31.0
+// 	protoc        v3.14.0
+// source: proto/node.proto
+
+package proto
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+	reflect "reflect"
+	sync "sync"
+)
+
+const (
+	// Verify that this generated code is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
+	// Verify that runtime/protoimpl is sufficiently up-to-date.
+	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
+)
+
+type NodeLibvirtQemuRequest struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+
+	Domains []byte `protobuf:"bytes,1,opt,name=domains,proto3" json:"domains,omitempty"`
+}
+
+func (x *NodeLibvirtQemuRequest) Reset() {
+	*x = NodeLibvirtQemuRequest{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_node_proto_msgTypes[0]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NodeLibvirtQemuRequest) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeLibvirtQemuRequest) ProtoMessage() {}
+
+func (x *NodeLibvirtQemuRequest) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_node_proto_msgTypes[0]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeLibvirtQemuRequest.ProtoReflect.Descriptor instead.
+func (*NodeLibvirtQemuRequest) Descriptor() ([]byte, []int) {
+	return file_proto_node_proto_rawDescGZIP(), []int{0}
+}
+
+func (x *NodeLibvirtQemuRequest) GetDomains() []byte {
+	if x != nil {
+		return x.Domains
+	}
+	return nil
+}
+
+type NodeLibvirtQemuResponse struct {
+	state         protoimpl.MessageState
+	sizeCache     protoimpl.SizeCache
+	unknownFields protoimpl.UnknownFields
+}
+
+func (x *NodeLibvirtQemuResponse) Reset() {
+	*x = NodeLibvirtQemuResponse{}
+	if protoimpl.UnsafeEnabled {
+		mi := &file_proto_node_proto_msgTypes[1]
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		ms.StoreMessageInfo(mi)
+	}
+}
+
+func (x *NodeLibvirtQemuResponse) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*NodeLibvirtQemuResponse) ProtoMessage() {}
+
+func (x *NodeLibvirtQemuResponse) ProtoReflect() protoreflect.Message {
+	mi := &file_proto_node_proto_msgTypes[1]
+	if protoimpl.UnsafeEnabled && x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use NodeLibvirtQemuResponse.ProtoReflect.Descriptor instead.
+func (*NodeLibvirtQemuResponse) Descriptor() ([]byte, []int) {
+	return file_proto_node_proto_rawDescGZIP(), []int{1}
+}
+
+var File_proto_node_proto protoreflect.FileDescriptor
+
+var file_proto_node_proto_rawDesc = []byte{
+	0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x6e, 0x6f, 0x64, 0x65, 0x2e, 0x70, 0x72, 0x6f,
+	0x74, 0x6f, 0x12, 0x07, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x1a, 0x1b, 0x67, 0x6f, 0x6f,
+	0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70,
+	0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0x32, 0x0a, 0x16, 0x4e, 0x6f, 0x64, 0x65,
+	0x4c, 0x69, 0x62, 0x76, 0x69, 0x72, 0x74, 0x51, 0x65, 0x6d, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65,
+	0x73, 0x74, 0x12, 0x18, 0x0a, 0x07, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x07, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x73, 0x22, 0x19, 0x0a, 0x17,
+	0x4e, 0x6f, 0x64, 0x65, 0x4c, 0x69, 0x62, 0x76, 0x69, 0x72, 0x74, 0x51, 0x65, 0x6d, 0x75, 0x52,
+	0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x32, 0x50, 0x0a, 0x04, 0x4e, 0x6f, 0x64, 0x65, 0x12,
+	0x48, 0x0a, 0x0b, 0x4c, 0x69, 0x62, 0x76, 0x69, 0x72, 0x74, 0x51, 0x65, 0x6d, 0x75, 0x12, 0x1f,
+	0x2e, 0x64, 0x65, 0x65, 0x76, 0x69, 0x72, 0x74, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x4c, 0x69, 0x62,
+	0x76, 0x69, 0x72, 0x74, 0x51, 0x65, 0x6d, 0x75, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x70,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+}
+
+var (
+	file_proto_node_proto_rawDescOnce sync.Once
+	file_proto_node_proto_rawDescData = file_proto_node_proto_rawDesc
+)
+
+func file_proto_node_proto_rawDescGZIP() []byte {
+	file_proto_node_proto_rawDescOnce.Do(func() {
+		file_proto_node_proto_rawDescData = protoimpl.X.CompressGZIP(file_proto_node_proto_rawDescData)
+	})
+	return file_proto_node_proto_rawDescData
+}
+
+var file_proto_node_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
+var file_proto_node_proto_goTypes = []interface{}{
+	(*NodeLibvirtQemuRequest)(nil),  // 0: deevirt.NodeLibvirtQemuRequest
+	(*NodeLibvirtQemuResponse)(nil), // 1: deevirt.NodeLibvirtQemuResponse
+	(*emptypb.Empty)(nil),           // 2: google.protobuf.Empty
+}
+var file_proto_node_proto_depIdxs = []int32{
+	0, // 0: deevirt.Node.LibvirtQemu:input_type -> deevirt.NodeLibvirtQemuRequest
+	2, // 1: deevirt.Node.LibvirtQemu:output_type -> google.protobuf.Empty
+	1, // [1:2] is the sub-list for method output_type
+	0, // [0:1] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_proto_node_proto_init() }
+func file_proto_node_proto_init() {
+	if File_proto_node_proto != nil {
+		return
+	}
+	if !protoimpl.UnsafeEnabled {
+		file_proto_node_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeLibvirtQemuRequest); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+		file_proto_node_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} {
+			switch v := v.(*NodeLibvirtQemuResponse); i {
+			case 0:
+				return &v.state
+			case 1:
+				return &v.sizeCache
+			case 2:
+				return &v.unknownFields
+			default:
+				return nil
+			}
+		}
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: file_proto_node_proto_rawDesc,
+			NumEnums:      0,
+			NumMessages:   2,
+			NumExtensions: 0,
+			NumServices:   1,
+		},
+		GoTypes:           file_proto_node_proto_goTypes,
+		DependencyIndexes: file_proto_node_proto_depIdxs,
+		MessageInfos:      file_proto_node_proto_msgTypes,
+	}.Build()
+	File_proto_node_proto = out.File
+	file_proto_node_proto_rawDesc = nil
+	file_proto_node_proto_goTypes = nil
+	file_proto_node_proto_depIdxs = nil
+}

pkg/api/proto/node.proto

@@ -0,0 +1,16 @@
+syntax="proto3";
+import "google/protobuf/empty.proto";
+
+option go_package = "./proto";
+package deevirt;
+
+// The greeting service definition.
+service Node {
+    rpc LibvirtQemu (NodeLibvirtQemuRequest) returns(google.protobuf.Empty) {}
+}
+
+message NodeLibvirtQemuRequest {
+  bytes domains = 1;
+}
+
+message NodeLibvirtQemuResponse {}

pkg/api/proto/node_grpc.pb.go

@@ -0,0 +1,126 @@
+// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.5.1
+// - protoc             v3.14.0
+// source: proto/node.proto
+
+package proto
+
+import (
+	context "context"
+	grpc "google.golang.org/grpc"
+	codes "google.golang.org/grpc/codes"
+	status "google.golang.org/grpc/status"
+	emptypb "google.golang.org/protobuf/types/known/emptypb"
+)
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+// Requires gRPC-Go v1.64.0 or later.
+const _ = grpc.SupportPackageIsVersion9
+
+const (
+	Node_LibvirtQemu_FullMethodName = "/deevirt.Node/LibvirtQemu"
+)
+
+// NodeClient is the client API for Node service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
+//
+// The greeting service definition.
+type NodeClient interface {
+	LibvirtQemu(ctx context.Context, in *NodeLibvirtQemuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
+}
+
+type nodeClient struct {
+	cc grpc.ClientConnInterface
+}
+
+func NewNodeClient(cc grpc.ClientConnInterface) NodeClient {
+	return &nodeClient{cc}
+}
+
+func (c *nodeClient) LibvirtQemu(ctx context.Context, in *NodeLibvirtQemuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(emptypb.Empty)
+	err := c.cc.Invoke(ctx, Node_LibvirtQemu_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// NodeServer is the server API for Node service.
+// All implementations must embed UnimplementedNodeServer
+// for forward compatibility.
+//
+// The greeting service definition.
+type NodeServer interface {
+	LibvirtQemu(context.Context, *NodeLibvirtQemuRequest) (*emptypb.Empty, error)
+	mustEmbedUnimplementedNodeServer()
+}
+
+// UnimplementedNodeServer must be embedded to have
+// forward compatible implementations.
+//
+// NOTE: this should be embedded by value instead of pointer to avoid a nil
+// pointer dereference when methods are called.
+type UnimplementedNodeServer struct{}
+
+func (UnimplementedNodeServer) LibvirtQemu(context.Context, *NodeLibvirtQemuRequest) (*emptypb.Empty, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method LibvirtQemu not implemented")
+}
+func (UnimplementedNodeServer) mustEmbedUnimplementedNodeServer() {}
+func (UnimplementedNodeServer) testEmbeddedByValue()              {}
+
+// UnsafeNodeServer may be embedded to opt out of forward compatibility for this service.
+// Use of this interface is not recommended, as added methods to NodeServer will
+// result in compilation errors.
+type UnsafeNodeServer interface {
+	mustEmbedUnimplementedNodeServer()
+}
+
+func RegisterNodeServer(s grpc.ServiceRegistrar, srv NodeServer) {
+	// If the following call pancis, it indicates UnimplementedNodeServer was
+	// embedded by pointer and is nil.  This will cause panics if an
+	// unimplemented method is ever invoked, so we test this at initialization
+	// time to prevent it from happening at runtime later due to I/O.
+	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
+		t.testEmbeddedByValue()
+	}
+	s.RegisterService(&Node_ServiceDesc, srv)
+}
+
+func _Node_LibvirtQemu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(NodeLibvirtQemuRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(NodeServer).LibvirtQemu(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: Node_LibvirtQemu_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(NodeServer).LibvirtQemu(ctx, req.(*NodeLibvirtQemuRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+// Node_ServiceDesc is the grpc.ServiceDesc for Node service.
+// It's only intended for direct use with grpc.RegisterService,
+// and not to be introspected or modified (even as a copy)
+var Node_ServiceDesc = grpc.ServiceDesc{
+	ServiceName: "deevirt.Node",
+	HandlerType: (*NodeServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "LibvirtQemu",
+			Handler:    _Node_LibvirtQemu_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "proto/node.proto",
+}

pkg/api/raft/fsm.go

@@ -12,6 +12,10 @@ type Fsm Store
 
 // Apply applies a Raft log entry to the key-value store.
 func (f *Fsm) Apply(l *raft.Log) interface{} {
+	/*if f.Raft.State() == raft.Leader {
+		println("j'insert dans etcd !")
+	}*/
+
 	var c command
 	if err := json.Unmarshal(l.Data, &c); err != nil {
 		panic(fmt.Sprintf("failed to unmarshal command: %s", err.Error()))
@@ -33,16 +37,18 @@ func (f *Fsm) Snapshot() (raft.FSMSnapshot, error) {
 	defer f.mu.Unlock()
 
 	// Clone the map.
-	o := make(map[string]string)
+	o := make(map[string][]byte)
 	for k, v := range f.m {
 		o[k] = v
 	}
+
 	return &fsmSnapshot{store: o}, nil
 }
 
 // Restore stores the key-value store to a previous state.
 func (f *Fsm) Restore(rc io.ReadCloser) error {
-	o := make(map[string]string)
+	o := make(map[string][]byte)
+
 	if err := json.NewDecoder(rc).Decode(&o); err != nil {
 		return err
 	}
@@ -53,7 +59,7 @@ func (f *Fsm) Restore(rc io.ReadCloser) error {
 	return nil
 }
 
-func (f *Fsm) applySet(key, value string) interface{} {
+func (f *Fsm) applySet(key string, value []byte) interface{} {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	f.m[key] = value
@@ -68,7 +74,7 @@ func (f *Fsm) applyDelete(key string) interface{} {
 }
 
 type fsmSnapshot struct {
-	store map[string]string
+	store map[string][]byte
 }
 
 func (f *fsmSnapshot) Persist(sink raft.SnapshotSink) error {
@@ -95,4 +101,5 @@ func (f *fsmSnapshot) Persist(sink raft.SnapshotSink) error {
 	return err
 }
 
-func (f *fsmSnapshot) Release() {}
+func (f *fsmSnapshot) Release() {
+}

pkg/api/raft/node.go

@@ -0,0 +1,123 @@
+package raft
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+
+	raft_hashicorp "github.com/hashicorp/raft"
+	"libvirt.org/go/libvirt"
+
+	etcd_client "deevirt.fr/compute/pkg/etcd"
+	//"deevirt.fr/compute/pkg/scheduler"
+)
+
+type RaftNode struct {
+	Bootstrap bool
+	Raft      *raft_hashicorp.Raft
+	Store     *Store
+	NodeID    string
+	StateCh   chan raft_hashicorp.Observation
+}
+
+func (n *RaftNode) init() {
+	println("bootstrap :")
+	nodes := make(NodeStore)
+
+	// Récupération des Noeuds ID
+	etcd, _ := etcd_client.New(n.Store.conf.EtcdURI)
+	defer etcd.Close()
+
+	for key, value := range etcd_client.GetNodes(etcd, n.Store.conf.ClusterID) {
+		nodes[key] = NodeStoreInfo{
+			IpManagement: value.IpManagement,
+			Scoring:      0,
+		}
+		println(key)
+		println(value.IpManagement)
+
+		var libvirt_uri string
+
+		if n.Store.conf.LibvirtTLS {
+			libvirt_uri = fmt.Sprintf("qemu+tls://%s/system", value.IpManagement)
+		} else {
+			libvirt_uri = fmt.Sprintf("qemu+tcp://%s/system", value.IpManagement)
+		}
+
+		c, err := libvirt.NewConnect(libvirt_uri)
+		if err != nil {
+			log.Fatalf("Erreur %v", err)
+		}
+		defer c.Close()
+
+		getDomains, _ := c.ListAllDomains(libvirt.CONNECT_LIST_DOMAINS_PERSISTENT)
+		for _, domain := range getDomains {
+			conf, _ := domain.GetXMLDesc(libvirt.DOMAIN_XML_INACTIVE)
+			uuid, _ := domain.GetUUIDString()
+			state, _, _ := domain.GetState()
+
+			d, _ := json.Marshal(struct {
+				Config  string `json:"config"`
+				State   int    `json:"state"`
+				Migrate bool   `json:"Migrate"`
+			}{
+				conf, int(state), false,
+			})
+
+			n.Store.Set(fmt.Sprintf("/etc/libvirt/qemu/%s/%s", key, uuid), d)
+		}
+	}
+
+	jNodes, _ := json.Marshal(nodes)
+	n.Store.Set("/etc/libvirt/cluster", jNodes)
+}
+
+// Fonction pour surveiller et afficher les changements d'état
+func (n *RaftNode) WatchStateChanges() {
+	sched, _ := NewScheduler(n.Store)
+
+	for obs := range n.StateCh {
+		switch evt := obs.Data.(type) {
+		case raft_hashicorp.RaftState:
+
+			if evt == raft_hashicorp.Leader {
+				log.Println("[ÉVÉNEMENT] Changement d'état Raft :", evt)
+				if n.Bootstrap {
+					n.init()
+				}
+
+				// On attend une seconde avant de démarrer le scheduler
+				time.Sleep(1 * time.Second)
+
+				go sched.Start()
+
+			} else {
+				sched.Stop()
+			}
+
+			log.Println("[ÉVÉNEMENT] Changement d'état Raft :", evt)
+		case raft_hashicorp.LeaderObservation:
+			log.Println("[ÉVÉNEMENT] Le leader est", evt.LeaderID)
+		case raft_hashicorp.PeerObservation:
+			if n.Raft.State() == raft_hashicorp.Leader {
+				peerID := evt.Peer.ID
+				peerAddr := evt.Peer.Address
+
+				log.Println("[NOUVEAU NŒUD] Détection de", peerID, "à", peerAddr)
+				log.Println("[ACTION] Ajout automatique en tant que voter...")
+
+				future := n.Raft.AddVoter(peerID, peerAddr, 0, 0)
+				if err := future.Error(); err != nil {
+					log.Println("[ERREUR] Impossible d'ajouter", peerID, ":", err)
+				} else {
+					log.Println("[SUCCÈS] Voter ajouté :", peerID)
+				}
+			}
+		case raft_hashicorp.FailedHeartbeatObservation:
+			log.Println("[ÉVÉNEMENT] Perte de connexion avec un nœud :", evt.PeerID)
+		default:
+			log.Println("[ÉVÉNEMENT] Autre événement :", evt)
+		}
+	}
+}

pkg/api/raft/scheduler.go

@@ -0,0 +1,144 @@
+package raft
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"time"
+
+	prom_api "github.com/prometheus/client_golang/api"
+	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
+	"github.com/prometheus/common/model"
+	"go.uber.org/zap"
+
+	"deevirt.fr/compute/pkg/config"
+)
+
+type Scheduler struct {
+	ctx       context.Context
+	cancel    context.CancelFunc
+	cancelled bool
+
+	store *Store
+
+	config *config.Config
+	log    *zap.Logger
+}
+
+func NewScheduler(r *Store) (*Scheduler, error) {
+	config, _ := config.New()
+	ctx, cancel := context.WithCancel(context.Background())
+
+	logger, _ := zap.NewProduction()
+
+	s := &Scheduler{
+		ctx:       ctx,
+		cancel:    cancel,
+		cancelled: true,
+
+		store: r,
+
+		config: config,
+		log:    logger,
+	}
+
+	return s, nil
+}
+
+func (w *Scheduler) api() (v1.API, error) {
+	client, err := prom_api.NewClient(prom_api.Config{
+		Address: "http://172.16.9.161:9090",
+	})
+	if err != nil {
+		w.log.Error("Prometheus HS")
+		return nil, nil
+	}
+
+	return v1.NewAPI(client), nil
+}
+
+func (w *Scheduler) Start() {
+	go func() {
+		// On synchronise l'état des hotes
+
+		for {
+			select {
+			case <-w.ctx.Done():
+				fmt.Println("🛑 Worker arrêté !")
+				return
+			default:
+				fmt.Println("🔄 Controle périodique en cours...")
+				w.Alerts()
+				/*for _, t := range w.checkHA() {
+					w.restartDomain(t)
+				}*/
+
+				time.Sleep(1 * time.Minute)
+			}
+		}
+	}()
+}
+
+func (w *Scheduler) Stop() {
+	if !w.cancelled {
+		w.cancel()
+		w.cancelled = true
+	}
+}
+
+/*
+On récupère les alertes
+*/
+func (w *Scheduler) Alerts() {
+	api, err := w.api()
+	if err != nil {
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// On controle l'état du cluster
+	query := fmt.Sprintf("ALERTS_FOR_STATE{cluster_id=\"%s\", type=\"deevirt_default\"}\n", w.config.ClusterID)
+	alerts, _, err := api.Query(ctx, query, time.Now())
+	if err != nil {
+		log.Fatalf("Erreur lors de la récupération des alertes filtrées: %v", err)
+	}
+
+	if alerts.Type() == model.ValVector {
+		for _, alert := range alerts.(model.Vector) {
+			if alert.Metric["severity"] == "critical" {
+				// En situation critique, on abandonne toutes les actions
+				return
+			}
+		}
+	}
+
+	query = fmt.Sprintf("ALERTS_FOR_STATE{cluster_id=\"%s\", type=\"deevirt_node_default\"}\n", w.config.ClusterID)
+	alerts, _, err = api.Query(ctx, query, time.Now())
+	if err != nil {
+		log.Fatalf("Erreur lors de la récupération des alertes filtrées: %v", err)
+	}
+
+	if alerts.Type() == model.ValVector {
+		for _, alert := range alerts.(model.Vector) {
+			println(alert.Metric["node_id"])
+			t, _ := w.store.Ls(fmt.Sprintf("/etc/libvirt/qemu/%s", alert.Metric["node_id"]), LsOptions{
+				Recursive: false,
+				Data:      true,
+			})
+
+			for k, v := range t {
+				var n DomainStore
+				json.Unmarshal(v, &n)
+
+				fmt.Printf("On relance la VM %s\n", k)
+
+				fmt.Printf("%v\n", n.State)
+			}
+
+			log.Printf("%v\n", alert)
+		}
+	}
+}

pkg/api/raft/schema.go

@@ -0,0 +1,19 @@
+package raft
+
+type NodeStore map[string]NodeStoreInfo
+
+type NodeStoreInfo struct {
+	IpManagement string
+	Scoring      int
+}
+
+type SchemaDomain struct {
+	Config string `json:"config"`
+	State  int    `json:"state"`
+}
+
+type DomainStore struct {
+	Config  string `json:"config"`
+	State   int    `json:"state"`
+	Migrate bool   `json:"Migrate"`
+}

pkg/api/raft/store.go

@@ -0,0 +1,287 @@
+package raft
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	transport "deevirt.fr/compute/pkg/api/raft/transport"
+	"github.com/hashicorp/raft"
+	raftboltdb "github.com/hashicorp/raft-boltdb/v2"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+
+	"deevirt.fr/compute/pkg/config"
+	etcd_client "deevirt.fr/compute/pkg/etcd"
+)
+
+const (
+	retainSnapshotCount = 2
+	raftTimeout         = 10 * time.Second
+)
+
+type Domain struct {
+	State  int
+	Config byte
+	CPUMAP byte
+}
+
+type Node struct {
+	Domains []Domain
+}
+
+type command struct {
+	Op    string `json:"op,omitempty"`
+	Key   string `json:"key,omitempty"`
+	Value []byte `json:"value,omitempty"`
+}
+
+type Store struct {
+	mu   sync.Mutex
+	conf *config.Config // Configuration générale
+
+	m map[string][]byte // The key-value store for the system.
+
+	Raft *raft.Raft // The consensus mechanism
+
+	logger *log.Logger
+}
+
+type Peers struct {
+	Id      string
+	Address string
+}
+
+func getTLSCredentials(conf *config.Config) credentials.TransportCredentials {
+	cert, err := tls.LoadX509KeyPair(conf.Manager.TlsCert, conf.Manager.TlsKey)
+	if err != nil {
+		log.Fatalf("Erreur chargement du certificat: %v", err)
+	}
+
+	// Charger la CA (facultatif, pour la vérification des clients)
+	caCert, err := os.ReadFile(conf.Manager.TlsCert)
+	if err != nil {
+		log.Fatalf("Erreur chargement CA: %v", err)
+	}
+	certPool := x509.NewCertPool()
+	certPool.AppendCertsFromPEM(caCert)
+
+	// Créer les credentials TLS
+	creds := credentials.NewTLS(&tls.Config{
+		Certificates:       []tls.Certificate{cert},
+		ClientCAs:          certPool,
+		InsecureSkipVerify: true,
+	})
+
+	return creds
+}
+
+func New(conf *config.Config) *Store {
+	return &Store{
+		conf:   conf,
+		m:      make(map[string][]byte),
+		logger: log.New(os.Stderr, "[store] ", log.LstdFlags),
+	}
+}
+
+func (s *Store) Open() (*transport.Manager, error) {
+	// Création du répertoire
+	baseDir := filepath.Join("/var/lib/deevirt/mgr/", s.conf.NodeID)
+	err := os.MkdirAll(baseDir, 0740)
+	if err != nil {
+		return nil, err
+	}
+
+	c := raft.DefaultConfig()
+	c.SnapshotInterval = 60 * time.Second
+	c.SnapshotThreshold = 1000
+	c.HeartbeatTimeout = 2 * time.Second
+	c.ElectionTimeout = 3 * time.Second
+
+	c.LocalID = raft.ServerID(s.conf.NodeID)
+
+	ldb, err := raftboltdb.NewBoltStore(filepath.Join(baseDir, "logs.dat"))
+	if err != nil {
+		return nil, fmt.Errorf(`boltdb.NewBoltStore(%q): %v`, filepath.Join(baseDir, "logs.dat"), err)
+	}
+
+	fss, err := raft.NewFileSnapshotStore(baseDir, 3, os.Stderr)
+	if err != nil {
+		return nil, fmt.Errorf(`raft.NewFileSnapshotStore(%q, ...): %v`, baseDir, err)
+	}
+
+	dialOption := []grpc.DialOption{}
+
+	if s.conf.Manager.TlsKey != "" {
+		dialOption = append(dialOption, grpc.WithTransportCredentials(getTLSCredentials(s.conf)))
+	}
+
+	tm := transport.New(raft.ServerAddress(s.conf.AddressPrivate), dialOption)
+
+	r, err := raft.NewRaft(c, (*Fsm)(s), ldb, ldb, fss, tm.Transport())
+	if err != nil {
+		return nil, fmt.Errorf("raft.NewRaft: %v", err)
+	}
+	s.Raft = r
+
+	// Observer pour surveiller les changements d'état
+	stateCh := make(chan raft.Observation, 1) // Canal de type raft.Observation
+	r.RegisterObserver(raft.NewObserver(stateCh, true, nil))
+
+	node := &RaftNode{
+		Bootstrap: false,
+		Raft:      r,
+		Store:     s,
+		NodeID:    s.conf.NodeID,
+		StateCh:   stateCh,
+	}
+
+	go node.WatchStateChanges()
+
+	hasState, _ := checkIfStateExists(ldb)
+
+	if strings.Split(s.conf.AddressPrivate, ":")[0] == s.conf.AddressPrivate && !hasState {
+		println("Démarrage du bootstrap ! ")
+		node.Bootstrap = true
+
+		// Récupération des Noeuds ID
+		etcd, err := etcd_client.New(s.conf.EtcdURI)
+		if err != nil {
+			return nil, err
+		}
+		defer etcd.Close()
+
+		peers := []raft.Server{}
+
+		for key, value := range etcd_client.GetNodes(etcd, s.conf.ClusterID) {
+			for _, peer := range s.conf.Manager.Peers {
+				addressPort := strings.Split(peer, ":")
+				if addressPort[0] == value.IpManagement {
+					peers = append(peers, raft.Server{
+						ID:      raft.ServerID(key),
+						Address: raft.ServerAddress(peer),
+					})
+				}
+			}
+		}
+
+		cfg := raft.Configuration{
+			Servers: peers,
+		}
+		f := r.BootstrapCluster(cfg)
+		if err := f.Error(); err != nil {
+			return nil, fmt.Errorf("raft.Raft.BootstrapCluster: %v", err)
+		}
+	}
+
+	return tm, nil
+}
+
+type LsOptions struct {
+	Recursive bool
+	Data      bool
+}
+
+// Retourne le contenu de la clé
+func (s *Store) Ls(key string, options LsOptions) (map[string][]byte, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	dir := map[string][]byte{}
+
+	for k, v := range s.m {
+		if options.Recursive {
+			re := regexp.MustCompile(fmt.Sprintf("^%s/([^/]+)/([^/]+)", key))
+			matches := re.FindStringSubmatch(k)
+			if matches != nil {
+				if options.Data {
+					dir[strings.Join(matches[1:], "/")] = v
+				} else {
+					dir[strings.Join(matches[1:], "/")] = nil
+				}
+			}
+		} else {
+			re := regexp.MustCompile(fmt.Sprintf("^%s/([^/]+)$", key))
+			matches := re.FindStringSubmatch(k)
+			if matches != nil {
+				if options.Data {
+					dir[matches[1]] = v
+				} else {
+					dir[matches[1]] = nil
+				}
+			}
+		}
+
+	}
+
+	return dir, nil
+}
+
+// Get returns the value for the given key.
+func (s *Store) Get(key string) ([]byte, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.m[key], nil
+}
+
+// Set sets the value for the given key.
+func (s *Store) Set(key string, value []byte) error {
+	if s.Raft.State() != raft.Leader {
+		return fmt.Errorf("not leader")
+	}
+
+	c := &command{
+		Op:    "set",
+		Key:   key,
+		Value: value,
+	}
+	b, err := json.Marshal(c)
+	if err != nil {
+		return err
+	}
+
+	f := s.Raft.Apply(b, raftTimeout)
+	return f.Error()
+}
+
+// Delete deletes the given key.
+func (s *Store) Delete(key string) error {
+	if s.Raft.State() != raft.Leader {
+		return fmt.Errorf("not leader")
+	}
+
+	c := &command{
+		Op:  "delete",
+		Key: key,
+	}
+	b, err := json.Marshal(c)
+	if err != nil {
+		return err
+	}
+
+	f := s.Raft.Apply(b, raftTimeout)
+	return f.Error()
+}
+
+// Vérifie si l'état Raft existe déjà
+func checkIfStateExists(logStore *raftboltdb.BoltStore) (bool, error) {
+	// Vérifier les logs Raft
+	firstIndex, err := logStore.FirstIndex()
+	if err != nil {
+		return false, err
+	}
+
+	if firstIndex > 0 {
+		return true, nil
+	}
+
+	return false, nil
+}

pkg/api/server.go

@@ -12,9 +12,10 @@ import (
 	"google.golang.org/grpc/credentials"
 	"google.golang.org/grpc/reflection"
 
+	"deevirt.fr/compute/pkg/api/domain"
 	pb "deevirt.fr/compute/pkg/api/proto"
+	"deevirt.fr/compute/pkg/api/raft"
 	"deevirt.fr/compute/pkg/config"
-	"deevirt.fr/compute/pkg/raft"
 )
 
 func createGRPCServer(conf *config.Config) *grpc.Server {
@@ -59,7 +60,7 @@ func Server() {
 		log.Fatalf("failed to listen: %v", err)
 	}
 
-	r := raft.New(conf, 4480)
+	r := raft.New(conf)
 
 	tm, err := r.Open()
 	if err != nil {
@@ -67,7 +68,11 @@ func Server() {
 	}
 
 	s := createGRPCServer(conf)
-	pb.RegisterDomainServer(s, &Domain{
+	pb.RegisterNodeServer(s, &Node{
+		Config: conf,
+		Store:  r,
+	})
+	pb.RegisterDomainServer(s, &domain.Domain{
 		Config: conf,
 		Store:  r,
 	})

pkg/prom/prom.go

@@ -0,0 +1,14 @@
+package prom
+
+import (
+	"github.com/prometheus/client_golang/api"
+	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
+)
+
+func New() (v1.API, error) {
+	client, err := api.NewClient(api.Config{
+		Address: "http://localhost:9090", // Remplacez par l'URL de votre Prometheus
+	})
+
+	return v1.NewAPI(client), err
+}

pkg/raft/store.go

@@ -1,371 +0,0 @@
-package raft
-
-import (
-	"crypto/tls"
-	"crypto/x509"
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-
-	transport "deevirt.fr/compute/pkg/raft/transport"
-	"github.com/hashicorp/raft"
-	raftboltdb "github.com/hashicorp/raft-boltdb/v2"
-	"google.golang.org/grpc"
-	"google.golang.org/grpc/credentials"
-
-	"deevirt.fr/compute/pkg/config"
-	etcd_client "deevirt.fr/compute/pkg/etcd"
-	"deevirt.fr/compute/pkg/scheduler"
-)
-
-const (
-	retainSnapshotCount = 2
-	raftTimeout         = 10 * time.Second
-)
-
-type command struct {
-	Op    string `json:"op,omitempty"`
-	Key   string `json:"key,omitempty"`
-	Value string `json:"value,omitempty"`
-}
-
-type Store struct {
-	mu   sync.Mutex
-	conf *config.Config // Configuration générale
-	port int            // Port de communication (identique au serveur GRPC)
-
-	m map[string]string // The key-value store for the system.
-
-	Raft *raft.Raft // The consensus mechanism
-
-	logger *log.Logger
-}
-
-type RaftNode struct {
-	Raft      *raft.Raft
-	NodeID    string
-	StateCh   chan raft.Observation
-	scheduler *scheduler.Scheduler
-}
-
-type Peers struct {
-	Id      string
-	Address string
-}
-
-func getTLSCredentials(conf *config.Config) credentials.TransportCredentials {
-	cert, err := tls.LoadX509KeyPair(conf.Manager.TlsCert, conf.Manager.TlsKey)
-	if err != nil {
-		log.Fatalf("Erreur chargement du certificat: %v", err)
-	}
-
-	// Charger la CA (facultatif, pour la vérification des clients)
-	caCert, err := os.ReadFile(conf.Manager.TlsCert)
-	if err != nil {
-		log.Fatalf("Erreur chargement CA: %v", err)
-	}
-	certPool := x509.NewCertPool()
-	certPool.AppendCertsFromPEM(caCert)
-
-	// Créer les credentials TLS
-	creds := credentials.NewTLS(&tls.Config{
-		Certificates:       []tls.Certificate{cert},
-		ClientCAs:          certPool,
-		InsecureSkipVerify: true,
-	})
-
-	return creds
-}
-
-func New(conf *config.Config, port int) *Store {
-	return &Store{
-		conf:   conf,
-		port:   port,
-		m:      make(map[string]string),
-		logger: log.New(os.Stderr, "[store] ", log.LstdFlags),
-	}
-}
-
-func (s *Store) Open() (*transport.Manager, error) {
-	// Création du répertoire
-	baseDir := filepath.Join("/var/lib/deevirt/mgr/", s.conf.NodeID)
-	err := os.MkdirAll(baseDir, 0740)
-	if err != nil {
-		return nil, err
-	}
-
-	// Récupération des Noeuds ID
-	etcd, err := etcd_client.New(s.conf.EtcdURI)
-	if err != nil {
-		return nil, err
-	}
-	defer etcd.Close()
-
-	peers := []raft.Server{}
-
-	for key, value := range etcd_client.GetNodes(etcd, s.conf.ClusterID) {
-		var p string
-
-		for _, peer := range s.conf.Manager.Peers {
-			if peer == value.IpManagement {
-				p = peer
-			}
-		}
-
-		if p != "" {
-			peers = append(peers, raft.Server{
-				ID:      raft.ServerID(key),
-				Address: raft.ServerAddress(fmt.Sprintf("%s:%d", p, s.port)),
-			})
-		}
-	}
-
-	c := raft.DefaultConfig()
-	c.LocalID = raft.ServerID(s.conf.NodeID)
-
-	ldb, err := raftboltdb.NewBoltStore(filepath.Join(baseDir, "logs.dat"))
-	if err != nil {
-		return nil, fmt.Errorf(`boltdb.NewBoltStore(%q): %v`, filepath.Join(baseDir, "logs.dat"), err)
-	}
-
-	fss, err := raft.NewFileSnapshotStore(baseDir, 3, os.Stderr)
-	if err != nil {
-		return nil, fmt.Errorf(`raft.NewFileSnapshotStore(%q, ...): %v`, baseDir, err)
-	}
-
-	dialOption := []grpc.DialOption{}
-
-	if s.conf.Manager.TlsKey != "" {
-		dialOption = append(dialOption, grpc.WithTransportCredentials(getTLSCredentials(s.conf)))
-	}
-
-	tm := transport.New(raft.ServerAddress(fmt.Sprintf("%s:%d", s.conf.AddressPrivate, s.port)), dialOption)
-
-	r, err := raft.NewRaft(c, (*Fsm)(s), ldb, ldb, fss, tm.Transport())
-	if err != nil {
-		return nil, fmt.Errorf("raft.NewRaft: %v", err)
-	}
-	s.Raft = r
-
-	sched, err := scheduler.New()
-	if err != nil {
-		return nil, fmt.Errorf("scheduler: %v", err)
-	}
-
-	// Observer pour surveiller les changements d'état
-	stateCh := make(chan raft.Observation, 1) // Canal de type raft.Observation
-	r.RegisterObserver(raft.NewObserver(stateCh, true, nil))
-
-	node := &RaftNode{
-		Raft:      r,
-		NodeID:    s.conf.NodeID,
-		StateCh:   stateCh,
-		scheduler: sched,
-	}
-
-	go node.watchStateChanges()
-
-	hasState, _ := checkIfStateExists(ldb)
-
-	if s.conf.Manager.Peers[0] == s.conf.AddressPrivate && !hasState {
-		println("Démarrage du bootstrap ! ")
-
-		cfg := raft.Configuration{
-			Servers: peers,
-		}
-		f := r.BootstrapCluster(cfg)
-		if err := f.Error(); err != nil {
-			return nil, fmt.Errorf("raft.Raft.BootstrapCluster: %v", err)
-		}
-	}
-
-	return tm, nil
-}
-
-// Get returns the value for the given key.
-func (s *Store) Get(key string) (string, error) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	fmt.Printf("%v", s.m)
-	return s.m[key], nil
-}
-
-// Set sets the value for the given key.
-func (s *Store) Set(key, value string) error {
-	if s.Raft.State() != raft.Leader {
-		return fmt.Errorf("not leader")
-	}
-
-	c := &command{
-		Op:    "set",
-		Key:   key,
-		Value: value,
-	}
-	b, err := json.Marshal(c)
-	if err != nil {
-		return err
-	}
-
-	f := s.Raft.Apply(b, raftTimeout)
-	return f.Error()
-}
-
-// Delete deletes the given key.
-func (s *Store) Delete(key string) error {
-	if s.Raft.State() != raft.Leader {
-		return fmt.Errorf("not leader")
-	}
-
-	c := &command{
-		Op:  "delete",
-		Key: key,
-	}
-	b, err := json.Marshal(c)
-	if err != nil {
-		return err
-	}
-
-	f := s.Raft.Apply(b, raftTimeout)
-	return f.Error()
-}
-
-// Vérifie si l'état Raft existe déjà
-func checkIfStateExists(logStore *raftboltdb.BoltStore) (bool, error) {
-	// Vérifier les logs Raft
-	firstIndex, err := logStore.FirstIndex()
-	if err != nil {
-		return false, err
-	}
-
-	if firstIndex > 0 {
-		return true, nil
-	}
-
-	return false, nil
-}
-
-// Fonction pour surveiller et afficher les changements d'état
-func (n *RaftNode) watchStateChanges() {
-	for obs := range n.StateCh {
-		switch evt := obs.Data.(type) {
-		case raft.RaftState:
-
-			if evt == raft.Leader {
-				go n.scheduler.Start()
-
-				log.Println("[ÉVÉNEMENT] Changement d'état Raft :", evt)
-			} else {
-				n.scheduler.Stop()
-			}
-
-			log.Println("[ÉVÉNEMENT] Changement d'état Raft :", evt)
-		case raft.LeaderObservation:
-			log.Println("[ÉVÉNEMENT] Le leader est", evt.LeaderID)
-		case raft.PeerObservation:
-			if n.Raft.State() == raft.Leader {
-				peerID := evt.Peer.ID
-				peerAddr := evt.Peer.Address
-
-				log.Println("[NOUVEAU NŒUD] Détection de", peerID, "à", peerAddr)
-				log.Println("[ACTION] Ajout automatique en tant que voter...")
-
-				future := n.Raft.AddVoter(peerID, peerAddr, 0, 0)
-				if err := future.Error(); err != nil {
-					log.Println("[ERREUR] Impossible d'ajouter", peerID, ":", err)
-				} else {
-					log.Println("[SUCCÈS] Voter ajouté :", peerID)
-				}
-			}
-		case raft.FailedHeartbeatObservation:
-			log.Println("[ÉVÉNEMENT] Perte de connexion avec un nœud :", evt.PeerID)
-		default:
-			log.Println("[ÉVÉNEMENT] Autre événement :", evt)
-		}
-	}
-}
-
-/*func New(ctx context.Context, myID, myAddress string) (*raft.Raft, *transport.Manager, error) {
-	// Création du répertoire
-	baseDir := filepath.Join("/var/lib/deevirt/mgr/", myID)
-	err := os.MkdirAll(baseDir, 0740)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	println(myAddress)
-
-	peers := []raft.Server{
-		{
-			ID:      raft.ServerID("nodeA"),
-			Address: raft.ServerAddress("172.16.9.161:4410"),
-		},
-		{
-			ID:      raft.ServerID("nodeB"),
-			Address: raft.ServerAddress("172.16.9.161:4411"),
-		},
-	}
-
-	c := raft.DefaultConfig()
-	c.LocalID = raft.ServerID(myID)
-
-	ldb, err := raftboltdb.NewBoltStore(filepath.Join(baseDir, "logs.dat"))
-	if err != nil {
-		return nil, nil, fmt.Errorf(`boltdb.NewBoltStore(%q): %v`, filepath.Join(baseDir, "logs.dat"), err)
-	}
-
-	sdb, err := raftboltdb.NewBoltStore(filepath.Join(baseDir, "stable.dat"))
-	if err != nil {
-		return nil, nil, fmt.Errorf(`boltdb.NewBoltStore(%q): %v`, filepath.Join(baseDir, "stable.dat"), err)
-	}
-
-	fss, err := raft.NewFileSnapshotStore(baseDir, 3, os.Stderr)
-	if err != nil {
-		return nil, nil, fmt.Errorf(`raft.NewFileSnapshotStore(%q, ...): %v`, baseDir, err)
-	}
-
-	tm := transport.New(raft.ServerAddress(myAddress), []grpc.DialOption{grpc.WithTransportCredentials(getTLSCredentials())})
-
-	r, err := raft.NewRaft(c, nil, ldb, sdb, fss, tm.Transport())
-	if err != nil {
-		return nil, nil, fmt.Errorf("raft.NewRaft: %v", err)
-	}
-
-	s, err := scheduler.New()
-	if err != nil {
-		return nil, nil, fmt.Errorf("scheduler: %v", err)
-	}
-
-	// Observer pour surveiller les changements d'état
-	stateCh := make(chan raft.Observation, 1) // Canal de type raft.Observation
-	r.RegisterObserver(raft.NewObserver(stateCh, true, nil))
-
-	node := &RaftNode{
-		Raft:      r,
-		NodeID:    myID,
-		StateCh:   stateCh,
-		scheduler: s,
-	}
-
-	go node.watchStateChanges()
-
-	hasState, _ := checkIfStateExists(ldb)
-
-	if myAddress == "172.16.9.161:4410" && !hasState {
-		println("Démarrage du bootstrap ! ")
-
-		cfg := raft.Configuration{
-			Servers: peers,
-		}
-		f := r.BootstrapCluster(cfg)
-		if err := f.Error(); err != nil {
-			return nil, nil, fmt.Errorf("raft.Raft.BootstrapCluster: %v", err)
-		}
-	}
-
-	return r, tm, nil
-}*/

pkg/raft/worker.go

@@ -1,41 +0,0 @@
-package raft
-
-import (
-	"context"
-	"fmt"
-	"time"
-)
-
-type Worker struct {
-	ctx       context.Context
-	cancel    context.CancelFunc
-	cancelled bool // Variable pour suivre si cancel a été appelé
-}
-
-func (w *Worker) Start() {
-	go func() {
-		for {
-			select {
-			case <-w.ctx.Done():
-				fmt.Println("🛑 Worker arrêté !")
-				return
-			default:
-				fmt.Println("🔄 Worker en cours...")
-				time.Sleep(1 * time.Second)
-			}
-		}
-	}()
-}
-
-func (w *Worker) Stop() {
-	if !w.cancelled {
-		w.cancel()         // Annuler le contexte
-		w.cancelled = true // Marquer comme annulé
-	} else {
-		fmt.Println("❗ Cancel déjà appelé, Worker déjà arrêté.")
-	}
-}
-
-func (w *Worker) IsCancelled() bool {
-	return w.cancelled
-}

pkg/scheduler/ha.go

@@ -3,95 +3,52 @@ package scheduler
 import (
 	"context"
 	"fmt"
-	"log"
-	"regexp"
-	"strings"
 	"time"
 
-	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
 	"github.com/prometheus/common/model"
-	clientv3 "go.etcd.io/etcd/client/v3"
 )
 
-type nodeDown struct {
+func (s *Scheduler) GetAlertCluster() ([]AlertsCluster, error) {
-	node_id string
-	domains []string
-}
-
-func (w *Scheduler) checkHA() []nodeDown {
-	s := []nodeDown{}
-
-	etcd, err := clientv3.New(clientv3.Config{
-		Endpoints:   strings.Split(w.config.EtcdURI, ","),
-		DialTimeout: 5 * time.Second,
-	})
-	if err != nil {
-		log.Fatalf("Error connexion to etcd: %v", err)
-	}
-	defer etcd.Close()
-
-	r := v1.Range{
-		Start: time.Now().Add(-time.Minute),
-		End:   time.Now(),
-		Step:  2 * time.Minute,
-	}
-
-	api, err := w.api()
-	if err != nil {
-		return s
-	}
-
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
-	println("up{cluster_id=" + w.config.ClusterID + "}")
+	// On récupère les alertes sur les noeuds
-
+	query := fmt.Sprintf("ALERTS_FOR_STATE{cluster_id=\"%s\", type=\"deevirt_default\"}\n", s.Config.ClusterID)
-	result, warnings, err := api.QueryRange(ctx, "up{cluster_id='"+w.config.ClusterID+"'}", r, v1.WithTimeout(5*time.Second))
+	res, _, err := s.Api.Query(ctx, query, time.Now())
 	if err != nil {
-		fmt.Printf("Error querying Prometheus: %v\n", err)
+		return nil, fmt.Errorf("erreur lors de la récupération des alertes filtrées: %v", err)
-	}
-	if len(warnings) > 0 {
-		fmt.Printf("Warnings: %v\n", warnings)
 	}
 
-	matrix, _ := result.(model.Matrix)
+	data := []AlertsCluster{}
-
+	for _, res := range res.(model.Vector) {
-	for _, stream := range matrix {
+		data = append(data, AlertsCluster{
-		node_id := ""
+			Severity: string(res.Metric["Severity"]),
-		domains := []string{}
+			Score:    uint8(res.Value),
-
+		})
-		for key, value := range stream.Metric {
-			if key == "node_id" {
-				//test.instance = string(value)
-				node_id = string(value)
-			}
-
-		}
-
-		state := int(stream.Values[0].Value)
-
-		if state == 1 {
-			re := regexp.MustCompile(`qemu/(?P<domainID>[a-zA-Z0-9-]+)`)
-
-			resp, _ := etcd.Get(ctx, "/cluster/"+w.config.ClusterID+"/host/"+node_id+"/qemu/", clientv3.WithPrefix(), clientv3.WithKeysOnly())
-			for _, kv := range resp.Kvs {
-				matches := re.FindStringSubmatch(string(kv.Key))
-				if matches != nil {
-					index := re.SubexpIndex("domainID")
-					domains = append(domains, matches[index])
-				}
-			}
-
-			s = append(s, nodeDown{
-				node_id: node_id,
-				domains: domains,
-			})
-		}
-
-		/*for _, pair := range stream.Values {
-			println(pair.Value.String())
-		}*/
 	}
 
-	return s
+	return data, nil
+}
+
+func (s *Scheduler) GetAlertNodes() ([]AlertsNode, error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	// On récupère les alertes sur les noeuds
+	query := fmt.Sprintf("ALERTS_FOR_STATE{cluster_id=\"%s\", type=\"deevirt_node_default\"}\n", s.Config.ClusterID)
+	res, _, err := s.Api.Query(ctx, query, time.Now())
+	if err != nil {
+		return nil, fmt.Errorf("erreur lors de la récupération des alertes filtrées: %v", err)
+	}
+
+	data := []AlertsNode{}
+	for _, res := range res.(model.Vector) {
+		data = append(data, AlertsNode{
+			NodeID:   string(res.Metric["NodeID"]),
+			Severity: string(res.Metric["Severity"]),
+			Score:    uint8(res.Value),
+		})
+	}
+
+	return data, nil
 }

pkg/scheduler/scheduler.go

@@ -5,151 +5,87 @@ import (
 	"fmt"
 	"time"
 
-	"deevirt.fr/compute/pkg/config"
+	"github.com/prometheus/client_golang/api"
-	prom_api "github.com/prometheus/client_golang/api"
 	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
 	"github.com/prometheus/common/model"
 	"go.uber.org/zap"
+
+	"deevirt.fr/compute/pkg/config"
+	"deevirt.fr/compute/pkg/prom"
 )
 
 type Scheduler struct {
-	ctx       context.Context
+	Config *config.Config
-	cancel    context.CancelFunc
+	Log    *zap.Logger
-	cancelled bool
+	Api    v1.API
+}
 
-	config *config.Config
+type TopNode struct {
-	log    *zap.Logger
+	NodeID string
+	Score  uint8
+}
+
+type AlertsCluster struct {
+	Severity string
+	Score    uint8
+}
+
+type AlertsNode struct {
+	NodeID   string
+	Severity string
+	Score    uint8
 }
 
 func New() (*Scheduler, error) {
 	config, _ := config.New()
-	ctx, cancel := context.WithCancel(context.Background())
 
 	logger, _ := zap.NewProduction()
 
-	s := &Scheduler{
+	client, err := api.NewClient(api.Config{
-		ctx:       ctx,
+		Address: "http://172.16.9.161:9090",
-		cancel:    cancel,
+	})
-		cancelled: true,
+	if err != nil {
+		logger.Error("Prometheus HS")
+		return nil, nil
+	}
 
-		config: config,
+	s := &Scheduler{
-		log:    logger,
+		Config: config,
+		Log:    logger,
+		Api:    v1.NewAPI(client),
 	}
 
 	return s, nil
 }
 
-func (w *Scheduler) api() (v1.API, error) {
+func (s *Scheduler) GetTopNode(number int) ([]TopNode, error) {
-	client, err := prom_api.NewClient(prom_api.Config{
-		Address: "http://172.16.9.161:9090",
-	})
-	if err != nil {
-		w.log.Error("Prometheus HS")
-		return nil, nil
-	}
-
-	return v1.NewAPI(client), nil
-}
-
-type scoringNode struct {
-	cpu    float64
-	memory float64
-}
-
-type scoring struct {
-	domain map[string]scoringNode
-}
-
-func (w *Scheduler) restartDomain(domain nodeDown) {
-	api, err := w.api()
-	if err != nil {
-		return
-	}
-
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
+	// On calcul un score global, pondéré à 30% sur le processeur, 70% pour la mémoire.
 	query := fmt.Sprintf(`
-		100 * (
+	topk(%d, sum(
-		(sum(rate(libvirt_node_cpu_time_seconds_total{cluster_id='%s'}[5m])) by (node_id) / sum(libvirt_node_cpu_threads{cluster_id='%s'}) by (node_id)
+  		(
-		+
+    		(1 - sum(rate(libvirt_node_cpu_time_seconds_total{cluster_id="%s"}[5m]) / libvirt_node_cpu_threads) by (node_id)) * 0.3
-		sum(libvirt_node_memory_usage_bytes{cluster_id='%s'}) by (node_id) / sum(libvirt_node_memory_total_bytes{cluster_id='%s'}) by (node_id))
+    		+
-		/ 2
+    		(1 - sum(libvirt_node_memory_usage_bytes{cluster_id="%s"} / libvirt_node_memory_total_bytes) by (node_id)) * 0.7
-		)`, w.config.ClusterID, w.config.ClusterID, w.config.ClusterID, w.config.ClusterID)
+  			) * 100
+		) by (node_id))
+	`, number, s.Config.ClusterID, s.Config.ClusterID)
 
-	cpu, _, _ := api.Query(ctx, query, time.Now(), v1.WithTimeout(5*time.Second))
+	api, _ := prom.New()
-
+	res, _, err := api.Query(ctx, query, time.Now())
-	matrix, _ := cpu.(model.Vector)
+	if err != nil {
-	for _, stream := range matrix {
+		return nil, fmt.Errorf("erreur lors de la récupération des alertes filtrées: %v", err)
-		println(stream.Value.String())
 	}
 
-	/*cpu, _, _ := api.Query(ctx, "rate(libvirt_node_cpu_time_seconds_total{cluster_id='"+w.config.ClusterID+"'}[5m]) * 100", time.Now(), v1.WithTimeout(5*time.Second))
+	data := []TopNode{}
-
+	for _, res := range res.(model.Vector) {
-	score.
+		data = append(data, TopNode{
-
+			NodeID: string(res.Metric["NodeID"]),
-	matrix, _ := cpu.(model.Vector)
+			Score:  uint8(res.Value),
-	for _, stream := range matrix {
+		})
-		total := 100
-
-		for key, value := range stream.Metric {
-			if key == "threads" {
-				threads, _ := strconv.Atoi(string(value))
-
-				total = threads * 100
-
-				println(total)
-			}
-
-			//fmt.Printf("%s => %s\n", key, value)
-		}
-
-		usage := float64(stream.Value)
-
-		p := usage / float64(total) * 100
-
-		fmt.Printf("%.2f%%\n", p)
-
-		//println(stream.Value.String())
 	}
 
-	memory_usage, _, _ := api.Query(ctx,
+	return data, nil
-		"(libvirt_node_memory_usage_bytes{cluster_id='"+w.config.ClusterID+"'}/1024e2)",
-		time.Now(),
-		v1.WithTimeout(5*time.Second))
-
-	memory_total, _, _ := api.Query(ctx,
-		"(libvirt_node_memory_usage_bytes{cluster_id='"+w.config.ClusterID+"'}/1024e2)",
-		time.Now(),
-		v1.WithTimeout(5*time.Second))*/
-
-	//fmt.Printf("==>%v\n", cpu)
-	//fmt.Printf("%v\n", memory)
-
-}
-
-func (w *Scheduler) Start() {
-	go func() {
-		for {
-			select {
-			case <-w.ctx.Done():
-				fmt.Println("🛑 Worker arrêté !")
-				return
-			default:
-				fmt.Println("🔄 Controle périodique en cours...")
-				for _, t := range w.checkHA() {
-					w.restartDomain(t)
-				}
-
-				time.Sleep(1 * time.Minute)
-			}
-		}
-	}()
-}
-
-func (w *Scheduler) Stop() {
-	if !w.cancelled {
-		w.cancel()
-		w.cancelled = true
-	}
 }

vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go

@@ -0,0 +1,150 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/empty.proto
+
+package emptypb
+
+import (
+	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
+	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
+	reflect "reflect"
+	sync "sync"
+	unsafe "unsafe"
+)
+
+// A generic empty message that you can re-use to avoid defining duplicated
+// empty messages in your APIs. A typical example is to use it as the request
+// or the response type of an API method. For instance:
+//
+//	service Foo {
+//	  rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+//	}
+type Empty struct {
+	state         protoimpl.MessageState `protogen:"open.v1"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
+}
+
+func (x *Empty) Reset() {
+	*x = Empty{}
+	mi := &file_google_protobuf_empty_proto_msgTypes[0]
+	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+	ms.StoreMessageInfo(mi)
+}
+
+func (x *Empty) String() string {
+	return protoimpl.X.MessageStringOf(x)
+}
+
+func (*Empty) ProtoMessage() {}
+
+func (x *Empty) ProtoReflect() protoreflect.Message {
+	mi := &file_google_protobuf_empty_proto_msgTypes[0]
+	if x != nil {
+		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
+		if ms.LoadMessageInfo() == nil {
+			ms.StoreMessageInfo(mi)
+		}
+		return ms
+	}
+	return mi.MessageOf(x)
+}
+
+// Deprecated: Use Empty.ProtoReflect.Descriptor instead.
+func (*Empty) Descriptor() ([]byte, []int) {
+	return file_google_protobuf_empty_proto_rawDescGZIP(), []int{0}
+}
+
+var File_google_protobuf_empty_proto protoreflect.FileDescriptor
+
+var file_google_protobuf_empty_proto_rawDesc = string([]byte{
+	0x0a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75,
+	0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0x07,
+	0x0a, 0x05, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x42, 0x7d, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67,
+	0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x42, 0x0a,
+	0x45, 0x6d, 0x70, 0x74, 0x79, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x2e, 0x67, 0x6f,
+	0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f,
+	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x79, 0x70, 0x65, 0x73, 0x2f, 0x6b,
+	0x6e, 0x6f, 0x77, 0x6e, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x70, 0x62, 0xf8, 0x01, 0x01, 0xa2,
+	0x02, 0x03, 0x47, 0x50, 0x42, 0xaa, 0x02, 0x1e, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x57, 0x65, 0x6c, 0x6c, 0x4b, 0x6e, 0x6f, 0x77,
+	0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+})
+
+var (
+	file_google_protobuf_empty_proto_rawDescOnce sync.Once
+	file_google_protobuf_empty_proto_rawDescData []byte
+)
+
+func file_google_protobuf_empty_proto_rawDescGZIP() []byte {
+	file_google_protobuf_empty_proto_rawDescOnce.Do(func() {
+		file_google_protobuf_empty_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_google_protobuf_empty_proto_rawDesc), len(file_google_protobuf_empty_proto_rawDesc)))
+	})
+	return file_google_protobuf_empty_proto_rawDescData
+}
+
+var file_google_protobuf_empty_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
+var file_google_protobuf_empty_proto_goTypes = []any{
+	(*Empty)(nil), // 0: google.protobuf.Empty
+}
+var file_google_protobuf_empty_proto_depIdxs = []int32{
+	0, // [0:0] is the sub-list for method output_type
+	0, // [0:0] is the sub-list for method input_type
+	0, // [0:0] is the sub-list for extension type_name
+	0, // [0:0] is the sub-list for extension extendee
+	0, // [0:0] is the sub-list for field type_name
+}
+
+func init() { file_google_protobuf_empty_proto_init() }
+func file_google_protobuf_empty_proto_init() {
+	if File_google_protobuf_empty_proto != nil {
+		return
+	}
+	type x struct{}
+	out := protoimpl.TypeBuilder{
+		File: protoimpl.DescBuilder{
+			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
+			RawDescriptor: unsafe.Slice(unsafe.StringData(file_google_protobuf_empty_proto_rawDesc), len(file_google_protobuf_empty_proto_rawDesc)),
+			NumEnums:      0,
+			NumMessages:   1,
+			NumExtensions: 0,
+			NumServices:   0,
+		},
+		GoTypes:           file_google_protobuf_empty_proto_goTypes,
+		DependencyIndexes: file_google_protobuf_empty_proto_depIdxs,
+		MessageInfos:      file_google_protobuf_empty_proto_msgTypes,
+	}.Build()
+	File_google_protobuf_empty_proto = out.File
+	file_google_protobuf_empty_proto_goTypes = nil
+	file_google_protobuf_empty_proto_depIdxs = nil
+}

vendor/modules.txt

@@ -286,6 +286,7 @@ google.golang.org/protobuf/types/descriptorpb
 google.golang.org/protobuf/types/gofeaturespb
 google.golang.org/protobuf/types/known/anypb
 google.golang.org/protobuf/types/known/durationpb
+google.golang.org/protobuf/types/known/emptypb
 google.golang.org/protobuf/types/known/timestamppb
 # gopkg.in/ini.v1 v1.67.0
 ## explicit