From d2406c313269defde5626c87830091865f48b364 Mon Sep 17 00:00:00 2001 From: aatarasoff Date: Fri, 13 Feb 2026 23:13:33 +0400 Subject: [PATCH] support drift cli --- cmd/drift.go | 83 +++ cmd/root.go | 2 + gen/pbuf-registry/v1/drift.pb.go | 696 ++++++++++++++++++ gen/pbuf-registry/v1/drift_grpc.pb.go | 207 ++++++ pbuf.yaml | 2 +- .../google/api/cloudquotas/v1/resources.proto | 2 +- .../v1beta/quota_adjuster_settings.proto | 10 +- .../api/cloudquotas/v1beta/resources.proto | 2 +- third_party/pbuf-registry/v1/drift.proto | 131 ++++ 9 files changed, 1129 insertions(+), 6 deletions(-) create mode 100644 cmd/drift.go create mode 100644 gen/pbuf-registry/v1/drift.pb.go create mode 100644 gen/pbuf-registry/v1/drift_grpc.pb.go create mode 100644 third_party/pbuf-registry/v1/drift.proto diff --git a/cmd/drift.go b/cmd/drift.go new file mode 100644 index 0000000..d306111 --- /dev/null +++ b/cmd/drift.go @@ -0,0 +1,83 @@ +package cmd + +import ( + v1 "github.com/pbufio/pbuf-cli/gen/pbuf-registry/v1" + "github.com/pbufio/pbuf-cli/internal/model" + "github.com/spf13/cobra" +) + +func NewDriftCmd(_ *model.Config, client v1.DriftServiceClient) *cobra.Command { + driftCmd := &cobra.Command{ + Use: "drift", + Short: "Drift", + Long: "Drift is a command to manage drift detection events", + RunE: func(cmd *cobra.Command, args []string) error { + return cmd.Help() + }, + } + + driftCmd.AddCommand(newListDriftEventsCmd(client)) + driftCmd.AddCommand(newGetModuleDriftEventsCmd(client)) + + return driftCmd +} + +func newListDriftEventsCmd(client v1.DriftServiceClient) *cobra.Command { + listCmd := &cobra.Command{ + Use: "list", + Short: "List drift events", + Long: "List is a command to list all drift events", + Args: cobra.ExactArgs(0), + RunE: func(cmd *cobra.Command, args []string) error { + unacknowledgedOnly, err := cmd.Flags().GetBool("unacknowledged-only") + if err != nil { + return err + } + + resp, err := client.ListDriftEvents(cmd.Context(), &v1.ListDriftEventsRequest{ + UnacknowledgedOnly: unacknowledgedOnly, + }) + if err != nil { + return err + } + + return printJSON(resp) + }, + } + + listCmd.Flags().Bool("unacknowledged-only", true, "only return unacknowledged events") + return listCmd +} + +func newGetModuleDriftEventsCmd(client v1.DriftServiceClient) *cobra.Command { + getCmd := &cobra.Command{ + Use: "module [module_name]", + Short: "Get module drift events", + Long: "Module is a command to get drift events for a specific module", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) error { + moduleName := args[0] + tagName, err := cmd.Flags().GetString("tag") + if err != nil { + return err + } + + req := &v1.GetModuleDriftEventsRequest{ + ModuleName: moduleName, + } + if tagName != "" { + req.TagName = &tagName + } + + resp, err := client.GetModuleDriftEvents(cmd.Context(), req) + if err != nil { + return err + } + + return printJSON(resp) + }, + } + + getCmd.Flags().String("tag", "", "filter drift events by tag name") + return getCmd +} diff --git a/cmd/root.go b/cmd/root.go index 6719e81..aa7e4d8 100644 --- a/cmd/root.go +++ b/cmd/root.go @@ -70,11 +70,13 @@ func NewRootCmd() *cobra.Command { registryClient := v1.NewRegistryClient(conn) usersClient := v1.NewUserServiceClient(conn) + driftClient := v1.NewDriftServiceClient(conn) rootCmd.AddCommand(NewModuleCmd(modulesConfig, registryClient)) rootCmd.AddCommand(NewVendorCmd(modulesConfig, netrcAuth, registryClient)) rootCmd.AddCommand(NewAuthCmd(modulesConfig, usr, netrcAuth)) rootCmd.AddCommand(NewUsersCmd(modulesConfig, usersClient)) + rootCmd.AddCommand(NewDriftCmd(modulesConfig, driftClient)) } else { rootCmd.AddCommand(NewVendorCmd(modulesConfig, netrcAuth, nil)) } diff --git a/gen/pbuf-registry/v1/drift.pb.go b/gen/pbuf-registry/v1/drift.pb.go new file mode 100644 index 0000000..80fed36 --- /dev/null +++ b/gen/pbuf-registry/v1/drift.pb.go @@ -0,0 +1,696 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.11 +// protoc (unknown) +// source: pbuf-registry/v1/drift.proto + +package v1 + +import ( + _ "google.golang.org/genproto/googleapis/api/annotations" + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +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) +) + +// DriftEventType represents the type of drift event +type DriftEventType int32 + +const ( + DriftEventType_DRIFT_EVENT_TYPE_UNSPECIFIED DriftEventType = 0 + DriftEventType_DRIFT_EVENT_TYPE_ADDED DriftEventType = 1 + DriftEventType_DRIFT_EVENT_TYPE_MODIFIED DriftEventType = 2 + DriftEventType_DRIFT_EVENT_TYPE_DELETED DriftEventType = 3 +) + +// Enum value maps for DriftEventType. +var ( + DriftEventType_name = map[int32]string{ + 0: "DRIFT_EVENT_TYPE_UNSPECIFIED", + 1: "DRIFT_EVENT_TYPE_ADDED", + 2: "DRIFT_EVENT_TYPE_MODIFIED", + 3: "DRIFT_EVENT_TYPE_DELETED", + } + DriftEventType_value = map[string]int32{ + "DRIFT_EVENT_TYPE_UNSPECIFIED": 0, + "DRIFT_EVENT_TYPE_ADDED": 1, + "DRIFT_EVENT_TYPE_MODIFIED": 2, + "DRIFT_EVENT_TYPE_DELETED": 3, + } +) + +func (x DriftEventType) Enum() *DriftEventType { + p := new(DriftEventType) + *p = x + return p +} + +func (x DriftEventType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (DriftEventType) Descriptor() protoreflect.EnumDescriptor { + return file_pbuf_registry_v1_drift_proto_enumTypes[0].Descriptor() +} + +func (DriftEventType) Type() protoreflect.EnumType { + return &file_pbuf_registry_v1_drift_proto_enumTypes[0] +} + +func (x DriftEventType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use DriftEventType.Descriptor instead. +func (DriftEventType) EnumDescriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{0} +} + +// DriftSeverity represents the severity level of a drift event +type DriftSeverity int32 + +const ( + DriftSeverity_DRIFT_SEVERITY_UNSPECIFIED DriftSeverity = 0 + DriftSeverity_DRIFT_SEVERITY_INFO DriftSeverity = 1 + DriftSeverity_DRIFT_SEVERITY_WARNING DriftSeverity = 2 + DriftSeverity_DRIFT_SEVERITY_CRITICAL DriftSeverity = 3 +) + +// Enum value maps for DriftSeverity. +var ( + DriftSeverity_name = map[int32]string{ + 0: "DRIFT_SEVERITY_UNSPECIFIED", + 1: "DRIFT_SEVERITY_INFO", + 2: "DRIFT_SEVERITY_WARNING", + 3: "DRIFT_SEVERITY_CRITICAL", + } + DriftSeverity_value = map[string]int32{ + "DRIFT_SEVERITY_UNSPECIFIED": 0, + "DRIFT_SEVERITY_INFO": 1, + "DRIFT_SEVERITY_WARNING": 2, + "DRIFT_SEVERITY_CRITICAL": 3, + } +) + +func (x DriftSeverity) Enum() *DriftSeverity { + p := new(DriftSeverity) + *p = x + return p +} + +func (x DriftSeverity) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (DriftSeverity) Descriptor() protoreflect.EnumDescriptor { + return file_pbuf_registry_v1_drift_proto_enumTypes[1].Descriptor() +} + +func (DriftSeverity) Type() protoreflect.EnumType { + return &file_pbuf_registry_v1_drift_proto_enumTypes[1] +} + +func (x DriftSeverity) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use DriftSeverity.Descriptor instead. +func (DriftSeverity) EnumDescriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{1} +} + +// DriftEvent represents a detected change in a proto file +type DriftEvent struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The unique identifier of the drift event + Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` + // The module name where the drift was detected + ModuleName string `protobuf:"bytes,2,opt,name=module_name,json=moduleName,proto3" json:"module_name,omitempty"` + // The tag name where the drift was detected + TagName string `protobuf:"bytes,3,opt,name=tag_name,json=tagName,proto3" json:"tag_name,omitempty"` + // The filename of the proto file that changed + Filename string `protobuf:"bytes,4,opt,name=filename,proto3" json:"filename,omitempty"` + // The type of drift event + EventType DriftEventType `protobuf:"varint,5,opt,name=event_type,json=eventType,proto3,enum=pbufregistry.v1.DriftEventType" json:"event_type,omitempty"` + // The previous content hash (empty for added files) + PreviousHash string `protobuf:"bytes,6,opt,name=previous_hash,json=previousHash,proto3" json:"previous_hash,omitempty"` + // The current content hash (empty for deleted files) + CurrentHash string `protobuf:"bytes,7,opt,name=current_hash,json=currentHash,proto3" json:"current_hash,omitempty"` + // The severity of the drift event + Severity DriftSeverity `protobuf:"varint,8,opt,name=severity,proto3,enum=pbufregistry.v1.DriftSeverity" json:"severity,omitempty"` + // When the drift was detected + DetectedAt *timestamppb.Timestamp `protobuf:"bytes,9,opt,name=detected_at,json=detectedAt,proto3" json:"detected_at,omitempty"` + // Whether the event has been acknowledged + Acknowledged bool `protobuf:"varint,10,opt,name=acknowledged,proto3" json:"acknowledged,omitempty"` + // When the event was acknowledged + AcknowledgedAt *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=acknowledged_at,json=acknowledgedAt,proto3" json:"acknowledged_at,omitempty"` + // Who acknowledged the event + AcknowledgedBy string `protobuf:"bytes,12,opt,name=acknowledged_by,json=acknowledgedBy,proto3" json:"acknowledged_by,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DriftEvent) Reset() { + *x = DriftEvent{} + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DriftEvent) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DriftEvent) ProtoMessage() {} + +func (x *DriftEvent) ProtoReflect() protoreflect.Message { + mi := &file_pbuf_registry_v1_drift_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 DriftEvent.ProtoReflect.Descriptor instead. +func (*DriftEvent) Descriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{0} +} + +func (x *DriftEvent) GetId() string { + if x != nil { + return x.Id + } + return "" +} + +func (x *DriftEvent) GetModuleName() string { + if x != nil { + return x.ModuleName + } + return "" +} + +func (x *DriftEvent) GetTagName() string { + if x != nil { + return x.TagName + } + return "" +} + +func (x *DriftEvent) GetFilename() string { + if x != nil { + return x.Filename + } + return "" +} + +func (x *DriftEvent) GetEventType() DriftEventType { + if x != nil { + return x.EventType + } + return DriftEventType_DRIFT_EVENT_TYPE_UNSPECIFIED +} + +func (x *DriftEvent) GetPreviousHash() string { + if x != nil { + return x.PreviousHash + } + return "" +} + +func (x *DriftEvent) GetCurrentHash() string { + if x != nil { + return x.CurrentHash + } + return "" +} + +func (x *DriftEvent) GetSeverity() DriftSeverity { + if x != nil { + return x.Severity + } + return DriftSeverity_DRIFT_SEVERITY_UNSPECIFIED +} + +func (x *DriftEvent) GetDetectedAt() *timestamppb.Timestamp { + if x != nil { + return x.DetectedAt + } + return nil +} + +func (x *DriftEvent) GetAcknowledged() bool { + if x != nil { + return x.Acknowledged + } + return false +} + +func (x *DriftEvent) GetAcknowledgedAt() *timestamppb.Timestamp { + if x != nil { + return x.AcknowledgedAt + } + return nil +} + +func (x *DriftEvent) GetAcknowledgedBy() string { + if x != nil { + return x.AcknowledgedBy + } + return "" +} + +// ListDriftEventsRequest is the request message for ListDriftEvents +type ListDriftEventsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Optional: only return unacknowledged events (default: true) + UnacknowledgedOnly bool `protobuf:"varint,1,opt,name=unacknowledged_only,json=unacknowledgedOnly,proto3" json:"unacknowledged_only,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListDriftEventsRequest) Reset() { + *x = ListDriftEventsRequest{} + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListDriftEventsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListDriftEventsRequest) ProtoMessage() {} + +func (x *ListDriftEventsRequest) ProtoReflect() protoreflect.Message { + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[1] + 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 ListDriftEventsRequest.ProtoReflect.Descriptor instead. +func (*ListDriftEventsRequest) Descriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{1} +} + +func (x *ListDriftEventsRequest) GetUnacknowledgedOnly() bool { + if x != nil { + return x.UnacknowledgedOnly + } + return false +} + +// ListDriftEventsResponse is the response message for ListDriftEvents +type ListDriftEventsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of drift events + Events []*DriftEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListDriftEventsResponse) Reset() { + *x = ListDriftEventsResponse{} + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListDriftEventsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListDriftEventsResponse) ProtoMessage() {} + +func (x *ListDriftEventsResponse) ProtoReflect() protoreflect.Message { + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[2] + 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 ListDriftEventsResponse.ProtoReflect.Descriptor instead. +func (*ListDriftEventsResponse) Descriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{2} +} + +func (x *ListDriftEventsResponse) GetEvents() []*DriftEvent { + if x != nil { + return x.Events + } + return nil +} + +// GetModuleDriftEventsRequest is the request message for GetModuleDriftEvents +type GetModuleDriftEventsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The module name to get drift events for + ModuleName string `protobuf:"bytes,1,opt,name=module_name,json=moduleName,proto3" json:"module_name,omitempty"` + // Optional: filter drift events by tag name + TagName *string `protobuf:"bytes,2,opt,name=tag_name,json=tagName,proto3,oneof" json:"tag_name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetModuleDriftEventsRequest) Reset() { + *x = GetModuleDriftEventsRequest{} + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetModuleDriftEventsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetModuleDriftEventsRequest) ProtoMessage() {} + +func (x *GetModuleDriftEventsRequest) ProtoReflect() protoreflect.Message { + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[3] + 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 GetModuleDriftEventsRequest.ProtoReflect.Descriptor instead. +func (*GetModuleDriftEventsRequest) Descriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{3} +} + +func (x *GetModuleDriftEventsRequest) GetModuleName() string { + if x != nil { + return x.ModuleName + } + return "" +} + +func (x *GetModuleDriftEventsRequest) GetTagName() string { + if x != nil && x.TagName != nil { + return *x.TagName + } + return "" +} + +// GetModuleDriftEventsResponse is the response message for GetModuleDriftEvents +type GetModuleDriftEventsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The list of drift events for the module + Events []*DriftEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *GetModuleDriftEventsResponse) Reset() { + *x = GetModuleDriftEventsResponse{} + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *GetModuleDriftEventsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GetModuleDriftEventsResponse) ProtoMessage() {} + +func (x *GetModuleDriftEventsResponse) ProtoReflect() protoreflect.Message { + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[4] + 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 GetModuleDriftEventsResponse.ProtoReflect.Descriptor instead. +func (*GetModuleDriftEventsResponse) Descriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{4} +} + +func (x *GetModuleDriftEventsResponse) GetEvents() []*DriftEvent { + if x != nil { + return x.Events + } + return nil +} + +// AcknowledgeDriftEventRequest is the request message for AcknowledgeDriftEvent +type AcknowledgeDriftEventRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The ID of the drift event to acknowledge + EventId string `protobuf:"bytes,1,opt,name=event_id,json=eventId,proto3" json:"event_id,omitempty"` + // Who is acknowledging the event + AcknowledgedBy string `protobuf:"bytes,2,opt,name=acknowledged_by,json=acknowledgedBy,proto3" json:"acknowledged_by,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AcknowledgeDriftEventRequest) Reset() { + *x = AcknowledgeDriftEventRequest{} + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AcknowledgeDriftEventRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AcknowledgeDriftEventRequest) ProtoMessage() {} + +func (x *AcknowledgeDriftEventRequest) ProtoReflect() protoreflect.Message { + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[5] + 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 AcknowledgeDriftEventRequest.ProtoReflect.Descriptor instead. +func (*AcknowledgeDriftEventRequest) Descriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{5} +} + +func (x *AcknowledgeDriftEventRequest) GetEventId() string { + if x != nil { + return x.EventId + } + return "" +} + +func (x *AcknowledgeDriftEventRequest) GetAcknowledgedBy() string { + if x != nil { + return x.AcknowledgedBy + } + return "" +} + +// AcknowledgeDriftEventResponse is the response message for AcknowledgeDriftEvent +type AcknowledgeDriftEventResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The acknowledged drift event + Event *DriftEvent `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *AcknowledgeDriftEventResponse) Reset() { + *x = AcknowledgeDriftEventResponse{} + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *AcknowledgeDriftEventResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*AcknowledgeDriftEventResponse) ProtoMessage() {} + +func (x *AcknowledgeDriftEventResponse) ProtoReflect() protoreflect.Message { + mi := &file_pbuf_registry_v1_drift_proto_msgTypes[6] + 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 AcknowledgeDriftEventResponse.ProtoReflect.Descriptor instead. +func (*AcknowledgeDriftEventResponse) Descriptor() ([]byte, []int) { + return file_pbuf_registry_v1_drift_proto_rawDescGZIP(), []int{6} +} + +func (x *AcknowledgeDriftEventResponse) GetEvent() *DriftEvent { + if x != nil { + return x.Event + } + return nil +} + +var File_pbuf_registry_v1_drift_proto protoreflect.FileDescriptor + +const file_pbuf_registry_v1_drift_proto_rawDesc = "" + + "\n" + + "\x1cpbuf-registry/v1/drift.proto\x12\x0fpbufregistry.v1\x1a\x1cgoogle/api/annotations.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\x87\x04\n" + + "\n" + + "DriftEvent\x12\x0e\n" + + "\x02id\x18\x01 \x01(\tR\x02id\x12\x1f\n" + + "\vmodule_name\x18\x02 \x01(\tR\n" + + "moduleName\x12\x19\n" + + "\btag_name\x18\x03 \x01(\tR\atagName\x12\x1a\n" + + "\bfilename\x18\x04 \x01(\tR\bfilename\x12>\n" + + "\n" + + "event_type\x18\x05 \x01(\x0e2\x1f.pbufregistry.v1.DriftEventTypeR\teventType\x12#\n" + + "\rprevious_hash\x18\x06 \x01(\tR\fpreviousHash\x12!\n" + + "\fcurrent_hash\x18\a \x01(\tR\vcurrentHash\x12:\n" + + "\bseverity\x18\b \x01(\x0e2\x1e.pbufregistry.v1.DriftSeverityR\bseverity\x12;\n" + + "\vdetected_at\x18\t \x01(\v2\x1a.google.protobuf.TimestampR\n" + + "detectedAt\x12\"\n" + + "\facknowledged\x18\n" + + " \x01(\bR\facknowledged\x12C\n" + + "\x0facknowledged_at\x18\v \x01(\v2\x1a.google.protobuf.TimestampR\x0eacknowledgedAt\x12'\n" + + "\x0facknowledged_by\x18\f \x01(\tR\x0eacknowledgedBy\"I\n" + + "\x16ListDriftEventsRequest\x12/\n" + + "\x13unacknowledged_only\x18\x01 \x01(\bR\x12unacknowledgedOnly\"N\n" + + "\x17ListDriftEventsResponse\x123\n" + + "\x06events\x18\x01 \x03(\v2\x1b.pbufregistry.v1.DriftEventR\x06events\"k\n" + + "\x1bGetModuleDriftEventsRequest\x12\x1f\n" + + "\vmodule_name\x18\x01 \x01(\tR\n" + + "moduleName\x12\x1e\n" + + "\btag_name\x18\x02 \x01(\tH\x00R\atagName\x88\x01\x01B\v\n" + + "\t_tag_name\"S\n" + + "\x1cGetModuleDriftEventsResponse\x123\n" + + "\x06events\x18\x01 \x03(\v2\x1b.pbufregistry.v1.DriftEventR\x06events\"b\n" + + "\x1cAcknowledgeDriftEventRequest\x12\x19\n" + + "\bevent_id\x18\x01 \x01(\tR\aeventId\x12'\n" + + "\x0facknowledged_by\x18\x02 \x01(\tR\x0eacknowledgedBy\"R\n" + + "\x1dAcknowledgeDriftEventResponse\x121\n" + + "\x05event\x18\x01 \x01(\v2\x1b.pbufregistry.v1.DriftEventR\x05event*\x8b\x01\n" + + "\x0eDriftEventType\x12 \n" + + "\x1cDRIFT_EVENT_TYPE_UNSPECIFIED\x10\x00\x12\x1a\n" + + "\x16DRIFT_EVENT_TYPE_ADDED\x10\x01\x12\x1d\n" + + "\x19DRIFT_EVENT_TYPE_MODIFIED\x10\x02\x12\x1c\n" + + "\x18DRIFT_EVENT_TYPE_DELETED\x10\x03*\x81\x01\n" + + "\rDriftSeverity\x12\x1e\n" + + "\x1aDRIFT_SEVERITY_UNSPECIFIED\x10\x00\x12\x17\n" + + "\x13DRIFT_SEVERITY_INFO\x10\x01\x12\x1a\n" + + "\x16DRIFT_SEVERITY_WARNING\x10\x02\x12\x1b\n" + + "\x17DRIFT_SEVERITY_CRITICAL\x10\x032\xd6\x03\n" + + "\fDriftService\x12~\n" + + "\x0fListDriftEvents\x12'.pbufregistry.v1.ListDriftEventsRequest\x1a(.pbufregistry.v1.ListDriftEventsResponse\"\x18\x82\xd3\xe4\x93\x02\x12\x12\x10/v1/drift/events\x12\x98\x01\n" + + "\x14GetModuleDriftEvents\x12,.pbufregistry.v1.GetModuleDriftEventsRequest\x1a-.pbufregistry.v1.GetModuleDriftEventsResponse\"#\x82\xd3\xe4\x93\x02\x1d:\x01*\"\x18/v1/drift/modules/events\x12\xaa\x01\n" + + "\x15AcknowledgeDriftEvent\x12-.pbufregistry.v1.AcknowledgeDriftEventRequest\x1a..pbufregistry.v1.AcknowledgeDriftEventResponse\"2\x82\xd3\xe4\x93\x02,:\x01*\"'/v1/drift/events/{event_id}/acknowledgeB4Z2github.com/pbufio/pbuf-cli/gen/pbuf-registry/v1;v1b\x06proto3" + +var ( + file_pbuf_registry_v1_drift_proto_rawDescOnce sync.Once + file_pbuf_registry_v1_drift_proto_rawDescData []byte +) + +func file_pbuf_registry_v1_drift_proto_rawDescGZIP() []byte { + file_pbuf_registry_v1_drift_proto_rawDescOnce.Do(func() { + file_pbuf_registry_v1_drift_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_pbuf_registry_v1_drift_proto_rawDesc), len(file_pbuf_registry_v1_drift_proto_rawDesc))) + }) + return file_pbuf_registry_v1_drift_proto_rawDescData +} + +var file_pbuf_registry_v1_drift_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_pbuf_registry_v1_drift_proto_msgTypes = make([]protoimpl.MessageInfo, 7) +var file_pbuf_registry_v1_drift_proto_goTypes = []any{ + (DriftEventType)(0), // 0: pbufregistry.v1.DriftEventType + (DriftSeverity)(0), // 1: pbufregistry.v1.DriftSeverity + (*DriftEvent)(nil), // 2: pbufregistry.v1.DriftEvent + (*ListDriftEventsRequest)(nil), // 3: pbufregistry.v1.ListDriftEventsRequest + (*ListDriftEventsResponse)(nil), // 4: pbufregistry.v1.ListDriftEventsResponse + (*GetModuleDriftEventsRequest)(nil), // 5: pbufregistry.v1.GetModuleDriftEventsRequest + (*GetModuleDriftEventsResponse)(nil), // 6: pbufregistry.v1.GetModuleDriftEventsResponse + (*AcknowledgeDriftEventRequest)(nil), // 7: pbufregistry.v1.AcknowledgeDriftEventRequest + (*AcknowledgeDriftEventResponse)(nil), // 8: pbufregistry.v1.AcknowledgeDriftEventResponse + (*timestamppb.Timestamp)(nil), // 9: google.protobuf.Timestamp +} +var file_pbuf_registry_v1_drift_proto_depIdxs = []int32{ + 0, // 0: pbufregistry.v1.DriftEvent.event_type:type_name -> pbufregistry.v1.DriftEventType + 1, // 1: pbufregistry.v1.DriftEvent.severity:type_name -> pbufregistry.v1.DriftSeverity + 9, // 2: pbufregistry.v1.DriftEvent.detected_at:type_name -> google.protobuf.Timestamp + 9, // 3: pbufregistry.v1.DriftEvent.acknowledged_at:type_name -> google.protobuf.Timestamp + 2, // 4: pbufregistry.v1.ListDriftEventsResponse.events:type_name -> pbufregistry.v1.DriftEvent + 2, // 5: pbufregistry.v1.GetModuleDriftEventsResponse.events:type_name -> pbufregistry.v1.DriftEvent + 2, // 6: pbufregistry.v1.AcknowledgeDriftEventResponse.event:type_name -> pbufregistry.v1.DriftEvent + 3, // 7: pbufregistry.v1.DriftService.ListDriftEvents:input_type -> pbufregistry.v1.ListDriftEventsRequest + 5, // 8: pbufregistry.v1.DriftService.GetModuleDriftEvents:input_type -> pbufregistry.v1.GetModuleDriftEventsRequest + 7, // 9: pbufregistry.v1.DriftService.AcknowledgeDriftEvent:input_type -> pbufregistry.v1.AcknowledgeDriftEventRequest + 4, // 10: pbufregistry.v1.DriftService.ListDriftEvents:output_type -> pbufregistry.v1.ListDriftEventsResponse + 6, // 11: pbufregistry.v1.DriftService.GetModuleDriftEvents:output_type -> pbufregistry.v1.GetModuleDriftEventsResponse + 8, // 12: pbufregistry.v1.DriftService.AcknowledgeDriftEvent:output_type -> pbufregistry.v1.AcknowledgeDriftEventResponse + 10, // [10:13] is the sub-list for method output_type + 7, // [7:10] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name +} + +func init() { file_pbuf_registry_v1_drift_proto_init() } +func file_pbuf_registry_v1_drift_proto_init() { + if File_pbuf_registry_v1_drift_proto != nil { + return + } + file_pbuf_registry_v1_drift_proto_msgTypes[3].OneofWrappers = []any{} + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_pbuf_registry_v1_drift_proto_rawDesc), len(file_pbuf_registry_v1_drift_proto_rawDesc)), + NumEnums: 2, + NumMessages: 7, + NumExtensions: 0, + NumServices: 1, + }, + GoTypes: file_pbuf_registry_v1_drift_proto_goTypes, + DependencyIndexes: file_pbuf_registry_v1_drift_proto_depIdxs, + EnumInfos: file_pbuf_registry_v1_drift_proto_enumTypes, + MessageInfos: file_pbuf_registry_v1_drift_proto_msgTypes, + }.Build() + File_pbuf_registry_v1_drift_proto = out.File + file_pbuf_registry_v1_drift_proto_goTypes = nil + file_pbuf_registry_v1_drift_proto_depIdxs = nil +} diff --git a/gen/pbuf-registry/v1/drift_grpc.pb.go b/gen/pbuf-registry/v1/drift_grpc.pb.go new file mode 100644 index 0000000..3ea7f0a --- /dev/null +++ b/gen/pbuf-registry/v1/drift_grpc.pb.go @@ -0,0 +1,207 @@ +// Code generated by protoc-gen-go-grpc. DO NOT EDIT. +// versions: +// - protoc-gen-go-grpc v1.6.0 +// - protoc (unknown) +// source: pbuf-registry/v1/drift.proto + +package v1 + +import ( + context "context" + grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" +) + +// 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 ( + DriftService_ListDriftEvents_FullMethodName = "/pbufregistry.v1.DriftService/ListDriftEvents" + DriftService_GetModuleDriftEvents_FullMethodName = "/pbufregistry.v1.DriftService/GetModuleDriftEvents" + DriftService_AcknowledgeDriftEvent_FullMethodName = "/pbufregistry.v1.DriftService/AcknowledgeDriftEvent" +) + +// DriftServiceClient is the client API for DriftService 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. +// +// DriftService provides access to drift detection events +type DriftServiceClient interface { + // List all unacknowledged drift events + ListDriftEvents(ctx context.Context, in *ListDriftEventsRequest, opts ...grpc.CallOption) (*ListDriftEventsResponse, error) + // Get drift events for a specific module + GetModuleDriftEvents(ctx context.Context, in *GetModuleDriftEventsRequest, opts ...grpc.CallOption) (*GetModuleDriftEventsResponse, error) + // Acknowledge a drift event + AcknowledgeDriftEvent(ctx context.Context, in *AcknowledgeDriftEventRequest, opts ...grpc.CallOption) (*AcknowledgeDriftEventResponse, error) +} + +type driftServiceClient struct { + cc grpc.ClientConnInterface +} + +func NewDriftServiceClient(cc grpc.ClientConnInterface) DriftServiceClient { + return &driftServiceClient{cc} +} + +func (c *driftServiceClient) ListDriftEvents(ctx context.Context, in *ListDriftEventsRequest, opts ...grpc.CallOption) (*ListDriftEventsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListDriftEventsResponse) + err := c.cc.Invoke(ctx, DriftService_ListDriftEvents_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *driftServiceClient) GetModuleDriftEvents(ctx context.Context, in *GetModuleDriftEventsRequest, opts ...grpc.CallOption) (*GetModuleDriftEventsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(GetModuleDriftEventsResponse) + err := c.cc.Invoke(ctx, DriftService_GetModuleDriftEvents_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *driftServiceClient) AcknowledgeDriftEvent(ctx context.Context, in *AcknowledgeDriftEventRequest, opts ...grpc.CallOption) (*AcknowledgeDriftEventResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(AcknowledgeDriftEventResponse) + err := c.cc.Invoke(ctx, DriftService_AcknowledgeDriftEvent_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +// DriftServiceServer is the server API for DriftService service. +// All implementations must embed UnimplementedDriftServiceServer +// for forward compatibility. +// +// DriftService provides access to drift detection events +type DriftServiceServer interface { + // List all unacknowledged drift events + ListDriftEvents(context.Context, *ListDriftEventsRequest) (*ListDriftEventsResponse, error) + // Get drift events for a specific module + GetModuleDriftEvents(context.Context, *GetModuleDriftEventsRequest) (*GetModuleDriftEventsResponse, error) + // Acknowledge a drift event + AcknowledgeDriftEvent(context.Context, *AcknowledgeDriftEventRequest) (*AcknowledgeDriftEventResponse, error) + mustEmbedUnimplementedDriftServiceServer() +} + +// UnimplementedDriftServiceServer 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 UnimplementedDriftServiceServer struct{} + +func (UnimplementedDriftServiceServer) ListDriftEvents(context.Context, *ListDriftEventsRequest) (*ListDriftEventsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListDriftEvents not implemented") +} +func (UnimplementedDriftServiceServer) GetModuleDriftEvents(context.Context, *GetModuleDriftEventsRequest) (*GetModuleDriftEventsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method GetModuleDriftEvents not implemented") +} +func (UnimplementedDriftServiceServer) AcknowledgeDriftEvent(context.Context, *AcknowledgeDriftEventRequest) (*AcknowledgeDriftEventResponse, error) { + return nil, status.Error(codes.Unimplemented, "method AcknowledgeDriftEvent not implemented") +} +func (UnimplementedDriftServiceServer) mustEmbedUnimplementedDriftServiceServer() {} +func (UnimplementedDriftServiceServer) testEmbeddedByValue() {} + +// UnsafeDriftServiceServer may be embedded to opt out of forward compatibility for this service. +// Use of this interface is not recommended, as added methods to DriftServiceServer will +// result in compilation errors. +type UnsafeDriftServiceServer interface { + mustEmbedUnimplementedDriftServiceServer() +} + +func RegisterDriftServiceServer(s grpc.ServiceRegistrar, srv DriftServiceServer) { + // If the following call panics, it indicates UnimplementedDriftServiceServer 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(&DriftService_ServiceDesc, srv) +} + +func _DriftService_ListDriftEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListDriftEventsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DriftServiceServer).ListDriftEvents(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: DriftService_ListDriftEvents_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DriftServiceServer).ListDriftEvents(ctx, req.(*ListDriftEventsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DriftService_GetModuleDriftEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetModuleDriftEventsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DriftServiceServer).GetModuleDriftEvents(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: DriftService_GetModuleDriftEvents_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DriftServiceServer).GetModuleDriftEvents(ctx, req.(*GetModuleDriftEventsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _DriftService_AcknowledgeDriftEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(AcknowledgeDriftEventRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(DriftServiceServer).AcknowledgeDriftEvent(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: DriftService_AcknowledgeDriftEvent_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(DriftServiceServer).AcknowledgeDriftEvent(ctx, req.(*AcknowledgeDriftEventRequest)) + } + return interceptor(ctx, in, info, handler) +} + +// DriftService_ServiceDesc is the grpc.ServiceDesc for DriftService service. +// It's only intended for direct use with grpc.RegisterService, +// and not to be introspected or modified (even as a copy) +var DriftService_ServiceDesc = grpc.ServiceDesc{ + ServiceName: "pbufregistry.v1.DriftService", + HandlerType: (*DriftServiceServer)(nil), + Methods: []grpc.MethodDesc{ + { + MethodName: "ListDriftEvents", + Handler: _DriftService_ListDriftEvents_Handler, + }, + { + MethodName: "GetModuleDriftEvents", + Handler: _DriftService_GetModuleDriftEvents_Handler, + }, + { + MethodName: "AcknowledgeDriftEvent", + Handler: _DriftService_AcknowledgeDriftEvent_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "pbuf-registry/v1/drift.proto", +} diff --git a/pbuf.yaml b/pbuf.yaml index 2915123..0c2bc1e 100644 --- a/pbuf.yaml +++ b/pbuf.yaml @@ -5,7 +5,7 @@ registry: modules: - name: pbufio/pbuf-registry path: api/pbuf-registry - tag: v0.5.0 + tag: v0.6.1 out: third_party/pbuf-registry gen_out: gen/pbuf-registry - name: googleapis diff --git a/third_party/google/api/cloudquotas/v1/resources.proto b/third_party/google/api/cloudquotas/v1/resources.proto index 9705035..d58a58b 100644 --- a/third_party/google/api/cloudquotas/v1/resources.proto +++ b/third_party/google/api/cloudquotas/v1/resources.proto @@ -74,7 +74,7 @@ message QuotaInfo { // `projects/123/locations/global/services/compute.googleapis.com/quotaInfos/CpusPerProjectPerRegion` string name = 1; - // The id of the quota, which is unquie within the service. + // The id of the quota, which is unique within the service. // Example: `CpusPerProjectPerRegion` string quota_id = 2; diff --git a/third_party/google/api/cloudquotas/v1beta/quota_adjuster_settings.proto b/third_party/google/api/cloudquotas/v1beta/quota_adjuster_settings.proto index 15b0f29..8f8d3eb 100644 --- a/third_party/google/api/cloudquotas/v1beta/quota_adjuster_settings.proto +++ b/third_party/google/api/cloudquotas/v1beta/quota_adjuster_settings.proto @@ -42,7 +42,7 @@ service QuotaAdjusterSettingsManager { option (google.api.oauth_scopes) = "https://www.googleapis.com/auth/cloud-platform"; - // RPC Method for updating QuotaAdjusterSettings based on the request + // Updates the QuotaAdjusterSettings for the specified resource. rpc UpdateQuotaAdjusterSettings(UpdateQuotaAdjusterSettingsRequest) returns (QuotaAdjusterSettings) { option (google.api.http) = { @@ -61,7 +61,7 @@ service QuotaAdjusterSettingsManager { "quota_adjuster_settings,update_mask"; } - // RPC Method for getting QuotaAdjusterSettings based on the request + // Gets the QuotaAdjusterSettings for the specified resource. rpc GetQuotaAdjusterSettings(GetQuotaAdjusterSettingsRequest) returns (QuotaAdjusterSettings) { option (google.api.http) = { @@ -130,9 +130,13 @@ message QuotaAdjusterSettings { DISABLED = 3; } - // Identifier. Name of the config would be of the format: + // Identifier. Name of the configuration, in the formats below: + // + // * For a project: // projects/PROJECT_NUMBER/locations/global/quotaAdjusterSettings + // * For a folder: // folders/FOLDER_NUMBER/locations/global/quotaAdjusterSettings + // * For an organization: // organizations/ORGANIZATION_NUMBER/locations/global/quotaAdjusterSettings string name = 1 [(google.api.field_behavior) = IDENTIFIER]; diff --git a/third_party/google/api/cloudquotas/v1beta/resources.proto b/third_party/google/api/cloudquotas/v1beta/resources.proto index 35db459..e9380bd 100644 --- a/third_party/google/api/cloudquotas/v1beta/resources.proto +++ b/third_party/google/api/cloudquotas/v1beta/resources.proto @@ -74,7 +74,7 @@ message QuotaInfo { // `projects/123/locations/global/services/compute.googleapis.com/quotaInfos/CpusPerProjectPerRegion` string name = 1; - // The id of the quota, which is unquie within the service. + // The id of the quota, which is unique within the service. // For example, `CpusPerProjectPerRegion` string quota_id = 2; diff --git a/third_party/pbuf-registry/v1/drift.proto b/third_party/pbuf-registry/v1/drift.proto new file mode 100644 index 0000000..52bdf02 --- /dev/null +++ b/third_party/pbuf-registry/v1/drift.proto @@ -0,0 +1,131 @@ +syntax = "proto3"; + +package pbufregistry.v1; + +import "google/api/annotations.proto"; +import "google/protobuf/timestamp.proto"; + +option go_package = "github.com/pbufio/pbuf-cli/gen/pbuf-registry/v1;v1"; + +// DriftService provides access to drift detection events +service DriftService { + // List all unacknowledged drift events + rpc ListDriftEvents(ListDriftEventsRequest) returns (ListDriftEventsResponse) { + option (google.api.http) = { + get: "/v1/drift/events" + }; + } + + // Get drift events for a specific module + rpc GetModuleDriftEvents(GetModuleDriftEventsRequest) returns (GetModuleDriftEventsResponse) { + option (google.api.http) = { + post: "/v1/drift/modules/events" + body: "*" + }; + } + + // Acknowledge a drift event + rpc AcknowledgeDriftEvent(AcknowledgeDriftEventRequest) returns (AcknowledgeDriftEventResponse) { + option (google.api.http) = { + post: "/v1/drift/events/{event_id}/acknowledge" + body: "*" + }; + } +} + +// DriftEventType represents the type of drift event +enum DriftEventType { + DRIFT_EVENT_TYPE_UNSPECIFIED = 0; + DRIFT_EVENT_TYPE_ADDED = 1; + DRIFT_EVENT_TYPE_MODIFIED = 2; + DRIFT_EVENT_TYPE_DELETED = 3; +} + +// DriftSeverity represents the severity level of a drift event +enum DriftSeverity { + DRIFT_SEVERITY_UNSPECIFIED = 0; + DRIFT_SEVERITY_INFO = 1; + DRIFT_SEVERITY_WARNING = 2; + DRIFT_SEVERITY_CRITICAL = 3; +} + +// DriftEvent represents a detected change in a proto file +message DriftEvent { + // The unique identifier of the drift event + string id = 1; + + // The module name where the drift was detected + string module_name = 2; + + // The tag name where the drift was detected + string tag_name = 3; + + // The filename of the proto file that changed + string filename = 4; + + // The type of drift event + DriftEventType event_type = 5; + + // The previous content hash (empty for added files) + string previous_hash = 6; + + // The current content hash (empty for deleted files) + string current_hash = 7; + + // The severity of the drift event + DriftSeverity severity = 8; + + // When the drift was detected + google.protobuf.Timestamp detected_at = 9; + + // Whether the event has been acknowledged + bool acknowledged = 10; + + // When the event was acknowledged + google.protobuf.Timestamp acknowledged_at = 11; + + // Who acknowledged the event + string acknowledged_by = 12; +} + +// ListDriftEventsRequest is the request message for ListDriftEvents +message ListDriftEventsRequest { + // Optional: only return unacknowledged events (default: true) + bool unacknowledged_only = 1; +} + +// ListDriftEventsResponse is the response message for ListDriftEvents +message ListDriftEventsResponse { + // The list of drift events + repeated DriftEvent events = 1; +} + +// GetModuleDriftEventsRequest is the request message for GetModuleDriftEvents +message GetModuleDriftEventsRequest { + // The module name to get drift events for + string module_name = 1; + + // Optional: filter drift events by tag name + optional string tag_name = 2; +} + +// GetModuleDriftEventsResponse is the response message for GetModuleDriftEvents +message GetModuleDriftEventsResponse { + // The list of drift events for the module + repeated DriftEvent events = 1; +} + +// AcknowledgeDriftEventRequest is the request message for AcknowledgeDriftEvent +message AcknowledgeDriftEventRequest { + // The ID of the drift event to acknowledge + string event_id = 1; + + // Who is acknowledging the event + string acknowledged_by = 2; +} + +// AcknowledgeDriftEventResponse is the response message for AcknowledgeDriftEvent +message AcknowledgeDriftEventResponse { + // The acknowledged drift event + DriftEvent event = 1; +}