Deevirt/compute
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Réorganisation globale

Browse Source
This commit is contained in:
Mickael BOURNEUF 2025-02-24 10:38:06 +01:00
parent e33590fba2
commit f0a191c9a4
34 changed files with 1906 additions and 936 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
cmd/monitor/events/qemu.go
View File

@ -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,
})

19
cmd/monitor/metrics/compute.go
View File

@ -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
}

102
pkg/api/domain.go
View File

@ -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
}
*/

181
pkg/api/domain/domain.go Normal file
View File

@ -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()
}
}
}

88
pkg/api/domain/events.go Normal file
View File

@ -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
}

44
pkg/api/events.go
View File

@ -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
}

44
pkg/api/node.go Normal file
View File

@ -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
}

392
pkg/api/proto/domain.pb.go
View File

@ -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"`
Config string `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
State int64 `protobuf:"varint,3,opt,name=state,proto3" json:"state,omitempty"`
NodeId string `protobuf:"bytes,1,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
DomainId string `protobuf:"bytes,2,opt,name=domain_id,json=domainId,proto3" json:"domain_id,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,
0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x63,
0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x03,
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,
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,
0x01, 0x28, 0x09, 0x52, 0x08, 0x64, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x49, 0x64, 0x22, 0x51, 0x0a,
0x15, 0x44, 0x6f, 0x6d, 0x61, 0x69, 0x6e, 0x4d, 0x69, 0x67, 0x72, 0x61, 0x74, 0x65, 0x52, 0x65,
0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e,
0x74, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0a, 0x70, 0x65, 0x72, 0x63,
0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67,
0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 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, 0x22, 0x38, 0x0a, 0x24, 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, 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, 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,
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, 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,
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, 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, 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
(*DomainPowerResponse)(nil), // 14: deevirt.DomainPowerResponse
(*DomainDevicesGraphicsConsoleRequest)(nil), // 15: deevirt.DomainDevicesGraphicsConsoleRequest
(*DomainDevicesGraphicsConsoleResponse)(nil), // 16: deevirt.DomainDevicesGraphicsConsoleResponse
(*DomainMigrateRequest)(nil), // 13: deevirt.DomainMigrateRequest
(*DomainMigrateResponse)(nil), // 14: deevirt.DomainMigrateResponse
(*DomainPowerRequest)(nil), // 15: deevirt.DomainPowerRequest
(*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, // 3: deevirt.Domain.List:input_type -> deevirt.DomainListAllRequest
5, // 4: deevirt.Domain.Get:input_type -> deevirt.DomainListRequest
7, // 5: deevirt.Domain.Create:input_type -> deevirt.DomainCreateRequest
9, // 6: deevirt.Domain.Update:input_type -> deevirt.DomainUpdateRequest
11, // 7: deevirt.Domain.Delete:input_type -> deevirt.DomainDeleteRequest
13, // 8: deevirt.Domain.Power:input_type -> deevirt.DomainPowerRequest
15, // 9: deevirt.DomainDevicesGraphics.Console:input_type -> deevirt.DomainDevicesGraphicsConsoleRequest
2, // 10: deevirt.Domain.Event:output_type -> deevirt.DomainEventResponse
3, // 2: deevirt.Domain.List:input_type -> deevirt.DomainListAllRequest
5, // 3: deevirt.Domain.Get:input_type -> deevirt.DomainListRequest
7, // 4: deevirt.Domain.Create:input_type -> deevirt.DomainCreateRequest
9, // 5: deevirt.Domain.Update:input_type -> deevirt.DomainUpdateRequest
11, // 6: deevirt.Domain.Delete:input_type -> deevirt.DomainDeleteRequest
13, // 7: deevirt.Domain.Migrate:input_type -> deevirt.DomainMigrateRequest
15, // 8: deevirt.Domain.Power:input_type -> deevirt.DomainPowerRequest
1, // 9: deevirt.Domain.Event:input_type -> deevirt.DomainEventRequest
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
16, // 17: deevirt.DomainDevicesGraphics.Console:output_type -> deevirt.DomainDevicesGraphicsConsoleResponse
10, // [10:18] is the sub-list for method output_type
2, // [2:10] is the sub-list for method input_type
14, // 16: deevirt.Domain.Migrate:output_type -> deevirt.DomainMigrateResponse
16, // 17: deevirt.Domain.Power:output_type -> deevirt.DomainPowerResponse
2, // 18: deevirt.Domain.Event:output_type -> deevirt.DomainEventResponse
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,
},

22
pkg/api/proto/domain.proto
View File

@ -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 config = 2;
int64 state = 3;
string node_id = 1;
string domain_id = 2;
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;

132
pkg/api/proto/domain_grpc.pb.go
View File

@ -19,13 +19,14 @@ import (
const _ = grpc.SupportPackageIsVersion9
const (
Domain_Event_FullMethodName = "/deevirt.Domain/Event"
Domain_List_FullMethodName = "/deevirt.Domain/List"
Domain_Get_FullMethodName = "/deevirt.Domain/Get"
Domain_Create_FullMethodName = "/deevirt.Domain/Create"
Domain_Update_FullMethodName = "/deevirt.Domain/Update"
Domain_Delete_FullMethodName = "/deevirt.Domain/Delete"
Domain_Power_FullMethodName = "/deevirt.Domain/Power"
Domain_List_FullMethodName = "/deevirt.Domain/List"
Domain_Get_FullMethodName = "/deevirt.Domain/Get"
Domain_Create_FullMethodName = "/deevirt.Domain/Create"
Domain_Update_FullMethodName = "/deevirt.Domain/Update"
Domain_Delete_FullMethodName = "/deevirt.Domain/Delete"
Domain_Migrate_FullMethodName = "/deevirt.Domain/Migrate"
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",
}

206
pkg/api/proto/node.pb.go Normal file
View File

@ -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
}

16
pkg/api/proto/node.proto Normal file
View File

@ -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 {}

126
pkg/api/proto/node_grpc.pb.go Normal file
View File

@ -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",
}

0
pkg/raft/admin.go → pkg/api/raft/admin.go
View File

17
pkg/raft/fsm.go → pkg/api/raft/fsm.go
View File

@ -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() {
}

123
pkg/api/raft/node.go Normal file
View File

@ -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)
}
}
}

144
pkg/api/raft/scheduler.go Normal file
View File

@ -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)
}
}
}

19
pkg/api/raft/schema.go Normal file
View File

@ -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"`
}

287
pkg/api/raft/store.go Normal file
View File

@ -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
}

0
pkg/raft/transport/api.go → pkg/api/raft/transport/api.go
View File

0
pkg/raft/transport/chunking.go → pkg/api/raft/transport/chunking.go
View File

0
pkg/raft/transport/fromproto.go → pkg/api/raft/transport/fromproto.go
View File

0
pkg/raft/transport/grpc.go → pkg/api/raft/transport/grpc.go
View File

0
pkg/raft/transport/options.go → pkg/api/raft/transport/options.go
View File

0
pkg/raft/transport/toproto.go → pkg/api/raft/transport/toproto.go
View File

0
pkg/raft/transport/transport.go → pkg/api/raft/transport/transport.go
View File

11
pkg/api/server.go
View File

@ -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,
})

14
pkg/prom/prom.go Normal file
View File

@ -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
}

371
pkg/raft/store.go
View File

@ -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
}*/

41
pkg/raft/worker.go
View File

@ -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
}

113
pkg/scheduler/ha.go
View File

@ -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 {
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
}
func (s *Scheduler) GetAlertCluster() ([]AlertsCluster, error) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
println("up{cluster_id=" + w.config.ClusterID + "}")
result, warnings, err := api.QueryRange(ctx, "up{cluster_id='"+w.config.ClusterID+"'}", r, v1.WithTimeout(5*time.Second))
// 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)
res, _, err := s.Api.Query(ctx, query, time.Now())
if err != nil {
fmt.Printf("Error querying Prometheus: %v\n", err)
}
if len(warnings) > 0 {
fmt.Printf("Warnings: %v\n", warnings)
return nil, fmt.Errorf("erreur lors de la récupération des alertes filtrées: %v", err)
}
matrix, _ := result.(model.Matrix)
for _, stream := range matrix {
node_id := ""
domains := []string{}
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())
}*/
data := []AlertsCluster{}
for _, res := range res.(model.Vector) {
data = append(data, AlertsCluster{
Severity: string(res.Metric["Severity"]),
Score: uint8(res.Value),
})
}
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
}

172
pkg/scheduler/scheduler.go
View File

@ -5,151 +5,87 @@ import (
"fmt"
"time"
"deevirt.fr/compute/pkg/config"
prom_api "github.com/prometheus/client_golang/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
cancel context.CancelFunc
cancelled bool
Config *config.Config
Log *zap.Logger
Api v1.API
}
config *config.Config
log *zap.Logger
type TopNode struct {
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{
ctx: ctx,
cancel: cancel,
cancelled: true,
client, err := api.NewClient(api.Config{
Address: "http://172.16.9.161:9090",
})
if err != nil {
logger.Error("Prometheus HS")
return nil, nil
}
config: config,
log: logger,
s := &Scheduler{
Config: config,
Log: logger,
Api: v1.NewAPI(client),
}
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
}
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
}
func (s *Scheduler) GetTopNode(number int) ([]TopNode, error) {
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 * (
(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)
+
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
)`, w.config.ClusterID, w.config.ClusterID, w.config.ClusterID, w.config.ClusterID)
topk(%d, sum(
(
(1 - sum(rate(libvirt_node_cpu_time_seconds_total{cluster_id="%s"}[5m]) / libvirt_node_cpu_threads) by (node_id)) * 0.3
+
(1 - sum(libvirt_node_memory_usage_bytes{cluster_id="%s"} / libvirt_node_memory_total_bytes) by (node_id)) * 0.7
) * 100
) by (node_id))
`, number, s.Config.ClusterID, s.Config.ClusterID)
cpu, _, _ := api.Query(ctx, query, time.Now(), v1.WithTimeout(5*time.Second))
matrix, _ := cpu.(model.Vector)
for _, stream := range matrix {
println(stream.Value.String())
api, _ := prom.New()
res, _, err := 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)
}
/*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))
score.
matrix, _ := cpu.(model.Vector)
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())
data := []TopNode{}
for _, res := range res.(model.Vector) {
data = append(data, TopNode{
NodeID: string(res.Metric["NodeID"]),
Score: uint8(res.Value),
})
}
memory_usage, _, _ := api.Query(ctx,
"(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
}
return data, nil
}

150
vendor/google.golang.org/protobuf/types/known/emptypb/empty.pb.go generated vendored Normal file
View File

@ -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
}

1
vendor/modules.txt vendored
View File

@ -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