From 5c87407c24bb86f7df79e1abca557941ee57a4e8 Mon Sep 17 00:00:00 2001 From: Kelly Date: Tue, 21 Apr 2020 13:26:14 -0400 Subject: [PATCH] wip: update hardware struct --- protos/hardware/hardware.pb.go | 1075 +++++++++++++++++++++++++++++++- protos/hardware/hardware.proto | 103 ++- 2 files changed, 1148 insertions(+), 30 deletions(-) diff --git a/protos/hardware/hardware.pb.go b/protos/hardware/hardware.pb.go index 904966be1..438a4218c 100644 --- a/protos/hardware/hardware.pb.go +++ b/protos/hardware/hardware.pb.go @@ -151,10 +151,14 @@ func (m *GetRequest) GetID() string { } type Hardware struct { - JSON string `protobuf:"bytes,1,opt,name=JSON,proto3" json:"JSON,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_unrecognized []byte `json:"-"` - XXX_sizecache int32 `json:"-"` + ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"` + Dhcp *Hardware_DHCP `protobuf:"bytes,2,opt,name=dhcp,proto3" json:"dhcp,omitempty"` + Netboot *Hardware_Netboot `protobuf:"bytes,3,opt,name=netboot,proto3" json:"netboot,omitempty"` + Network []*Hardware_Network `protobuf:"bytes,4,rep,name=network,proto3" json:"network,omitempty"` + Metadata *Hardware_Metadata `protobuf:"bytes,5,opt,name=metadata,proto3" json:"metadata,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *Hardware) Reset() { *m = Hardware{} } @@ -182,9 +186,949 @@ func (m *Hardware) XXX_DiscardUnknown() { var xxx_messageInfo_Hardware proto.InternalMessageInfo -func (m *Hardware) GetJSON() string { +func (m *Hardware) GetID() string { + if m != nil { + return m.ID + } + return "" +} + +func (m *Hardware) GetDhcp() *Hardware_DHCP { + if m != nil { + return m.Dhcp + } + return nil +} + +func (m *Hardware) GetNetboot() *Hardware_Netboot { + if m != nil { + return m.Netboot + } + return nil +} + +func (m *Hardware) GetNetwork() []*Hardware_Network { + if m != nil { + return m.Network + } + return nil +} + +func (m *Hardware) GetMetadata() *Hardware_Metadata { + if m != nil { + return m.Metadata + } + return nil +} + +type Hardware_DHCP struct { + MAC string `protobuf:"bytes,1,opt,name=MAC,proto3" json:"MAC,omitempty"` + IP string `protobuf:"bytes,2,opt,name=IP,proto3" json:"IP,omitempty"` + Hostname string `protobuf:"bytes,3,opt,name=hostname,proto3" json:"hostname,omitempty"` + LeaseTime int64 `protobuf:"varint,4,opt,name=leaseTime,proto3" json:"leaseTime,omitempty"` + NameServers []string `protobuf:"bytes,5,rep,name=nameServers,proto3" json:"nameServers,omitempty"` + TimeServers []string `protobuf:"bytes,6,rep,name=timeServers,proto3" json:"timeServers,omitempty"` + Gateway string `protobuf:"bytes,7,opt,name=gateway,proto3" json:"gateway,omitempty"` + Arch string `protobuf:"bytes,8,opt,name=arch,proto3" json:"arch,omitempty"` + Uefi bool `protobuf:"varint,9,opt,name=uefi,proto3" json:"uefi,omitempty"` + IfaceName string `protobuf:"bytes,10,opt,name=ifaceName,proto3" json:"ifaceName,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_DHCP) Reset() { *m = Hardware_DHCP{} } +func (m *Hardware_DHCP) String() string { return proto.CompactTextString(m) } +func (*Hardware_DHCP) ProtoMessage() {} +func (*Hardware_DHCP) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 0} +} + +func (m *Hardware_DHCP) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_DHCP.Unmarshal(m, b) +} +func (m *Hardware_DHCP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_DHCP.Marshal(b, m, deterministic) +} +func (m *Hardware_DHCP) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_DHCP.Merge(m, src) +} +func (m *Hardware_DHCP) XXX_Size() int { + return xxx_messageInfo_Hardware_DHCP.Size(m) +} +func (m *Hardware_DHCP) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_DHCP.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_DHCP proto.InternalMessageInfo + +func (m *Hardware_DHCP) GetMAC() string { + if m != nil { + return m.MAC + } + return "" +} + +func (m *Hardware_DHCP) GetIP() string { + if m != nil { + return m.IP + } + return "" +} + +func (m *Hardware_DHCP) GetHostname() string { + if m != nil { + return m.Hostname + } + return "" +} + +func (m *Hardware_DHCP) GetLeaseTime() int64 { + if m != nil { + return m.LeaseTime + } + return 0 +} + +func (m *Hardware_DHCP) GetNameServers() []string { + if m != nil { + return m.NameServers + } + return nil +} + +func (m *Hardware_DHCP) GetTimeServers() []string { + if m != nil { + return m.TimeServers + } + return nil +} + +func (m *Hardware_DHCP) GetGateway() string { + if m != nil { + return m.Gateway + } + return "" +} + +func (m *Hardware_DHCP) GetArch() string { + if m != nil { + return m.Arch + } + return "" +} + +func (m *Hardware_DHCP) GetUefi() bool { + if m != nil { + return m.Uefi + } + return false +} + +func (m *Hardware_DHCP) GetIfaceName() string { + if m != nil { + return m.IfaceName + } + return "" +} + +type Hardware_Netboot struct { + AllowPXE bool `protobuf:"varint,1,opt,name=allowPXE,proto3" json:"allowPXE,omitempty"` + AllowWorkflow bool `protobuf:"varint,2,opt,name=allowWorkflow,proto3" json:"allowWorkflow,omitempty"` + Ipxe *Hardware_Netboot_IPXE `protobuf:"bytes,3,opt,name=ipxe,proto3" json:"ipxe,omitempty"` + Bootstrapper *Hardware_Netboot_Bootstrapper `protobuf:"bytes,4,opt,name=bootstrapper,proto3" json:"bootstrapper,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Netboot) Reset() { *m = Hardware_Netboot{} } +func (m *Hardware_Netboot) String() string { return proto.CompactTextString(m) } +func (*Hardware_Netboot) ProtoMessage() {} +func (*Hardware_Netboot) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 1} +} + +func (m *Hardware_Netboot) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Netboot.Unmarshal(m, b) +} +func (m *Hardware_Netboot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Netboot.Marshal(b, m, deterministic) +} +func (m *Hardware_Netboot) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Netboot.Merge(m, src) +} +func (m *Hardware_Netboot) XXX_Size() int { + return xxx_messageInfo_Hardware_Netboot.Size(m) +} +func (m *Hardware_Netboot) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Netboot.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Netboot proto.InternalMessageInfo + +func (m *Hardware_Netboot) GetAllowPXE() bool { + if m != nil { + return m.AllowPXE + } + return false +} + +func (m *Hardware_Netboot) GetAllowWorkflow() bool { + if m != nil { + return m.AllowWorkflow + } + return false +} + +func (m *Hardware_Netboot) GetIpxe() *Hardware_Netboot_IPXE { + if m != nil { + return m.Ipxe + } + return nil +} + +func (m *Hardware_Netboot) GetBootstrapper() *Hardware_Netboot_Bootstrapper { + if m != nil { + return m.Bootstrapper + } + return nil +} + +type Hardware_Netboot_IPXE struct { + URL string `protobuf:"bytes,1,opt,name=URL,proto3" json:"URL,omitempty"` + Contents string `protobuf:"bytes,2,opt,name=contents,proto3" json:"contents,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Netboot_IPXE) Reset() { *m = Hardware_Netboot_IPXE{} } +func (m *Hardware_Netboot_IPXE) String() string { return proto.CompactTextString(m) } +func (*Hardware_Netboot_IPXE) ProtoMessage() {} +func (*Hardware_Netboot_IPXE) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 1, 0} +} + +func (m *Hardware_Netboot_IPXE) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Netboot_IPXE.Unmarshal(m, b) +} +func (m *Hardware_Netboot_IPXE) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Netboot_IPXE.Marshal(b, m, deterministic) +} +func (m *Hardware_Netboot_IPXE) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Netboot_IPXE.Merge(m, src) +} +func (m *Hardware_Netboot_IPXE) XXX_Size() int { + return xxx_messageInfo_Hardware_Netboot_IPXE.Size(m) +} +func (m *Hardware_Netboot_IPXE) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Netboot_IPXE.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Netboot_IPXE proto.InternalMessageInfo + +func (m *Hardware_Netboot_IPXE) GetURL() string { + if m != nil { + return m.URL + } + return "" +} + +func (m *Hardware_Netboot_IPXE) GetContents() string { + if m != nil { + return m.Contents + } + return "" +} + +type Hardware_Netboot_Bootstrapper struct { + Kernel string `protobuf:"bytes,1,opt,name=kernel,proto3" json:"kernel,omitempty"` + Initrd string `protobuf:"bytes,2,opt,name=initrd,proto3" json:"initrd,omitempty"` + OS string `protobuf:"bytes,3,opt,name=OS,proto3" json:"OS,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Netboot_Bootstrapper) Reset() { *m = Hardware_Netboot_Bootstrapper{} } +func (m *Hardware_Netboot_Bootstrapper) String() string { return proto.CompactTextString(m) } +func (*Hardware_Netboot_Bootstrapper) ProtoMessage() {} +func (*Hardware_Netboot_Bootstrapper) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 1, 1} +} + +func (m *Hardware_Netboot_Bootstrapper) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Netboot_Bootstrapper.Unmarshal(m, b) +} +func (m *Hardware_Netboot_Bootstrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Netboot_Bootstrapper.Marshal(b, m, deterministic) +} +func (m *Hardware_Netboot_Bootstrapper) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Netboot_Bootstrapper.Merge(m, src) +} +func (m *Hardware_Netboot_Bootstrapper) XXX_Size() int { + return xxx_messageInfo_Hardware_Netboot_Bootstrapper.Size(m) +} +func (m *Hardware_Netboot_Bootstrapper) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Netboot_Bootstrapper.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Netboot_Bootstrapper proto.InternalMessageInfo + +func (m *Hardware_Netboot_Bootstrapper) GetKernel() string { + if m != nil { + return m.Kernel + } + return "" +} + +func (m *Hardware_Netboot_Bootstrapper) GetInitrd() string { + if m != nil { + return m.Initrd + } + return "" +} + +func (m *Hardware_Netboot_Bootstrapper) GetOS() string { + if m != nil { + return m.OS + } + return "" +} + +type Hardware_Network struct { + Dhcp *Hardware_DHCP `protobuf:"bytes,1,opt,name=dhcp,proto3" json:"dhcp,omitempty"` + Netboot *Hardware_Netboot `protobuf:"bytes,2,opt,name=Netboot,proto3" json:"Netboot,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Network) Reset() { *m = Hardware_Network{} } +func (m *Hardware_Network) String() string { return proto.CompactTextString(m) } +func (*Hardware_Network) ProtoMessage() {} +func (*Hardware_Network) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 2} +} + +func (m *Hardware_Network) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Network.Unmarshal(m, b) +} +func (m *Hardware_Network) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Network.Marshal(b, m, deterministic) +} +func (m *Hardware_Network) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Network.Merge(m, src) +} +func (m *Hardware_Network) XXX_Size() int { + return xxx_messageInfo_Hardware_Network.Size(m) +} +func (m *Hardware_Network) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Network.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Network proto.InternalMessageInfo + +func (m *Hardware_Network) GetDhcp() *Hardware_DHCP { + if m != nil { + return m.Dhcp + } + return nil +} + +func (m *Hardware_Network) GetNetboot() *Hardware_Netboot { + if m != nil { + return m.Netboot + } + return nil +} + +type Hardware_Metadata struct { + State string `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"` + BondingMode int64 `protobuf:"varint,2,opt,name=bondingMode,proto3" json:"bondingMode,omitempty"` + Manufacturer *Hardware_Metadata_Manufacturer `protobuf:"bytes,3,opt,name=manufacturer,proto3" json:"manufacturer,omitempty"` + Instance *Hardware_Metadata_Instance `protobuf:"bytes,4,opt,name=instance,proto3" json:"instance,omitempty"` + Custom *Hardware_Metadata_Custom `protobuf:"bytes,5,opt,name=custom,proto3" json:"custom,omitempty"` + Facility *Hardware_Metadata_Facility `protobuf:"bytes,6,opt,name=facility,proto3" json:"facility,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata) Reset() { *m = Hardware_Metadata{} } +func (m *Hardware_Metadata) String() string { return proto.CompactTextString(m) } +func (*Hardware_Metadata) ProtoMessage() {} +func (*Hardware_Metadata) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3} +} + +func (m *Hardware_Metadata) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata.Unmarshal(m, b) +} +func (m *Hardware_Metadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata.Merge(m, src) +} +func (m *Hardware_Metadata) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata.Size(m) +} +func (m *Hardware_Metadata) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata proto.InternalMessageInfo + +func (m *Hardware_Metadata) GetState() string { + if m != nil { + return m.State + } + return "" +} + +func (m *Hardware_Metadata) GetBondingMode() int64 { + if m != nil { + return m.BondingMode + } + return 0 +} + +func (m *Hardware_Metadata) GetManufacturer() *Hardware_Metadata_Manufacturer { + if m != nil { + return m.Manufacturer + } + return nil +} + +func (m *Hardware_Metadata) GetInstance() *Hardware_Metadata_Instance { + if m != nil { + return m.Instance + } + return nil +} + +func (m *Hardware_Metadata) GetCustom() *Hardware_Metadata_Custom { + if m != nil { + return m.Custom + } + return nil +} + +func (m *Hardware_Metadata) GetFacility() *Hardware_Metadata_Facility { + if m != nil { + return m.Facility + } + return nil +} + +type Hardware_Metadata_Manufacturer struct { + ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"` + Slug string `protobuf:"bytes,2,opt,name=slug,proto3" json:"slug,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata_Manufacturer) Reset() { *m = Hardware_Metadata_Manufacturer{} } +func (m *Hardware_Metadata_Manufacturer) String() string { return proto.CompactTextString(m) } +func (*Hardware_Metadata_Manufacturer) ProtoMessage() {} +func (*Hardware_Metadata_Manufacturer) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3, 0} +} + +func (m *Hardware_Metadata_Manufacturer) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata_Manufacturer.Unmarshal(m, b) +} +func (m *Hardware_Metadata_Manufacturer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata_Manufacturer.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata_Manufacturer) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata_Manufacturer.Merge(m, src) +} +func (m *Hardware_Metadata_Manufacturer) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata_Manufacturer.Size(m) +} +func (m *Hardware_Metadata_Manufacturer) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata_Manufacturer.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata_Manufacturer proto.InternalMessageInfo + +func (m *Hardware_Metadata_Manufacturer) GetID() string { + if m != nil { + return m.ID + } + return "" +} + +func (m *Hardware_Metadata_Manufacturer) GetSlug() string { + if m != nil { + return m.Slug + } + return "" +} + +type Hardware_Metadata_Instance struct { + ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"` + State string `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"` + Hostname string `protobuf:"bytes,3,opt,name=hostname,proto3" json:"hostname,omitempty"` + AllowPXE bool `protobuf:"varint,4,opt,name=allowPXE,proto3" json:"allowPXE,omitempty"` + Rescue bool `protobuf:"varint,5,opt,name=rescue,proto3" json:"rescue,omitempty"` + OS *Hardware_Metadata_Instance_OperatingSystem `protobuf:"bytes,6,opt,name=OS,proto3" json:"OS,omitempty"` + AlwaysPXE bool `protobuf:"varint,7,opt,name=alwaysPXE,proto3" json:"alwaysPXE,omitempty"` + IpxeScriptURL string `protobuf:"bytes,8,opt,name=ipxeScriptURL,proto3" json:"ipxeScriptURL,omitempty"` + IPs []*Hardware_Metadata_Instance_IP `protobuf:"bytes,9,rep,name=IPs,proto3" json:"IPs,omitempty"` + UserData string `protobuf:"bytes,10,opt,name=userData,proto3" json:"userData,omitempty"` + CryptedRootPassword string `protobuf:"bytes,11,opt,name=cryptedRootPassword,proto3" json:"cryptedRootPassword,omitempty"` + Tags []string `protobuf:"bytes,12,rep,name=tags,proto3" json:"tags,omitempty"` + Storage *Hardware_Metadata_Instance_Storage `protobuf:"bytes,13,opt,name=storage,proto3" json:"storage,omitempty"` + SshKeys []string `protobuf:"bytes,14,rep,name=sshKeys,proto3" json:"sshKeys,omitempty"` + NetworkReady bool `protobuf:"varint,15,opt,name=networkReady,proto3" json:"networkReady,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata_Instance) Reset() { *m = Hardware_Metadata_Instance{} } +func (m *Hardware_Metadata_Instance) String() string { return proto.CompactTextString(m) } +func (*Hardware_Metadata_Instance) ProtoMessage() {} +func (*Hardware_Metadata_Instance) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3, 1} +} + +func (m *Hardware_Metadata_Instance) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata_Instance.Unmarshal(m, b) +} +func (m *Hardware_Metadata_Instance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata_Instance.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata_Instance) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata_Instance.Merge(m, src) +} +func (m *Hardware_Metadata_Instance) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata_Instance.Size(m) +} +func (m *Hardware_Metadata_Instance) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata_Instance.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata_Instance proto.InternalMessageInfo + +func (m *Hardware_Metadata_Instance) GetID() string { + if m != nil { + return m.ID + } + return "" +} + +func (m *Hardware_Metadata_Instance) GetState() string { + if m != nil { + return m.State + } + return "" +} + +func (m *Hardware_Metadata_Instance) GetHostname() string { + if m != nil { + return m.Hostname + } + return "" +} + +func (m *Hardware_Metadata_Instance) GetAllowPXE() bool { + if m != nil { + return m.AllowPXE + } + return false +} + +func (m *Hardware_Metadata_Instance) GetRescue() bool { + if m != nil { + return m.Rescue + } + return false +} + +func (m *Hardware_Metadata_Instance) GetOS() *Hardware_Metadata_Instance_OperatingSystem { + if m != nil { + return m.OS + } + return nil +} + +func (m *Hardware_Metadata_Instance) GetAlwaysPXE() bool { + if m != nil { + return m.AlwaysPXE + } + return false +} + +func (m *Hardware_Metadata_Instance) GetIpxeScriptURL() string { + if m != nil { + return m.IpxeScriptURL + } + return "" +} + +func (m *Hardware_Metadata_Instance) GetIPs() []*Hardware_Metadata_Instance_IP { + if m != nil { + return m.IPs + } + return nil +} + +func (m *Hardware_Metadata_Instance) GetUserData() string { + if m != nil { + return m.UserData + } + return "" +} + +func (m *Hardware_Metadata_Instance) GetCryptedRootPassword() string { + if m != nil { + return m.CryptedRootPassword + } + return "" +} + +func (m *Hardware_Metadata_Instance) GetTags() []string { + if m != nil { + return m.Tags + } + return nil +} + +func (m *Hardware_Metadata_Instance) GetStorage() *Hardware_Metadata_Instance_Storage { + if m != nil { + return m.Storage + } + return nil +} + +func (m *Hardware_Metadata_Instance) GetSshKeys() []string { + if m != nil { + return m.SshKeys + } + return nil +} + +func (m *Hardware_Metadata_Instance) GetNetworkReady() bool { + if m != nil { + return m.NetworkReady + } + return false +} + +type Hardware_Metadata_Instance_OperatingSystem struct { + Slug string `protobuf:"bytes,1,opt,name=slug,proto3" json:"slug,omitempty"` + Distro string `protobuf:"bytes,2,opt,name=distro,proto3" json:"distro,omitempty"` + Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"` + ImageTag string `protobuf:"bytes,4,opt,name=imageTag,proto3" json:"imageTag,omitempty"` + OsSlug string `protobuf:"bytes,5,opt,name=osSlug,proto3" json:"osSlug,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata_Instance_OperatingSystem) Reset() { + *m = Hardware_Metadata_Instance_OperatingSystem{} +} +func (m *Hardware_Metadata_Instance_OperatingSystem) String() string { + return proto.CompactTextString(m) +} +func (*Hardware_Metadata_Instance_OperatingSystem) ProtoMessage() {} +func (*Hardware_Metadata_Instance_OperatingSystem) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3, 1, 0} +} + +func (m *Hardware_Metadata_Instance_OperatingSystem) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata_Instance_OperatingSystem.Unmarshal(m, b) +} +func (m *Hardware_Metadata_Instance_OperatingSystem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata_Instance_OperatingSystem.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata_Instance_OperatingSystem) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata_Instance_OperatingSystem.Merge(m, src) +} +func (m *Hardware_Metadata_Instance_OperatingSystem) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata_Instance_OperatingSystem.Size(m) +} +func (m *Hardware_Metadata_Instance_OperatingSystem) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata_Instance_OperatingSystem.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata_Instance_OperatingSystem proto.InternalMessageInfo + +func (m *Hardware_Metadata_Instance_OperatingSystem) GetSlug() string { + if m != nil { + return m.Slug + } + return "" +} + +func (m *Hardware_Metadata_Instance_OperatingSystem) GetDistro() string { + if m != nil { + return m.Distro + } + return "" +} + +func (m *Hardware_Metadata_Instance_OperatingSystem) GetVersion() string { + if m != nil { + return m.Version + } + return "" +} + +func (m *Hardware_Metadata_Instance_OperatingSystem) GetImageTag() string { + if m != nil { + return m.ImageTag + } + return "" +} + +func (m *Hardware_Metadata_Instance_OperatingSystem) GetOsSlug() string { + if m != nil { + return m.OsSlug + } + return "" +} + +type Hardware_Metadata_Instance_IP struct { + Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"` + Netmask string `protobuf:"bytes,2,opt,name=netmask,proto3" json:"netmask,omitempty"` + Gateway string `protobuf:"bytes,3,opt,name=gateway,proto3" json:"gateway,omitempty"` + Family int64 `protobuf:"varint,4,opt,name=family,proto3" json:"family,omitempty"` + Public bool `protobuf:"varint,5,opt,name=public,proto3" json:"public,omitempty"` + Management bool `protobuf:"varint,6,opt,name=management,proto3" json:"management,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata_Instance_IP) Reset() { *m = Hardware_Metadata_Instance_IP{} } +func (m *Hardware_Metadata_Instance_IP) String() string { return proto.CompactTextString(m) } +func (*Hardware_Metadata_Instance_IP) ProtoMessage() {} +func (*Hardware_Metadata_Instance_IP) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3, 1, 1} +} + +func (m *Hardware_Metadata_Instance_IP) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata_Instance_IP.Unmarshal(m, b) +} +func (m *Hardware_Metadata_Instance_IP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata_Instance_IP.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata_Instance_IP) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata_Instance_IP.Merge(m, src) +} +func (m *Hardware_Metadata_Instance_IP) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata_Instance_IP.Size(m) +} +func (m *Hardware_Metadata_Instance_IP) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata_Instance_IP.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata_Instance_IP proto.InternalMessageInfo + +func (m *Hardware_Metadata_Instance_IP) GetAddress() string { + if m != nil { + return m.Address + } + return "" +} + +func (m *Hardware_Metadata_Instance_IP) GetNetmask() string { + if m != nil { + return m.Netmask + } + return "" +} + +func (m *Hardware_Metadata_Instance_IP) GetGateway() string { + if m != nil { + return m.Gateway + } + return "" +} + +func (m *Hardware_Metadata_Instance_IP) GetFamily() int64 { + if m != nil { + return m.Family + } + return 0 +} + +func (m *Hardware_Metadata_Instance_IP) GetPublic() bool { + if m != nil { + return m.Public + } + return false +} + +func (m *Hardware_Metadata_Instance_IP) GetManagement() bool { + if m != nil { + return m.Management + } + return false +} + +type Hardware_Metadata_Instance_Storage struct { + // TODO: create the actual structs + Disks []string `protobuf:"bytes,1,rep,name=disks,proto3" json:"disks,omitempty"` + RAID []string `protobuf:"bytes,2,rep,name=RAID,proto3" json:"RAID,omitempty"` + Filesystems []string `protobuf:"bytes,3,rep,name=filesystems,proto3" json:"filesystems,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata_Instance_Storage) Reset() { *m = Hardware_Metadata_Instance_Storage{} } +func (m *Hardware_Metadata_Instance_Storage) String() string { return proto.CompactTextString(m) } +func (*Hardware_Metadata_Instance_Storage) ProtoMessage() {} +func (*Hardware_Metadata_Instance_Storage) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3, 1, 2} +} + +func (m *Hardware_Metadata_Instance_Storage) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata_Instance_Storage.Unmarshal(m, b) +} +func (m *Hardware_Metadata_Instance_Storage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata_Instance_Storage.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata_Instance_Storage) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata_Instance_Storage.Merge(m, src) +} +func (m *Hardware_Metadata_Instance_Storage) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata_Instance_Storage.Size(m) +} +func (m *Hardware_Metadata_Instance_Storage) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata_Instance_Storage.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata_Instance_Storage proto.InternalMessageInfo + +func (m *Hardware_Metadata_Instance_Storage) GetDisks() []string { + if m != nil { + return m.Disks + } + return nil +} + +func (m *Hardware_Metadata_Instance_Storage) GetRAID() []string { + if m != nil { + return m.RAID + } + return nil +} + +func (m *Hardware_Metadata_Instance_Storage) GetFilesystems() []string { + if m != nil { + return m.Filesystems + } + return nil +} + +type Hardware_Metadata_Custom struct { + PreinstalledOS *Hardware_Metadata_Instance_OperatingSystem `protobuf:"bytes,1,opt,name=preinstalledOS,proto3" json:"preinstalledOS,omitempty"` + PrivateSubnets []string `protobuf:"bytes,2,rep,name=privateSubnets,proto3" json:"privateSubnets,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata_Custom) Reset() { *m = Hardware_Metadata_Custom{} } +func (m *Hardware_Metadata_Custom) String() string { return proto.CompactTextString(m) } +func (*Hardware_Metadata_Custom) ProtoMessage() {} +func (*Hardware_Metadata_Custom) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3, 2} +} + +func (m *Hardware_Metadata_Custom) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata_Custom.Unmarshal(m, b) +} +func (m *Hardware_Metadata_Custom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata_Custom.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata_Custom) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata_Custom.Merge(m, src) +} +func (m *Hardware_Metadata_Custom) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata_Custom.Size(m) +} +func (m *Hardware_Metadata_Custom) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata_Custom.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata_Custom proto.InternalMessageInfo + +func (m *Hardware_Metadata_Custom) GetPreinstalledOS() *Hardware_Metadata_Instance_OperatingSystem { + if m != nil { + return m.PreinstalledOS + } + return nil +} + +func (m *Hardware_Metadata_Custom) GetPrivateSubnets() []string { + if m != nil { + return m.PrivateSubnets + } + return nil +} + +type Hardware_Metadata_Facility struct { + PlanSlug string `protobuf:"bytes,1,opt,name=planSlug,proto3" json:"planSlug,omitempty"` + PlanVersionSlug string `protobuf:"bytes,2,opt,name=planVersionSlug,proto3" json:"planVersionSlug,omitempty"` + FacilityCode string `protobuf:"bytes,3,opt,name=facilityCode,proto3" json:"facilityCode,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_unrecognized []byte `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *Hardware_Metadata_Facility) Reset() { *m = Hardware_Metadata_Facility{} } +func (m *Hardware_Metadata_Facility) String() string { return proto.CompactTextString(m) } +func (*Hardware_Metadata_Facility) ProtoMessage() {} +func (*Hardware_Metadata_Facility) Descriptor() ([]byte, []int) { + return fileDescriptor_61ac56d7fc2e671f, []int{3, 3, 3} +} + +func (m *Hardware_Metadata_Facility) XXX_Unmarshal(b []byte) error { + return xxx_messageInfo_Hardware_Metadata_Facility.Unmarshal(m, b) +} +func (m *Hardware_Metadata_Facility) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + return xxx_messageInfo_Hardware_Metadata_Facility.Marshal(b, m, deterministic) +} +func (m *Hardware_Metadata_Facility) XXX_Merge(src proto.Message) { + xxx_messageInfo_Hardware_Metadata_Facility.Merge(m, src) +} +func (m *Hardware_Metadata_Facility) XXX_Size() int { + return xxx_messageInfo_Hardware_Metadata_Facility.Size(m) +} +func (m *Hardware_Metadata_Facility) XXX_DiscardUnknown() { + xxx_messageInfo_Hardware_Metadata_Facility.DiscardUnknown(m) +} + +var xxx_messageInfo_Hardware_Metadata_Facility proto.InternalMessageInfo + +func (m *Hardware_Metadata_Facility) GetPlanSlug() string { + if m != nil { + return m.PlanSlug + } + return "" +} + +func (m *Hardware_Metadata_Facility) GetPlanVersionSlug() string { + if m != nil { + return m.PlanVersionSlug + } + return "" +} + +func (m *Hardware_Metadata_Facility) GetFacilityCode() string { if m != nil { - return m.JSON + return m.FacilityCode } return "" } @@ -194,6 +1138,19 @@ func init() { proto.RegisterType((*Empty)(nil), "github.com.tinkerbell.tink.protos.hardware.Empty") proto.RegisterType((*GetRequest)(nil), "github.com.tinkerbell.tink.protos.hardware.GetRequest") proto.RegisterType((*Hardware)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware") + proto.RegisterType((*Hardware_DHCP)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.DHCP") + proto.RegisterType((*Hardware_Netboot)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Netboot") + proto.RegisterType((*Hardware_Netboot_IPXE)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Netboot.IPXE") + proto.RegisterType((*Hardware_Netboot_Bootstrapper)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Netboot.Bootstrapper") + proto.RegisterType((*Hardware_Network)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Network") + proto.RegisterType((*Hardware_Metadata)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata") + proto.RegisterType((*Hardware_Metadata_Manufacturer)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata.Manufacturer") + proto.RegisterType((*Hardware_Metadata_Instance)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata.Instance") + proto.RegisterType((*Hardware_Metadata_Instance_OperatingSystem)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata.Instance.OperatingSystem") + proto.RegisterType((*Hardware_Metadata_Instance_IP)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata.Instance.IP") + proto.RegisterType((*Hardware_Metadata_Instance_Storage)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata.Instance.Storage") + proto.RegisterType((*Hardware_Metadata_Custom)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata.Custom") + proto.RegisterType((*Hardware_Metadata_Facility)(nil), "github.com.tinkerbell.tink.protos.hardware.Hardware.Metadata.Facility") } func init() { @@ -201,29 +1158,89 @@ func init() { } var fileDescriptor_61ac56d7fc2e671f = []byte{ - // 349 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0xcf, 0x48, 0x2c, 0x4a, - 0x29, 0x4f, 0x2c, 0x4a, 0xd5, 0x87, 0x31, 0xf4, 0x0a, 0x8a, 0xf2, 0x4b, 0xf2, 0x85, 0xb4, 0xd2, - 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0x4a, 0x32, 0xf3, 0xb2, 0x53, 0x8b, - 0x92, 0x52, 0x73, 0x72, 0xc0, 0x4c, 0x88, 0x8a, 0x62, 0x3d, 0x98, 0x0e, 0x29, 0x99, 0xf4, 0xfc, - 0xfc, 0xf4, 0x9c, 0x54, 0xfd, 0xc4, 0x82, 0x4c, 0xfd, 0xc4, 0xbc, 0xbc, 0xfc, 0x92, 0xc4, 0x92, - 0xcc, 0xfc, 0xbc, 0x62, 0x88, 0x3a, 0x25, 0x45, 0x2e, 0xee, 0x80, 0xd2, 0xe2, 0x8c, 0xa0, 0xd4, - 0xc2, 0xd2, 0xd4, 0xe2, 0x12, 0x21, 0x21, 0x2e, 0x96, 0x94, 0xc4, 0x92, 0x44, 0x09, 0x46, 0x05, - 0x46, 0x0d, 0xce, 0x20, 0x30, 0x5b, 0x89, 0x9d, 0x8b, 0xd5, 0x35, 0xb7, 0xa0, 0xa4, 0x52, 0xc9, - 0x8e, 0x8b, 0xcb, 0x3d, 0xb5, 0x04, 0xa6, 0x54, 0x80, 0x8b, 0xd9, 0xd7, 0xd1, 0x19, 0xaa, 0x12, - 0xc4, 0x14, 0xe2, 0xe3, 0x62, 0xf2, 0x0c, 0x90, 0x60, 0x02, 0x0b, 0x30, 0x79, 0x06, 0x80, 0xf9, - 0x2e, 0x12, 0xcc, 0x50, 0xbe, 0x8b, 0x92, 0x1c, 0x17, 0x87, 0x07, 0xd4, 0x55, 0x20, 0x8b, 0xbc, - 0x82, 0xfd, 0xfd, 0x60, 0x16, 0x81, 0xd8, 0x46, 0x5f, 0xd8, 0xb8, 0xf8, 0x61, 0x0a, 0x82, 0x53, - 0x8b, 0xca, 0x32, 0x93, 0x53, 0x85, 0xba, 0x19, 0xb9, 0x58, 0x40, 0x0e, 0x14, 0x32, 0xd7, 0x23, - 0xde, 0xcf, 0x7a, 0x48, 0x5e, 0x92, 0x32, 0x24, 0x45, 0x23, 0xc4, 0xa3, 0xe2, 0x4d, 0x97, 0x9f, - 0x4c, 0x66, 0x12, 0x54, 0xe2, 0xd1, 0x2f, 0x33, 0x84, 0x07, 0xbd, 0x15, 0xa3, 0x96, 0x50, 0x29, - 0x17, 0xab, 0x53, 0x25, 0xc8, 0xab, 0x66, 0xa4, 0x18, 0x8a, 0x08, 0x34, 0x29, 0x13, 0x52, 0xf4, - 0xc1, 0x03, 0xab, 0x84, 0x8b, 0xc5, 0xa9, 0xd2, 0x33, 0x60, 0x40, 0x6c, 0x75, 0xa1, 0xb3, 0xad, - 0x6d, 0x8c, 0x5c, 0xcc, 0x8e, 0x39, 0x39, 0x42, 0xa4, 0x47, 0x1b, 0x79, 0x16, 0x2a, 0x89, 0x80, - 0x23, 0x9b, 0x4f, 0x08, 0x25, 0xb2, 0x0d, 0x18, 0x85, 0xf2, 0xb8, 0xd8, 0x3c, 0xf3, 0xd2, 0x41, - 0x29, 0x9d, 0x0c, 0xa7, 0x90, 0xae, 0x45, 0xa8, 0x9c, 0x8b, 0x35, 0x3c, 0xb1, 0x24, 0x39, 0x83, - 0xbe, 0xe1, 0x6d, 0xc0, 0xe8, 0xc4, 0x15, 0xc5, 0x01, 0x13, 0x4e, 0x62, 0x03, 0xab, 0x33, 0x06, - 0x04, 0x00, 0x00, 0xff, 0xff, 0x17, 0x7a, 0xd6, 0x42, 0x7a, 0x04, 0x00, 0x00, + // 1301 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x57, 0xcd, 0x6e, 0x1c, 0xc5, + 0x13, 0xd7, 0xec, 0xe7, 0xb8, 0xbc, 0xb1, 0xff, 0xff, 0x26, 0x4a, 0x46, 0xa3, 0x08, 0x99, 0x15, + 0x42, 0x56, 0x0e, 0xeb, 0xc4, 0x44, 0x20, 0x10, 0x20, 0xd9, 0xde, 0x84, 0x2c, 0xc4, 0xf6, 0xaa, + 0x37, 0x4e, 0xc2, 0xc7, 0xa5, 0x77, 0xa6, 0x77, 0xb7, 0xe5, 0xf9, 0x62, 0xba, 0xc7, 0xcb, 0x5e, + 0x38, 0x70, 0xc8, 0x25, 0x47, 0x0e, 0x9c, 0xb8, 0xe4, 0x09, 0x78, 0x17, 0xc4, 0x1b, 0xf0, 0x08, + 0x3c, 0x00, 0xaa, 0x9e, 0x9e, 0xdd, 0x59, 0x07, 0xa1, 0xd8, 0x6b, 0xc2, 0xad, 0xaa, 0xa6, 0xe7, + 0x57, 0xd5, 0x55, 0xbf, 0xae, 0xea, 0x86, 0x9b, 0x13, 0x96, 0xfa, 0x53, 0x96, 0xf2, 0x9d, 0x42, + 0xe8, 0x24, 0x69, 0xac, 0x62, 0x72, 0x7b, 0x2c, 0xd4, 0x24, 0x1b, 0x76, 0xbc, 0x38, 0xec, 0x28, + 0x11, 0x9d, 0xf2, 0x74, 0xc8, 0x83, 0x40, 0x8b, 0xf9, 0x0a, 0xd9, 0x29, 0xfe, 0x70, 0x6f, 0x8d, + 0xe3, 0x78, 0x1c, 0xf0, 0x1d, 0x96, 0x88, 0x1d, 0x16, 0x45, 0xb1, 0x62, 0x4a, 0xc4, 0x91, 0xcc, + 0xd7, 0xb5, 0xdf, 0x81, 0xf5, 0x7e, 0x26, 0x27, 0x94, 0x7f, 0x97, 0x71, 0xa9, 0x08, 0x81, 0x9a, + 0xcf, 0x14, 0x73, 0xac, 0x2d, 0x6b, 0x7b, 0x8d, 0x6a, 0xb9, 0xdd, 0x84, 0xfa, 0xfd, 0x30, 0x51, + 0xb3, 0xf6, 0x67, 0x00, 0x9f, 0x73, 0x55, 0x2c, 0xfd, 0x1f, 0x54, 0x0f, 0xf7, 0x0e, 0xcc, 0x4a, + 0x14, 0xc9, 0x06, 0x54, 0x7a, 0x7d, 0xa7, 0xa2, 0x0d, 0x95, 0x5e, 0x5f, 0xeb, 0x5d, 0xa7, 0x6a, + 0xf4, 0x6e, 0xfb, 0xa5, 0x03, 0xf6, 0x43, 0x13, 0x96, 0xf9, 0x68, 0x15, 0x1f, 0xc9, 0x21, 0xd4, + 0xfc, 0x89, 0x97, 0xe8, 0xdf, 0xd7, 0x77, 0x3f, 0xea, 0xbc, 0xfe, 0x0e, 0x3b, 0x05, 0x66, 0xa7, + 0xfb, 0xf0, 0xa0, 0x4f, 0x35, 0x0c, 0x79, 0x02, 0xcd, 0x88, 0xab, 0x61, 0x1c, 0x2b, 0x1d, 0xc0, + 0xfa, 0xee, 0x27, 0x97, 0x42, 0x3c, 0xca, 0x31, 0x68, 0x01, 0x66, 0x70, 0xa7, 0x71, 0x7a, 0xea, + 0xd4, 0xb6, 0xaa, 0xab, 0xe0, 0x22, 0x06, 0x2d, 0xc0, 0xc8, 0x57, 0x60, 0x87, 0x5c, 0x31, 0x9d, + 0xfc, 0xba, 0x0e, 0xf8, 0xd3, 0x4b, 0x01, 0x1f, 0x1a, 0x10, 0x3a, 0x87, 0x73, 0x9f, 0x57, 0xa0, + 0x86, 0x99, 0x79, 0x8d, 0x8a, 0xb9, 0x60, 0x4f, 0x62, 0xa9, 0x22, 0x16, 0x72, 0x53, 0xb7, 0xb9, + 0x4e, 0x6e, 0xc1, 0x5a, 0xc0, 0x99, 0xe4, 0x8f, 0x45, 0xc8, 0x9d, 0xda, 0x96, 0xb5, 0x5d, 0xa5, + 0x0b, 0x03, 0xd9, 0x82, 0x75, 0x5c, 0x35, 0xe0, 0xe9, 0x19, 0x4f, 0xa5, 0x53, 0xdf, 0xaa, 0x6e, + 0xaf, 0xd1, 0xb2, 0x09, 0x57, 0x28, 0xb1, 0x58, 0xd1, 0xc8, 0x57, 0x94, 0x4c, 0xc4, 0x81, 0xe6, + 0x98, 0x29, 0x3e, 0x65, 0x33, 0xa7, 0xa9, 0x9d, 0x17, 0x2a, 0xd2, 0x92, 0xa5, 0xde, 0xc4, 0xb1, + 0x73, 0x5a, 0xa2, 0x8c, 0xb6, 0x8c, 0x8f, 0x84, 0xb3, 0xb6, 0x65, 0x6d, 0xdb, 0x54, 0xcb, 0x18, + 0xa3, 0x18, 0x31, 0x8f, 0x1f, 0xe1, 0x06, 0x40, 0x2f, 0x5e, 0x18, 0xdc, 0x9f, 0xab, 0xd0, 0x34, + 0x05, 0xc5, 0x9d, 0xb2, 0x20, 0x88, 0xa7, 0xfd, 0x67, 0xf7, 0x75, 0x42, 0x6c, 0x3a, 0xd7, 0xc9, + 0xbb, 0x70, 0x4d, 0xcb, 0x4f, 0xe3, 0xf4, 0x74, 0x14, 0xc4, 0x53, 0x9d, 0x20, 0x9b, 0x2e, 0x1b, + 0xc9, 0x09, 0xd4, 0x44, 0xf2, 0x3d, 0x37, 0xf4, 0xda, 0x5b, 0x85, 0x5e, 0x9d, 0x5e, 0xff, 0xd9, + 0x7d, 0xaa, 0xe1, 0x48, 0x08, 0x2d, 0x34, 0x49, 0x95, 0xb2, 0x24, 0xe1, 0xa9, 0xce, 0xf4, 0xfa, + 0x6e, 0x6f, 0x25, 0xf8, 0xfd, 0x12, 0x20, 0x5d, 0x82, 0x77, 0xef, 0x41, 0x0d, 0x9d, 0x23, 0x37, + 0x4e, 0xe8, 0xa3, 0x82, 0x1b, 0x27, 0xf4, 0x11, 0x66, 0xc8, 0x8b, 0x23, 0xc5, 0x23, 0x25, 0x0d, + 0x43, 0xe6, 0xba, 0x7b, 0x04, 0xad, 0x32, 0x26, 0xb9, 0x01, 0x8d, 0x53, 0x9e, 0x46, 0x3c, 0x30, + 0x00, 0x46, 0x43, 0xbb, 0x88, 0x84, 0x4a, 0x7d, 0x83, 0x60, 0x34, 0xe4, 0xdd, 0xf1, 0xa0, 0xe8, + 0x0c, 0xc7, 0x03, 0xf7, 0x57, 0x4b, 0x57, 0x46, 0x9f, 0x84, 0xa2, 0x11, 0x58, 0x57, 0xd6, 0x08, + 0x4c, 0x1a, 0x4c, 0x6b, 0x59, 0xb1, 0x11, 0x18, 0xc1, 0xfd, 0x7d, 0x03, 0xec, 0xe2, 0xb0, 0x91, + 0xeb, 0x50, 0x97, 0x8a, 0x29, 0x6e, 0xb6, 0x9f, 0x2b, 0xc8, 0xf8, 0x61, 0x1c, 0xf9, 0x22, 0x1a, + 0x1f, 0xc6, 0x3e, 0xd7, 0xee, 0xab, 0xb4, 0x6c, 0x22, 0x11, 0xb4, 0x42, 0x16, 0x65, 0x23, 0xe6, + 0xa9, 0x2c, 0xe5, 0xa9, 0xe1, 0xd2, 0x17, 0x2b, 0x9d, 0xfc, 0xce, 0x61, 0x09, 0x91, 0x2e, 0xe1, + 0x93, 0x21, 0xd8, 0x22, 0x92, 0x8a, 0x45, 0x1e, 0x37, 0xc4, 0x7a, 0xb0, 0x9a, 0xaf, 0x9e, 0x41, + 0xa3, 0x73, 0x5c, 0xf2, 0x2d, 0x34, 0xbc, 0x4c, 0xaa, 0x38, 0x34, 0x7d, 0xac, 0xbb, 0x9a, 0x87, + 0x03, 0x8d, 0x45, 0x0d, 0x26, 0xee, 0x60, 0xc4, 0x3c, 0x11, 0x08, 0x35, 0x73, 0x1a, 0x57, 0xb1, + 0x83, 0x07, 0x06, 0x8d, 0xce, 0x71, 0xdd, 0x5d, 0x68, 0x95, 0x73, 0xf8, 0xca, 0xa8, 0x22, 0x50, + 0x93, 0x41, 0x36, 0x36, 0x9c, 0xd6, 0xb2, 0xfb, 0x8b, 0x0d, 0x76, 0x91, 0x8c, 0x57, 0x7e, 0x98, + 0xd3, 0xa3, 0x52, 0xa6, 0xc7, 0x3f, 0x35, 0xdb, 0x72, 0x7b, 0xaa, 0x9d, 0x6b, 0x4f, 0x37, 0xa0, + 0x91, 0x72, 0xe9, 0x65, 0x5c, 0x27, 0xd8, 0xa6, 0x46, 0x23, 0x23, 0x7d, 0xa8, 0xf2, 0xa4, 0x3c, + 0xb9, 0x9a, 0xb2, 0x76, 0x8e, 0x13, 0x9e, 0x32, 0x25, 0xa2, 0xf1, 0x60, 0x26, 0x15, 0x0f, 0xf1, + 0xb0, 0x62, 0x93, 0x65, 0xc1, 0x94, 0xcd, 0x24, 0x06, 0xd7, 0xd4, 0x21, 0x2c, 0x0c, 0xd8, 0x3c, + 0xb1, 0x8f, 0x0d, 0xbc, 0x54, 0x24, 0x0a, 0x5b, 0x4a, 0xde, 0xb3, 0x97, 0x8d, 0xe4, 0x1b, 0xa8, + 0xf6, 0xfa, 0xd2, 0x59, 0xd3, 0x23, 0xb4, 0x77, 0x45, 0xc1, 0xf6, 0xfa, 0x14, 0x51, 0x31, 0x79, + 0x99, 0xe4, 0x69, 0x17, 0x67, 0x69, 0x3e, 0x04, 0xe6, 0x3a, 0xb9, 0x03, 0x6f, 0x79, 0xe9, 0x2c, + 0x51, 0xdc, 0xa7, 0x71, 0xac, 0xfa, 0x4c, 0xca, 0x69, 0x9c, 0xfa, 0xce, 0xba, 0x5e, 0xf6, 0x77, + 0x9f, 0xb0, 0xda, 0x8a, 0x8d, 0xa5, 0xd3, 0xd2, 0x03, 0x4b, 0xcb, 0x64, 0x02, 0x4d, 0xa9, 0xe2, + 0x94, 0x8d, 0xb9, 0x73, 0x4d, 0xe7, 0xfb, 0xe8, 0x8a, 0xb6, 0x30, 0xc8, 0x51, 0x69, 0x01, 0x8f, + 0x33, 0x51, 0xca, 0xc9, 0x97, 0x7c, 0x26, 0x9d, 0x0d, 0x1d, 0x40, 0xa1, 0x92, 0x36, 0xb4, 0xcc, + 0xe5, 0x81, 0x72, 0xe6, 0xcf, 0x9c, 0x4d, 0x5d, 0x89, 0x25, 0x9b, 0xfb, 0xc2, 0x82, 0xcd, 0x73, + 0x25, 0x9c, 0xb3, 0xd7, 0x5a, 0xb0, 0x17, 0x29, 0xe5, 0x0b, 0xa9, 0xd2, 0xb8, 0xe8, 0xd3, 0xb9, + 0x86, 0xde, 0x71, 0x32, 0x8b, 0x38, 0x32, 0x0c, 0x2d, 0x54, 0xcc, 0xb1, 0x08, 0xd9, 0x98, 0x3f, + 0x66, 0x63, 0x4d, 0xd0, 0x35, 0x3a, 0xd7, 0x11, 0x2d, 0x96, 0x03, 0xf4, 0x51, 0xcf, 0xd1, 0x72, + 0xcd, 0x7d, 0x69, 0xe1, 0x75, 0x03, 0x41, 0x99, 0xef, 0xa7, 0x5c, 0x4a, 0x13, 0x43, 0xa1, 0xe2, + 0x97, 0x88, 0xab, 0x90, 0xc9, 0x53, 0x13, 0x47, 0xa1, 0x96, 0xaf, 0x06, 0xd5, 0xe5, 0xab, 0xc1, + 0x0d, 0x68, 0x8c, 0x58, 0x28, 0x82, 0x99, 0xb9, 0x93, 0x18, 0x0d, 0xed, 0x49, 0x36, 0x0c, 0x84, + 0x57, 0x9c, 0x92, 0x5c, 0x23, 0x6f, 0x03, 0x84, 0x2c, 0x62, 0x63, 0x1e, 0xf2, 0x48, 0xe9, 0xd3, + 0x62, 0xd3, 0x92, 0xc5, 0x3d, 0x81, 0xa6, 0x29, 0x02, 0x1e, 0x5b, 0x5f, 0xc8, 0x53, 0x0c, 0x13, + 0x33, 0x9f, 0x2b, 0x98, 0x3f, 0xba, 0xd7, 0xeb, 0x3a, 0x95, 0x9c, 0x0f, 0x28, 0x63, 0xa7, 0x1f, + 0x89, 0x80, 0x4b, 0x9d, 0x61, 0xe9, 0x54, 0xf3, 0xbb, 0x4d, 0xc9, 0x84, 0x13, 0xae, 0x91, 0xb7, + 0x32, 0xf2, 0x03, 0x6c, 0x24, 0x29, 0xd7, 0xfd, 0x32, 0x08, 0xb8, 0x7f, 0x3c, 0x30, 0xa3, 0xee, + 0xdf, 0x3a, 0xb3, 0xe7, 0xbc, 0x91, 0xf7, 0xd0, 0xbf, 0x38, 0x63, 0x8a, 0x0f, 0xb2, 0x61, 0xc4, + 0xf5, 0x78, 0xc7, 0x78, 0xcf, 0x59, 0x5d, 0x05, 0x76, 0xd1, 0x1c, 0xb1, 0xdc, 0x49, 0xc0, 0xa2, + 0xc1, 0x82, 0x38, 0x73, 0x9d, 0x6c, 0xc3, 0x26, 0xca, 0x4f, 0x72, 0x66, 0x0c, 0x16, 0x9d, 0xf1, + 0xbc, 0x19, 0x29, 0x5b, 0x34, 0xd9, 0x03, 0x9c, 0x88, 0x79, 0x29, 0x97, 0x6c, 0xbb, 0x7f, 0x36, + 0x60, 0xb3, 0xd8, 0x1c, 0x5e, 0x0c, 0x85, 0xc7, 0xc9, 0x0b, 0x0b, 0x6a, 0xf8, 0x4a, 0x21, 0x1f, + 0x5e, 0x24, 0x45, 0xa5, 0x77, 0x8d, 0x7b, 0xf7, 0x22, 0x3f, 0xe6, 0xaf, 0x9d, 0x9b, 0x3f, 0xfe, + 0xf6, 0xc7, 0x4f, 0x95, 0xff, 0xb7, 0x5b, 0x3b, 0x67, 0x77, 0xe7, 0xef, 0xaf, 0x8f, 0xad, 0xdb, + 0x24, 0x83, 0xfa, 0xfe, 0x0c, 0x6f, 0xcf, 0x1f, 0x5c, 0x04, 0x74, 0xf1, 0x72, 0x72, 0xef, 0x5d, + 0xa6, 0xd0, 0x44, 0x41, 0x6d, 0x7f, 0xd6, 0xeb, 0xff, 0x27, 0x5e, 0xbb, 0x6f, 0xd8, 0xeb, 0x73, + 0x0b, 0xaa, 0x7b, 0x41, 0x40, 0x2e, 0x5e, 0xb6, 0xcb, 0x39, 0x6c, 0x5f, 0xd7, 0xc5, 0xde, 0x20, + 0x4b, 0xc5, 0xbe, 0x63, 0x91, 0x08, 0x1a, 0xbd, 0x68, 0x8c, 0xcf, 0xdd, 0x4b, 0x84, 0x72, 0xf1, + 0x5f, 0xc8, 0x14, 0xea, 0x4f, 0x99, 0xf2, 0x26, 0x6f, 0x36, 0xdf, 0x77, 0xac, 0x7d, 0xf8, 0xda, + 0x2e, 0xcc, 0xc3, 0x86, 0x5e, 0xf7, 0xfe, 0x5f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xea, 0x60, 0x6d, + 0x57, 0x7f, 0x10, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. diff --git a/protos/hardware/hardware.proto b/protos/hardware/hardware.proto index 2fdc70449..a18305784 100644 --- a/protos/hardware/hardware.proto +++ b/protos/hardware/hardware.proto @@ -39,5 +39,106 @@ message GetRequest { } message Hardware { - string JSON = 1; + message DHCP { + string MAC = 1; + string IP = 2; + string hostname = 3; + int64 leaseTime = 4; + repeated string nameServers = 5; + repeated string timeServers = 6; + string gateway = 7; + string arch = 8; + bool uefi = 9; + string ifaceName = 10; + } + message Netboot { + message IPXE { + string URL = 1; + string contents = 2; + } + message Bootstrapper { + string kernel = 1; + string initrd = 2; + string OS = 3; + } + + bool allowPXE = 1; + bool allowWorkflow = 2; + IPXE ipxe = 3; + Bootstrapper bootstrapper = 4; + } + message Network { + DHCP dhcp = 1; + Netboot Netboot = 2; + } + message Metadata { + message Manufacturer { + string ID = 1; + string slug = 2; + } + message Instance { + message OperatingSystem { + string slug = 1; + string distro = 2; + string version = 3; + string imageTag = 4; + string osSlug = 5; + } + message IP { + string address = 1; + string netmask = 2; + string gateway = 3; + int64 family = 4; + bool public = 5; + bool management = 6; + } + message Storage { + // TODO: create the actual structs + repeated string disks = 1; + repeated string RAID = 2; + repeated string filesystems = 3; + } + + string ID = 1; + string state = 2; + string hostname = 3; + bool allowPXE = 4; + bool rescue = 5; + + OperatingSystem OS = 6; + bool alwaysPXE = 7; + string ipxeScriptURL = 8; + repeated IP IPs = 9; + string userData = 10; + + string cryptedRootPassword = 11; + + repeated string tags = 12; + Storage storage = 13; + repeated string sshKeys = 14; + bool networkReady = 15; + } + message Custom { + Instance.OperatingSystem preinstalledOS = 1; + repeated string privateSubnets = 2; + } + message Facility { + string planSlug = 1; + string planVersionSlug = 2; + string facilityCode = 3; + } + + string state = 1; + int64 bondingMode = 2; + Manufacturer manufacturer = 3; + Instance instance = 4; + Custom custom = 5; + Facility facility = 6; + } + + string ID = 1; + DHCP dhcp = 2; + Netboot netboot = 3; + repeated Network network = 4; + Metadata metadata = 5; }